GLM-5

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

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

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

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 :

# 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

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

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 :

# 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

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

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

• Checkpoint FP8 de GLM-5

• Plateforme Z.AI

• Docs API Z.AI

• Recette vLLM pour GLM-5

• Blog technique GLM-5

• Infrastructure Slime RL