LLM local sem GPU (CPU): modelos por capacidade de RAM 8/16/32 GB

#Por que rodar um LLM local sem GPU?

Todos os guias de IA local partem do princípio de que você tem uma RTX 4070 no gabinete do seu PC. A realidade é que a grande maioria dos notebooks, computadores de mesa profissionais e mini-PCs funciona com GPU integrada ou sem nenhuma placa dedicada. Boa notícia: um LLM rodando só na CPU funciona.

Três razões típicas para usar apenas a CPU: um laptop sem GPU NVIDIA (a maioria dos Dell, Lenovo e Macs Intel antigos), um PC de mesa profissional com uma iGPU Intel ou AMD, ou um servidor Linux sem interface gráfica que não se deseja equipar. Nos três casos, a questão não é "isso funciona?", mas "qual modelo continua utilizável?".

#O que você pode esperar na prática

Antes de baixar qualquer coisa, ajuste suas expectativas. Um LLM local sem GPU, usando apenas a CPU, não responde com a mesma rapidez que o ChatGPT ou um modelo em uma RTX 4090. Aqui estão estimativas realistas de ordem de grandeza para 2026:

Modelo 1B–2B Q4

20 a 40 tokens/segundo em uma CPU recente. Muito fluido, quase como um chat online. Perfeito para tarefas simples: reformulação, resumo curto, classificação.

Modelo 3B Q4

10 a 20 tokens/segundo. Continua confortável: você lê ao mesmo tempo que o modelo escreve. O ponto ideal da CPU para uso diário.

Modelo 7B–8B Q4

4 a 10 tokens/s. Utilizável, mas é preciso esperar. Bom para tarefas assíncronas (analisar um texto, gerar um rascunho).

Modelo 13B–14B Q4

2 a 5 tokens/s. No limite do tolerável. Reserve para tarefas em lote, não para conversas interativas.

Acima de 14B

Possível, mas doloroso. Melhor alugar uma hora de GPU na nuvem do que rodar um 32B no CPU.

#Modelos recomendados com base na RAM disponível

Ao usar a CPU, toda a RAM do sistema pode ser usada pelo modelo, mas é necessário reservar uma margem para o sistema operacional e seus aplicativos. Reserve entre 4 e 6 GB para o sistema. O restante determina o tamanho do modelo que você pode executar.

#8 GB de RAM: modelos de 2B a 4B

Qwen 3.5 2B Q4_K_M

≈1,9 GB. Ultra-rápido, multimodal, até 256k de contexto e licença Apache 2.0. Bom para reformular, traduzir e classificar.

Granite 4.2 3B Q4_K_M

≈2,2 GB. Muito econômico em recursos e eficiente no uso de tokens, desenvolvido pela IBM, licença Apache 2.0. Fala bem francês.

Qwen 3.5 4B Q4_K_M

≈3,4 GB. O novo modelo pequeno padrão. Sólido em código e em francês.

Gemma 4 E2B Q4 (QAT)

≈4,3 GB. Compacto e multimodal, desenvolvido pelo Google, passou a usar a licença Apache 2.0 em 2026.

#16 GB de RAM: uso confortável de modelos de 8B–12B

Granite 4.2 8B Q4_K_M

≈5,3 GB. Muito eficiente em termos de tokens, 128k de contexto, licença Apache 2.0. Rápido de carregar.

Qwen 3.5 9B Q4_K_M

≈6,6 GB. A escolha de 8 GB de 2026: 256k de contexto, visão, excelente em raciocínio e em francês.

Gemma 4 12B Q4_K_M

≈7,6 GB. Multimodal e eficiente, licença Apache 2.0. Um nível acima se sua RAM permitir.

Qwen 2.5 Coder 7B base Q4_K_M

Aproximadamente 4,7 GB. A exceção que continua vigente: a referência 2026 para autocompletar código inline (FIM) localmente.

#32 GB de RAM: dá para considerar um modelo de 24B

Mistral Small 24B Q4_K_M

≈14 GB. Generalista, muito bom em francês, mas 3 a 5 tokens/s na CPU.

gpt-oss 20B Q4 (MXFP4)

≈14 GB. Modelo com pesos abertos da OpenAI, muito rápido graças ao formato MXFP4, 131k de contexto.

Qwen 3.8 27B Q4_K_M (no limite)

≈18 GB. 262k de contexto, visão, licença Apache 2.0. Possível, mas lento, ~2 tokens/s. Mais útil em lote — considere definir o nível de raciocínio como low para evitar que o modelo raciocine demais.

