# GateLLM — Gateway de LLM auto-hospedado para empresas

> Cerca de 1/7 do custo, mesma carga de trabalho. Um gateway de LLM (AI gateway) confiável, compatível e auto-hospedado que orquestra modelos fechados de primeira linha ao lado de modelos SOTA abertos — planejamento em modelos de fronteira, execução no SOTA aberto.

Canônico: https://www.gatellm.io/pt-BR/

## Planejamento de ponta. Execução com SOTA aberto. Cerca de 1/7 do custo.
Modelos de primeira linha cuidam do planejamento; modelos SOTA abertos executam os 90% rotineiros da carga. A composição leva a conta a ~1/7 — os números são calculados ao vivo na calculadora, não afirmados aqui.
```
from openai import OpenAI

# One line change: point your SDK at your own gateway
client = OpenAI(
    base_url="https://your-gateway.gatellm.io/v1",
    api_key="your-gateway-api-key",
)

# Existing code unchanged — the gateway routes each request
# to the right model tier (planning vs execution) per your console policy
resp = client.chat.completions.create(
    model="claude-opus-5",  # or claude-sonnet-5, gpt-6-astra, deepseek-flash...
    messages=[{"role": "user", "content": "Plan the architecture"}],
)
```
Combine modelos: o Claude Opus planeja, DeepSeek / Qwen executam — ~1/7 do custo, até 90% mais barato

O gateway decide qual modelo roda: qualquer que seja a configuração do cliente, o modelo de destino é o que os admins fixaram — lista de permissões na entrada + mapeamento curinga "*"

Um protocolo basta: fale OpenAI ou Anthropic e alcance modelos das quatro famílias de chat (OpenAI / Anthropic / Gemini / DashScope) — trocar de modelo nunca toca seu código

Os dados ficam no local: totalmente auto-hospedado, os prompts nunca chegam até nós; credenciais e PII detectadas no caminho da requisição — log / mascarar / bloquear por escopo

## Três coisas que o gateway faz e que um único modelo não faz
Combine modelos para cortar custo, imponha qual deles realmente roda e mantenha o código do cliente em um único protocolo.
### Combine modelos em vez de rodar o mais caro em todo lugar
Modelos de fronteira (Claude Opus) planejam e raciocinam; modelos SOTA abertos (DeepSeek / Qwen / GLM) executam a rotina. Na mistura padrão a conta fica em ~1/7, com ~97% da capacidade preservada nas tarefas rotineiras de execução — calculado ao vivo na calculadora, não afirmado aqui.
- Modo de planejamento detectado por requisição — sem mudar o cliente
- Camadas atribuídas por grupo de chaves ou identidade
- Atribuição de custo e tetos de orçamento por modo
### O gateway decide qual modelo realmente roda
Qualquer que seja o modelo configurado pelo desenvolvedor, a requisição é normalizada na chegada. Nomes fora da lista de permissões recebem 403; um mapeamento curinga "*" reescreve todo o resto para o modelo autorizado. Mapeamentos e regras recarregam a quente — sem rollout por desenvolvedor.
- A lista de permissões do grupo de chaves barra nomes de modelo na entrada
- O mapeamento curinga fixa o modelo de destino
- Cada requisição registra o modelo de destino real (tag SW para trocas por script, MM para mapeamentos por identidade)
### Escreva o cliente uma vez e troque o backend livremente
Seu app fala um protocolo — OpenAI ou Anthropic. O gateway traduz entre as quatro famílias de protocolo de chat (OpenAI / Anthropic / Gemini / DashScope) e normaliza streaming, chamadas de ferramenta e outras diferenças de capacidade, então adicionar um fornecedor ou um modelo nunca toca o código de negócio.
- Qualquer-para-qualquer entre as quatro famílias de protocolo de chat
- Clientes só-Anthropic (Claude Code, claude-code-action) podem rodar modelos de outros fornecedores
- 15 formatos de protocolo upstream além das quatro famílias, documentados na matriz de interoperabilidade

Integrado a mais de 100 provedores de LLM · mais de 30 SDKs e frameworks

## Verifique você mesmo
Publicamos os documentos em vez de pedir que você acredite na nossa palavra. Cada afirmação nesta página tem um rastro documental que você pode ler antes de falar conosco.

### [Segurança e conformidade](https://www.gatellm.io/pt-BR/security.md)
Arquitetura, tratamento de chaves e modelo de isolamento.

### [Questionário de segurança](https://www.gatellm.io/trust.md)
Respostas CAIQ / SIG / VSA, já preenchidas.

### [Lista de subprocessadores](https://www.gatellm.io/subprocessors.md)
Todos os terceiros que podem tocar nos seus dados.

### [Resposta a incidentes e suporte](https://www.gatellm.io/sla.md)
Prazos de resposta e compromissos de suporte.

