Motores de inferência

O que observar

As perguntas que separam as opções, em ordem de importância.

1. 01

   Throughput ou latência: decida o que você está comprando

   Throughput é o total de tokens por segundo somando todos os usuários, e define o seu custo por token. Latência é o que um usuário sente: o tempo até o primeiro token (TTFT) e a velocidade de saída da requisição dele. Motores como vLLM e SGLang agrupam muitas requisições para aumentar o throughput, o que pode deixar cada fluxo individual mais lento; chips especializados (Groq, Cerebras) vendem velocidade muito alta por usuário. Um chatbot precisa de TTFT baixo, um job noturno em lote precisa de throughput, e um agente que faz dezenas de chamadas em sequência precisa dos dois.

2. 02

   Como ler os benchmarks de provedores da Artificial Analysis

   A Artificial Analysis cronometra cada provedor que serve o mesmo modelo. A velocidade de saída é medida em tokens por segundo depois que chega o primeiro token; o TTFT é o número de segundos até o primeiro token, o que, em modelos de raciocínio, significa o primeiro token de raciocínio, então confira também o tempo até o primeiro token da resposta. Os números são a mediana das últimas 72 horas, o prompt padrão tem cerca de 10.000 tokens de entrada e os testes rodam a partir de uma região do Google Cloud em Iowa, então o TTFT inclui a distância de rede a partir dali. A maioria dos testes envia uma requisição por vez; o teste paralelo envia só 10, uma vez por dia, então os gráficos dizem pouco sobre como um provedor aguenta o seu pico de carga.

3. 03

   Suporte a hardware

   O motor precisa rodar bem no que você tem ou aluga. O TensorRT-LLM é voltado apenas para NVIDIA. O vLLM e o SGLang cobrem NVIDIA e AMD, com suporte a Intel e Ascend em alguns casos. O llama.cpp chega a CPUs, Apple Metal, CUDA, AMD e Vulkan; o MLX é só para Apple silicon. Os provedores hospedados decidem isso por você: a Groq usa os próprios chips LPU, a Cerebras os seus chips wafer-scale, e o Together AI e a Fireworks usam GPUs NVIDIA.

4. 04

   Formatos de quantização

   A quantização armazena os pesos com menos bits para que um modelo caiba em menos GPUs e rode mais rápido, geralmente com uma pequena perda de qualidade. Os formatos são ligados ao hardware: FP8 exige GPUs Ada ou Hopper ou mais novas, NVFP4 e MXFP4 exigem Blackwell para velocidade nativa, e GGUF é o formato do llama.cpp, do Ollama e da maior parte do uso em notebooks. Verifique se o motor suporta exatamente o checkpoint que você pretende baixar e meça a qualidade na sua própria tarefa depois de quantizar. Os provedores hospedados raramente publicam a precisão que servem, o que é um dos motivos pelos quais o mesmo modelo pode responder de forma diferente em dois deles.

5. 05

   API compatível com a OpenAI e as suas lacunas

   Quase todas as opções aqui falam o formato chat-completions da OpenAI, então trocar é basicamente mudar a URL base e o nome do modelo. As lacunas estão nos detalhes: a Groq rejeita logprobs e logit_bias, a Cerebras limita n a 1 e, no gpt-oss-120b, não combina ferramentas com um schema de resposta, e o Together usa IDs de modelo com namespace. Teste exatamente os parâmetros que o seu código envia, incluindo streaming e chamadas de ferramentas.

6. 06

   Saída estruturada e chamadas de ferramentas

   Agentes e jobs de extração precisam de JSON que siga um schema todas as vezes. Os motores garantem isso restringindo quais tokens podem ser gerados; o SGLang fez da geração estruturada um recurso central, e o Together suporta response_format na sua API compatível com a OpenAI. Verifique se a imposição do schema funciona junto com chamadas de ferramentas e streaming no modelo que você usa, porque o suporte varia por modelo, não só por provedor.

7. 07

   Muitos fine-tunes sobre um único modelo base

   Se você serve vários fine-tunes com LoRA, verifique se o motor ou o provedor consegue carregar muitos adaptadores sobre uma única cópia do modelo base e escolher o certo a cada requisição. Sem isso, cada fine-tune precisa da sua própria GPU. A Fireworks, por exemplo, serve modelos com fine-tuning pelo mesmo preço do modelo base.