#1. Instalar Ollama (modo CPU automático)

Ollama é a ferramenta mais simples para começar. Ele detecta automaticamente a ausência de GPU e muda para CPU sem configurações especiais. O daemon escuta por padrão em http://localhost:11434.

curl -fsSL https://ollama.com/install.sh | sh

Em Windows e macOS, baixe o instalador do ollama.com. Nenhum ajuste específico necessário para o modo CPU — Ollama faz a escolha correta sozinho.

ollama --version
ollama ps

O comando ollama ps deve exibir o status do daemon. Se uma conversa estiver em andamento, a coluna PROCESSOR indicará 100% CPU — exatamente o que queremos aqui.

#2. Três modelos para comparar usando apenas a CPU

Com 16 GB de RAM, a pergunta não é "qual modelo" mas "qual entre os três principais modelos pequenos de 2026". Baixe os três e faça sua própria avaliação em uma hora.

ollama pull qwen3.5:4b
ollama pull granite4.2:3b
ollama pull gemma4:e2b-it-qat

Qwen 3.5 4B

O melhor modelo versátil nesse tamanho. Muito sólido em francês, bom em código, 256k de contexto, segue bem as instruções. O mais lento dos três (por ter 4B de parâmetros).

Granite 4.2 3B

Muito econômico em recursos e eficiente no uso de tokens, desenvolvido pela IBM. Segue bem as instruções, com licença Apache 2.0. Um bom equilíbrio entre velocidade e qualidade.

Gemma 4 E2B

O mais rápido dos três. Multimodal, com qualidade surpreendente para seu tamanho. Ideal se você quer respostas quase em tempo real em uma CPU modesta. Tem desempenho inferior em código ao dos outros dois.

ollama run gemma4:e2b-it-qat --verbose
>>> Explique en 3 phrases la différence entre une LLC et une SAS.

A opção --verbose exibe as estatísticas ao final de cada resposta: prompt eval rate, eval rate (tokens/s na geração), total duration. Essa é sua métrica de referência nessa máquina.

#3. Benchmarks tokens/sec: ordens de grandeza

Aqui estão estimativas para máquinas representativas, sem GPU, com Ollama (que utiliza llama.cpp por trás) em quantização Q4_K_M. Seus resultados variarão em ±20% conforme o contexto, a memória e a frequência DDR.

#Intel Core i5-12400 + DDR4-3200 16 GB

Gemma 4 E2B Q4

≈ 26 tokens/segundo na geração

Granite 4.2 3B Q4_K_M

Aproximadamente 20 tokens por segundo

Qwen 3.5 4B Q4_K_M

≈ 15 tokens/sec

Granite 4.2 8B Q4_K_M

≈ 8 tokens/sec

Qwen 3.5 9B Q4_K_M

≈ 6 tokens/segundo

#Intel Core i7-13700K + DDR5-5600 32 GB

Gemma 4 E2B Q4

≈ 40 tokens/segundo

Granite 4.2 3B Q4_K_M

≈ 30 tokens/segundo

Qwen 3.5 4B Q4_K_M

≈ 23 tokens/sec

Qwen 3.5 9B Q4_K_M

≈ 12 tokens/sec

Mistral Small 24B Q4_K_M

≈ 4 tokens/sec

#AMD Ryzen 7 7700X + DDR5-6000 32 GB

Gemma 4 E2B Q4

≈ 44 tokens/sec

Granite 4.2 3B Q4_K_M

≈ 32 tokens/sec

Qwen 3.5 4B Q4_K_M

≈ 24 tokens/sec

Granite 4.2 8B Q4_K_M

≈ 13 tokens/sec

Qwen 3.5 9B Q4_K_M

≈ 11 tokens/sec

Mistral Small 24B Q4_K_M

≈ 5 tokens/sec

#4. Compilar o llama.cpp com AVX-512 (avançado)

Ollama inclui binários genéricos pré-compilados do llama.cpp. Ao compilar manualmente o llama.cpp com os conjuntos de instruções da sua CPU (AVX2, AVX-512, AMX), você pode obter um ganho de 10 a 30% em tokens por segundo em certos processadores. Restrito aos Intel Core de 11ª geração ou posteriores (Ice Lake / Rocket Lake / Sapphire Rapids) que suportam AVX-512.

grep -o 'avx512[a-z_]*' /proc/cpuinfo | sort -u

