SGLang, vLLM ou Ollama? O Guia Definitivo de Frameworks de Inferência para 2026

Quando você decide usar um modelo open source em produção, o modelo em si é só metade da decisão. A outra metade é como você vai servir ele.

Framework de inferência é o software que fica entre o modelo (pesos, arquitetura) e sua aplicação. Ele decide como o modelo recebe requisições, como processa os tokens, como gerencia memória de GPU, e com que throughput e latência ele responde. A mesma arquitetura de modelo pode ter performance 3-10x diferente dependendo do framework que a serve.

Com o Gemma 4, Llama 4, Mistral e outros modelos poderosos disponíveis com licenças permissivas, times estão cada vez mais considerando hosting próprio — e a escolha de framework virou uma decisão de arquitetura genuinamente importante.

Este guia mapeia o cenário atual: quais frameworks existem, para que são bons, e como escolher.

Os Principais Frameworks em 2026

SGLang — O Rei dos Cenários Agênticos

O SGLang se consolidou como o framework de referência para cenários onde o agente chama o modelo repetidamente com prompts que compartilham prefixos longos — exatamente o padrão de uso em sistemas agenticos.

O diferencial técnico do SGLang é o RadixAttention: um sistema de cache de KV (key-value attention) que reconhece prefixos compartilhados entre requisições e reutiliza os cálculos. Em um cenário agentico onde o system prompt tem 2000 tokens e muda pouco entre chamadas, o SGLang evita recalcular esses 2000 tokens em cada requisição.

# Instalação e launch do servidor SGLang
pip install sglang[all]

# Servidor para Gemma 4 26B com RadixAttention habilitado
python -m sglang.launch_server \
  --model google/gemma-4-26b-it \
  --tp 2 \                        # tensor parallelism em 2 GPUs
  --enable-flashinfer \           # kernels FlashInfer para velocidade
  --port 30000

# O RadixAttention é ativado por padrão — zero config necessária

# Usando SGLang com programação estruturada
import sglang as sgl

@sgl.function
def pipeline_analise(s, codigo, contexto_projeto):
    s += sgl.system("""Você é um senior engineer revisando código.
    Contexto do projeto: """ + contexto_projeto)

    s += sgl.user(f"Analise este código:\n```\n{codigo}\n```")
    s += sgl.assistant(sgl.gen("issues", max_tokens=512))

    s += sgl.user("Agora sugira refactoring específico para os problemas encontrados.")
    s += sgl.assistant(sgl.gen("refactoring", max_tokens=1024))

    s += sgl.user("Finalmente, estime o impacto de performance das mudanças.")
    s += sgl.assistant(sgl.gen("impact", max_tokens=256))

# Multi-turn compartilha o cache do system prompt entre todas as chamadas
runtime = sgl.Runtime(url="http://localhost:30000")
sgl.set_default_backend(runtime)

state = pipeline_analise.run(
    codigo="def buscar_usuarios(): return db.execute('SELECT * FROM users')",
    contexto_projeto="App de e-commerce, PostgreSQL, 10M usuários"
)

print(state["issues"])
print(state["refactoring"])

Use SGLang quando: você tem um sistema agentico com múltiplos turnos, prompts com prefixos longos compartilhados, ou pipelines de geração estruturada.

Performance típica: 40-60% mais throughput que vLLM em cenários agenticos com prefixos compartilhados.

vLLM — O Padrão da Cloud

O vLLM é o framework mais usado em produção na cloud. Tem o maior ecossistema, a maior comunidade, e é o que a maioria dos provedores gerenciados (Anyscale, Fireworks, Together AI) usa internamente.

O diferencial técnico do vLLM é o PagedAttention: gerenciamento de memória KV inspirado em paginação de sistemas operacionais, que permite servir muito mais requisições simultâneas na mesma GPU sem fragmentação de memória.

# Instalação
pip install vllm

# Servidor OpenAI-compatible
python -m vllm.entrypoints.openai.api_server \
  --model google/gemma-4-26b-it \
  --tensor-parallel-size 2 \
  --max-model-len 131072 \         # 128K context
  --gpu-memory-utilization 0.90 \
  --host 0.0.0.0 \
  --port 8000

# vLLM tem API compatível com OpenAI — drop-in replacement
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"  # não usa key localmente
)

# Mesma interface da OpenAI API
response = client.chat.completions.create(
    model="google/gemma-4-26b-it",
    messages=[
        {"role": "system", "content": "Você é um assistente técnico."},
        {"role": "user", "content": "Explique o conceito de eventual consistency."}
    ],
    temperature=0.7,
    max_tokens=1024
)

print(response.choices[0].message.content)

Use vLLM quando: você tem alta concorrência de usuários diferentes (cada um com contexto distinto), precisa de compatibilidade OpenAI API, ou está fazendo deploy em cloud com GPU compartilhada entre muitas requisições.

Performance típica: melhor throughput de tokens/segundo em alta concorrência com contextos diferentes. Melhor opção para chatbots e APIs de uso geral.

oMLX — O Favorito do Mac

O oMLX é um servidor de inferência construído sobre o framework MLX da Apple, otimizado para Apple Silicon (M-series). Se você desenvolve no Mac, o oMLX é provavelmente a melhor opção para rodar modelos localmente — usa a memória unificada do Apple Silicon de forma muito mais eficiente do que alternativas baseadas em CUDA.

