Kurz gesagt
GLM-5.1 ist über die BigModel API unter https://open.bigmodel.cn/api/paas/v4/ verfügbar. Die API ist OpenAI-kompatibel: gleiche Endpunktstruktur, gleiches Anfrageformat, gleiches Streaming-Muster. Sie benötigen ein BigModel-Konto, einen API-Schlüssel und den Modellnamen glm-5.1. Dieser Leitfaden behandelt die Authentifizierung, Ihre erste Anfrage, Streaming, Tool-Aufrufe und das Testen Ihrer Integration mit Apidog.
Probiere Apidog noch heute aus
Einleitung
GLM-5.1 ist Z.AIs führendes agentenbasiertes Modell, veröffentlicht im April 2026. Es belegt Platz 1 bei SWE-Bench Pro und übertrifft GLM-5 in allen wichtigen Coding-Benchmarks. Wenn Sie einen KI-Codierungsassistenten, einen autonomen Agenten oder eine Anwendung entwickeln, die von der Ausführung langfristiger Aufgaben profitiert, lohnt sich die Integration von GLM-5.1.
Die gute Nachricht für Entwickler: Die API ist OpenAI-kompatibel. Wenn Sie bereits auf GPT-4 oder Claude aufgebaut haben, können Sie zu GLM-5.1 wechseln, indem Sie die Basis-URL und den Modellnamen ändern. Keine neuen SDKs zu lernen. Kein anderes Antwortformat zu handhaben.
💡 Hinweis: Die größte Herausforderung bei agentenbasierten APIs ist das Testen. Ein Modell, das Hunderte von Tool-Aufrufen über viele Minuten ausführt, ist schwer gegen die echte API zu testen, ohne das Kontingent zu verbrauchen. Die Test-Szenarien von Apidog lösen dieses Problem: Sie können die vollständige Abfolge der Anfragen Ihres Agenten definieren, die Antworten für jeden Zustand simulieren und überprüfen, ob Ihre Integration Streaming, Tool-Aufrufe und Fehlerbedingungen korrekt verarbeitet, bevor Sie in Produktion gehen. Laden Sie Apidog kostenlos herunter, um den Testabschnitt in diesem Leitfaden zu verfolgen.
Voraussetzungen
Bevor Sie Ihren ersten Aufruf tätigen, benötigen Sie:
- Ein BigModel-Konto unter bigmodel.cn. Die Registrierung ist kostenlos.
- Einen API-Schlüssel aus der BigModel-Konsole unter API-Schlüssel.
- Python 3.8+ oder Node.js 18+ (Beispiele decken beides ab).
- Das OpenAI SDK oder Standard-
requests/fetch(die API von GLM-5.1 ist OpenAI-kompatibel).
Setzen Sie Ihren API-Schlüssel als Umgebungsvariable:
export BIGMODEL_API_KEY="your_api_key_here"
Hardcodieren Sie niemals API-Schlüssel in Ihrem Quellcode.
Authentifizierung
Jede Anfrage benötigt einen Bearer-Token im Authorization-Header:
Authorization: Bearer YOUR_API_KEY
Das Format des BigModel API-Schlüssels sieht aus wie xxxxxxxx.xxxxxxxxxxxxxxxx, eine zweiteilige Zeichenfolge, getrennt durch einen Punkt. Dies unterscheidet sich vom sk-Format von OpenAI, funktioniert aber im Header auf die gleiche Weise.
Basis-URL
https://open.bigmodel.cn/api/paas/v4/
Der Endpunkt für Chat-Vervollständigungen ist:
POST https://open.bigmodel.cn/api/paas/v4/chat/completions
Ihre erste Anfrage
Verwendung von 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
}'
Verwendung von 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"])
Verwendung des OpenAI SDK (empfohlen)
Da die API OpenAI-kompatibel ist, können Sie das offizielle OpenAI Python SDK mit einer benutzerdefinierten Basis-URL verwenden:
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)
Das OpenAI SDK übernimmt Wiederholungsversuche, Timeout-Management und das Parsen von Antworten. Sie erhalten all das kostenlos, indem Sie einfach die BigModel-Basis-URL verwenden.
Antwortformat
Die Antwortstruktur ist identisch mit der von 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
}
}
Antworttext: result["choices"][0]["message"]["content"]
Das Feld usage zeigt die Token-Anzahl für die Anfrage. Überwachen Sie dies, um Ihren Kontingentverbrauch zu steuern, da GLM-5.1 während der Spitzenzeiten (14:00-18:00 UTC+8) das 3-fache Kontingent berechnet.
Streaming-Antworten
Für lange Codegenerierungsaufgaben empfiehlt sich Streaming, um Tokens direkt bei Eintreffen zu erhalten.
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() # newline after streaming completes
Jeder Stream-Chunk ist ein Delta mit den neuen Tokens. Der letzte Chunk hat finish_reason = "stop" (oder "length").
Streaming mit Roh-Anfragen
Ohne OpenAI 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)
Tool-Aufrufe
GLM-5.1 unterstützt Tool-Aufrufe (Funktionsaufrufe), um z.B. Code auszuführen, Dateien zu lesen oder externe APIs zu nutzen.
Tools definieren
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"Finish reason: {response.choices[0].finish_reason}")
if message.tool_calls:
for tool_call in message.tool_calls:
print(f"\nTool called: {tool_call.function.name}")
print(f"Arguments: {tool_call.function.arguments}")
Behandeln von Tool-Aufruf-Antworten
Führt das Modell einen Tool-Aufruf aus, führen Sie die Funktion aus und geben Sie das Ergebnis in der nächsten Nachricht zurück:
import subprocess
def execute_tool(tool_call):
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"Error: file {args['path']} not found"
return f"Unknown tool: {name}"
def run_agent_loop(user_message, tools, max_iterations=20):
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 "Max iterations reached"
result = run_agent_loop(
"Write a quicksort implementation, test it with a random list of 1000 integers, and report the time.",
tools
)
print(result)
Dieses Muster ermöglicht agentenbasierte Schleifen mit automatischer Tool-Ausführung.
Wichtige Parameter
| Parameter | Typ | Standard | Beschreibung |
|---|---|---|---|
model |
String | erforderlich | Verwenden Sie "glm-5.1"
|
messages |
Array | erforderlich | Konversationsverlauf |
max_tokens |
Integer | 1024 | Max. zu generierende Tokens (bis zu 163.840) |
temperature |
Float | 0.95 | Zufälligkeit. Niedriger = deterministischer. 0,0-1,0 |
top_p |
Float | 0.7 | Nucleus-Sampling. 0,7 empfohlen für Codierungsaufgaben |
stream |
Boolean | false | Streaming-Antworten aktivieren |
tools |
Array | null | Funktionsdefinitionen für Tool-Aufrufe |
tool_choice |
String/Objekt | "auto" |
"auto", "none" oder spezifisches Tool |
stop |
String/Array | null | Benutzerdefinierte Stoppsequenzen |
Empfohlene Einstellungen für Codierungsaufgaben:
{
"model": "glm-5.1",
"temperature": 1.0,
"top_p": 0.95,
"max_tokens": 163840 # voller Kontext für lange Agentenläufe
}
Für deterministische Codegenerierung: Temperatur auf 0,2-0,4 senken.
GLM-5.1 mit Codierungsassistenten verwenden
Der Z.AI Coding Plan ermöglicht es Ihnen, Claude Code, Cline, Kilo Code und andere KI-Codierungsassistenten über GLM-5.1 via BigModel API zu nutzen.
Claude Code Einrichtung
In Ihrer Claude Code Konfigurationsdatei (~/.claude/settings.json):
{
"model": "glm-5.1",
"baseURL": "https://open.bigmodel.cn/api/paas/v4/",
"apiKey": "your_bigmodel_api_key"
}
Cline / Roo Code Einrichtung
In Ihren VS Code-Einstellungen oder der Cline-Erweiterungskonfiguration:
{
"cline.apiProvider": "openai",
"cline.openAIBaseURL": "https://open.bigmodel.cn/api/paas/v4/",
"cline.openAIApiKey": "your_bigmodel_api_key",
"cline.openAIModelId": "glm-5.1"
}
Kontingentverbrauch
GLM-5.1 verwendet das Z.AI-Kontingentsystem statt Token-basierter Abrechnung:
- Spitzenzeiten (14:00-18:00 UTC+8): 3x Kontingent pro Anfrage
- Nebenzeiten: 2x Kontingent pro Anfrage
- Aktionspreis bis April 2026: 1x während der Nebenzeiten
Planen Sie langlaufende Aufgaben für Nebenzeiten, um Kontingent zu sparen.
Testen der GLM-5.1 API mit Apidog
Das Testen einer agentenbasierten API-Integration erfordert das Handling verschiedener Antworttypen: normale Vervollständigungen, Streaming-Chunks, Tool-Aufrufanfragen, Tool-Ergebnismeldungen und Fehlerzustände. Das echte API-Testing kostet Kontingent.
Apidogs Smart Mock ermöglicht es, all diese Antwortzustände zu definieren und zu testen, ohne die echte API zu nutzen.
Einrichten des Mock-Endpunkts
- Erstellen Sie in Apidog einen neuen Endpunkt:
POST https://open.bigmodel.cn/api/paas/v4/chat/completions - Fügen Sie eine Mock-Erwartung für eine Standard-Erfolgsantwort hinzu:
{
"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
}
}
- Fügen Sie eine zweite Erwartung für eine Tool-Aufruf-Antwort hinzu:
{
"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
}
}
- Fügen Sie eine Ratenbegrenzungsantwort (HTTP 429) hinzu:
{
"error": {
"message": "Rate limit exceeded. Please retry after 60 seconds.",
"type": "rate_limit_error",
"code": "rate_limit_exceeded"
}
}
Testen des vollständigen Agenten-Loops
Nutzen Sie Apidogs Test-Szenarien, um mehrere Anfragen zu verketten:
-
Schritt 1: POST an
/chat/completionsmit Ihrer Nachricht, bestätigen Sie 200 undfinish_reason == "tool_calls" -
Schritt 2: POST mit Tool-Ergebnis im Nachrichten-Array, bestätigen Sie 200 und
finish_reason == "stop" - Schritt 3: Extrahieren Sie den finalen Inhalt und prüfen Sie, ob er erwarteten Code enthält
So testen Sie Agenten-Loops ohne echten Kontingentverbrauch. Fehlerbehandlung lässt sich testen, indem Sie den Mock auf HTTP 429 umschalten und die Retry-Logik Ihrer Anwendung prüfen.
Für mehrstufige Workflows können Sie mit Apidog Variablen zwischen Schritten weitergeben, z.B. request_id oder tool_call_id.
Fehlerbehandlung
Die API gibt Standard-HTTP-Statuscodes zurück:
| Status | Bedeutung | Aktion |
|---|---|---|
| 200 | Erfolg | Antwort normal verarbeiten |
| 400 | Fehlerhafte Anfrage | Anfrageformat prüfen |
| 401 | Nicht autorisiert | API-Schlüssel prüfen |
| 429 | Ratenbegrenzung | Nach Wert im Retry-After-Header erneut versuchen |
| 500 | Serverfehler | Mit exponentiellem Backoff wiederholen |
| 503 | Dienst nicht verfügbar | Mit exponentiellem Backoff wiederholen |
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"Rate limited. Waiting {retry_after}s...")
time.sleep(retry_after)
continue
response.raise_for_status()
return response.json()
except requests.exceptions.Timeout:
wait = 2 ** attempt
print(f"Timeout on attempt {attempt + 1}. Retrying in {wait}s...")
time.sleep(wait)
raise Exception("Max retries exceeded")
Für langlaufende Agentenläufe (30-60 Sekunden pro Schritt) empfehlen sich großzügige Timeouts (120-300 Sekunden).
Fazit
Die OpenAI-kompatible API von GLM-5.1 lässt sich in wenigen Minuten integrieren, wenn Sie bereits mit GPT oder Claude gearbeitet haben. Wichtig ist der andere Endpunkt (open.bigmodel.cn) und das Kontingentsystem.
Für agentenbasierte Anwendungen, in denen das Modell viele Tool-Aufrufe über längere Sitzungen ausführt, ist GLM-5.1 aufgrund seiner Langzeitoptimierung besonders geeignet. Setzen Sie auf automatisierte Tests mit Apidogs Smart Mock und Test-Szenarien, um Integrationsfehler frühzeitig zu erkennen.
Weitere Hintergrundinfos zu GLM-5.1 und Benchmarks finden Sie in der GLM-5.1 Modellübersicht. Details zu KI-Agenten-Workflows und Testen mit Apidog: wie das Gedächtnis von KI-Agenten funktioniert.
FAQ
Ist die GLM-5.1 API OpenAI-kompatibel?
Ja. Das Anfrageformat, die Antwortstruktur, das Streaming-Protokoll und das Tool-Aufruf-Format sind identisch mit der OpenAI Chat Completions API. Sie können das offizielle OpenAI Python SDK oder jeden OpenAI-kompatiblen Client verwenden, indem Sie die Basis-URL auf https://open.bigmodel.cn/api/paas/v4/ setzen.
Welchen Modellnamen soll ich in API-Anfragen verwenden?
Verwenden Sie "glm-5.1" als Modellnamen. Verwenden Sie keinen vollständigen Versionsnamen; glm-5.1 funktioniert.
Wie funktioniert die Preisgestaltung der GLM-5.1 API?
Die BigModel API verwendet ein Kontingentsystem. GLM-5.1 verbraucht das 3-fache Kontingent während der Spitzenzeiten (14:00-18:00 UTC+8) und das 2-fache in Nebenzeiten. Bis Ende April 2026 wird die Nutzung in Nebenzeiten mit dem 1-fachen Kontingent als Aktionspreis abgerechnet.
Was ist die maximale Kontextlänge?
200.000 Tokens Eingabekontext. Die maximale Ausgabe beträgt 163.840 Tokens. Für lange agentenbasierte Läufe setzen Sie max_tokens auf einen großen Wert (32.768 oder höher), um zu vermeiden, dass die Ausgabe des Modells mitten in der Aufgabe abgeschnitten wird.
Kann ich GLM-5.1 für Funktionsaufrufe / Tool-Nutzung verwenden?
Ja. GLM-5.1 unterstützt das gleiche Tool-Aufruf-Format wie die OpenAI API. Definieren Sie Tools mit einem type: "function" Schema, übergeben Sie sie im tools Array und behandeln Sie finish_reason: "tool_calls" Antworten in Ihrem Agenten-Loop.
Wie teste ich GLM-5.1 API-Aufrufe, ohne Kontingent zu verbrauchen?
Verwenden Sie Apidogs Smart Mock, um Mock-Antworten für jeden API-Zustand zu definieren: Erfolg, Tool-Aufrufe, Ratenbegrenzungen, Fehler. Führen Sie Ihre Testsuite während der Entwicklung gegen den Mock aus und verwenden Sie die echte API nur zur endgültigen Validierung.
Wo finde ich die Modellgewichte von GLM-5.1?
Die Open-Source-Gewichte finden Sie auf HuggingFace unter zai-org/GLM-5.1. Sie werden unter der MIT-Lizenz veröffentlicht und unterstützen vLLM und SGLang für die lokale Inferenz.
Top comments (0)