🔀 LiteLLM Proxy
O LiteLLM é um proxy que traduz APIs — ele faz seu modelo local parecer uma API do Claude para qualquer cliente. Isso significa que você pode usar o Claude Code CLI (com toda a sua UX refinada) apontando para um modelo Qwen3 rodando localmente. Zero custo de API, toda a experiência do Claude Code.
Configurando LiteLLM + Claude Code
# litellm_config.yaml
model_list:
- model_name: claude-sonnet-4-6
litellm_params:
model: ollama/qwen3-coder-next
api_base: http://localhost:11434# Terminal 1: iniciar o proxy
pip install litellm
litellm --config litellm_config.yaml --port 44000
# Terminal 2: usar Claude Code com modelo local
export ANTHROPIC_BASE_URL=http://localhost:44000
export ANTHROPIC_AUTH_TOKEN=sk-local
claude # Agora usa Qwen3 local!model_name: deve bater com o modelo que o Claude Code espera (ex: claude-sonnet-4-6)
ollama/: prefixo que diz ao LiteLLM para usar o provider Ollama
ANTHROPIC_BASE_URL: redireciona todas as chamadas do Claude Code para o proxy local
💡 Toda a UX do Claude Code, Grátis
Com o LiteLLM proxy, você ganha: auto-complete, tool calling nativo, histórico de sessão, permissões por ferramenta e toda a interface do Claude Code — sem pagar um centavo de API. A qualidade das respostas depende do modelo local, mas a experiência de uso é idêntica.
👥 Multi-Agente Local
Por que rodar um agente quando você pode rodar três? Com multiprocessing, você spawna agentes especializados em paralelo — um pesquisa, outro codifica, outro testa. É o mesmo conceito do Army Mode do Claude Code, mas rodando 100% local sem custos de API.
Spawning Multi-Agente com Multiprocessing
import multiprocessing
def worker_agent(task, model, result_queue):
result = agent_loop(task, model=model)
result_queue.put(result)
# Spawnar 3 agentes em paralelo
queue = multiprocessing.Queue()
workers = [
multiprocessing.Process(
target=worker_agent,
args=(task, 'qwen3:8b', queue)
)
for task in ['research', 'code', 'test']
]
for w in workers: w.start()
for w in workers: w.join()
# Coletar resultados
results = []
while not queue.empty():
results.append(queue.get())multiprocessing.Process: cada agente roda em processo separado — isolamento total
Queue: comunicação entre processos — resultados vão para uma fila compartilhada
VRAM compartilhada: o Ollama gerencia a VRAM — múltiplos agentes com o mesmo modelo compartilham os pesos
📊 Army Mode Local
Claude Code Army Mode: spawna até 5 sub-agentes para tarefas paralelas — usa API com custo por token
Nossa versão local: mesmo conceito, custo zero — limitado apenas pela VRAM disponível
Limitação: modelos menores (8B) produzem resultados menos confiáveis em tarefas complexas — use para tarefas bem definidas
📊 Benchmarks
Números reais importam. Antes de escolher um modelo para seu agente, você precisa entender os trade-offs entre qualidade (SWE-bench), custo (VRAM + API), e latência. Aqui está a comparação direta entre os principais modelos para agentes de código.
Comparativo de Modelos para Agentes
| Modelo | SWE-bench | VRAM | Custo | Latência |
|---|---|---|---|---|
| Claude Opus 4.6 | 72-77% | N/A (API) | $$$ | 0.5-2s |
| Qwen3-Coder-Next | 69.6% | 35-40GB | $0 | 2-5s |
| Qwen3-Coder:30b | ~50% | 20GB | $0 | 1-3s |
| Qwen3:32b | ~45% | 20GB | $0 | 1-3s |
| Qwen3:8b | ~35% | 5GB | $0 | 0.5-1s |
| Qwen2.5-Coder:7b | ~30% | 4GB | $0 | 0.5-1s |
💡 O Sweet Spot
O Qwen3-Coder-Next é o sweet spot para quem tem GPU com 40GB+ de VRAM: 69.6% no SWE-bench (próximo do Claude) a custo zero. Para GPUs menores (8-16GB), o Qwen3:8b é surpreendentemente capaz para tarefas simples de código como leitura, busca e edições pequenas.
⚖️ Quando Usar Local vs API
Não é "local OU API" — é "local E API, cada um no seu contexto". Entender quando usar cada abordagem é a diferença entre gastar $0 onde poderia e desperdiçar qualidade onde não deveria.
Guia de Decisão: Local vs API
| Use Case | Local | API |
|---|---|---|
| Desenvolvimento/teste | ✓ | |
| Dados sensíveis | ✓ | |
| Custo zero | ✓ | |
| Qualidade máxima | ✓ | |
| Contexto > 128K | ✓ | |
| Produção crítica | ✓ | |
| Experimentação | ✓ |
Fazer
- ✓ Usar local para desenvolvimento diário e testes rápidos
- ✓ Escalar para API quando a tarefa exige qualidade máxima
- ✓ Manter dados sensíveis sempre local — nunca enviar para API
- ✓ Implementar routing automático baseado em complexidade
Evitar
- ✗ Usar API para tarefas simples que o local resolve bem
- ✗ Confiar em modelo 8B para refactoring complexo de produção
- ✗ Ignorar custos de API quando local resolve 90% dos casos
- ✗ Tratar local e API como mutuamente exclusivos
🛠️ Frameworks Alternativos
Nosso agente custom não é a única opção. Vários frameworks maduros suportam Ollama nativamente ou via adaptadores. A escolha depende do seu caso de uso: simplicidade, workflows complexos, multi-agente ou controle total.
Comparativo de Frameworks
| Framework | Melhor Para | Ollama? |
|---|---|---|
| smolagents | Agentes simples, code-first | Nativo |
| LangGraph | Workflows complexos | Via ChatOllama |
| Qwen-Agent | Modelos Qwen específico | Nativo |
| CrewAI | Times multi-agente | Via LiteLLM |
| Custom (nosso!) | Controle total | Direto |
💡 ~120 Linhas = Controle Total
Nosso agente custom é ~120 linhas de Python e dá controle total sobre cada aspecto: loop, ferramentas, memória, permissões e contexto. Frameworks adicionam conveniência mas também adicionam dependências, abstrações e pontos de falha. Para aprender, custom é imbatível. Para produção, avalie cada framework no seu caso de uso.
🔮 O Futuro: Agentes Híbridos
O futuro não é "local ou API" — é agentes híbridos que automaticamente escolhem o modelo certo para cada tarefa. Leitura de arquivo? Modelo local de 8B, instantâneo. Refactoring de 500 linhas? Escala para Claude via API. Routing inteligente baseado em complexidade.
Arquitetura do Agente Híbrido
Tarefas simples (local): leitura de arquivos, busca em código, navegação de diretórios, edições pequenas — resposta em milissegundos, custo zero
Tarefas complexas (API): refactoring pesado, debugging de bugs difíceis, geração de código complexo, decisões de arquitetura — qualidade máxima quando importa
Routing inteligente: classificador que analisa a complexidade da tarefa e direciona para local ou API automaticamente
Fallback automático: se o modelo local falha (output ruim, loop infinito), escala automaticamente para API
💡 O Modelo Mental Correto
Pense em modelos como ferramentas no toolbox: você não usa uma marreta para pregar um prego. O modelo local de 8B é o martelo — rápido, barato, eficiente para o dia a dia. O Claude via API é a marreta — quando precisa de força bruta para problemas complexos. O agente híbrido escolhe a ferramenta certa automaticamente.
📊 Economia do Modelo Híbrido
90% das operações são simples: leitura, busca, navegação — modelo local resolve em milissegundos a custo zero
10% das operações são complexas: refactoring, debugging, decisões — API garante qualidade quando importa
Resultado: redução de ~90% nos custos de API mantendo qualidade onde ela importa — o melhor dos dois mundos
📋 Resumo do Módulo
🎓 Parabéns! Curso Completo.
Você completou todas as 6 trilhas do curso "Por Dentro do Claude Code". De arquitetura interna a agentes locais, você agora tem o conhecimento para entender, construir e otimizar agentes de IA.
Próximos Passos
Construa seu próprio agente com o código das Trilhas 5 e 6
Experimente diferentes modelos via Ollama — encontre o sweet spot para seu hardware
Contribua com a comunidade open-source de agentes de IA