¿Ollama o Llama.cpp? Cuál elegir para montar tu propia Inteligencia Artificial 1Vistas: 1

Desde la primera publicación de los episodios sobre IA, aparecieron los comentarios sobre porque utilizar Ollama y no llama.cpp, o viceversa. En este episodio vamos a comparar ambos proyectos, sus ventajas e inconvenientes, y sobre todo, cuales son los casos de uso para cada uno de ellos. La verdad es que me han sorprendido algunos de los comentarios, que rayaban el insulto, pero, es lo que hay. Sin embargo, no intentes buscarlos, porque ese tipo de comentarios simplemente los borro y santas pascuas. Otra de las cuestiones que se ha planteado de forma reiterada es sobre el Hardware necesario. Así que en este episodio también le dedicaré una parte a esto del hardware, tanto el que yo utilizo, incluyendo una sorpresita como otras recomendaciones para aquellos que quieran iniciarse en esto de la IA local, sin depender de servicios en la nube. Y por último, algo que creo que faltaba desde el principio era el tema de los modelos. Porque los nombres de los modelos tienen su aquel y creo que es necesario dejarlo mas o menos claro, porque es importante a la hora de seleccionar lar herramienta que quieres utilizar

¿Ollama o Llama.cpp? Cuál elegir para montar tu propia Inteligencia Artificial

Sobre las jornadas de IA en Linux Center

Como te conté en los episodios anteriores el pasado día 25 de abril tuve la oportunidad de participar en unas Jornadas de IA en Linux Center de la mano de Slimbook, junto a Alejandro López (el culpable) y Manuel S Lemos. Te digo lo de culpable, porque como de costumbre, si el no llega a empujarme no hubiera participado, y lo cierto es que me resultaron increíblemente provechosas.

Tengo que agradecer a Slimbook la oportunidad de participar en estas jornadas, y a Linux Center por el trato recibido. Y por supuesto, a los asistentes, que se portaron de maravilla, y que me hicieron preguntas muy interesantes. De hecho, algunas de las preguntas que me hicieron en esas jornadas, son las que voy a tratar de responder en este episodio. El esfuerzo de Alejandro por organizar estas jornadas, y el de Manuel por compartir su experiencia, es digno de admirar, y espero que se repitan este tipo de eventos, porque creo que son muy necesarios para la comunidad.

Es mas, te tengo que decir, que cuando terminamos se comentó unas nuevas jornadas para dentro de un mes, así que estate atento. Por mi parte, si me deja Alejandro, lo dedicaré a Open WebUI, y como exprimir una NPU para correr modelos de IA. Pero bueno, eso ya lo veremos.

llama.cpp vs Ollama

Para entenderlo bien, hay que ver de dónde viene cada uno:

• llama.cpp: Es el motor puro. Escrito por Georgi Gerganov en C++ (de ahí su nombre), su objetivo es exprimir al máximo el hardware (especialmente la CPU y Apple Silicon, aunque vuela en NVIDIA/AMD). Es una implementación minimalista y de altísimo rendimiento. Si quieres tocar cada parámetro del modelo (quantización, contexto exacto, hilos), este es tu sitio.
• Ollama: Es la experiencia de usuario. Realmente, Ollama utiliza llama.cpp (y otros backends) por debajo, pero te ofrece una interfaz tipo «Docker». Te permite descargar modelos con un simple ollama run, gestiona los pesos, expone una API REST y se encarga de que todo funcione sin que tengas que compilar nada.

llama.cpp: El Quirófano de los Tensores

Es una implementación pura en C++ orientada a la eficiencia extrema mediante SIMD (Single Instruction Multiple Data).

• Gestión de Memoria (mmap): llama.cpp utiliza mmap para mapear el archivo del modelo directamente en el espacio de direcciones de memoria. Esto permite que el sistema operativo gestione qué partes del modelo están en RAM y cuáles no, reduciendo drásticamente el tiempo de carga.
• Quantización K-Quants: Aquí es donde vive la magia. llama.cpp te permite elegir exactamente cómo quieres «comprimir» el modelo (Q4_K_M, Q5_0, etc.). Puedes balancear la pérdida de precisión (perplexity) frente a la velocidad de inferencia a un nivel granular.
• Gramáticas (GBNF): Esto es vital. llama.cpp soporta gramáticas a nivel de muestreador (sampler). Puedes forzar a que la salida del modelo sea estrictamente un JSON válido o un esquema específico, sin que el modelo «delire» con texto extra.

Ollama: El Orquestador de Backends

Ollama no es solo un envoltorio; es un gestor de ciclos de vida.

• El Wrapper de Go: Ollama está escrito en Go. Cuando pides un modelo, Ollama levanta un proceso hijo que es, de hecho, una instancia de llama.cpp (o vLLM en algunos casos).
• Gestión dinámica de VRAM: Ollama es inteligente. Si tienes 8GB de VRAM y el modelo ocupa 10GB, él calcula automáticamente cuántas capas (layers) mandar a la GPU y cuántas dejar en la CPU. En llama.cpp tienes que pasarle el parámetro --n-gpu-layers a mano.
• Concurrencia: Ollama gestiona una cola de peticiones y puede cargar/descargar modelos de la memoria de video automáticamente tras un tiempo de inactividad.

Para un usuario normal el que quiere encender el ordenador y que la IA le ayude a escribir correos, resumir PDF o simplemente charlar sin complicaciones la respuesta es clara como el agua: Ollama.

Si llama.cpp es como construirte tu propio mueble cortando la madera y barnizándolo tú mismo, Ollama es como ir a IKEA: ya viene diseñado para que encaje a la primera.

Para un usuario normal, Ollama gana por goleada en estos tres puntos:

• La «Tienda» de Modelos (Registry): No tienes que buscar archivos raros por internet. Escribes ollama run llama3.1 y él solito se lo baja, lo verifica y lo arranca. Es como una App Store pero de IA.
• Se olvida del Hardware: No tienes que calcular cuántas capas caben en tu GPU. Ollama analiza tu tarjeta de vídeo y tu RAM y lo configura todo para que vaya lo más rápido posible de forma automática.
• El Ecosistema de Apps: Esta es la clave. Al tener una API estándar, puedes instalar interfaces visuales (GUIs) que son igualitas a ChatGPT.

Instalando llama.cpp

Aunque te dije en el episodio anterior que era el último en el que ibamos a tocar la terminal, te engañé un poquito, porque como de costumbre, depende mucho del feedbak, que como sabes es el alimento del podcaster. Después de estos comentarios, he integrado también llama.cpp para que lo puedas utilizar también con Podman de la siguiente forma,

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

[Container]
# We use the official image (check their latest tag)
Image=ghcr.io/ggml-org/llama.cpp:server-cuda
ContainerName=llama
PublishPort=8000:8000

AddDevice=nvidia.com/gpu=all
Annotation=run.oci.keep_original_groups=1

# Environment
Environment=NVIDIA_DRIVER_CAPABILITIES=all
Environment=NVIDIA_VISIBLE_DEVICES=all


# Exec
# Optimized for 16GB VRAM:
# --flash-attn: Essential for speed
Exec=--host 0.0.0.0 \
     --port ${PORT} \
     -m ${MODEL_PATH} \
     -ngl ${NGL} \
     -c ${CONTEXT_SIZE} \
     --flash-attn on \
     --batch-size ${BATCH}

#Volumes
Volume=/data/models:/models:Z

# Networks
Network=llama.network

[Service]
# Restart the container if it fails
Restart=always
Environment=PORT=8000
Environment=MODEL_PATH=/models/gemma-4-E4B-it-Q8_0.gguf
#Environment=MODEL_PATH=/models/gemma-4-26b-a4b-it-Q4_K_M.gguf
# -ngl 99: Offload everything to the 4060 Ti
Environment=NGL=99
# -c 32768: 32k context is very comfortable on 16GB
Environment=CONTEXT_SIZE=128000
# --batch 512: You can handle larger batches now
Environment=BATCH=512

[Install]
# Start this container when the user logs in
WantedBy=default.target

Por otro lado, como la gestión de modelos la tienes que hacer tu por tu cuenta, indicarte que estoy utilizando rust-hf-downloader.

rust-hf-downloader

Hardawre recomendado

En esta tabla comparativa he añadido no solo la GPU, sino también otros datos como VRAM, uso ideal y algún modelo con el que funcionar. Aquí tienes la tabla definitiva para tu soberanía digital,

Aquí falta la NPU de la que te he adelantado anteriormente. Slimbook, me ha dejado durante unos días un Slimbook One que lleva NPU, de la que te hablaré mas adelante y te podré hacer una comparativa con estos dispositivos. Y es que una de las grandes ventajas que ofrece es que te permite utilizar RAM.

Anatomía de un Modelo de IA

Otra cuestión que me he dejado es el tema del nombre de los modelos. A continuación en una tabla te resumo que es que en la definición de un modelo.

La Piedra Rosetta de la Quantización

Si ves estas siglas y te suenan a chino, aquí tienes el truco para entender la quantización de un vistazo:

• FP16 (Original): Sin compresión. Es el modelo «puro». Pesa una barbaridad.
• Q8_0: Compresión mínima. Calidad casi perfecta, pero sigue siendo pesado.
• Q4_K_M (El Recomendado): Es el estándar de la industria para local. Pierdes un 1-2% de precisión pero el modelo ocupa la mitad. ¡Es el que debes elegir casi siempre!
• Q2_K: Compresión extrema. El modelo se vuelve «tonto» y empieza a inventar cosas (alucinaciones), pero corre en hardware muy antiguo.

Más información

• Hardware PDF para IA Local
• Anatomía de Moedlos de IA