Llama.cpp: guía completa para ejecutar modelos de IA en local

Si has usado Ollama o LM Studio para correr modelos de lenguaje en tu ordenador, has usado llama.cpp sin saberlo. Ollama está construido sobre llama.cpp. LM Studio también. Casi todo el ecosistema de IA local en 2026 se apoya en esta biblioteca de C++ creada por Georgi Gerganov. Pero si usas Ollama, estás viendo llama.cpp a través de una capa que esconde los detalles. Y a veces merece la pena levantar el capó.

En esta guía vas a instalar llama.cpp desde cero, descargar un modelo, ejecutarlo, servirlo como API y conectarlo con otras herramientas. Sin intermediarios, con control total y entendiendo lo que pasa debajo.

¿Qué es llama.cpp y por qué usarlo directamente?

Llama.cpp es un motor de inferencia de modelos de lenguaje escrito en C/C++. Su función es cargar un modelo (un archivo con los pesos de una red neuronal) y ejecutarlo para generar texto. No tiene dependencias pesadas: no necesita Python, PyTorch ni CUDA Toolkit para funcionar. Compila a binarios pequeños que corren en Linux, Windows, macOS, Raspberry Pi y hasta en el navegador.

El secreto de su eficiencia es el formato GGUF: un archivo único que contiene los pesos del modelo, el tokenizador y los metadatos. GGUF permite cuantizar los pesos —reducir su precisión de 16 bits a 8, 6, 4 o incluso 2 bits— para que un modelo que ocuparía 40 GB en precisión completa quepa en 10 GB y corra en una tarjeta gráfica de gama media.

Usar llama.cpp directamente en lugar de Ollama te da:
- Control total sobre cada parámetro de inferencia (temperatura, contexto, capas GPU, batching)
- La versión más reciente del motor, sin esperar a que Ollama la empaquete
- Capacidad de servir una API OpenAI-compatible para conectar cualquier herramienta
- Sin sobrecarga: un binario, sin demonios extra, sin capas de abstracción

Ollama es mejor para quien quiere empezar rápido sin pensar en configuración. Llama.cpp es para quien quiere entenderlo, afinarlo o integrarlo en sus propias herramientas.

Antes de empezar: qué necesitas

Llama.cpp no exige mucho. Para seguirlo solo necesitas:

• Git para clonar el repositorio
• CMake 3.14+ para compilar
• Un compilador C++17 (GCC, Clang o MSVC)
• Opcional pero recomendado: una GPU NVIDIA con los drivers más recientes

Si no tienes GPU, no te preocupes. Llama.cpp corre en CPU. Los modelos pequeños (3B o 7B cuantizados) funcionan bien con 8-16 GB de RAM. Será más lento que con GPU, pero funciona.

La regla para saber qué modelo te cabe: el archivo GGUF ocupa aproximadamente el tamaño que ves en Hugging Face, más un margen de 2-4 GB para el contexto (KV cache). Un modelo de 7B en Q4_K_M pesa unos 5 GB; necesitas al menos 8 GB libres para que corra cómodo.

Instalación: compilar desde fuente

El método recomendado es compilar desde el código fuente. Te da el mejor rendimiento y acceso a todas las opciones. La alternativa son los binarios precompilados, que veremos después.

Clonar el repositorio

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp

Compilar para CPU (funciona en cualquier máquina)

cmake -B build
cmake --build build --config Release -j$(nproc)

Los binarios aparecen en build/bin/. Lo principal:
- llama-cli — inferencia interactiva desde terminal
- llama-server — servidor con API compatible con OpenAI
- llama-quantize — cuantizar modelos
- llama-bench — benchmark de rendimiento

Compilar con aceleración GPU

Si tienes una GPU NVIDIA, el salto de velocidad es enorme. Necesitas tener instalado el CUDA Toolkit (descárgalo de NVIDIA si no lo tienes).

cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)

Si tu gráfica es AMD o prefieres una opción multiplataforma, puedes usar Vulkan:

cmake -B build -DGGML_VULKAN=ON
cmake --build build --config Release -j$(nproc)

Binarios precompilados (alternativa rápida)

Si no quieres compilar, en las releases de llama.cpp hay binarios listos para descargar para Windows, macOS y Linux con distintos backends (CPU, CUDA, Vulkan, ROCm, Metal). Solo tienes que descomprimir la carpeta y los binarios están listos para usar.