## Uma interface, combine todos os modelos
Do roteamento simples de modelos à orquestração multi-modelo, o GateLLM oferece um conjunto completo de capacidades de nível empresarial.
### Roteamento multi-modelo
Uma interface para chamar todos os modelos. Fallback inteligente, balanceamento de carga e nova tentativa automática.
- API unificada para mais de 100 provedores de LLM
- Roteamento com fallback inteligente
- Balanceamento de carga e limite de taxa
- Pool de chaves upstream: cada chamador fica fixo em uma chave e passa para a próxima em caso de falha
- Ollama / vLLM / llama.cpp como upstreams compatíveis com OpenAI, em um único plano de governança
### Composição
Roteamento em camadas por modo de plano, identidade ou formato da requisição: planejamento nos modelos de primeira linha, execução no SOTA aberto. O gateway reescreve o nome do modelo — o código do cliente nunca muda.
- Detecção de modo de plano: planejar na primeira linha, executar no SOTA aberto — zero alteração no cliente
- Mapeamento de modelo por identidade: mesmo nome de modelo → upstreams diferentes por grupo de chaves
- Regras switch-route: redirecione requisições com imagem ou especiais para o modelo certo
- Rebaixamento em agente: plano travado / rebaixamento automático fora do plano
### Revisão de código multi-modelo
Execute 2–3 modelos em paralelo na mesma PR. O gateway fornece a interoperabilidade de protocolo e a medição com uma única chave; o fan-out, o merge e a pontuação de confiança ficam na ação de orquestração de código aberto.
- Interoperabilidade de protocolo no gateway: modelos não Anthropic entram em filas de revisão exclusivas do Anthropic
- Uma única chave de acesso mede e governa todo o fan-out
- Fan-out, pontuação [Consensus N/M] e merge ficam em gatellm-io/gatellm-code-review (lado da orquestração)
### Governança de ferramentas MCP
Agregue servidores externos de ferramentas MCP atrás de um único endpoint /mcp: ACLs por ferramenta, orçamentos de contexto e auditoria de chamadas. Quais ferramentas um agente pode usar ficam no mesmo plano de permissões que define quais modelos ele pode chamar.
- Vários servidores MCP atrás de um único endpoint /mcp
- Lista de permitir/negar por grupo de chaves + filtros por rótulo
- Recuperação BM25 integrada quando a lista de ferramentas cresce
- Ponte REST: exponha qualquer API REST como ferramenta MCP a partir de uma especificação simplificada, sem código
- Chamadas / violações / sessões MCP totalmente auditadas
### Injeção de busca na web
Dê busca na web a todos os modelos, de forma uniforme: o gateway recupera e injeta os resultados, sintetizando blocos de busca nativos por protocolo de cliente — modelos abertos também ganham fundamentação por busca.
- Blocos de busca nativos por protocolo (Anthropic / OpenAI / Responses)
- Alternância tripla por modelo, com degradação suave em caso de falha
- Busca interceptada excluída da cobrança de uso
### Controle de custos
Gestão de orçamento, limite de taxa, atribuição de custos por equipe e política de modelos ciente do modo. Nunca acrescentamos margem sobre tokens; BYOK com suas próprias chaves.
- Atribuição de custo por projeto/recurso
- Alertas de orçamento flexíveis
- BYOK: pague aos provedores as tarifas padrão
- Política de modelos ciente do modo (planejar/executar, aplicável)
### Governança e integrações
Do controle de acesso de clientes à integração com CI/CD — estenda as capacidades do gateway para seus fluxos de desenvolvimento e colaboração.
- Controle de acesso de clientes (política de User-Agent)
- Revisão de código via GitHub Actions usando seu próprio gateway
- Configuração em lote: preparar → visualizar o conjunto completo de conflitos → commit atômico em transação única
### Add-in Office / M365
Use seu próprio gateway de modelos diretamente no Excel, Word, PowerPoint e Outlook — add-in auto-hospedado, os dados nunca saem da rede, sem dependência de pivô.
- Modelagem financeira no Excel / revisão de contratos no Word / caixa de entrada no Outlook
- Entra SSO + bloqueio por rótulo do Purview
- 33 habilidades de domínio incluídas, add-on pago
### Scripts de transformação
Um motor JavaScript em sandbox (QuickJS) reescreve o JSON de requisição e resposta no gateway. Edite no console, entra em vigor na hora — sem reimplantar, sem código de cola.
- Slots antes / depois da requisição + um slot de resposta: veja o formato do cliente antes da tradução ou o formato do upstream depois dela
- context.useModel() troca toda a rota — base_url, protocolo e credenciais juntos
- Biblioteca integrada: json_path / str_* / regex_* / array_* / codificação + hash / UUID + tempo
- Em sandbox (sem rede, sem sistema de arquivos) com modos fail-open/fail-closed e um testador de scripts no console

## Combinação de modelos: qualidade que nenhum modelo isolado entrega
A composição é um padrão nativo do gateway; a revisão de código multi-modelo é um padrão do lado da orquestração que o gateway habilita — ambos construídos sobre a camada de normalização de capacidades.
### Composição: roteamento em camadas entre modelos
Roteie por modo de plano, identidade ou formato da requisição: o planejamento fica nos modelos de primeira linha, a execução cai para o SOTA aberto. O gateway reescreve o nome do modelo e traduz protocolos — o código do cliente nunca muda.
- Detecção de modo de plano: encaminhe o planejamento para a primeira linha e a execução para o SOTA aberto — zero alteração no cliente
- Mapeamento de modelo por identidade: mesmo nome de modelo → upstreams diferentes por grupo de chaves / cabeçalho
- Regras switch-route: redirecione requisições com imagem ou especiais para o modelo certo
- Sem código de cola — a tradução de protocolo é feita pelo gateway
- Política aplicável: admins travam as camadas de modelo por modo planejar/executar, impedindo o uso de tudo na primeira linha
```
// before-slot transform script (JavaScript) — switch execution model by plan mode.
// Mounted on the entry model in the console; runs before routing.
function transform(body, context) {
    if (context.sourceProtocol !== "Anthropic") {
        return body;
    }
    const EXEC_MODEL = "qwen3.8-max"; // a model name configured in the gateway
    const PLAN = /plan mode is active/i;
    const EXIT = /exited plan mode/i;
    // take the last marker-bearing message: later marker wins
    const messages = body.messages || [];
    for (let i = messages.length - 1; i >= 0; i--) {
        const s = JSON.stringify(messages[i].content || "");
        const inPlan = PLAN.test(s);
        const exited = EXIT.test(s);
        if (inPlan || exited) {
            // not in plan mode → switch execution to the cost-efficient model
            if (exited || !inPlan) context.useModel(EXEC_MODEL);
            return body;
        }
    }
    context.useModel(EXEC_MODEL);
    return body;
}
```
### Revisão de código multi-modelo (lado da orquestração)
O gateway habilita o padrão, a camada de orquestração o executa: o claude-code-action fala apenas o protocolo Anthropic, e a interoperabilidade de protocolo do gateway permite que modelos não Anthropic, como qwen3.8-max e kimi-k3, entrem na fila de revisão. Uma única chave de acesso do gateway mede uniformemente todos os modelos de revisão.
- Anotações de confiança [Consensus N/M], merge e deduplicação são produzidos pela ação
- Cada modelo de revisão é cobrado separadamente e agregado de forma uniforme pelo gateway
- O limite de linhas da PR e o agrupamento de comentários históricos já vêm na ação

## Três passos para o seu primeiro token.
Passe de um único modelo para a orquestração multi-modelo em três passos, sem reescrever o código de negócio. Qualquer SDK (OpenAI / Anthropic / Gemini / DashScope) funciona.
### Implante o gateway
Início com um clique no Docker, ou implantação com Kubernetes Helm no seu ambiente privado.
### Configure as chaves
Modo BYOK: informe as chaves de API dos provedores que você já usa, os dados ficam no local e nunca são persistidos.
### Troque o endpoint
Aponte o base_url do SDK OpenAI para o GateLLM e chame todos os modelos com uma interface unificada.
```
# Just one line change: point base_url to GateLLM
from openai import OpenAI

client = OpenAI(
    base_url="https://your-gateway.gatellm.io/v1",
    api_key="your-gatellm-api-key"
)

# Existing code unchanged, call any model
response = client.chat.completions.create(
    model="claude-opus-5",  # or claude-sonnet-5, gpt-6-astra, deepseek-flash...
    messages=[{"role": "user", "content": "Hello"}]
)
```
## Ou entregue ao seu agente

Instale e configure o gateway GateLLM. Primeiro faça o curl do Markdown bruto deste guia de instalação, leia-o do início ao fim e então siga cada passo na ordem (os passos têm dependências — por exemplo, um grupo de chaves precisa existir antes de uma chave de acesso; não pule etapas):

curl -fsSL https://docs.gatellm.io/en/quickstart/docker-single-node.md

O agente precisa de uma coisa sua: a chave de API do provedor upstream. Ele gera o resto, configura tudo pela API do Console — sem navegador — e termina quando a primeira requisição retorna uma conclusão.

## Ou execute você mesmo

