SDKs und MCP

FloopFloop SDKs & MCP

FloopFloop liefert acht offizielle Sprach-SDKs sowie einen MCP-Server für KI-Agenten. Jede Oberfläche zielt auf dasselbe /api/v1/*-Backend ab — ein über das Node SDK erstelltes Projekt ist also dasselbe Projekt, das ein LLM über den MCP sehen wird, Byte für Byte.

Wählen Sie die richtige Oberfläche für Ihren Stack:

• Eine App oder ein Backend entwickeln? Verwenden Sie das SDK für Ihre Sprache.
• Einen KI-Agenten / Chatbot entwickeln? Verwenden Sie den @floopfloop/mcp-Server mit Claude Desktop, Cursor, Zed, Copilot CLI oder einem beliebigen MCP-fähigen Host.
• Über das Terminal steuern? Verwenden Sie die FloopFloop CLI.

MCP-Server — für KI-Agenten

@floopfloop/mcp— Model Context Protocol Server. Kapselt die FloopFloop-API als 23 Tools, die jeder MCP-fähige LLM-Host aufrufen kann.

Die Tools decken den vollständigen Projektlebenszyklus ab: create_project, refine_project, upload_from_path(Anhänge), cancel_project, reactivate_project, wait_for_live, list_secrets / set_secret / remove_secret, list_library_projects / clone_library_project, current_subscription, usage_summary, sowie Subdomain-Prüfungen und API-Schlüsselverwaltung. Jedes Tool ist schreibgeschützt oder mit destructiveHint gekennzeichnet, sodass der Host den Benutzer vor einer Zustandsänderung auffordern kann.

Claude Desktop-Konfigurationsausschnitt

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

Fügen Sie dies zu ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) oder %APPDATA%\Claude\claude_desktop_config.json(Windows) hinzu, starten Sie Claude Desktop neu und fragen Sie “Erstelle mir eine FloopFloop-Website für <X>”.

Mit floop-skills für das Playbook kombinieren

Der MCP stellt die Fähigkeiten bereit; floop-skills liefert einbindbare Anthropic-Stil-Markdown-Skills, die die Workflows — wann welches Tool in welcher Reihenfolge mit welchen Argumenten aufzurufen ist — erklären. Installieren Sie beides für die beste Agenten-Erfahrung:

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

Links: npm · GitHub · floop-skills

Sprach-SDKs

Dieselbe Oberfläche über alle acht: client.projects.create(), refine, waitForLive / Streaming, secrets, uploads, library, apiKeys, subscriptions.current, usage.summary, subdomains, user.me. Jedes SDK liefert die nativen Idiome der jeweiligen Sprache (sync + async in Python, Flow in Kotlin, AsyncThrowingStreamin Swift usw.), aber der Wire-Vertrag — Fehlercodes, Antwort-Envelopes, Terminal-State-Semantik — ist identisch.

Node / TypeScript — @floopfloop/sdk

Node 20+. Natives fetch, vollständige TypeScript-Typen,AsyncIterator für Streaming. Das kanonische SDK; der MCP-Server umschließt dieses direkt.

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);

Links: npm · GitHub · cookbook

Python — floopfloop

Python 3.10+. Synchrones FloopClient auf httpx.Client plus asynchrones AsyncFloopClient auf httpx.AsyncClient — dieselben neun Ressourcen-Accessors, async for auf 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"])

Links: PyPI · GitHub · cookbook

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

Go 1.22+. Idiomatisches context.Context als erstes Argument, *Error mit typisiertem Code-Feld, Channel-freundliches Streaming.

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)

Links: pkg.go.dev · GitHub · cookbook

Rust — floopfloop

Rust 2021 / 1.75+. tokio-basiertes Async, Builder-Muster für den Client, typisiertes FloopErrorCode-Enum, Result<T, FloopError> bei jeder Methode.

# 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());

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

Ruby — floopfloop

Ruby 3.0+. Net::HTTP-Transport, Hash-basierte Antworten (keine meinungsstarken typisierten Wrapper), Block-Übergabe für 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"]

Links: RubyGems · GitHub · cookbook

PHP — floopfloop/sdk

PHP 8.1+. Reiner stdlib-Transport (kein ext-curl erforderlich), Named-Argument-freundlicher Konstruktor, FloopFloop\Error Exception-Klasse mit typisiertem Code.

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'];

Links: Packagist · GitHub · cookbook

Swift — FloopFloop (SPM)

Swift 5.9+. async/await durchgehend, Codable-Typen, AsyncThrowingStream für Streaming. iOS 17+ / macOS 14+ / tvOS 17+ / watchOS 10+ / visionOS 1+. Server-seitig / Desktop heute; Mobile-App-Distribution erfordert einen anderen Auth-Flow im Backend (Roadmap).

// 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 ?? "")

Links: SPM tags · GitHub · cookbook

Kotlin / JVM — floop-kotlin-sdk

Kotlin 2.0+ / JVM 11+. OkHttp + kotlinx-serialization + kotlinx-coroutines. suspend-Funktionen durchgehend; Streaming über kalte Flow<StatusEvent>. JitPack- Distribution (Maven Central geplant).

// 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)

Links: JitPack · GitHub · cookbook

API-Schlüssel

Jedes SDK verwendet programmatische flp_…-API-Schlüssel zur Authentifizierung, die sich von den Gerätetoken unterscheiden, die die CLI für interaktive Anmeldungen verwendet. Die Ausstellung von API-Schlüsseln erfordert den Business-Plan. Erstellen Sie einen Schlüssel unter Konto → API-Schlüssel, speichern Sie ihn in Ihrem Secret-Manager / Ihrer Umgebung und übergeben Sie ihn dem SDK-Konstruktor.

Siehe API-Authentifizierung für das vollständige Schlüsselmodell (Scopes, Rate-Limits, Rotationsmuster).

Quellcode & Releases

Alle acht SDK-Repos sowie der MCP und die Skills sind Open-Source unter der MIT-Lizenz auf github.com/FloopFloopAI. Jedes Release wird bei einem Tag-Push in die Standardregistry der jeweiligen Sprache veröffentlicht (npm, PyPI, crates.io, RubyGems, Packagist, Go modules, JitPack, SPM tags). SDK-spezifische CHANGELOGs befinden sich in jedem Repo; die übergreifende Release-Koordination wird im Monorepo verfolgt.