llama.cpp: El motor bajo el capó

Qué cubre este artículo sobre llama.cpp

• Qué es llama.cpp y por qué es el motor de inferencia central del mundo de la IA local
• Cómo instalar llama.cpp, ya sea como binario precompilado o compilado desde el código fuente
• Qué backends de GPU (CUDA, Metal, ROCm, Vulkan) se soportan y cómo activarlos
• Cómo cargar modelos, ejecutarlos y usar el modo servidor para una API compatible con OpenAI
• Cuándo llama.cpp es la opción correcta y cuándo es mejor usar Ollama o LM Studio

Introducción: entendiendo llama.cpp

Si trabajas con IA local, hay un nombre inevitable: llama.cpp. Herramientas como Ollama y LM Studio utilizan exactamente esta librería C++ como motor de inferencia. Es el fundamento sobre el que se construye la mayoría del software de IA local.

llama.cpp fue desarrollado originalmente por Georgi Gerganov para ejecutar el modelo LLaMA de Meta en hardware comercial estándar. Hoy en día, el proyecto soporta docenas de arquitecturas de modelos y funciona en prácticamente cualquier dispositivo, desde Raspberry Pi hasta workstations de gama alta con múltiples GPUs.

Este artículo te explica qué hace llama.cpp, cómo instalarlo y usarlo, y cuándo merece la pena usarlo directamente en lugar de depender de una interfaz gráfica. Si estás comenzando, el artículo Qué es la IA local te proporciona una buena base.

¿Por qué necesito llama.cpp?

Imagina que ejecutas un LLM local en tu máquina y quieres extraer cada gota de rendimiento. Tienes una GPU específica con una versión CUDA determinada, y los binarios precompilados de Ollama no aprovechan todas las optimizaciones que tu hardware ofrece. O necesitas una función que no está disponible en las interfaces gráficas, como parámetros de muestreo específicos o un backend personalizado.

Aquí es donde entra llama.cpp. Es la capa más baja, que ofrece control directo sobre la compilación, la selección del backend y los parámetros de inferencia. Quién quiera entender qué hace realmente el software de IA local bajo el capó, tiene que conocer llama.cpp.

Otro motivo: llama.cpp es el proyecto de referencia para nuevos formatos de modelos y métodos de cuantización. Cuando se publica una nueva arquitectura de modelo, llama.cpp suele ser el primer proyecto en soportarla. Quién trabaja de forma experimental y necesita acceso a los últimos desarrollos, usa llama.cpp directamente.

llama.cpp en pocas palabras

llama.cpp es una librería C++ y un conjunto de herramientas de línea de comandos para la inferencia de modelos de lenguaje grande. El núcleo consiste en una implementación pura de C/C++ que no depende de frameworks de aprendizaje profundo externos como PyTorch o TensorFlow. Esto hace que el proyecto sea fácil de compilar y portable a una amplia gama de plataformas.

Los componentes principales son:

• llama-cli: Ejecuta un modelo y genera texto en modo interactivo.
• llama-server: Inicia un servidor HTTP con una API compatible con OpenAI.
• llama-quantize: Cuantiza modelos en varios formatos GGUF.
• libllama: La librería que otros programas pueden integrar.

Los modelos se cargan en formato GGUF, que agrupa la cuantización y metadatos en un único archivo. llama.cpp soporta una lista creciente de arquitecturas, incluyendo LLaMA, Mistral, Qwen, Phi, Gemma y muchas más.

¿Para quién está pensado llama.cpp?

llama.cpp se dirige a varios públicos:

• Desarrolladores que quieren integrar un motor de inferencia en sus propias aplicaciones.
• Usuarios avanzados que necesitan control máximo sobre parámetros y rendimiento.
• Investigadores que experimentan con nuevas arquitecturas de modelos o métodos de cuantización.
• Administradores de sistemas que desean ejecutar un servidor de inferencia local con API compatible con OpenAI.

