Key Takeaways
- A inferência somente com CPU funciona bem para modelos de 3-13B em processadores modernos com 8-32 GB de RAM.
- Melhores modelos CPU: Phi-4 Mini (3,8B, 2,3 GB, 12 tokens/s), Gemma 4 E2B (1,5 GB, 15 tokens/s), Llama 3.2 3B (2 GB, 10 tokens/s).
- A inferência CPU é 10-30× mais lenta que a GPU, mas usa zero VRAM dedicada.
- Ative o modo somente CPU no Ollama ou llama.cpp com uma simples opção de linha de comando.
- A inferência CPU é ideal para APIs de produção (sem sobrecarga de GPU), dispositivos edge e ambientes com orçamento limitado.
O Phi-4 Mini (3,8B) roda a cerca de 12 tokens/s em uma CPU moderna usando 2,3 GB de RAM, sendo a melhor escolha somente-CPU para chat geral.
Não é preciso placa de vídeo: esses modelos rodam na memória do sistema. São de 10 a 30 vezes mais lentos que na GPU, mas não consomem VRAM. Para chat geral use o Phi-4 Mini, para velocidade o Gemma 4 E2B (1,5 GB) e para qualidade o Llama 3.2 3B, todos via Ollama ou llama.cpp em modo CPU.
As CPUs podem rodar LLMs?
Sim, CPUs modernas (Intel i7 10.ª geração+, AMD Ryzen 5000+, Apple M-series) podem rodar modelos de 3-13B a 8-15 tokens por segundo. Isso é 10-30× mais lento do que uma GPU, mas não requer VRAM dedicada. Uma CPU com RAM do sistema suficiente (8-32 GB) pode rodar modelos que exigiriam uma GPU de US$ 300 ou mais.
A inferência em CPU troca velocidade por acessibilidade: zero sobrecarga de GPU, estabilidade perfeita e sem problemas de drivers. Para casos de uso ocasionais (chatbots que respondem poucas solicitações por segundo, processamento de documentos offline), o modo somente CPU é prático.
CPUs modernas têm instruções vetoriais AVX-512 ou NEON/SVE que aceleram operações matriciais. Ferramentas como llama.cpp e Ollama as utilizam automaticamente.
Melhores modelos somente CPU 2026
| Modelo | Parâmetros | RAM necessária | Velocidade CPU | Melhor para |
|---|---|---|---|---|
| Phi-4 Mini | 3,8B | ~2,3 GB | 12 tok/s | Chat geral, raciocínio |
| Gemma 4 E2B | 2B | ~1,5 GB | 15 tok/s | Velocidade máxima, edge |
| Llama 3.2 3B | 3B | ~2 GB | 10 tok/s | Qualidade equilibrada |
| Qwen3 8B | 8B | ~5 GB | 4-5 tok/s | Melhor programação em CPU, 76% HumanEval |
| DeepSeek-R1 7B | 7B | ~5 GB | 4 tok/s | Raciocínio, matemática (cadeia de pensamento) |
Qual a Diferença de Velocidade entre CPU e GPU?
A inferência em CPU roda de 5 a 30× mais lenta que a GPU: um i7-12700 atinge 12 tok/s contra mais de 80 tok/s de uma RTX 3060 no mesmo modelo 7B em Q4. Para chat interativo, isso significa 1-2 segundos até a primeira resposta na CPU contra menos de 200 ms na GPU. Estes benchmarks usam hardware padrão de 2026 via Ollama ou llama.cpp:
| Hardware | Modelo | Velocidade | Notas |
|---|---|---|---|
| Intel i7-12700 (CPU) | Phi-4 Mini 3.8B | 12 tokens/s | AVX-512 ativado |
| AMD Ryzen 7 5700X (CPU) | Phi-4 Mini 3.8B | 9 tokens/s | Apenas AVX2 (mais antigo) |
| Apple M3 (CPU) | Phi-4 Mini 3.8B | 14 tokens/s | Vantagem da memória unificada |
| RTX 3060 (GPU, 12 GB) | Phi-4 Mini 3.8B | 80 tokens/s | GPU é 6,7× mais rápida |
| RTX 4090 (GPU, 24 GB) | DeepSeek-R1 7B | 120 tokens/s | GPU é 30× mais rápida que a CPU |
Quanta RAM Cada Modelo Somente CPU Precisa?
Regra prática: tamanho do GGUF + 500 MB de overhead = RAM mínima necessária. Um modelo GGUF de 2 GB precisa de 2,5-3 GB de RAM livre do sistema:
| Modelo | Tamanho GGUF | RAM Mínima | Confortável | Comprimento de Contexto |
|---|---|---|---|---|
| Gemma 4 E2B | ~1,5 GB | 2-2,5 GB | 4 GB | 128K |
| Phi-4 Mini 3.8B | ~2,3 GB | 3 GB | 6 GB | 4K |
| Llama 3.2 3B | ~2 GB | 2,5-3 GB | 6 GB | 8K |
| Qwen3 8B | ~5 GB | 5 GB | 8 GB | 32K |
| DeepSeek-R1 7B | ~5 GB | 6 GB | 12 GB | 128K |
Como rodar no modo somente CPU
- Ollama (mais simples): `OLLAMA_NUM_GPU=0 ollama run llama3.2:3b` -- força somente CPU
- llama.cpp: `./llama-cli -m modelo.gguf --n-gpu-layers 0` -- zero camadas na GPU
- LM Studio: Nas configurações do modelo, defina "GPU Layers" como 0
Como Maximizar a Velocidade de Inferência em CPU?
Quantização Q4_K_M, llama.cpp multi-thread e flags de CPU AVX2/AVX-512 juntos adicionam 15-25% de velocidade em relação às configurações padrão do Ollama. Dicas específicas:
- Use quantização Q4_K_M — reduz o tamanho do GGUF em ~70%, com perda mínima de qualidade e ganho de 10-20% de velocidade por melhor uso de cache.
- Reduza a janela de contexto — contextos mais longos deixam a inferência mais lenta. Use `--context 2048` para limitar o contexto a 2K tokens.
- Ative o multi-threading — Ollama e llama.cpp detectam automaticamente o número de núcleos da CPU. Confira com `nproc` se está correto.
- Use AVX-512 ou ARM NEON — CPUs Intel/AMD/ARM modernas têm instruções vetoriais. Verifique as flags: `cat /proc/cpuinfo | grep avx512` (Linux) ou Sobre este Mac → Relatório do Sistema (Mac).
- Batch size = 1 — a CPU lida melhor com inferência de sequência única. Não tente multi-batch em CPU.
- Fixe as threads nos núcleos — no Linux, use `numactl --cpunodebind=0 ollama run phi:mini` para evitar sobrecarga de troca de núcleos.
Quando Usar CPU em Vez de GPU?
| Caso de Uso | CPU | GPU |
|---|---|---|
| Chat em tempo real (latência sub-1s) | ❌ Muito lenta (12 tok/s = 5s para 60 tokens) | ✅ 80+ tok/s |
| Processamento em lote (documentos, logs) | ✅ Tranquilo (velocidade não importa) | ⚠️ Exagero |
| API de produção (orçamento limitado) | ✅ Custo de hardware $0 | ⚠️ GPU de $200+ mais eletricidade |
| Dispositivo edge (Raspberry Pi) | ✅ Sem alternativa | ❌ Opções de GPU limitadas |
| Desenvolvimento / testes locais | ✅ Menor consumo, mais silenciosa | ⚠️ Exagero |
| Fine-tuning de LLM | ❌ Muito lenta (horas → dias) | ✅ 10-30× mais rápida |
Perguntas frequentes
Posso rodar LLMs somente com CPU?
Sim. CPUs modernas com 8+ GB de RAM podem rodar modelos de 3-7B a 8-15 tokens/s. Isso é suficiente para chat interativo com respostas em 10-30 segundos.
Qual é o melhor modelo LLM para CPU sem GPU?
Phi-4 Mini (3,8B) é o melhor equilíbrio de qualidade e velocidade para somente CPU em 2026. Gemma 4 E2B é o mais rápido. Llama 3.2 3B é o mais equilibrado.
A inferência somente CPU é adequada para o português?
Sim. Qwen3 8B (5 tok/s em CPU) tem melhor suporte para português. Phi-4 Mini e Llama 3.2 3B também funcionam razoavelmente em português.
A inferência CPU é adequada para produção?
Sim, se você não precisar de latência em tempo real. Processamento em lote, APIs assíncronas e fluxos de trabalho offline funcionam muito bem em CPU.
Qual a diferença de velocidade entre CPU e GPU na inferência?
CPU: 8-15 tokens/s em processadores modernos. GPU (RTX 3060): 80 tokens/s. GPU (RTX 4090): mais de 120 tokens/s. A CPU é de 10 a 30× mais lenta, mas não exige nenhum investimento em GPU.
Qual é o menor modelo que ainda produz respostas coerentes na CPU?
O Gemma 4 E2B (1,5 GB) produz respostas razoáveis. Abaixo de 2B, a qualidade cai bastante. Para a melhor qualidade com 8 GB de RAM, use o Phi-4 Mini (3,8B) ou o Llama 3.2 3B (2 GB).
É possível rodar um modelo de 13B na CPU?
Sim. Com quantização Q4_K_M, um modelo de 13B ocupa cerca de 6,5 GB e precisa de 8-12 GB de RAM do sistema. A velocidade fica em torno de 2-3 tokens/s -- desconfortável para uso interativo, mas funciona bem para processamento em lote.
A inferência em CPU usa a GPU em algum momento?
Não. O modo somente CPU no Ollama e no llama.cpp desativa explicitamente o uso da GPU e depende exclusivamente da RAM do sistema.
A inferência somente CPU é estável?
Sim, mais estável do que a GPU. Não há travamentos de driver nem erros de memória de GPU. O único risco é a saturação da RAM do sistema, que você controla escolhendo o modelo certo.
Preciso ajustar configurações para CPUs Apple Silicon?
Não. O Ollama detecta automaticamente os chips M1/M2/M3/M4 e usa a memória unificada com eficiência. O Apple Silicon é cerca de 10-20% mais rápido do que CPUs Intel equivalentes graças à sua arquitetura de memória.
Quanta VRAM um modelo de 7B precisa no modo somente CPU?
Nenhuma VRAM dedicada. Um modelo de 7B com quantização Q4_K_M (~4,5 GB) precisa de 5-6 GB de RAM do sistema para rodar com folga. Essa é a grande vantagem da inferência somente CPU: você não precisa de GPU nem de VRAM.
A inferência somente CPU é viável em um notebook antigo com 8-10 GB de RAM?
Sim. O Gemma 4 E2B (1,5 GB) ou o Phi-4 Mini (2,3 GB) rodam com eficiência em 8-10 GB de RAM. Espere de 3 a 5 tokens/s -- suficiente para processamento em lote ou um chatbot leve, mas lento demais para chat em tempo real.
Próximos passos
- LLMs locais mais rápidos para PCs básicos — PC antigo ou limitado? Melhores modelos para velocidade →
- Quantização de LLM explicada — Por que Q4_K_M importa para a velocidade do CPU →
- Melhores LLMs locais para programação — Melhores modelos leves de código para CPU →
Por Que LLMs Somente CPU Importam para Implantações Sensíveis à Privacidade?
LGPD do Brasil: a inferência em CPU em um dispositivo local é o nível mais alto de conformidade com privacidade de dados. Quando o Phi-4 Mini ou o Gemma 4 E2B roda na sua CPU, a inferência é totalmente isolada -- sem chamadas de API, sem telemetria, sem questões de residência de dados. Isso satisfaz os requisitos de segurança da LGPD (Lei nº 13.709/2018) no nível de infraestrutura. Empresas de saúde, jurídicas e o setor público no Brasil cada vez mais preferem a inferência em CPU para fluxos de trabalho com documentos sensíveis, já que até instâncias de GPU na nuvem criam complexidade de auditoria.
Mercados em desenvolvimento e ambientes offline: modelos em CPU funcionam sem internet confiável. Em regiões com conectividade instável ou banda limitada, a inferência em CPU viabiliza fluxos de trabalho de IA impossíveis com APIs na nuvem. Um arquivo GGUF do Phi-4 Mini baixado uma vez roda indefinidamente sem internet.
Ambientes sob controle de exportação: CPUs não enfrentam restrições de hardware. GPUs de servidor NVIDIA A100/H100 de ponta enfrentam controles de exportação dos EUA para certos países. CPUs de consumo não. Organizações em regiões afetadas podem rodar modelos capazes de 3B-7B em hardware x86 padrão sem restrições de importação.
Quais São os Erros Comuns na Inferência em CPU?
- Rodar FP16 em vez de Q4_K_M. O Phi-4 Mini em FP16 precisa de 7,6 GB de RAM contra 2,3 GB em Q4_K_M, com perda de qualidade insignificante. Sempre use modelos GGUF quantizados para inferência em CPU.
- Esquecer de definir as flags de somente CPU no llama.cpp. Sem flags explícitas, o llama.cpp pode tentar usar parcialmente a GPU. Defina `--n-gpu-layers 0` para o modo CPU puro.
- Usar batch size > 1 na CPU. O batching ajuda no throughput da GPU, mas prejudica a latência na CPU. Mantenha o batch size em 1 para chat interativo.
- Escolher um modelo grande demais. O Phi-4 Mini (3,8B) a 12 tok/s supera o DeepSeek-R1 7B a 4 tok/s para uso interativo. Ajuste o tamanho do modelo à velocidade da CPU, não só à RAM.
- Não definir a contagem de threads. O Ollama detecta threads automaticamente, mas o llama.cpp pode usar um valor padrão baixo. Defina explicitamente a contagem de threads para corresponder aos núcleos da sua CPU.