# 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)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/glm5.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.