SDKs y MCP

FloopFloop SDKs & MCP

FloopFloop incluye ocho SDKs de lenguajes oficiales más un servidor MCP para agentes de IA. Cada superficie apunta al mismo backend /api/v1/*— así que un proyecto creado mediante el SDK de Node es el mismo proyecto que un LLM que use el MCP verá, byte a byte.

Elige la superficie adecuada para tu stack:

• ¿Construyendo una aplicación o backend? Usa el SDK de tu lenguaje.
• ¿Construyendo un agente de IA / chatbot? Usa el servidor @floopfloop/mcp con Claude Desktop, Cursor, Zed, Copilot CLI o cualquier host compatible con MCP.
• ¿Trabajando desde la terminal? Usa el FloopFloop CLI.

Servidor MCP — para agentes de IA

@floopfloop/mcp— servidor de Model Context Protocol. Envuelve la API de FloopFloop como 23 herramientas que cualquier host LLM compatible con MCP puede llamar.

Las herramientas cubren el ciclo de vida completo del proyecto: create_project, refine_project, upload_from_path(archivos adjuntos), cancel_project, reactivate_project, wait_for_live, list_secrets / set_secret / remove_secret, list_library_projects / clone_library_project, current_subscription, usage_summary, además de comprobaciones de subdominio y gestión de claves de API. Cada herramienta es de solo lectura o está marcada como destructiveHint para que el host pueda solicitar confirmación al usuario antes de modificar el estado.

Fragmento de configuración para Claude Desktop

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

Añade esto a ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) o %APPDATA%\Claude\claude_desktop_config.json(Windows), reinicia Claude Desktop y pregunta “build me a FloopFloop site for <X>”.

Combínalo con floop-skills para el manual de uso

El MCP expone las capacidades; floop-skills incluye skills de markdown al estilo Anthropic que explican los flujos de trabajo — cuándo llamar a cada herramienta, en qué orden y con qué argumentos. Instala ambos para la mejor experiencia con agentes:

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

Enlaces: npm · GitHub · floop-skills

SDKs de lenguajes

La misma superficie en los ocho: client.projects.create(), refine, waitForLive / streaming, secrets, uploads, library, apiKeys, subscriptions.current, usage.summary, subdomains, user.me. Cada SDK sigue el estilo nativo de su lenguaje (sync + async en Python, Flow en Kotlin, AsyncThrowingStreamen Swift, etc.) pero el contrato de red — códigos de error, envoltorios de respuesta, semántica de estados terminales — es idéntico.

Node / TypeScript — @floopfloop/sdk

Node 20+. fetch nativo, tipos TypeScript completos,AsyncIterator para streaming. El SDK canónico; el servidor MCP envuelve este directamente.

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

Enlaces: npm · GitHub · cookbook

Python — floopfloop

Python 3.10+. FloopClient síncrono sobre httpx.Client más AsyncFloopClient asíncrono sobre httpx.AsyncClient — los mismos nueve accesores de recursos, async for en 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"])

Enlaces: PyPI · GitHub · cookbook

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

Go 1.22+. Primer argumento idiomático context.Context, *Error con campo de código tipado, streaming compatible con canales.

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)

Enlaces: pkg.go.dev · GitHub · cookbook

Rust — floopfloop

Rust 2021 / 1.75+. Async basado en tokio, patrón builder en el cliente, enum tipado FloopErrorCode, Result<T, FloopError> en cada método.

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

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

Ruby — floopfloop

Ruby 3.0+. Transporte Net::HTTP, respuestas basadas en hashes (sin wrappers tipados dogmáticos), paso de bloques para 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"]

Enlaces: RubyGems · GitHub · cookbook

PHP — floopfloop/sdk

PHP 8.1+. Transporte de stdlib puro (no se necesita ext-curl), constructor compatible con argumentos nombrados, clase de excepción FloopFloop\Error con código tipado.

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

Enlaces: Packagist · GitHub · cookbook

Swift — FloopFloop (SPM)

Swift 5.9+. async/await en todo momento, tipos Codable, AsyncThrowingStream para streaming. iOS 17+ / macOS 14+ / tvOS 17+ / watchOS 10+ / visionOS 1+. Lado del servidor / escritorio hoy; la distribución en apps móviles requiere un flujo de autenticación diferente en el 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 ?? "")

Enlaces: SPM tags · GitHub · cookbook

Kotlin / JVM — floop-kotlin-sdk

Kotlin 2.0+ / JVM 11+. OkHttp + kotlinx-serialization + kotlinx-coroutines. Funciones suspend en todas partes; streaming mediante Flow<StatusEvent> frío. Distribución mediante JitPack (Maven Central planificado).

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

Enlaces: JitPack · GitHub · cookbook

Claves de API

Todos los SDKs usan claves de API programáticas flp_… para la autenticación, distintas de los tokens de dispositivo que el CLI usa para los inicios de sesión interactivos. La emisión de claves de API requiere el plan Business. Genera una clave desde Cuenta → Claves de API, guárdala en tu gestor de secretos / entorno y pásala al constructor del SDK.

Consulta Autenticación de API para conocer el modelo completo de claves (scopes, límites de tasa, patrón de rotación).

Código fuente & versiones

Los ocho repositorios de SDK más el MCP y las skills son de código abierto bajo la licencia MIT en github.com/FloopFloopAI. Cada versión se publica en el registro estándar de su lenguaje al hacer push de una etiqueta (npm, PyPI, crates.io, RubyGems, Packagist, módulos de Go, JitPack, SPM tags). Los CHANGELOGs por SDK están en cada repositorio; la coordinación de versiones entre SDKs se gestiona en el monorepo.