LLM local sin GPU (CPU): modelos según la RAM, 8/16/32 Go

#¿Por qué ejecutar un LLM local sin GPU?

Todas las guías de IA local dan por hecho que tienes una RTX 4070 en tu torre. La realidad es que una amplia mayoría de los portátiles, los ordenadores de sobremesa profesionales y los mini-PC funcionan con una GPU integrada o sin ninguna tarjeta dedicada. La buena noticia: un LLM ejecutado únicamente en la CPU funciona.

Tres razones típicas para usar solo el CPU: un portátil sin GPU NVIDIA (la mayoría de los Dell, Lenovo, Mac Intel antiguos), un ordenador de escritorio profesional con iGPU de Intel o AMD, o un servidor Linux headless que no se quiere equipar. En todos los casos, el reto no es "¿funciona o no?" sino "¿qué modelo sigue siendo usable?".

#Lo que puedes esperar en la práctica

Antes de descargar nada, ajusta tus expectativas. Un LLM local que funciona con CPU, sin GPU, no tiene la misma capacidad de respuesta que ChatGPT o un modelo en una RTX 4090. Estos son los órdenes de magnitud realistas en 2026:

Modelo 1B–2B Q4

20 a 40 tokens/segundo en CPU reciente. Muy fluido, casi como un chat en línea. Ideal para tareas simples: reformulación, resumen corto, clasificación.

Modelo 3B Q4

10 a 20 tokens/segundo. Sigue siendo cómodo: puedes leer al mismo tiempo que el modelo escribe. El punto ideal para el uso diario con CPU.

Modelo 7B–8B Q4

4 a 10 tokens/segundo. Se puede usar, pero hay que esperar. Bueno para tareas asincrónicas (analizar un texto, generar un borrador).

Modelo 13B–14B Q4

2 a 5 tokens/segundo. Al límite de lo tolerable. Resérvalo para tareas por lotes, no para el chat interactivo.

Más allá de 14B

Posible pero doloroso. Mejor alquilar una hora de GPU en la nube que ejecutar un 32B en CPU.

#Modelos recomendados según RAM disponible

En CPU, toda la RAM del sistema puede usarse para el modelo, pero hay que reservar espacio para el sistema operativo y tus aplicaciones. Reserva entre 4 y 6 GB para el sistema. El resto determina el tamaño del modelo accesible.

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

Qwen 3.5 2B Q4_K_M

≈1,9 GB. Ultrarrápido, multimodal, hasta 256k de contexto y licencia Apache 2.0. Bueno para reformular, traducir y clasificar.

Granite 4.2 3B Q4_K_M

≈2,2 GB. Muy ligero y eficiente en el uso de tokens, desarrollado por IBM, con licencia Apache 2.0. Habla bien francés.

Qwen 3.5 4B Q4_K_M

≈3,4 GB. El nuevo modelo pequeño por defecto. Sólido en programación y en francés.

Gemma 4 E2B Q4 (QAT)

≈4,3 GB. Compacto y multimodal, de Google, pasó a estar bajo licencia Apache 2.0 en 2026.

#16 GB de RAM: modelos de 8B–12B con margen suficiente

Granite 4.2 8B Q4_K_M

≈5,3 GB. Muy eficiente en tokens, 128k de contexto, licencia Apache 2.0. Rápido de cargar.

Qwen 3.5 9B Q4_K_M

≈6,6 GB. LA opción para 8 GB en 2026: 256k de contexto, visión, excelente en razonamiento y en francés.

Gemma 4 12B Q4_K_M

≈7,6 GB. Multimodal y eficiente, licencia Apache 2.0. Un nivel por encima si tu RAM lo permite.

Qwen 2.5 Coder 7B base Q4_K_M

≈4,7 GB. La excepción que sigue vigente: la referencia de 2026 para el autocompletado de código inline (FIM) en local.

#32 GB de RAM: se puede optar por un modelo de 24B

Mistral Small 24B Q4_K_M

≈14 GB. Generalista, muy bueno en francés, pero 3 a 5 tokens/seg en CPU.

