llama.cpp: conociendo, instalando y ejecutando IA local en Linux

Hay un proyecto del que casi todo el mundo depende sin saberlo. Cuando ejecutas un modelo local con Ollama, con LM Studio, con Jan o con esa aplicación de IA en el móvil, es muy probable que, en el fondo, quien esté haciendo los cálculos sea llama.cpp — un motor de inferencia escrito en C++ puro, sin Python, sin CUDA obligatorio, sin ninguna dependencia.

Este post es la guía directa: de dónde viene, cómo instalarlo, cómo ejecutar el primer modelo y cómo ponerlo a servir una API.

De dónde viene llama.cpp

La historia comienza con una biblioteca, no con LLaMA. En septiembre de 2022, el búlgaro Georgi Gerganov empezó a escribir la GGML — una biblioteca de álgebra tensorial en C, pensada para ejecutarse rápido en una CPU común.

En marzo de 2023 los pesos de LLaMA, de Meta, se filtraron. Pocos días después, el 10 de marzo de 2023, Gerganov publicó llama.cpp: el modelo de Meta ejecutándose en un MacBook, sin GPU, sin Python, sin nada. Fue uno de esos momentos en los que el listón de lo posible se mueve de sitio — hasta entonces, “ejecutar un LLM” significaba alquilar una GPU de centro de datos.

Qué vino después:

• Junio de 2023 — Gerganov funda ggml.ai en Sofía, Bulgaria, con una inversión pre-semilla de Nat Friedman (ex-CEO de GitHub) y Daniel Gross, a través de AI Grant.
• 21 de agosto de 2023 — nace el formato GGUF, que sustituye al antiguo GGML y se convierte en el estándar de facto de modelo cuantizado.
• 20 de febrero de 2026 — la Hugging Face anuncia que Gerganov y el equipo de GGML se incorporaron a la organización, como empleados a tiempo completo, manteniendo autonomía y liderazgo técnico sobre el proyecto.
• Julio de 2026 — reformulación importante: el llama-cli deja de ejecutar la inferencia en su propio proceso y se convierte en un cliente ligero que levanta el llama-server por debajo y se comunica con él.

Hoy el proyecto vive en ggml-org/llama.cpp, licencia MIT, con más de 127 mil estrellas — y obtuvo su propio sitio web, el llama.app.

GGUF: el formato que hace que todo funcione

El llama.cpp ejecuta modelos en formato GGUF, y entender esto evita mucha confusión.

Un GGUF es un único archivo que empaqueta todo lo que el modelo necesita: los pesos, el tokenizador y los metadatos. No hay un directorio con una docena de archivos, no hay config.json por separado, no hay sorpresa de “falta el tokenizador”. Descargas un archivo y se ejecuta.

Y carga los pesos cuantizados — comprimidos de 16 bits a 8, 5, 4 o menos por parámetro. Es esa compresión la que hace que un modelo de 8 mil millones de parámetros quepa en 5 GB en lugar de 16, y por eso se ejecuta en tu portátil.

¿llama.cpp, Ollama o vLLM?

La confusión más habitual es pensar que son competidores. En realidad no lo son exactamente:

	llama.cpp	Ollama	vLLM
Qué es	El motor	Una capa de conveniencia	Motor de servidor
Escrito en	C++	Go	Python
Hardware	CPU, cualquier GPU, Raspberry Pi	CPU y GPU	GPU dedicada
Formato	GGUF	GGUF, mediante registro propio	Pesos de Hugging Face
Control	Total, hasta el más mínimo detalle	Patrones listos	Enfoque en rendimiento
Rendimiento bajo carga	Modesta	Modesta	Es el objetivo del proyecto

En resumen: el Ollama es más fácil y utiliza buena parte de esta base; el vLLM sirve a mucha gente a la vez en una GPU grande; llama.cpp es para quien quiere control, quiere ejecutar en hardware modesto o exótico, o quiere entender lo que realmente está pasando.

Instalación

El camino recomendado hoy es el instalador oficial, que detecta la plataforma y descarga el binario adecuado:

curl -LsSf https://llama.app/install.sh | sh

llama cli --version

Si prefieres compilar, que es lo que querrás hacer para aprovechar la GPU NVIDIA:

sudo apt update
sudo apt install -y build-essential cmake git libcurl4-openssl-dev

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

# CPU apenas
cmake -B build
cmake --build build --config Release -j$(nproc)

# com CUDA (precisa do CUDA Toolkit instalado)
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)

Existen back-ends para prácticamente todo: -DGGML_CUDA=ON para NVIDIA, -DGGML_HIP=ON para AMD con ROCm, -DGGML_VULKAN=ON para cualquier GPU con Vulkan, -DGGML_METAL=ON en Apple Silicon. El mismo código, los mismos modelos, kernels ajustados a mano para cada uno.

Primeros pasos: conversando en la terminal

O llama cli descarga el modelo de Hugging Face y ya abre el chat. No es necesario descargar nada antes:

llama cli -hf unsloth/gemma-4-E4B-it-GGUF:Q4_K_M

La sintaxis es usuario/repositorio-GGUF:QUANTIZACAO. El modelo cae en la caché predeterminada de Hugging Face, que se comparte con otras herramientas, es decir, no se duplica si ya usas otra cosa.

# listar o que já está no cache
llama cli -cl

# usar um arquivo .gguf que você já tem em disco
llama cli -m ./meu-modelo.gguf

# uma pergunta só, sem entrar no chat — útil para script
llama cli -m ./meu-modelo.gguf -p "explique o comando tar czf" --no-cnv

Al final de cada respuesta muestra la velocidad en tokens por segundo, separando el procesamiento del prompt de la generación. Es la métrica que quieres mirar al comparar modelo, cuantización y ajuste.

llama serve: API compatible con OpenAI e interfaz web

Aquí el proyecto va más allá de lo que mucha gente imagina. Un comando levanta un servidor con interfaz de chat en el navegador y una API compatible con la de OpenAI:

llama serve -hf ggml-org/gemma-4-e4b-it-GGUF:Q4_0

Abre http://localhost:8080 y la interfaz ya está ahí, sin instalar ningún front-end. Y cualquier aplicación que hable con la API de OpenAI apunta aquí cambiando solo la URL:

curl http://localhost:8080/v1/chat/completions 
  -H "Content-Type: application/json" 
  -d '{
    "messages": [{"role": "user", "content": "Escreva uma unit systemd para /opt/job.sh"}]
  }'

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8080/v1", api_key="nao-importa")

r = client.chat.completions.create(
    model="local",
    messages=[{"role": "user", "content": "Explique inodes em duas frases."}],
)
print(r.choices[0].message.content)

Eligiendo la cuantización correcta

Es la decisión que más afecta al resultado, y la nomenclatura asusta sin motivo. La regla práctica:

Sufijo	Bits/peso	Cuándo usar
Q8_0	~8	Casi idéntico al original; úsalo si sobra memoria
Q6_K	~6,5	Pérdida desdeñable; excelente si cabe
Q5_K_M	~5,5	Excelente equilibrio
Q4_K_M	~4,8	El estándar razonable. Empieza por aquí
Q4_0	~4,5	Más rápido, algo peor que K_M
Q3_K_M	~3,9	Solo si la memoria es muy justa
Q2_K	~3	La calidad baja notablemente; evítalo

La cuenta rápida de memoria: multiplica los miles de millones de parámetros por 0,6 GB para obtener el tamaño aproximado en Q4, y suma un margen para el contexto. Un modelo de 8B en Q4_K_M ocupa unos 5 GB.

Y el consejo que ahorra tiempo: un modelo mayor mal cuantizado suele rendir más que un modelo pequeño bien cuantizado. Entre un 14B en Q4 y un 7B en Q8 ocupando la misma memoria, el 14B suele ganar.

Los parámetros que importan

llama serve -m ./modelo.gguf 
  -ngl 99 
  -c 8192 
  --host 0.0.0.0 --port 8080 
  -t 8

• -ngl (n-gpu-layers) — el más importante de todos. Cuántas capas del modelo van a la GPU. Usa -ngl 99 para mandar todo lo que quepa. Si el modelo no cabe entero, llama.cpp reparte entre GPU y CPU solo — y justo eso es lo que vLLM no hace con elegancia.
• -c — tamaño del contexto. Cuanto mayor, más memoria. Es el primer parámetro a reducir cuando falta VRAM.
• -t — número de hilos de CPU. El valor por defecto suele funcionar; ajusta si estás ejecutando solo en CPU.
• --host 0.0.0.0 — expone en la red. Atención: el servidor no tiene autenticación por defecto. Usa --api-key y un proxy inverso delante si vas a exponerlo.