Si simplemente quieres probar rápidamente un modelo sin preocuparte por sistemas de compilación y flags de línea de comandos, Ollama o LM Studio son opciones mejores. Estas herramientas usan llama.cpp bajo el capó, pero lo empaquetan en una interfaz amigable. Encontrarás más información en el artículo Ejecutar LLMs localmente.

Términos importantes relacionados con llama.cpp

Término	Explicación
llama.cpp	Motor de inferencia C++ para LLMs, sin dependencias de PyTorch o TensorFlow
GGUF	Formato de archivo para modelos cuantizados, reemplaza al antiguo formato GGML
GGML	El formato de modelo original, ahora reemplazado por GGUF
Cuantización	Reducción de la precisión de los pesos del modelo para ahorrar memoria y tiempo de cálculo
CUDA	Plataforma de Nvidia para programación GPU, el principal backend de GPU para llama.cpp
Metal	API de GPU de Apple, utilizada para Macs con Apple Silicon o GPUs AMD
BLAS	Basic Linear Algebra Subprograms, librerías para operaciones matriciales optimizadas
AVX	Advanced Vector Extensions, conjunto de instrucciones de CPU para operaciones de punto flotante paralelas
KV-Cache	Almacenamiento en caché de tensores Key y Value, acelera la generación de texto
Context Window	Número máximo de tokens que el modelo puede procesar simultáneamente

Qué hace especial a llama.cpp

Tres características distinguen llama.cpp de otros motores de inferencia:

Optimización de CPU como competencia central. llama.cpp fue construido desde el principio para ejecutarse eficientemente en CPUs. Utiliza conjuntos de instrucciones SIMD como AVX, AVX2, AVX-512 y NEON para acelerar las operaciones matriciales de la inferencia. En una CPU moderna, puedes ejecutar un modelo de 7B en cuantización de 4 bits con una velocidad aceptable, completamente sin GPU. Los detalles están en el artículo CPU vs. GPU.

Cuantización como parte integral. En lugar de cargar modelos en precisión completa de 16 bits, llama.cpp usa archivos GGUF cuantizados. Los formatos más comunes son Q4_K_M, Q5_K_M y Q8_0, que ofrecen un balance entre tamaño, velocidad y calidad. Puedes cuantizar modelos tú mismo o descargar archivos GGUF precompilados de plataformas como Hugging Face. Lee más sobre la teoría en el artículo Cuantización.

Amplio soporte de hardware. llama.cpp funciona en x86, ARM, WebAssembly y RISC-V. Soporta CUDA de Nvidia, Metal de Apple, ROCm de AMD, Vulkan y OpenCL como backends de GPU. Esta diversidad lo convierte en la navaja suiza de la inferencia local.

Instalación: binarios precompilados

La forma más rápida de obtener llama.cpp es a través de los binarios precompilados. En el repositorio de GitHub bajo Releases encontrarás compilaciones listas para Windows, macOS y Linux.

Windows: Descarga llama-bXXXX-bin-win-cuda-cu12.x-x64.zip si tienes una GPU Nvidia, o la variante de CPU llama-bXXXX-bin-win-avx2-x64.zip. Descomprime el archivo y ejecuta los archivos .exe incluidos.

macOS: Para Macs con Apple Silicon hay compilaciones con soporte Metal. Descarga llama-bXXXX-bin-macos-arm64.zip. En Macs Intel utiliza la variante x64.

Linux: La selección es más amplia aquí. Hay compilaciones para CPU, CUDA y ROCm. Elige la variante que se ajuste a tu hardware.

Ten en cuenta que los binarios precompilados no son óptimos para cada combinación de conjunto de instrucciones de CPU y controlador de GPU. Si quieres exprimir el último gramo de rendimiento, compilar desde el código fuente es el mejor camino.

Compilación desde el código fuente

Compilar llama.cpp es sencillo gracias a CMake. Solo necesitas un compilador C++, CMake y Git.

