LLM on-premise vs API é a escolha entre rodar um modelo de linguagem em infraestrutura que a empresa controla (servidor próprio, data center ou GPU dedicada na conta de nuvem dela) e consumir o modelo pronto, por chamada, na infraestrutura de um fornecedor. Na API, a empresa paga por token e não opera nada. No on-premise, paga a GPU e o time que a mantém, use o modelo muito ou pouco, e em troca ganha controle sobre onde o dado passa, qual versão do modelo responde e quanto cada chamada custa no limite.
Não existe vencedor geral. A API costuma ganhar no começo, com volume baixo ou irregular e quando a tarefa exige o modelo mais capaz do mercado. O on-premise passa a fazer sentido quando o volume é alto e estável, quando um modelo aberto menor resolve a tarefa com a qualidade necessária ou quando o dado não pode sair do perímetro da empresa. A maior parte das empresas que chega à produção acaba com as duas coisas, atrás de um mesmo gateway.
Este guia explica o que muda entre os dois caminhos, mostra como montar a conta de ponto de equilíbrio com preços publicados, compara qualidade, latência e operação, e traz um roteiro para decidir caso a caso. No fim, há perguntas frequentes sobre o tema.
O que muda entre LLM on-premise e API
A diferença não é só onde o modelo roda. Cada caminho muda quem responde pela disponibilidade, como o custo se comporta e quem decide quando o modelo muda.
API: o modelo como serviço
Na API, a aplicação manda o prompt para o fornecedor e recebe a resposta. O fornecedor cuida de GPU, escala, atualização e disponibilidade. A empresa ganha acesso imediato aos modelos mais capazes e paga só pelo que usa, com preço separado para os tokens de entrada (o que vai no prompt) e de saída (o que o modelo gera).
O que fica fora do controle da empresa: o preço, que o fornecedor pode mudar; a versão do modelo, que tem data para ser descontinuada; e o caminho do dado, que em geral passa por servidores fora do Brasil. Para contratos corporativos, os grandes fornecedores oferecem cláusulas de não treinamento e de retenção de dados, mas o que vale é o contrato do plano contratado.
On-premise: o modelo dentro de casa
No on-premise, a empresa baixa os pesos de um modelo aberto e o serve com um servidor de inferência. O termo é usado de forma ampla: vale para o servidor no data center próprio e para a GPU dedicada alugada na conta de nuvem da empresa, porque nos dois casos quem opera o modelo é o time da empresa, e não um fornecedor de modelo.
Isso ficou muito mais viável com os modelos de pesos abertos recentes. O gpt-oss-120b, da OpenAI, tem 117 bilhões de parâmetros (5,1 bilhões ativos por token), é distribuído sob licença Apache 2.0 e cabe em uma única GPU de 80 GB, como uma NVIDIA H100 (model card do gpt-oss-120b). A versão menor, gpt-oss-20b, tem cerca de 21 bilhões de parâmetros e roda com 16 GB de memória (model card do gpt-oss-20b). Outras famílias de modelos abertos seguem a mesma tendência, cada uma com a sua licença, que precisa ser lida antes do uso comercial.
O servidor de inferência também deixou de ser projeto de pesquisa. O vLLM, de código aberto, expõe o modelo por um servidor HTTP compatível com a API da OpenAI, com rotas de chat, completions e embeddings. Na prática, a aplicação que hoje chama a API de um fornecedor pode apontar para o servidor interno trocando o endereço e o nome do modelo, o que facilita testar os dois caminhos lado a lado.
Se a motivação principal é a LGPD, o guia de IA privada e LGPD trata do que a lei exige e de como a classe de cada dado define o caminho. Aqui o foco é o resto da decisão: custo, desempenho e operação.
Custo: como montar a conta do ponto de equilíbrio
A troca é de custo variável por custo fixo. Com API, o gasto acompanha o uso, chamada a chamada. Com on-premise, a GPU custa o mesmo ocupada ou parada. O ponto de equilíbrio é o volume a partir do qual o custo fixo da GPU fica menor que a fatura de tokens que ela substituiria.
Os preços de cada lado
Do lado da API, a tabela pública da OpenAI lista, por milhão de tokens, US$ 1,25 de entrada e US$ 10,00 de saída para o gpt-5, e US$ 0,25 de entrada e US$ 2,00 de saída para o gpt-5-mini. Entrada em cache sai a um décimo do preço, e a Batch API cobra metade para chamadas que podem esperar algumas horas.
Do lado da GPU, uma referência pública é a reserva de capacidade da AWS: em novembro de 2026, a página de Capacity Blocks listava a instância p5.48xlarge, com oito H100, a US$ 5,970 por GPU-hora na região da Virgínia do Norte, com a ressalva de que os preços são revistos conforme oferta e demanda. Uma GPU ligada o mês inteiro (cerca de 730 horas) custa, nesse preço, por volta de US$ 4.360. Comprar o hardware muda a conta para depreciação, energia, refrigeração e espaço, mas a lógica é a mesma.
Um exemplo de conta
Considere um assistente interno em que cada chamada usa, em média, 2.000 tokens de entrada (pergunta, instruções e trechos de documentos) e 500 de saída. Os números de tokens são hipotéticos; os preços são os das páginas citadas.
| Caminho | Custo por chamada | Chamadas por mês que somam US$ 4.360 |
|---|---|---|
| API, gpt-5 | US$ 0,0075 | cerca de 580 mil |
| API, gpt-5-mini | US$ 0,0015 | cerca de 2,9 milhões |
| API, gpt-5-mini via Batch | US$ 0,00075 | cerca de 5,8 milhões |
A tabela mostra duas coisas. Primeiro, contra um modelo de API pequeno e barato, o ponto de equilíbrio de uma única GPU fica na casa dos milhões de chamadas por mês, um volume que poucos casos de uso internos atingem. Segundo, contra o modelo mais caro, o equilíbrio chega bem antes, e é aí que o on-premise costuma aparecer: quando a empresa descobre que um modelo aberto resolve uma tarefa que hoje está no modelo de ponta.
O que a conta da GPU não mostra
A comparação acima é generosa com o on-premise, porque considera só a GPU. Na operação real entram outros custos:
- Redundância. Uma GPU é um ponto único de falha. Se o assistente faz parte de um processo, a conta passa a ter duas.
- Pico, não média. O uso se concentra no horário comercial. A capacidade precisa atender o pico das 10h, e fica ociosa de madrugada.
- Pessoas. Alguém instala, atualiza, monitora e responde por incidentes do servidor de inferência. Esse tempo é recorrente.
- Avaliação de modelos. Cada modelo aberto novo precisa ser testado contra um conjunto de casos antes de entrar, o que também vale para a API, mas no on-premise a decisão e o trabalho são da empresa.
E a API tem custos que a tabela de preços não mostra: tokens desperdiçados com prompts longos demais, chamadas repetidas sem cache e o uso do modelo mais caro em tarefas simples. Antes de comparar os dois caminhos, vale medir e enxugar o consumo atual, como explicamos no guia de FinOps para IA. Uma fatura de API que cai pela metade com cache e roteamento muda o ponto de equilíbrio.
Qualidade, latência e capacidade
Custo só faz sentido comparado com a mesma qualidade de resposta. Esse é o ponto em que as comparações mais erram.
Qualidade: o modelo aberto que cabe no hardware
O modelo aberto mais capaz que cabe na GPU disponível costuma ficar atrás dos melhores modelos comerciais em tarefas abertas e complexas, como raciocínio em várias etapas ou redação longa. Em tarefas delimitadas, como classificar um chamado, extrair campos de um documento ou resumir um texto em formato fixo, a diferença pode ser pequena ou nula.
A única forma de saber é medir: montar um conjunto de casos reais com a resposta esperada, rodar os dois modelos e comparar. Sem esse conjunto, a decisão vira opinião, e a troca de modelo pode piorar a resposta sem que ninguém perceba.
Latência e vazão
Na API, a latência depende da carga do fornecedor e da distância até o servidor, e cada conta tem limites de requisições por minuto definidos pelo fornecedor. No on-premise, a latência depende do hardware e de quantas requisições chegam ao mesmo tempo.
O servidor de inferência faz muita diferença na vazão. O artigo que apresentou o vLLM, Efficient Memory Management for Large Language Model Serving with PagedAttention, de 2023, mostrou ganho de 2 a 4 vezes na vazão de modelos populares em relação a sistemas de referência da época, com a mesma latência. Isso quer dizer que a capacidade de uma GPU não é um número fixo: depende do modelo, do tamanho dos prompts, da quantização e da configuração do servidor, e precisa ser medida com a carga real antes de dimensionar o ambiente.
Controle da versão
Um ponto a favor do on-premise que raramente entra na planilha: o modelo só muda quando a empresa decide. Na API, versões são descontinuadas com data marcada e a aplicação precisa ser retestada com o substituto. Para processos regulados ou auditados, em que a mesma pergunta precisa ter respostas consistentes ao longo do tempo, isso pesa.
Operação: o que a empresa passa a fazer
Trocar a API pelo on-premise é trocar uma fatura por uma operação. A lista do que o time passa a fazer:
- Escolher e avaliar o modelo. Selecionar candidatos abertos, conferir a licença e testar contra o conjunto de casos.
- Servir o modelo. Instalar e configurar o servidor de inferência, dimensionar GPU e definir o limite de requisições simultâneas.
- Garantir disponibilidade. Redundância, balanceamento, plano de contingência (que pode ser a própria API) e monitoramento de saúde.
- Observar. Registrar cada chamada, com latência, tokens, erros e qualidade, como em qualquer aplicação com LLM. O guia de LLMOps detalha essa camada, que é a mesma para API e on-premise.
- Atualizar. Patch de segurança do servidor, novas versões do servidor de inferência e troca de modelo quando um melhor aparece.
Nenhum desses itens é difícil isoladamente. O problema é que todos são recorrentes, e um servidor de inferência sem dono degrada como qualquer sistema sem dono.
Como decidir: um roteiro por caso de uso
A decisão funciona melhor por caso de uso do que para a empresa inteira. A tabela resume os critérios.
| Critério | Pesa a favor da API | Pesa a favor do on-premise |
|---|---|---|
| Volume | Baixo, irregular ou ainda desconhecido | Alto e estável, com GPU ocupada boa parte do dia |
| Tarefa | Aberta, complexa, exige o modelo mais capaz | Delimitada, em que um modelo aberto atinge a qualidade necessária |
| Dado | Não sensível ou já mascarado | Sensível, sob sigilo contratual ou sem permissão para sair do perímetro |
| Prazo | Precisa estar no ar em dias | Pode esperar semanas para montar a infraestrutura |
| Time | Sem gente para operar GPU e servidor de inferência | Com time de plataforma ou um parceiro que opere |
| Estabilidade do modelo | A aplicação tolera trocas de versão | O processo exige a mesma versão por longos períodos |
- Medir o consumo atual. Tokens por chamada, chamadas por dia, distribuição por hora e por caso de uso. Sem isso, o ponto de equilíbrio é chute.
- Otimizar a API primeiro. Cache, prompts menores, modelo menor para tarefas simples, Batch para o que pode esperar. A fatura otimizada é a base da comparação.
- Montar o conjunto de avaliação. Casos reais com respostas esperadas, para comparar modelos abertos e comerciais com a mesma régua.
- Testar um modelo aberto em GPU alugada. Antes de comprar hardware, rodar o modelo candidato em nuvem com a carga real, por algumas semanas, mede qualidade, latência e vazão de verdade.
- Decidir por caso de uso e manter o gateway. Cada caso vai para o caminho que ganhou na medição, e um gateway único permite mudar a decisão depois, quando preços e modelos mudarem.
A arquitetura híbrida
O desenho que mais aparece em produção é híbrido. Um gateway recebe todas as chamadas das aplicações e decide para onde cada uma vai: o modelo aberto interno para tarefas delimitadas ou com dado sensível, o modelo comercial pequeno para o volume geral e o modelo de ponta só quando a tarefa exige. O custo e a qualidade de cada rota aparecem no mesmo painel, e a regra de roteamento pode mudar sem mexer nas aplicações.
O roteamento entre modelos já dá resultado mesmo sem on-premise. No Grupo Soma, a BIX implementou observabilidade com LangFuse na camada de servidores MCP e roteamento de LLMs, o que reduziu o consumo de tokens e os custos de LLM do assistente IAzzas em mais de 70%. É o tipo de ganho que precisa ser capturado antes de qualquer comparação com GPU própria, porque muda a base da conta.
A BIX trabalha nesse problema medindo o consumo de cada caso de uso, montando o conjunto de avaliação e testando modelos abertos e comerciais lado a lado, com o custo e a qualidade de cada rota visíveis no mesmo gateway. O ponto de partida costuma ser a página de soluções com LLM, e a continuidade, um squad dedicado que opera os modelos, acompanha preços e versões e revisa a decisão de cada caso de uso conforme o volume cresce.
Perguntas frequentes
LLM on-premise é sempre mais barato que API?
Não. O on-premise troca custo variável por custo fixo, e só fica mais barato quando o volume é alto e estável o bastante para manter a GPU ocupada. Contra modelos de API pequenos e baratos, o ponto de equilíbrio de uma única GPU pode ficar na casa dos milhões de chamadas por mês, sem contar redundância e o tempo do time que opera.
Um modelo aberto tem a mesma qualidade de um modelo comercial?
Depende da tarefa. Em tarefas delimitadas, como classificação, extração de campos e resumos em formato fixo, modelos abertos que cabem em uma GPU podem atingir a qualidade necessária. Em tarefas abertas e complexas, os modelos comerciais de ponta costumam ir melhor. A resposta sai de um conjunto de avaliação com casos reais, não de benchmark genérico.
Dá para começar com API e migrar para on-premise depois?
Sim, e é o caminho mais comum. Servidores de inferência como o vLLM expõem uma interface compatível com a API da OpenAI, então a aplicação pode trocar de destino com pouca mudança de código. Ter um gateway desde o início facilita: a troca vira uma regra de roteamento, e os dois caminhos podem conviver.
Rodar o modelo em GPU alugada na nuvem conta como on-premise?
Na prática, sim. Para a decisão de custo e operação, o que importa é quem opera o modelo e onde o dado é processado. Uma GPU dedicada na conta de nuvem da empresa, com o modelo servido pelo time dela, tem o mesmo perfil de custo fixo e de controle de versão do servidor no data center próprio.
Qual é o primeiro passo para decidir entre on-premise e API?
Medir o consumo atual por caso de uso: tokens por chamada, volume por dia e por hora e o modelo usado em cada tarefa. Com esses números, dá para otimizar a fatura da API, calcular o ponto de equilíbrio e escolher quais casos valem um teste com modelo aberto.







