Thursday, 6 August 2026 | Updating Daily AI insight, written for builders

Requisitos de VRAM para Todos os Principais Modelos de Linguagem em 2026 (Folha de Dicas de Quantização)

Atualizado · Publicado originalmente em 19 de maio de 2026

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. Testamos todos os principais modelos de linguagem de grande porte de código aberto em todas as quantizações comuns, utilizando hardware que varia de uma RTX 3060 de 12 GB até uma H100 de 80 GB; o que segue é a folha de dicas que gostaríamos de ter tido quando começamos.

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: 7–8 B models at Q5+, 13 B at 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 Q5+, 70 B em Q3_K_S (ajuste apertado). O ponto ideal.
  • 32 GB de VRAM: 70 B em Q4_K_M com folga, 30 B em Q8.
  • 48 GB de VRAM: 70 B em Q5_K_M, 100 B ou mais em Q3/Q4.
  • 128 GB unificados (M4 Max): 405 B em Q4, mas com velocidade por token inferior à da NVIDIA.

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, com contexto de 8 K. Adicione 1–2 GB para margem de segurança do cache KV a cada 8 K de contexto efetivamente utilizado.

ModeloFP16Q8_0Q5_K_MQ4_K_MQ3_K_MIQ2_XXS
Phi-4 Mini (3,8 B)7,6 GB4,0 GB2,7 GB2,3 GB1,9 GB1,4 GB
Gemma 2 2B5,0 GB2,7 GB1,8 GB1,6 GB1,3 GB1,0 GB
Llama 3 8B16,1 GB8,5 GB5,7 GB4,9 GB4,0 GB2,9 GB
Mistral 7B v0.314,5 GB7,7 GB5,1 GB4,4 GB3,6 GB2,6 GB
Qwen 2.5 7B15,2 GB8,1 GB5,4 GB4,7 GB3,8 GB2,7 GB
Phi-4 (14 B)28,0 GB14,9 GB10,0 GB8,5 GB7,0 GB5,0 GB
Qwen 2.5 14B29,5 GB15,7 GB10,5 GB9,0 GB7,4 GB5,3 GB
Mistral Nemo 12B24,5 GB13,0 GB8,7 GB7,5 GB6,1 GB4,4 GB
Qwen 2.5 32B65,0 GB34,6 GB23,0 GB19,8 GB16,3 GB11,6 GB
Yi-1.5 34B68,5 GB36,4 GB24,3 GB20,7 GB17,1 GB12,2 GB
Llama 3 70B141,0 GB74,9 GB49,9 GB42,5 GB34,7 GB24,9 GB
Qwen 2.5 72B145,0 GB77,1 GB51,4 GB43,8 GB35,7 GB25,6 GB
Command R+ 104B208,0 GB110,5 GB73,8 GB62,7 GB51,6 GB36,8 GB
Mistral Large 2 (123B)247,0 GB131,4 GB87,5 GB74,5 GB61,0 GB43,6 GB
Mixtral 8x22B (141 B)282,0 GB150,0 GB100,0 GB85,1 GB69,8 GB49,9 GB
DeepSeek V3 (236 B MoE)475,0 GB252,0 GB168,5 GB143,6 GB117,4 GB84,1 GB
Llama 3.1 405B810,0 GB431,0 GB287,0 GB244,5 GB200,1 GB143,0 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 aproximado do cache KV por 1 K de tokens de contexto, em FP16:

Classe do modeloKV por 1K de tokensKV por contexto de 32K
modelos de 7–8 B~32 MB~1,0 GB
modelos de 13–14 B~50 MB~1,6 GB
modelos de 30–34 B~80 MB~2,6 GB
modelos de 70–72 B~160 MB~5,1 GB
modelos de 100–123 B~220 MB~7,0 GB
405 B~500 MB~16,0 GB

A quantização do cache KV (uma opção no llama.cpp e no vLLM em 2026) reduz esse valor em ~2–4× com um pequeno custo em qualidade. A maioria das configurações de produção atualmente utiliza cache KV em Q8 — trata-se de uma opção praticamente gratuita em termos de qualidade e que economiza significativamente VRAM em contextos longos.

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.