Se o comando retornar linhas (avx512f, avx512dq, etc.), sua CPU suporta AVX-512. Caso contrário, continue com a versão padrão do Ollama, pois você não terá nenhum ganho.

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build \
  -DGGML_NATIVE=ON \
  -DGGML_AVX512=ON \
  -DGGML_AVX512_VBMI=ON \
  -DGGML_AVX512_VNNI=ON
cmake --build build --config Release -j

A opção -DGGML_NATIVE=ON deixa o compilador detectar automaticamente os conjuntos de instruções da sua CPU e ativa tudo o que estiver disponível. É a abordagem mais simples e confiável.

./build/bin/llama-bench -m qwen3.5-9b-Q4_K_M.gguf -t 8

A opção -t define o número de threads (coloque o número de núcleos físicos, não lógicos). O llama-bench retorna uma tabela com pp512 (prompt eval) e tg128 (geração) em tokens/segundo — sua nova referência para comparação.

#Dicas para ganhar tokens por segundo no CPU

1. 01
   Definir o número de threads

   Por padrão, o Ollama utiliza todos os núcleos lógicos. Em alguns CPUs com hyper-threading, limitar aos núcleos físicos (OLLAMA_NUM_THREADS=8 para um processador com 8 núcleos) acelera em 5 a 15%.
2. 02
   Manter o modelo carregado

   O carregamento do modelo leva vários segundos. OLLAMA_KEEP_ALIVE=30m mantém o modelo na RAM por 30 minutos após a última requisição. Sem GPU, isso é ainda mais valioso, pois o recarregamento é lento.
3. 03
   Reduzir o contexto se possível

   num_ctx de 2048 em vez de 8192 economiza RAM e acelera significativamente. Mantenha um contexto grande apenas para os usos que realmente precisam dele (RAG, documentos longos).
4. 04
   Fechar Chrome e Slack

   Um LLM de 7B executado na CPU satura a largura de banda da memória. Tudo que também acessa a RAM (navegador com 50 abas, Slack, Teams) tira ciclos dele. Com 16 GB, isso pode fazer a diferença entre 5 e 8 tokens por segundo.
5. 05
   Escolher a DDR mais rápida compatível

   Se você fizer um upgrade: DDR4-3200 → DDR4-3600 = +10%. DDR4 → DDR5-5600 = +30 a 50%. O processador importa muito menos que a memória para a inferência de LLMs.

#Quando a CPU já não é suficiente

Sejamos honestos: sem GPU, alguns usos permanecem fora do alcance. Se você reconhecer seu caso na lista abaixo, é hora de considerar uma GPU, mesmo modesta (uma RTX 3060 de 12 GB usada por 250 € muda a vida), ou alugar recursos na nuvem por hora.

Chat interativo com um 13B+

2 a 5 tokens por segundo é lento demais para IA conversacional. Uma GPU de 12 GB resolve isso instantaneamente.

RAG com grande contexto (16k+)

O tempo de processamento da avaliação do prompt aumenta drasticamente na CPU. Uma RTX 3060 processa um prompt de 8k em 1 segundo; um i7 leva 30 segundos.

Autocompletamento de código em tempo real

As extensões de autocompletar em linha (Tabby e similares, no modo FIM com Qwen 2.5 Coder 7B base) precisam de respostas em menos de 200 ms. Usando CPU, você não conseguirá ficar abaixo de 1 a 2 segundos. GPU obrigatória.

Geração em volume

Processar 1000 documentos = dias na CPU, horas na GPU. Para um lote pontual, RunPod ou Vast.ai a 0,30 €/h fazem o trabalho em uma noite.

#Para se aprofundar

Você tem um LLM local que responde usando a CPU. Alguns próximos passos naturais, dependendo da sua próxima pergunta:

Escolher a quantização correta

Q4_K_M é uma opção padrão sensata, mas Q5_K_M ou Q3 têm seu lugar de acordo com a sua RAM. O guia de quantização detalha os compromissos.

Adicionar uma interface ao conjunto

O terminal é bom para testes. Open WebUI ou LM Studio oferecem uma interface local semelhante à do ChatGPT em poucos minutos.

Quando adicionar uma GPU

Se você decidir dar esse passo, o guia de escolha de GPU compara RTX 3060 vs 4060 vs 4070, com os benchmarks de LLM correspondentes.

Hardware recomendado: Radeon RX 9070 XT 16 GB — para passar do processamento exclusivamente na CPU para uma GPU dedicada. Todo o hardware de IA →