Build solo CPU

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build
cmake --build build --config Release

Después encontrarás los binarios en el directorio build/bin/.

Build con CUDA (Nvidia)

Para CUDA necesitas tener instalado el CUDA Toolkit. Activa CUDA con un flag de CMake:

cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j

El flag -j aprovecha todos los núcleos CPU disponibles para la compilación, acelerando significativamente el proceso.

Build con Metal (macOS)

En Macs con Apple Silicon, Metal está activado de forma predeterminada. Un build normal es suficiente:

cmake -B build
cmake --build build --config Release

Si Metal no se detecta automáticamente, puedes activarlo explícitamente:

cmake -B build -DGGML_METAL=ON
cmake --build build --config Release

Build con Vulkan

Vulkan es útil si tienes una GPU que no soporta CUDA ni Metal. Actívalo así:

cmake -B build -DGGML_VULKAN=ON
cmake --build build --config Release

Necesitarás tener instalada la Vulkan SDK en tu sistema.

Soporte de GPU

llama.cpp soporta varios backends de GPU que activas según tu hardware:

CUDA (Nvidia): El backend de GPU más maduro y con mejor rendimiento. Si tienes una GPU Nvidia, CUDA es tu primera opción. Puedes descargar partes del modelo a la GPU y calcular el resto en CPU. Más detalles en el artículo GPU Offloading.

Metal (Apple): En Macs con chips M1 a M4, llama.cpp utiliza Metal para aceleración de GPU. La memoria unificada de Apple Silicon es una ventaja aquí, ya que no requiere transferencias explícitas entre memoria CPU y GPU.

ROCm (AMD): Para GPUs AMD, especialmente bajo Linux. ROCm es menos maduro que CUDA, pero se está desarrollando activamente.

Vulkan: Un backend multiplataforma que funciona en una amplia variedad de GPUs. El rendimiento es típicamente menor que CUDA, pero la compatibilidad es más amplia.

Puedes compilar múltiples backends simultáneamente. llama.cpp elige el mejor backend disponible en tiempo de ejecución.

Cargar y ejecutar modelos

Después de la instalación necesitas un modelo en formato GGUF. Descarga uno desde Hugging Face, por ejemplo variantes cuantizadas de Llama o Mistral.

El uso más simple se ve así:

./llama-cli -m model.gguf -p "Explícame la cuantización en tres oraciones." -n 256

Los flags más importantes:

• -m: Ruta al archivo de modelo GGUF.
• -p: El prompt a procesar.
• -n: Número máximo de tokens a generar.
• -c: Tamaño de la ventana de contexto, por defecto es 2048.
• -t: Número de threads CPU.
• -ngl: Cantidad de capas a descargar a la GPU.

Para un diálogo interactivo usa -i:

./llama-cli -m model.gguf -i -c 4096 -ngl 33

Aquí se descargan 33 capas a la GPU, lo que es típico para un modelo 7B con cuantización de 4 bits.

Modo servidor

llama.cpp incluye un servidor HTTP que proporciona una API compatible con OpenAI. Es útil si tienes aplicaciones que ya hablan con la API de OpenAI y quieres cambiar a un modelo local.

Inicia el servidor así:

./llama-server -m model.gguf -c 4096 -ngl 33 --port 8080

Después accedes a la API en http://localhost:8080. Un ejemplo de llamada:

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "local-model",
    "messages": [{"role": "user", "content": "Hola, quién eres?"}]
  }'

El servidor soporta streaming, Function Calling (con modelos apropiados) y múltiples solicitudes paralelas. Para integración en tus propias aplicaciones, el modo servidor es a menudo la opción más directa.

llama.cpp vs. Ollama vs. LM Studio