```bash
docker run -d \
  --name gatellm \
  -p 7890:7890 \
  -e CONSOLE_PASSWORD=change-me-on-first-login \
  -e ENCRYPTION_KEY=REPLACE_WITH_YOUR_ENCRYPTION_KEY \
  -e CONSOLE_SECRET_KEY=REPLACE_WITH_YOUR_CONSOLE_SECRET_KEY \
  -e STORAGE_MODE=sqlite \
  -v gatellm-data:/var/lib/protoflux \
  ghcr.io/gatellm-io/gatellm:latest
```

Substitua os três valores de exemplo antes de executar — o guia explica o que é cada um e por que deixá-los como estão é inseguro.

## Use o SDK que você já tem. Mude uma linha.
Os mesmos quatro protocolos nos dois lados. Converta qualquer um para qualquer outro sem código de cola, em chat, imagem, fala, vídeo, voz em tempo real, embedding e rerank.
### Todas as modalidades
- chat
- imagem
- fala
- vídeo
- voz em tempo real
- embedding
- rerank

- Entrada nativa: os SDKs OpenAI / Anthropic / Gemini / DashScope se conectam diretamente, sem alteração além do base_url
- Saída nativa: roteia para qualquer provedor no protocolo nativo dele, não um envelope OpenAI unificado retraduzido
- Conversão qualquer-para-qualquer: entrada A → saída B sem atrito (por exemplo, chamada do SDK Anthropic → roteada para um modelo nativo DashScope, convertida para o protocolo DashScope)
- Todas as modalidades + embedding/rerank: chat / imagem / fala / vídeo / voz em tempo real, além dos protocolos de embedding e rerank unificados
- Mais forte do que "compatível com OpenAI": synthorai e outros oferecem três protocolos de entrada unificados em uma superfície OpenAI; o GateLLM oferece quatro de entrada + quatro de saída, qualquer-para-qualquer
- Superfície de protocolos de saída mais ampla: além das quatro grandes famílias de protocolo, 15 formatos de protocolo upstream no total (incluindo AWS Bedrock Converse / Invoke, Realtime e passthrough) — modelos empresariais no Bedrock e modelos auto-hospedados entram em um único gateway
- Sessões de voz em tempo real (/v1/realtime, openai_realtime + dashscope_realtime) medidas por turno no mesmo pipeline de estatísticas / cobrança / logs do HTTP

## Funciona com o SDK que você já tem
Aponte qualquer SDK ou framework para o gateway com uma linha. OpenAI, Anthropic, Gemini e DashScope se conectam nativamente; LangChain, LlamaIndex, CrewAI, Vercel AI SDK e mais de 30 outros, pela mesma troca de base_url.
### Aponte o base_url para o gateway
Padrão https://your-gateway.gatellm.io — incluir ou não /v1 depende do SDK (cada exemplo traz o valor exato).
### Troque por uma chave de acesso do gateway
Não é uma chave upstream sk-… — a mesma chave de acesso é montada no cabeçalho que o seu SDK espera.
### Use o nome de modelo do gateway
Aquele que você configurou no console — não o nome oficial do fornecedor.
```
# base_url convention differs by SDK — match the one you're using
from openai import OpenAI
OpenAI(base_url="https://your-gateway.gatellm.io/v1")        # OpenAI SDK: /v1

import anthropic
anthropic.Anthropic(base_url="https://your-gateway.gatellm.io")  # Anthropic SDK: root (appends /v1/messages)

# Vercel AI SDK createAnthropic: baseURL ".../v1" (appends /messages) — the reverse
# LangChain ChatOpenAI: base_url="https://your-gateway.gatellm.io/v1"
```
### `Authorization: Bearer <key>`
- SDK / framework: OpenAI · DashScope · genérico
- Prefixo Bearer não diferencia maiúsculas de minúsculas

### `x-api-key: <key>`
- SDK / framework: SDK Anthropic
- Authorization também é aceito

### `x-goog-api-key: <key>`
- SDK / framework: SDK Gemini
- Authorization também é aceito

### SDKs oficiais dos fornecedores
SDKs OpenAI / Anthropic / Google se conectam nativamente — só o base_url muda

### DashScope nativo
Texto, imagem, vídeo assíncrono, embedding e rerank por um único endpoint

### SDKs e gateways unificados
Vercel AI SDK, LiteLLM, Portkey, Semantic Kernel, Spring AI

### Frameworks de orquestração
LangChain, LlamaIndex, CrewAI, AutoGen, DSPy, Haystack

### SDKs de agentes
OpenAI Agents, Claude Agent, Pydantic AI, ADK, Mastra

### Tempo real e áudio
Voz em tempo real via WebSocket + ASR / TTS openai_audio

### Local / auto-hospedado
Ollama, vLLM, llama.cpp como upstreams — mantenha qualquer SDK de cliente

### O nome do modelo precisa corresponder à configuração do gateway
Não é o nome oficial do fornecedor nem o ID do modelo upstream — é o nome que você deu no console. Nome errado → 404 model_not_found.

### Incluir /v1 no base_url varia conforme o SDK
O SDK OpenAI usa /v1; o SDK Anthropic usa a raiz (ele mesmo acrescenta /v1/messages); o createAnthropic do Vercel AI SDK usa /v1 (ele acrescenta /messages). Errar isso adiciona ou remove um segmento de caminho.

### Campos são traduzidos e restringidos entre protocolos
Um max_tokens pode virar max_output_tokens com limite inferior (por exemplo, ≥16) quando o upstream é um modelo de protocolo Responses — valor pequeno demais → 400.

### Blocos de raciocínio são envolvidos pelo gateway
Conteúdo e assinaturas de raciocínio do Claude / Gemini passam adiante ou são removidos — pegue o elemento com type == "text" do array content, não presuma que content[0] é texto.

### O SDK OpenAI Agents usa /v1/responses por padrão
Ele chama a API Responses, não Chat Completions. Se o upstream for openai (Chat), troque explicitamente com OpenAIChatCompletionsModel; se for openai_response, um nome de modelo em string funciona como está.

### O LlamaIndex valida o nome do modelo contra uma allowlist
A classe OpenAI só aceita famílias que reconhece e rejeita nomes personalizados do gateway — use OpenAILike (Python) ou declare as informações do modelo explicitamente.

### O CrewAI é movido pelo LiteLLM nos bastidores
base_url não é um parâmetro do framework — é a variável de ambiente OPENAI_API_BASE, e o modelo precisa do prefixo openai/.

### O AutoGen exige model_info explícito
Nomes de modelo desconhecidos geram erro na lista padrão — declare model_info explicitamente para contornar a verificação.

### O SDK Google GenAI aponta para a raiz
O base_url vai por http_options.base_url (sem /v1) e a chave é montada no cabeçalho x-goog-api-key.

