SDKs and MCP

FloopFloop SDKs & MCP

FloopFloop ships eight official language SDKs plus an MCP server for AI agents. Every surface targets the same /api/v1/* backend — so a project created via the Node SDK is the same project an LLM running through the MCP will see, byte-for-byte.

Pick the right surface for your stack:

• Building an app or backend? Use the SDK for your language.
• Building an AI agent / chatbot? Use the @floopfloop/mcp server with Claude Desktop, Cursor, Zed, Copilot CLI, or any MCP-aware host.
• Driving from the terminal? Use the FloopFloop CLI.

MCP server — for AI agents

@floopfloop/mcp— Model Context Protocol server. Wraps the FloopFloop API as 23 tools that any MCP-aware LLM host can call.

Tools cover the full project lifecycle: create_project, refine_project, upload_from_path(attachments), cancel_project, reactivate_project, wait_for_live, list_secrets / set_secret / remove_secret, list_library_projects / clone_library_project, current_subscription, usage_summary, plus subdomain checks and API-key management. Each tool is read-only or marked destructiveHint so the host can prompt the user before mutating state.

Claude Desktop config snippet

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

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json(Windows), restart Claude Desktop, and ask “build me a FloopFloop site for <X>”.

Pair with floop-skills for the playbook

The MCP exposes the capabilities; floop-skills ships drop-in Anthropic-style markdown skills that explain the workflows — when to call which tool, in what order, with which args. Install both for the best agent experience:

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

Language SDKs

Same surface across all eight: client.projects.create(), refine, waitForLive / streaming, secrets, uploads, library, apiKeys, subscriptions.current, usage.summary, subdomains, user.me. Each SDK ships per its language's native idiom (sync + async on Python, Flow on Kotlin, AsyncThrowingStream on Swift, etc.) but the wire contract — error codes, response envelopes, terminal-state semantics — is identical.

Node / TypeScript — @floopfloop/sdk

Node 20+. Native fetch, full TypeScript types,AsyncIterator for streaming. The canonical SDK; the MCP server wraps this one directly.

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+. Sync FloopClient on httpx.Client plus async AsyncFloopClient on httpx.AsyncClient — same nine resource accessors, async for on 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+. Idiomatic context.Context first arg, *Error with typed code field, channels-friendly 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-based async, builder pattern on the client, typed FloopErrorCode enum, Result<T, FloopError> on every method.

# 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-based responses (no opinionated typed wrappers), block-passing for 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+. Pure stdlib transport (no ext-curl needed), named-argument-friendly constructor, FloopFloop\Error exception class with typed 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 throughout, Codable types, AsyncThrowingStream for streaming. iOS 17+ / macOS 14+ / tvOS 17+ / watchOS 10+ / visionOS 1+. Server-side / desktop today; mobile-app distribution needs a different auth flow on the 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 functions throughout; streaming via cold Flow<StatusEvent>. JitPack distribution (Maven Central planned).

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

Every SDK uses programmatic flp_… API keys for authentication, distinct from the device tokens the CLI uses for interactive logins. API-key issuance requires the Business plan. Mint a key from Account → API Keys, store it in your secret manager / environment, and pass it to the SDK constructor.

See API Authentication for the full key model (scopes, rate limits, rotation pattern).

Source & releases

All eight SDK repos plus the MCP and skills are open-source under the MIT license at github.com/FloopFloopAI. Each release ships to its language's standard registry on tag push (npm, PyPI, crates.io, RubyGems, Packagist, Go modules, JitPack, SPM tags). Per-SDK CHANGELOGs in each repo; cross-SDK release coordination tracked in the monorepo.