Sexto módulo del Curso de GPU para IA. Ollama (Módulo 5) es la puerta de entrada; llama.cpp es la sala de máquinas. Cuando necesitas exprimir una GPU justa de memoria, correr un modelo que Ollama no tiene empaquetado, o entender por qué algo va lento, bajas a este nivel.

La tesis del módulo

Ollama decide por ti; llama.cpp te deja decidir. Cuántas capas van a la GPU, cuánto contexto reservar, qué backend usar. El precio del control es escribir más flags — y el premio es correr modelos que “no caben” en tu tarjeta.

Qué es llama.cpp

Un motor de inferencia de código abierto, escrito en C/C++, nacido en 2023 para correr Llama en un MacBook — y convertido en la infraestructura de casi todo el ecosistema local: el formato GGUF es suyo, y Ollama, LM Studio y compañía lo usan por debajo.

Su superpoder es la portabilidad de backends: el mismo programa corre sobre CUDA (NVIDIA), Metal (Mac), Vulkan (casi cualquier GPU, incluidas AMD en Windows) o CPU pura.

 modelo.gguf (de Hugging Face)
        │
        ▼
 llama.cpp: el motor (llama-cli, llama-server)
        │
        ▼
 backend: CUDA · Metal · Vulkan · CPU

Se obtiene en binarios precompilados por backend desde los releases oficiales del proyecto en GitHub (elige el de tu plataforma: el build CUDA para NVIDIA, Vulkan para AMD en Windows), o compilándolo tú mismo. Trae dos ejecutables protagonistas: llama-cli (terminal) y llama-server (API).

Conseguir modelos: GGUF directo de Hugging Face

Sin el catálogo de Ollama, los modelos se descargan de Hugging Face, donde la comunidad publica repositorios -GGUF con todas las cuantizaciones de cada modelo. Ahí eliges el archivo exacto — Q4_K_M, Q5_K_M, el que tu VRAM pida — con los criterios del Módulo 4. Un solo archivo, un solo modelo, cero magia.

La flag que lo cambia todo: -ngl

llama-cli -m qwen2.5-7b-instruct-q4_k_m.gguf -ngl 99 -c 8192 -p "Hola"

-m — el archivo GGUF.
-ngl (n-gpu-layers) — cuántas capas del modelo van a la GPU. 99 = todas las que existan. Esta flag es el offloading del Módulo 2 hecho perilla.
-c — el tamaño del contexto (y por tanto del KV cache que se reserva).

El detalle que quema a todo el mundo: sin -ngl, llama.cpp corre en CPU aunque tengas la mejor GPU del mercado. Es la causa #1 de “instalé todo y va lentísimo”.

Offloading fino: el arte de lo que no cabe

Aquí llama.cpp brilla sobre Ollama. Si un modelo no cabe entero, tú decides cuántas capas sacrificar:

Configuración	Efecto
`-ngl 99` (todo en GPU)	Velocidad completa
`-ngl` alto parcial (ej. 28 de 32 capas)	Pierdes algo, sigue usable
Mitad de capas o menos	La CPU domina: velocidad se desploma
`-ngl 0`	CPU pura: el modo supervivencia

La regla práctica: el offloading parcial rinde solo cuando es marginal. Si tienes que dejar fuera más de un puñado de capas, casi siempre gana bajar de cuantización (Q4 → Q3) o de tamaño de modelo. Y una perilla extra para VRAM justa: el KV cache se puede cuantizar (--cache-type-k q8_0), recortando lo que come el contexto.

llama-server: tu propia API

llama-server -m qwen2.5-7b-instruct-q4_k_m.gguf -ngl 99 -c 8192 --port 8080

Igual que Ollama, expone una API compatible con OpenAI — mismo patrón de cliente del módulo 5, apuntando a http://localhost:8080/v1. La diferencia es la filosofía: un servidor, un modelo, tus flags exactas. Para un servicio que corre un solo modelo bien afinado, es más liviano y predecible que el gestor completo.

Medir en serio: llama-bench

llama-bench -m qwen2.5-7b-instruct-q4_k_m.gguf

llama-bench mide por separado las dos fases de la inferencia — y distinguirlas te sube de nivel:

pp (prompt processing): qué tan rápido “lee” tu prompt. Aquí la GPU paraleliza a fondo: miles de tokens por segundo.
tg (token generation): qué tan rápido escribe. Esta es la fase memory-bound del Módulo 2, decenas de tokens por segundo.

Por eso un modelo local “piensa” casi instantáneo sobre un documento largo pero escribe a velocidad de lectura humana: son dos problemas distintos con dos límites distintos.

Errores comunes

Olvidar -ngl. El clásico absoluto. Sin esa flag no hay GPU, punto.
Descargar el binario sin tu backend. El release “CPU” no usa CUDA por mucho que tu tarjeta exista. Verifica el nombre del build.
Poner -c gigante “por si acaso”. El contexto reserva KV cache aunque no lo uses: -c 32768 puede ser el OOM que no te explicas.
Comparar velocidades mezclando pp y tg. “Me da 3.000 tokens/s” (pp) y “me da 40” (tg) son ambas ciertas; comparar peras con peras.
Bajar GGUF de repos aleatorios. Quédate con los cuantizadores de confianza de la comunidad; un GGUF mal hecho degrada el modelo sin avisar.

La frase para llevarse

“Ollama te presta el auto con chofer; llama.cpp te pasa las llaves. En una GPU justa de memoria, manejar tú es la diferencia entre caber y no caber.”

Qué viene

Módulo 7: vLLM y el serving de producción. Todo lo de hoy sirve a UN usuario; cuando son cincuenta a la vez, cambia el juego completo — batching continuo, PagedAttention y throughput real.

GPU para IA — Módulo 6: llama.cpp a fondo