Cómo Ejecutar GLM-5 Localmente Gratis

Quieres acceso a uno de los modelos abiertos más capaces de 2026—GLM-5 de Z.ai—sin pagar un solo céntimo por las llamadas a la API o la computación en la nube. Ingenieros y desarrolladores logran esto hoy ejecutando GLM-5 localmente en hardware de consumo y prosumidor. La cuantificación agresiva de Unsloth reduce el modelo Mixture-of-Experts de 744B parámetros (40B activos) de 1.65TB a solo 241GB, y puedes desplegarlo a través de llama.cpp, Ollama o vLLM.

¡Estás ejecutando GLM-5 localmente! El proceso exige atención al hardware, pasos de construcción precisos y estrategias inteligentes de descarga. Esta guía te lleva a través de cada método, explica por qué cada comando es importante y te muestra cómo exprimir el máximo rendimiento de tu configuración. Obtendrás total soberanía de datos, latencia cero para flujos de trabajo de agentes y inferencia ilimitada.

¿Qué hace de GLM-5 un cambio de juego para el despliegue local?

Z.ai lanzó GLM-5 como el sucesor de GLM-4.7. El modelo escala a 744B parámetros totales con 40B activos por token, entrenado con 28.5T tokens. Ofrece resultados de vanguardia en benchmarks de agentes: 77.8% en SWE-bench Verified, 89.7% en τ²-Bench, y 61.1% en Terminal-Bench 2.0 con herramientas.

Te beneficias de una ventana de contexto de 200K gracias a DeepSeek Sparse Attention. El modelo destaca en el razonamiento de largo alcance, la llamada a herramientas en múltiples turnos y la generación de código complejo. Además, la licencia MIT abierta te permite ejecutarlo, modificarlo e incluso comercializarlo sin restricciones.

Sin embargo, el modelo original requiere 1.65TB de almacenamiento y una VRAM masiva. Unsloth cambió el juego al lanzar las cuantificaciones GGUF Dynamic 2.0—UD-IQ2_XXS con 241GB (-85%) y 1-bit con 176GB (-89%). Estas versiones preservan la calidad del razonamiento mediante el upcasting inteligente de capas, mientras que se ajustan a un Mac con 256GB de memoria unificada o una sola GPU de 24GB emparejada con 256GB de RAM del sistema.

Ejecutas GLM-5 localmente con estas cuantificaciones porque equilibran tamaño, velocidad y capacidad. Los benchmarks muestran una degradación mínima en tareas de codificación y de agentes en comparación con la precisión completa.

¿Por qué ejecutar GLM-5 localmente en lugar de usar APIs en la nube?

Eliminas los costos recurrentes. Los proveedores de la nube cobran por token, y las capacidades de GLM-5 hacen que un uso intensivo sea caro rápidamente. La inferencia local no cuesta nada más allá de la electricidad.

Proteges datos sensibles. Empresas e investigadores mantienen código propietario, registros médicos o consultas de clientes completamente offline.

Logras una menor latencia. Los modelos locales responden en milisegundos para chat y bucles de llamada a herramientas. Encadenas agentes sin saltos de red.

Personalizas libremente. Ajustas con Unsloth, creas Modelfiles en Ollama o construyes herramientas personalizadas en vLLM.

Además, experimentas sin límites de tasa. Pruebas contextos de 200K, ejecutas conversaciones de 1000 turnos o evalúas la precisión de la llamada a herramientas durante la noche.

Requisitos de Hardware: Lo que realmente necesitas

Ajusta tu configuración al nivel de cuantificación.

• UD-IQ2_XXS de 2 bits (241 GB): Se ejecuta en Apple serie M con 256 GB de memoria unificada o GPU NVIDIA de 24 GB + 256 GB de RAM con descarga de MoE.
• 1 bit (176 GB): Cabe en 180 GB de RAM.
• FP8 (vLLM): Demanda 8×H200 o equivalente—más de 800 GB de VRAM total.
• Mínimo viable: 64 GB de RAM + CPU moderna para contextos muy pequeños; 128 GB+ recomendado para trabajo práctico.

Monitorea el uso con nvidia-smi en Linux o el Monitor de Actividad en macOS. El almacenamiento SSD acelera la descarga. Asigna al menos 50GB libres para los archivos del modelo y la caché.

Método 1: Ejecutar GLM-5 localmente con Unsloth GGUF en llama.cpp (el más accesible)

Elige esta ruta para obtener la máxima flexibilidad y eficiencia en hardware mixto.

Paso 1: Construir llama.cpp con soporte para GLM-5

Necesitas la última versión de llama.cpp con la PR 19460 fusionada.

apt-get update && apt-get install -y build-essential cmake curl libcurl4-openssl-dev pciutils
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
git fetch origin pull/19460/head:MASTER
git checkout MASTER
mkdir build && cd build
cmake .. -DGGML_CUDA=ON  # Use -DGGML_CUDA=OFF for CPU-only
cmake --build . --config Release -j
cd ..
cp build/bin/llama-* .

Ejecuta esto una vez. La construcción tarda entre 10 y 20 minutos dependiendo de tu máquina.

Paso 2: Descargar el modelo cuantificado

Usa huggingface_hub para transferencias rápidas.

pip install -U huggingface_hub hf_transfer
export HF_HUB_ENABLE_HF_TRANSFER=1
hf download unsloth/GLM-5-GGUF --local-dir GLM-5-GGUF --include "*UD-IQ2_XXS*"

Ahora tienes el modelo de 241GB dividido en fragmentos.

Paso 3: Iniciar la inferencia

Inicia la CLI para uso interactivo.

