# GLM-5

GLM-5, lanzado en febrero de 2026 por Zhipu AI (Z.AI), es un **modelo de lenguaje de mezcla de expertos (Mixture-of-Experts) de 744 mil millones de parámetros** que activa solo 40B parámetros por token. Logra un rendimiento de código abierto de primera clase en razonamiento, programación y tareas agentivas — obteniendo 77.8% en SWE-bench Verified y rivalizando con modelos de frontera como Claude Opus 4.5 y GPT-5.2. El modelo está disponible bajo el **Licencia MIT** en HuggingFace.

## Características clave

* **744B total / 40B activos** — MoE de 256 expertos con enrutamiento altamente eficiente
* **Rendimiento de vanguardia en programación** — 77.8% SWE-bench Verified, 73.3% SWE-bench Multilingual
* **Razonamiento profundo** — 92.7% en AIME 2026, 96.9% en HMMT Nov 2025, modo de pensamiento incorporado
* **Capacidades agente** — llamadas a herramientas nativas, ejecución de funciones y planificación de tareas a largo plazo
* **Ventana de contexto de 200K+** — maneja bases de código masivas y documentos extensos
* **Licencia MIT** — pesos totalmente abiertos, uso comercial permitido

## Requisitos

Autoalojar GLM-5 es una empresa seria — el checkpoint FP8 requiere **\~860GB de VRAM**.

| Componente | Mínimo (FP8) | Recomendado   |
| ---------- | ------------ | ------------- |
| GPU        | 8× H100 80GB | 8× H200 141GB |
| VRAM       | 640GB        | 1.128GB       |
| RAM        | 256GB        | 512GB         |
| Disco      | 1.5TB NVMe   | 2TB NVMe      |
| CUDA       | 12.0+        | 12.4+         |

**recomendación de Clore.ai**: Para la mayoría de los usuarios, **acceder a GLM-5 vía API** (Z.AI, OpenRouter). Autoalojar solo tiene sentido si puedes alquilar 8× H100/H200 (\~$24–48/día en Clore.ai).

## Acceso por API (recomendado para la mayoría de los usuarios)

La forma más práctica de usar GLM-5 desde una máquina Clore.ai o desde cualquier lugar:

### Vía la plataforma de Z.AI

```python
from openai import OpenAI

client = OpenAI(
    api_key="tu-clave-zai",
    base_url="https://api.z.ai/v1"
)

response = client.chat.completions.create(
    model="glm-5",
    messages=[
        {"role": "system", "content": "Eres un asistente útil."},
        {"role": "user", "content": "Escribe un scraper web asíncrono en Python usando aiohttp y BeautifulSoup"}
    ],
    temperature=1.0,
    max_tokens=4096
)
print(response.choices[0].message.content)
```

### Vía OpenRouter

```python
from openai import OpenAI

client = OpenAI(
    api_key="tu-clave-openrouter",
    base_url="https://openrouter.ai/api/v1"
)

response = client.chat.completions.create(
    model="zai-org/glm-5",
    messages=[
        {"role": "user", "content": "Explica la arquitectura MoE usada en GLM-5"}
    ],
    max_tokens=2048
)
print(response.choices[0].message.content)
```

## Configuración de vLLM (autoalojamiento)

Para quienes tienen acceso a máquinas multi-GPU de alta gama en Clore.ai:

```bash
# Instalar vLLM (se requiere la versión nightly para soporte de GLM-5)
pip install -U vllm --pre --extra-index-url https://wheels.vllm.ai/nightly

# Instalar transformers más reciente (requerido)
pip install git+https://github.com/huggingface/transformers.git
```

### Servir FP8 en 8× GPUs H200

```bash
vllm serve zai-org/GLM-5-FP8 \
  --tensor-parallel-size 8 \
  --speculative-config.method mtp \
  --speculative-config.num_speculative_tokens 1 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --enable-auto-tool-choice \
  --served-model-name glm-5-fp8 \
  --gpu-memory-utilization 0.85
```

### Consultar el servidor

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

# Con modo de pensamiento (predeterminado)
response = client.chat.completions.create(
    model="glm-5-fp8",
    messages=[
        {"role": "system", "content": "Eres un asistente útil."},
        {"role": "user", "content": "Resuelve: encuentra todos los primos p donde p^2 + 2 también es primo"}
    ],
    temperature=1.0,
    max_tokens=4096
)
print(response.choices[0].message.content)

