Providers

O Floopy atua como um gateway entre sua aplicação e os providers de LLM. Para rotear requisições, você precisa adicionar pelo menos uma API key de provider à sua organização. O Floopy suporta os seguintes providers:

• OpenAI — GPT-4o, GPT-4.1, o3, o4-mini e outros modelos da OpenAI
• Anthropic — Claude 4, Claude 3.5 Sonnet e outros modelos da Anthropic
• Google Gemini — Gemini 2.5 Pro, Gemini 2.0 Flash e outros modelos do Google
• Groq — Llama, Mixtral e outros modelos no motor de inferência da Groq
• Mistral — Mistral Large, Codestral e outros modelos da Mistral AI
• DeepSeek — DeepSeek V3, DeepSeek R1 e outros modelos da DeepSeek
• xAI — Grok 4.20, Grok 4.1 Fast e outros modelos da xAI
• Perplexity — Sonar, Sonar Pro e outros modelos com busca integrada
• Novita — DeepSeek, Qwen, Llama e outros modelos open-source via inferência Novita
• Nebius — DeepSeek, Qwen, Llama e outros modelos open-source via inferência Nebius
• DeepInfra — DeepSeek, Qwen, Llama e outros modelos open-source via inferência DeepInfra
• Azure OpenAI — GPT-4o, GPT-4.1, o3 e outros modelos OpenAI na Azure
• Together — Llama, Mixtral, Qwen e outros modelos open-source via inferência Together
• Fireworks — Llama, Mixtral e outros modelos open-source via inferência Fireworks
• Cohere — Command R, Command R+ e outros modelos da Cohere
• AI21 — Jamba 1.5 e outros modelos da AI21 Labs
• Cerebras — Llama e outros modelos na inferência wafer-scale da Cerebras
• SambaNova — Llama, DeepSeek e outros modelos na inferência acelerada da SambaNova
• AWS Bedrock — Acesso a modelos do AWS Bedrock via configuração de base URL customizada
• Google Vertex — Acesso a modelos do Google Vertex AI via configuração de base URL customizada

1. Vá para Settings > Providers no dashboard.
2. Clique em Add provider.
3. Selecione o provider na lista.
4. Cole sua API key desse provider.
5. Clique em Save.

A API key do seu provider é criptografada em repouso e nunca é exposta no dashboard após ser salva.

Quando sua aplicação envia uma requisição para https://api.floopy.ai/v1, o Floopy determina qual provider chamar com base em:

1. O nome do modelo na requisição (ex.: gpt-4o roteia para OpenAI, claude-3-5-sonnet roteia para Anthropic).
2. A routing rule atribuída à API key, se existir.

O Floopy traduz a requisição para o formato nativo da API do provider, encaminha-a e retorna a resposta no formato compatível com a OpenAI. O código da sua aplicação não precisa ser alterado ao trocar de providers.

Cada provider expõe seu conjunto completo de modelos de chat completion pelo gateway. Use o nome do modelo exatamente como o provider o documenta:

import { OpenAI } from "openai";

const client = new OpenAI({
  baseURL: "https://api.floopy.ai/v1",
  apiKey: process.env.FLOOPY_API_KEY,
});

// OpenAI
const a = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Hello" }],
});

// Anthropic (via Floopy gateway)
const b = await client.chat.completions.create({
  model: "claude-3-5-sonnet-20241022",
  messages: [{ role: "user", content: "Hello" }],
});

// Google Gemini (via Floopy gateway)
const c = await client.chat.completions.create({
  model: "gemini-2.5-pro",
  messages: [{ role: "user", content: "Hello" }],
});

from openai import OpenAI
import os

client = OpenAI(
    base_url="https://api.floopy.ai/v1",
    api_key=os.environ["FLOOPY_API_KEY"],
)

# OpenAI
a = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}],
)

# Anthropic (via Floopy gateway)
b = client.chat.completions.create(
    model="claude-3-5-sonnet-20241022",
    messages=[{"role": "user", "content": "Hello"}],
)

# Google Gemini (via Floopy gateway)
c = client.chat.completions.create(
    model="gemini-2.5-pro",
    messages=[{"role": "user", "content": "Hello"}],
)

# OpenAI
curl https://api.floopy.ai/v1/chat/completions \
  -H "Authorization: Bearer $FLOOPY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-4o", "messages": [{"role": "user", "content": "Hello"}]}'

# Anthropic (via Floopy gateway)
curl https://api.floopy.ai/v1/chat/completions \
  -H "Authorization: Bearer $FLOOPY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "claude-3-5-sonnet-20241022", "messages": [{"role": "user", "content": "Hello"}]}'

# Google Gemini (via Floopy gateway)
curl https://api.floopy.ai/v1/chat/completions \
  -H "Authorization: Bearer $FLOOPY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gemini-2.5-pro", "messages": [{"role": "user", "content": "Hello"}]}'

Para rotacionar ou atualizar a API key de um provider:

1. Vá para Settings > Providers.
2. Encontre o provider e clique em Edit.
3. Cole a nova API key.
4. Clique em Save.

A alteração entra em vigor imediatamente. O cache do gateway é invalidado automaticamente, então novas requisições usarão a chave atualizada.

Para remover um provider:

1. Vá para Settings > Providers.
2. Encontre o provider e clique em Remove.
3. Confirme a ação.

Se o provider removido estiver referenciado em uma routing rule, as requisições que seriam roteadas para ele farão fallback para o próximo provider disponível (se estiver usando fallback routing) ou retornarão um erro.

Adicionar múltiplos providers habilita estratégias poderosas de routing. Por exemplo, você pode:

• Configurar fallback routing para que as requisições automaticamente tentem novamente em um provider diferente caso um esteja fora do ar.
• Usar weighted routing para dividir o tráfego 80/20 entre providers para otimização de custos.
• Configurar latency-based routing para sempre usar o provider mais rápido.

Consulte o guia de Routing para detalhes sobre como configurar essas estratégias.