gpt-oss 20B Q4 (MXFP4)

≈14 GB. Modelo de pesos abiertos de OpenAI, muy rápido gracias al formato MXFP4, 131k de contexto.

Qwen 3.8 27B Q4_K_M (al límite)

≈18 GB. 262k de contexto, visión, licencia Apache 2.0. Posible pero lento, ~2 tokens/segundo. Más útil para el procesamiento por lotes — considera ajustar su razonamiento a low para evitar que piense demasiado.

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

Ollama es la herramienta más sencilla para empezar. Detecta automáticamente la ausencia de GPU y cambia a CPU sin configuración especial. El daemon escucha por defecto en http://localhost:11434.

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

En Windows y macOS, descarga el instalador desde ollama.com. No hace falta ningún ajuste específico para el modo CPU: Ollama elige la opción adecuada por sí solo.

ollama --version
ollama ps

El comando ollama ps debe mostrar el estado del demonio. Si una conversación está en curso, la columna PROCESSOR indicará 100% CPU: exactamente lo que queremos aquí.

#2. Tres modelos para comparar solo en CPU

Para 16 GB de RAM, la pregunta no es «qué modelo» sino «cuál de los tres grandes modelos pequeños de 2026». Descarga los tres y forma tu propia opinión en una hora.

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

Qwen 3.5 4B

El mejor modelo polivalente de este tamaño. Muy sólido en francés, bueno en código, 256k de contexto, sigue bien las instrucciones. El más lento de los tres (por sus 4B parámetros).

Granite 4.2 3B

Muy sobrio y eficiente en el uso de tokens, desarrollado por IBM. Buen seguimiento de instrucciones, licencia Apache 2.0. Un buen equilibrio entre velocidad y calidad.

Gemma 4 E2B

El más rápido de los tres. Multimodal, con una calidad sorprendente para su tamaño. Ideal si quieres respuestas casi en tiempo real con una CPU modesta. Peor en programación que los otros dos.

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

La opción --verbose muestra las estadísticas al final de cada respuesta: prompt eval rate, eval rate (tokens/segundo durante la generación), total duration. Es tu métrica de referencia en esta máquina.

#3. Benchmarks de tokens/sec: órdenes de magnitud

Aquí tienes valores aproximados para máquinas representativas, sin GPU, con Ollama (que utiliza llama.cpp como base) y cuantización Q4_K_M. Tus resultados variarán en ±20 % según el contexto, la memoria y la frecuencia DDR.

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

Gemma 4 E2B Q4

≈ 26 tokens/segundo en generación

Granite 4.2 3B Q4_K_M

≈ 20 tokens/segundo

Qwen 3.5 4B Q4_K_M

≈ 15 tokens/sec

Granite 4.2 8B Q4_K_M

≈ 8 tokens/seg

Qwen 3.5 9B Q4_K_M

≈ 6 tokens/sec

#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/seg

Granite 4.2 3B Q4_K_M

≈ 32 tokens/seg

Qwen 3.5 4B Q4_K_M

≈ 24 tokens/seg

Granite 4.2 8B Q4_K_M

≈ 13 tokens/seg

Qwen 3.5 9B Q4_K_M

≈ 11 tokens/sec

Mistral Small 24B Q4_K_M

≈ 5 tokens/sec

#4. Compilar llama.cpp con AVX-512 (avanzado)

Ollama incluye binarios genéricos precompilados de llama.cpp. Al compilar llama.cpp manualmente con los conjuntos de instrucciones de tu CPU (AVX2, AVX-512, AMX), puedes aumentar entre un 10 y un 30 % los tokens/segundo en algunos procesadores. Reservado para los Intel Core de 11.ª generación o posteriores (Ice Lake / Rocket Lake / Sapphire Rapids) compatibles con AVX-512.

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

Si el comando devuelve líneas (avx512f, avx512dq, etc.), tu CPU admite AVX-512. De lo contrario, sigue con Ollama estándar: no ganarás nada.

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