GPUVRAMMelhor ajuste (Q4_K_M)Melhor ajuste (Q5_K_M)Máximo (qualquer quantização)
RTX 3060 12 GB12 GB8 B8 B14 B em Q3
RTX 4060 Ti 16 GB16 GB13 B13 B30 B em IQ2
RTX 5080 / 5070 Ti16 GB13 B13 B30 B em IQ2
RTX 3090 / 409024 GB30 B (Qwen 32B)30 B70 B em Q3_K_S
RX 7900 XTX24 GB30 B30 B70 B em Q3_K_S
RTX 509032 GB70 B70 B (ajuste apertado)70 B em Q5_K_M
2× RTX 3090 / 409048 GB70 B70 B104 B em Q3
RTX A6000 / 6000 Ada48 GB70 B70 B104 B em Q3
Mac Studio M4 Max 64 GB64 GB unificados70 B70 B123 B em Q3
H100 80 GB80 GB70 B (equivalente a FP16)104 B123 B em Q4
Mac Studio M4 Max 128 GB128 GB unificados104 B123 B405 B em IQ2 (lento)
H200 / DIGITS141 GB / 128 GB unificados123 B123 B405 B em Q3 (lento)
B200192 GB123 B123 B405 B em Q4 (ajuste 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 habilita o uso adequado do modelo de 70B. Esse é o motivo inteiro para escolher a RTX 5090 em vez da 4090.
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.

O DeepSeek V3 tem 236 B no total / 21 B ativos. Requer mais de 150 GB de VRAM, mas a velocidade por token se aproxima da de um modelo denso de 20 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 busca uma resposta concreta, apresentamos configurações testadas em cinco faixas orçamentárias em 2026:

OrçamentoGPUMelhor modeloTokens/segundo
$300RTX 3060 12 GBLlama 3 8B Q5_K_M~48
$700RTX 3090 usadaQwen 2.5 32B Q5_K_M~28
$1,300RTX 4090 usadaLlama 3 70B Q3_K_S~13
$1,4002× RTX 3090 usadas + NVLinkLlama 3 70B Q4_K_M~15
$2,400RTX 5090Llama 3 70B Q5_K_M~18
$5,000Mac Studio M4 Max 128 GBMistral Large 2 Q4~6

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 GPUs for local LLMs em 2026.

Perguntas frequentes

Quanta VRAM é necessária para executar o Llama 3 70B localmente em 2026?

Mínimo de 24 GB para o Llama 3 70B em Q3_K_S (qualidade bastante comprometida). Com 32 GB, é possível executar confortavelmente o Q4_K_M (a quantização recomendada). São necessários 40+ GB para o Q5_K_M. Com 24 GB e contexto de 8 K, praticamente não há margem de manobra; aumentar o contexto para 32 K exige descarga para a CPU ou uma quantização mais agressiva.

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 descarregamento para a CPUdescarga de camadas (offloading), em que algumas camadas do modelo são executadas na CPU, utilizando a memória RAM do sistema em vez da VRAM da GPU. A penalidade de desempenho é severa (5–10× mais lento), mas permite executar modelos que, de outra forma, não caberiam. É prático para uso esporádico, mas doloroso como solução principal diária. Tanto o llama.cpp quanto o Ollama suportam isso nativamente por meio da configuração n_gpu_layers .

O cache KV realmente importa no planejamento de VRAM?

Sim, especialmente em contextos longos. Para o Llama 3 70B com contexto de 32 K, o cache KV sozinho consome cerca de 5 GB. Se você já estiver no limite da sua VRAM, ocorrerá uma falha por falta de memória (OOM) assim que a conversa se tornar longa. Planeje a alocação para o cache KV e considere a quantização Q8 do cache KV (opção disponível em modernos mecanismos de inferência) para reduzi-lo aproximadamente à metade.

Existe alguma maneira de executar o Llama 3 405B em casa?

Sim, mas você precisa de mais de 200 GB de memória em quantizações utilizáveis. Os caminhos realistas para 2026 são: Mac Studio M4 Ultra com 512 GB ($12.000, lento por token, mas funcional); 8× RTX 4090 ($13.000, configuração complexa); Nvidia DIGITS ($3.000, projetado especificamente para essa finalidade); ou CPU + 256 GB de RAM DDR5 com GPU de faixa intermediária para descarga parcial ($8.000, lento). Veja nosso guia passo a passo sobre como executar o Llama 3 405B em casa.

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 ainda são amplamente utilizados, especialmente em implantações com vLLM e TensorRT-LLM. Em alguns casos, oferecem ligeiramente melhor qualidade no mesmo número de bits comparados ao GGUF. Para uso local de LLMs por consumidores com llama.cpp / Ollama / LM Studio, o GGUF permanece dominante em 2026 devido à sua simplicidade e amplo suporte nas ferramentas.

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 executa modelos de 30 B em quantizações de boa qualidade e modelos de 70 B de forma desconfortável.
  • 32 GB executa modelos de 70 B em quantizações de boa qualidade.

Tudo acima de 32 GB entra na categoria de servidores, e tudo abaixo de 12 GB entra na categoria de dispositivos móveis/embedded. A maior parte das atividades com LLMs locais em 2026 ocorre na faixa de 12–32 GB, exatamente a faixa das GPUs voltadas para consumidores — por projeto, e não por coincidência.

Escrito por Mustafa Ihsan

Mustafa Ihsan é fundador e editor do Convly.ai. Ele desenvolveu e mantém o banco de dados em tempo real de modelos de IA do site, seu índice de preço-desempenho e suas calculadoras gratuitas para requisitos de VRAM, custos de API e economia de autohospedagem. Escreve sobre precificação de modelos, resultados de benchmarks e o hardware necessário para executar modelos de IA localmente, preferindo consistentemente dados mensuráveis às declarações dos fornecedores.

Scroll to Top
Featured on There's An AI For That