Característica	llama.cpp	Ollama	LM Studio
Público objetivo	Desarrolladores, power users	Principiantes, desarrolladores	Principiantes, usuarios visuales
Interfaz	Línea de comandos	Línea de comandos, API	Aplicación de escritorio gráfica
Instalación	Build o binario	Un comando	Descarga, arrastra y suelta
Gestión de modelos	Manual (archivos GGUF)	Automática (registro de modelos)	Automática (integración Hugging Face)
Soporte de GPU	Todos los backends, control total	CUDA, Metal (precompilado)	CUDA, Metal (precompilado)
API	Compatible con OpenAI (servidor)	Compatible con OpenAI	Compatible con OpenAI
Personalización	Muy alta	Media	Baja

Cuándo usar llama.cpp: Cuando necesitas máximo control, quieres configurar hardware específico o integrar llama.cpp en tu propio proyecto.

Cuándo usar Ollama: Cuando quieres comenzar rápidamente y prefieres una CLI limpia con API. Ollama usa llama.cpp bajo el capó y abstrae la complejidad.

Cuándo usar LM Studio: Cuando prefieres una interfaz gráfica y quieres descargar y probar modelos con un clic. LM Studio también usa llama.cpp como motor de inferencia.

Obstáculos típicos con llama.cpp

1. Conjunto de instrucciones CPU incorrecto. Si usas un binario compilado para AVX2 pero tu CPU solo soporta AVX, el programa se bloqueará o irá extremadamente lento. Verifica con lscpu en Linux qué conjuntos de instrucciones soporta tu CPU.

2. Muy poca memoria de GPU. Si desciendes más capas a la GPU con -ngl de las que hay memoria disponible, la inferencia fallarả con un error. Reduce el valor gradualmente hasta que el modelo funcione.

3. Ventana de contexto demasiado pequeña. Una ventana de contexto pequeña hace que el modelo olvide el inicio de un prompt largo. Establece -c a un valor suficientemente alto, por ejemplo 4096 u 8192, dependiendo del modelo.

4. Variante GGUF incorrecta. Hay varios niveles de cuantización. Q4_K_M es un estándar sólido, pero si necesitas máxima calidad, elige Q8_0. Q2 o Q3 son muy pequeños, pero con pérdida de calidad notable.

5. Archivos GGUF desactualizados. El formato GGUF evoluciona. Los archivos GGUF muy antiguos pueden no ser compatibles con la versión actual de llama.cpp. Descarga modelos de nuevo o conviértelos con llama-quantize.

6. Threads configurados incorrectamente. Más threads no siempre es mejor. Como regla general, usa tantos threads como núcleos físicos tengas, no más. Los hyperthreads pueden incluso empeorar el rendimiento.

7. Versión de CUDA no coincide. La versión de CUDA del binario debe coincidir con la versión del driver Nvidia instalado. Si usas un binario CUDA 12.x, también necesitas un driver que soporte CUDA 12.

8. Metal no se detecta. En versiones antiguas de macOS o con ciertas versiones de Xcode, Metal puede no encontrarse. Asegúrate de que tu macOS y Xcode estén actualizados.

Hardware, costos y seguridad con llama.cpp

Hardware: llama.cpp funciona en casi cualquier hardware. Para un rendimiento aceptable con modelos 7B necesitas al menos 8 GB de RAM y una CPU con AVX2. Una GPU con 8 GB de VRAM permite GPU offloading e inferencia significativamente más rápida. Para modelos 13B o 33B se recomiendan 16 GB o 32 GB de RAM o VRAM respectivamente.

Costos: llama.cpp es código abierto bajo la licencia MIT y completamente gratuito. Los únicos costos provienen del hardware en el que lo ejecutas. No hay costos de API ni cuotas de suscripción, lo que representa una ventaja significativa frente a servicios de IA basados en la nube.

Seguridad: Dado que llama.cpp se ejecuta localmente, tus prompts y datos nunca salen de tu máquina. Esto es especialmente relevante para datos sensibles en campos como medicina, derecho o secretos empresariales. No necesitas enviar datos a servidores externos. Aún así, asegúrate de que los modelos que descargas provengan de fuentes confiables, ya que los archivos GGUF teóricamente podrían manipularse.

