SDKs e MCP

FloopFloop SDKs & MCP

O FloopFloop disponibiliza oito SDKs oficiais para diferentes linguagens mais um servidor MCP para agentes de IA. Todas as interfaces visam o mesmo backend /api/v1/*— por isso, um projeto criado via o Node SDK é o mesmo projeto que um LLM a correr pelo MCP verá, byte a byte.

Escolhe a interface certa para a tua stack:

• A construir uma app ou backend? Usa o SDK para a tua linguagem.
• A construir um agente de IA / chatbot? Usa o servidor @floopfloop/mcp com Claude Desktop, Cursor, Zed, Copilot CLI, ou qualquer host com suporte a MCP.
• A controlar a partir do terminal? Usa o FloopFloop CLI.

Servidor MCP — para agentes de IA

@floopfloop/mcp— servidor Model Context Protocol. Expõe a API FloopFloop como 23 ferramentas que qualquer host LLM com suporte a MCP pode invocar.

As ferramentas cobrem o ciclo de vida completo do projeto: create_project, refine_project, upload_from_path(anexos), cancel_project, reactivate_project, wait_for_live, list_secrets / set_secret / remove_secret, list_library_projects / clone_library_project, current_subscription, usage_summary, mais verificações de subdomínio e gestão de chaves de API. Cada ferramenta é só de leitura ou marcada com destructiveHint para que o host possa pedir confirmação ao utilizador antes de alterar o estado.

Fragmento de configuração do Claude Desktop

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

Adiciona em ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) ou %APPDATA%\Claude\claude_desktop_config.json(Windows), reinicia o Claude Desktop e pede “cria-me um site FloopFloop para <X>”.

Combina com floop-skills para o playbook

O MCP expõe as capacidades; floop-skills disponibiliza skills markdown no estilo Anthropic que explicam os fluxos de trabalho — quando chamar qual ferramenta, em que ordem, com que argumentos. Instala ambos para a melhor experiência com 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/

Ligações: npm · GitHub · floop-skills

SDKs por linguagem

Mesma interface em todos os oito: client.projects.create(), refine, waitForLive / streaming, secrets, uploads, library, apiKeys, subscriptions.current, usage.summary, subdomains, user.me. Cada SDK segue o idioma nativo da sua linguagem (sync + async em Python, Flow em Kotlin, AsyncThrowingStreamem Swift, etc.) mas o contrato de rede — códigos de erro, envelopes de resposta, semântica de estado terminal — é idêntico.

Node / TypeScript — @floopfloop/sdk

Node 20+. fetch nativo, tipos TypeScript completos,AsyncIterator para streaming. O SDK canónico; o servidor MCP envolve este diretamente.

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

Ligações: npm · GitHub · cookbook

Python — floopfloop

Python 3.10+. FloopClient síncrono sobre httpx.Client mais AsyncFloopClient assíncrono sobre httpx.AsyncClient — os mesmos nove acessores de recursos, async for em 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"])

Ligações: PyPI · GitHub · cookbook

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

Go 1.22+. context.Context idiomático como primeiro argumento, *Error com campo de código tipado, streaming compatível com canais.

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)

Ligações: pkg.go.dev · GitHub · cookbook

Rust — floopfloop

Rust 2021 / 1.75+. Assíncrono baseado em tokio, padrão builder no cliente, enum FloopErrorCode tipado, Result<T, FloopError> em todos os métodos.

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

Ligações: crates.io · docs.rs · GitHub · cookbook

Ruby — floopfloop

Ruby 3.0+. Transporte Net::HTTP, respostas baseadas em hash (sem wrappers tipados opinionados), passagem de blocos 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"]

Ligações: RubyGems · GitHub · cookbook

PHP — floopfloop/sdk

PHP 8.1+. Transporte stdlib puro (sem necessidade de ext-curl), construtor compatível com argumentos nomeados, classe de exceção FloopFloop\Error com 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'];

Ligações: Packagist · GitHub · cookbook

Swift — FloopFloop (SPM)

Swift 5.9+. async/await em todo o lado, tipos Codable, AsyncThrowingStream para streaming. iOS 17+ / macOS 14+ / tvOS 17+ / watchOS 10+ / visionOS 1+. Lado do servidor / desktop atualmente; a distribuição para apps móveis necessita de um fluxo de autenticação diferente no 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 ?? "")

Ligações: tags SPM · GitHub · cookbook

Kotlin / JVM — floop-kotlin-sdk

Kotlin 2.0+ / JVM 11+. OkHttp + kotlinx-serialization + kotlinx-coroutines. Funções suspend em todo o lado; streaming via Flow<StatusEvent> frio. Distribuição via JitPack (Maven Central planeado).

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

Ligações: JitPack · GitHub · cookbook

Chaves de API

Todos os SDKs utilizam chaves de API programáticas flp_… para autenticação, distintas dos tokens de dispositivo que o CLI usa para logins interativos. A emissão de chaves de API exige o plano Business. Cria uma chave em Conta → Chaves de API, guarda-a no teu gestor de segredos / ambiente e passa-a ao construtor do SDK.

Consulta Autenticação de API para o modelo completo de chaves (âmbitos, limites de taxa, padrão de rotação).

Código-fonte & versões

Os oito repositórios de SDK mais o MCP e as skills são open-source sob a licença MIT em github.com/FloopFloopAI. Cada versão é publicada no registo padrão da sua linguagem no push de tag (npm, PyPI, crates.io, RubyGems, Packagist, Go modules, JitPack, tags SPM). CHANGELOGs por SDK em cada repositório; coordenação de versões entre SDKs acompanhada no monorepo.