## Aponte qualquer agente de código de IA para o gateway
```
# Every agent is one base_url + one access key away
export ANTHROPIC_BASE_URL="https://your-gateway.gatellm.io"   # Anthropic agents: root (no /v1)
export ANTHROPIC_API_KEY="<gateway access key>"

export OPENAI_API_BASE="https://your-gateway.gatellm.io/v1"   # OpenAI-compatible agents: /v1
export OPENAI_API_KEY="<gateway access key>"

# Codex CLI (~/.codex/config.toml) speaks the Responses protocol
# [model_providers.gatellm]
# base_url = "https://your-gateway.gatellm.io/v1"
# wire_api = "responses"
```
### Agentes de terminal
Claude Code, Codex CLI, Gemini CLI, OpenClaw, opencode, Crush, Droid, Goose, Aider, Qwen Code, OpenHands, Kimi Code, Plandex, SWE-agent, Grok Build, Mistral Vibe, MiMo Code, ForgeCode, Codebuff

### IDEs e extensões
Cline, Roo Code, Kilo Code, Continue, Zed, Cursor, Windsurf, GitHub Copilot (BYOK)

### Plataformas gerenciadas
Warp (somente chaves BYOK), Amazon Q Developer CLI, Devin — endpoint fixo ou não substituível

### O harness fixa o próprio ID de modelo
O Claude Code envia o padrão configurado nele (por exemplo, claude-opus-5 ou claude-sonnet-5) — não o nome do seu gateway. Ou dê ao modelo do gateway exatamente o nome que o harness pede, ou defina a variável de ambiente de modelo dele (por exemplo, ANTHROPIC_MODEL) com o nome do seu gateway. Incompatibilidade → 404 model_not_found na primeira mensagem.

### Harnesses de protocolo Anthropic usam a raiz, não /v1
A base URL de clientes no estilo Anthropic aponta para a raiz do gateway (sem /v1) — o próprio cliente acrescenta /v1/messages. Adicionar /v1 aqui duplica o segmento de caminho.

### Provedores personalizados do Codex exigem wire_api="responses"
O Codex CLI requer wire_api = "responses" para um bloco personalizado [model_providers.*]. O gateway implementa /v1/responses nativamente — aponte o base_url para ele e defina env_key com uma chave de acesso do gateway.

### Harnesses baseados em LiteLLM querem o prefixo openai/ no modelo
Aider, OpenHands e SWE-agent rodam sobre o LiteLLM: defina OPENAI_API_BASE com o gateway e dê ao modelo um prefixo openai/ (por exemplo, openai/gateway-model-name) para que o LiteLLM o roteie como endpoint compatível com OpenAI.

### O padrão é OAuth de assinatura, não a sua chave
Codex, Gemini CLI e Qwen Code usam por padrão o login OAuth / assinatura do fornecedor. Para rotear pelo gateway você precisa mudar para autenticação por chave de API (definir a chave + a base URL explicitamente) — caso contrário o agente contorna o gateway por completo.

### IDEs inferem suporte a ferramentas/visão pelo ID do modelo
Cline / Roo / Kilo e outros decidem a capacidade de chamada de ferramentas e de visão pelo nome do modelo. Um nome personalizado do gateway pode desativar a chamada de funções — se as chamadas de ferramenta falharem, verifique as regras de detecção de capacidade do cliente ou dê ao modelo um nome que corresponda a uma família conhecida.

### Inferência longa adiciona :keep-alive e _gateway_warning
Durante inferências upstream longas, o gateway emite linhas de comentário SSE :keep-alive (inofensivas — ignore linhas que começam com :), e em uma quebra no meio do stream insere um campo _gateway_warning em vez de gerar erro, para que harnesses como o Claude Code não abortem toda a conversa.

### Modo automático do Claude Code: decida quem responde ao veredito de segurança
No modo automático, o Claude Code aguarda um veredito do servidor (um campo safeguards na requisição) antes de uma ação potencialmente perigosa. Quando o upstream é o Anthropic oficial, o veredito é produzido dentro da mesma requisição e o gateway o repassa intacto. Quando o upstream é um terceiro que ignora o campo, o gateway responde em seu lugar — e o padrão de fábrica (allow_all) libera toda ação, o que é mais permissivo do que deixar a chamada seguir. Devolva uma rota ao próprio upstream escrevendo "anthropic_server_safeguards": "upstream" no extra_config desse upstream; a configuração no console é exclusiva de admin.

## Normalização de capacidades: tornando possível a combinação entre fornecedores
A combinação de modelos de fornecedores diferentes se apoia na camada de normalização de capacidades, que unifica sete pontos de acoplamento para que trocar de modelo nunca signifique reescrever código de cola.
### Normalização de chamada de ferramentas
OpenAI / Anthropic / Gemini / modelos chineses têm esquemas de chamada de ferramentas diferentes. Unificamos tudo na base: escreva o código uma vez e chame todos os modelos.
### Compatibilidade de saída estruturada
Cada provedor usa protocolos diferentes (schema JSON estrito, json_mode, tool_use). Unificamos em uma interface consistente.
### Unificação do cache de prompt
cache_control do Anthropic, cache automático do OpenAI, contexto do Gemini — cada um tem um mecanismo diferente. Oferecemos uma estratégia de cache unificada.
### Adaptação de tokens de raciocínio
Os formatos de saída de o1 / raciocínio do Claude / DeepSeek R1 diferem. Adaptamos ao protocolo de tokens de raciocínio de cada provedor.
### Suporte a formatos multimodais
Protocolos de visão / áudio / upload de arquivos diferem entre provedores. Unificamos os formatos de entrada multimodal.
### Abstração do modelo de cobrança
A estrutura de preços de cada provedor é diferente. Abstraímos para uma interface unificada de acompanhamento de custos.
### Normalização da semântica de erros
Códigos e corpos de erro de cada fornecedor diferem. Normalizamos para um corpo de erro uniforme, com z-request-id correlacionando cada requisição de ponta a ponta.
### Fluxo de dados: fica no local, nunca é persistido
No modo BYOK, as chaves de API ficam armazenadas apenas na memória do gateway, nunca são persistidas nem transmitidas. As requisições passam pelo gateway diretamente para as APIs oficiais dos provedores; os dados nunca saem da sua rede privada.
Controles SOC 2 alinhados

Controles ISO 27001 alinhados

GDPR

## Por que ~1/7 do custo?
Considere uma empresa que processa 1 bilhão de tokens por dia: mesma carga de trabalho — compare a conta de "primeira linha de ponta a ponta" com "primeira linha planeja, modelos abertos executam".
## Três fontes de economia:
- BYOK sem margem sobre tokens — você paga aos provedores as tarifas padrão, o GateLLM não fica com nenhuma comissão intermediária (agregadores normalmente acrescentam taxas de plataforma e de pagamento sobre o preço de lista);
- Composição — modelos SOTA abertos (GLM / Qwen / DeepSeek) executam a maior parte (classificação, extração, tradução), modelos fechados de primeira linha (como o Claude Opus) só para planejamento e raciocínio difícil;
- Cache de prompt — chamadas de alta frequência acertam o cache, o preço unitário cai 50%–90%.
Os números são modelos ilustrativos baseados em preços públicos; a economia real depende do cenário de negócio e das proporções da mistura. A licença Pro de $400/mês (instância única de 2GB) está incluída no plano GateLLM.

