llama.cpp es el motor que democratizó la inferencia local de LLM: una implementación en C/C++, sin dependencias pesadas, capaz de ejecutar un modelo de lenguaje en un simple procesador, en una GPU de consumo o en un Mac. Lanzado por Georgi Gerganov y mantenido hoy bajo la organización ggml-org, es uno de los proyectos de código abierto más seguidos en GitHub, y una pieza sobre la que se apoyan numerosas herramientas, entre ellas Ollama.
Usar llama.cpp directamente, en lugar de a través de una capa superior, tiene varias ventajas: un control fino sobre la cuantización, el tamaño de contexto y el reparto de capas entre CPU y GPU, binarios ligeros fáciles de empaquetar y un servidor HTTP integrado que habla el dialecto de la API de OpenAI.
En este artículo presentamos las nociones clave (GGUF, cuantización, descarga a la GPU), compilamos y lanzamos llama-server, y vemos después cómo monitorizarlo: endpoint de salud, métricas de Prometheus, logs y trazas de OpenTelemetry en la aplicación, hasta un backend como Dynatrace.
llama.cpp en breve: GGUF, cuantización y backends
Tres nociones bastan para empezar.
- GGUF es el formato de archivo de los modelos para llama.cpp: un solo archivo contiene los pesos, el tokenizer y los metadatos. Muchos modelos abiertos se publican en este formato en Hugging Face.
- La cuantización reduce la precisión de los pesos (8 bits, 5 bits, 4 bits…) para disminuir la memoria necesaria y acelerar la inferencia, a costa de una ligera pérdida de calidad. Las variantes llevan nombres como
Q8_0oQ4_K_M. - Los backends determinan el hardware utilizado: CPU por defecto, CUDA para NVIDIA, Metal en Apple Silicon, Vulkan, HIP para AMD, entre otros. Se puede descargar a la GPU todas las capas del modelo o solo una parte.
El proyecto ofrece varias herramientas: llama-cli para conversar en el terminal, llama-server para servir un modelo por HTTP, llama-quantize para producir variantes cuantizadas y llama-bench para medir el rendimiento en tu propio hardware.
En la práctica: inferencia local con llama.cpp
Paso 1: instalar o compilar
Lo más rápido es usar un paquete (Homebrew, winget…) o los binarios precompilados que se publican con cada versión en GitHub. Para activar un backend concreto, se compila con CMake:
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build # CPU uniquement
# cmake -B build -DGGML_CUDA=ON # avec CUDA
cmake --build build --config Release -j
ls build/bin/ # llama-cli, llama-server, ...
Las opciones de compilación y los requisitos de cada backend se describen en la guía de compilación del repositorio oficial de llama.cpp.
Paso 2: obtener un modelo GGUF
Puedes descargar un archivo .gguf desde Hugging Face, o dejar que llama.cpp lo haga con la opción -hf, que toma un repositorio de Hugging Face (y, opcionalmente, una variante de cuantización):
build/bin/llama-cli -hf ggml-org/gemma-3-1b-it-GGUF
Elige la cuantización según la memoria disponible: un modelo de 7 a 8 miles de millones de parámetros en 4 bits cabe en unos pocos gigabytes, mientras que la versión de 16 bits necesita varias veces más.
Paso 3: lanzar el servidor HTTP
build/bin/llama-server \
-m modeles/mon-modele-Q4_K_M.gguf \
--host 127.0.0.1 --port 8080 \
-c 8192 \
-ngl 99 \
--metrics
-c fija el tamaño de contexto, -ngl el número de capas descargadas a la GPU (un valor alto las coloca todas si la memoria lo permite) y --metrics activa el endpoint de Prometheus. Una opción --api-key protege el acceso, y una opción de paralelismo regula el número de peticiones atendidas simultáneamente. Los nombres de las opciones evolucionan: llama-server --help es la referencia.
El servidor también ofrece una pequeña interfaz web en su raíz, práctica para una prueba rápida. Se publica una imagen de contenedor oficial en el registro de GitHub del proyecto.
Paso 4: llamar a la API compatible con OpenAI
curl -s http://127.0.0.1:8080/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"messages": [{"role": "user", "content": "Donne trois causes de latence réseau."}]}'
Las respuestas incluyen el recuento de tokens y, en el endpoint nativo, información de tiempo de procesamiento del prompt y de generación.
¿Cómo monitorizar llama-server?
Salud y disponibilidad
El endpoint /health indica si el servidor está listo; devuelve un error mientras el modelo se está cargando. Es el objetivo natural de una sonda de disponibilidad de Kubernetes o de un monitor sintético.
Métricas de Prometheus
Con --metrics, la ruta /metrics expone métricas con el prefijo llamacpp:: contadores de tokens de prompt y de tokens generados, rendimientos medios, peticiones en curso de procesamiento y peticiones diferidas por falta de un slot libre, así como el número medio de slots ocupados por llamada de decodificación y el tamaño de contexto máximo observado. Consulta tu instancia para ver la lista exacta:
curl -s http://127.0.0.1:8080/metrics | grep '^llamacpp'
Las peticiones diferidas son el indicador de saturación que hay que vigilar en primer lugar: significan que todos los slots están ocupados y que los clientes esperan.
Logs
llama-server escribe en la salida estándar: detección del hardware, carga del modelo, reparto de capas entre CPU y GPU y, después, una línea de tiempos por petición (tiempo de procesamiento del prompt, tokens por segundo en la generación). Estas líneas son valiosas para entender una degradación; un OpenTelemetry Collector o un agente de host las centraliza.
Trazas de OpenTelemetry
Que sepamos, el servidor no emite trazas de OpenTelemetry. Como es compatible con OpenAI, la solución más sencilla consiste en instrumentar la aplicación llamante con una instrumentación de OpenAI para OpenTelemetry (por ejemplo, las de OpenLLMetry), apuntando el cliente a la URL de llama-server. Cada llamada se convierte en un span con el modelo, los tokens y la duración, asociado a la traza de la petición del usuario.
Llevar llama.cpp a Dynatrace
La cadena es la misma que para vLLM: un OpenTelemetry Collector hace scrape de /metrics con el receptor prometheus, convierte los contadores a delta, recibe las trazas OTLP de la aplicación y exporta al endpoint OTLP de Dynatrace con un token de API. Detallamos esta configuración en vLLM en producción; basta con cambiar el objetivo del scrape. En un host equipado con OneAgent, las métricas de proceso y de GPU completan el cuadro.
Los indicadores útiles: tokens generados por segundo, peticiones diferidas, latencia por petición en el lado del cliente, utilización y memoria de la GPU, y número de reinicios. Para correlacionar estos datos con el resto de la cadena, aplica los principios de nuestro artículo OpenTelemetry de extremo a extremo.
Buenas prácticas
- Mide con
llama-benchen tu hardware antes de elegir una cuantización. - Activa siempre
--metricsy una sonda en/healthen cuanto un servidor se comparta. - Mantén
--host 127.0.0.1por defecto y añade una clave de API o un reverse proxy antes de cualquier exposición. - Fija la versión: el proyecto publica con mucha frecuencia y las opciones evolucionan.
- Descarga modelos GGUF solo de fuentes de confianza.
Preguntas frecuentes
¿Qué diferencia hay entre llama.cpp y Ollama?
Ollama se apoya en llama.cpp y añade una gestión simplificada de los modelos. llama.cpp ofrece más control y más opciones, con algo más de configuración. Consulta nuestra guía de Ollama en local.
¿Funciona llama.cpp sin GPU?
Sí, es incluso su punto de partida. El rendimiento depende entonces mucho del procesador, del ancho de banda de memoria y de la cuantización elegida.
¿Cómo activar las métricas de Prometheus de llama-server?
Lanzando el servidor con la opción --metrics; se exponen después en /metrics, en el mismo puerto que la API.
Conclusión
llama.cpp sigue siendo la referencia para la inferencia local ligera, del portátil al pequeño servidor con GPU. Su servidor integrado, compatible con OpenAI y dotado de métricas de Prometheus, lo hace fácil de integrar y de observar. Para situarlo frente a Ollama, vLLM y las demás piezas, consulta nuestra comparativa de pilas de IA de código abierto autoalojadas.
span.observer es un blog independiente de la comunidad, no afiliado a Dynatrace LLC ni a los proyectos citados. Las marcas citadas pertenecen a sus propietarios. Las herramientas evolucionan rápido: comprueba los comandos y opciones en su documentación oficial.