SLMs vs LLMs: quando usar modelos pequenos em vez do GPT da vida

Há um meme que SLM (Small Language Model) é para "quando você quer usar IA mas não quer pagar". É mentira. Bem, é parcialmente verdade.

A verdade completa é mais nuançada: SLMs (modelos de 3B a 15B parâmetros) são ideais para tarefas específicas. Nem sempre custam menos — às vezes custam mais porque você roda localmente e paga infraestrutura. Mas você ganha latência, privacidade e previsibilidade.

Este post é pra você entender quando SLM faz sentido vs quando GPT-4o é o caminho.

O que é SLM?

Historicamente, "pequeno" era relativo. Agora temos:

• Nano: 1-2B (smartphones, edge devices)
• Micro: 2-7B (Phi-3, Gemma 2 2B)
• Small: 7-13B (Llama 3.1 8B, Mistral 7B, Phi-3-medium)
• Medium: 13-40B (Llama 3 70B, Mixtral 8x7B)
• Large: 40B+ (GPT-4o, Claude 3.5, Llama 3 405B)

SLMs, pra esse artigo, significa Small + Medium — tudo que roda em GPU consumer ou CPU razoável sem paralelização.

Características de SLM bem-feito:

• Treinado em dados curados (não "tudo que existe na internet")
• Otimizado pra tarefa específica (classificação, extração, reranking)
• Context window moderado (4K-8K, não 200K)
• Token count previsível

SLM vs LLM em 5 dimensões

Dimensão	SLM	LLM
Custo por token	$0.0001-0.001 (API) / zero (local)	$0.01-0.10
Latência	50-200ms (local) / 100-300ms (API)	300-1000ms
Memória	4-15 GB	50+ GB
Qualidade geral	70-85% GPT-4o	90-98%
Privacidade	Total (on-device)	Depende provider

SLM ganha em custo, latência, privacidade. LLM ganha em qualidade, flexibilidade, raciocínio.

Casos de uso onde SLM é melhor

1. Classificação

Task: "Este ticket é urgente?"

entrada: "PRODUTO VEIO QUEBRADO QUERO MEU DINHEIRO DE VOLTA"
saída: urgente (confidence: 0.97)

custo com Llama 3.1 8B: ~$0.0001
custo com GPT-4o: ~$0.005

Llama 8B consegue fazer isso com 95% de acurácia. GPT-4o tem 97%. Vale gastar 50x mais? Não, não vale.

2. Extração estruturada

Task: "Extraia nome, email, telefone deste contato"

entrada: {
  "texto": "Olá sou João Silva, email joao.silva@example.com, fone (11) 98888-7777"
}

saída: {
  "nome": "João Silva",
  "email": "joao.silva@example.com",
  "telefone": "(11) 98888-7777"
}

SLM bom em regex estruturado. Phi-3 8B retorna JSON válido 98% das vezes.

3. Roteamento / Decision-making

Task: "Esta conversa é sobre suporte técnico ou cobrança?"

SLM rápido (50ms) decide. Depois escalona pro agente certo. LLM seria overkill.

4. Re-ranking

Task: "De 10 documentos, ordene por relevância"

Retrieval traz top-10. Llama 8B reordena em 200ms. GPT-4o levaria 1s. Ambos acertam, mas SLM é 5x mais rápido.

5. Summarização de contexto

Task: "Resuma esse log de 5000 tokens em 100 tokens"

Missão: resumir, não raciocinar. SLM mantém essências, remove ruído.

Casos onde LLM ainda vence

1. Raciocínio multi-step

Task: "Como faço uma integração OAuth2 com microsserviços em Kubernetes?"

Precisa de knowledge profundo + capacidade de conectar conceitos. SLM sabe OAuth2, sabe Kubernetes, mas pode não conectar bem. LLM conecta.

2. Creative writing / ideation

Task: "Crie 5 headlines para um produto de finanças"

SLM gera baseline. LLM gera headlines que fazem sentido e vendem.

3. Reasoning com constraints

Task: "Otimize essa query SQL levando em conta índices e cardinality estimates"

Exige raciocínio fino. SLM não consegue explorar trade-offs. LLM consegue.

4. Few-shot com padrões complexos

Task: "Classifique sentimento em português com 2 exemplos de edge case"

Llama pode perder. GPT-4o captura nuança.

Modelos SLM notáveis em 2026

Phi-3 (Microsoft)

Phi-3-mini: 3.8B params, 4K context, treinado em "high quality data"
Phi-3-small: 7B params, 8K context
Phi-3-medium: 14B params, 128K context

Performance: 80% de GPT-3.5 em 3% do tamanho
Custo API: $0.00035 / 1M input tokens (barato)

Phi-3 é incrivelmente pequeno e bom pra tamanho. Roda em laptop.

Llama 3.1 8B (Meta)

8B params, 128K context, totalmente open
Performance: 85% de GPT-4o em reasoning
Custo: Zero (rodando local) ou $0.0003 (API)

