> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/glm5.md).

# GLM-5

Despliega GLM-5 (744B MoE) de Zhipu AI en Clore.ai: acceso por API y autoalojamiento con vLLM

GLM-5, lanzado en febrero de 2026 por Zhipu AI (Z.AI), es un **modelo Mixture-of-Experts de 744 mil millones de parámetros** modelo de lenguaje que activa solo 40 mil millones de parámetros por token. Logra un rendimiento de código abierto de primer nivel en razonamiento, programación y tareas agénticas — obteniendo un 77.8% en SWE-bench Verified y compitiendo con modelos punteros como Claude Opus 4.5 y GPT-5.2. El modelo está disponible bajo la **licencia MIT** en HuggingFace.

## Características clave

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

## Requisitos

{% hint style="warning" %}
**Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai.** Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como [bare metal](https://clore.ai/bare-metal) bajo pedido. Consulta [Precios y disponibilidad de GPU](/guides/guides_v2-es/primeros-pasos/pricing.md) antes de dimensionar un despliegue.
{% endhint %}

Autoalojar GLM-5 es una tarea 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.8+        | 12.8+         |

**Recomendación de Clore.ai**: Para la mayoría de los usuarios, **acceder a GLM-5 vía API** (Z.AI, OpenRouter). El autoalojamiento solo tiene sentido si puedes alquilar 8× H100/H200 ([bare metal](https://clore.ai/bare-metal) en Clore.ai).

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

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

### Vía la plataforma Z.AI

```python
from openai import OpenAI

client = OpenAI(
    api_key="tu-clave-api-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 web scraper 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 utilizada en GLM-5"}
    ],
    max_tokens=2048
)
print(response.choices[0].message.content)
```

## Configuración de vLLM (autoalojamiento)

Para quienes tienen acceso a máquinas multinodo de gama alta con varias GPU en Clore.ai:

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

# Instalar la última versión de transformers (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 (respuestas más rápidas y 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 admite GLM-5 y puede ofrecer mejor rendimiento en algo de hardware:

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

# Iniciar 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 herramientas

GLM-5 tiene compatibilidad nativa con llamadas a herramientas — ideal para crear aplicaciones agénticas:

```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": "¿Qué clima hace 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 ([bare metal](https://clore.ai/bare-metal) en Clore.ai). Para un uso ocasional, la API de Z.AI o OpenRouter es mucho más rentable. Autoalójalo solo si necesitas un 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 (\~$4.16/h) y sigue ofreciendo un rendimiento excelente.
* **Usa pesos FP8**: Usa siempre `zai-org/GLM-5-FP8` — la misma calidad que BF16 pero con casi la mitad de uso de memoria. La versión BF16 requiere 16× GPUs.
* **Supervisa el uso de VRAM**: `watch nvidia-smi` — las consultas de contexto largo pueden disparar el uso de memoria. Deja `--gpu-memory-utilization 0.85` para mantener margen.
* **Compromiso 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 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 mediante `pip install -U vllm --pre`.        |
| Las llamadas a herramientas no funcionan | Añade `--tool-call-parser glm47 --enable-auto-tool-choice` al comando serve.                    |
| Errores de DeepGEMM                      | Instala DeepGEMM para FP8: usa el script `install_deepgemm.sh` del repositorio de vLLM.         |
| Salida vacía en el modo de pensamiento   | Establece `temperature=1.0` — el modo de pensamiento requiere una 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 de la API de Z.AI](https://docs.z.ai/guides/llm/glm-5)
* [Receta de GLM-5 para vLLM](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
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.