> 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-fr/modeles-de-langage/glm5.md).

# GLM-5

GLM-5, publié en février 2026 par Zhipu AI (Z.AI), est un **modèle de langage Mixture-of-Experts de 744 milliards de paramètres** qui n'active que 40B paramètres par token. Il atteint des performances open-source de premier plan en raisonnement, codage et tâches agentiques — obtenant 77,8 % sur SWE-bench Verified et rivalisant avec des modèles de pointe comme Claude Opus 4.5 et GPT-5.2. Le modèle est disponible sous **Licence MIT** sur HuggingFace.

## Principales caractéristiques

* **744B au total / 40B actifs** — MoE à 256 experts avec routage très efficace
* **Performances de pointe en codage** — 77,8 % SWE-bench Verified, 73,3 % SWE-bench Multilingue
* **Raisonnement approfondi** — 92,7 % sur AIME 2026, 96,9 % sur HMMT Nov 2025, mode de réflexion intégré
* **Capacités agentiques** — appel natif d'outils, exécution de fonctions et planification de tâches à long terme
* **Fenêtre de contexte >200K** — gère d'énormes bases de code et de longs documents
* **Licence MIT** — poids entièrement ouverts, usage commercial autorisé

## Exigences

L'auto-hébergement de GLM-5 est une entreprise sérieuse — le checkpoint FP8 nécessite **\~860Go de VRAM**.

| Composant | Minimum (FP8) | Recommandé     |
| --------- | ------------- | -------------- |
| GPU       | 8× H100 80GB  | 8× H200 141 Go |
| VRAM      | 640Go         | 1 128 Go       |
| RAM       | 256GB         | 512GB          |
| Disque    | 1,5To NVMe    | 2To NVMe       |
| CUDA      | 12.0+         | 12.4+          |

**Recommandation Clore.ai**: Pour la plupart des utilisateurs, **accédez à GLM-5 via l'API** (Z.AI, OpenRouter). L'auto-hébergement n'a de sens que si vous pouvez louer 8× H100/H200 (\~24–48 $/jour sur Clore.ai).

## Accès API (Recommandé pour la plupart des utilisateurs)

La façon la plus pratique d'utiliser GLM-5 depuis une machine Clore.ai ou n'importe où :

### Via la plateforme Z.AI

```python
from openai import OpenAI

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

response = client.chat.completions.create(
    model="glm-5",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant serviable."},
        {"role": "user", "content": "Écris un web scraper Python asynchrone utilisant aiohttp et BeautifulSoup"}
    ],
    temperature=1.0,
    max_tokens=4096
)
print(response.choices[0].message.content)
```

### Via OpenRouter

```python
from openai import OpenAI

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

response = client.chat.completions.create(
    model="zai-org/glm-5",
    messages=[
        {"role": "user", "content": "Explique l'architecture MoE utilisée dans GLM-5"}
    ],
    max_tokens=2048
)
print(response.choices[0].message.content)
```

## Configuration vLLM (Auto-hébergement)

Pour ceux qui ont accès à des machines multi-GPU haut de gamme sur Clore.ai :

```bash
# Installer vLLM (nightly requis pour le support GLM-5)
pip install -U vllm --pre --extra-index-url https://wheels.vllm.ai/nightly

# Installer transformers (dernière version requise)
pip install git+https://github.com/huggingface/transformers.git
```

### Servir FP8 sur 8× GPU 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
```

### Interroger le serveur

```python
from openai import OpenAI

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

# Avec le mode réflexion (par défaut)
response = client.chat.completions.create(
    model="glm-5-fp8",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant serviable."},
        {"role": "user", "content": "Résoudre : trouver tous les nombres premiers p tels que p^2 + 2 soit aussi premier"}
    ],
    temperature=1.0,
    max_tokens=4096
)
print(response.choices[0].message.content)