export LLAMA_CACHE="GLM-5-GGUF"
./llama-cli \
  -hf unsloth/GLM-5-GGUF:UD-IQ2_XXS \
  --jinja \
  --ctx-size 32768 \
  --flash-attn on \
  --temp 0.7 \
  --top-p 1.0 \
  --fit on

Añade --threads 32 para configuraciones que usan mucha CPU o -ot ".ffn_.*_exps.=CPU" para descargar expertos de MoE.

Paso 4: Servir como API de OpenAI

Expón el modelo para aplicaciones.

./llama-server \
  --model GLM-5-GGUF/UD-IQ2_XXS/GLM-5-UD-IQ2_XXS-00001-of-00006.gguf \
  --alias "glm-5" \
  --fit on \
  --ctx-size 32768 \
  --port 8000 \
  --jinja

Ahora apunta cualquier cliente de OpenAI a http://localhost:8000/v1.

Con esta configuración, logras de 3 a 8 tokens/segundo en una GPU de 24 GB. Escalas el contexto a 128K sin fallar cuando usas --fit on.

Método 2: Ejecutar GLM-5 localmente con Ollama (el más fácil para principiantes)

Prefieres la simplicidad. Ollama gestiona las descargas, la cuantificación y el servicio automáticamente.

Instalación

Descarga desde ollama.com y ejecuta el instalador. En Linux:

curl -fsSL https://ollama.com/install.sh | sh
ollama serve

Descargar y ejecutar GLM-5

Usa la etiqueta optimizada por la comunidad.

ollama pull glm-5:cloud
ollama run glm-5:cloud

Interactúas directamente en la terminal o a través de la API en http://localhost:11434/v1.

Crear un Modelfile personalizado

Personalizas el prompt del sistema y los parámetros.

FROM glm-5:cloud
SYSTEM You are an expert software architect with deep knowledge of distributed systems.
PARAMETER temperature 0.6
PARAMETER num_ctx 131072

Construyes y ejecutas:

ollama create my-glm5 -f Modelfile
ollama run my-glm5

Integras con Claude Code, Cursor o Continue.dev configurando el endpoint de Ollama. Obtienes una alternativa local pulida a los agentes de codificación en la nube.

Método 3: Despliegue avanzado con vLLM (Máximo rendimiento)

Necesitas el mayor rendimiento para agentes de producción.

Instalas la versión nocturna:

uv pip install --upgrade vllm --extra-index-url https://wheels.vllm.ai/nightly/cu130

Lanzas el servidor (la versión FP8 requiere 8×H200):

vllm serve unsloth/GLM-5-FP8 \
  --served-model-name glm-5 \
  --tensor-parallel-size 8 \
  --kv-cache-dtype fp8 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --max-model-len 200000 \
  --gpu-memory-utilization 0.93

Habilitas la decodificación especulativa y la llamada a herramientas. Sirves miles de solicitudes por minuto en un clúster multi-GPU.

Prueba y depura tu GLM-5 local con Apidog

Conecta Apidog a tu endpoint y verifica que todo funciona.

Crea un nuevo proyecto, establece la URL base en http://localhost:8000/v1 (o 11434 para Ollama) y define el endpoint /chat/completions.

Construye solicitudes visualmente:

• Modelo: glm-5
• Mensajes: sistema + usuario
• Temperatura: 0.7
• Herramientas: define esquemas JSON para la llamada a funciones

Envías solicitudes, inspeccionas las respuestas de streaming y guardas colecciones para pruebas de regresión. Generas SDKs de Python o JavaScript al instante. Simulas respuestas para equipos de frontend.

Apidog convierte tu GLM-5 local en una plataforma de desarrollo de primera clase. Iteras sobre agentes, validas las salidas de las herramientas y mides la latencia, todo sin salir de la interfaz.

Técnicas de Optimización del Rendimiento

Exprime más velocidad de tu hardware.

• Habilitas flash attention y --fit on en llama.cpp.
• Descargas solo expertos de MoE a la CPU cuando la VRAM es limitada.
• Usas 4 bits para chat y 2 bits para codificación de agentes.
• Estableces --prio 3 en el servidor para una mayor prioridad de proceso.
• Monitoreas con nvtop o htop y ajustas --n-gpu-layers.

Logras de 15 a 25 tokens/segundo en una configuración de doble RTX 4090 con estos ajustes.

Problemas comunes y cómo solucionarlos

Encuentras errores de memoria. Reduces el contexto a 16K o descargas más capas.

Observas una mala llamada a herramientas. Estableces la temperatura en 1.0 y top-p en 0.95, luego usas el flag --tool-call-parser glm47.

Experimentas descargas lentas. Habilitas hf_transfer y usas un espejo rápido.

Te quedas sin memoria CUDA. Añades --gpu-memory-utilization 0.85 y cierras los procesos en segundo plano.

Siempre revisa la documentación de Unsloth y el repositorio GGUF de GLM-5 para los últimos fragmentos.

El camino a seguir: GLM-5 local y más allá

Eres testigo del cambio hacia la IA soberana. Modelos como GLM-5 demuestran que la capacidad de frontera se ejecuta en hardware que ya posees. Lo combinas con bases de datos vectoriales locales, servidores de herramientas y frameworks de agentes para construir sistemas privados de alto rendimiento.

Te unes a la comunidad en Hugging Face, r/LocalLLaMA de Reddit y el Discord de Unsloth. Compartes Modelfiles, resultados de benchmarks y cuantificaciones personalizadas.

Ejecuta GLM-5 localmente hoy. Controlas la computación, los datos y el futuro de tu pila de IA.

Empieza con el GGUF de 2 bits en llama.cpp. Descarga Apidog. Pon en marcha el servidor. Te sorprenderá lo que puedes construir cuando el modelo reside en tu máquina.

La era de los modelos de frontera verdaderamente locales ha llegado. Aprovéchala al máximo.