En bref
GLM-5.1 est disponible via l'API BigModel à l'adresse https://open.bigmodel.cn/api/paas/v4/. L'API est compatible avec OpenAI : même structure de point de terminaison, même format de requête, même modèle de streaming. Vous avez besoin d'un compte BigModel, d'une clé API et du nom de modèle glm-5.1. Ce guide couvre l'authentification, votre première requête, le streaming, l'appel d'outils et le test de votre intégration avec Apidog.
Essayez Apidog dès aujourd'hui
Introduction
GLM-5.1 est le modèle agentique phare de Z.AI, lancé en avril 2026. Il se classe n°1 sur SWE-Bench Pro et surpasse GLM-5 sur tous les principaux benchmarks de codage. Pour intégrer GLM-5.1 à un assistant de codage IA, un agent autonome ou une application exécutant des tâches longues, suivez ce guide.
Bonne nouvelle : l'API est compatible OpenAI. Si vous avez déjà utilisé GPT-4 ou Claude, il suffit de changer l'URL de base et le nom de modèle. Aucun nouveau SDK à apprendre, aucun format de réponse à adapter.
💡 Le principal défi avec les API agentiques est le test. Un modèle qui exécute des centaines d'appels d'outils sur plusieurs minutes est difficile à tester avec l'API réelle sans épuiser le quota. Les Scénarios de Test d'Apidog résolvent ce problème : vous pouvez définir la séquence complète des requêtes de votre agent, simuler les réponses pour chaque état, et vérifier que votre intégration gère correctement le streaming, les appels d'outils et les conditions d'erreur avant de passer en production. Téléchargez Apidog gratuitement pour suivre la section de test de ce guide.
Prérequis
Avant d'effectuer votre premier appel, assurez-vous d'avoir :
- Un compte BigModel sur bigmodel.cn. L'inscription est gratuite.
- Une clé API depuis la console BigModel, sous Clés API.
- Python 3.8+ ou Node.js 18+ (exemples fournis pour les deux).
- SDK OpenAI ou requêtes/fetch standards (l'API GLM-5.1 est compatible OpenAI).
Définissez votre clé API comme variable d'environnement :
export BIGMODEL_API_KEY="votre_clé_api_ici"
Ne codez jamais en dur vos clés API dans votre code source.
Authentification
Chaque requête nécessite un jeton Bearer dans l'en-tête Authorization :
Authorization: Bearer VOTRE_CLÉ_API
Le format de la clé BigModel ressemble à xxxxxxxx.xxxxxxxxxxxxxxxx (deux parties séparées par un point).
URL de base
https://open.bigmodel.cn/api/paas/v4/
Point de terminaison pour les complétions de chat :
POST https://open.bigmodel.cn/api/paas/v4/chat/completions
Votre première requête
Utilisation de curl
curl https://open.bigmodel.cn/api/paas/v4/chat/completions \
-H "Authorization: Bearer $BIGMODEL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "glm-5.1",
"messages": [
{
"role": "user",
"content": "Write a Python function that finds all prime numbers up to n using the Sieve of Eratosthenes."
}
],
"max_tokens": 1024,
"temperature": 0.7
}'
Utilisation de Python (requests)
import os
import requests
api_key = os.environ["BIGMODEL_API_KEY"]
response = requests.post(
"https://open.bigmodel.cn/api/paas/v4/chat/completions",
headers={
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
},
json={
"model": "glm-5.1",
"messages": [
{
"role": "user",
"content": "Write a Python function that finds all prime numbers up to n using the Sieve of Eratosthenes."
}
],
"max_tokens": 1024,
"temperature": 0.7
}
)
result = response.json()
print(result["choices"][0]["message"]["content"])
Utilisation du SDK OpenAI (recommandé)
L'API étant compatible OpenAI, vous pouvez utiliser le SDK Python officiel d'OpenAI en définissant l'URL de base :
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["BIGMODEL_API_KEY"],
base_url="https://open.bigmodel.cn/api/paas/v4/"
)
response = client.chat.completions.create(
model="glm-5.1",
messages=[
{
"role": "user",
"content": "Write a Python function that finds all prime numbers up to n using the Sieve of Eratosthenes."
}
],
max_tokens=1024,
temperature=0.7
)
print(response.choices[0].message.content)
Le SDK OpenAI gère les tentatives, délais d'attente et parsing de réponses automatiquement.
Format de réponse
La structure de la réponse est identique à celle d'OpenAI :
{
"id": "chatcmpl-abc123",
"object": "chat.completion",
"created": 1744000000,
"model": "glm-5.1",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "def sieve_of_eratosthenes(n):\n ..."
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 32,
"completion_tokens": 215,
"total_tokens": 247
}
}
Accédez au texte via result["choices"][0]["message"]["content"].
Le champ usage vous aide à suivre la consommation de quota. GLM-5.1 est facturé 3x pendant les heures de pointe (14h00-18h00 UTC+8).
Streaming des réponses
Pour les tâches longues, activez le streaming pour recevoir les jetons en temps réel.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["BIGMODEL_API_KEY"],
base_url="https://open.bigmodel.cn/api/paas/v4/"
)
stream = client.chat.completions.create(
model="glm-5.1",
messages=[
{
"role": "user",
"content": "Explain how a B-tree index works in a database, with a code example."
}
],
stream=True,
max_tokens=2048
)
for chunk in stream:
if chunk.choices[0].delta.content is not None:
print(chunk.choices[0].delta.content, end="", flush=True)
print() # saut de ligne après la fin du streaming
Chaque bloc contient uniquement les nouveaux jetons depuis le précédent.
Streaming avec des requêtes brutes
Sans SDK :
import os
import json
import requests
api_key = os.environ["BIGMODEL_API_KEY"]
response = requests.post(
"https://open.bigmodel.cn/api/paas/v4/chat/completions",
headers={
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
},
json={
"model": "glm-5.1",
"messages": [{"role": "user", "content": "Write a merge sort in Python."}],
"stream": True,
"max_tokens": 1024
},
stream=True
)
for line in response.iter_lines():
if line:
line = line.decode("utf-8")
if line.startswith("data: "):
data = line[6:]
if data == "[DONE]":
break
chunk = json.loads(data)
delta = chunk["choices"][0]["delta"]
if "content" in delta:
print(delta["content"], end="", flush=True)
Appel d'outils
GLM-5.1 supporte l'appel d'outils (function calling) pour exécuter du code, interroger des bases de données, ou déclencher des actions via API.
Définition d'outils
import os
import json
from openai import OpenAI
client = OpenAI(
api_key=os.environ["BIGMODEL_API_KEY"],
base_url="https://open.bigmodel.cn/api/paas/v4/"
)
tools = [
{
"type": "function",
"function": {
"name": "run_python",
"description": "Execute Python code and return the output. Use this to test, profile, or benchmark code.",
"parameters": {
"type": "object",
"properties": {
"code": {
"type": "string",
"description": "The Python code to execute"
}
},
"required": ["code"]
}
}
},
{
"type": "function",
"function": {
"name": "read_file",
"description": "Read the contents of a file",
"parameters": {
"type": "object",
"properties": {
"path": {
"type": "string",
"description": "File path to read"
}
},
"required": ["path"]
}
}
}
]
response = client.chat.completions.create(
model="glm-5.1",
messages=[
{
"role": "user",
"content": "Write a function to compute Fibonacci numbers, test it for n=10, and show me the output."
}
],
tools=tools,
tool_choice="auto"
)
message = response.choices[0].message
print(f"Raison de l'achèvement: {response.choices[0].finish_reason}")
if message.tool_calls:
for tool_call in message.tool_calls:
print(f"\nOutil appelé: {tool_call.function.name}")
print(f"Arguments: {tool_call.function.arguments}")
Gestion des réponses d'appel d'outils
Lorsque GLM-5.1 demande un appel d'outil, exécutez la fonction puis retournez le résultat dans le message suivant :
import subprocess
def execute_tool(tool_call):
"""Execute l'outil et renvoie le résultat."""
name = tool_call.function.name
args = json.loads(tool_call.function.arguments)
if name == "run_python":
result = subprocess.run(
["python3", "-c", args["code"]],
capture_output=True,
text=True,
timeout=10
)
return result.stdout or result.stderr
elif name == "read_file":
try:
with open(args["path"]) as f:
return f.read()
except FileNotFoundError:
return f"Erreur : fichier {args['path']} introuvable"
return f"Outil inconnu : {name}"
def run_agent_loop(user_message, tools, max_iterations=20):
"""Exécute une boucle d'agent complète avec appel d'outils."""
messages = [{"role": "user", "content": user_message}]
for i in range(max_iterations):
response = client.chat.completions.create(
model="glm-5.1",
messages=messages,
tools=tools,
tool_choice="auto",
max_tokens=4096
)
message = response.choices[0].message
messages.append(message.model_dump())
if response.choices[0].finish_reason == "stop":
return message.content
if response.choices[0].finish_reason == "tool_calls":
for tool_call in message.tool_calls:
tool_result = execute_tool(tool_call)
messages.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": tool_result
})
return "Nombre maximal d'itérations atteint"
result = run_agent_loop(
"Écrivez une implémentation de quicksort, testez-la avec une liste aléatoire de 1000 entiers, et rapportez le temps.",
tools
)
print(result)
Ce schéma vous permet de piloter des boucles agentiques complexes avec appels de fonctions dynamiques.
Paramètres clés
| Paramètre | Type | Défaut | Description |
|---|---|---|---|
model |
string | required | Utiliser "glm-5.1"
|
messages |
array | required | Historique de la conversation |
max_tokens |
integer | 1024 | Nombre maximal de jetons (jusqu'à 163 840) |
temperature |
float | 0.95 | Aléatoire (0,0-1,0) |
top_p |
float | 0.7 | Échantillonnage par noyau |
stream |
boolean | false | Activer le streaming |
tools |
array | null | Définition des fonctions pour l'appel d'outils |
tool_choice |
string/object | "auto" |
"auto", "none" ou nom d'outil spécifique |
stop |
string/array | null | Séquences d'arrêt personnalisées |
Paramètres recommandés pour le codage :
{
"model": "glm-5.1",
"temperature": 1.0,
"top_p": 0.95,
"max_tokens": 163840 # contexte complet pour exécutions longues
}
Pour une génération déterministe, baissez la température à 0,2-0,4.
Utilisation de GLM-5.1 avec les assistants de codage
Le Plan de Codage Z.AI permet de router Claude Code, Cline, Kilo Code et autres assistants via GLM-5.1 avec l'API BigModel. Cela réduit les coûts par rapport à GPT-5.4 ou Claude Opus.
Configuration de Claude Code
Dans ~/.claude/settings.json :
{
"model": "glm-5.1",
"baseURL": "https://open.bigmodel.cn/api/paas/v4/",
"apiKey": "votre_clé_api_bigmodel"
}
Configuration de Cline / Roo Code
Dans votre configuration VS Code ou extension :
{
"cline.apiProvider": "openai",
"cline.openAIBaseURL": "https://open.bigmodel.cn/api/paas/v4/",
"cline.openAIApiKey": "votre_clé_api_bigmodel",
"cline.openAIModelId": "glm-5.1"
}
Consommation de quota
- Heures de pointe (14h00-18h00 UTC+8) : 3x le quota
- Hors heures de pointe : 2x le quota
- Tarif promotionnel jusqu'à fin avril 2026 : 1x en heures creuses
Planifiez vos tâches longues pendant les heures creuses pour optimiser le quota.
Tester l'API GLM-5.1 avec Apidog
Pour tester vos intégrations agentiques sans consommer de quota, utilisez le Smart Mock d'Apidog.
Configuration du point de terminaison de simulation
- Dans Apidog, créez un nouveau point de terminaison :
POST https://open.bigmodel.cn/api/paas/v4/chat/completions - Ajoutez une attente de simulation pour une réponse standard :
{
"id": "chatcmpl-test123",
"object": "chat.completion",
"created": 1744000000,
"model": "glm-5.1",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "def sieve(n): ..."
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 32,
"completion_tokens": 120,
"total_tokens": 152
}
}
- Ajoutez une deuxième attente pour une réponse d'appel d'outil :
{
"id": "chatcmpl-tool456",
"object": "chat.completion",
"created": 1744000001,
"model": "glm-5.1",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": null,
"tool_calls": [
{
"id": "call_abc",
"type": "function",
"function": {
"name": "run_python",
"arguments": "{\"code\": \"print(2+2)\"}"
}
}
]
},
"finish_reason": "tool_calls"
}
],
"usage": {
"prompt_tokens": 48,
"completion_tokens": 35,
"total_tokens": 83
}
}
- Ajoutez une réponse de limite de débit (HTTP 429) :
{
"error": {
"message": "Rate limit exceeded. Please retry after 60 seconds.",
"type": "rate_limit_error",
"code": "rate_limit_exceeded"
}
}
Test de la boucle d'agent complète
Utilisez les Scénarios de Test d'Apidog pour simuler une vraie boucle :
-
Étape 1 : Requête POST vers
/chat/completionsavec message initial, vérifiez code 200 etfinish_reason == "tool_calls" -
Étape 2 : Nouvelle requête POST avec le résultat de l'outil, vérifiez code 200 et
finish_reason == "stop" - Étape 3 : Extrayez le contenu final et validez le résultat
Pour tester la gestion des erreurs, configurez le mock pour renvoyer 429 et vérifiez la logique de réessai.
Les Scénarios de Test Apidog permettent de transmettre automatiquement les variables d'une étape à l'autre (request_id, tool_call_id), comme dans une vraie boucle agentique.
Gestion des erreurs
L'API renvoie les codes HTTP standards :
| Statut | Signification | Action |
|---|---|---|
| 200 | Succès | Traitez la réponse |
| 400 | Mauvaise requête | Vérifiez le format |
| 401 | Non autorisé | Vérifiez la clé API |
| 429 | Limite de débit | Réessayez après Retry-After
|
| 500 | Erreur serveur | Réessayez avec délai d'attente exponentiel |
| 503 | Service indispo | Réessayez avec délai d'attente exponentiel |
Exemple de gestion robuste :
import time
import requests
def call_with_retry(payload, max_retries=3):
for attempt in range(max_retries):
try:
response = requests.post(
"https://open.bigmodel.cn/api/paas/v4/chat/completions",
headers={"Authorization": f"Bearer {os.environ['BIGMODEL_API_KEY']}",
"Content-Type": "application/json"},
json=payload,
timeout=120
)
if response.status_code == 429:
retry_after = int(response.headers.get("Retry-After", 60))
print(f"Limite de débit atteinte. Attente de {retry_after}s...")
time.sleep(retry_after)
continue
response.raise_for_status()
return response.json()
except requests.exceptions.Timeout:
wait = 2 ** attempt
print(f"Délai d'attente dépassé à la tentative {attempt + 1}. Nouvelle tentative dans {wait}s...")
time.sleep(wait)
raise Exception("Nombre maximal de tentatives dépassé")
Pour des tâches longues, définissez des timeouts généreux (120-300s).
Conclusion
L'API compatible OpenAI de GLM-5.1 permet une intégration rapide pour les utilisateurs de GPT ou Claude. La différence réside dans l'URL (open.bigmodel.cn) et le système de quota.
Pour des applications agentiques complexes, la capacité d'optimisation longue durée de GLM-5.1 est un atout. Utilisez le Smart Mock et les Scénarios de Test d'Apidog pour valider vos intégrations avant la mise en production.
Pour plus d'informations sur GLM-5.1 et les performances, consultez l'aperçu du modèle GLM-5.1. Pour approfondir la création et le test de workflows d'agents IA avec Apidog, lisez le fonctionnement de la mémoire des agents IA.
FAQ
L'API GLM-5.1 est-elle compatible avec OpenAI ?
Oui. Le format de requête, la structure de réponse, le protocole de streaming et le format d'appel d'outils sont identiques à l'API d'OpenAI. Utilisez le SDK Python officiel ou tout client OpenAI en définissant l'URL de base sur https://open.bigmodel.cn/api/paas/v4/.
Quel est le nom du modèle à utiliser ?
Utilisez "glm-5.1" comme nom de modèle.
Comment fonctionne la tarification de l'API GLM-5.1 ?
Le système est basé sur le quota : 3x pendant les heures de pointe (14h00-18h00 UTC+8), 2x en heures creuses. Jusqu'à fin avril 2026, tarif promotionnel à 1x en heures creuses.
Quelle est la longueur maximale du contexte ?
Entrée : 200 000 jetons. Sortie : 163 840 jetons. Pour les tâches longues, définissez max_tokens sur une valeur élevée (32 768+).
GLM-5.1 supporte-t-il l'appel de fonctions/outils ?
Oui, même format qu'OpenAI. Définissez vos outils dans le tableau tools et gérez la réponse finish_reason: "tool_calls" dans votre boucle d'agent.
Comment tester les appels API GLM-5.1 sans dépenser de quota ?
Utilisez le Smart Mock d'Apidog pour simuler tous les états (succès, outils, erreurs) pendant le développement.
Où trouver les poids du modèle GLM-5.1 ?
Sur HuggingFace à zai-org/GLM-5.1 (licence MIT). Compatible vLLM et SGLang pour l'inférence locale.
Top comments (0)