# Sin modo de pensamiento (más rápido, respuestas más cortas)
response = client.chat.completions.create(
    model="glm-5-fp8",
    messages=[
        {"role": "user", "content": "Escribe un quicksort en Rust"}
    ],
    temperature=1.0,
    max_tokens=4096,
    extra_body={
        "chat_template_kwargs": {"enable_thinking": False}
    }
)
print(response.choices[0].message.content)
```

## Alternativa SGLang

SGLang también soporta GLM-5 y puede ofrecer mejor rendimiento en algún hardware:

```bash
# Usando Docker (GPUs Hopper)
docker pull lmsysorg/sglang:glm5-hopper

# Lanzar servidor
python3 -m sglang.launch_server \
  --model-path zai-org/GLM-5-FP8 \
  --tp-size 8 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --speculative-algorithm EAGLE \
  --speculative-num-steps 3 \
  --speculative-eagle-topk 1 \
  --speculative-num-draft-tokens 4 \
  --mem-fraction-static 0.85 \
  --served-model-name glm-5-fp8
```

## Inicio rápido con Docker

```bash
# Imagen Docker de vLLM con soporte para GLM-5
docker run --gpus all -p 8000:8000 \
  --ipc=host \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:glm5 zai-org/GLM-5-FP8 \
  --tensor-parallel-size 8 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --enable-auto-tool-choice \
  --served-model-name glm5 \
  --trust-remote-code
```

## Ejemplo de llamada a herramienta

GLM-5 tiene soporte nativo para llamadas a herramientas — ideal para construir aplicaciones agentivas:

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Obtener el clima actual de una ciudad",
        "parameters": {
            "type": "object",
            "required": ["city"],
            "properties": {
                "city": {"type": "string", "description": "Nombre de la ciudad"}
            }
        }
    }
}]

response = client.chat.completions.create(
    model="glm-5-fp8",
    messages=[{"role": "user", "content": "¿Cuál es el clima en Tokio?"}],
    tools=tools,
    tool_choice="auto"
)
print(response.choices[0].message.tool_calls)
```

## Consejos para usuarios de Clore.ai

* **API primero, autoalojamiento después**: GLM-5 requiere 8× H200 (\~$24–48/día en Clore.ai). Para uso ocasional, la API de Z.AI o OpenRouter es mucho más rentable. Autoalojar solo si necesitas rendimiento sostenido o privacidad de datos.
* **Considera GLM-4.7 en su lugar**: Si 8× H200 es demasiado, el predecesor GLM-4.7 (355B, 32B activos) funciona en 4× H200 o 4× H100 (\~$12–24/día) y aún ofrece un rendimiento excelente.
* **Usa pesos FP8**: Usa siempre `zai-org/GLM-5-FP8` — misma calidad que BF16 pero con casi la mitad del consumo de memoria. La versión BF16 requiere 16× GPUs.
* **Monitorea el uso de VRAM**: `watch nvidia-smi` — las consultas de contexto largo pueden aumentar picos de memoria. Ajusta `--gpu-memory-utilization 0.85` para dejar margen.
* **Compensación del modo de pensamiento**: El modo de pensamiento produce mejores resultados para tareas complejas pero usa más tokens y tiempo. Desactívalo para consultas simples con `enable_thinking: false`.

## Solución de problemas

| Problema                                 | Solución                                                                                     |
| ---------------------------------------- | -------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` al iniciar            | Asegúrate de tener 8× H200 (141GB cada una). FP8 necesita \~860GB de VRAM en total.          |
| Descargas lentas (\~800GB)               | Usa `huggingface-cli download zai-org/GLM-5-FP8` con `--local-dir` para reanudar.            |
| Incompatibilidad de versión de vLLM      | GLM-5 requiere la versión nightly de vLLM. Instala vía `pip install -U vllm --pre`.          |
| Llamadas a herramientas no funcionan     | Agregar `--tool-call-parser glm47 --enable-auto-tool-choice` para el comando serve.          |
| Errores DeepGEMM                         | Instala DeepGEMM para FP8: usa el `install_deepgemm.sh` script del repositorio de vLLM.      |
| Modo de pensamiento produce salida vacía | Establecer `temperature=1.0` — el modo de pensamiento requiere temperatura distinta de cero. |

## Lecturas adicionales

* [GLM-5 en HuggingFace](https://huggingface.co/zai-org/GLM-5)
* [Checkpoint FP8 de GLM-5](https://huggingface.co/zai-org/GLM-5-FP8)
* [Plataforma Z.AI](https://chat.z.ai)
* [Documentación API de Z.AI](https://docs.z.ai/guides/llm/glm-5)
* [Receta vLLM para GLM-5](https://docs.vllm.ai/projects/recipes/en/latest/GLM/GLM5.html)
* [Blog técnico de GLM-5](https://z.ai/blog/glm-5)
* [Infraestructura Slime RL](https://github.com/THUDM/slime)