## Uso que você enxerga, custo que você fecha, orçamentos que você segura
O Token Ops rastreia quem usa o quê; o Token FinOps transforma tokens em dinheiro cobrável e limitado. Um único plano de controle torna o gasto com IA tão operável quanto o gasto com nuvem.
### Observabilidade de uso e custo
Detalhe cada chamada por modelo, chave de acesso e grupo de chaves, com tokens de entrada / saída / acerto de cache medidos separadamente em granularidade de 1 minuto.
- Agrupado por modelo / chave / grupo de chaves
- Entrada, saída e acerto de cache medidos separadamente
- Séries temporais de 24h / 7d / 30d / personalizadas
### Admissão de clientes e trilha de auditoria
Só clientes que você aprovou alcançam o gateway — permita, limite ou negue por User-Agent. Cada chamada deixa um registro auditável para governança de endpoints e evidências de conformidade.
- Controle de acesso de clientes (política de User-Agent)
- Registros de chamadas com retenção de logs (Pro e acima)
- Integração com auditoria / DLP (Enterprise)
### API de gerenciamento (controle programático)
Gerencie o gateway via API: crie / revogue chaves de API, defina cotas e orçamentos, consulte uso e custo, exporte logs de auditoria — conecte à sua operação interna e aos sistemas de cobrança.
- Criação / revogação programática de chaves de API
- Cotas e orçamentos via API
- API de consulta de uso e custo
- Exportação de logs de auditoria
### Sua própria tabela de preços e snapshots
Informe manualmente o preço privado que você negociou e ele passa a ser autoritativo — atualizações do sistema nunca o sobrescrevem. Cada preço tem uma janela de vigência: agende reduções com antecedência, e edições nunca reescrevem custos históricos.
- Preço privado fixado tem precedência sobre o automático, nunca é sobrescrito
- Snapshots entram em vigor por janela de tempo
- Preencha o histórico / agende reduções de preço
- Modos de cobrança por token · por chamada · por segundo
### Alocação por tags e repasse de custos
Marque chaves e grupos de chaves com tags e agregue uso e custo por tag para levar o gasto com tokens ao centro de custo certo. A exportação em Excel divide o extrato por modelo × chave para showback ou chargeback interno.
- Tags livres em chaves / grupos de chaves
- Agregação de uso e custo por tag
- Exportação Excel com 6 planilhas (incluindo chave × modelo)
- Pronto para showback / chargeback interno
### Cotas e limites de custo
Defina tetos de gasto diários e mensais por chave — avaliados de forma independente no dia e no mês do calendário UTC, bloqueados no momento em que qualquer um deles estoura. As cotas herdam chave → grupo → global, adotando a mais ampla entre os grupos.
- Tetos diário / mensal, avaliados de forma independente
- Herança chave → grupo → global
- 429 quota_exceeded, Retry-After no diário

## GateLLM vs LiteLLM
Uma comparação verificada na fonte. Só o GateLLM oferece vários mecanismos que o LiteLLM não tem; ambos compartilham uma base consolidada; algumas coisas diferem em natureza. Decida pelas duas camadas principais, não pelo ruído de marketing.
### Só o GateLLM faz isto
Mecanismos que o LiteLLM não tem — o "como funciona" em uma linha fica abaixo de cada capacidade.
| Capacidade | GateLLM | LiteLLM |
| --- | --- | --- |
| Troca condicional de modelo | ✓ | ✗ |
| Mistura de modelos / SDKs entre protocolos | ✓ | ✗ |
| Commit de configuração em transação única | ✓ | ✗ |
| Bloqueio rígido por cota de custo | ✓ | ✗ |
| Cobrança à prova de falhas | ✓ | ✗ |
| Pool de chaves upstream e vínculo fixo | ✓ | ✗ |
| Três modos de cobrança + várias moedas | ✓ | ✗ |
| Login de credenciais SSO no upstream | ✓ | ✗ |
| Registro de metadados de capacidade | ✓ | ✗ |
| Branch de release LTS | ✓ | ✗ |

- **Troca condicional de modelo**: Regras declarativas switch-route + detecção integrada de modo de plano + scripts context.useModel() — zero alteração no cliente. O LiteLLM precisa de callbacks Python personalizados.
- **Mistura de modelos / SDKs entre protocolos**: Entradas nativas qualquer-para-qualquer — chame GPT pelo SDK Anthropic, DeepSeek pelo SDK Gemini. O LiteLLM é centrado em OpenAI; os caminhos inversos passam por camadas de compatibilidade.
- **Commit de configuração em transação única**: Preparar → visualizar o conjunto completo de conflitos → commit atômico; o lote inteiro é revertido em qualquer conflito.
- **Bloqueio rígido por cota de custo**: Ciclos diário / mensal retornam 429 quota_exceeded no momento em que o gasto estoura. O LiteLLM só envia alertas de orçamento.
- **Cobrança à prova de falhas**: Pré-débito → fechamento → estorno com um extrato de operações em andamento — correto mesmo com falhas do processo.
- **Pool de chaves upstream e vínculo fixo**: Hash FNV-1a ponderado fixa cada chamador em uma chave e passa para a próxima não tentada; weight=0 fica em espera.
- **Três modos de cobrança + várias moedas**: Token / por chamada / por duração, USD/CNY/EUR/JPY/GBP, dimensões personalizadas. O LiteLLM só faz acompanhamento baseado em tokens.
- **Login de credenciais SSO no upstream**: Integra fornecedores sem chaves estáticas (por exemplo, Kiro). O LiteLLM aceita apenas chaves de API estáticas.
- **Registro de metadados de capacidade**: Alimenta injeção e degradação automáticas; mudanças de capacidade de novos modelos não exigem alteração de código.
- **Branch de release LTS**: N-1 + branch LTS (veja /lifecycle). O LiteLLM suporta apenas as 4 últimas linhas menores.

### Ambos fazem bem
Uma base consolidada — qualquer um dos gateways cobre esta camada. A decisão está nas camadas acima e abaixo.
| Capacidade | GateLLM | LiteLLM |
| --- | --- | --- |
| Roteamento de API · fallback · balanceamento de carga | ✓ | ✓ |
| BYOK, sem margem sobre tokens | ✓ | ✓ |
| Totalmente auto-hospedado, dados ficam no local | ✓ | ✓ |
| Normalização de chamada de ferramentas entre fornecedores | ✓ | ✓ |
| Normalização de saída estruturada (JSON Schema) | ✓ | ✓ |
| Adaptação de tokens de raciocínio / pensamento | ✓ | ✓ |
| Cache de prompt entre modelos | ✓ | ✓ |
| Injeção de busca na web | ✓ | ✓ |
| Gateway MCP (agregação de ferramentas) | ✓ | ✓ |
| Console visual para configuração | ✓ | ✓ |
| Logs de auditoria e medição de uso / custo | ✓ | ✓ |

