Key Takeaways
- O Qwen 3.6 27B é a nova escolha principal: denso, Apache 2.0, contexto de 256K, ~17 GB de VRAM em Q4_K_M via `ollama run qwen3.6:27b` (lançado em abril de 2026).
- Qwen3 8B funciona com 5,5 GB de VRAM — um único comando `ollama pull qwen2.5:7b` e já está em execução a 57 tokens/seg em uma RTX 3060.
- Quatro subfamílias práticas: Qwen3 (geral, modo de raciocínio), Qwen2.5 (geral, mais testada), Qwen2.5-Coder (programação, 92,7% no HumanEval em 32B), Qwen2-VL (visão, melhor OCR CJK local).
- Arquitetura densa = compatível com hardware de consumo: ao contrário do modelo MoE de 236B do DeepSeek (~130 GB de RAM), o Qwen2.5-72B cabe em 46 GB de VRAM em duas RTX 3090.
- Multilíngue nativo: pré-treinado em chinês, japonês, coreano, árabe, alemão, francês e mais 23 idiomas — o Qwen3 supera sistematicamente o Llama 3.3 em tarefas CJK.
- Q4_K_M é a quantização correta para a maioria dos usuários: ~55% de redução de VRAM, menos de 1% de perda de qualidade nos benchmarks.
- Decisão de hardware: 12 GB de VRAM → modelo 14B; 24 GB → 32B; 48 GB+ (duas GPUs ou Apple Silicon 64 GB) → 72B.
O Qwen3 cobre três subfamílias de implantação local — uso geral (7B–72B), programação (Coder 7B–32B) e visão (VL 7B–72B) — todas executáveis via Ollama ou LM Studio.
Executar um modelo localmente significa que a IA roda no seu próprio computador em vez de em um servidor na nuvem. Nenhum dado sai da sua máquina e não há custo por token após adquirir o hardware.
Visão geral da família de modelos Qwen
A linha Qwen agora abrange cinco opções práticas: o flagship Qwen 3.6 27B, a família Qwen3 mais recente, o Qwen2.5 de raciocínio geral, o Qwen2.5-Coder e o Qwen2-VL para visão — cada uma com múltiplas opções de tamanho. Todos são modelos de pesos abertos publicados pela equipe Qwen da Alibaba no Hugging Face sob a licença Apache 2.0.
Escolha primeiro a subfamília e depois o tamanho que se encaixa na sua VRAM. É comum combinar subfamílias: Qwen2.5-Coder 14B para autocompletar código e Qwen3 8B ou Qwen 3.6 27B para resumir documentos.
| Subfamília | Tamanhos disponíveis | Uso principal | Prefixo de tag Ollama |
|---|---|---|---|
| Qwen3 | 0,6B, 1,7B, 4B, 8B, 14B, 32B | Raciocínio geral, modo de raciocínio, multilíngue, tarefas agênticas | qwen3: |
| Qwen2.5 | 7B, 14B, 32B, 72B | Raciocínio geral, tarefas em chinês/multilíngue, RAG | qwen2.5: |
| Qwen2.5-Coder | 7B, 14B, 32B | Geração de código, depuração, HumanEval, SWE-bench | qwen2.5-coder: |
| Qwen2-VL | 2B, 7B, 72B | OCR de documentos, perguntas sobre imagens, extração de texto CJK | qwen2-vl: |
O Qwen 3.6 27B (lançado em abril de 2026) é a nova escolha principal — um modelo denso com janela de contexto de 256K que funciona com ~17 GB de VRAM em Q4_K_M via `ollama run qwen3.6:27b`. O Qwen2.5 continua sendo a família mais testada, com a cobertura mais ampla no Ollama e GGUF em meados de 2026.
Requisitos de hardware por tamanho de modelo
Escolha primeiro seu nível de VRAM e depois o maior modelo Qwen3 que caiba. Q4_K_M é a quantização padrão usada em todos os números abaixo — oferece a melhor relação tamanho/qualidade para Ollama e LM Studio.
| Modelo | VRAM | GPU mínima | Apple Silicon | Velocidade (RTX 3060) |
|---|---|---|---|---|
| Qwen3 8B Q4_K_M | 5,5 GB | RTX 3060 6 GB, RTX 4060 | M1/M2 8 GB | ~57 tok/s |
| Qwen3-Coder 7B Q4_K_M | 5,5 GB | RTX 3060 6 GB, RTX 4060 | M1/M2 8 GB | ~55 tok/s |
| Qwen2-VL 7B Q4_K_M | 6,2 GB | RTX 3060 8 GB, RTX 4060 | M1/M2 16 GB | — |
| Qwen3 14B Q4_K_M | 9,5 GB | RTX 4070 12 GB | M2 Pro 16 GB | — |
| Qwen3-Coder 14B Q4_K_M | 9,5 GB | RTX 4070 12 GB | M2 Pro 16 GB | — |
| Qwen3 32B Q4_K_M | 20,5 GB | RTX 3090 24 GB | M3 Max 48 GB | — |
| Qwen3-Coder 32B Q4_K_M | 20,5 GB | RTX 3090 24 GB | M3 Max 48 GB | — |
| Qwen 3.6 27B Q4_K_M | ~17 GB | RTX 4090 24 GB | M3 Max 36 GB | — |
| Qwen2.5-72B Q4_K_M | 46 GB | 2× RTX 3090 (48 GB) | M2 Ultra 64 GB | — |
Os números de VRAM correspondem a arquivos GGUF Q4_K_M da biblioteca do Ollama. Adicione 1–2 GB para o cache KV com um contexto de 4K. Se a GPU tiver menos VRAM do que o modelo precisa, o Ollama descarrega camadas automaticamente para a RAM do sistema — funciona, mas reduz a velocidade significativamente.
Configuração com Ollama
O Ollama é a forma mais rápida de executar qualquer modelo Qwen3 localmente — gerencia o download do modelo, a quantização GGUF e a API local em `localhost:11434` sem nenhuma configuração. Instale a partir de ollama.com. Se você nunca usou o Ollama antes, leia primeiro como instalar o Ollama.
- 1Instalar o Ollama
Why it matters: Disponível para macOS, Linux (instalação em uma linha) e Windows. Não é necessário configurar drivers de GPU — o Ollama detecta CUDA, ROCm e Metal automaticamente. - 2Baixar o modelo com uma tag de tamanho explícita
Why it matters: Sempre especifique o tamanho: `qwen2.5:7b`, `qwen2.5:14b`, `qwen2.5:32b`. O `qwen2.5` sem tag resolve para o modelo 7B, mas pode mudar entre versões do Ollama. - 3Executar o modelo
Why it matters: `ollama run qwen2.5:7b` abre um chat interativo. Digite seu prompt e pressione Enter. Feche com `/bye`. - 4Ajustar a janela de contexto se necessário
Why it matters: O Qwen3 suporta por padrão um contexto de 32K no Ollama. Para usar um contexto de 128K em um modelo 7B, execute `ollama run qwen2.5:7b --num-ctx 131072`. Isso requer mais VRAM. - 5Testar o endpoint da API
Why it matters: O Ollama expõe uma API compatível com OpenAI. Aplicativos como PromptQuorum, Continue.dev e Open WebUI se conectam diretamente a `http://localhost:11434/v1`.
# Instalar o Ollama (Linux)
curl -fsSL https://ollama.com/install.sh | sh
# macOS: baixe o .dmg em ollama.com ou:
brew install ollama
# Baixar modelos — use tags explícitas
ollama pull qwen3.6:27b # flagship, contexto 256K (~17 GB)
ollama pull qwen3:8b # Qwen3 uso geral 8B (~5,5 GB)
ollama pull qwen2.5:7b # Qwen2.5 uso geral 7B (~5,5 GB)
ollama pull qwen2.5:14b # Qwen2.5 uso geral 14B (~9,5 GB)
ollama pull qwen2.5:32b # Qwen2.5 uso geral 32B (~20,5 GB)
ollama pull qwen2.5-coder:32b # Qwen2.5-Coder 32B (~20,5 GB)
ollama pull qwen2-vl:7b # visão 7B (~6,2 GB)
# Executar em modo interativo
ollama run qwen2.5:7b
# Testar a API compatível com OpenAI
curl http://localhost:11434/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"model":"qwen2.5:7b","messages":[{"role":"user","content":"Olá"}]}'Configuração com LM Studio
O LM Studio oferece uma interface gráfica para o Qwen3 sem precisar de comandos no terminal. Baixe em lmstudio.ai ou consulte como instalar o LM Studio. Funciona no macOS, Windows e Linux.
- 1Abrir o navegador de modelos
Why it matters: Pesquise "Qwen3" ou "Qwen Coder" para explorar todos os builds GGUF disponíveis. Filtre por Q4_K_M para a relação qualidade/tamanho recomendada. - 2Baixar um build GGUF
Why it matters: Selecione a variante Q4_K_M. O LM Studio mostra o tamanho do arquivo antes do download — confirme que se encaixa na VRAM disponível. - 3Carregar o modelo e começar a conversar
Why it matters: Clique no modelo na barra lateral esquerda para carregá-lo na memória. A alocação de camadas para a GPU é automática com base na VRAM detectada. - 4Iniciar o servidor local
Why it matters: "Iniciar servidor" expõe um endpoint compatível com OpenAI em `localhost:1234`. Seus aplicativos e scripts se conectam a ele como se fosse a API da OpenAI.
Quantização: qual formato escolher
Q4_K_M é o padrão correto para o Qwen3 em hardware de consumo. Reduz a VRAM em 55–60% em relação ao FP16 com menos de 1% de degradação no MMLU e HumanEval. Outros formatos têm casos de uso específicos:
Q4_K_M é a melhor quantização do Qwen3 para a maioria dos usuários: reduz a VRAM em 55% com menos de 1% de perda de qualidade em relação ao FP16.
A quantização comprime os números do modelo de 16 bits para 4 bits, reduzindo aproximadamente pela metade o tamanho do arquivo e a VRAM necessária. É como passar de TIFF para JPEG de alta qualidade — arquivo menor, resultado quase idêntico para a maioria dos usos.
- Q4_K_M (recomendado): ~5,5 GB para 7B. A melhor relação qualidade por GB. Comece por este.
- Q8_0: ~8,5 GB para 7B. Qualidade próxima ao FP16; use se tiver VRAM sobrando e quiser máxima precisão.
- Q5_K_M: ~6,5 GB para 7B. Melhoria marginal sobre Q4_K_M — escolha apenas se a qualidade de saída do Q4_K_M for visivelmente deficiente para sua tarefa.
- Q2_K: ~3 GB para 7B. O arquivo menor, mas a qualidade de saída em chinês se degrada notavelmente — evite com Qwen3 se o chinês faz parte do seu caso de uso.
- IQ4_XS: ~4,8 GB para 7B. Uma quantização imatrix mais recente que supera a qualidade do Q4_K_M com um tamanho ligeiramente menor — disponível em versões recentes do llama.cpp e LM Studio 0.3+.
Desempenho em benchmarks em hardware de consumo
O Qwen3 32B Q4_K_M em uma RTX 4090 entrega 28 tokens/seg — velocidade suficiente para assistência de código em tempo real. As pontuações abaixo correspondem a builds GGUF Q4_K_M testados no Ollama.
| Modelo (Q4_K_M) | MMLU | Math | HumanEval | Velocidade (RTX 3060 12 GB) |
|---|---|---|---|---|
| Qwen3 8B | 74,2% | 58,8% | 57,3% | 57 tok/s |
| Qwen3 14B | 79,9% | 69,8% | 64,6% | — |
| Qwen3 32B | 83,3% | 79,5% | 71,3% | — |
| Qwen2.5-72B | 86,1% | 83,1% | 73,2% | — |
| Qwen3-Coder 7B | — | — | 75,6% | 55 tok/s |
| Qwen3-Coder 14B | — | — | 85,2% | — |
| Qwen3-Coder 32B | — | — | 92,7% | — |
Qwen vs DeepSeek vs Llama: o que executar localmente
O Qwen3 vence em tarefas em chinês e eficiência de VRAM; o DeepSeek-V2.5 vence em raciocínio em grande escala mas é impraticável em hardware de consumo; o Llama 3.3 70B é a melhor opção em uma única GPU se você preferir o modelo aberto da Meta.
| Nível de VRAM | Melhor Qwen | Melhor concorrente | Veredicto |
|---|---|---|---|
| 6 GB | Qwen3 8B | Llama 3.2 3B (cabe, mas apenas 3B) | Qwen3 8B vence — mesma VRAM, modelo muito maior |
| 12 GB | Qwen3-Coder 14B | Llama 3.3 8B Instruct | Qwen3-Coder 14B para código; Llama 3.3 8B para chat geral |
| 24 GB | Qwen3-Coder 32B | Llama 3.3 70B (com descarregamento) | Qwen3-Coder 32B para código; Llama 3.3 70B se qualidade > velocidade |
| 48 GB+ | Qwen2.5-72B | DeepSeek-V2.5 236B MoE | DeepSeek precisa de ~130 GB de RAM; Qwen2.5-72B é a opção prática para 48 GB |
Usuários brasileiros: soberania de dados e implantação local
Executar o Qwen3 localmente significa que nenhum dado sai da sua máquina — sem transferência para servidores na nuvem, sem exposição sob a LGPD ou outras leis de proteção de dados brasileiras. APIs de LLM na nuvem exigem enviar prompts para servidores externos, o que aciona os requisitos de tratamento de dados e possíveis transferências internacionais.
O Qwen3 foi treinado pela equipe Qwen da Alibaba em um corpus predominantemente chinês e multilíngue. É o modelo com implantação local mais poderoso para documentos em chinês simplificado, chinês tradicional e textos mistos.
Para implantações em empresas brasileiras: uma configuração do Qwen3 sem conexão à internet durante a inferência é totalmente compatível com a Lei Geral de Proteção de Dados (LGPD) e as diretrizes da ANPD. O modelo roda inteiramente em hardware local — nenhum terceiro acessa os dados de entrada ou saída.
O Qwen3 funciona completamente offline após o download — nenhum dado sai da sua máquina, eliminando o risco de transferência transfronteiriça de dados sob a LGPD e as regulamentações da ANPD.
Quando você executa o Qwen3 localmente, seus prompts e documentos nunca saem do seu computador. Não há chamadas para uma API na nuvem, não há servidor externo e não há dados acessíveis por reguladores ou terceiros.
Recomendações de hardware por orçamento
A RTX 3060 12 GB é o melhor ponto de entrada para o Qwen3 8B e Qwen3-Coder 7B por menos de R$ 1.500. Para modelos 14B, a RTX 4070 12 GB adiciona 35% de velocidade.
- Econômico (Qwen3 8B): NVIDIA RTX 4060 8 GB ou RTX 3060 12 GB. Ambas gerenciam modelos 7B a 50–57 tokens/seg. A RTX 3060 12 GB geralmente é mais barata de segunda mão e tem mais margem de VRAM.
- Médio porte (Qwen3 14B): RTX 4070 12 GB ou RTX 4070 Super 12 GB. A 4070 Super executa o Qwen3-Coder 14B a 38–42 tokens/seg.
- Alto desempenho (Qwen3 32B): RTX 4090 24 GB ou RTX 3090 24 GB. A 4090 entrega 27–28 tok/s no Qwen3-Coder 32B — velocidade de assistência de código em tempo real.
- Apple Silicon (todos os tamanhos): Mac mini M4 Pro 48 GB oferece a melhor relação custo-benefício para executar o Qwen3 32B (~22 tok/s) com baixo ruído e consumo.
- Mini PC para uso contínuo: MINISFORUM UM890 Pro ou PC AMD Ryzen AI similar. Executa o Qwen3 8B em CPU+iGPU a ~8–12 tok/s — lento, mas capaz de funcionar 24/7 com menos de 35 W de consumo.
Erros frequentes ao executar o Qwen3 localmente
- Usar o comando `ollama pull qwen2.5` sem tag de tamanho. Sem uma tag de tamanho explícita (`:7b`, `:14b`, etc.), o Ollama pode resolver para o tamanho padrão, que pode mudar entre atualizações da biblioteca. Sempre use tags explícitas: `ollama pull qwen2.5:14b`.
- Ignorar o tamanho da janela de contexto. O Qwen3 suporta um contexto de 128K, mas o Ollama usa 2K por padrão para `num_ctx`. Se você processa documentos longos, adicione `--num-ctx 8192` (ou mais) ao comando de execução.
- Escolher quantização Q2_K para uso em chinês. A 2 bits de precisão, a saída em chinês do Qwen3 se degrada notavelmente. Use Q4_K_M no mínimo para qualquer trabalho em chinês.
- Executar o modelo 32B com pouca VRAM. Se a GPU tiver 16 GB e o modelo precisar de 20,5 GB, o Ollama descarrega camadas para a RAM do sistema. O modelo funciona mas a 3–5 tok/s — inutilizável para uso interativo.
- Usar a subfamília errada para programação. O Qwen3 8B (uso geral) pontua 57,3% no HumanEval. O Qwen3-Coder 7B pontua 75,6% — uma melhoria relativa de 32%. Para código, sempre use a variante Coder do mesmo tamanho.
Próximos passos
- Melhores LLMs apenas CPU — Sem GPU? Veja quais tamanhos do Qwen3 rodam só no CPU →
- Quantização de LLM explicada — Confuso com Q4_K_M vs Q8? Quantização explicada →
Perguntas frequentes
Quanta VRAM preciso para executar o Qwen3 8B localmente?
O Qwen3 8B Q4_K_M requer 5,5 GB de VRAM. Uma RTX 3060 6 GB, RTX 4060 ou chip Apple M com 8 GB de memória unificada são suficientes.
Qual é o melhor modelo Qwen para programação localmente?
Qwen3-Coder 32B — 92,7% no HumanEval, precisa de GPU de 24 GB. Com 12 GB de VRAM ou menos: Qwen3-Coder 14B (85,2%, 9,5 GB de VRAM).
Como o Qwen se compara ao DeepSeek para implantação local?
O Qwen3 usa arquitetura densa compatível com hardware de consumo. O DeepSeek-V2.5 é um modelo MoE de 236B que precisa de ~130 GB de RAM — inviável sem GPU de servidor.
Posso executar o Qwen em um Mac?
Sim. M2 Pro 32 GB executa o Qwen3 14B a ~32 tok/s. M3 Max 64 GB gerencia o Qwen3 32B a ~22 tok/s.
Qual comando do Ollama uso para o Qwen?
Para o flagship, `ollama run qwen3.6:27b` (~17 GB de VRAM). Para o Qwen3, `ollama pull qwen3:8b`. Para o Qwen2.5, `ollama pull qwen2.5:7b` para 7B, `:14b` para 14B, `:32b` para 32B, ou `qwen2.5-coder:32b` para a variante de programação. Sempre use tags de tamanho explícitas.
O Qwen é adequado para tarefas em chinês?
Sim. O Qwen3 foi pré-treinado em um grande corpus chinês e suporta nativamente chinês simplificado, chinês tradicional, japonês, coreano e mais 24 idiomas.
Qual quantização devo usar para o Qwen3?
Q4_K_M por padrão — reduz a VRAM ~55% em relação ao FP16 com menos de 1% de perda de qualidade. Evite Q2_K para uso em chinês.
O Qwen2-VL funciona para OCR de documentos em chinês?
Sim — `ollama pull qwen2-vl:7b`, ~6 GB de VRAM, lê texto CJK em resoluções de até 4096×4096 pixels.