O que é um servidor de inferência LLM corporativo?
Um servidor de inferência LLM corporativo é a camada de software que recebe requisições concorrentes de muitos usuários ou aplicações e as roteia eficientemente por um pool de GPU compartilhado. Isso é diferente de um runtime de um único usuário, que carrega um modelo para um único processo em uma única máquina.
Três coisas separam um software de serving de nível corporativo de uma ferramenta de notebook: continuous batching (agrupar várias requisições em andamento no mesmo passo de GPU), paralelismo multi-GPU (dividir um modelo entre várias GPUs ou nós), e uma superfície de API de produção (health checks, métricas, ganchos de autoscaling) que um time de plataforma consegue operar dentro do Kubernetes.
vLLM, Hugging Face TGI e NVIDIA NIM foram construídos desde o início em torno desses três requisitos. O Ollama, construído sobre o llama.cpp, foi projetado para portabilidade e simplicidade em uma única máquina -- um objetivo diferente e válido, mas não o mesmo. Veja nossa comparação de motores para um único usuário se a pergunta real for "o que instala mais fácil no meu PC" -- este guia cobre o outro extremo dessa decisão.
Comparativo: vLLM vs TGI vs NVIDIA NIM vs Ollama
Capacidade | vLLM | TGI | NVIDIA NIM | Ollama |
|---|---|---|---|---|
| Licença | Apache 2.0 / Gratuito | Apache 2.0 / Gratuito | NVIDIA AI Enterprise / Pago | MIT / Gratuito |
| Feito para | Serving de GPU alto throughput | Serving HF legado (manutenção) | Stack corporativo NVIDIA pronto | Um usuário, não multi-tenant |
| Multi-GPU | Tensor + pipeline paralelo | Tensor paralelo | Paralelismo tensorial (por perfil) | Um nó (conforme a doc) |
| Continuous batching | Sim (PagedAttention) | Sim (roteador Rust) | Sim (no nível do motor) | Requisições paralelas (padrão 1) |
| Quantização | GPTQ / AWQ / FP8 / INT4 | bitsandbytes / GPTQ / AWQ / EETQ / Marlin / FP8 | Conforme o perfil do modelo | GGUF Q4-Q8 |
| Deploy Kubernetes | Helm / production-stack / KServe | Imagem de contêiner / manifestos próprios | NIM Operator (oficial) | Charts da comunidade listados |
| Modelo de suporte | Comunidade / GitHub | Modo de manutenção / arquivado | Suporte corporativo NVIDIA | Comunidade (conforme a doc) |
| Observabilidade | Métricas Prometheus embutidas | Prometheus + traces OTel | Métricas DCGM / próprias do NIM | Sem endpoint de métricas documentado |
Entendendo o vLLM: um motor open source de alto throughput
vLLM é um servidor de inferência open source (Apache 2.0) construído especificamente para serving multi-GPU de alto throughput. Surgiu do Sky Computing Lab da UC Berkeley e é uma engine open source amplamente utilizada para APIs de LLM em produção.
- PagedAttention: gerencia o cache KV em blocos de tamanho fixo em vez de uma alocação contígua por requisição, o que eleva a utilização de memória de GPU alcançável e permite mais requisições concorrentes compartilhando uma GPU.
- Continuous batching: novas requisições entram em um batch já em execução em vez de esperar o batch atual terminar, mantendo a utilização de GPU alta sob tráfego variável.
- Multi-GPU e multi-node: o paralelismo tensor divide as camadas de um modelo entre GPUs de um nó; o paralelismo de pipeline divide entre nós para modelos grandes demais para a VRAM combinada de um nó.
- Quantização: formatos GPTQ, AWQ, FP8 e INT4 reduzem o consumo de VRAM por réplica, aumentando o número de réplicas simultâneas que uma frota fixa de GPUs comporta.
- API compatível com OpenAI:
vllm serve <model>expõe um substituto direto da API OpenAI Chat Completions, minimizando o trabalho de integração no lado da aplicação. - vLLM traz um Helm chart oficial e se integra ao KServe para serving de modelos nativo do Kubernetes, com autoscaling orientado por profundidade de fila de requisições ou utilização de GPU.
# Servir um modelo com paralelismo tensor em 4 GPUs
pip install vllm
# --api-key protege apenas os caminhos /v1, /v2, /inference e /cohere; os demais endpoints continuam abertos. Coloque um firewall ou um reverse proxy na frente antes de expor a porta
vllm serve meta-llama/Llama-3.3-70B-Instruct \
--tensor-parallel-size 4 \
--gpu-memory-utilization 0.9 \
--api-key "$VLLM_API_KEY" \
--host 0.0.0.0 --port 8000Entendendo o Hugging Face TGI: agora em modo de manutenção
O Hugging Face Text Generation Inference (TGI) é um servidor de inferência open source (Apache 2.0) para modelos do Hugging Face Hub, mas agora está em modo de manutenção: o repositório no GitHub foi arquivado (somente leitura) em março de 2026 e o Hugging Face recomenda vLLM e SGLang para novos deployments. Segundo o README, ele ainda sustenta o Hugging Chat, a Inference API e os Inference Endpoints, então os deployments existentes continuam funcionando, mas não espere novos recursos.
- Roteador de requisições em Rust: gerencia filas e continuous batching segundo a documentação do TGI.
- Flash Attention e Paged Attention: a documentação do TGI cita as duas, as mesmas técnicas de eficiência de memória que o vLLM popularizou.
- Paralelismo tensor: divide um modelo entre várias GPUs de um nó; serving multi-node é suportado, mas com menos ferramental próprio do que o vLLM.
- Quantização: formatos bitsandbytes, GPTQ, AWQ, EETQ, Marlin e FP8.
- Integração nativa com o Hugging Face Hub: baixar um modelo, seu tokenizer e pesos safetensors não exige nenhuma conversão manual se o modelo já estiver hospedado no Hub.
- Nota sobre licença: o TGI foi brevemente distribuído sob uma licença mais restritiva escrita pela própria Hugging Face (HFOIL 1.0; veja a FAQ de licença do TGI) em 2023-2024 antes de voltar para Apache 2.0 -- confirme a versão de licença fixada no seu manifesto de deploy, já que uma imagem antiga em cache ainda pode carregar o marcador restritivo.
- Migração: comece projetos novos no vLLM ou SGLang; se já tem uma frota TGI, planeje a mudança para um motor com manutenção ativa em vez de permanecer em um código arquivado. A última versão do TGI foi a v3.3.7, de dezembro de 2025.
Entendendo o NVIDIA NIM: a opção com suporte do fabricante
NVIDIA NIM (NVIDIA Inference Microservices) é um container pago e pré-construído que empacota uma engine de inferência open source otimizada pela NVIDIA atrás de uma API padronizada, vendido como parte da assinatura NVIDIA AI Enterprise. Ele troca a configuração manual do vLLM e do TGI por um deploy respaldado e já otimizado.
- Contêineres de motor com otimizações da NVIDIA: a documentação atual do NIM for LLMs diz que cada imagem de contêiner empacota um motor open source, vLLM ou SGLang, com otimizações da NVIDIA; segundo a mesma página de visão geral, a arquitetura 1.x anterior reunia vários backends em um único contêiner. Verifique qual motor sua versão do NIM usa antes de comparar o desempenho com um vLLM auto-hospedado.
- Suporte corporativo respaldado pela NVIDIA: a diferença em relação às opções open source -- um caminho de suporte do fabricante sob uma licença NVIDIA AI Enterprise; confirme no contrato os termos exatos de SLA e disponibilidade.
- NIM Operator para Kubernetes: o operator da NVIDIA cria o deployment Kubernetes de cada serviço NIM, pode pré-carregar modelos nos nós e suporta autoescalonamento com métricas do DCGM ou próprias do NIM.
- Catálogo de modelos: a NVIDIA mantém um conjunto curado de modelos de pesos abertos pré-empacotados como containers NIM prontos para uso, além de um caminho para empacotar modelos afinados próprios.
- A contrapartida é a dependência do fornecedor e o custo da licença: o NIM foi feito para GPUs NVIDIA e o uso em produção exige uma licença NVIDIA AI Enterprise, que segundo o FAQ do NIM da NVIDIA começa em US$ 4.500 por GPU por ano. Membros do NVIDIA Developer Program podem auto-hospedar o NIM para pesquisa, desenvolvimento e experimentação em até 16 GPUs. Confirme as condições atuais com a NVIDIA AI Enterprise antes de orçar, pois os preços de assinaturas de software corporativo mudam sem muito aviso público.
Por que o Ollama não é um motor de serving corporativo
O Ollama não foi feito para serving corporativo multi-tenant, e isso é uma decisão de design, não um defeito. O Ollama empacota o llama.cpp com uma API REST simples e download de modelo em um único comando, otimizado para um desenvolvedor rodando um modelo em uma máquina.
- Concorrência: segundo o FAQ, o Ollama trata requisições paralelas por meio de OLLAMA_NUM_PARALLEL (padrão 1) e uma fila (OLLAMA_MAX_QUEUE, padrão 512), mas não documenta batching contínuo nem gerenciamento de memória no estilo PagedAttention, então não foi projetado para muitos usuários simultâneos como o vLLM ou o NIM.
- Multi-GPU: o Ollama consegue dividir um modelo grande entre GPUs de uma máquina, mas a documentação dele não descreve serving tensor-paralelo ou multi-node comparável ao do vLLM.
- Kubernetes: um Helm chart mantido pela comunidade consta no README do GitHub; a documentação não lista nenhum operador Kubernetes próprio nem integração com autoscaler.
- Observabilidade: a documentação do Ollama não descreve nenhum endpoint de métricas, ao contrário de vLLM e TGI.
- Onde o Ollama ainda é a ferramenta certa em uma empresa: notebooks de desenvolvedores, um protótipo departamental com pouco tráfego interno, ou um dispositivo de edge isolado atendendo um usuário por vez. Assim que o tráfego exigir concorrência multi-tenant, migre para vLLM, TGI ou NIM -- veja configurações multi-GPU para LLMs locais para o lado de hardware dessa mudança.
Decisões de arquitetura: um nó vs multi-node
A primeira decisão de arquitetura é um único nó versus multi-node, e ela é definida por o modelo caber ou não na memória de GPU combinada de um nó, não apenas pelo volume de tráfego.
Equipes que precisam de nós multi-GPU sem comprar uma frota podem comparar os provedores de hospedagem de servidores GPU.
- Um nó, multi-GPU: use paralelismo tensor (
--tensor-parallel-sizeno vLLM,--num-shardno TGI) para dividir as camadas de um modelo entre as GPUs de um servidor. É o padrão para modelos que cabem na VRAM combinada de um nó. - Multi-node: adicione paralelismo de pipeline assim que um modelo exceder a memória de GPU de um nó, ou o volume de requisições exceder o que o paralelismo tensor em um nó consegue atender. O vLLM suporta isso via Ray; o NIM via seus próprios templates de deploy multi-node.
- Balanceamento de carga: um balanceador round-robin simples funciona para réplicas de tamanho idêntico, mas o roteamento consciente do cache KV -- enviar uma requisição de continuação da mesma conversa de volta para a réplica que já tem seu contexto em cache -- reduz a latência de forma significativa em cargas de trabalho tipo chat.
- Roteamento de modelos: empresas que rodam mais de um modelo (por exemplo, um modelo de código e um modelo de chat geral) costumam manter pools de réplicas separados por modelo atrás de uma camada de roteamento, em vez de um pool compartilhado -- a memória de GPU não se divide de forma limpa o suficiente entre modelos muito diferentes para justificar a complexidade.
- Autoscaling: escale pela profundidade da fila de requisições ou pela utilização de GPU, não pela CPU (o padrão clássico do HPA do Kubernetes) -- a utilização de CPU de um pod de inferência em GPU muitas vezes mal se move quando a carga muda. O KEDA com uma métrica Prometheus customizada é o padrão comum para vLLM/TGI; o Operator do NIM já conecta isso como parte do produto. Veja escalando LLMs locais para empresas para o planejamento de capacidade mais amplo por trás disso.
Como implantar um stack de inferência multi-GPU
Implantar um stack de inferência corporativo segue uma sequência fixa: definir o SLA, dimensionar a frota, escolher a engine, e então conectar deploy, roteamento e observabilidade em torno disso.
- 1Defina seu SLA de latência e concorrência antes de escolher o hardware.
- 2Dimensione a frota de GPU pelo consumo de VRAM do modelo e pela meta de requisições concorrentes, não apenas pela contagem de parâmetros do modelo.
- 3Escolha o motor de serving -- vLLM (ou SGLang) para flexibilidade open source, NIM para deployment pronto com suporte do fabricante; não inicie projetos novos no TGI.
- 4Containerize a engine e implante via Helm (ou o NIM Operator) no seu cluster Kubernetes.
- 5Configure paralelismo tensor dentro de um nó e paralelismo de pipeline entre nós, se o modelo exigir.
- 6Configure balanceamento de carga consciente do cache KV ou round-robin na frente do pool de réplicas.
- 7Conecte o autoscaling à profundidade da fila de requisições ou à utilização de GPU, não à CPU.
- 8Adicione observabilidade Prometheus/OpenTelemetry e faça teste de carga na concorrência alvo antes de ir para produção.
Licenciamento e modelo de suporte comparados
A licença é o item que mais altera o custo total de propriedade entre essas opções. O vLLM tem licença Apache 2.0 e é gratuito em qualquer escala, assim como o TGI (Apache 2.0, agora arquivado) -- você paga apenas pela infraestrutura de GPU por baixo. O NVIDIA NIM exige uma licença NVIDIA AI Enterprise para produção, que segundo o FAQ da NVIDIA começa em US$ 4.500 por GPU por ano, além do custo da GPU; pesquisa, desenvolvimento e experimentação em até 16 GPUs são gratuitos para membros do NVIDIA Developer Program. Confirme as condições atuais diretamente com a NVIDIA antes de orçar. O Ollama tem licença MIT e é gratuito, com suporte limitado ao GitHub e ao Discord da comunidade -- a documentação não menciona nenhum nível pago de suporte corporativo.
O modelo de suporte importa tanto quanto o custo da licença em um sistema de produção: o suporte do vLLM vem de issues no GitHub e canais da comunidade (rápido para problemas populares, sem SLA), o TGI recebe apenas manutenção menor, o NIM vem com um contrato de suporte da NVIDIA e a documentação do Ollama não menciona nenhum caminho de suporte além dos canais da comunidade.
Pontos de observabilidade para serving em produção
vLLM e TGI expõem de fábrica um endpoint /metrics compatível com Prometheus, cobrindo latência de requisição, profundidade de fila, utilização de cache KV de GPU e throughput de tokens. Conecte isso a uma stack Prometheus/Grafana existente para dashboards de nível de produção sem instrumentação customizada.
O NVIDIA NIM suporta métricas de GPU baseadas no DCGM e métricas próprias do NIM, que o Operator pode usar para autoescalonamento -- encaixa melhor se o restante da infraestrutura já é centrado na NVIDIA.
O Ollama tem métricas embutidas mínimas: a documentação não descreve nenhum endpoint de métricas, coerente com seu projeto para um único usuário, mas uma lacuna real se você o usa como infraestrutura compartilhada e precisa ver a latência por requisição com muitos usuários simultâneos.
Qual servidor de inferência escolher?
Escolha open source padrão: vLLM -- comunidade ampla, grande suporte a hardware, ferramentas multi-GPU e lançamentos frequentes.
Já usa o Hugging Face: ainda assim planeje com vLLM ou SGLang -- o TGI está em modo de manutenção, mantenha-o apenas em deployments existentes.
Indicado se você precisa de suporte do fabricante: NVIDIA NIM -- respaldado pelo fabricante, pronto para uso, com custo de licença.
Não para tráfego de produção multi-tenant: Ollama -- reserve para máquinas de desenvolvedores e deploys de edge de único usuário.
- 🧭 Time de plataforma que mantém uma API de LLM interna compartilhada para várias equipes → vLLM, auto-hospedado em Kubernetes.
- 🧭 Empresa regulada que quer um contrato de suporte do fabricante → NVIDIA NIM; adicione seu próprio registro de auditoria na frente (veja o guia de compliance corporativo relacionado).
- 🧭 Equipe já padronizada no Hugging Face Hub para hospedar modelos → vLLM, que carrega modelos do Hub diretamente; mantenha o TGI apenas em deployments existentes.
- 🧭 Desenvolvedores montando uma prova de conceito antes de a infraestrutura estar pronta → Ollama e depois migração para o vLLM quando o tráfego simultâneo for real.
- ❌ Se você espera mais do que um punhado de usuários simultâneos, o Ollama não foi projetado para um endpoint de produção compartilhado -- use o vLLM.
- ❌ Se você precisa de autoescalonamento nativo do Kubernetes pela carga de requisições, a documentação do Ollama não lista nenhum equivalente ao escalonamento por profundidade de fila com KEDA -- use vLLM ou NIM.
Erros comuns ao dimensionar infraestrutura de inferência corporativa
- Dimensionar GPUs pela contagem de parâmetros em vez da contagem de requisições concorrentes. Uma frota de GPU dimensionada só para uma cópia do modelo caber na VRAM não tem margem para usuários concorrentes -- dimensione pela concorrência de pico e depois verifique se o modelo ainda cabe.
- Implantar o Ollama atrás de um load balancer de produção compartilhado. Funciona em uma demo com dois usuários; não foi projetado para um deployment voltado a centenas de usuários.
- Escalar pela utilização de CPU. Pods de inferência em GPU muitas vezes mal movem a utilização de CPU quando a carga muda -- escale pela profundidade da fila ou pela utilização de GPU.
- Ignorar a checagem de licença em imagens antigas do TGI em cache. Confirme se a tag de imagem baixada corresponde à versão Apache 2.0, não a um build da era HFOIL 1.0 em cache.
- Orçar o NIM sem confirmar os preços atuais por GPU diretamente com a NVIDIA. Preços de assinatura de software corporativo mudam; uma cotação antiga não é base de orçamento.
Fontes
- Documentação do vLLM -- Docs oficiais do vLLM: PagedAttention, continuous batching e guias de deploy multi-GPU/multi-node.
- Hugging Face Text Generation Inference (GitHub) -- Repositório oficial do TGI: aviso de modo de manutenção, status de arquivamento, formatos de quantização suportados e histórico de licenças.
- Documentação do NVIDIA NIM -- Docs oficiais do NIM: modelos suportados, imagens de motor vLLM e SGLang e o NIM Operator para Kubernetes.
- Ollama GitHub -- Repositório oficial do Ollama e rastreador de issues, referenciado para comportamento de concorrência e deploy.
- NVIDIA AI Enterprise -- Página de produto da NVIDIA para a assinatura AI Enterprise sob a qual o NIM é distribuído.
- FAQ do NVIDIA NIM -- Declarações de licenciamento da NVIDIA sobre o NIM: uso do Developer Program em até 16 GPUs, licença NVIDIA AI Enterprise para produção e preço inicial.
Perguntas frequentes
Qual é a diferença entre vLLM e NVIDIA NIM?
O vLLM é um servidor de inferência gratuito e open source (Apache 2.0) que você hospeda e opera por conta própria. O NVIDIA NIM é um contêiner pré-pronto da NVIDIA que, segundo a documentação atual da NVIDIA, empacota o motor vLLM ou SGLang com otimizações da NVIDIA; o uso em produção exige uma licença NVIDIA AI Enterprise e inclui suporte do fabricante. O vLLM dá controle e nenhuma taxa de licença, em troca de você cuidar do ajuste e do suporte; o NIM troca isso por uma licença. A PromptQuorum não fez benchmarks comparando os dois.
O Ollama pode ser usado para serving de inferência multiusuário corporativo?
Não é recomendado para tráfego de produção multiusuário. O Ollama processa requisições paralelas por meio de OLLAMA_NUM_PARALLEL (padrão 1) e uma fila, mas não documenta batching contínuo nem gerenciamento de memória no estilo PagedAttention e a documentação dele não menciona autoescalonamento nativo do Kubernetes. Serve bem para máquinas de desenvolvedores, dispositivos edge de um único usuário ou protótipos internos com pouco tráfego.
Vale a pena o custo de licença do NVIDIA NIM frente ao vLLM ou TGI open source?
Depende de o contrato de suporte do fabricante e o empacotamento da NVIDIA valerem o custo da licença para você, em vez de manter a infraestrutura gratuita e operá-la por conta própria. Empresas reguladas que querem um contrato de suporte do fabricante costumam justificar o custo (o registro de auditoria ainda precisa ser adicionado separadamente); equipes com expertise própria em infraestrutura de ML costumam rodar o vLLM sem custo de licença.
Como escalar a inferência de LLM entre várias GPUs e nós?
Use paralelismo tensorial para dividir as camadas de um modelo entre as GPUs de um nó e paralelismo de pipeline para dividir entre vários nós quando o modelo excede a memória de GPU combinada de um nó. O vLLM suporta os dois (multinó via Ray ou multiprocessing); o TGI suporta paralelismo tensorial com menos ferramentas multinó próprias e está em modo de manutenção; o NIM implanta modelos multi-GPU por meio de seus perfis de modelo e roda em Kubernetes com o NIM Operator.
Quais formatos de quantização cada servidor de inferência suporta?
O vLLM suporta GPTQ, AWQ, FP8 e INT4. O TGI lista bitsandbytes, GPTQ, AWQ, EETQ, Marlin e FP8. O NVIDIA NIM seleciona a precisão por perfil de modelo e GPU. O Ollama usa o formato GGUF com precisão de Q4 a Q8, voltado a economizar memória em uma única máquina e não a desempenho multiusuário.
Como implantar vLLM ou TGI no Kubernetes?
O vLLM documenta várias rotas para Kubernetes, incluindo um chart do Helm, o KServe e o production-stack do vllm-project. O TGI fornece uma imagem de contêiner que você envolve em seus próprios manifestos. Configure requisições de recursos compatíveis com sua alocação de GPU, defina o autoescalonamento pela profundidade da fila ou pelo uso de GPU em vez da CPU e adicione um ServiceMonitor do Prometheus para coletar o endpoint de métricas.
O que é continuous batching e por que importa para serving corporativo?
O batching contínuo permite que novas requisições entrem em um lote de GPU que já está em execução, em vez de esperar o lote atual terminar. Ele mantém a utilização da GPU alta com tráfego real irregular, por isso é padrão no vLLM, no TGI e nos motores do NIM, e uma das maiores diferenças em relação a uma ferramenta de usuário único como o Ollama.
Qual servidor de inferência tem a melhor observabilidade?
O vLLM expõe métricas em seu endpoint /metrics e o TGI oferece métricas do Prometheus e tracing OpenTelemetry -- ideal para uma stack Prometheus/Grafana existente. O NVIDIA NIM suporta métricas do DCGM e próprias do NIM por meio do Operator, mais adequado a infraestruturas centradas na NVIDIA. A documentação do Ollama não descreve nenhum endpoint de métricas.
Vários modelos precisam de frotas de GPU separadas, ou podem compartilhar um mesmo pool?
Na prática, empresas rodando mais de um modelo costumam manter pools de réplicas separados por modelo em vez de compartilhar um pool, porque a memória de GPU não se divide de forma limpa entre modelos de tamanhos muito diferentes. Roteie as requisições para o pool correto na camada de aplicação ou gateway, em vez de tentar colocar vários modelos nas mesmas réplicas de GPU.
Como o licenciamento difere entre vLLM, TGI e NVIDIA NIM?
vLLM e Hugging Face TGI têm licença Apache 2.0 e são gratuitos em qualquer escala -- você paga apenas pela infraestrutura de GPU. O NVIDIA NIM exige uma licença NVIDIA AI Enterprise para produção, que segundo o FAQ da NVIDIA começa em US$ 4.500 por GPU por ano, além do custo do hardware de GPU; membros do Developer Program podem auto-hospedar o NIM para pesquisa e desenvolvimento em até 16 GPUs. Confirme os preços atuais diretamente com a NVIDIA. O Ollama tem licença MIT, é gratuito e só tem suporte da comunidade.
O Hugging Face TGI ainda recebe manutenção?
O TGI está em modo de manutenção. O README diz que o Hugging Face aceita apenas correções menores de bugs, melhorias de documentação e manutenção leve, e o repositório no GitHub foi arquivado (somente leitura) em março de 2026. A última versão é a v3.3.7 de dezembro de 2025 e o Hugging Face recomenda vLLM e SGLang para novos deployments. Os deployments TGI existentes continuam funcionando, mas planeje uma migração.
Como o vLLM e o TensorRT-LLM se comparam?
O vLLM é um motor de serving geral que carrega diretamente modelos no formato Hugging Face e roda em GPUs NVIDIA e AMD e em outros hardwares. O TensorRT-LLM é a biblioteca de inferência da NVIDIA para GPUs NVIDIA. Versões anteriores compilavam um modelo antecipadamente em um motor TensorRT específico de uma GPU; a documentação atual da NVIDIA descreve um fluxo de trabalho baseado em PyTorch no qual o backend de motor TensorRT foi removido, então verifique a versão que você implanta. O vLLM costuma significar um deployment mais simples e maior cobertura de hardware e modelos; o TensorRT-LLM serve a equipes comprometidas com as GPUs NVIDIA. Veja TensorRT-LLM explicado.