A pergunta mais comum que recebemos de iniciantes em LLMs locais em 2026 não é 'qual modelo devo usar?', mas sim 'esse modelo funcionará na minha GPU?'
Este guia é a resposta: as necessidades de VRAM de cada LLM open major em cada quantização comum, para hardware variando de uma RTX 3060 12 GB a uma H100 80 GB — a cola que gostaríamos que tivesse existido.
Um lembrete para os impacientes: A VRAM é a restrição determinante. Se o seu modelo + cache KV + contexto não couberem na VRAM, o desempenho da inferência cai drasticamente. Tudo abaixo pressupõe que você deseja realizar inferência puramente na GPU; se estiver disposto a utilizar descarga para a CPU, divida a taxa de processamento por um fator entre 5 e 10.
Principais conclusões
- VRAM de 12 GB: Modelos de 7–8 B em Q5+ e de 13 B em Q4. Llama 3 8B, Mistral 7B, Phi-4 Mini.
- 16 GB de VRAM: 13–14 B em Q5+. Faixa incômoda — excesso para modelos de 8 B, mas insuficiente para modelos de 30 B.
- 24 GB de VRAM: 30 B em Q4_K_M (Q5_K_M é um arquivo ~23.3 GB, muito apertado uma vez que o KV cache é adicionado); 70 B apenas em 2-bit (IQ2_XXS) ou com CPU offload. O ponto ótimo.
- 32 GB de VRAM: 30 B em Q5_K_M com espaço para contexto longo; 70 B apenas em Q3_K_S (~31 GB, apertado).
- 48 GB de VRAM: 70 B em Q4_K_M (~42.5 GB) confortavelmente; 104 B apenas em Q3_K_S ou menor (apertado).
- 128 GB unificado (Apple Silicon): 123 B em Q4_K_M; 405 B apenas em ~2-bit. Mais lento por token que Nvidia.
Resposta rápida
Regra prática: os pesos de um LLM precisam de cerca de 2 GB de VRAM por bilhão de parâmetros em FP16, pouco acima de 1 GB por bilhão em 8-bit (Q8_0) e cerca de 0.6 GB por bilhão em 4-bit (Q4_K_M), mais espaço para o KV cache, que cresce com o comprimento do contexto. Para um 70 bilhões de parâmetros isso resulta em aproximadamente 141 GB em FP16, 75 GB em Q8_0 e 42.5 GB em Q4_K_M (o tamanho do arquivo Llama 3 70B Q4_K_M GGUF), então rodar 70B na quantização 4-bit recomendada leva cerca de 48 GB de VRAM: duas placas RTX 3090/4090 24 GB, uma RTX A6000 48 GB ou 6000 Ada, ou um Mac com 64 GB ou mais de memória unificada. Uma única placa 24 GB cabe em 70B apenas em 2-bit (IQ2_XXS, cerca de 19 GB, com perda de qualidade clara) ou com CPU offload lento, e uma RTX 5090 32 GB atinge Q3_K_S (cerca de 31 GB). Para verificar um modelo específico, quant e comprimento de contexto, use nossa Calculadora de VRAM para LLMs.
Tabela de referência rápida
Todos os principais LLMs abertos de 2026 e suas necessidades de VRAM em níveis comuns de quantização. Os valores referem-se apenas aos pesos do modelo: colunas quantizadas são tamanhos de arquivo GGUF de repositórios Hugging Face públicos (principalmente bartowski; «—» onde nenhum arquivo assim é publicado), e FP16 é cerca de 2 bytes por parâmetro. Adicione KV cache no topo: aproximadamente 0.5–4 GB por 8 K de contexto em FP16, dependendo do modelo (veja a tabela de KV cache abaixo).
| Modelo | FP16 | Q8_0 | Q5_K_M | Q4_K_M | Q3_K_M | IQ2_XXS |
|---|---|---|---|---|---|---|
| Phi-4 Mini (3,8 B) | 7,7 GB | 4,1 GB | 2.8 GB | 2.5 GB | 2.1 GB | — |
| Gemma 2 2B | 5,2 GB | 2.8 GB | 1,9 GB | 1.7 GB | 1.5 GB | 0.9 GB |
| Llama 3 8B | 16,1 GB | 8,5 GB | 5,7 GB | 4,9 GB | 4,0 GB | 2.4 GB |
| Mistral 7B v0.3 | 14,5 GB | 7,7 GB | 5,1 GB | 4,4 GB | 3.5 GB | 2.0 GB |
| Qwen 2.5 7B | 15,2 GB | 8,1 GB | 5,4 GB | 4,7 GB | 3,8 GB | 2,3 GB |
| Phi-4 (14 B) | 29.3 GB | 15.6 GB | 10.6 GB | 9.1 GB | 7,4 GB | 4,1 GB |
| Qwen 2.5 14B | 29,5 GB | 15,7 GB | 10,5 GB | 9,0 GB | 7,4 GB | 4,3 GB |
| Mistral Nemo 12B | 24,5 GB | 13,0 GB | 8,7 GB | 7,5 GB | 6,1 GB | 3,6 GB |
| Qwen 2.5 32B | 65.5 GB | 34.8 GB | 23.3 GB | 19,8 GB | 15.9 GB | 9,0 GB |
| Yi-1.5 34B | 68,5 GB | 36,4 GB | 24,3 GB | 20,7 GB | 16.7 GB | 9,3 GB |
| Llama 3 70B | 141,0 GB | 74,9 GB | 49,9 GB | 42,5 GB | 34.3 GB | 19.1 GB |
| Qwen 2.5 72B | 145,0 GB | 77,3 GB | 54,4 GB | 47,4 GB | 37,7 GB | 25,5 GB |
| Command R+ 104B | 208,0 GB | 110,5 GB | 73,8 GB | 62,7 GB | 51,0 GB | 28,6 GB |
| Mistral Large 2 (123B) | 245,2 GB | 130,3 GB | 86,5 GB | 73,2 GB | 59,1 GB | 32,4 GB |
| Mixtral 8x22B (141 B) | 282,0 GB | 150,0 GB | 100,0 GB | 85,1 GB | 69,8 GB | 37,9 GB |
| DeepSeek V3 (671 B MoE) | ~1.342 GB | 713,3 GB | 475,4 GB | 404,4 GB | 319,2 GB | 174,4 GB |
| Llama 3.1 405B | 810,0 GB | 431,0 GB | 287,0 GB | 244,5 GB | 200,1 GB | 107,3 GB |
Uma observação prática: para uso diário, Q4_K_M é o equilíbrio recomendado entre tamanho e qualidade. A queda de qualidade em comparação com FP16 é pequena (aumento típico de perplexidade < 2%) e as economias de memória são enormes (~3,3× menor). Q5_K_M oferece qualidade marginalmente superior, com cerca de 17% a mais de memória. Q3 e IQ2 devem ser usados apenas em situações emergenciais — a qualidade degrada de forma notável.
Memória do cache KV — a parte que todos esquecem
Os números acima referem-se apenas aos pesos do modelo. O cache KV — a memória em execução de todos os tokens na sua conversa — também reside na VRAM e cresce linearmente com o comprimento do contexto.
Tamanho do KV cache por token em FP16 = 2 (chaves e valores) × camadas × cabeças KV × dimensão da cabeça × 2 bytes. A tabela aplica essa fórmula à configuração publicada de cada modelo; todos esses modelos usam atenção de consulta agrupada (GQA), então apenas as cabeças KV contam (1 K = 1.024 tokens, 32 K = 32.768 tokens):
| Classe do modelo | KV por 1K de tokens | KV por contexto de 32K |
|---|---|---|
| Modelos de 7–8 B (Llama 3 8B, Mistral 7B: 32 camadas, 8 cabeças KV) | ~134 MB | ~4,3 GB |
| Qwen 2.5 7B (28 camadas, 4 cabeças KV) | ~59 MB | ~1,9 GB |
| Modelos de 12–14 B (Mistral Nemo 12B, Qwen 2.5 14B, Phi-4: 40–48 camadas, 8–10 cabeças KV) | ~168–210 MB | ~5,4–6,7 GB |
| Modelos de 32–34 B (Qwen 2.5 32B, Yi-1.5 34B: 60–64 camadas, 8 cabeças KV) | ~252–268 MB | ~8,1–8,6 GB |
| Modelos de 70–72 B (Llama 3 70B, Qwen 2.5 72B: 80 camadas, 8 cabeças KV) | ~336 MB | ~10,7 GB |
| Modelos de 104–123 B (Command R+ 104B: 64 camadas; Mistral Large 2: 88 camadas; ambos com 8 cabeças KV) | ~268–369 MB | ~8,6–11,8 GB |
| Llama 3.1 405B (126 camadas, 8 cabeças KV) | ~528 MB | ~16,9 GB |
DeepSeek V3 é a exceção: usa atenção latente multi-cabeça (MLA), que armazena um cache comprimido, então a fórmula não se aplica a ele. Quantizar o KV cache (uma opção em llama.cpp e vLLM em 2026) reduz isso em ~2–4× com um pequeno custo de qualidade. A maioria das configurações de produção agora usa KV cache Q8 — é quase sem custo de qualidade e economiza VRAM substancial em contexto longo.
Se você pretende usar um contexto de 32 K ou mais inclua o cache KV nos seus cálculos de VRAM ao escolher uma GPU.
Matriz de compatibilidade de GPUs
Quais modelos cabem confortavelmente em cada GPU comum, nas quantizações recomendadas e com contexto de 8 K? «Confortavelmente» significa modelo + cache KV + 1 GB de margem para o sistema.
| GPU | VRAM | Melhor ajuste (Q4_K_M) | Melhor ajuste (Q5_K_M) | Máximo (qualquer quantização) |
|---|---|---|---|---|
| RTX 3060 12 GB | 12 GB | 8 B | 8 B | 14 B em Q3 |
| RTX 4060 Ti 16 GB | 16 GB | 13 B | 13 B | 30 B em IQ2 |
| RTX 5080 / 5070 Ti | 16 GB | 13 B | 13 B | 30 B em IQ2 |
| RTX 3090 / 4090 | 24 GB | 30 B (Qwen 32B) | 14 B (30 B é muito apertado) | 70 B em IQ2_XXS (2-bit) |
| RX 7900 XTX | 24 GB | 30 B | 14 B (30 B é muito apertado) | 70 B em IQ2_XXS (2-bit) |
| RTX 5090 | 32 GB | 30 B | 30 B | 70 B em Q3_K_S (apertado) |
| 2× RTX 3090 / 4090 | 48 GB | 70 B | 34 B (70 B precisa ~50 GB) | 104 B em Q3_K_S |
| RTX A6000 / 6000 Ada | 48 GB | 70 B | 34 B (70 B precisa ~50 GB) | 104 B em Q3_K_S |
| Mac Studio M5 Max 64 GB | 64 GB unificados | 70 B | 70 B | 123 B em IQ3_XXS (~47 GB) |
| H100 80 GB | 80 GB | 123 B | 104 B | 123 B em Q4 |
| Mac Studio M5 Max 128 GB | 128 GB unificados | 123 B | 123 B | 405 B em IQ2 (lento) |
| H200 / DGX Spark | 141 GB / 128 GB unificados | 123 B | 123 B | 405 B em IQ2_XXS (~107 GB, lento) |
| B200 | 192 GB | 123 B | 123 B | 405 B em Q3_K_S (~177 GB, apertado) |
Padrões a internalizar:
1. 12 GB é o limite mínimo de entrada. Abaixo disso, você fica limitado a modelos minúsculos que não justificam uma GPU dedicada.
2. 24 GB é o ponto de inflexão. É o nível mais barato em que o Llama 3 70B se torna viável (em quantizações comprometidas).
3. 32 GB ainda não é uma placa 70B. Llama 3 70B em Q4_K_M é cerca de 42.5 GB, então uma RTX 5090 32 GB apenas atinge Q3_K_S; seu ganho sobre a 4090 é rodar modelos da classe 30B em quants mais altos com contexto longo.
4. 48 GB representa um território confortável. A maioria das tarefas que você deseja executar cabe perfeitamente.
5. 128 GB unificados constituem o limite para hardware consumidor. Acima desse valor, você já está adquirindo hardware de servidor.
Escolhendo a quantização certa para seu hardware
A quantização correta nem sempre é 'a maior que cabe'. A qualidade importa, e, às vezes, um modelo menor com uma quantização melhor supera um modelo maior com uma quantização pior.
Classificação aproximada de qualidade (baseada em perplexidade; quanto menor, melhor):
- FP16 / BF16 — Original. Referência de qualidade base.
- Q8_0 — Aumento de ~0,3% na perplexidade. Essencialmente indistinguível.
- Q6_K — Aumento de ~0,5%. Indistinguível na prática.
- Q5_K_M — Aumento de ~1,0%. Queda ligeira de qualidade, ainda com qualidade muito alta.
- Q4_K_M — Aumento de ~1,5–2,5%. Recomendado para a maioria dos usuários.
- Q4_K_S — Aumento de ~3%. Pior que o Q4_K_M para tamanho semelhante, de forma perceptível.
- Q3_K_M — Aumento de ~5–8%. Saída visivelmente afetada.
- Q3_K_S — Aumento de ~10%. Use apenas se o Q4 não couber.
- IQ2_XXS — Aumento de ~15–25%. Último recurso.
Regra geral: prefira um modelo com menos parâmetros em Q5_K_M a um modelo maior em Q3_K_S para tarefas cotidianas. Um Qwen 32B em Q5 geralmente supera um Llama 3 70B em IQ2_XXS em benchmarks do mundo real, apesar de este último soar mais impressionante no papel.
Exceção: tarefas de programação e raciocínio nas quais a vantagem de conhecimento bruto do modelo maior frequentemente sobrevive à quantização pesada. Especificamente para geração de código, até mesmo o Q3_K_S de um modelo de 70B pode superar um modelo de 30B em Q5_K_M.
Modelos MoE — a ressalva
Modelos Mixture-of-Experts (MoE), como Mixtral 8x22B e DeepSeek V3 apresentam uma assimetria que confunde iniciantes:
- VRAM necessária = parâmetros totais (porque todos os especialistas devem ser mantidos na memória)
- Cálculo realizado = parâmetros ativos por token (muito menor)
O Mixtral 8x22B possui 141 B no total e 39 B ativos. Requer mais de 80 GB de VRAM para rodar, mas sua velocidade por token é próxima à de um modelo denso de 40 B.
DeepSeek V3 é 671 B total / 37 B ativo (236 B / 21 B era seu antecessor, DeepSeek-V2). Até seu GGUF Q4_K_M é cerca de 404 GB (cerca de 174 GB em IQ2_XXS), mas a computação por token é mais próxima a um modelo denso ~37 B. É por isso que DeepSeek o V3 é ‘rápido para seu tamanho’ — você paga o custo em VRAM, mas obtém um desconto computacional.
Se seu hardware consegue carregar um modelo MoE, ele costuma ser a melhor escolha. Caso contrário, o modelo denso na mesma classe de parâmetros é o que você deve buscar.
Configurações prontas por faixa de orçamento
Para quem quer uma resposta concreta, aqui estão configurações de exemplo em vários pontos de orçamento em 2026 (os tamanhos de pesos são os arquivos GGUF no Hugging Face; adicione o KV cache por cima):
| Orçamento | GPU | Melhor modelo | Pesos (arquivo GGUF) |
|---|---|---|---|
| $300 | RTX 3060 12 GB | Llama 3 8B Q5_K_M | 5,7 GB |
| $700 | RTX 3090 usada | Qwen 2.5 32B Q4_K_M | 19,8 GB |
| $1,300 | RTX 4090 usada | Qwen 2.5 32B Q4_K_M (70B apenas em 2-bit) | 19,8 GB |
| $1,400 | 2× RTX 3090 usadas + NVLink | Llama 3 70B Q4_K_M | 42,5 GB |
| $2,400 | RTX 5090 | Llama 3 70B Q3_K_S (apertado) | 30,9 GB |
| $3,799+ | Mac Studio M5 Max, 64–128 GB | Llama 3 70B Q4_K_M (64 GB); Mistral Large 2 Q4_K_M (128 GB) | 42,5 GB / 73,2 GB |
A 'melhor faixa de valor' em 2026 continua sendo a RTX 3090 ou 4090 usada — são as únicas GPUs consumidoras nas quais a relação preço-por-VRAM é favorável, e ambas permanecerão capazes até pelo menos 2028.
Para uma análise detalhada sobre qual GPU escolher, consulte melhor Placas de vídeo para LLMs locais em 2026.
Verifique essas figuras na fonte
Especificações e preços mudam sem aviso. Estas são as próprias páginas dos fornecedores para o que é coberto acima:
Perguntas frequentes
Quanta VRAM é necessária para executar o Llama 3 70B localmente em 2026?
Planeje 48 GB para Llama 3 70B em Q4_K_M, a quantização recomendada: os pesos sozinhos são cerca de 42.5 GB, o que deixa espaço para um KV cache 8 K. Q5_K_M (cerca de 50 GB) precisa de mais de 48 GB, e Q3_K_S (cerca de 31 GB) é o máximo que uma RTX 5090 32 GB pode conter. Uma única placa 24 GB apenas cabe em quants 2-bit como IQ2_XXS (cerca de 19 GB, qualidade aproximada), e contexto mais longo em 24 GB requer CPU offload.
Qual é a diferença entre Q4_K_M e Q4_K_S?
Ambos são quantizações de 4 bits do mesmo modelo. O Q4_K_M ('médio') usa 5 bits para alguns grupos críticos de pesos, tornando-o ligeiramente maior, mas com qualidade nitidamente superior ao Q4_K_S ('pequeno'). Para VRAM praticamente idêntica, prefere-se o Q4_K_M. O Q4_K_S só faz sentido quando você tenta encaixar um modelo em um orçamento muito apertado de VRAM.
Posso executar um LLM maior do que minha VRAM?
Sim — usando CPU offload, onde algumas camadas do modelo rodam na CPU usando RAM do sistema em vez de VRAM da GPU. A penalidade de desempenho é severa (5–10× mais lento), mas permite rodar modelos que não caberiam de outra forma. Prático para uso ocasional, doloroso como ferramenta diária. Tanto llama.cpp quanto Ollama suportam isto nativamente via n_gpu_layers .
O cache KV realmente importa no planejamento de VRAM?
Sim, especialmente em contexto longo. Para Llama 3 70B com contexto de 32 K, apenas o cache KV é ~10,7 GB em FP16. Se você já estiver no limite da sua VRAM, terá OOM no momento em que a conversa ficar longa. Planeje para cache KV e considere quantização Q8 KV-cache (opção em motores de inferência modernos) para reduzir aproximadamente pela metade.
Existe alguma maneira de executar o Llama 3 405B em casa?
Sim, mas você precisa de 200+ GB de memória em quants utilizáveis. Os caminhos realistas de 2026: um Mac Studio com M5 Ultra e 512 GB de memória unificada (a página de especificações do Mac Studio da Apple agora lista a configuração de 512 GB; lenta por token, mas funciona), 8× RTX 4090 ($13K, configuração complexa; 192 GB no total acomoda 405B apenas em Q3_K_S, aproximadamente 177 GB), duas unidades vinculadas NVIDIA DGX Spark unidades (256 GB combinados, que a NVIDIA classifica para modelos de até cerca de 400B parâmetros), ou CPU + 256 GB DDR5 RAM com GPU de gama média para descarregamento parcial ($8K, lenta). Para comparar essa conta de hardware com pagamento por token, use nosso calculadora de ponto de equilíbrio entre hospedagem local e uso de API.
Existem novos formatos de quantização para 2026 além do GGUF dos quais devo saber?
Sim — AWQ (Quantização de Pesos com Consciência de Ativações) e GPTQ são ambos ainda amplamente usados, especialmente para deployments vLLM e TensorRT-LLM. Têm qualidade ligeiramente melhor no mesmo bit count que GGUF em alguns casos. Para uso local-LLM consumer com llama.cpp/Ollama/LM Studio, GGUF permanece dominante em 2026 por causa de sua simplicidade e suporte de ferramental amplo.
A quantização Q4 afetará minha capacidade de programação?
Menos do que se imagina, mas sim. Para conclusão direta de código, Q4_K_M é essencialmente idêntico ao FP16. Para raciocínio complexo em múltiplas etapas envolvendo um código-base inteiro, Q4 ocasionalmente produz lógica inferior à obtida com Q5+. Se você faz programação séria com modelos locais, prefira Q5_K_M e escolha seu hardware para suportá-lo.
Conclusão
O planejamento de VRAM para LLMs locais em 2026 não é complicado, mas recompensa a precisão. Escolha primeiro a classe de parâmetros (o tamanho do modelo que oferece a capacidade necessária), depois selecione a menor quantização que forneça qualidade aceitável (Q4_K_M geralmente é a ideal), adicione então a estimativa do cache KV para seu comprimento real de contexto e, por fim, dimensione sua GPU adequadamente.
Se você lembrar apenas três números, lembre-se destes:
- 12 GB executa modelos de 8 B sem problemas.
- 24 GB roda 30 B em quants de qualidade, 70 B apenas em 2-bit.
- 48 GB roda 70 B em quants de qualidade (Q4_K_M).
Tudo acima de 32 GB entra em território multi-GPU, workstation ou big-unified-memory, e tudo abaixo de 12 GB entra em território telefone/embedded. A maior parte da atividade local-LLM 2026 acontece na faixa 12–32 GB, que é exatamente a faixa GPU consumer — por design, não coincidência.