Descargar un modelo

Los modelos en formato GGUF se encuentran en Hugging Face. El repositorio más popular de GGUF es TheBloke, aunque cada vez más modelos oficiales incluyen GGUF nativo.

Para esta guía vamos a usar un modelo pequeño que funciona en casi cualquier equipo:

# Descargar un modelo pequeño para empezar (3.8B, ~2.5 GB en Q4)
curl -L -o models/qwen3.5-0.8b-q4.gguf \
  https://huggingface.co/unsloth/Qwen3.5-0.8B-GGUF/resolve/main/Qwen3.5-0.8B-Q4_K_M.gguf

Crea una carpeta llamada models/ dentro de llama.cpp y descarga ahí los modelos.

Si tu equipo tiene más memoria, prueba uno de 7B:

curl -L -o models/llama-3.2-3b-q4.gguf \
  https://huggingface.co/bartowski/Llama-3.2-3B-Instruct-GGUF/resolve/main/Llama-3.2-3B-Instruct-Q4_K_M.gguf

Ejecutar un modelo: llama-cli

Una vez descargado el modelo, puedes hablar con él directamente:

./build/bin/llama-cli -m models/qwen3.5-0.8b-q4.gguf -p "Explícame qué es una red neuronal como si tuviera 12 años" -n 256

• -m es la ruta al modelo
• -p es el prompt inicial
• -n es el número máximo de tokens a generar

Para una conversación interactiva:

./build/bin/llama-cli -m models/qwen3.5-0.8b-q4.gguf -i

La opción -i activa el modo interactivo: puedes escribir, recibir respuesta, escribir otra vez, igual que en un chat. Para salir, escribe /exit.

Medir el rendimiento

Antes de ajustar nada, ejecuta un benchmark de referencia:

./build/bin/llama-bench -m models/qwen3.5-0.8b-q4.gguf

La salida te muestra dos métricas:
- pp512 — prefill: velocidad procesando tu prompt (tokens de entrada por segundo)
- tg128 — decode: velocidad generando la respuesta (tokens de salida por segundo)

La que más importa para la experiencia de chat es tg128. Si ves menos de 10 tokens/segundo en un modelo de 7B, busca optimización.

Acelerar con GPU

Si compilaste con soporte CUDA, usa -ngl para indicar cuántas capas enviar a la GPU:

./build/bin/llama-cli -m models/llama-3.2-3b-q4.gguf -ngl -1 -p "Hola" -n 50

-ngl -1 significa "todas las capas posibles en GPU". También puedes poner un número concreto, como -ngl 20, dejando algunas capas en CPU si te quedas sin VRAM.

Con GPU activada, un modelo de 7B debería darte entre 30 y 70 tokens/segundo según tu tarjeta.

Servir como API: llama-server

Lo más potente de llama.cpp es el servidor. Expone una API compatible con OpenAI, lo que significa que cualquier herramienta que hable con ChatGPT puede hablar con tu modelo local.

./build/bin/llama-server -m models/qwen3.5-0.8b-q4.gguf

Por defecto escucha en http://127.0.0.1:8080. Abre esa dirección en el navegador y verás una interfaz de chat. Pero lo interesante es la API.

Llamar a la API desde cualquier sitio

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.5-0.8b",
    "messages": [
      {"role": "user", "content": "¿Qué es llama.cpp?"}
    ]
  }'

La respuesta incluye choices[0].message.content con el texto generado, exactamente como en la API de OpenAI. Esto significa que puedes conectar prácticamente cualquier herramienta.

Conectar con Continue.dev

Continue es una extensión de VS Code y JetBrains que te permite usar modelos locales como asistente de código. Para conectarlo a tu llama-server:

1. Abre la configuración de Continue (config.json)
2. Añade este proveedor:

{
  "models": [{
    "title": "Llama.cpp Local",
    "provider": "llamacpp",
    "apiBase": "http://localhost:8080"
  }]
}

Ya puedes usar tu modelo local para autocompletar, chat y edición de código, todo sin enviar tu código a ningún servidor externo.

Conectar con Open WebUI

