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.
💡Tip: Já identificou o seu nível de VRAM? Veja exatamente qual GPU ou Mac comprar para esse nível — 6 GB → RTX 4060, 12 GB → RTX 4070 Super, 24 GB → RTX 3090/4090, 48 GB+ → Mac mini M5 Pro ou GPU dupla.
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% | — |
💡Tip: Quer essa pontuação de 92,7% no HumanEval a 27 tok/s? Veja a GPU de 24 GB que executa o Qwen3-Coder 32B.
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.1 8B Instruct | Qwen3-Coder 14B para código; Llama 3.1 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.
Qual hardware comprar para implantar o Qwen3?
Primeiro, ajuste o nível de Qwen desejado à VRAM necessária e depois compre a placa mais barata que atenda esse requisito — pagar por mais VRAM do que o modelo precisa é o gasto excessivo mais comum nesta lista. As recomendações abaixo correspondem diretamente à tabela de hardware acima: econômico → RTX 4060, médio porte → RTX 4070 Super, alto desempenho → RTX 3090/4090, Apple Silicon → Mac mini M5 Pro, uso contínuo → um mini PC. Os preços abaixo refletem o mercado de GPUs em 2026 — a escassez de chips de memória e a demanda de data centers de IA encareceram tanto as GPUs novas quanto as configurações de memória da Apple, e no Brasil o imposto de importação amplia ainda mais essa diferença; confirme o preço atual antes de comprar.
💡Tip: Pule esta seção se você já tem uma GPU com 8 GB de VRAM ou mais — primeiro execute o Qwen3 8B no que você já possui. Só compre hardware novo quando atingir esse limite e quiser um modelo maior.
NVIDIA RTX 4060 8 GB
Opção econômica — Qwen3 8B, Qwen3-Coder 7B (5,5 GB de VRAM)
A placa mais barata desta lista que atende ao requisito de 5,5 GB do Qwen3 8B com folga para o contexto. Executa o Qwen3-Coder 7B a ~55 tok/s — velocidade suficiente para assistência de código interativa.
Vantagens
- +O requisito de 5,5 GB de VRAM é atendido com folga para o cache KV de contexto longo
- +Preço mais baixo desta lista — a primeira GPU certa se você nunca executou um LLM local
- +50–57 tok/s em modelos 7B/8B, no mesmo nível de placas mais caras nesse tamanho de modelo
Desvantagens
- –Limita-se ao Qwen3 8B / Qwen3-Coder 7B — sem margem para crescer para 14B sem comprimir o cache KV
NVIDIA RTX 4070 Super 12 GB
Opção intermediária — Qwen3 14B, Qwen3-Coder 14B (9,5 GB de VRAM)
Executa o Qwen3-Coder 14B (85,2% no HumanEval) a 36–38 tok/s, com 2–3 GB de VRAM sobrando para contexto — o nível em que a qualidade de código dá um salto perceptível em relação aos modelos 7B/8B.
Vantagens
- +O modelo de 9,5 GB cabe com 2–3 GB de VRAM sobrando — espaço para janelas de contexto maiores
- +O HumanEval sobe de 75,6% (7B) para 85,2% (14B) — o salto de custo-benefício mais claro da linha
- +~38 tok/s mantêm o chat interativo e a conclusão de código responsivos
Desvantagens
- –VRAM insuficiente para o nível 32B — considere revender ou reaproveitar se precisar ir além do 14B
NVIDIA RTX 4090 24 GB (ou RTX 3090 24 GB usada)
Opção de alto desempenho — Qwen3-Coder 32B, Qwen 3.6 27B (~17–20,5 GB de VRAM)
A 4090 entrega 27–28 tok/s no Qwen3-Coder 32B — velocidade de codificação em tempo real com 92,7% no HumanEval. Uma RTX 3090 usada tem a mesma VRAM de 24 GB e fica cerca de 15% atrás da velocidade de inferência da 4090, por um preço bem menor se você encontrar um anúncio de segunda mão confiável.
Vantagens
- +24 GB de VRAM cobrem todas as variantes do Qwen3 32B e o Qwen 3.6 27B com folga
- +27–28 tok/s no Qwen3-Coder 32B (92,7% no HumanEval) — rápido o suficiente para pair programming em tempo real
- +A RTX 3090 usada é a alternativa econômica: mesmo limite de VRAM, cerca de 15% mais lenta, bem mais barata de segunda mão
Desvantagens
- –Custo inicial mais alto desta lista — só se justifica quando você realmente precisa da qualidade de nível 32B
Apple Mac mini M5 Pro 64 GB
Opção Apple Silicon — Qwen3 32B, silencioso e de baixo consumo
A melhor relação custo-benefício para executar o Qwen3 32B com memória unificada — silencioso, baixo consumo de energia, sem GPU separada para instalar. Para o Qwen2.5-72B, é necessário o M2 Ultra 192 GB.
Vantagens
- +As configurações do M5 Pro chegam a 64 GB de memória unificada — bem acima do requisito de 20,5 GB do Qwen3 32B, com espaço de sobra para outros aplicativos
- +Operação silenciosa e consumo adequado para uso de mesa — sem necessidade de gerenciar refrigeração dedicada de GPU
- +Uma única compra cobre sistema operacional, armazenamento e inferência — sem montagem separada de GPU/fonte/gabinete
Desvantagens
- –Ainda não há benchmarks independentes do Qwen3 32B no chip M5 Pro — espere desempenho visivelmente mais lento que uma GPU dedicada como a RTX 4090, em linha com gerações anteriores de Apple Silicon no Mac mini
MINISFORUM UM890 Pro (ou mini PC AMD Ryzen AI similar)
Opção para uso contínuo — Qwen3 8B em CPU + iGPU (~8–12 tok/s, menos de 35 W)
Não indicado para uso interativo — serve para manter uma instância do Qwen3 8B em execução 24 horas por dia, 7 dias por semana para tarefas em segundo plano, automação residencial ou um endpoint de API de baixo tráfego, em que o custo de energia importa mais que a velocidade.
Vantagens
- +Consumo abaixo de 35 W — barato para rodar continuamente, ao contrário de uma configuração de desktop com GPU
- +Formato compacto cabe em qualquer lugar; sem GPU separada para adquirir ou refrigerar
- +Executa o Qwen3 8B sem nenhuma GPU dedicada
Desvantagens
- –8–12 tok/s é lento demais para chat interativo — opção voltada apenas para uso em segundo plano/API
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. A especificação do Modelfile do Ollama define `num_ctx` como 2048 por padrão, mas o runtime na verdade aplica um padrão escalonado por VRAM: 4K abaixo de 24 GiB, 32K entre 24 e 48 GiB, 256K acima de 48 GiB. Não confie em nenhum dos dois padrões: defina `num_ctx` explicitamente, por exemplo adicionando `--num-ctx 8192` (ou mais) ao comando de execução — caso contrário o modelo trunca a entrada silenciosamente.
- 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.