llama.cpp

El motor de inferencia C++ de referencia para LLMs de código abierto — el proyecto que Ollama / LM Studio / Jan / KoboldCpp / llamafile envuelven, creado por el desarrollador que inventó el formato de modelo GGUF en el que se estandarizó el ecosistema de pesos abiertos. Calificado como Grade A porque `llama.cpp` es la capa irreducible de inferencia local: sin operador en la ruta de datos, con licencia MIT, instalación de un solo binario, cero cuentas en cualquier parte, aceleración nativa en CPU + NVIDIA CUDA + AMD ROCm + Apple Metal + Vulkan. La postura de privacidad más fuerte disponible en este directorio, conjuntamente con Ollama (que se sitúa una capa de envoltorio por encima), y la respuesta correcta cuando quieres control máximo sobre cuantización, ventana de contexto, tamaño de lote y división de descarga — las cosas que Ollama abstrae.

Qué es. `llama.cpp` es un proyecto C++ de un solo repositorio (`github.com/ggml-org/llama.cpp`, más de 70k estrellas) que carga pesos de modelos GGUF cuantizados y ejecuta inferencia LLM contra ellos. Incluye:

• Una CLI (`./llama-cli`) para consultas únicas y REPL interactivo
• Un servidor HTTP (`./llama-server`) que expone un endpoint `/v1/chat/completions` compatible con OpenAI
• Una biblioteca C++ que puedes enlazar desde cualquier lenguaje anfitrión (Python mediante `llama-cpp-python`, Rust mediante `llama-rs`, Go, Node, etc.)
• La cadena de herramientas `convert_hf_to_gguf.py` para convertir cualquier modelo de Hugging Face a GGUF
• El binario `quantize` que produce todos los niveles de cuantización desde `Q2_K` hasta `Q8_0` hasta FP16 / BF16 completo

Donde Ollama es el envoltorio de "aplicación de consumo", `llama.cpp` es el motor. Cada función de Ollama (servicio de modelos, plantillas de prompts, descarga de GPU, llamada a funciones) es `llama.cpp` por debajo. Si quieres saltarte el envoltorio — tener tus propios archivos de modelo, controlar la cuantización por despliegue, enlazar la biblioteca en un servidor personalizado — este es el proyecto.

Antecedentes. Iniciado en marzo de 2023 por Georgi Gerganov como un puerto del modelo LLaMA de Meta a C++, originalmente dirigido a Macs Apple Silicon. El proyecto se convirtió rápidamente en la implementación de referencia de facto para ejecutar LLMs de pesos abiertos localmente — a mediados de 2024 todo el ecosistema local de LLM (Ollama, LM Studio, KoboldCpp, GPT4All, llamafile, el backend local de OpenWebUI, el modo CPU de vLLM) se había estandarizado en el formato de modelo GGUF de Gerganov y sus algoritmos de cuantización.

`llama.cpp` es mantenido por un colectivo de código abierto a través de la organización GitHub `ggml-org` (~600 contribuidores a mediados de 2025). Gerganov también dirige la empresa ggml.ai (Sofía, Bulgaria) que proporciona soporte comercial y contribuye mejoras al motor de inferencia upstream, pero el código base permanece bajo licencia MIT y gobernado por la comunidad — sin CLA, sin cesión de derechos de autor, sin bifurcación empresarial.

En qué confías.

• La inferencia es local. Una vez que tienes un GGUF en disco, la generación se ejecuta completamente en tu hardware. El binario realiza cero llamadas de red durante la inferencia. Puedes ejecutar `llama-server` en una máquina desconectada y usarlo para siempre.
• Sin cuenta, sin registro, sin dependencia de registro. Descargas el código fuente / un binario de lanzamiento desde GitHub, compilas (o desempaquetas el precompilado), apuntas a un archivo GGUF. No existe una "cuenta llama.cpp". No se realiza ninguna búsqueda upstream.
• Licencia MIT, ~70k estrellas, ~600 contribuidores. Audita el commit de cualquiera en `github.com/ggml-org/llama.cpp`. Las correcciones de errores se envían horas después de que se reporta un problema grave. Varias empresas (Mozilla, ggml.ai, individuos) patrocinan a los mantenedores.
• Trae tus propios pesos de modelo. Los archivos GGUF provienen de Hugging Face (`hf.co/<org>/<model>-GGUF`), del archivo de TheBloke, de la conversión del operador de un checkpoint `safetensors`, o de cualquier tercero en quien confíes. No hay un registro central que controle lo que puedes ejecutar.
• Compilaciones reproducibles. El código fuente compila limpiamente con `cmake` + `make` estándar en cualquier sistema POSIX; los tarballs de `release` incluyen código fuente + binarios juntos. Puedes verificar el binario reconstruyendo desde el código fuente etiquetado.
• La telemetría es cero. Sin analíticas, sin pings de uso, sin informes de error que salgan de tu máquina. El proyecto no tiene un operador que pudiera recopilar datos incluso si quisiera.

Especificaciones operativas.

• Instalación — `git clone https://github.com/ggml-org/llama.cpp && cmake -B build && cmake --build build` (~5 min en una máquina moderna). O descarga un tarball de lanzamiento desde GitHub. Binarios precompilados para Linux / macOS / Windows incluidos por lanzamiento.
• Hardware — mínimo 4 GB de RAM para modelos pequeños (1-3B) en Q4; ~8 GB para 7B; 16-32 GB para 13B; 64+ GB para 70B. GPU opcional. Rutas de aceleración: NVIDIA CUDA, AMD ROCm + Vulkan, Apple Metal, Intel SYCL, Vulkan (multiproveedor). La inferencia solo CPU funciona en x86-64 + ARM (incluyendo teléfonos a través del puerto Android).
• Formatos de modelo — GGUF (nativo, todos los niveles de cuantización desde `IQ1_S` 1.5-bit hasta `F32` flotante de 32 bits). Convertidores disponibles desde `safetensors` de Hugging Face, `.bin` de PyTorch, checkpoints originales de `LLaMA`.
• Flags CLI — `./llama-cli -m model.gguf -p "tu prompt" -n 256 --temp 0.7 -ngl 35 -c 4096`. `-ngl` controla la descarga de capas GPU (33-99 para GPU completa en 7B/Q4). `-c` establece la longitud de contexto. `--cache-type-k Q8_0 --cache-type-v Q8_0` cuantiza la caché KV para contextos más largos.
• Modo servidor — `./llama-server -m model.gguf --port 8080 --host 0.0.0.0 -c 8192 -ngl 99`. Expone `/completion`, `/chat/completions` (compatible con OpenAI), `/embeddings`, `/v1/audio/transcriptions` (integración whisper.cpp), y una UI de chat incorporada en la raíz.
• Bindings Python — `pip install llama-cpp-python` te da el mismo motor bajo una API Python; de primera clase para LangChain, LlamaIndex, pipelines RAG personalizados.
• Muestreo — top-k, top-p, min-p, locally-typical, mirostat, XTC, DRY, modelado de temperatura. Cada muestreador moderno que el campo ha inventado, expuesto como flags CLI.
• Decodificación especulativa — aceleración de modelo borrador (`--model-draft`) para una generación 1.5-3× más rápida en hardware capaz.
• Soporte — GitHub Issues (activo, se maneja el retraso de semanas), Discord, la pestaña de discusiones del proyecto. Sin SLA comercial en el nivel gratuito; `ggml.ai` vende servicios comerciales.

Filosofía del operador. Gerganov ha sido explícito en que `llama.cpp` está construido para "todos, en todas partes" — el objetivo explícito es hacer que la inferencia LLM funcione en cualquier hardware que el usuario tenga, incluyendo teléfonos, microcontroladores y servidores solo CPU. El soporte de primera clase del proyecto para cuantización `IQ1_S` (1.5-bit) y `Q2_K` (2-bit) es consecuencia de esto: incluso un modelo 70B puede caber en 16 GB de RAM a costa de algo de calidad. La biblioteca GGML subyacente es una primitiva tensorial mantenida por separado que otros proyectos (whisper.cpp, stable-diffusion.cpp, bark.cpp) comparten — Gerganov está construyendo el sustrato de inferencia abierto en lugar de una sola aplicación.

Justificación de la calificación. Grade A refleja: la postura de privacidad más fuerte en el directorio (inferencia local, sin operador en la ruta de datos, sin cuenta, sin telemetría), licencia MIT bajo normas permisivas de código abierto (bifurcable, auditable, sin CLA), el soporte de hardware más amplio (cada acelerador de consumo + CPU en cada plataforma común), el motor fundacional sobre el que se construye todo el ecosistema local de LLM (Ollama, LM Studio, Jan, KoboldCpp, llamafile dependen de él — la credibilidad se hereda hacia arriba), responsabilidad del operador nombrado sin dependencia del operador (Gerganov + ggml.ai públicamente identificados, pero el runtime sigue funcionando si cualquiera desaparece), sin incidentes importantes en r/LocalLLaMA / r/MachineLearning / GitHub issues en los últimos 12 meses, y mantenimiento activo — múltiples lanzamientos por mes. Última verificación 2026-05-26.

Útil cuando:

• Quieres control total sobre el nivel de cuantización, tipo de caché KV, longitud de contexto y división de descarga de GPU — cosas que Ollama abstrae.
• Estás integrando inferencia LLM en una aplicación personalizada (Electron, binding FFI, sistema embebido) y necesitas la biblioteca C++ en lugar de un servidor.
• Estás optimizando para el tamaño binario mínimo absoluto / huella de runtime mínima (ZeroMQ + `llama.cpp` es una pila de inferencia viable en ~5 MB).
• Necesitas un muestreador específico (mirostat, XTC, DRY) que Ollama no expone.
• Quieres ejecutar en hardware que Ollama no soporta limpiamente (GPUs solo Vulkan, Intel SYCL, SoCs ARM extraños, la caja Hetzner CPU que ya pagas).
• Estás construyendo/ejecutando benchmarks y necesitas control determinista por ejecución sobre cada parámetro de inferencia.

Advertencias:

• La configuración es de nivel desarrollador C++. La primera instalación es `git clone + cmake + make` y ~5 minutos; para no desarrolladores, la instalación curl + configuración automática de Ollama es el camino más amigable al mismo motor subyacente.
• Sin registro de modelos. Obtienes archivos GGUF por ti mismo (Hugging Face es el repositorio de facto, pero verifica al cargador; algunos trabajos de cuantización introducen regresiones sutiles de calidad). Ollama envuelve esto con `ollama.com/library`; `llama.cpp` no lo hace.
• La superficie API es funcional pero minimalista. La UI de chat incorporada en `localhost:8080/` es básica — adecuada para pruebas, no para usuarios finales en producción. Combínala con un frontend real (Open WebUI, React personalizado, tu propia solución).
• Cambios disruptivos durante iteración rápida. El proyecto lanza múltiples versiones por mes y a veces rompe la compatibilidad del modelo (los GGUF antiguos necesitan recuantización contra nuevas versiones). Para producción, fija una etiqueta de lanzamiento y vuelve a probar antes de actualizar.
• La descarga de GPU requiere flags de compilación correctas. `cmake -DGGML_CUDA=ON` para NVIDIA, `-DGGML_HIPBLAS=ON` para AMD, `-DGGML_METAL=ON` (por defecto en macOS) para Apple. Olvidar un flag hace que silenciosamente recurra a CPU, lo que destruye el rendimiento. El README documenta esto; verifica antes de asumir que la GPU está funcionando.
• Sin contrato de soporte de proveedor en el nivel gratuito. Los errores se presentan como GitHub Issues; los usuarios serios compran servicios de `ggml.ai`. Combina el proyecto con capacidad de triaje interno si dependes de la inferencia para ingresos.
• La CLI de `llama.cpp` cambia la API entre lanzamientos. `./main` fue renombrado a `./llama-cli` a mediados de 2024, `./server` a `./llama-server`, etc. Los scripts fijados a nombres binarios antiguos necesitan actualización contra nuevos lanzamientos.