~/ / Artigos sobre IA / LLMs locais em uma VPS / Quanta memória um LLM local precisa em uma VPS? Arquivo do modelo mais cache KV
Quanta memória um LLM local precisa em uma VPS? Arquivo do modelo mais cache KV
Antes de alugar um servidor para rodar um modelo local, você precisa saber quanta memória ele consome. A resposta tem duas partes: o modelo em si e um cache que cresce com o tamanho da conversa e com o número de requisições tratadas ao mesmo tempo. Este artigo reúne o que a biblioteca do Ollama, o FAQ do Ollama e os arquivos de configuração oficiais dos modelos informam, calcula o cache de seis modelos populares e permite que você teste os seus próprios números.
Publicado: · 5 min de leitura · Dados dos modelos conferidos nas fontes oficiais em 2026-10-26. Tamanhos e valores padrão mudam, por isso confirme-os antes de escolher um plano.
Duas coisas ocupam a memória
A primeira são os pesos do modelo, que ocupam aproximadamente tanta memória quanto o arquivo baixado. A segunda é o cache KV, que guarda as chaves e os valores que o modelo já calculou para o texto presente no seu contexto. O FAQ do Ollama afirma que a RAM necessária escala com OLLAMA_NUM_PARALLEL multiplicado por OLLAMA_CONTEXT_LENGTH.
O tamanho do cache pode ser calculado a partir da configuração do modelo: 2 × camadas × cabeças KV × dimensão da cabeça × bytes por valor dá os bytes de um token, e você multiplica pelo tamanho do contexto e pelo número de requisições paralelas. Em f16, um valor ocupa 2 bytes. Para o Qwen3 8B, que tem 36 camadas, 8 cabeças KV e dimensão da cabeça de 128, um token ocupa 2 × 36 × 8 × 128 × 2 = 147,456 bytes. Com 4,096 tokens são 576 MiB, e com 32,768 tokens são 4,608 MiB. Esta fórmula é um cálculo nosso a partir dos valores de configuração, não um número publicado pelo Ollama.
O que as fontes oficiais dizem sobre cada modelo
O tamanho do download e a quantização são os que a biblioteca do Ollama mostra para cada tag, e as seis tags abaixo aparecem com a quantização Q4_K_M. As camadas, as cabeças KV e a dimensão da cabeça vêm do config.json de cada modelo no Hugging Face.
| Modelo | Tamanho do download (GB) | Camadas | Cabeças KV | Dimensão da cabeça |
|---|---|---|---|---|
| Qwen3 0.6B | 0.523 | 28 | 8 | 128 |
| Qwen3 1.7B | 1.4 | 28 | 8 | 128 |
| Qwen3 4B | 2.5 | 36 | 8 | 128 |
| Qwen3 8B | 5.2 | 36 | 8 | 128 |
| Qwen3 14B | 9.3 | 40 | 8 | 128 |
| Mistral 7B (v0.3) | 4.4 | 32 | 8 | 128 |
A configuração do Mistral 7B não informa a dimensão da cabeça, então ela é o tamanho oculto dividido pelo número de cabeças de atenção, 4096 ÷ 32 = 128. A tag Qwen3 4B na biblioteca do Ollama indica uma janela de contexto de 256K. As versões 2507 do Qwen3 4B no Hugging Face têm as mesmas camadas, cabeças KV e dimensão da cabeça que a original.
O que isso significa para a memória
Usando a fórmula acima, esta tabela mostra o cache de cada modelo em dois tamanhos de contexto e o total estimado com 4,096 tokens. O total é a soma dos pesos, do cache em f16 para uma requisição por vez e de uma reserva de 1 GiB para o sistema operacional e outros serviços. A última coluna é o menor tamanho de memória comum que comporta esse total.
| Modelo | Cache KV com 4,096 tokens (MiB) | Cache KV com 32,768 tokens (MiB) | Total estimado com 4,096 tokens (GiB) | Menor tamanho de memória comum (GiB) |
|---|---|---|---|---|
| Qwen3 0.6B | 448 | 3584 | 1.92 | 2 |
| Qwen3 1.7B | 448 | 3584 | 2.74 | 4 |
| Qwen3 4B | 576 | 4608 | 3.89 | 4 |
| Qwen3 8B | 576 | 4608 | 6.41 | 8 |
| Qwen3 14B | 640 | 5120 | 10.29 | 12 |
| Mistral 7B (v0.3) | 512 | 4096 | 5.60 | 8 |
Estas são estimativas, não medições. Um modelo que cabe com pouquíssima folga com 4,096 tokens deixará de caber quando você aumentar o tamanho do contexto: com 32,768 tokens, só o cache do Qwen3 8B já ocupa 4,608 MiB.
Contexto mais longo, mais requisições paralelas
- O FAQ do Ollama diz que a RAM necessária escala com OLLAMA_NUM_PARALLEL multiplicado por OLLAMA_CONTEXT_LENGTH e dá um exemplo: um contexto de 2K com 4 requisições paralelas resulta em um contexto de 8K e em memória adicional.
- OLLAMA_NUM_PARALLEL está documentado com valor padrão 1, então um servidor para um único usuário começa com uma requisição por vez.
- O FAQ também diz que quantizar o cache de chave-valor com q8_0 usa aproximadamente metade da memória do f16, e q4_0 aproximadamente um quarto. Com isso, o cache cai para cerca de 288 MiB no Qwen3 8B com 4,096 tokens em q8_0, usando a proporção do FAQ.
- A página sobre o tamanho do contexto na documentação do Ollama diz que um contexto maior aumenta a memória de que o modelo precisa, e que você pode consultar a coluna PROCESSOR de ollama ps para ver se um modelo foi transferido para a CPU.
Teste os seus próprios números
A calculadora abaixo usa a mesma fórmula e os mesmos dados. Escolha um modelo ou informe o seu, defina o tamanho do contexto, as requisições paralelas, o tipo de cache e uma reserva, e digite a memória do plano que você está avaliando para ver se a estimativa cabe.
Experimente: Local LLM Memory Estimator
Estimativa
- Pesos do modelo
- 4.84 GiB
- KV cache
- 0.56 GiB
- Reserva
- 1.00 GiB
- Total
- 6.41 GiB (6.88 GB)
- Menor tamanho de memória comum que o comporta
- 8 GiB
Esta é uma estimativa. Ela não inclui os buffers de computação do runtime e supõe que todas as camadas têm o mesmo formato de KV. Meça uma execução real antes de escolher um plano.
Dados do modelo verificados em 2026-10-26.
Fontes: Ollama library · Configuração do modelo (config.json) · Ollama FAQ
Tudo é executado no seu navegador. Nada é enviado.
Antes de escolher um plano
- A estimativa deixa de fora a memória de trabalho do próprio runtime para os seus buffers de computação. Nossa sugestão: rode o modelo em um servidor de teste, acompanhe o uso de memória com o tamanho de contexto que pretende usar e deixe uma margem.
- Um GB equivale a 1,000,000,000 bytes e um GiB equivale a 1,073,741,824 bytes. O "GB" de um provedor pode significar qualquer um dos dois, então verifique como o seu provedor conta antes de comparar.
- A memória não é o único limite. Os arquivos dos modelos da tabela também precisam de espaço em disco, e os documentos que consultamos não trazem números de velocidade para a operação somente com CPU.
- Se um modelo mal cabe, escolha o tamanho de memória seguinte ou um modelo menor, em vez de reduzir o tamanho do contexto até ele funcionar.
Fontes
- Ollama library: qwen3
- Ollama library: mistral
- Ollama documentation: FAQ
- Ollama documentation: Context length
- Qwen3-0.6B config.json (Hugging Face)
- Qwen3-1.7B config.json (Hugging Face)
- Qwen3-4B config.json (Hugging Face)
- Qwen3-8B config.json (Hugging Face)
- Qwen3-14B config.json (Hugging Face)
- Mistral-7B-Instruct-v0.3 config.json (Hugging Face)
Leia a seguir
- Chamando um modelo local pelo seu código: saídas estruturadas e a API compatível com OpenAI no OllamaRestrinja a saída de um modelo local com um JSON Schema e chame o Ollama a partir de clientes no estilo OpenAI: o que a documentação oficial diz e o que não é compatível.
- O que um modelo local sabe fazer? Tools, thinking, vision e embeddings no Ollama, e o que cabe em uma VPSTools, thinking, vision, embeddings: o que significam os rótulos da biblioteca do Ollama, quais modelos os têm e qual o tamanho dos downloads.
- Instalar o Ollama em uma VPS e mantê-lo em execução: instalação, serviço systemd, configurações e atualizaçõesInstale o Ollama em uma VPS Linux e mantenha-o em execução: o comando de instalação, o serviço systemd, as variáveis de ambiente, o armazenamento dos modelos e as atualizações, conforme a documentação oficial.
- IA no seu próprio VPS: quanta memória planejar e o que não exporVai rodar Ollama ou Dify em um VPS? O que a documentação oficial diz sobre memória, inferência só com CPU e as portas que devem ficar fechadas.