// guia

Quanta VRAM você precisa para rodar um LLM local?

A resposta curta: o suficiente para guardar o arquivo do modelo mais a sua memória de trabalho. Um modelo típico de 8B precisa de cerca de 5 GB no popular ajuste de 4 bits, cerca de 8,5 GB em 8 bits e 16 GB sem quantização. Este guia transforma a sua placa de vídeo — ou a RAM do sistema, se você não tiver placa — numa resposta concreta para cada tamanho de modelo comum.

Última atualização: novembro de 2026 · Editor: LibreAI · Pela equipe do LibreAI · Valores calculados a partir do número de parâmetros dos modelos e dos tamanhos publicados dos arquivos GGUF — o método está no fim desta página

Principais conclusões

  1. Os pesos dominam. VRAM necessária ≈ o tamanho do arquivo do modelo em disco, mais uma folga de cerca de 10–20 % para o cache KV e os buffers do motor em contextos de conversa.
  2. Um modelo de 8B em Q4_K_M (≈4,9 GB) é o ponto de entrada: qualquer placa de vídeo de 8 GB o roda inteiramente na GPU.
  3. Uma placa de 24 GB (classe RTX 3090 / 4090) roda um modelo de 32B em Q4_K_M com folga; um modelo de 70B precisa de 48 GB nesse ajuste, ou de descarga parcial para a RAM.
  4. Não ter GPU não é um beco sem saída: a mesma tabela de tamanhos se lê como RAM do sistema para execuções só com CPU: mais lento, mas funciona.
  5. O gpt-oss-20b foi feito para placas de 16 GB; o gpt-oss-120b precisa de uma GPU da classe de 80 GB ou de um Mac com muita memória.

A resposta curta

Um modelo de linguagem na memória tem três partes: os pesos (o próprio arquivo do modelo), o cache KV (a memória de trabalho do modelo sobre a sua conversa, que cresce com o tamanho do contexto) e os buffers do motor. No uso normal de conversa, os pesos são 80–95 % do total, por isso o tamanho do arquivo do modelo em disco é o número por onde começar. A quantização é o que torna o hardware doméstico viável: guardar cada peso em cerca de 4 bits em vez de 16 reduz o arquivo a cerca de um quarto, com um pequeno custo de qualidade. Cada valor abaixo é um tamanho real de arquivo GGUF, ou um cálculo direto a partir de um.

VRAM por tamanho de modelo e quantização

Só os pesos, em GB: o tamanho do arquivo do modelo que você baixa. Os mesmos números valem para a RAM do sistema no caminho só com CPU. Some uma folga para o cache KV e os buffers (próxima seção) antes de comparar com a sua placa.

Tamanho do modeloFP16Q8_0 (8 bits)Q4_K_M (4 bits)Q2_K (2 bits)
~1B2,01,10,80,6
~3B6,43,42,01,3
~8B168,54,93,0
~14B30169,05,6
~32B65352012
~70B141754326
gpt-oss-20b (MoE)——≈14 (MXFP4 nativo)—
gpt-oss-120b (MoE)——≈65 (MXFP4 nativo)—

Modelos de mistura de especialistas (MoE), como o gpt-oss, guardam todos os seus especialistas, por isso o número total de parâmetros define o tamanho do arquivo, mesmo que só uma parte do modelo esteja ativa em cada token.

O cache KV: por que o tamanho do contexto consome memória

O cache KV é a memória do modelo sobre tudo o que foi dito até agora, e cresce de forma linear com o tamanho do contexto. Um modelo de 8B com o desenho do Llama 3.1 guarda cerca de 0,13 MB de cache por token em precisão total, por isso uma conversa de 8.000 tokens soma aproximadamente 1 GB — e um contexto de 32.000 tokens soma cerca de 4 GB. Modelos maiores guardam mais por token. A maioria dos motores também pode quantizar o cache, reduzindo-o para metade ou um quarto com um pequeno custo de qualidade. Regra prática: some 1–2 GB sobre os pesos para uma conversa normal, e 4 GB ou mais se pretende dar documentos longos ao modelo.

O que cabe na sua placa de vídeo?

