LLM API

A LLM API expõe endpoints de chamada direta de modelos pelo Felo API Platform. Use-a quando quiser chamar modelos de linguagem de uso geral, reutilizar clientes compatíveis com OpenAI ou com Anthropic, ou conectar frameworks de agentes ao Felo API Platform.

A LLM API inclui atualmente três superfícies de chamada de modelo compatíveis com chat:

• POST /api/v1/responses: compatível com OpenAI Responses
• POST /api/v1/chat/completions: compatível com OpenAI Chat Completions
• POST /api/v1/messages: compatível com Anthropic Messages

Decisions API

POST https://openapi.felo.ai/api/v1/decisions

Envie estado e perguntas tipadas e restritas para jev-1.13 (também aceito: typesafe/jev-1.13). Use /api/v1/decisions, não os endpoints Chat Completions, Messages ou Responses. Streaming não tem suporte.

Campos da requisição

• model: jev-1.13
• state: contexto a ser avaliado; uma string ou um valor JSON.
• questions: perguntas nomeadas usando type, instructions e criteria.

import os
import requests

response = requests.post(
    "https://openapi.felo.ai/api/v1/decisions",
    headers={"Authorization": f"Bearer {os.environ['FELO_API_KEY']}"},
    json={
        "model": "jev-1.13",
        "state": "Help! My payouts have been failing for 3 days.",
        "questions": {
            "is_urgent": {
                "type": "noul",
                "instructions": "Does this message convey urgency?",
                "criteria": {"true": "Time-sensitive", "false": "No urgency"},
            },
            "department": {
                "type": "choice",
                "instructions": "Which team should handle this?",
                "criteria": {
                    "billing": "Payments, invoicing, refunds",
                    "technical": "Bugs, outages, integrations",
                    "sales": "Pricing, upgrades, new accounts",
                },
            },
            "frustration": {
                "type": "score",
                "instructions": "How frustrated is the customer?",
                "criteria": ["Calm", "Frustrated", "Very angry"],
            },
        },
    },
    timeout=60,
)
response.raise_for_status()
answers = response.json()["answers"]
print(answers["is_urgent"]["noul"])
print(answers["department"]["choice"], answers["department"]["probabilities"])
print(answers["frustration"]["score"])

Tipos de resposta

noul: uma probabilidade de 0 a 1. choice: a opção selecionada e sua distribuição de probabilidade. score: uma pontuação numérica para critérios ordenados, com sua distribuição.

Os erros usam error.code (status HTTP numérico) e error.message. Trate respostas não 2xx antes de ler answers.

Uso e preços

A resposta inclui usage.input_tokens, usage.output_tokens e pode incluir usage.cost. Tarifas de referência verificadas em 2026-10-12: entrada USD 0,042 por milhão de tokens; saída USD 0. Uma tarifa de saída zero não torna o uso de entrada gratuito. As tarifas podem mudar; use o preço publicado do modelo e os descontos aplicáveis da conta para fazer estimativas.

Autenticação

As requisições à LLM API exigem uma chave do Felo API Platform. Use Authorization: Bearer ... ou X-API-Key.

Authorization: Bearer YOUR_API_KEY

X-API-Key: YOUR_API_KEY

Consulte o guia de autenticação para detalhes sobre como criar e gerenciar chaves de API.

URL base

Use o host público do Felo API Platform:

https://openapi.felo.ai

Para clientes de SDK, configure a URL base específica do protocolo mostrada em Uso básico.

Cabeçalhos comuns

Descoberta de modelos

O catálogo geral inclui todas as categorias de modelo. Use as listas dedicadas para descobrir modelos de vídeo ou de decisão:

Os três endpoints aceitam o parâmetro de consulta opcional provider (por exemplo, openrouter) e retornam {"object":"list","data":[...]}. Cada item contém id, object, created, owned_by e model_kind. As listas dedicadas usam a categoria efetiva após as substituições de mapeamento de provedores habilitados.

Apenas modelos habilitados, listados, não excluídos e com preço atual que corresponda às condições do provedor são retornados; um preço zero é válido. Modelos recém-sincronizados ficam ocultos até que um administrador os liste. Todas as listas compartilham a ordenação configurada, com nome e ID do modelo como critérios de desempate. Nenhuma correspondência retorna HTTP 200 com um array data vazio. A descoberta lê o catálogo local e não invoca nem cobra por uma chamada de modelo.

Apenas GET /api/v1/models aceita exclude_video_and_decisions (booleano, padrão false). Defina como true para excluir os tipos efetivos video_generation e decisions; modelos de imagem continuam elegíveis. Pode ser combinado com provider. Omiti-lo ou defini-lo como false preserva o catálogo completo. Valores booleanos inválidos retornam HTTP 422.