Enlaces útiles e información adicional sobre llama.cpp

• llama.cpp en GitHub - Repositorio oficial con documentación y releases
• Modelos GGUF en Hugging Face - Amplio catálogo de archivos GGUF listos para usar
• Discussions de llama.cpp - Soporte comunitario y consejos prácticos
• Ollama - Interfaz cómoda basada en llama.cpp
• LM Studio - Aplicación gráfica de escritorio que usa llama.cpp como motor
• Cuantización - Fundamentos sobre GGUF y niveles de cuantización
• GPU-Offloading - Cómo trasladar capas del modelo a la GPU

FAQ: llama.cpp - Preguntas frecuentes

¿Qué es exactamente llama.cpp? llama.cpp es una librería C++ y un conjunto de herramientas de línea de comandos para la inferencia de Large Language Models. No requiere frameworks de aprendizaje profundo como PyTorch y es simple de compilar.

¿Necesito una GPU para llama.cpp? No. llama.cpp funciona completamente en CPU. Una GPU acelera considerablemente la inferencia, pero no es obligatoria.

¿Cuál es la diferencia entre GGML y GGUF? GGML fue el formato de modelo original de llama.cpp. GGUF es su sucesor y resuelve varios problemas de GGML, como metadatos faltantes e incompatibilidades. Las versiones actuales de llama.cpp usan GGUF.

¿Puedo integrar llama.cpp en mi propia aplicación? Sí. llama.cpp se proporciona como librería (libllama), que puedes usar directamente en C, C++ o a través de bindings en Python, Go, Rust y otros lenguajes.

¿Cuántas capas debo trasladar a la GPU? Depende de tu VRAM disponible. Comienza con un valor bajo e increméntalo gradualmente hasta que la VRAM esté casi llena. Con un modelo de 7B y cuantización Q4, generalmente todas las 32 capas caben en una GPU de 8 GB.

¿Es llama.cpp más rápido que Ollama? Ollama usa llama.cpp como motor, así que la velocidad bruta de inferencia es comparable. Un llama.cpp compilado por ti mismo puede ser marginalmente más rápido mediante flags optimizados para hardware.

¿Puede llama.cpp cargar múltiples modelos simultáneamente? El modo servidor puede gestionar varios modelos si los inicias con puertos diferentes. La inferencia multi-modelo verdadera dentro de un solo proceso no está prevista actualmente.

¿Qué arquitecturas de modelos soporta llama.cpp? Una lista en constante expansión que incluye LLaMA, LLaMA 2, LLaMA 3, Mistral, Mixtral, Qwen, Phi-2, Phi-3, Gemma, Falcon, Baichuan y muchas más. La lista completa la encontrarás en la documentación.

¿Cómo actualizo llama.cpp? Si compilaste desde el código fuente, ejecuta git pull y vuelve a compilar. Para binarios precompilados, simplemente descarga la última versión desde la página de releases.

¿Es llama.cpp gratuito? Sí, llama.cpp es código abierto bajo la licencia MIT. Puedes usarlo gratuitamente, incluso comercialmente.

¿Necesito internet para usar llama.cpp? Solo para descargar llama.cpp y los modelos GGUF. La inferencia se ejecuta completamente sin conexión en tu máquina.

Referencias y lecturas complementarias

• Gerganov, G. (2023). llama.cpp [Software]. GitHub. https://github.com/ggerganov/llama.cpp
• GGUF Format Specification. Hugging Face. https://github.com/ggerganov/ggml/blob/master/docs/gguf.md
• llama.cpp Build Documentation. GitHub. https://github.com/ggerganov/llama.cpp/blob/master/docs/build.md
• CUDA Toolkit Documentation. Nvidia. https://docs.nvidia.com/cuda/
• Metal Performance Shaders. Apple Developer. https://developer.apple.com/metal/