Orquestração de LLMs Locais no Desktop: Qwen, Gemma e Ollama — do código local ao escalonamento para 6 APIs cloud

O contexto de 2026: IA local virou infraestrutura

A pergunta deixou de ser "dá pra rodar LLM em casa?" e passou a ser "qual modelo pra qual tarefa?". Em 2025-2026 o ecossistema amadureceu: o Ollama chegou na versão 0.30, o Qwen3 e o Gemma 3 trouxeram tool calling nativo e multimodal, e padrões de orquestração que antes eram papel de pesquisa viraram receita de produção — roteamento por tarefa, council multi-modelo (Mixture-of-Agents), pipelines de especialistas. Em maio de 2026 o ritmo acelerou ainda mais: o suporte nativo ao Gemma 4 (arquitetura MoE com ~4B parametros ativos de 26B totais, 256K de contexto e function calling treinado no proprio peso) chegou ao Ollama, e modelos como o Qwen 3.6 (abril/2026, 77,2% no SWE-bench na variante 27B) elevaram a regua do que cabe num desktop. Este curso ja reflete esse cenario e roda na versao 0.30 do Ollama nesta maquina.

O ponto central deste curso é simples e contra-intuitivo: um modelo grande não é a melhor jogada num desktop. A melhor jogada é um time de modelos pequenos, cada um afiado numa coisa, e um orquestrador que manda a tarefa certa pro especialista certo. É o mesmo princípio de uma equipe: você não contrata um gênio pra tudo, você monta um time onde cada um faz o que faz bem.

Neste módulo você vai entender os 3 modelos, o que a sua placa realmente entrega, e — antes de tudo — onde está a fronteira entre o local e a nuvem. Sem essa fronteira clara, você vai tentar usar a ferramenta errada e se frustrar.

Os 3 modelos e seus papéis

O setup roda três famílias, cada uma com um trabalho

1. Qwen-Coder = CÓDIGO. É o cavalo de batalha. O qwen2.5-coder:7b (rota coder_fast) roda 100% na GPU a ~50 tok/s e resolve a maior parte do dia: gerar função, refatorar, explicar trecho, escrever teste. Quando você precisa de qualidade acima da média — um patch mais complexo, raciocínio sobre arquitetura — entra o qwen3-coder:30b (rota coder_heavy), um MoE de 30B com ~3B parâmetros ativos por token: roda em modo híbrido (CPU + RAM), é mais lento, porém entrega melhor. E há ainda o qwen2.5-coder:1.5b-base, minúsculo e residente, dedicado a autocomplete FIM (fill-in-the-middle) dentro do editor.

2. Qwen3 = RACIOCÍNIO. Quando a tarefa é pensar antes de responder — planejar, depurar lógica, decompor um problema —, é o Qwen3 8B. Ele tem dois modos: reason (qwen3-8b-nothink, sem o passo de pensamento, rápido) e reason_think (qwen3:8b, com thinking mode, mais latência mas raciocínio mais profundo). Roda a ~36-42 tok/s.

3. Gemma 3 = VISÃO / MULTILÍNGUE / GERAL. É o modelo multimodal: lê imagens, faz OCR, analisa documento, e fala 140+ idiomas (incluindo PT-BR bem tokenizado). gemma3:4b-it-qat (rota vision/general) é o ponto ótimo de velocidade; gemma3:12b-it-qat (rota vision_heavy/multilingual) entrega mais qualidade quando cabe na VRAM.

Fora do trio, dois coadjuvantes essenciais: `bge-m3` para embeddings (busca semântica, RAG) e o `qwen3-coder:30b` também atuando como *judge* — o juiz que consolida respostas no modo council.

A realidade do hardware: RTX 4060 8GB

Aqui está a parte que separa expectativa de prática. Sua placa tem 8GB de VRAM, com ~6GB efetivamente utilizáveis (1-2GB de margem para o sistema). Isso define duas zonas bem distintas:

Zona verde — 7B/8B, 100% GPU. Modelos de 7-8B cabem inteiros na VRAM e voam. Benchmark medido neste setup numa RTX 4060 8GB, 100% GPU: qwen2.5-coder:7b = ~50 tok/s; qwen3:8b = 36-42 tok/s. É a sua zona de uso interativo fluido — chat, código, raciocínio rápido — e onde você vai passar a maior parte do tempo. Para refazer a medida: pwsh -File D:\Ollama\bench.ps1 -Model qwen2.5-coder:7b (histórico em D:\Ollama\logs\benchmarks.csv).

Zona híbrida — 30B MoE, CPU + RAM. O qwen3-coder:30b não cabe só na GPU. Mas por ser MoE (30B totais, ~3B ativos por token), você empurra os *experts* pra RAM (e os 64GB de RAM da máquina sustentam isso). Resultado: roda mais devagar, porém com qualidade melhor que o 7B. É a peça que você aciona quando vale esperar por uma resposta superior. Em 8GB de VRAM, modelos densos de 13B+ são inviáveis para uso interativo.

O gargalo real do 4060 é a largura de banda de memória. Por isso a regra firme: até 9B para uso interativo; acima disso, só quando velocidade não importa.

O que o local FAZ — e o que NÃO faz

Essa fronteira é o coração da decisão. Errar aqui é usar martelo pra apertar parafuso.

O local FAZ bem:

• Código. O Qwen-Coder cobre geração, refatoração, testes, autocomplete FIM no VS Code (extensão Continue, ~/.continue/config.yaml apontando pro Ollama). É o caso de uso campeão.
• Privacidade. Código proprietário, dados de cliente, documento sensível — nada sai do 127.0.0.1.
• Dev offline. Avião, hotel, rede caindo: o time continua funcionando.
• Embeddings grátis e ilimitados. bge-m3 indexa tudo localmente, sem custo por chamada.
• Experimentação ilimitada. Você itera, testa prompts, roda council, sem olhar o relógio nem a fatura.

O local NÃO faz (fica na nuvem):

• Copy editorial. Texto de venda, posicionamento, peça publicada — a qualidade de redação de um modelo 7-8B local não chega no padrão. Isso continua na nuvem.
• Deep research. Pesquisa profunda, multi-fonte, com verificação — exige modelos de fronteira e ferramentas de busca robustas. Nuvem.

E o enquadramento certo: o local não é economia de fatura. É privacidade e autonomia. Você não roda local pra economizar centavos de API; você roda local porque o dado não pode sair, porque quer iterar sem limite, e porque quer um time que funciona sem internet. Se a sua motivação for só cortar custo, a conta não fecha — o valor está em controle, não em preço.