Ejecutar un LLM en local sobre hardware que ya tienes te da tres cosas que una API hospedada no ofrece: sin coste por token, sin datos que salen de la máquina y sin límite de tasa. El intercambio es un presupuesto de memoria que hay que planificar en lugar de una factura que se puede ignorar.

Los lanzamientos recientes de pesos abiertos han llevado esto de hobby a opción por defecto para trabajo sensible a la privacidad. Kolibri, de Aleph Alpha, es un modelo de mezcla de expertos inglés-alemán publicado bajo Apache 2.0 (Aleph Alpha), y ds4, de antirez, apunta a DeepSeek V4 Flash sobre Metal, CUDA y ROCm (ds4). Los runtimes de abajo son la capa que sostiene a ambos.

01Elige un runtime antes que un modelo

Hay tres niveles de control, y la elección correcta depende de si optimizas comodidad o rendimiento.

Los tres ejecutan archivos GGUF, así que un modelo descargado para uno no se desperdicia en otro.

02Calcula la memoria antes de descargar

Este es el paso que la gente se salta, y la razón de que una descarga termine y luego no cargue. Importan dos costes.

Los pesos escalan con el número de parámetros y la profundidad de bits, porque la cuantización guarda menos bits por peso. Cuatro bits son medio byte, así que mil millones de parámetros ocupan unos 0,5 GB más el sobrecoste: cuenta 0,6 GB. Ocho bits duplican eso, unos 1,1 GB.

La caché KV escala con la longitud de contexto, el tamaño de lote, el número de capas y la dimensión de cabeza, y no es gratis. En un modelo de 7B, pasar de un contexto de 4K a 32K puede añadir varios gigabytes.

Los pesos son el suelo, no el total

Un modelo que cabe con el contexto vacío puede quedarse sin memoria al subir la ventana de contexto. Decide primero el contexto que necesitas y luego elige el cuantizado que deje sitio para él.

03Ejecuta un modelo con Ollama

Ollama es el camino más corto de la nada a un endpoint funcional. Descarga un modelo cuantizado, lo cachea y arranca un demonio que habla HTTP.

1. Instala y arranca el demonio. El instalador oficial cubre macOS, Windows y Linux; el demonio escucha en el puerto 11434 en cuanto está en marcha.
2. Descarga y ejecuta un modelo. La etiqueta selecciona tamaño y cuantización; omitirla suele elegir un valor por defecto.

ollama pull gemma4
ollama run gemma4

El ejemplo descarga gemma4, la versión actual de Gemma en la biblioteca de Ollama. La etiqueta selecciona tamaño y cuantización; omitirla suele elegir un valor por defecto.

1. Llama a la API directamente. Ollama sirve un endpoint compatible con OpenAI en 11434, así que los clientes existentes funcionan cambiando la URL base.

curl http://localhost:11434/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemma4",
    "messages": [{ "role": "user", "content": "Summarize this changelog in one line." }]
  }'

1. Comprueba qué está cargado y a qué velocidad. Ollama informa el modelo, el tamaño de contexto y los tokens por segundo, que es el número a vigilar al ajustar.

04Ejecuta el mismo modelo con llama.cpp

llama.cpp es donde controlas explícitamente la descarga a GPU y el contexto. Compílalo una vez y sirve cualquier archivo GGUF.

cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release -j

Sirve un modelo con la mayoría de capas en la GPU. -ngl 99 descarga todas las capas que puede, -c fija el tamaño de contexto y --port expone un servidor compatible con OpenAI.

./build/bin/llama-server \
  -m ./models/qwen3-8b-q4_k_m.gguf \
  -c 8192 \
  -ngl 99 \
  --host 127.0.0.1 --port 8080

curl http://127.0.0.1:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model": "local", "messages": [{"role": "user", "content": "Hello"}]}'

-ngl es el flag más útil. Si el modelo no cabe, bajarlo mueve capas a la RAM del sistema: seguirá funcionando, pero mucho más lento, porque cada token cruza el bus PCIe.

05Ajusta los tres valores que deciden el rendimiento

La cuantización fija el techo de calidad (llama.cpp quantize). Q4_K_M es el equilibrio estándar, Q5_K_M conserva más calidad por un aumento moderado de tamaño y Q8_0 se acerca al original con el doble de peso. Baja solo cuando no quepa nada mayor.

El contexto es el valor con más probabilidad de pasarse de memoria en silencio. Empieza por la longitud que de verdad necesitas para la tarea, no por el máximo anunciado del modelo, y súbela paso a paso vigilando la memoria.

La descarga a GPU decide si la inferencia es rápida o solo posible. Descarga tantas capas como quepan en VRAM y reserva un poco de margen para la caché KV y el sistema operativo.

Un cuantizado que cabe por pesos puede fallar por contexto

Si el servidor se cae tras cargar el modelo, o se arrastra a mitad de conversación, baja -ngl o reduce -c. Las conversaciones largas hacen crecer la caché hasta que la máquina empieza a hacer swap.

06Errores comunes y soluciones

El flujo que funciona: calcula la memoria, elige el cuantizado más pequeño que cumpla tu nivel de calidad, sírvelo con un endpoint compatible con OpenAI y apunta tus herramientas a localhost. Cuando ese endpoint sea estable, podrás entregárselo a un agente de código o a una herramienta interna sin enviar un solo token fuera de la máquina.

07Fuentes

• Aleph Alpha — Kolibri Has Landed: A Sovereign Open-Weight Model (fecha de consulta: 2026-10-09)
• antirez/ds4 (DwarfStar) — hardware soportado y lista de modelos (fecha de consulta: 2026-10-09)
• llama.cpp — herramienta quantize: qué cambia la cuantización (fecha de consulta: 2026-10-09)
• Ollama — instrucciones de instalación para macOS, Windows y Linux (fecha de consulta: 2026-10-09)
• Biblioteca de Ollama — gemma4 (fecha de consulta: 2026-10-09)
• Ollama — compatibilidad con OpenAI, URL base http://localhost:11434/v1/ (fecha de consulta: 2026-10-09)
• llama.cpp — instrucciones de compilación (fecha de consulta: 2026-10-09)
• llama.cpp — README del servidor: -ngl, -c, --host, --port y las rutas compatibles con OpenAI (fecha de consulta: 2026-10-09)