SDK et MCP

FloopFloop SDKs & MCP

FloopFloop propose huit SDK officiels dans différents langagesainsi qu'un serveur MCP pour les agents IA. Toutes les interfaces ciblent le même backend /api/v1/*— ainsi, un projet créé via le SDK Node est exactement le même projet qu'un LLM utilisant le MCP verra, octet pour octet.

Choisissez la bonne interface pour votre stack :

• Vous développez une application ou un backend ? Utilisez le SDK pour votre langage.
• Vous développez un agent IA / chatbot ? Utilisez le serveur @floopfloop/mcp avec Claude Desktop, Cursor, Zed, Copilot CLI, ou tout hôte compatible MCP.
• Vous travaillez depuis le terminal ? Utilisez le CLI FloopFloop.

Serveur MCP — pour les agents IA

@floopfloop/mcp— serveur Model Context Protocol. Expose l'API FloopFloop sous forme de 23 outils que tout hôte LLM compatible MCP peut appeler.

Les outils couvrent l'ensemble du cycle de vie du projet : create_project, refine_project, upload_from_path(pièces jointes), cancel_project, reactivate_project, wait_for_live, list_secrets / set_secret / remove_secret, list_library_projects / clone_library_project, current_subscription, usage_summary, ainsi que la vérification des sous-domaines et la gestion des clés API. Chaque outil est en lecture seule ou marqué destructiveHintafin que l'hôte puisse inviter l'utilisateur avant de modifier l'état.

Extrait de configuration Claude Desktop

{
  "mcpServers": {
    "floopfloop": {
      "command": "npx",
      "args": ["-y", "@floopfloop/mcp"],
      "env": { "FLOOP_API_KEY": "flp_..." }
    }
  }
}

Ajoutez-le à ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) ou %APPDATA%\Claude\claude_desktop_config.json(Windows), redémarrez Claude Desktop et demandez “crée-moi un site FloopFloop pour <X>”.

Associez à floop-skills pour le guide pratique

Le MCP expose les capacités ; floop-skills propose des compétences markdown de style Anthropic qui expliquent les flux de travail — quel outil appeler, dans quel ordre et avec quels arguments. Installez les deux pour la meilleure expérience d'agent :