Para descubrir el mejor ajuste de tu máquina, el proyecto trae un medidor listo:

llama-bench -m ./modelo.gguf -ngl 0,20,99

Ejecutándose como servicio

En servidor, cree /etc/systemd/system/llama.service:

[Unit]
Description=llama.cpp server
After=network-online.target
Wants=network-online.target

[Service]
Type=exec
User=llama
Group=llama
WorkingDirectory=/opt/llama
Environment="LLAMA_CACHE=/opt/llama/models"
ExecStart=/usr/local/bin/llama serve -m /opt/llama/models/modelo.gguf 
  -ngl 99 -c 8192 --host 127.0.0.1 --port 8080
Restart=always
RestartSec=5
TimeoutStartSec=300

[Install]
WantedBy=multi-user.target

sudo useradd -r -s /usr/sbin/nologin -d /opt/llama llama
sudo mkdir -p /opt/llama/models && sudo chown -R llama:llama /opt/llama
sudo systemctl daemon-reload
sudo systemctl enable --now llama
journalctl -u llama -f

O TimeoutStartSec alto es intencionado: cargar un modelo grande desde disco lleva tiempo, y el patrón de 90 segundos mataría el servicio a mitad de ejecución.

Cuantizando un modelo uno mismo

Si el modelo que quieres no tiene GGUF listo, se puede convertir:

cd llama.cpp
pip install -r requirements.txt

# baixe os pesos originais do Hugging Face e converta para GGUF em 16 bits
python convert_hf_to_gguf.py /caminho/do/modelo --outfile modelo-f16.gguf

# depois quantize
./build/bin/llama-quantize modelo-f16.gguf modelo-Q4_K_M.gguf Q4_K_M

En la práctica, casi nunca hace falta: la comunidad publica GGUF de todo lo importante en Hugging Face pocas horas después del lanzamiento.

Línea de tiempo

• Septiembre de 2022 — Georgi Gerganov empieza GGML, biblioteca de tensores en C.
• 10 de marzo de 2023 — sale llama.cpp, días después de la filtración de los pesos de LLaMA. LLM funcionando en un portátil, sin GPU.
• Junio de 2023 — nace ggml.ai, en Sofía, con inversión de Nat Friedman y Daniel Gross.
• 21 de agosto de 2023 — el formato GGUF sustituye a GGML y se convierte en estándar de facto.
• 20 de febrero de 2026 — Gerganov y el equipo de GGML se unen a la Hugging Face, manteniendo el liderazgo técnico del proyecto.
• Julio de 2026 — el llama-cli se convierte en cliente ligero de llama-server; llega la CLI unificada llama cli / llama serve y el sitio web llama.app.
• 2 de septiembre de 2026 — la NVIDIA anuncia la compra de Hugging Face por US$ 12,93 mil millones, con cierre previsto para el primer semestre de 2027, sujeto a aprobación regulatoria.

Lo que queda — y la ironía del final

llama.cpp es la prueba de que una decisión de ingeniería bien tomada vale más que presupuesto. Un desarrollador, C++ puro, sin dependencias, apostando que se podía ejecutar un modelo grande en hardware pequeño — y toda la industria acabó construyendo sobre eso.

Y ahí está la ironía que merece registrarse: el proyecto que nació para ejecutar IA sin depender de GPU cara terminó, por tres saltos, dentro de la NVIDIA — a través de Hugging Face, si se aprueba la compra. Jensen Huang dijo que la plataforma sigue abierta y que no hará falta hardware de NVIDIA para usarla. La licencia de llama.cpp es MIT, el código está publicado y un fork siempre es posible. Aun así, es el tipo de movimiento que vale la pena seguir de cerca.

Para continuar: Ollama si quieres el camino fácil, vLLM si necesitas servir a mucha gente, llama-model para gestionar tus GGUF, y el servidor de IA reacondicionado si la idea es montar la máquina.

Enlaces oficiales: llama.app · documentación · modelos recomendados · github.com/ggml-org/llama.cpp