> 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

Déployez GLM-5 (MoE 744B) de Zhipu AI sur Clore.ai — accès API et auto-hébergement avec vLLM

GLM-5, sorti en février 2026 par Zhipu AI (Z.AI), est un **modèle à mélange d'experts de 744 milliards de paramètres** modèle de langage qui n'active que 40 milliards de paramètres par jeton. Il atteint des performances open source de premier plan sur les tâches de raisonnement, de codage et agentiques — avec un score de 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 la **licence MIT** sur HuggingFace.

## Caractéristiques clés

* **744 Mds au total / 40 Mds actifs** — MoE à 256 experts avec un routage très efficace
* **Performances de codage de pointe** — 77,8 % sur SWE-bench Verified, 73,3 % sur SWE-bench Multilingual
* **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 horizon
* **Fenêtre de contexte de plus de 200 K** — gère de vastes bases de code et de longs documents
* **licence MIT** — poids entièrement ouverts, usage commercial autorisé

## Exigences

{% hint style="warning" %}
**Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai.** Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez [bare metal](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement.
{% endhint %}

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

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

**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 ([bare metal](https://clore.ai/bare-metal) 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-clé-api-zai",
    base_url="https://api.z.ai/v1"
)

response = client.chat.completions.create(
    model="glm-5",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant utile."},
        {"role": "user", "content": "Écris un scraper web asynchrone en Python 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-clé-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 (la version nightly est requise pour la prise en charge de GLM-5)
pip install -U vllm --pre --extra-index-url https://wheels.vllm.ai/nightly

# Installer la dernière version de transformers (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 utile."},
        {"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 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 avec Docker

```bash
# Image Docker vLLM avec prise en charge de 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'outil

GLM-5 prend en charge l'appel natif d'outils — idéal pour créer 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": "Quelle est la météo à 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 ([bare metal](https://clore.ai/bare-metal) sur Clore.ai). Pour un usage occasionnel, l'API Z.AI ou OpenRouter est bien plus rentable. N'auto-hébergez que si vous avez besoin d'un débit soutenu ou de confidentialité des données.
* **Envisagez plutôt GLM-4.7**: Si 8× H200 est trop, le prédécesseur GLM-4.7 (355B, 32B actifs) fonctionne sur 4× H200 ou 4× H100 (\~4,16 $/h) et offre toujours d'excellentes performances.
* **Utiliser les poids FP8**: Utilisez toujours `zai-org/GLM-5-FP8` — même qualité que BF16 mais avec une empreinte mémoire presque divisée par deux. La version BF16 nécessite 16× GPU.
* **Surveiller l'utilisation de la VRAM**: `watch nvidia-smi` — les requêtes à long contexte peuvent faire grimper la mémoire. Définissez `--gpu-memory-utilization 0.85` pour garder une marge.
* **Compromis du mode réflexion**: Le mode réflexion produit de meilleurs résultats pour les tâches complexes mais utilise plus de jetons 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). Le FP8 nécessite \~860 Go 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 la version nightly de vLLM. Installez via `pip install -U vllm --pre`.    |
| Les appels d'outils ne fonctionnent pas | Ajoutez `--tool-call-parser glm47 --enable-auto-tool-choice` dans la commande serve.      |
| Erreurs DeepGEMM                        | Installez DeepGEMM pour FP8 : utilisez le script `install_deepgemm.sh` du dépôt vLLM.     |
| Sortie du mode réflexion vide           | Définissez `temperature=1.0` — le mode réflexion nécessite une température non nulle.     |

## Pour aller plus loin

* [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)
* [Documentation API Z.AI](https://docs.z.ai/guides/llm/glm-5)
* [Recette vLLM 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, and the optional `goal` query parameter:

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