# Instalação (requer Mac com Apple Silicon)
pip install omlx

# Rodar Gemma 4 E4B no M3 Pro
omlx serve google/gemma-4-e4b-it \
  --quantize q4  \               # quantização 4-bit para caber na RAM
  --context-length 32768

# Performance típica no M3 Max (128GB):
# Gemma 4 E4B: ~45 tokens/s
# Gemma 4 26B (q4): ~12 tokens/s

# oMLX também expõe API OpenAI-compatible
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="local"
)

# Desenvolvimento local sem custo de API
response = client.chat.completions.create(
    model="gemma-4-e4b-it",
    messages=[{"role": "user", "content": "Revise este PR diff..."}]
)

Use oMLX quando: você está no Mac com Apple Silicon e quer inferência local rápida, especialmente para desenvolvimento e prototipagem.

Performance típica: 2-4x mais rápido que llama.cpp no mesmo hardware Apple Silicon, usando unified memory de forma muito eficiente.

Ollama — O Mais Simples Para Dev Local

O Ollama ganhou popularidade por uma razão simples: funciona sem configuração. Um comando para instalar, um comando para rodar um modelo. Perfeito para desenvolvimento local e experimentação.

# Instalar Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Baixar e rodar Gemma 4
ollama pull gemma4:26b
ollama run gemma4:26b

# API local automática
curl http://localhost:11434/api/chat -d '{
  "model": "gemma4:26b",
  "messages": [{"role": "user", "content": "Hello"}]
}'

O Ollama não é o mais performático — ele usa llama.cpp por baixo, que é menos eficiente que vLLM ou SGLang em GPU. Mas para desenvolvimento local, a simplicidade supera a performance.

Use Ollama quando: você está desenvolvendo e quer testar rapidamente com um modelo local, fazer prototipagem, ou usar em scripts de automação pessoal.

Não use Ollama quando: você precisa de performance em produção, alta concorrência, ou controle fino sobre a inferência.

A Tabela de Decisão

Benchmark Comparativo (Gemma 4 26B, 2x A100 80GB)

Métrica: tokens/segundo gerados, 100 requisições concorrentes, contexto ~500 tokens

SGLang (com RadixAttention, prefixo de 2000 tokens compartilhado):
  - Input processado: 8.400 tokens/s
  - Output gerado: 3.200 tokens/s
  - Latência P50: 0.8s para 1a token

vLLM (PagedAttention, contextos diversos):
  - Input processado: 5.100 tokens/s
  - Output gerado: 2.800 tokens/s
  - Latência P50: 1.2s para 1a token

TensorRT-LLM (máxima performance, mais complexo de configurar):
  - Input processado: 11.200 tokens/s
  - Output gerado: 4.100 tokens/s
  - Latência P50: 0.5s para 1a token

Ollama (llama.cpp, GPU):
  - Input processado: 1.800 tokens/s
  - Output gerado: 890 tokens/s
  - Latência P50: 3.1s para 1a token

O TensorRT-LLM lidera em performance pura, mas exige configuração complexa e recompilação do modelo para cada hardware. Para a maioria dos times, SGLang ou vLLM oferecem 70-80% da performance do TensorRT com 10% da complexidade operacional.

Considerações de FinOps

A escolha do framework tem impacto direto no custo de infraestrutura. Maior throughput = menos GPUs para a mesma carga de trabalho:

Carga: 10 milhões de tokens gerados/dia, Gemma 4 26B

Com Ollama (llama.cpp): ~12 GPUs A100 necessárias
Com vLLM: ~4 GPUs A100 necessárias
Com SGLang (se agentico): ~2-3 GPUs A100 necessárias

Custo mensal (AWS, p4d.24xlarge ~$32/h):
Ollama: ~$9.200/mês
vLLM: ~$3.100/mês
SGLang: ~$1.500-2.300/mês

Não estou dizendo para nunca usar Ollama em produção — estou dizendo que se você tem carga de produção, a escolha do framework importa tanto quanto a escolha do modelo.

O Setup Que Eu Uso

Para projetos de produção com componente agentico: SGLang no servidor principal, com Ollama no meu Mac para desenvolvimento e testes rápidos antes de subir para o ambiente de staging.

Para APIs de chat com usuários concorrentes: vLLM com o wrapper OpenAI-compatible, que permite trocar para a API real da OpenAI/Anthropic nos ambientes onde o custo de infra própria não compensa.

Para modelos pequenos de classificação/extração que rodam em batch offline: vLLM com offline_inference (processa lista de prompts sem servidor HTTP, mais eficiente para batch jobs).

# vLLM offline inference para batch processing
from vllm import LLM, SamplingParams

llm = LLM(model="google/gemma-4-e4b-it")
sampling_params = SamplingParams(temperature=0.0, max_tokens=64)

# Processa 10.000 textos de uma vez
textos = load_dataset("meu_dataset")
prompts = [f"Classifique o sentimento: {t}" for t in textos]

outputs = llm.generate(prompts, sampling_params)

for output in outputs:
    print(output.outputs[0].text)

Recursos

• SGLang — GitHub e documentação
• vLLM — Documentação oficial
• Ollama — Site oficial
• oMLX — GitHub
• 2026 Ultimate LLM Inference Framework Guide — StableLearn
• Posts relacionados: Gemma 4 — Open Source vs APIs Fechadas · FinOps LLM — Preços Caíram · Token Economics e FinOps de IA