SDK i MCP

FloopFloop SDKs & MCP

FloopFloop dostarcza osiem oficjalnych SDK dla różnych języków oraz serwer MCP dla agentów AI. Każda powierzchnia korzysta z tego samego backendu /api/v1/*— projekt utworzony przez SDK dla Node jest tym samym projektem, który zobaczy model LLM działający przez MCP, bajt po bajcie.

Wybierz odpowiednią powierzchnię dla swojego stosu:

• Budujesz aplikację lub backend? Użyj SDK dla swojego języka.
• Budujesz agenta AI / chatbota? Użyj serwera @floopfloop/mcp z Claude Desktop, Cursor, Zed, Copilot CLI lub dowolnym hostem obsługującym MCP.
• Sterowanie z terminalu? Użyj FloopFloop CLI.

Serwer MCP — dla agentów AI

@floopfloop/mcp— serwer Model Context Protocol. Udostępnia API FloopFloop jako 23 narzędzia, które może wywoływać dowolny host LLM obsługujący MCP.

Narzędzia obejmują pełny cykl życia projektu: create_project, refine_project, upload_from_path(załączniki), cancel_project, reactivate_project, wait_for_live, list_secrets / set_secret / remove_secret, list_library_projects / clone_library_project, current_subscription, usage_summary, a także sprawdzanie subdomen i zarządzanie kluczami API. Każde narzędzie jest tylko do odczytu lub oznaczone destructiveHint, aby host mógł poprosić użytkownika o potwierdzenie przed zmianą stanu.

Fragment konfiguracji dla Claude Desktop

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

Dodaj do pliku ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) lub %APPDATA%\Claude\claude_desktop_config.json (Windows), uruchom ponownie Claude Desktop i wpisz “zbuduj mi stronę FloopFloop dla <X>”.

Połącz z floop-skills dla gotowych przepływów

MCP udostępnia możliwości; floop-skills dostarcza gotowe umiejętności w stylu Anthropic, które opisują przepływy pracy — kiedy wywoływać które narzędzie, w jakiej kolejności i z jakimi argumentami. Zainstaluj oba, aby uzyskać najlepsze doświadczenie agenta:

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

Linki: npm · GitHub · floop-skills

SDK dla języków programowania

Ta sama powierzchnia we wszystkich ośmiu: client.projects.create(), refine, waitForLive / strumieniowanie, secrets, uploads, library, apiKeys, subscriptions.current, usage.summary, subdomains, user.me. Każdy SDK stosuje natywne idiomy swojego języka (sync + async w Pythonie, Flow w Kotlinie, AsyncThrowingStreamw Swifcie itd.), ale kontrakt sieciowy — kody błędów, koperty odpowiedzi, semantyka stanów końcowych — jest identyczny.

Node / TypeScript — @floopfloop/sdk

Node 20+. Natywny fetch, pełne typy TypeScript,AsyncIterator do strumieniowania. Kanonicze SDK; serwer MCP bezpośrednio je opakowuje.

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

Linki: npm · GitHub · cookbook

Python — floopfloop

Python 3.10+. Synchroniczny FloopClient na bazie httpx.Client oraz asynchroniczny AsyncFloopClient na bazie httpx.AsyncClient— te same dziewięć akcesorów zasobów, async for na 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"])

Linki: PyPI · GitHub · cookbook

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

Go 1.22+. Idiomatyczny context.Context jako pierwszy argument, *Error z typizowanym polem kodu, strumieniowanie przyjazne dla kanałów.

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)

Linki: pkg.go.dev · GitHub · cookbook

Rust — floopfloop

Rust 2021 / 1.75+. Asynchroniczność oparta na tokio, wzorzec budowniczego na kliencie, typizowane wyliczenie FloopErrorCode, Result<T, FloopError> na każdej metodzie.

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

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

Ruby — floopfloop

Ruby 3.0+. Transport Net::HTTP, odpowiedzi oparte na hashu (bez narzuconych typowanych wrapperów), przekazywanie bloków do strumieniowania.

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"]

Linki: RubyGems · GitHub · cookbook

PHP — floopfloop/sdk

PHP 8.1+. Czysty transport stdlib (bez potrzeby ext-curl), konstruktor przyjazny nazwanym argumentom, klasa wyjątku FloopFloop\Error z typizowanym kodem.

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

Linki: Packagist · GitHub · cookbook

Swift — FloopFloop (SPM)

Swift 5.9+. async/await wszędzie, typy Codable, AsyncThrowingStream do strumieniowania. iOS 17+ / macOS 14+ / tvOS 17+ / watchOS 10+ / visionOS 1+. Dziś po stronie serwera/desktopowej; dystrybucja aplikacji mobilnych wymaga innego przepływu auth po stronie backendu (w planach).

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

Linki: tagi SPM · GitHub · cookbook

Kotlin / JVM — floop-kotlin-sdk

Kotlin 2.0+ / JVM 11+. OkHttp + kotlinx-serialization + kotlinx-coroutines. Funkcje suspend wszędzie; strumieniowanie przez zimny Flow<StatusEvent>. Dystrybucja przez JitPack (Maven Central w planach).

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

Linki: JitPack · GitHub · cookbook

Klucze API

Każdy SDK używa programowych kluczy API flp_… do uwierzytelniania, odrębnych od tokenów urządzeń, których CLI używa do logowania interaktywnego. Wystawianie kluczy API wymaga planu Business. Utwórz klucz w Konto → Klucze API, przechowuj go w menedżerze sekretów lub zmiennych środowiskowych i przekaż do konstruktora SDK.

Zobacz Uwierzytelnianie API dla pełnego modelu kluczy (zakresy, limity szybkości, wzorzec rotacji).

Źródła & wydania

Wszystkie osiem repozytoriów SDK wraz z MCP i umiejętnościami jest open-source na licencji MIT pod adresem github.com/FloopFloopAI. Każde wydanie trafia do standardowego rejestru swojego języka przy wypchnięciu tagu (npm, PyPI, crates.io, RubyGems, Packagist, moduły Go, JitPack, tagi SPM). Pliki CHANGELOG per-SDK w każdym repozytorium; koordynacja wydań między SDK śledzona w monorepo.