> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flexinference.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Modelos suportados
> Os modelos que o FlexInference roteia e as entradas que eles aceitam.
O FlexInference roteia aliases de modelos **OpenAI**, **Google Gemini** e **Anthropic**. Passe o modelo pelo seu **alias** (por exemplo, `gpt-5.5` ou `gemini-3.5-flash`), não por um snapshot datado.
Defina `start_within` para o tempo máximo que você esperará para que a solicitação comece. O planejador de superfície executa a flex race apenas nos modelos OpenAI e Gemini com capacidade flex listados abaixo: ele tenta o tier flex do provedor mais barato contra esse orçamento e, em seguida, escala para o tier padrão se o flex não iniciar a tempo. Veja [como a flex race funciona](/pt/deadline-routing) para entender a mecânica completa.
Para solicitações sem duração, o FlexInference atua como proxy para qualquer modelo nos tiers de provedor que ele suporta. O Gemini não tem um tier `auto`, então `auto` em um modelo Gemini retorna `400 auto_unsupported_for_gemini`.
## Modelos com capacidade flex
### OpenAI
`gpt-5.6`, `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`
`gpt-5.5`, `gpt-5.5-pro`
`gpt-5.4`, `gpt-5.4-mini`, `gpt-5.4-nano`, `gpt-5.4-pro`
`gpt-5.2`
`gpt-5`, `gpt-5-mini`, `gpt-5-nano`, `gpt-5.1`
`o3`, `o4-mini`
### Gemini
`gemini-3.5-flash`, `gemini-3.1-pro-preview`, `gemini-3.1-flash-lite`
`gemini-3-flash-preview`
`gemini-2.5-pro`, `gemini-2.5-flash`, `gemini-2.5-flash-lite`
Um `start_within` com duração em um modelo OpenAI ou Gemini fora desta lista de permissões não executa a flex race. O FlexInference retorna `400 flex_model_not_capable`. Escolha um modelo listado para usar o flex. Para pular a flex race, envie um valor de tier em vez de uma duração: `default`, `priority` ou, onde suportado, `auto`. O FlexInference atua como proxy para solicitações de tier suportadas para o provedor. Para o Gemini, `default` mapeia para o tier **standard** do Gemini, e `auto` retorna `400 auto_unsupported_for_gemini`.
## Anthropic (Claude)
Os modelos Claude são roteados para a Anthropic e são **somente proxy**. Eles suportam `default`, `priority` e `auto`, mas não a flex race. Um `start_within` com duração em um modelo `claude-*` retorna `400 flex_unsupported_for_anthropic`, porque a Anthropic não tem um tier flex.
`default` mapeia para o tier de serviço **standard\_only** da Anthropic. `auto` permite que a Anthropic escolha. `priority` é um esforço de melhor tentativa e mapeia para `auto`, já que a Anthropic rejeita um tier de prioridade literal.
A Anthropic exige `max_tokens` upstream. O FlexInference encaminha seu campo de token de saída quando você o define e não sintetiza um padrão quando você o omite, então a Anthropic retorna seu próprio erro de solicitação para limites ausentes.
`claude-opus-4-8`, `claude-opus-4-7`, `claude-opus-4-6`, `claude-opus-4-5`,
`claude-opus-4-1`
`claude-sonnet-5`, `claude-sonnet-4-6`, `claude-sonnet-4-5`
`claude-haiku-4-5`
`claude-fable-5`
O Claude funciona com todos os formatos de chamador suportados: `/v1/responses`, `/v1/chat/completions`, `/v1/interactions` e o [`/v1/messages`](/pt/sdks) nativo da Anthropic. O FlexInference traduz cada um para a API Messages da Anthropic. A Anthropic decide o tier servido. Uma solicitação `standard_only` retorna como `"service_tier": "standard"` na resposta.
## Roteamento de provedor
Um array `provider` opcional e ordenado fixa a rota que sua solicitação toma. O elemento 0 é a rota primária e o único gate flex; os elementos 1 a n são a cadeia de fallback do mesmo modelo, tentada em ordem quando uma rota falha transitoriamente. Omita `provider` e o FlexInference usa a rota direta nativa do modelo, exatamente como antes. Definir o array para a rota nativa do seu modelo é uma operação nula de roteamento que fixa o mesmo comportamento explicitamente.
`google`, `openai` e `anthropic` são **rotas diretas**. `vertex` (Gemini) e `bedrock` (Claude) são **rotas de nuvem** que servem o mesmo modelo em um provedor diferente: `bedrock` serve `claude-*` através do Amazon Bedrock (Bedrock Converse), e `vertex` serve `gemini-*` através do Google Vertex AI (Vertex generateContent). Um fallback de provedor altera apenas a rota: nunca altera o modelo ou o tier, e uma entrada de fallback é sempre uma chamada padrão simples, nunca uma flex race.
### Cada rota que você nomeia precisa de sua chave
Uma cadeia é uma declaração de que você configurou todas as rotas nela. Cada rota usa sua própria chave BYOK: `openai` usa sua chave OpenAI, `google` sua chave Gemini, `anthropic` sua chave Anthropic, `vertex` sua chave Vertex express e `bedrock` sua chave e região Bedrock. Adicione-as no painel em Settings -> API keys antes de nomear a rota.
Uma chave ausente é um erro de configuração, não uma falha transitória, então não passa para a próxima rota. O FlexInference rejeita a solicitação com o código `400 no_..._key` para a rota cuja chave está ausente, antes de qualquer chamada upstream e antes de qualquer trabalho faturável. `["bedrock","anthropic"]` sem uma chave Bedrock retorna [`400 no_bedrock_key`](/pt/errors#no_bedrock_key) mesmo quando sua chave Anthropic está presente e poderia ter servido o modelo. O fallback aqui ocultaria a rota não configurada e o serviria silenciosamente em um provedor que você não pretendia usar, então o FlexInference o informa. Adicione a chave ausente ou remova essa rota da cadeia.
O fallback cobre falhas upstream transitórias e nada mais: um `429`, um `5xx`, um erro de conexão ou um timeout, cada um capturado antes que a resposta seja confirmada. Tudo o que uma rota pode ser rejeitada antecipadamente, incluindo uma chave ausente, um modelo que a rota não pode servir e uma cadeia malformada, é sua solicitação para corrigir e retorna um `400`.
Cada rota serve uma família de modelos, então uma cadeia que fixa uma rota que não pode servir seu modelo retorna [`400 provider_model_mismatch`](/pt/errors#provider_model_mismatch). `openai` serve modelos GPT e da série o, `google` e `vertex` servem Gemini, e `anthropic` e `bedrock` servem Claude.
| Modelo | Rota direta nativa | Rota de nuvem | Exemplos de arrays válidos | Flex race? |
| ------------------------------ | ------------------ | ------------- | ------------------------------------------------------------------------------------ | --------------------------------------------------------------------- |
| `claude-*` | `anthropic` | `bedrock` | `["anthropic"]`, `["bedrock"]`, `["anthropic","bedrock"]`, `["bedrock","anthropic"]` | Não, Claude não tem tier flex |
| `gemini-*` com capacidade flex | `google` | `vertex` | `["google"]`, `["vertex"]`, `["google","vertex"]`, `["vertex","google"]` | Somente quando o elemento 0 é `google` e `start_within` é uma duração |
| `gemini-*` sem flex | `google` | `vertex` | o mesmo que acima | Não, não está na lista de permissões flex |
| `gpt-*` com capacidade flex | `openai` | none | `["openai"]` | Somente quando o elemento 0 é `openai` e `start_within` é uma duração |
| `gpt-*` sem flex | `openai` | none | `["openai"]` | Não, não está na lista de permissões flex |
Uma cadeia de elemento único com prioridade de nuvem, como `["vertex"]` ou `["bedrock"]`, é uma rota direta válida sem flex para esse provedor de nuvem. Um `start_within` com duração e uma rota de nuvem como elemento 0 retorna [`400 flex_unsupported_on_cloud`](/pt/errors#flex_unsupported_on_cloud), porque as rotas de nuvem não têm um tier flex para competir; envie um valor de tier (`default`, `priority` ou `auto`) em vez disso. Um array malformado (um nome desconhecido, um duplicado, um array vazio ou mais de três entradas) retorna [`400 invalid_provider_chain`](/pt/errors#invalid_provider_chain).
### Claude no Bedrock: roteamento global, opus-4-1 e concessões de acesso
A rota `bedrock` serve Claude através dos perfis de inferência entre regiões da Amazon. O FlexInference a roteia **global-first**: cada modelo `claude-*` que ele serve no Bedrock é endereçado através de um perfil de inferência global, então ele serve de qualquer região AWS, independentemente de onde a chave Bedrock da sua organização esteja configurada. Uma consequência é uma compensação de residência de dados que vale a pena conhecer: um perfil global roteia cada solicitação por todas as regiões AWS suportadas, então uma solicitação não tem garantia de ser executada em sua própria região. Sob o global-first, nenhuma rota garante o processamento em uma região AWS específica, e a rota direta `anthropic` não é uma alternativa na região: ela alcança a própria infraestrutura da Anthropic, não sua conta AWS. Se o processamento na região for um requisito, um perfil Bedrock fixado na região (`us.` ou `eu.`, correspondendo à região da sua chave Bedrock) está disponível mediante solicitação através de uma política de residência de dados por organização.
`claude-opus-4-1` é a única exceção que **não está na rota `bedrock` de forma alguma**. A Amazon o publica apenas nos EUA, e nem mesmo em todas as regiões dos EUA, então, em vez de carregar uma exceção de região parcial, o FlexInference o serve apenas na rota direta `anthropic`; uma cadeia `["bedrock"]` para ele retorna [`400 bedrock_model_unavailable`](/pt/errors#bedrock_model_unavailable) em todas as regiões. Ele está sempre disponível na rota direta `anthropic`, então omita `provider` ou envie `["anthropic"]` para alcançá-lo de qualquer região.
Separadamente, um modelo pode servir globalmente e ainda estar fechado para sua conta AWS até que você solicite acesso a ele no console do Amazon Bedrock. Quando o Bedrock tem o modelo, mas sua conta AWS não recebeu a concessão, você recebe [`403 bedrock_model_access_denied`](/pt/errors#bedrock_model_access_denied), que nomeia o modelo e cita o que o Bedrock disse. (O outro caso, [`400 bedrock_model_unavailable`](/pt/errors#bedrock_model_unavailable) para um modelo para o qual o Bedrock não publica perfil, agora se aplica efetivamente apenas a `claude-opus-4-1`, já que todos os outros modelos servidos têm um perfil global.)
Nenhum dos dois é um problema com sua chave Bedrock, e uma chave funcionando continua funcionando: ambos os erros significam o modelo, não a credencial. Nenhum deles também passa para a próxima rota na cadeia, porque uma rota que você nomeou é uma rota que você deve ter configurado. Envie o modelo para a rota `anthropic` em vez disso, ou conceda-o à conta AWS.
### Os modelos Claude mais recentes no Bedrock precisam de uma configuração de conta única
Cinco modelos Claude servem na rota `bedrock` uma vez que a conta AWS tenha a concessão comum de **Model access**: `claude-haiku-4-5`, `claude-sonnet-4-6`, `claude-sonnet-4-5`, `claude-opus-4-6` e `claude-opus-4-5`.
Os quatro modelos mais recentes - `claude-sonnet-5`, `claude-fable-5`, `claude-opus-4-8` e `claude-opus-4-7` - precisam de duas etapas adicionais únicas na conta AWS antes que o Bedrock os sirva. A concessão de **Model access** do console do Amazon Bedrock sozinha não os habilita. Execute ambos uma vez por conta AWS, usando as credenciais AWS de um administrador (não sua chave de inferência Bedrock).
**Passo 1 - opte pela conta para compartilhamento de dados do provedor.** Esta etapa não tem UI de console, então deve ser executada a partir da AWS CLI:
```bash theme={null}
aws bedrock put-account-data-retention --mode provider_data_share
```
**Passo 2 - aceite o contrato do modelo** para cada um desses modelos que você planeja chamar (execute-o uma vez por modelo):
```bash theme={null}
aws bedrock create-foundation-model-agreement
```
Até que ambos sejam feitos, uma solicitação `bedrock` para um desses quatro modelos retorna [`403 bedrock_model_access_denied`](/pt/errors#bedrock_model_access_denied). Este é um requisito da conta Amazon Bedrock, não do FlexInference, então é o mesmo se você acessa o Bedrock através do FlexInference ou diretamente. `claude-opus-4-1` não é afetado porque não é servido na rota `bedrock` de forma alguma; acesse-o na rota `anthropic`.
As rotas de nuvem `vertex` e `bedrock` estão em serviço hoje. `bedrock` serve `claude-*`
através do Amazon Bedrock e `vertex` serve `gemini-*` através do Google Vertex
AI, sempre o mesmo modelo que você solicitou. Cada rota de nuvem precisa da
própria chave dessa nuvem adicionada no painel: uma chave Vertex express (prefixo `AQ.`) para
`vertex`, uma chave bearer Bedrock (prefixo `ABSK`) e região para `bedrock`. As rotas de nuvem
são executadas apenas no tier padrão, sem flex race. Ambas as rotas de nuvem
transportam texto, imagens e arquivos: uma URL remota `https` de imagem ou arquivo é buscada
no lado do servidor e inlinada para elas (veja [Entradas](#inputs) abaixo).
## Capacidades por rota
A tabela é o sim/não rápido por rota. Cada rota serve texto, streaming, chamada de função, imagens, arquivos (incluindo PDFs) e pensamento/raciocínio; as linhas abaixo da linha de base são onde as rotas diferem. `openai`, `anthropic` e `google` são as rotas diretas; `vertex` e `bedrock` são as rotas de nuvem.
| Capacidade | OpenAI (`openai`) | Anthropic (`anthropic`) | Gemini (`google`) | Vertex (`vertex`) | Bedrock (`bedrock`) |
| ----------------------------------------- | ----------------- | ----------------------- | ----------------- | ----------------- | ------------------- |
| Texto, streaming, chamada de função | Sim | Sim | Sim | Sim | Sim |
| Imagens e arquivos (incluindo PDF) | Sim | Sim | Sim | Sim | Sim |
| Pensamento / raciocínio | Sim | Sim | Sim | Sim | Sim\* |
| Pesquisa na web | Sim | Sim | Sim | Sim | Não |
| Citações (`url_citation`) | Sim | Sim | Sim | Sim | Não |
| Saídas estruturadas (`json_schema`) | Sim | Sim | Sim | Sim | Não |
| Formato de saída `json_object` | Sim | Não | Sim | Sim | Não |
| Esquema estrito (`text.format.strict`) | Sim | Não | Não | Não | Não |
| `code_execution` / `url_context` (Gemini) | Não | Não | Sim | Sim | Não |
\*Bedrock executa o pensamento, mas dobra os tokens de raciocínio na contagem de saída e não relata um total separado de tokens de raciocínio; o Vertex relata os tokens de raciocínio.
Um `Não` é um `400 unsupported_parameter` alto, não uma queda silenciosa. Envie `web_search`, uma saída estruturada `json_schema` ou `text.format.strict: true` para uma rota que não a suporta e o FlexInference rejeita a solicitação e nomeia o campo. Roteie a pesquisa na web ou saídas estruturadas para qualquer rota direta ou `vertex`, e roteie a conformidade estrita do esquema para `openai`.
## Resultados e erros do Flex
Os cabeçalhos `x-flexinference-flex-*` relatam os resultados do flex em respostas bem-sucedidas. Erros de validação ainda usam o corpo de erro normal. Consulte a [página de erros](/pt/errors) para ver a forma completa do erro e os cabeçalhos de resultado do Flex.
* `flex_model_not_capable` significa que você enviou um `start_within` com duração para um modelo OpenAI ou Gemini fora da lista de permissões flex. Use um valor de tier ou escolha um modelo com capacidade flex.
* `auto_unsupported_for_gemini` significa que você solicitou `auto` em um modelo Gemini, que não tem um tier `auto`. Use `default` para o tier padrão do Gemini.
* `flex_unsupported_for_anthropic` significa que você enviou um `start_within` com duração para um modelo `claude-*`. Use `default`, `priority` ou `auto` para Claude.
## Entradas
Essas rotas aceitam entradas compatíveis com OpenAI:
* **Texto**: mensagens de sistema, desenvolvedor, usuário e assistente.
* **Imagens**: passe URLs de imagem ou URLs de dados base64. URLs de dados base64 são os mais confiáveis. Para as rotas Bedrock e Vertex, que precisam de bytes inline, uma URL de imagem `https` remota é baixada no lado do servidor e inlinada para você, por trás de verificações de segurança SSRF (somente https, sem hosts privados ou de metadados, um limite de tamanho e uma verificação de tipo de byte mágico para png/jpeg/gif/webp); uma URL que falha em uma verificação retorna `400 unsupported_parameter` em vez de ser silenciosamente descartada.
* **Arquivos**: PDFs e outras entradas de arquivo que a API Responses aceita. URLs de PDF `https` remotas são baixadas e inlinadas para Bedrock e Vertex sob as mesmas verificações.
As saídas são texto, incluindo chamadas de ferramentas, saídas estruturadas e raciocínio. O streaming funciona em todos os modelos. No Gemini, `reasoning.effort` mapeia para um `thinking_level` por modelo e pode ser limitado ao intervalo que o modelo suporta.
Parâmetros de provedor nativos passam apenas quando o modelo pertence a esse provedor. Consulte [SDKs](/pt/sdks) para regras de passthrough específicas do endpoint.
A [matriz de capacidades](#capabilities-by-route) acima é o sim/não por rota;
esta nota é como as capacidades compartilhadas mapeiam para cada provedor. Para pesquisa na web,
envie uma ferramenta `web_search` do Responses; o Gemini a mapeia para `google_search`
e a Anthropic para sua ferramenta `web_search_20250305`. Qualquer que seja o provedor que atenda à
solicitação, `web_search` (e `url_context` do Gemini) retorna suas fontes como
anotações canônicas `url_citation` na saída da mensagem, para que você leia
as citações da mesma forma, independentemente da rota. Saídas estruturadas (`text.format`
com um `json_schema`) mapeiam para `response_format` do Gemini e `output_config` da Anthropic;
`json_object` mapeia no Gemini, mas não na Anthropic. O flag `strict` é
honrado apenas na OpenAI. Gemini, Vertex e Anthropic honram a forma do esquema de resposta,
mas não podem garantir conformidade estrita, então `text.format.strict: true`
retorna `400 unsupported_parameter` lá em vez de ser silenciosamente ignorado;
remova `strict` ou roteie para a OpenAI para aplicá-lo. O Gemini adicionalmente
aceita as ferramentas `code_execution` e `url_context` e `top_k`. Passe arquivos como
URLs de dados base64; PDFs são os mais confiáveis no Gemini.
O FlexInference adiciona novos modelos com capacidade flex da OpenAI e do Gemini à medida que os
provedores os lançam. Se um modelo que você espera estiver faltando, verifique se você está
usando seu alias e se o provedor oferece um tier flex para ele.