«Cabe» aqui significa que o modelo inteiro permanece na GPU com um contexto de conversa normal: a configuração rápida. As placas citadas são exemplos de cada nível (uma RTX 3060 tem 12 GB, uma RTX 4060 tem 8 GB, e uma RTX 4090 e uma RX 7900 XTX têm 24 GB).

A sua VRAMA maior configuração completa na GPU, com conforto
4–6 GBUm modelo de 3B em Q4_K_M; um de 8B só com camadas descarregadas para a RAM
8 GBUm modelo de 8B em Q4_K_M: o ponto ideal de entrada
12 GBUm modelo de 8B em Q8_0, ou um de 14B em Q4_K_M
16 GBUm modelo de 14B em Q8_0, ou o gpt-oss-20b no seu MXFP4 nativo
24 GBUm modelo de 32B em Q4_K_M, com espaço para um contexto longo
32 GBUm modelo de 32B em Q8_0, ou um de 70B com uma quantização baixa da classe de 3 bits
48 GBUm modelo de 70B em Q4_K_M, inteiramente na GPU
80 GBgpt-oss-120b, ou um modelo de 70B em Q8_0

Exemplo prático: uma placa de 8 GB, passo a passo

Pegue um desktop com uma RTX 4060 (8 GB). Baixe um modelo de 8B em Q4_K_M: o arquivo tem 4,9 GB. Carregue-o no llama.cpp ou no Ollama com um contexto de 8.000 tokens: o cache KV soma cerca de 1 GB e os buffers algumas centenas de MB — aproximadamente 6,3 GB no total, com uma folga confortável na placa. O mesmo modelo em Q8_0 (um arquivo de 8,5 GB) não cabe por completo, por isso o motor descarrega algumas camadas para a RAM do sistema e a geração fica visivelmente mais lenta. É exatamente essa a decisão para a qual esta página existe: escolha a quantização que cabe, não o maior arquivo.

Sem placa de vídeo? O caminho só com CPU

Tudo o que está acima se lê da mesma forma trocando VRAM por RAM do sistema: o arquivo do modelo fica na RAM. Uma execução com CPU de um modelo de 8B em Q4_K_M precisa dos mesmos ~5 GB de RAM para os pesos, mais espaço para o sistema operativo: 16 GB de RAM total é viável, e 32 GB é confortável e também cobre um modelo de 14B em Q4_K_M. A velocidade é definida pela largura de banda da memória, não pelo número de núcleos: espere um número de tokens por segundo de um só dígito com uma CPU de desktop típica num modelo de 8B — suficiente para resumos, tarefas em lote e trabalho durante a noite, mas lento para conversa ao vivo. O modo híbrido equilibra as duas coisas: o llama.cpp e o KoboldCpp podem manter parte do modelo numa GPU pequena e o resto na RAM.

Apple Silicon: um único bloco de memória

Os Macs com chips da série M partilham um único bloco de memória entre CPU e GPU, por isso a coluna da VRAM passa a ser a memória total do seu Mac menos o que o macOS e as suas aplicações precisam: deixe cerca de um quarto livre. Na prática: um Mac de 16 GB roda bem um modelo de 8B em Q4_K_M e um de 14B em Q4_K_M de forma apertada; 32 GB roda um de 32B em Q4_K_M; 64 GB roda um de 70B em Q4_K_M; e um Mac de 128 GB é a configuração que guarda o gpt-oss-120b. Aplicações de desktop como o Jan e o GPT4All deixam tudo isto a dois cliques no macOS.

Que motor deve usar?

Decidido o tamanho, o motor decide como o modelo é carregado. A categoria LLM Local do catálogo cobre o campo; os pontos de partida habituais são o llama.cpp (o motor GGUF sobre o qual a maioria das ferramentas se constrói, com o controle mais fino sobre descarga e cache), o Ollama (modelos com um único comando e uma API), o Jan e o GPT4All (aplicações de desktop, amigas da CPU), o KoboldCpp (um executável único feito para configurações híbridas GPU/RAM), o text-generation-webui (uma interface web completa), o WebLLM (roda no navegador sobre WebGPU, dentro dos limites de memória do navegador) e o vLLM (para servir muitos utilizadores ao mesmo tempo: outra aposta, o débito total acima do ajuste doméstico). A página de cada projeto indica os seus próprios requisitos documentados.

