Cómo correr modelos GGUF en local: Ollama, llama.cpp y vLLM

¿Bajaste un archivo .gguf y te preguntas cómo ejecutarlo de verdad? La ruta más corta: ollama run hf.co/<repo>:Q4_K_M — Ollama descarga el GGUF directo de Hugging Face y lo sirve. GGUF es el formato de modelo en un solo archivo que introdujo llama.cpp y que hoy habla toda herramienta de LLM locales, así que el mismo archivo corre en Ollama, llama.cpp, LM Studio, Jan y (con matices) vLLM. Esta guía cubre cada runner con comandos listos para pegar, cómo elegir la cuantización correcta para tu VRAM y los errores de carga que te vas a topar de verdad. Y si te preguntas can vLLM run GGUF — sí, mediante un plugin externo, solo GPU.

¿Qué es un archivo GGUF?

GGUF (GGML Universal File) es un formato contenedor para modelos de lenguaje cuantizados. Un solo archivo guarda los pesos, el tokenizador y los metadatos del modelo — nada más que descargar, nada de sopa de configs. Los pesos de adentro están cuantizados: comprimidos de flotantes de 16 bits a enteros de 4 bits (o menos), que es la razón por la que un modelo 9B que necesita ~18 GB en precisión completa cabe en ~5.5 GB como archivo Q4 y corre en una GPU de videojuegos o incluso en una CPU.

Dos cosas importan en el nombre de un archivo GGUF:

1. El modelo base — gemma-3-4b-it-GGUF es un Gemma 3 4B afinado y exportado a GGUF.
2. El tag de quant — Q4_K_M, Q8_0, IQ4_XS y compañía dicen cuán agresivamente se comprimieron los pesos. Más abajo, cómo elegir uno.

¿Puede Ollama correr modelos GGUF?

Sí — GGUF es el formato nativo de Ollama, y desde 2024 puede bajar uno directo de Hugging Face sin que toques un solo archivo:

# Baja un quant GGUF directo de Hugging Face y conversa con él
ollama run hf.co/bartowski/gemma-2-9b-it-GGUF:Q4_K_M

# El tag de quant tras los dos puntos elige el archivo dentro del repo
ollama run hf.co/ggml-org/gemma-3-4b-it-GGUF:Q8_0

¿Ya bajaste un .gguf por tu cuenta? Apunta un Modelfile hacia él:

# Modelfile — una línea basta
FROM ./gemma-2-9b-it-Q4_K_M.gguf

ollama create gemma9b -f Modelfile
ollama run gemma9b

Ollama decide el offload a GPU automáticamente y expone una API compatible con OpenAI en el puerto 11434, así que cualquier herramienta que hable esa API puede usar el modelo. El precio es el control: no eliges cuántas capas van a la GPU.

¿Cómo corres un archivo GGUF en llama.cpp?

llama.cpp es donde nace GGUF — el formato existe para él — así que el soporte es el más profundo y el más fresco. El binario llama-server te da a la vez una UI de chat y un endpoint compatible con OpenAI:

# Descarga directo de Hugging Face (elige un GGUF adecuado para tu máquina)
llama-server -hf ggml-org/gemma-3-4b-it-GGUF --port 8080

# O corre un archivo que ya tengas, con offload completo a GPU
llama-server -m ./gemma-2-9b-it-Q4_K_M.gguf -ngl 99 --port 8080

-ngl 99 empuja 99 capas a la GPU; ponlo por debajo de lo que tu VRAM permita y el resto se queda en CPU. Ese dial de offload parcial es el superpoder de llama.cpp — un modelo 9B corre bien en una tarjeta de 6 GB con 20 de 48 capas descargadas, solo que más lento. Para prompting de una sola vez en vez de un servidor, cambia llama-server por llama-cli con el mismo flag -m.

LM Studio es el mismo motor detrás de una GUI de escritorio: suelta un .gguf en su carpeta de modelos (o busca en Hugging Face desde la app) y dale a cargar. Para la elección de la herramienta en sí, la comparación Ollama vs LM Studio cubre cuál ponerle debajo a tus modelos.

¿Qué cuantización GGUF deberías descargar?

Respuesta por defecto: Q4_K_M. Es el punto dulce de la comunidad — a un uno o dos por ciento de la calidad de precisión completa con cerca de un cuarto del tamaño. La escalera, de mayor a menor:

• Q8_0 — casi sin pérdida; úsalo si tu VRAM se come 8.5 bits por peso sin enterarse.
• Q6_K / Q5_K_M — un escalón abajo en tamaño, sigue siendo excelente para modelos de 30B+.
• Q4_K_M — el default. Para modelos de 7–14B es donde la calidad por GB llega a su pico.
• IQ4_XS / Q3_K_M — para meter un modelo grande en una tarjeta pequeña; la pérdida de calidad ya se nota.
• Q2_K y abajo — último recurso; el modelo empieza a degradarse en disparates a media frase.

La regla de dedo para saber si cabe: tamaño del archivo en GB más ~1–2 GB de overhead de contexto debe caber en tu VRAM. Un Q4_K_M de 4.7 GB de un modelo 9B va cómodo en una tarjeta de 8 GB. Prefiere un modelo más pequeño a un quant más alto antes que un modelo más grande a un quant terrible — un Q8 de 4B suele ganarle a un Q2 de 9B.

GGUF vs Safetensors: ¿qué formato necesitas?

Safetensors es el formato de archivo sin cuantizar — pesos de precisión completa para entrenamiento, fine-tuning y herramientas como transformers y ComfyUI. GGUF es el formato cuantizado y ejecutable para inferencia en tu propio hardware. No puedes hacer fine-tuning de un GGUF, y no puedes correr un archivo safetensors en Ollama o llama.cpp sin convertirlo antes (para eso existe el script convert_hf_to_gguf.py de llama.cpp). Regla: entrenamiento o pipelines de imagen → safetensors; chat local y servido → GGUF. Si tu búsqueda empezó como «gguf vs safetensors», esa división es toda la respuesta.

¿Qué runner de GGUF deberías usar?

Runner	Ideal para	Instalación	Offload a GPU	API compatible con OpenAI
Ollama	Servicio de configurar y olvidar	one-liner con curl	Automático	Sí (:11434/v1)
llama.cpp	Control máximo, funciones más nuevas	Compilar o gestor de paquetes	Dial manual con -ngl	Sí (llama-server)
LM Studio	GUI de escritorio, explorar modelos	Descarga de la app	Automático	Sí (servidor local)
vLLM	Servido multiusuario por lotes	pip install vllm	Automático	Sí (nativo)

Elige Ollama si lo quieres corriendo al arranque y fuera de la vista — es lo que uso en mi homelab para servir modelos a todo lo que hay en la red. Elige llama.cpp cuando necesitas una función el día que sale (las arquitecturas nuevas aterrizan ahí primero) o quieres control de memoria por capa. Elige LM Studio para una GUI. Elige vLLM solo cuando un modelo debe atender a muchos usuarios concurrentes — su soporte de GGUF funciona, pero es de segunda clase junto a sus formatos nativos.

¿Por qué no carga mi modelo GGUF?

Los cuatro errores que cubren la mayoría de los casos:

1. unknown model architecture — el GGUF usa una arquitectura que tu runtime no conoce (los MoE y los modelos de visión nuevos aterrizan sin parar). Actualiza Ollama o recompila llama.cpp; no existe otro arreglo.
2. Sin memoria al cargar — el quant es demasiado grande para tu VRAM más el contexto. Baja un escalón (Q4_K_M → Q3_K_M), reduce -ngl o achica el contexto con -c 4096.
3. Descarga truncada / corrupta — la carga del GGUF falla con un error de número mágico o de metadatos. Vuelve a descargar y compara el SHA256 que muestra la página de Hugging Face.
4. ollama run ./model.gguf se niega — esperado: el run de Ollama acepta nombres de modelos, no rutas de archivo. Usa la vía del Modelfile de arriba.

Un último ángulo que vale conocer: un endpoint GGUF local hace muy buena pareja con las herramientas de código agéntico — apunta un cliente compatible con OpenAI hacia él y las completaciones cuestan solo luz. Los mejores LLM locales para programar probaron qué modelos merecen ese puesto una vez que la fontanería de esta guía funciona.

Cuando llegue la pregunta del runtime, lee llama.cpp vs Ollama — su historial público diseccionado, y los compromisos no son los que sugieren los README.

Y si tu camino pasa por el modo GGUF de vLLM, can vLLM run GGUF cubre la realidad de solo-GPU y los flags exactos de servicio.