### Diferente em natureza
Nem melhor nem pior — mecanismos e empacotamento diferentes que você deve pesar diretamente.
| Capacidade | GateLLM | LiteLLM |
| --- | --- | --- |
| Runtime | Binário Rust único · sem pausas de GC | Processo Python + pilha de dependências |
| Superfície de tradução de protocolos | 15 formatos de protocolo; as quatro famílias de protocolo de chat (OpenAI / Anthropic / Gemini / DashScope) traduzem qualquer-para-qualquer, o resto conforme a matriz de interoperabilidade | Envelope centrado em OpenAI + endpoints compatíveis |
| Entradas de protocolo nativas | /v1/messages + count_tokens, generateContent do Gemini, CRUD de /v1beta/cachedContents, /v1/realtime, /mcp — um gateway atende todos os SDKs nativamente | Endpoint compatível com OpenAI (mais variantes compatíveis) |
| Profundidade do cache de prompt | Injeta automaticamente pontos de quebra de cache em chamadas de protocolo OpenAI + mapeamento entre protocolos + deduplicação de cachedContent do Google | Repassa cache_control e normaliza o uso |
| Padrões de privacidade de logs | Logs de requisição desligados por padrão · corpos armazenados são redigidos em toda superfície de saída, revelação bruta só para admin e auditada · retenção padrão de 7 dias | Log de requisição/resposta ligado; redação via guardrails |
| Modo de configuração | Totalmente no console — sem YAML, mudanças aplicadas ao vivo | Centrado em config.yaml |
| Empacotamento de SSO e SCIM empresarial | OIDC + SAML 2.0 + SCIM incluídos na licença fixa por instância, sem cobrança por assento | OSS limita o SSO a 5 usuários; SCIM exige o nível Enterprise com preço por uso |
| Licenciamento | Fixo por instância / memória, sem assentos, sem margem sobre tokens | OSS gratuito; Enterprise tem preço por uso |
| SLA de suporte | Suporte prioritário incluído na licença fixa | O nível padrão não tem compromisso de tempo de resposta; SLA 24/7 é add-on pago (Sev0 1h / Sev1 6h) |
| Superfície de endpoints | Endpoints principais de chat / tempo real / MCP | Acrescenta /batches, /files, /fine_tuning, /vector_stores, /videos, /containers |
| Ecossistema de terceiros | Logs / Prometheus / OTel integrados — saída em protocolo padrão, sem aprisionamento a um fornecedor; detecção de segredos e PII integrada ao gateway, sem motor de terceiros | Gerenciadores de segredos AWS KMS / Vault / CyberArk; guardrails de PII do Presidio; observabilidade Langfuse / Langsmith / Arize |

Verificado contra a documentação oficial de cada produto em 2026-09-04 (docs.litellm.ai / docs.gatellm.io). Algumas capacidades do LiteLLM exigem licença Enterprise; os detalhes podem mudar — confira as fontes antes da compra.

## Segredos e PII são detectados na entrada — você decide o que acontece depois.
Um motor de regras determinísticas inspeciona cada requisição de modelo em busca de formatos de credenciais e PII, e registra o que encontrou sem registrar o segredo em si. As regras integradas vêm desligadas e em modo de observação; você as arma e escolhe registrar, mascarar ou bloquear por escopo. Nenhum modelo fica no caminho de detecção.
### Detecção determinística, sem modelo no caminho
Determinística por construção: primeiro, sondas literais; depois, regras de regex que exigem palavras de contexto; por fim, validadores de checksum — Luhn para números de cartão, mod-97 para IBAN, o checksum de documento nacional, blocos de chave privada PEM e OpenSSH, IPv4.
- Formatos de credenciais: chaves de API de provedores de modelos, chaves de acesso de nuvem, tokens do GitHub e GitLab, JWTs, chaves privadas PEM e OpenSSH, tokens do Slack
- Classes de PII: celulares da China continental, documentos nacionais de residente, números de cartão bancário, IBANs, endereços de e-mail, endereços IPv4
- Conversas com vários turnos verificam apenas o que é novo — uma cadeia de hashes de cursor impede que uma sessão longa verifique de novo um texto já liberado
### Mascaramento que o cliente consegue atravessar; bloqueio que não vaza nada
No modo mascarar, o modelo upstream recebe placeholders numerados e o seu cliente recebe os valores reais restaurados — incluindo restauração por quadro SSE durante o streaming. No modo bloquear, a recusa carrega a categoria da regra e um ID de requisição, nunca o texto correspondido.
- O upstream vê placeholders; quem é dono dos dados vê os próprios valores de volta
- Colagens longas não ficam isentas — strings grandes demais são gravadas em disco e verificadas de volta em janelas de tamanho fixo, mantendo a memória estável independentemente do tamanho da carga
- A allowlist compara por valor, nunca por caminho: aprovar uma chave de teste não isenta silenciosamente um campo inteiro
### Corpos de log: armazenados como recebidos, redigidos em toda saída
A persistência de logs de requisição vem desligada na imagem distribuída. Ligue-a e os corpos são armazenados como recebidos e então redigidos em toda superfície de saída — a API do Console redige por padrão, a saída SSE e de terminal é sempre redigida, e uma falha de redação fecha a resposta em vez de vazar por ela.
- Revelar conteúdo bruto é um ato explícito: papel de admin mais um sinalizador de revelação explícito, auditado e contabilizado
- A redação cobre chaves sensíveis do corpo, parâmetros sensíveis de consulta e URL, cabeçalhos estáticos e personalizados de esquema de autenticação, e valores de token bearer com revelação parcial
- Um achado guarda um trecho mascarado com contexto ao redor limitado, nunca o texto correspondido; os achados compartilham a janela de retenção de logs, 7 dias por padrão
Desligado por padrão, de propósito
O pacote de regras integrado vem desativado, e a ação de toda regra integrada é registrar. Essa é a implantação segura, não uma lacuna: veja o que teria acontecido no seu tráfego real, ajuste a allowlist contra seus próprios falsos positivos e então arme mascarar ou bloquear onde importa. A política tem escopo global, por grupo de chaves de acesso ou por chave de acesso, e as regras são recarregadas a quente.
#### log
Observar. Os achados chegam ao console com trechos mascarados; a requisição em si não é tocada.
#### mask
Aplicar, de forma reversível. O upstream vê placeholders; seu cliente ainda recebe o valor real.
#### block
Recusar. A requisição é rejeitada com a categoria da regra e um ID de requisição — nunca o texto correspondido.
### O que é, e o que não é
#### O que é
- Roda dentro do seu próprio processo de gateway, no caminho da requisição de modelo, com escopo global / por grupo de chaves de acesso / por chave de acesso
- Uma página dedicada no console: visão de achados para papéis admin e monitor, visão de regras para admin, um interruptor de liga/desliga com pré-verificação de orçamento de memória, recarga a quente e entradas de auditoria
- Um endpoint de pré-visualização em modo de teste, para que uma regra possa ser testada com uma amostra antes de ser armada
- Cada achado rastreia até um nome de regra, categoria, severidade, ação tomada, contagem de correspondências, modelo e nome da chave de acesso