Quanta VRAM preciso para um modelo de 8B?

Cerca de 5 GB em Q4_K_M, 8,5 GB em Q8_0 e 16 GB em FP16 para os pesos; some aproximadamente 1–2 GB para o cache KV e os buffers em contextos de tamanho de conversa. Uma placa de vídeo de 8 GB é o mínimo confortável para a versão de 4 bits, e a configuração doméstica mais comum.

8 GB de VRAM chegam para rodar LLMs locais?

Sim: é o ponto de entrada padrão. Roda modelos de 7–8B em Q4_K_M inteiramente na GPU, e modelos mais pequenos de 1–3B em 8 bits ou em precisão total. Não chega para um modelo de 14B sem descarregar algumas camadas para a RAM do sistema, o que funciona mas roda mais devagar.

Qual é o maior modelo que posso rodar com 24 GB de VRAM?

Um modelo de 32B em Q4_K_M — cerca de 20 GB de pesos — cabe por completo, com espaço de sobra para um contexto longo. Um modelo de 70B em Q4_K_M (cerca de 43 GB) não cabe: precisa de descarga parcial para a RAM, de uma quantização menor ou de uma segunda GPU.

Posso rodar um LLM local sem GPU?

Sim. Com CPU, a RAM do sistema faz o papel da VRAM e aplica-se a mesma tabela de tamanhos: um modelo de 8B em Q4_K_M precisa de cerca de 5 GB de RAM para os seus pesos. A geração é muito mais lenta, normalmente um número de tokens por segundo de um só dígito para um modelo de 8B numa CPU de desktop, mas funciona, e as tarefas em lote não se importam com a espera.

O que significa Q4_K_M?

É um formato de quantização do GGUF: os pesos são guardados com cerca de 4 bits cada um — cerca de 0,6 bytes por parâmetro contando os fatores de escala — e os tensores mais sensíveis são mantidos com maior precisão (o esquema «K»; o «M» é o tamanho médio). É o equilíbrio padrão entre tamanho de arquivo e qualidade de resposta para o hardware doméstico, e a coluna pela qual a maioria dos leitores se deve guiar.

Mais VRAM torna um modelo mais rápido?

Não diretamente. A VRAM decide o que cabe; a velocidade de geração vem da largura de banda da memória e da capacidade de cálculo. A VRAM extra só ajuda a velocidade de forma indireta: mantendo o modelo inteiro, e um contexto mais longo, na GPU em vez de transbordar para a RAM do sistema.

De quanta memória precisa o gpt-oss-120b?

Os seus pesos em MXFP4 rondam os 65 GB, por isso o alvo são GPUs de centro de dados da classe de 80 GB, ou um Mac com 96 GB ou mais de memória unificada. O seu irmão mais pequeno, o gpt-oss-20b (cerca de 14 GB de pesos), foi desenhado para rodar numa única placa de 16 GB.

Como estes valores são calculados

Os tamanhos de arquivo da tabela são os tamanhos GGUF publicados de modelos representativos de cada classe de tamanho (as famílias Llama, Qwen, Mistral e Gemma), e a coluna FP16 é simplesmente o número de parâmetros × 2 bytes. Os tamanhos quantizados seguem os bytes por peso de cada formato (Q8_0 ≈ 1,06; Q4_K_M ≈ 0,6; Q2_K ≈ 0,35 bytes por parâmetro). Os valores do cache KV são calculados a partir da arquitetura do Llama 3.1 8B: 32 camadas, 8 cabeças KV e cabeças de 128 dimensões. Nesta página não são citadas velocidades de referência, porque a velocidade depende do seu hardware exato, dos controladores e das definições do motor; cada projeto do catálogo indica os seus próprios requisitos na sua página. Se um valor daqui discordar da documentação de um projeto, é a documentação do projeto que manda: conte-nos pela página de contato e corrigiremos.

Veja também: Open-Source AI Statistics 2026, com dados do mesmo catálogo verificado.

AdvertisementToolNest · Free online tools146 free tools. Zero sign-ups.Calculators, converters, PDF & developer tools — right in your browser.Open ToolNest →