Calculadora de VRAM para LLM — consigo rodar este LLM localmente?
Descubra quanta memória de GPU um LLM local precisa para sua quantização e tamanho de contexto, se ele cabe na sua GPU ou no seu Mac e com que velocidade vai rodar.
8,03B parâmetros. Atenção: 32 camadas x 8 cabeças KV x 128 dim.
Escuro: pesos · Azul: KV cache · Cinza: overhead. GB aqui significa GiB (1024³ bytes), a unidade em que a memória de GPU é vendida.
| GPU / Mac | Utilizável | Resultado | Velocidade est. |
|---|---|---|---|
| RTX 3060 12 GB 360 GB/s | 12 GB | Cabe | ~39 tok/s |
| RTX 4060 Ti 16 GB 288 GB/s | 16 GB | Cabe | ~31 tok/s |
| RTX 4070 Super 12 GB 504 GB/s | 12 GB | Cabe | ~55 tok/s |
| RTX 4080 Super 16 GB 736 GB/s | 16 GB | Cabe | ~80 tok/s |
| RTX 5080 16 GB 960 GB/s | 16 GB | Cabe | ~104 tok/s |
| RTX 3090 24 GB 936 GB/s | 24 GB | Cabe | ~102 tok/s |
| RTX 4090 24 GB 1008 GB/s | 24 GB | Cabe | ~110 tok/s |
| RTX 5090 32 GB 1792 GB/s | 32 GB | Cabe | ~195 tok/s |
| Radeon RX 7900 XTX 24 GB 960 GB/s | 24 GB | Cabe | ~104 tok/s |
| RTX 6000 Ada 48 GB 960 GB/s | 48 GB | Cabe | ~104 tok/s |
| A100 40 GB 1555 GB/s | 40 GB | Cabe | ~169 tok/s |
| A100 80 GB (SXM) 2039 GB/s | 80 GB | Cabe | ~222 tok/s |
| H100 80 GB (SXM) 3350 GB/s | 80 GB | Cabe | ~364 tok/s |
| H200 141 GB 4800 GB/s | 141 GB | Cabe | ~522 tok/s |
| Ryzen AI Max+ 395 (96 GB to GPU) 256 GB/s | 96 GB | Cabe | ~28 tok/s |
| Mac M2/M3/M4, 16 GB 100 GB/s | 10.7 GB | Cabe | ~11 tok/s |
| Mac M3/M4, 24 GB 120 GB/s | 16.1 GB | Cabe | ~13 tok/s |
| Mac M4 Pro, 48 GB 273 GB/s | 36 GB | Cabe | ~30 tok/s |
| Mac M4 Max, 64 GB 546 GB/s | 48 GB | Cabe | ~59 tok/s |
| Mac M4 Max, 128 GB 546 GB/s | 96 GB | Cabe | ~59 tok/s |
| Mac M2 Ultra, 192 GB 800 GB/s | 144 GB | Cabe | ~87 tok/s |
| Mac M3 Ultra, 512 GB 819 GB/s | 384 GB | Cabe | ~89 tok/s |
“No limite” significa a menos de 10% do limite: pode carregar, mas um navegador ou outro app pode fazer passar do limite. A velocidade é a geração para um único usuário, estimada como 65% da largura de banda da memória dividida pelos bytes lidos por token; o processamento do prompt é mais rápido, e os números reais variam conforme o runtime. Por padrão, o Apple Silicon pode dar à GPU cerca de dois terços (até 36 GB) ou três quartos (acima disso) da RAM.
Calculado no seu navegador. Nada do que você digita é enviado para lugar nenhum. Ver todas as ferramentas grátis.
Encontrou um problema ou algo que poderia ser melhor? Lemos todas as mensagens e corrigimos rápido.
Esta calculadora de VRAM para LLM responde à pergunta “consigo rodar este LLM localmente?” estimando a memória que um modelo precisa na sua GPU ou no seu Mac: os pesos na quantização escolhida, o KV cache para o seu tamanho de contexto e o overhead do runtime. Escolha um modelo aberto popular ou informe uma contagem de parâmetros, selecione uma quantização como Q4_K_M e veja o total ao lado de um veredito — Cabe, No limite ou Não cabe — para placas de vídeo comuns e máquinas Apple Silicon, com uma estimativa de velocidade de geração para cada uma.
A maioria das estimativas rápidas multiplica os parâmetros pelos bytes por peso e para por aí, o que chega perto para prompts curtos e erra feio nos longos. Um Llama 3.1 8B em Q4_K_M precisa de cerca de 4,6 GB para os pesos, mas o KV cache dele cresce de 1 GB num contexto de 8K para 16 GB em 128K. As predefinições daqui trazem a arquitetura de atenção real de cada modelo (grouped-query heads, sliding windows, a latent attention do DeepSeek), então o KV cache é calculado do jeito que o llama.cpp e o vLLM realmente o alocam. As fórmulas estão detalhadas abaixo e a matemática é testada com testes unitários contra tamanhos reais de arquivos GGUF.
Como usar
- Escolha um modelo da lista, ou Personalizado para informar uma contagem de parâmetros (e, para um KV cache exato, os valores de Camadas, Cabeças KV e Dim. da cabeça do config.json do modelo).
- Escolha a quantização que pretende baixar. Q4_K_M é o ponto de partida habitual para modelos GGUF no llama.cpp, no Ollama e no LM Studio.
- Defina o tamanho de contexto que você vai usar de fato e o número de sequências paralelas (1 para chat pessoal, mais para um servidor).
- Leia o total e o detalhamento e depois o veredito para cada GPU ou Mac. “No limite” significa a menos de 10% do limite.
- Se não couber, tente uma quantização menor, um contexto mais curto, um KV cache em Q8_0 ou um modelo com menos parâmetros.
Perguntas frequentes
Quanta VRAM preciso para rodar um modelo 8B?
Cerca de 6,5 GB para o Llama 3.1 8B em Q4_K_M com contexto de 8K: 4,6 GB de pesos, 1 GB de KV cache e menos de 1 GB de overhead. Isso cabe numa GPU de 8 GB e sobra espaço numa RTX 3060 de 12 GB. Em FP16, o mesmo modelo precisa de cerca de 17 GB, ou seja, uma placa de 24 GB. O tamanho do contexto pesa: no contexto completo de 128K, só o KV cache ocupa 16 GB.
Consigo rodar um modelo 70B numa GPU de 24 GB?
Não inteiramente na VRAM. O Llama 3.3 70B em Q4_K_M precisa de cerca de 40 GB para os pesos e de aproximadamente 45 GB no total com contexto de 8K; até o Q2_K precisa de uns 30 GB. As opções são duas GPUs de 24 GB, uma placa de 48 GB, um Mac com 64 GB ou mais de memória unificada ou descarregar parte do modelo para a RAM do sistema, o que funciona, mas fica várias vezes mais lento.
O que é o KV cache e por que ele cresce com o contexto?
Durante a geração, o modelo guarda um vetor de chave e um de valor para cada token anterior em cada camada, para não precisar recalculá-los a cada novo token. O tamanho é 2 x camadas x KV heads x dimensão da head x tamanho do contexto x bytes por valor. Para o Llama 3.1 8B (32 camadas, 8 KV heads, head dim 128, FP16), isso dá 128 KB por token: 1 GB com 8K tokens e 16 GB com 128K. Modelos com grouped-query attention, camadas de sliding window (Gemma) ou latent attention (DeepSeek) precisam de bem menos.
Qual quantização devo usar?
Q4_K_M é o equilíbrio padrão: cerca de um terço do tamanho em FP16, com pouca perda de qualidade na maioria dos usos. Use Q5_K_M ou Q6_K se couberem, Q8_0 quando quiser resultados praticamente idênticos ao original, e evite Q3 e Q2 em modelos abaixo de uns 30B de parâmetros, onde a queda de qualidade fica evidente. Um modelo maior em Q4 costuma superar um modelo menor em Q8 com o mesmo tamanho de arquivo.
Mac ou GPU NVIDIA: o que é melhor para LLMs locais?
O Mac comporta modelos maiores; a GPU NVIDIA roda mais rápido os que cabem nela. O Apple Silicon compartilha um único bloco de memória entre CPU e GPU, então um Mac de 128 GB consegue carregar um modelo 70B que nenhuma placa de vídeo doméstica comporta, mas a largura de banda da memória dele (546 GB/s num M4 Max) é cerca de metade dos 1.008 GB/s de uma RTX 4090, e a velocidade de geração acompanha a largura de banda. Por padrão, o macOS deixa a GPU usar cerca de dois terços da RAM em máquinas de até 36 GB e cerca de três quartos nas maiores.
Qual é a precisão da estimativa de tokens por segundo?
É uma referência aproximada, geralmente com margem de 30% para geração com um único usuário. Gerar cada token significa ler uma vez da memória os pesos ativos e o KV cache, então a velocidade é mais ou menos a largura de banda da memória dividida pelos bytes por token; a ferramenta supõe que 65% da largura de banda máxima é atingida. O processamento do prompt depende de computação e é bem mais rápido, modelos MoE acrescentam overhead de roteamento, e runtime, drivers e configurações alteram os números reais.
As fórmulas que esta calculadora usa
Memória total = pesos do modelo + KV cache + overhead do runtime. Todos os tamanhos estão em GiB (1.024³ bytes), que é a unidade em que a memória de GPU é vendida: uma RTX 4090 de “24 GB” tem 24 GiB.
Pesos = parâmetros x bits por peso / 8. Para k-quants GGUF, os bits por peso são valores efetivos medidos em arquivos reais, porque cada tipo de quantização mistura precisões entre os tensores: Q8_0 8,5, Q6_K 6,57, Q5_K_M 5,70, Q4_K_M 4,89, IQ4_XS 4,43, Q3_K_M 4,00, Q2_K 3,17 (a partir dos arquivos GGUF do Llama 3.1 8B; modelos maiores saem até cerca de 5% menores). AWQ e GPTQ usam pesos de 4 bits com uma escala a cada 128 pesos (cerca de 4,16 bits) e mantêm os embeddings e a camada de saída em 16 bits; o gpt-oss vem com os pesos dos experts em MXFP4 (4,25 bits) e a atenção e os embeddings em BF16.
KV cache = 2 x camadas x KV heads x head dim x tokens x bytes por valor x sequências paralelas. A grouped-query attention é o motivo de kv_heads (8 no Llama 3 70B) ser bem menor que o número de attention heads (64). Camadas de sliding window guardam no máximo sua janela (1.024 tokens no Gemma 3, 128 em metade das camadas do gpt-oss). O DeepSeek V3 e o R1 guardam um latent de 576 valores por camada por token em vez de chaves e valores completos. FP16 usa 2 bytes por valor, um cache Q8_0 cerca de 1,06 e Q4_0 cerca de 0,56.
Overhead = 0,75 GiB + 3% dos pesos, cobrindo o contexto CUDA ou Metal e os buffers de computação. Os runtimes reais variam algumas centenas de megabytes. Velocidade = largura de banda da memória x 0,65 / (bytes dos pesos ativos + KV cache de uma sequência).
Tamanhos por quantização em resumo
Só os pesos, segundo esta calculadora, para o Llama 3.1 8B e o Llama 3.3 70B:
• FP16 / BF16: 15,0 GB e 131,5 GB
• Q8_0: 7,9 GB e 69,9 GB
• Q6_K: 6,1 GB e 54,0 GB
• Q5_K_M: 5,3 GB e 46,8 GB
• Q4_K_M: 4,6 GB e 40,2 GB
• Q3_K_M: 3,7 GB e 32,9 GB
• Q2_K: 3,0 GB e 26,1 GB
Some o KV cache do seu contexto e cerca de 1 GB de overhead para saber quanto a GPU precisa comportar.
Modelos mixture-of-experts: memória de modelo grande, velocidade de modelo pequeno
Um modelo mixture-of-experts (MoE), como Qwen3 30B-A3B, Mixtral 8x7B, gpt-oss ou DeepSeek R1, contém muitas sub-redes de experts, mas usa só algumas para cada token. Todas precisam estar na memória, então a memória acompanha a contagem total de parâmetros. Já a velocidade acompanha os parâmetros ativos, porque só esses pesos são lidos a cada token.
É por isso que o Qwen3 30B-A3B em Q4_K_M precisa de cerca de 19 GB, a memória de um modelo denso de 30B, mas gera texto na velocidade de um de 3B. É também por isso que modelos MoE combinam com Macs e outras máquinas com bastante memória mais lenta: a capacidade é a restrição, a largura de banda nem tanto.
O DeepSeek R1, com 671B de parâmetros, é o caso extremo: cerca de 380 GB em Q4_K_M, além do que qualquer máquina doméstica comporta, embora só 37B de parâmetros fiquem ativos por token.
Ferramentas grátis relacionadas
- Calculadora de custo de API de LLM — Compare o custo da sua carga de trabalho em mais de 40 modelos, com cache, descontos de batch, faixas de contexto longo e tokens de raciocínio. Preços com fonte e data.
- Contador de tokens — Conte tokens com exatidão para modelos da OpenAI, estime para Claude, Gemini e Llama, veja o custo e acompanhe o texto sendo dividido em tokens.
- Calculadora de ROI de IA — Estime quantas horas e quanto dinheiro automatizar uma tarefa repetitiva pode economizar para a sua empresa a cada ano.