Benchmark favorito de muita gente. Equilibrado, bom Português.

Gemma 2 (Google)

2B e 9B variants, 8K context, open
Performance: Gemma-9B ≈ Llama-8B
Custo: Zero (local) ou $0.00005 (API)

Muito bem otimizado. 2B roda em smartphone.

Mistral 7B (Mistral AI)

7B params, 32K context, open
Performance: 80% GPT-4o
Custo: $0.00007 (API)

Rápido, barato, popular em Europa.

Fine-tuning SLM: estratégia barata

Fine-tuning LLM custa fortune (milhares de dólares).

Fine-tuning SLM? Centenas:

Hardware: RTX 4090 ($1.5k aluguel)
Tempo: 2-4 horas pra 10k exemplos
Custo: ~$20-50 com Paperspace/Runpod
Resultado: Llama 8B customizado pro seu domínio

Workflow:

1. Colete 10k exemplos do seu domínio (suporte técnico, jurídico, etc)
2. Fine-tune Llama 3.1 8B no seu dataset
3. Deploy localmente ou via API
4. Qualidade específica de domínio, custo 10x menor

Exemplo:

# 1. Preparar dataset
dataset = [
    {
        "input": "Qual é a taxa de juros?",
        "output": "A taxa é 1.5% ao mês conforme a tabela XXXXX"
    },
    # ... 10k exemplos
]

# 2. Fine-tune (usando Unsloth pra speedup)
model = AutoModelForCausalLM.from_pretrained("unsloth/llama-3-8b")
trainer = SFTTrainer(model, dataset, ...)
trainer.train()

# 3. Deploy local ou via vLLM
model.save_pretrained("./meu_modelo_dominio")

# 4. Rodar
output = model.generate("Qual é a taxa de juros?")

Custa pouco, funciona bem pra domínio específico.

Rodando SLM localmente

Ollama (mais fácil)

ollama pull llama2:7b
ollama run llama2:7b "Olá, qual é o Python?"

# Agora está disponível em localhost:11434
curl http://localhost:11434/api/generate \
  -d '{"model":"llama2:7b","prompt":"Olá"}'

Pronto. LLM rodando local.

llama.cpp (mais rápido)

# Quantizar modelo pra CPU otimizado
./quantize ./llama-7b.gguf ./llama-7b-q4.gguf q4_0

# Rodar
./main -m ./llama-7b-q4.gguf -p "Olá"

Mais complicado, mas 2-3x mais rápido que Ollama.

vLLM (pra produção)

from vllm import LLM

llm = LLM(model="meta-llama/Llama-3-8b-instruct")
outputs = llm.generate([
    "Classifique o sentimento: Produto excelente!",
    "Classifique o sentimento: Terrível, não funciona"
])

vLLM é batching inteligente, multi-GPU, otimizado. Benchmark: 10-40x mais throughput que naive inference.

Matriz de decisão: SLM vs LLM

Task: Classificação de sentimento

├─ Domínio bem-definido? (urgente/normal/baixo)
│  ├─ Sim → SLM (Phi-3 7B) ✓
│  └─ Não → LLM
│
├─ Latência crítica? (< 100ms)
│  ├─ Sim → SLM (local) ✓
│  └─ Não → depende custo
│
├─ Custo é fator? (volume > 1M/mês)
│  ├─ Sim → SLM ✓
│  └─ Não → LLM (melhor qualidade)
│
└─ Privacidade? (dados sensíveis)
   ├─ Sim → SLM (on-device) ✓
   └─ Não → depende tradeoff

Se 3+ fatores apontam SLM, use SLM. Se 2+ apontam LLM, use LLM.

O hype vs realidade

Hype: "SLMs vão substituir LLMs"

Realidade: SLMs são ferramentas muito boas pra problemas específicos. Não substituem LLMs pra reasoning, criatividade, knowledge broad.

Recomendação: arquitetura em camadas.

entrada → SLM rápido (classificação) → escalona
         └─ se confiança alta: responde
         └─ se confiança baixa: LLM + RAG
         └─ se crítico: human-in-the-loop

Isso é eficiente. SLM trata 70% das queries rápido e barato. LLM trata 20% complexas e caras. Humans tratam 10% críticas.

Começar local, escalar depois

Passo 1: Rode Llama 3.1 8B localmente via Ollama. Custa zero, aprende como funciona.

Passo 2: Se performance é bom e quer usar em produção, deploy em vLLM + GPU.

Passo 3: Se quer managed, use API (Together, Anyscale, Groq).

Passo 4: Se quer otimizar muito, fine-tune seu SLM pra seu domínio específico.

A gente na Alienhub trabalha com muita mistura: SLM pra roteamento, LLM pra reasoning, fine-tuned SLM pra domínio. Depende do problema.

Se você está usando GPT-4o pra tudo, provável que está gastando 10x do necessário. Se você está tentando usar SLM pra raciocínio complex, provável que está frustrado pela qualidade.

Conversa pra avaliar onde seu pipeline sairia ganhando com SLMs?