curl "https://openapi.felo.ai/api/v1/models?exclude_video_and_decisions=true&provider=openrouter" \
  -H "Authorization: Bearer ${FELO_API_KEY}"
curl "https://openapi.felo.ai/api/v1/videos/models?provider=openrouter" \
  -H "Authorization: Bearer ${FELO_API_KEY}"
curl "https://openapi.felo.ai/api/v1/decisions/models?provider=openrouter" \
  -H "Authorization: Bearer ${FELO_API_KEY}"

Escolha um endpoint de chamada conforme o model_kind: chat para Responses, Chat Completions ou Messages, conforme o suporte do modelo; video_generation para POST /api/v1/videos/generations; decisions para POST /api/v1/decisions; image_generation para POST /api/v1/images/generations. Os detalhes permanecem em GET /api/v1/models/{model_id}. Um modelo listado não é necessariamente compatível com todos os endpoints de chamada.

Modelos de imagem não têm endpoint de lista dedicado. Filtre GET /api/v1/models por model_kind: "image_generation". Consulte Geração de imagens para ver os campos da requisição de imagem.

Modelos e preços

As requisições usam o canal padrão do modelo, a menos que você fixe um com X-Felo-Channel. Passe uma lista ordenada, separada por vírgulas, de códigos de canal públicos do catálogo de modelos; omita o cabeçalho para usar o padrão. Use default apenas sozinho. Apenas o grupo de provedores do primeiro canal é acionado; não há fallback automático. Consulte Canais e roteamento de provedores.

Os preços são listados em dólares. As tarifas por token são exibidas por 1 milhão de tokens para facilitar a leitura; a cobrança usa a precisão por token do snapshot de preço atual. As tarifas de cache se aplicam apenas quando a resposta do protocolo inclui uso de cache. Um traço significa que não há tarifa ou limite publicado separado. O uso de busca na web, quando informado pelo serviço do modelo, é cobrado a $0.01 por busca.

O Claude Haiku 5.5 usa preços em faixas: prompts de até 100K tokens são cobrados pelas tarifas padrão acima, e requisições cujo prompt excede 100K tokens são cobradas a $0.50 de entrada, $2.50 de saída, $0.05 de leitura de cache e $0.0625 de gravação de cache por 1M de tokens para a requisição inteira.

O GPT-5.6 está disponível em três níveis: Luna para cargas rápidas e econômicas; Terra para tarefas equilibradas de codificação, raciocínio e agentes; e Sol para raciocínio complexo e codificação de ponta. Cada nível também expõe um ID de modelo -pro (gpt-5.6-luna-pro, gpt-5.6-terra-pro e gpt-5.6-sol-pro), que usa o mesmo modelo subjacente com o modo de raciocínio pro. Preços, tamanho de contexto e saída máxima não mudam nos IDs -pro.

O DeepSeek V4 Flash oferece suporte a modos de raciocínio e sem raciocínio, saída JSON, chamadas de ferramentas, Responses API e compatibilidade com a API da Anthropic. Ele está disponível pelas superfícies Responses, Chat Completions e Messages da Felo. O preço de gravação de cache ainda não foi publicado.

Uso básico

Estes exemplos usam os SDKs oficiais da OpenAI e da Anthropic. Defina FELO_API_KEY com sua chave do Felo API Platform antes de executar os exemplos.

export FELO_API_KEY="YOUR_API_KEY"

Instale os SDKs

SDK da OpenAI

Use o SDK da OpenAI para a Responses API e a Chat Completions API.

##### JavaScript

npm install openai

##### Python

pip install openai

SDK da Anthropic

Use o SDK da Anthropic para a Messages API.

##### JavaScript

npm install @anthropic-ai/sdk

##### Python

pip install anthropic

Configure os clientes

Os endpoints compatíveis com OpenAI usam a URL base do SDK da OpenAI com /api/v1, porque o SDK acrescenta caminhos de recurso como /responses e /chat/completions.

JavaScript

import OpenAI from "openai";

const openai = new OpenAI({
  apiKey: process.env.FELO_API_KEY,
  baseURL: "https://openapi.felo.ai/api/v1",
});

Python

import os
from openai import OpenAI

openai = OpenAI(
    api_key=os.environ.get("FELO_API_KEY"),
    base_url="https://openapi.felo.ai/api/v1",
)

Os endpoints compatíveis com Anthropic usam a URL base do SDK da Anthropic sem /v1, porque o SDK acrescenta /v1/messages.

JavaScript

import Anthropic from "@anthropic-ai/sdk";

const anthropic = new Anthropic({
  apiKey: process.env.FELO_API_KEY,
  baseURL: "https://openapi.felo.ai/api",
});

Python

import os
from anthropic import Anthropic

anthropic = Anthropic(
    api_key=os.environ.get("FELO_API_KEY"),
    base_url="https://openapi.felo.ai/api",
)

Usando a Responses API