mkdir -p ~/.claude/skills
git clone https://github.com/FloopFloopAI/floop-skills.git /tmp/floop-skills
cp -r /tmp/floop-skills/skills/* ~/.claude/skills/

Liens : npm · GitHub · floop-skills

SDK par langage

Même interface pour les huit : client.projects.create(), refine, waitForLive / streaming, secrets, uploads, library, apiKeys, subscriptions.current, usage.summary, subdomains, user.me. Chaque SDK suit l'idiome natif de son langage (sync + async sur Python, Flow sur Kotlin, AsyncThrowingStreamsur Swift, etc.) mais le contrat wire — codes d'erreur, enveloppes de réponse, sémantique des états terminaux — est identique.

Node / TypeScript — @floopfloop/sdk

Node 20+. fetch natif, types TypeScript complets,AsyncIteratorpour le streaming. Le SDK de référence ; le serveur MCP l'encapsule directement.

npm install @floopfloop/sdk

import { FloopClient } from "@floopfloop/sdk";

const floop = new FloopClient({ apiKey: process.env.FLOOP_API_KEY! });
const { project } = await floop.projects.create({
  prompt: "a cat-cafe blog with three sample posts",
});
const live = await floop.projects.waitForLive(project.id);
console.log(live.url);

Liens : npm · GitHub · cookbook

Python — floopfloop

Python 3.10+. FloopClient synchrone sur httpx.Client et AsyncFloopClient asynchrone sur httpx.AsyncClient — mêmes neuf accesseurs de ressources, async for sur projects.stream.

pip install floopfloop

from floopfloop import FloopClient

floop = FloopClient(api_key=os.environ["FLOOP_API_KEY"])
created = floop.projects.create(prompt="a cat cafe landing page")
live = floop.projects.wait_for_live(created["project"]["id"])
print(live["url"])

Liens : PyPI · GitHub · cookbook

Go — github.com/FloopFloopAI/floop-go-sdk

Go 1.22+. Premier argument idiomatique context.Context, *Error avec champ de code typé, streaming compatible avec les channels.

go get github.com/FloopFloopAI/floop-go-sdk@latest

client := floop.NewClient(os.Getenv("FLOOP_API_KEY"))
res, err := client.Projects.Create(ctx, floop.CreateProjectInput{
    Prompt: "a cat cafe landing page",
})
if err != nil { log.Fatal(err) }
live, err := client.Projects.WaitForLive(ctx, res.Project.ID, nil)
fmt.Println(live.URL)

Liens : pkg.go.dev · GitHub · cookbook

Rust — floopfloop

Rust 2021 / 1.75+. Async basé sur tokio, pattern builder sur le client, enum FloopErrorCode typée, Result<T, FloopError> sur chaque méthode.

# Cargo.toml
floopfloop = "0.1.0-alpha.4"

use floopfloop::{Client, CreateProjectInput};

let client = Client::new(std::env::var("FLOOP_API_KEY")?)?;
let res = client.projects().create(CreateProjectInput {
    prompt: "a cat cafe landing page".into(),
    ..Default::default()
}).await?;
let live = client.projects().wait_for_live(&res.project.id, None).await?;
println!("{}", live.url.unwrap_or_default());

Liens : crates.io · docs.rs · GitHub · cookbook

Ruby — floopfloop

Ruby 3.0+. Transport Net::HTTP, réponses basées sur des hachages (pas de wrappers typés dogmatiques), passage de blocs pour le streaming.

gem install floopfloop

require "floopfloop"

client = FloopFloop::Client.new(api_key: ENV.fetch("FLOOP_API_KEY"))
res = client.projects.create(prompt: "a cat cafe landing page")
live = client.projects.wait_for_live(res["project"]["id"])
puts live["url"]

Liens : RubyGems · GitHub · cookbook

PHP — floopfloop/sdk

PHP 8.1+. Transport stdlib pur (pas besoin de ext-curl), constructeur compatible avec les arguments nommés, classe d'exception FloopFloop\Error avec code typé.

composer require floopfloop/sdk

$client = new FloopFloop\Client(apiKey: getenv('FLOOP_API_KEY'));
$res = $client->projects()->create(prompt: 'a cat cafe landing page');
$live = $client->projects()->waitForLive($res['project']['id']);
echo $live['url'];

Liens : Packagist · GitHub · cookbook

Swift — FloopFloop (SPM)

Swift 5.9+. async/await partout, types Codable, AsyncThrowingStreampour le streaming. iOS 17+ / macOS 14+ / tvOS 17+ / watchOS 10+ / visionOS 1+. Côté serveur / bureau aujourd'hui ; la distribution d'applications mobiles nécessite un flux d'authentification différent côté backend (feuille de route).

// Package.swift
.package(url: "https://github.com/FloopFloopAI/floop-swift-sdk.git", from: "0.1.0-alpha.2")

import FloopFloop

let client = FloopFloop(apiKey: ProcessInfo.processInfo.environment["FLOOP_API_KEY"]!)
let res = try await client.projects.create(.init(prompt: "a cat cafe landing page"))
let live = try await client.projects.waitForLive(res.project.id)
print(live.url ?? "")

Liens : tags SPM · GitHub · cookbook

Kotlin / JVM — floop-kotlin-sdk

Kotlin 2.0+ / JVM 11+. OkHttp + kotlinx-serialization + kotlinx-coroutines. Fonctions suspend partout ; streaming via Flow<StatusEvent> froid. Distribution JitPack (Maven Central prévu).

// build.gradle.kts
repositories {
    maven("https://jitpack.io")
}
dependencies {
    implementation("com.github.FloopFloopAI:floop-kotlin-sdk:0.1.0-alpha.3")
}

import com.floopfloop.sdk.FloopFloop
import com.floopfloop.sdk.resources.CreateProjectInput

val client = FloopFloop(apiKey = System.getenv("FLOOP_API_KEY"))
val res = client.projects.create(CreateProjectInput(prompt = "a cat cafe landing page"))
val live = client.projects.waitForLive(res.project.id)
println(live.url)

Liens : JitPack · GitHub · cookbook

Clés API

Chaque SDK utilise des clés API programmatiques flp_…pour l'authentification, distinctes des jetons d'appareil que le CLI utilise pour les connexions interactives. L'émission de clés API nécessite le plan Business. Créez une clé depuis Compte → Clés API, stockez-la dans votre gestionnaire de secrets / environnement et transmettez-la au constructeur du SDK.

Consultez Authentification API pour le modèle complet de clés (portées, limites de débit, schéma de rotation).

Sources & versions

Les huit dépôts SDK ainsi que le MCP et les skills sont open source sous licence MIT sur github.com/FloopFloopAI. Chaque version est publiée dans le registre standard de son langage lors d'un push de tag (npm, PyPI, crates.io, RubyGems, Packagist, modules Go, JitPack, tags SPM). Les CHANGELOG par SDK se trouvent dans chaque dépôt ; la coordination des versions cross-SDK est suivie dans le monorepo.