#### O que não é
- Sem detecção de conteúdo de resposta — o trecho de resposta apenas restaura placeholders
- Sem ML, sem detecção de jailbreak ou injeção de prompt e sem API de moderação: as regras são determinísticas
- Sem reauditoria offline — conteúdo que não foi verificado no momento da requisição não é verificado depois
- Não é um conjunto de DLP: sem cobertura de endpoint, e-mail ou outros canais de saída
- Sem detectores de passaporte, SSN, nome ou endereço, e lacunas residuais conhecidas estão documentadas — mídia codificada em base64 é ignorada, e um placeholder dividido entre dois quadros de stream passa inalterado

## O que você realmente recebe.
As três coisas que importam para o time de compras, resolvidas antes do preço: um DPA que o jurídico pode assinar, uma conta que não dispara e prompts que nunca chegam até nós.
### Um DPA que seu jurídico pode assinar
Pronto para GDPR e CCPA, com um DPA que o seu time jurídico pode realmente assinar. Auto-hospedado — os dados nunca saem do seu perímetro — com SSO empresarial (OIDC / SAML 2.0) e provisionamento SCIM 2.0 incluídos.
- GDPR
- CCPA
- DPA
- SSO
- SCIM
- Trilha de auditoria
### Uma conta que não dispara
BYOK: pague aos provedores as tarifas padrão — sem margem sobre tokens, sem cobrança por assento. Tetos rígidos de cota por chave e por projeto impedem que um script descontrolado ultrapasse seu orçamento.
- Sem margem sobre tokens
- 0 cobrança por assento
- Cache de prompt
- Tetos rígidos de cota
- Reembolso em 30 dias
### Seus prompts nunca chegam até nós
Totalmente auto-hospedado — seus prompts e conclusões nunca entram nos nossos sistemas. As chaves BYOK vivem apenas na memória do gateway; as requisições vão direto para as APIs dos provedores, sem nunca sair da sua rede.
- Dados ficam no local
- Chaves nunca persistidas
- TLS 1.3
- Admissão de clientes
- Modelos escolhidos por você

## Totalmente auto-hospedado · Instância única de 2GB · Nunca cobramos margem sobre tokens
BYOK (traga suas próprias chaves) — você paga aos provedores as tarifas padrão. Licenciamos uma instância única de 2GB, nunca por assentos nem com margem sobre tokens. Mais memória ou várias instâncias passam pelo Enterprise.
O núcleo é construído em Rust. No nível de encaminhamento do gateway, cada 1GB de memória sustenta aproximadamente 100M tokens por minuto (TPM) e ~500 requisições por minuto (RPM), atendendo com folga ~100 usuários típicos. São números de referência: a vazão real é limitada pelos limites de taxa e pela complexidade das requisições dos seus próprios provedores, e não é um compromisso de SLA.
Incluído em todos os planos: BYOK sem margem sobre tokens · roteamento para mais de 100 provedores · controle de acesso de clientes · cache de prompt · cotas de custo
### Free
$0
Totalmente auto-hospedado · Licença única
Instância única de 512MB, sem retenção de logs — ideal para avaliação e PoCs, não para tráfego de produção.
- Roteamento para mais de 100 LLMs · Fallback · Balanceamento de carga
- Mistura de modelos entre fornecedores · rebaixamento em agente (plano travado / rebaixamento automático fora do plano)
- Controle de acesso de clientes (política de User-Agent)
- Cache de prompt
- BYOK (traga suas próprias chaves, sem margem)
- Teto de memória de 512MB · SQLite · instância única
- Revisão de código via GitHub Actions usando seu próprio gateway
- Sem retenção de logs
### Pro
$400
Teto fixo de 2GB, sem complemento. Para vários nós, conformidade (Auditoria/DLP) ou a API de Gerenciamento, vá para o Enterprise.
- Todos os recursos do Free
- 2GB de memória · instância única (teto fixo, sem complemento)
- Retenção de logs
- SSO empresarial (OIDC: Azure AD / Okta / genérico, além de SAML 2.0 + SCIM)
- PostgreSQL · 2GB de memória
- Suporte por e-mail / ticket
Reembolso de 100% em até 30 dias se não ficar satisfeito
### Enterprise
a partir de $400/GB
Por capacidade de memória · Cobrado anualmente · Reembolso em 30 dias
- Todos os recursos do Pro
- Cobrança por capacidade (nós × memória, $400/GB/mês fixo)
- Implantação multi-nó / em cluster
- Revisão de código via GitHub Actions usando seu próprio gateway
- Add-in do Microsoft 365 (Excel/Word/PPT/Outlook, add-on pago)
- Retenção estendida de logs
- Resposta de suporte prioritária
- Conformidade (Auditoria / DLP)
- API de Gerenciamento (chave de API programática · cota · consulta de uso · exportação de auditoria)
Precisa de mais capacidade ou de uma configuração personalizada?
## Comparação de recursos

| Capacidade | Free | Pro | Enterprise |
| --- | --- | --- | --- |
| Roteamento multi-modelo · Fallback · Balanceamento de carga | ✓ | ✓ | ✓ |
| Mistura de modelos entre fornecedores (planejamento/execução por fornecedor) | ✓ | ✓ | ✓ |
| Rebaixamento de modelo em agente (plano travado / rebaixamento automático fora do plano) | ✓ | ✓ | ✓ |
| Cache de prompt | ✓ | ✓ | ✓ |
| BYOK (traga suas próprias chaves, sem margem) | ✓ | ✓ | ✓ |
| Camada de memória | 512MB | 2GB (fixo) | Personalizado |
| Armazenamento / banco de dados | SQLite (instância única) | PostgreSQL · 2GB | PostgreSQL + cluster Redis |
| Escala de implantação | 1 instância | 1 instância · 2GB | Multi-nó / cluster |
| Vazão por GB (referência) | — | 2GB ≈ 200M TPM / 1.000 RPM | ≈ 100M TPM / 500 RPM por GB |
| Retenção de logs | Nenhuma | Retidos | Retenção estendida |
| SSO (OIDC / SAML 2.0) | — | ✓ | ✓ |
| Provisionamento automático SCIM 2.0 | — | ✓ | ✓ |
| Conformidade (Auditoria / DLP) | — | — | ✓ |
| API de Gerenciamento (chave programática · cota · uso · auditoria) | — | — | ✓ |
| Tabela de preços própria / snapshots de preço (incluindo preços privados) | ✓ | ✓ | ✓ |
| Cotas de custo (diárias / mensais, herança em três níveis) | ✓ | ✓ | ✓ |
| Resposta de suporte | Comunidade | E-mail / ticket | Resposta prioritária |
| Política de modelos ciente do modo (planejar/executar, aplicável) | ✓ | ✓ | ✓ |
| Controle de acesso de clientes (política de User-Agent) | ✓ | ✓ | ✓ |
| Revisão de código no GitHub Actions (pelo seu gateway) | ✓ | ✓ | ✓ |
| Add-in Microsoft 365 (Excel/Word/PPT/Outlook, auto-hospedado) | — | Add-on | Add-on |
| Bloqueio por rótulo de sensibilidade do Purview (addin.access / file.upload) | — | — | ✓ |