Si prefieres una interfaz al estilo ChatGPT, Open WebUI (antes Ollama Web UI) también acepta endpoints compatibles con OpenAI:

1. En la configuración de Open WebUI, busca "Conexiones"
2. Añade un endpoint con URL http://localhost:8080/v1
3. Selecciónalo como proveedor activo

Optimización: sacar el máximo al hardware

Flash Attention

Reduce el uso de VRAM y acelera la generación con contextos largos. En GPU moderna funciona sin problemas:

./build/bin/llama-server -m models/llama-3.2-3b-q4.gguf -fa on

Ajustar el tamaño de contexto

Cada modelo tiene un máximo teórico. Si no especificas nada, usa el máximo. Para ahorrar memoria:

./build/bin/llama-server -m models/llama-3.2-3b-q4.gguf -c 8192

-c 8192 limita el contexto a 8192 tokens. Con contextos más pequeños puedes usar menos VRAM.

Cuantizar el contexto

Las claves y valores del KV cache también se pueden cuantizar para ahorrar memoria:

./build/bin/llama-server -m models/llama-3.2-3b-q4.gguf -ctk q4_0 -ctv q4_0

Batching

Controla cómo se procesan los tokens:

./build/bin/llama-server -m models/llama-3.2-3b-q4.gguf -b 4096 -ub 1024

• -b 4096: tokens máximos por lote en prefill
• -ub 1024: subtamaño para que la GPU procese más eficientemente

Varios slots (peticiones concurrentes)

Si quieres que varias personas o herramientas usen el servidor a la vez:

./build/bin/llama-server -m models/llama-3.2-3b-q4.gguf -np 2

Cada slot tiene su propio caché, así que el consumo de VRAM se multiplica.

Comando optimizado completo

./build/bin/llama-server \
  -m models/llama-3.2-3b-q4.gguf \
  -ngl -1 -fa on \
  -c 8192 -ctk q4_0 -ctv q4_0 \
  -b 4096 -ub 1024 \
  --host 0.0.0.0 --port 8080

Con --host 0.0.0.0 haces que el servidor sea accesible desde otros equipos de tu red local, ideal para tener un servidor de IA en casa al que se conectan todos tus dispositivos.

Entender los GGUF y la cuantización

Un modelo en su formato original (16 bits) ocupa el doble que en 8 bits, cuatro veces más que en 4 bits. La cuantización reduce la precisión de los pesos para que quepan en menos espacio. El truco está en que la pérdida de calidad es mucho menor de lo que sugiere la teoría.

Las cuantizaciones más comunes, ordenadas de mejor calidad a más compactas:

• Q8_0: prácticamente sin pérdida, pero ocupa casi lo mismo que el original
• Q6_K: muy buena calidad, ahorro notable
• Q5_K_M: el punto dulce para la mayoría (buena calidad, tamaño moderado)
• Q4_K_M: el estándar de facto (calidad aceptable, ocupa ~4.5 GB para un 7B)
• Q3_K_M: para equipos con poca RAM, se nota la pérdida
• Q2_K: mínima viabilidad, solo para modelos grandes en hardware muy limitado

Para uso general, empieza por Q4_K_M. Si tienes espacio, prueba Q5_K_M y mira si notas la diferencia.

Cuándo usar llama.cpp y cuándo usar Ollama

No hay una opción incorrecta. Ollama te da comodidad; llama.cpp te da control. Puedes tener ambos en el mismo equipo sin conflictos.

Resumen rápido

# 1. Clonar y compilar
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build && cmake --build build --config Release -j$(nproc)

# 2. Descargar un modelo
curl -L -o models/qwen3.5-0.8b-q4.gguf [url_del_gguf]

# 3. Probar en terminal
./build/bin/llama-cli -m models/qwen3.5-0.8b-q4.gguf -i

# 4. Servir como API
./build/bin/llama-server -m models/qwen3.5-0.8b-q4.gguf -ngl -1 -fa on

# 5. Hablar con la API
curl http://localhost:8080/v1/chat/completions -d '{"model":"qwen","messages":[{"role":"user","content":"Hola"}]}'

A partir de ahí, puedes enganchar Continue.dev, Open WebUI, o tu propia aplicación. Tienes un ChatGPT local, sin suscripción, sin enviar datos a nadie, y con control total sobre cómo funciona.