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