## FAQ
### Quanta latência um gateway de IA adiciona?

Um gateway SaaS adiciona um salto extra para fora da sua rede. O GateLLM é auto-hospedado dentro do seu VPC; o salto extra até a API do fornecedor é comunicação local entre processos — sobrecarga inferior a um milissegundo, com impacto desprezível no tempo até o primeiro token em streaming.
### O que acontece se um provedor falhar ou atingir o limite de taxa?

Chamar diretamente um único provedor é um ponto único de falha. O GateLLM suporta fallback entre provedores — quando o primário retorna 5xx ou dá timeout, o tráfego vai para um provedor reserva sem alteração de código. Ele também agrupa várias chaves por upstream: um hash determinístico fixa cada chamador em uma chave, e quando uma chave falha o gateway tenta a próxima chave ainda não utilizada.
### Eu realmente preciso de um gateway?

Critério honesto: um único provedor, uma única equipe, nenhuma exigência de conformidade, gasto mensal administrável — chame as APIs diretamente; você não precisa de um gateway. Um gateway começa a se pagar quando você precisa de failover entre vários provedores, atribuição de custos por equipe, conformidade / residência de dados ou visibilidade em tempo real de gastos descontrolados.
### Como o GateLLM ganha dinheiro no modo BYOK?

Licenciamos uma instância única com 2GB de memória (Pro $400/mês, 20% de desconto no anual a $3,840/ano), sem margem sobre tokens e sem cobrança por assento. Você paga aos provedores as tarifas padrão e o GateLLM não fica com nenhuma comissão intermediária.
### Minhas chaves de API e meus dados saem da minha rede?

Não. No modo BYOK, as chaves de API ficam armazenadas apenas na memória do gateway, nunca são persistidas nem transmitidas. As requisições passam pelo gateway diretamente para as APIs oficiais dos provedores — os dados nunca saem da sua rede privada.
### Como sei que o gateway serve o modelo real, e não um substituto mais barato?

Com um agregador SaaS você só pode confiar na palavra dele. O GateLLM é BYOK e auto-hospedado: você usa suas próprias chaves e as requisições vão do seu gateway diretamente para o endpoint da API do fornecedor — a identidade do modelo é garantida pela própria API do fornecedor, sem nenhum salto substituível no meio.

## Comece a construir seus apps de IA multi-modelo
Totalmente auto-hospedado · Instância única de 2GB · Nunca cobramos margem sobre tokens.

## Relacionados
- [Preços](https://www.gatellm.io/pt-BR/pricing.md)
- [Calculadora de custos](https://www.gatellm.io/pt-BR/calculator.md)
- [Sobre](https://www.gatellm.io/pt-BR/about.md)
- [Agendar uma demonstração](https://www.gatellm.io/pt-BR/demo.md)
- [FAQ](https://www.gatellm.io/pt-BR/faq.md)
- [Comparar gateways de IA](https://www.gatellm.io/pt-BR/compare.md)
- [Comparar LiteLLM](https://www.gatellm.io/pt-BR/compare/litellm.md)
- [Comparar OpenRouter](https://www.gatellm.io/pt-BR/compare/openrouter.md)
- [Comparar Alibaba Cloud AI Gateway](https://www.gatellm.io/pt-BR/compare/alibaba-cloud.md)
- [Comparar Azure API Management](https://www.gatellm.io/pt-BR/compare/azure-apim.md)
- [Comparar Apigee](https://www.gatellm.io/pt-BR/compare/apigee.md)
- [Comparar Cloudflare AI Gateway](https://www.gatellm.io/pt-BR/compare/cloudflare.md)
- [Comparar Kong AI Gateway](https://www.gatellm.io/pt-BR/compare/kong.md)
- [Comparar Portkey](https://www.gatellm.io/pt-BR/compare/portkey.md)
- [LiteLLM vs Kong AI Gateway](https://www.gatellm.io/pt-BR/compare/litellm-vs-kong.md)
- [LiteLLM vs OpenRouter](https://www.gatellm.io/pt-BR/compare/litellm-vs-openrouter.md)
- [LiteLLM vs Portkey](https://www.gatellm.io/pt-BR/compare/litellm-vs-portkey.md)
- [Casos de uso](https://www.gatellm.io/pt-BR/use-cases.md)
- [Reduzir custo de LLM](https://www.gatellm.io/pt-BR/use-cases/reduce-cost.md)
- [Alta disponibilidade](https://www.gatellm.io/pt-BR/use-cases/high-availability.md)
- [Isolamento multilocatário](https://www.gatellm.io/pt-BR/use-cases/multi-tenant.md)
- [Conformidade e auditoria](https://www.gatellm.io/pt-BR/use-cases/compliance-audit.md)
- [Solução de problemas por sintoma](https://www.gatellm.io/pt-BR/use-cases/troubleshooting.md)
- [Stack de modelos multivendor](https://www.gatellm.io/pt-BR/use-cases/mixed-model-stack.md)
- [IA auto-hospedada dentro do Office](https://www.gatellm.io/pt-BR/use-cases/self-hosted-office-ai.md)
- [Visibilidade e atribuição do uso de tokens](https://www.gatellm.io/pt-BR/use-cases/token-ops.md)
- [Token FinOps: alocação e controle de custos de IA](https://www.gatellm.io/pt-BR/use-cases/token-finops.md)
- [Governança de ferramentas MCP](https://www.gatellm.io/pt-BR/use-cases/mcp-tool-governance.md)
- [Busca na web para todos os modelos](https://www.gatellm.io/pt-BR/use-cases/web-search-grounding.md)
- [Rotação e standby de múltiplas chaves](https://www.gatellm.io/pt-BR/use-cases/multi-key-pooling.md)
- [Controle de admissão de clientes](https://www.gatellm.io/pt-BR/use-cases/client-admission-control.md)
- [Aplicar política de uso de modelos](https://www.gatellm.io/pt-BR/use-cases/enforce-model-policy.md)
- [Sem escolha de modelo no cliente](https://www.gatellm.io/pt-BR/use-cases/automatic-model-tiering.md)
- [Um protocolo, qualquer modelo](https://www.gatellm.io/pt-BR/use-cases/one-protocol-any-model.md)
- [Suplemento Office / Microsoft 365](https://www.gatellm.io/pt-BR/office-addin.md)
- [Glossário](https://www.gatellm.io/pt-BR/glossary.md)
- [Catálogo de modelos](https://www.gatellm.io/pt-BR/models.md)
- [Integrações de SDK e frameworks](https://www.gatellm.io/pt-BR/integrations.md)
- [Agentes de código de IA e harnesses](https://www.gatellm.io/pt-BR/coding-agents.md)
- [Segurança e conformidade](https://www.gatellm.io/pt-BR/security.md)