Use a Responses API para novas integrações compatíveis com OpenAI e para objetos de resposta no estilo de agente.

JavaScript

import OpenAI from "openai";

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

const response = await client.responses.create({
  model: "gpt-5.6-sol",
  input: "Write a one-sentence bedtime story about a unicorn.",
});

console.log(response.output_text);

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("FELO_API_KEY"),
    base_url="https://openapi.felo.ai/api/v1",
)

response = client.responses.create(
    model="gpt-5.6-sol",
    input="Write a one-sentence bedtime story about a unicorn.",
)

print(response.output_text)

Como usar Chat Completions

Use Chat Completions quando sua aplicação já envia messages no estilo OpenAI.

JavaScript

import OpenAI from "openai";

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

const completion = await client.chat.completions.create({
  model: "gpt-5.6-sol",
  messages: [
    {
      role: "user",
      content: "Give me one sentence about why API compatibility matters.",
    },
  ],
});

console.log(completion.choices[0].message.content);

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("FELO_API_KEY"),
    base_url="https://openapi.felo.ai/api/v1",
)

completion = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[
        {
            "role": "user",
            "content": "Give me one sentence about why API compatibility matters.",
        }
    ],
)

print(completion.choices[0].message.content)

Usando Messages

Use Messages quando seu cliente ou framework de agentes esperar formatos de requisição e resposta compatíveis com Anthropic.

JavaScript

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.FELO_API_KEY,
  baseURL: "https://openapi.felo.ai/api",
});

const message = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 128,
  messages: [
    {
      role: "user",
      content: "Summarize the value of direct model APIs in one sentence.",
    },
  ],
});

const text = message.content
  .filter((block) => block.type === "text")
  .map((block) => block.text)
  .join("");

console.log(text);

Python

import os
from anthropic import Anthropic

client = Anthropic(
    api_key=os.environ.get("FELO_API_KEY"),
    base_url="https://openapi.felo.ai/api",
)

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=128,
    messages=[
        {
            "role": "user",
            "content": "Summarize the value of direct model APIs in one sentence.",
        }
    ],
)

text = "".join(block.text for block in message.content if block.type == "text")
print(text)

Documentação oficial

• Início rápido da API da OpenAI
• OpenAI Create response
• OpenAI Create chat completion
• Claude Messages API
• SDK TypeScript da Anthropic
• SDK Python da Anthropic

Para configurar clientes de agente, consulte Configuração do Claude Code e do Codex.

Referência de protocolos

Responses

Use este endpoint para clientes e integrações compatíveis com a OpenAI Responses API.

Endpoint

POST https://openapi.felo.ai/api/v1/responses

Corpo da requisição

Requisição via SDK

const response = await client.responses.create({
  model: "gpt-5.6-sol",
  input: "Reply with exactly: responses ok",
});

console.log(response.output_text);

Caminho do texto da resposta

output_text

Chat Completions

Use este endpoint para clientes e SDKs compatíveis com OpenAI Chat Completions.

Endpoint

POST https://openapi.felo.ai/api/v1/chat/completions

Corpo da requisição

Requisição via SDK

const completion = await client.chat.completions.create({
  model: "gpt-5.6-sol",
  messages: [
    {
      role: "user",
      content: "Reply with exactly: chat completions ok",
    },
  ],
});

console.log(completion.choices[0].message.content);

Caminho do texto da resposta

choices[0].message.content

Messages

Use este endpoint para clientes e SDKs compatíveis com Anthropic Messages.

Endpoint

POST https://openapi.felo.ai/api/v1/messages

Corpo da requisição

Requisição via SDK

const message = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 64,
  messages: [
    {
      role: "user",
      content: "Reply with exactly: messages ok",
    },
  ],
});

const text = message.content
  .filter((block) => block.type === "text")
  .map((block) => block.text)
  .join("");

console.log(text);

Requisição com bloco de conteúdo

const message = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 64,
  messages: [
    {
      role: "user",
      content: [
        {
          type: "text",
          text: "Reply with exactly: messages ok",
        },
      ],
    },
  ],
});

Caminho do texto da resposta

content[].text

Streaming

Defina stream como true para receber Server-Sent Events. O formato do payload dos eventos segue o protocolo selecionado:

• Streams de Responses retornam eventos de resposta compatíveis com Responses.
• Streams de Chat Completions retornam chunks de conclusão de chat compatíveis com OpenAI.
• Streams de Messages retornam eventos de mensagem compatíveis com Anthropic.

const stream = await client.responses.create({
  model: "gpt-5.6-sol",
  input: "Write one sentence.",
  stream: true,
});

Os clientes devem analisar o stream de acordo com o protocolo que estão usando, em vez de esperar um esquema de evento compartilhado entre os três endpoints.

Erros

A LLM API retorna o formato de erro do protocolo selecionado sempre que possível. Causas comuns incluem: