llama.cpp vs Ollama: el mismo motor, 4 peticiones a la vez o 1, y cuál elegir

Elige Ollama si quieres un comando por modelo, una aplicación de escritorio en Mac o Windows y modelos que se cargan y descargan solos. Elige llama.cpp si quieres todos los ajustes en la mano, 4 peticiones a la vez de fábrica y que no salga nada. Por debajo, el mismo motor: Ollama arranca dentro el servidor de llama.cpp.

Esa última frase es la gracia de esta comparativa, y no nos la creímos sin mirarla. llama.cpp v0.7.0 es la versión estable del 15 de octubre de 2026; Ollama 0.40.10 salió como estable el 23 de octubre de 2026. Hemos leído el código de las dos versiones allí donde deciden la memoria, las peticiones a la vez, la red y tu privacidad. No los hemos puesto a competir con cronómetro, así que aquí no hay ganador en velocidad: con el mismo fichero de modelo y el mismo motor, la velocidad depende de la compilación y de los ajustes, y esos ajustes son justo donde se separan.

llama.cppFicha del programa→ OllamaFicha del programa→

	llama.cpp	Ollama
Qué es	El motor en sí, con servidor, chat en la terminal y página de chat	Un gestor por encima: biblioteca de modelos, servicio en segundo plano y aplicación de escritorio
Versión a 24 de octubre de 2026	v0.7.0 (compilación b11669), y unas 16 compilaciones al día en el canal diario	0.40.10, que lleva dentro la compilación b11803 de llama.cpp
Código y licencia	Abierto, MIT	Abierto, MIT
Funciona en	Windows, macOS, Linux y Android; compilaciones para CPU, CUDA, ROCm, Vulkan, Metal, SYCL y OpenVINO	Windows 10 22H2 o posterior, macOS 14 o posterior y Linux; NVIDIA, AMD, Vulkan y Apple Silicon (también con MLX)
Ficheros de modelo	GGUF; safetensors solo tras convertirlos	GGUF y safetensors; en Apple Silicon, MLX por defecto
De dónde salen los modelos	Cualquier fichero GGUF, o Hugging Face con -hf	La biblioteca propia de Ollama con ollama pull, o tu propio fichero con un Modelfile
Peticiones a la vez, de fábrica	4, que comparten un mismo bloque de memoria de contexto	1 por modelo; las demás esperan en una cola de hasta 512
Contexto de fábrica	El máximo del modelo, recortado hasta que quepa (nunca por debajo de 4.096 tokens)	4.096 tokens con menos de 23 GiB de memoria gráfica, 32.768 desde 23 GiB y 262.144 desde 47 GiB
Modelo sin uso	Sigue cargado hasta que paras el servidor	Se descarga a los 5 minutos
Instalación y primera respuesta	Una compilación o brew install llama.cpp, y luego llama serve -hf con un modelo	Instalador o script de una línea, y luego ollama run con un modelo
Ventana	Una página de chat en tu navegador, activada de fábrica	Aplicación de escritorio en macOS y Windows; terminal en Linux
Escucha en	127.0.0.1:9931 (8080 hasta la v0.6.0)	127.0.0.1:11434
Clave y CORS	Sin clave de fábrica (--api-key la añade); CORS abierto a cualquier página web	Sin clave posible; CORS abierto solo a páginas de localhost, 127.0.0.1 y 0.0.0.0
Envía por su cuenta	Nada	2 tipos de llamada con ollama serve y 4 con la aplicación; OLLAMA_NO_CLOUD=1 corta 2

El mismo motor: lo que lleva dentro Ollama 0.40.10

Abres el código de Ollama y la relación está escrita sin rodeos. Un fichero en la raíz del proyecto, LLAMA_CPP_VERSION, fija el llama.cpp que compila: la b11803, una compilación diaria del 21 de octubre de 2026. Cuando cargas un modelo GGUF, Ollama 0.40.10 arranca el servidor de llama.cpp, llama-server, como un proceso aparte: en 127.0.0.1, en un puerto libre que elige el sistema, con su página de chat apagada y las descargas prohibidas (--offline). Ollama habla con él y te pasa las respuestas por su propia API, en el puerto 11434. Por encima añade una capa de compatibilidad suya y un parche pequeño al código de carga de modelos y de visión de llama.cpp.

Y aquí viene lo divertido: a 24 de octubre de 2026, el llama.cpp de Ollama es más nuevo que la estable del propio llama.cpp. La v0.7.0 es la compilación b11669, del 15 de octubre; Ollama lleva la b11803, 134 commits después. Las diarias de llama.cpp van todavía más por delante, así que si necesitas un modelo que salió ayer, llama.cpp a pelo llega antes.

El otro motor de Ollama es MLX, el de Apple, que usa en Apple Silicon siempre que el modelo que te bajaste sea su versión MLX. Flint, un modelo para programar, ya funciona con los dos motores: la 0.40.8 solo lo movía en macOS, a través de MLX; la 0.40.9 lo mueve también en Linux y Windows, porque la b11803 es la compilación de llama.cpp que añadió Flint. Su etiqueta por defecto en el catálogo de Ollama trae ahora dos versiones, MLX para los Mac con Apple Silicon y un fichero GGUF para llama.cpp en el resto, y Ollama descarga la que va con tu equipo.

Así que no eliges entre dos motores. Eliges entre usar el motor directamente, con todas sus opciones, o a través de un gestor que las elige por ti. El resto de la página va de esas elecciones.

4 peticiones a la vez, o 1

Arrancas llama serve y abre 4 huecos: hasta 4 peticiones se atienden al mismo tiempo. En el código de la v0.7.0, el número de huecos del servidor viene en automático, y automático significa 4, con un único bloque de memoria de contexto que comparten todos. Ese bloque compartido es el detalle que conviene saber: si lo arrancas con -c 8192, tienes 8.192 tokens para los 4 juntos, de modo que una conversación larga puede usar el bloque entero, pero 4 conversaciones largas a la vez se lo disputan. Con -np pones otro número de huecos, y entonces el bloque se reparte a partes iguales entre ellos salvo que añadas --kv-unified.

Ollama atiende 1 petición por modelo cada vez: OLLAMA_NUM_PARALLEL vale 1 de fábrica, y las demás esperan en una cola de hasta 512. Para una persona charlando, es justo lo que quieres. Puedes subirlo, y aquí el código enseña el precio: Ollama le pide a su llama-server interno un contexto del tamaño elegido multiplicado por el número de peticiones en paralelo. Ponlo en 4 con un contexto de 4.096 tokens y reservará memoria para 16.384.

¿Cuándo importa? Con un complemento del editor que lanza autocompletados mientras chateas, un script que manda preguntas en paralelo o 2 personas de casa usando el mismo modelo. Con una sola persona escribiendo una pregunta cada vez, los 4 huecos están casi siempre vacíos y los dos se portan igual. ¿Y cuánto más rápido va llama.cpp con 4 peticiones en marcha? No lo hemos medido: depende de la tarjeta, del modelo y de cuántas peticiones lleguen juntas.

Contexto: el máximo del modelo, o 4.096 tokens

Este es el ajuste de fábrica que más cambia lo que notas al usarlos, y aquí cada uno tira por un lado.

llama.cpp empieza por arriba. Su tamaño de contexto, -c, vale 0 de fábrica, que significa el contexto más largo con el que se entrenó el modelo. Luego un mecanismo llamado --fit, activado de fábrica, ajusta todo lo que no hayas fijado tú: encoge el contexto hasta un suelo de 4.096 tokens y después pasa capas de la tarjeta gráfica a la memoria del sistema, intentando dejar 1.024 MiB libres en cada dispositivo. Te queda el contexto más largo que aguanta tu máquina, a veces con parte del modelo en el procesador, que va más lento.

Ollama empieza por abajo, y decide según la memoria gráfica que encuentra al arrancar: con menos de 23 GiB en total, 4.096 tokens; desde 23 GiB, 32.768; desde 47 GiB, 262.144. En una tarjeta de 8 o 12 GB eso son 4.096 tokens para cualquier modelo, aunque se haya entrenado para 262.144, salvo que pongas otro número tú o lo traiga el Modelfile del modelo. Un documento largo se corta entonces sin avisar, y el modelo contesta sobre el trozo que ha visto. OLLAMA_CONTEXT_LENGTH cambia el valor para todos los modelos; num_ctx, para uno o para una petición.

La memoria también se porta distinto cuando termina la respuesta. Ollama descarga el modelo tras 5 minutos sin peticiones y devuelve la memoria, una maravilla en un portátil que además mueve un navegador y algún juego. llama-server mantiene el modelo cargado hasta que lo paras; --sleep-idle-seconds lo pone a dormir pasado un rato si prefieres los modales de Ollama.

Instalarlos, y la primera respuesta

Ollama son 2 pasos: el instalador en macOS o Windows, o un script de una línea en Linux, y luego ollama run con el nombre de un modelo. Descarga el modelo de su propia biblioteca y abre un chat en la terminal; en macOS y Windows tienes además una aplicación de escritorio con su ventana de chat. Este vídeo, en español, va de la instalación al primer modelo; se grabó con una versión anterior, así que donde no coincida, manda esta página.

llama.cpp te pide antes una elección: qué compilación. La vía tranquila es brew install llama.cpp, que en Mac y Linux instala la estable v0.7.0 desde el 16 de octubre de 2026. La página de publicaciones de GitHub ofrece 36 ficheros por compilación, según sistema y tarjeta gráfica, y coges el que encaja con la tuya (con NVIDIA, más su fichero cudart); winget en Windows y el script de instalación del proyecto te dan, en cambio, una compilación diaria. Después, 1 comando:

llama serve -hf ggml-org/Qwen3.5-0.8B-GGUF -c 8192

Descarga el modelo de Hugging Face, con la compresión Q4_K_M si no indicas otra, y abre el servidor y una página de chat en http://127.0.0.1:9931. Nuestra guía para instalar llama.cpp repasa compilaciones y opciones, y la guía para instalar Ollama hace lo mismo con Ollama.

Si prefieres verlos lado a lado antes de elegir, este vídeo hace justo eso. Se grabó con otras versiones: donde no coincida con esta página, manda la página (v0.7.0 y 0.40.10).

De dónde salen los modelos es una diferencia de verdad. Los dos leen GGUF, el formato que creó llama.cpp. llama.cpp carga cualquier fichero GGUF que le des, de cualquier carpeta, y -hf descarga de Hugging Face a la caché estándar de Hugging Face, compartida con otros programas que la usan, así que nada se baja dos veces. Un modelo en safetensors hay que convertirlo antes con el script convert_hf_to_gguf.py del repositorio. Ollama descarga de su propia biblioteca con ollama pull, en su empaquetado por capas dentro de ~/.ollama/models; para usar un fichero tuyo, escribes un Modelfile que apunte a un GGUF o a una carpeta de safetensors y ejecutas ollama create.

En hardware, la lista más larga es la de llama.cpp: compilaciones listas para el procesador solo, NVIDIA con CUDA, AMD con ROCm o Vulkan, Intel con SYCL u OpenVINO, Apple Silicon con Metal y hasta móviles Android. Ollama cubre Windows 10 22H2 o posterior, macOS 14 o posterior y Linux, tarjetas NVIDIA desde la capacidad de cómputo 5.0, AMD con ROCm v7 y Vulkan, activado de fábrica en Windows y Linux. En un Mac con Intel, los dos funcionan solo con el procesador.

Una ventana, una página de chat o solo la terminal

llama-server trae su propia página de chat, activada de fábrica, en la misma dirección que la API. Abres http://127.0.0.1:9931 y ahí está: tus conversaciones y, desde la v0.7.0, un gestor de modelos. Los chats se guardan en el almacenamiento de tu navegador, no en una carpeta del disco: si borras los datos del sitio, desaparecen, y no te siguen a otro navegador. --no-ui apaga la página si solo quieres la API.

La ventana de Ollama es su aplicación de escritorio en macOS y Windows, que guarda tus chats en una pequeña base de datos dentro de tu carpeta de usuario. En Linux, Ollama es un servicio en segundo plano y una terminal; delante de su API pones la interfaz de chat que prefieras. Detalle curioso: el llama-server que corre dentro de Ollama tiene esa misma página de chat, y Ollama la apaga a propósito.

Qué puertas quedan abiertas: 127.0.0.1:9931 frente a 127.0.0.1:11434

Primero la buena noticia: de fábrica, los dos escuchan solo en tu propia máquina. llama.cpp v0.7.0 espera en 127.0.0.1:9931; hasta la v0.6.0 era el 8080, y las imágenes Docker del proyecto siguen usando el 8080 dentro del contenedor. Ollama espera en 127.0.0.1:11434. Nadie de tu wifi llega a ninguno de los dos hasta que lo abras a propósito: --host 0.0.0.0 en llama.cpp y OLLAMA_HOST=0.0.0.0 en Ollama.

La diferencia está en lo que pasa dentro de tu navegador. El CORS decide qué páginas web pueden usar un servidor local desde el navegador, y aquí el más estricto es Ollama. llama.cpp, de fábrica, refleja cualquier origen y permite credenciales, así que una página web que visites puede mandar peticiones a tu llama-server y leer las respuestas mientras esté arrancado; el propio servidor lo avisa al arrancar con security: no API key is set and CORS allows all origins. Ollama solo acepta páginas servidas desde localhost, 127.0.0.1 y 0.0.0.0 en cualquier puerto, más unos pocos esquemas de aplicación, y responde 403 a cualquier otro origen.

En claves, el que las tiene es llama.cpp. --api-key, o la variable LLAMA_API_KEY, obliga a los clientes a mandar una clave, y --api-key-file lee varias de un fichero. El servidor local de Ollama no tiene clave que comprobar: sus defensas son escuchar solo en tu máquina, su lista corta de CORS y una comprobación de la cabecera Host de cada petición. Una trampa en el lado de llama.cpp: la clave no cambia el CORS. En nuestra prueba de la guía de instalación, el origen se seguía devolviendo con la clave puesta; lo que lo cierra es --cors-origins localhost.

Qué envía cada uno por su cuenta

Aquí llama.cpp gana sin discusión. Buscamos en el código de su motor, su servidor, su chat de terminal y su página de chat librerías de analítica, telemetría y seguimiento, y no hay ninguna; la v0.7.0 no añade ninguna llamada nueva. No comprueba actualizaciones ni tiene cuentas. Solo sale a internet cuando se lo pides: descargas de modelos, de Hugging Face con -hf o llama download y de cualquier dirección con --model-url; modelos empaquetados como imagen de contenedor con --docker-repo; y llama update, que solo funciona en instalaciones hechas con el script del proyecto. Con los modelos ya en el disco, --offline le prohíbe la red del todo.

Ollama tampoco tiene ninguna librería de analítica en su código. Con solo ollama serve, como en Linux, hace por su cuenta 2 tipos de llamada a ollama.com: un catálogo de modelos recomendados cada 4 horas y las fichas de sus modelos en la nube al arrancar el servidor. OLLAMA_NO_CLOUD=1 apaga las dos. Con la aplicación de escritorio en macOS o Windows se suman 2 tipos más: una comprobación de actualizaciones cada hora, que ningún ajuste detiene, y una consulta de la cuenta al abrir la aplicación.

Así que la configuración más callada es llama.cpp con --offline, y después ollama serve sin la aplicación y con OLLAMA_NO_CLOUD=1. Cada destino, con su fuente y su fecha, está en nuestra ficha de llama.cpp y en la ficha de Ollama.

Cuál instalaríamos, según tu caso

• Tu primera vez con IA local, en cualquier ordenador: Ollama. Un comando, un modelo que se carga y se descarga solo y un CORS estrecho desde el principio.
• Un Mac o un portátil con Windows, y quieres ventana: la aplicación de escritorio de Ollama. La página de chat de llama.cpp está bien, pero vive en el navegador.
• Quieres contextos largos sin pelearte: llama.cpp, que parte del máximo del modelo; u Ollama con OLLAMA_CONTEXT_LENGTH puesto a mano.
• Un complemento del editor, scripts o 2 personas con un modelo: llama.cpp, con sus 4 huecos, --cors-origins localhost y una clave.
• No puede salir nada de la máquina: llama.cpp con --offline.
• Un modelo que salió ayer: una compilación diaria de llama.cpp, que recibe las familias nuevas antes que el canal estable y antes que Ollama.
• Una estantería de ficheros GGUF en una carpeta: llama.cpp los lee tal cual; Ollama necesita un Modelfile por modelo.

Si algo falla por el camino, tenemos una guía para cuando llama.cpp no funciona y otra para cuando Ollama no funciona. ¿Dudas entre una aplicación de escritorio o un servidor para mucha gente? Nuestras comparativas LM Studio vs Ollama y vLLM vs Ollama cubren esos casos, y el buscador de modelos te dice qué modelos caben en tu máquina.