La opción -DGGML_NATIVE=ON deja que el compilador detecte automáticamente los conjuntos de instrucciones de tu CPU y activa todo lo disponible. Es el método más sencillo y más fiable.

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

La opción -t define el número de hilos (coloca el número de núcleos físicos, no lógicos). llama-bench devuelve una tabla con pp512 (prompt eval), tg128 (generación) en tokens/segundo — tu nueva referencia para comparar.

#Consejos para ganar tokens/segundo en CPU

1. 01
   Configurar el número de hilos

   Por defecto, Ollama utiliza todos los núcleos lógicos. En algunas CPU con hyper-threading, limitar el número de hilos al de núcleos físicos (OLLAMA_NUM_THREADS=8 para un procesador de 8 núcleos) aumenta la velocidad entre un 5 % y un 15 %.
2. 02
   Mantener el modelo cargado

   La carga del modelo tarda varios segundos. OLLAMA_KEEP_ALIVE=30m mantiene el modelo en RAM durante 30 minutos después de la última solicitud. Sin GPU, esto resulta aún más útil porque volver a cargarlo es lento.
3. 03
   Reducir el contexto si es posible

   num_ctx de 2048 en lugar de 8192 ahorra RAM y acelera significativamente. No mantengas un gran contexto salvo para usos que realmente lo necesiten (RAG, documentos largos).
4. 04
   Cerrar Chrome y Slack

   Un LLM de 7B ejecutado en CPU satura el ancho de banda de la memoria. Todo lo que también utiliza la RAM (un navegador con 50 pestañas, Slack, Teams) le resta ciclos. Con 16 GB, eso puede marcar la diferencia entre 5 y 8 tokens/segundo.
5. 05
   Elegir la DDR más rápida compatible

   Si actualizas: DDR4-3200 → DDR4-3600 = +10 %. DDR4 → DDR5-5600 = +30 a 50 %. El CPU importa mucho menos que la memoria para la inferencia LLM.

#Cuando el CPU ya no es suficiente

Seamos honestos: sin GPU, algunos usos siguen fuera de alcance. Si reconoces tu caso en la lista siguiente, es hora de considerar una GPU, aunque sea modesta (una RTX 3060 de 12 GB de segunda mano por 250 € te cambia la vida), o de alquilar recursos en la nube por horas.

Chat interactivo con un 13B+

Entre 2 y 5 tokens/segundo es demasiado lento para la IA conversacional. Una GPU de 12 GB lo resuelve instantáneamente.

RAG con gran contexto (16k+)

El tiempo de procesamiento de la evaluación del prompt se dispara en CPU. Una RTX 3060 procesa un prompt de 8k en 1 segundo; un i7 tarda 30 segundos.

Autocompletado de código en tiempo real

Las extensiones de autocompletado dentro del editor (Tabby y similares, en modo FIM con Qwen 2.5 Coder 7B base) necesitan respuestas en menos de 200 ms. Con CPU, no bajarás de 1 a 2 segundos. GPU obligatoria.

Generación a gran escala

Procesar 1000 documentos = días en CPU, horas en GPU. Para un batch puntual, RunPod o Vast.ai a 0,30 €/h hacen el trabajo en una noche.

#Para ir más allá

Tienes un LLM local que se ejecuta en la CPU y responde. Algunas formas naturales de continuar según tu siguiente pregunta:

Elegir la cuantización adecuada

Q4_K_M es una opción sensata por defecto, pero Q5_K_M o Q3 también tienen su lugar según tu RAM. La guía de cuantización detalla los compromisos.

Dotar al conjunto de una interfaz

El terminal está bien para hacer pruebas. Open WebUI o LM Studio ofrecen una interfaz local similar a ChatGPT en unos minutos.

Cuándo añadir un GPU

Si das el paso, la guía para elegir una GPU compara las RTX 3060, 4060 y 4070, con los benchmarks de LLM correspondientes.

Hardware recomendado: Radeon RX 9070 XT 16 GB — para pasar de usar solo la CPU a una GPU dedicada. Todo el hardware de IA →