8. 08

   Licença e base de preço

   Os motores self-hosted são software livre, na maioria Apache 2.0 ou MIT; você paga pelas GPUs e pelas pessoas que os operam. Os provedores hospedados cobram por milhão de tokens, com entrada e saída cobradas separadamente, e a maioria acrescenta descontos para lotes e para entrada em cache, além de GPUs dedicadas por hora. Com volume alto e constante, hospedar por conta própria em GPUs alugadas costuma vencer; com volume irregular ou baixo, vence a cobrança por token.

13 ferramentas comparadas

Ordenadas pela nossa nota. Abra qualquer avaliação para ver as fontes, os preços e o veredito completo.

Ferramentas de Motores de inferência comparadas

Ferramenta	Nota	Nosso veredito	Ideal para	Preço
llama.cpprepositório	4.8/5	Se um modelo aberto roda em um notebook, quase certamente roda pelo llama.cpp, e nada mais cobre tanto hardware.	Desenvolvedores que querem controle direto sobre a execução de modelos abertos localmente, em dispositivos de borda ou em servidores modestos.	Gratuito e de código aberto sob a licença MIT. Sem edição paga.
vLLMrepositório	4.7/5	Continua sendo o mecanismo ideal para colocar um modelo aberto atrás de uma API multiusuário, desde que alguém na equipe se responsabilize pelas atualizações e pela exposição na rede.	Equipes que disponibilizam modelos abertos para muitos usuários simultâneos em servidores GPU.	Gratuito e de código aberto sob a licença Apache 2.0. Você paga pelas GPUs nas quais ele é executado.
Ollamarepositório	4.6/5	Modelos locais com um comando, com padrões (contexto de 4.096 tokens, uma requisição por vez, sem login) que servem para um notebook e nada maior.	Desenvolvedores e pessoas que querem rodar modelos abertos localmente com o mínimo de configuração.	Código aberto (MIT) e gratuito para rodar localmente. Ollama Cloud opcional: Free com créditos iniciais; Pro US$ 20/mês (US$ 60 em créditos); Max US$ 100/mês (US$ 300 em créditos); Team US$ 500/mês (US$ 1.000 em créditos compartilhados, usuários ilimitados); Enterprise sob consulta.
Together AIferramenta	4.5/5	A Together roda modelos abertos em todas as etapas com uma única conta, de uma recarga de $15 na API a um cluster de H100 reservado, e seu hardware dedicado custa menos do que cobram os provedores especializados.	Equipes que trabalham com modelos abertos e querem passar de chamadas de API para fine-tuning e GPUs próprias com um só provedor.	Pré-pago, primeira compra mínima de $15, sem teste gratuito. Por 1M de tokens, p. ex. gpt-oss-120B $0.15 de entrada / $0.60 de saída, Kimi K3 $3 / $15; lote com até 50% de desconto. Endpoints dedicados: H100 $5.49/hora, B200 $8.99/hora. Clusters de GPU: H100 $3.99/hora sob demanda, $1.99 interruptível. Fine-tuning a partir de $0.34 por 1M de tokens.
SGLangrepositório	4.4/5	O SGLang foi feito para as cargas de agentes e RL que reenviam os mesmos prompts longos, e o lugar dele é atrás de uma rede bem fechada.	Equipes que servem modelos abertos com muito reaproveitamento de prompts, como agentes e chat de vários turnos.	Gratuito e de código aberto sob a licença Apache 2.0.
MLXrepositório	4.4/5	O MLX transforma um Mac com muita memória em uma máquina crível para inferência local e ajuste LoRA; fora do Apple silicon, é um port, não um motivo para trocar.	Desenvolvedores e pesquisadores que trabalham no Mac e querem velocidade nativa e controle em Python no Apple silicon.	Gratuito e de código aberto sob a licença MIT.
Fireworks AIferramenta	4.4/5	A Fireworks é um lugar seguro para rodar modelos abertos em produção, sem guardar nada por padrão e servindo modelos ajustados pelo preço dos modelos base, e suas GPUs dedicadas são a única parte cara.	Equipes que rodam modelos abertos em produção e querem fine-tuning e preços por token previsíveis.	Créditos pré-pagos. Por 1M de tokens, por exemplo GPT OSS 120B $0,15 de entrada / $0,60 de saída, Kimi K3 $3 / $15. Lote com 50% de desconto. H100/H200 dedicadas $8/hora, B200 $13/hora. Fine-tuning a partir de $0,50 por 1M de tokens de treinamento.
audio.cpprepositório	4.3/5	O audio.cpp está fazendo pela fala local o que o llama.cpp fez pelos modelos de chat, e com quatro meses de vida já roda mais de 110 famílias de modelos.	Engenheiros que auto-hospedam vários modelos de fala ou áudio e querem um único runtime nativo e uma API HTTP em vez de um ambiente Python por modelo.	Gratuito sob Apache 2.0. Não há edição paga. Os pesos dos modelos mantêm as próprias licenças, muitas delas não comerciais.
colibrirepositório	4.2/5	Um motor em C que lê do disco e faz modelos abertos de 744B parâmetros rodarem em um desktop, devagar, com um substituto local honesto para a API de decisões do Jev de quebra.	Entusiastas e desenvolvedores que querem rodar modelos MoE abertos de tamanho de fronteira, ou prototipar decisões no estilo Jev, na própria máquina.	Gratuito e de código aberto (Apache 2.0). Cada modelo mantém sua própria licença.
TensorRT-LLMrepositório	4.0/5	O TensorRT-LLM é onde o silício novo da NVIDIA recebe suas primeiras otimizações sérias, e o preço é uma longa lista de CVEs e um ritmo de releases estáveis medido em estações do ano.	Equipes com grandes frotas de GPUs NVIDIA que querem o máximo de throughput por GPU.	Gratuito e de código aberto sob a licença Apache 2.0 (alguns componentes incluídos têm licenças próprias).
Groqferramenta	4.0/5	A Groq ainda vende alguns dos tokens mais rápidos do mercado a preço de pechincha, mas a empresa por trás dela mudou e a sua lista de modelos encolheu junto.	Desenvolvedores que criam recursos de voz, tempo real ou agentes em que a velocidade de resposta importa mais do que a escolha do modelo.	Plano gratuito com limites de uso (30 solicitações/minuto e 1.000/dia para o gpt-oss-120b). Plano Developer com pagamento por uso: gpt-oss-120b US$ 0,15 de entrada / US$ 0,60 de saída por 1M de tokens, gpt-oss-20b US$ 0,075 / US$ 0,30, qwen3.8-27b US$ 0,80 / US$ 4,00; Whisper large-v3-turbo US$ 0,04/hora de áudio. Llama e alguns modelos mais novos via equipe de vendas.
Cerebrasferramenta	4.0/5	A Cerebras vende velocidade por token, e com mais do que o dobro do preço de entrada da Groq para o gpt-oss ela só compensa quando a latência é o produto.	Desenvolvedores que constroem agentes sensíveis à latência ou ferramentas de programação que podem trabalhar com modelos gpt-oss ou Qwen.	Crédito único de teste de US$ 5 (30 dias), depois pagamento por uso. gpt-oss-120b US$ 0,35 de entrada / US$ 0,75 de saída por 1M de tokens; Qwen 3.8 27B US$ 0,99 / US$ 1,49. Dedicated Inference mediante acordo. Assinaturas Cerebras Code (US$ 50 e US$ 200/mês) listadas como esgotadas.
DeepInferrepositório	3.6/5	Um raro olhar por dentro de um serviço de LLM em produção, mas por enquanto é um motor de referência para um modelo em duas famílias de chips, não algo para colocar atrás de uma API.	Engenheiros de inferência que rodam o DeepSeek-V4.1-Flash em escala de cluster e querem os kernels e configurações da DeepSeek como referência.	Gratuito e de código aberto sob a licença Apache 2.0. Você paga pelas GPUs Blackwell ou NPUs Ascend.

Lado a lado

As especificações que importam nesta etapa. Verificadas em 19 de out. de 2026; confirme no site do fornecedor antes de decidir.

Onde esta etapa se encaixa

• Converse com os seus documentos: começaríamos com Together AI.
• Agente de voz: começaríamos com Groq.
• IA privada no dispositivo: começaríamos com Ollama, llama.cpp, MLX.
• O seu próprio modelo com fine-tuning: começaríamos com vLLM.

Fontes deste guia

• Artificial Analysis: metodologia de benchmark de desempenho
• Documentação do vLLM: suporte a quantização
• Documentação do SGLang: quantização
• Documentação do TensorRT-LLM: quantização
• Documentação do TensorRT-LLM: trtllm-serve
• Documentação da Groq: compatibilidade com a OpenAI
• Documentação da Cerebras: compatibilidade com a OpenAI
• Documentação do Together AI: compatibilidade com a API da OpenAI
• Documentação da Fireworks AI: compatibilidade com a OpenAI
• DeepInfer no GitHub