# Sans le mode réflexion (plus rapide, réponses plus courtes)
response = client.chat.completions.create(
    model="glm-5-fp8",
    messages=[
        {"role": "user", "content": "Écris un quicksort en Rust"}
    ],
    temperature=1.0,
    max_tokens=4096,
    extra_body={
        "chat_template_kwargs": {"enable_thinking": False}
    }
)
print(response.choices[0].message.content)
```

## Alternative SGLang

SGLang prend également en charge GLM-5 et peut offrir de meilleures performances sur certains matériels :

```bash
# Utilisation de Docker (GPU Hopper)
docker pull lmsysorg/sglang:glm5-hopper

# Lancer le serveur
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
```

## Démarrage rapide Docker

```bash
# Image Docker vLLM avec support 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
```

## Exemple d'appel d'outils

GLM-5 dispose d'un support natif d'appel d'outils — idéal pour construire des applications agentiques :

```python
from openai import OpenAI

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

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Obtenir la météo actuelle pour une ville",
        "parameters": {
            "type": "object",
            "required": ["city"],
            "properties": {
                "city": {"type": "string", "description": "Nom de la ville"}
            }
        }
    }
}]

response = client.chat.completions.create(
    model="glm-5-fp8",
    messages=[{"role": "user", "content": "Quel temps fait-il à Tokyo ?"}],
    tools=tools,
    tool_choice="auto"
)
print(response.choices[0].message.tool_calls)
```

## Conseils pour les utilisateurs de Clore.ai

* **API d'abord, auto-hébergement ensuite**: GLM-5 nécessite 8× H200 (\~24–48 $/jour sur Clore.ai). Pour un usage occasionnel, l'API Z.AI ou OpenRouter est bien plus rentable. Auto-hébergez uniquement si vous avez besoin d'un débit soutenu ou de confidentialité des données.
* **Envisagez GLM-4.7 à la place**: Si 8× H200 est trop, le prédécesseur GLM-4.7 (355B, 32B actifs) fonctionne sur 4× H200 ou 4× H100 (\~12–24 $/jour) et offre toujours d'excellentes performances.
* **Utilisez les poids FP8**: Utilisez toujours `zai-org/GLM-5-FP8` — même qualité que BF16 mais presque moitié moindre empreinte mémoire. La version BF16 nécessite 16× GPU.
* **Surveillez l'utilisation de la VRAM**: `watch nvidia-smi` — les requêtes de long contexte peuvent faire monter la mémoire. Réglez `--gpu-memory-utilization 0.85` pour laisser de la marge.
* **Compromis du mode réflexion**: Le mode réflexion produit de meilleurs résultats pour les tâches complexes mais utilise plus de tokens et de temps. Désactivez-le pour les requêtes simples avec `enable_thinking: false`.

## Dépannage

| Problème                         | Solution                                                                                 |
| -------------------------------- | ---------------------------------------------------------------------------------------- |
| `OutOfMemoryError` au démarrage  | Assurez-vous d'avoir 8× H200 (141 Go chacun). FP8 nécessite \~860Go de VRAM au total.    |
| Téléchargements lents (\~800 Go) | Utilisez `huggingface-cli download zai-org/GLM-5-FP8` avec `--local-dir` pour reprendre. |
| Incompatibilité de version vLLM  | GLM-5 nécessite vLLM nightly. Installez via `pip install -U vllm --pre`.                 |
| Appels d'outils non fonctionnels | Ajoutez `--tool-call-parser glm47 --enable-auto-tool-choice` pour la commande serve.     |
| Erreurs DeepGEMM                 | Installez DeepGEMM pour FP8 : utilisez le `install_deepgemm.sh` script du dépôt vLLM.    |
| Sortie vide en mode réflexion    | Définir `temperature=1.0` — le mode réflexion nécessite une température non nulle.       |

## Lectures complémentaires

* [GLM-5 sur HuggingFace](https://huggingface.co/zai-org/GLM-5)
* [Checkpoint FP8 de GLM-5](https://huggingface.co/zai-org/GLM-5-FP8)
* [Plateforme Z.AI](https://chat.z.ai)
* [Docs API Z.AI](https://docs.z.ai/guides/llm/glm-5)
* [Recette vLLM pour GLM-5](https://docs.vllm.ai/projects/recipes/en/latest/GLM/GLM5.html)
* [Blog technique GLM-5](https://z.ai/blog/glm-5)
* [Infrastructure 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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/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.