Dieser Schnellstart zeigt, wie du GLM 5.2 auf Novita AI über die OpenAI-kompatible Chat-Completions-API aufrufst. Verwende die verifizierte Modell-ID zai-org/glm-5.2, die Novita AI Basis-URL und eine kleine erste Anfrage, bevor du das 1.048.576-Token-Kontextfenster, die maximale Ausgabe von 131.072 Token, Function Calling, strukturierte Ausgaben, Reasoning-Unterstützung oder den Anthropic-kompatiblen Zugang testest, die in der aktuellen Modellliste aufgeführt sind.
Voraussetzungen für den GLM 5.2 API Schnellstart
GLM 5.2 ist das Flaggschiff-Modell von Z.AI für langfristige autonome Arbeit. Die Novita AI Modellseite beschreibt es als ein Modell, das für anhaltende Aufgaben wie Planung, Ausführung, iterative Optimierung, Codierung und die Bereitstellung produktionsreifer Ergebnisse entwickelt wurde. Für Entwickler ist der praktische Punkt einfach: GLM 5.2 ist nicht nur ein weiteres Kurzchat-Modell. Es ist für Workflows positioniert, bei denen das Modell genügend Kontext benötigt, um eine große Aufgabe, eine Codebasis, einen Dokumentsatz oder einen Agentenzustand im Blick zu behalten.
Auf Novita AI wird GLM 5.2 über serverlose Modell-APIs bereitgestellt. Das ist wichtig, wenn du das Modell evaluieren möchtest, ohne GPU-Infrastruktur aufzusetzen, Traffic durch einen benutzerdefinierten Inferenz-Stack zu leiten oder selbst Long-Context-Serving zu verwalten. Du verwendest den API-Key von Novita AI, den OpenAI-kompatiblen Endpunkt und die exakte Modell-ID:
zai-org/glm-5.2
Die aktuelle Novita AI LLM API Anleitung dokumentiert den OpenAI-kompatiblen Ansatz der Plattform für Chat- und Completion-Aufgaben. Die Chat-Completions-API-Referenz dokumentiert den REST-Pfad, der in den folgenden Beispielen verwendet wird:
https://api.novita.ai/openai/v1/chat/completions
Verwende die Modellseite für modellspezifische Details wie Kontextlänge, maximale Ausgabe, Preise, Modalitäten und unterstützte Endpunktfamilien. Verwende die API-Referenz für Anfrageparameter, Authentifizierung, Streaming und die Struktur von Chat-Nachrichten.
GLM 5.2 API-Spezifikationen und Preise
Die aktuelle Novita AI Auflistung für GLM 5.2 zeigt ein serverloses Text-in, Text-out-Modell mit Long-Context- und agentenorientierten Feature-Unterstützung.
| Feld | Aktueller Novita AI Wert |
|---|---|
| Anzeigename | GLM 5.2 |
| API-Modell-ID | zai-org/glm-5.2 |
| Zugriffspfad | Serverlos |
| Kontextfenster | 1.048.576 Tokens |
| Maximale Ausgabe | 131.072 Tokens |
| Eingabe-Modalitäten | Text |
| Ausgabe-Modalitäten | Text |
| Endpunktfamilien | chat/completions, Anthropic-kompatibler Endpunkt |
| Function Calling | Unterstützt |
| Strukturierte Ausgaben | Unterstützt |
| Reasoning | Unterstützt |
| Eingabepreis | 1,40 $ pro Million Tokens |
| Preis für gecachte Eingabe | 0,26 $ pro Million Tokens |
| Ausgabepreis | 4,40 $ pro Million Tokens |
Die Preise sind pro Million Tokens angegeben. Für eine schnelle Schätzung multipliziere die Prompt-Tokens mit dem Eingabesatz und die generierten Tokens mit dem Ausgabesatz. Der Preis für gecachte Lesevorgänge kann die Kosten senken, wenn deine Anwendung wiederholt denselben wiederverwendbaren Kontext sendet, z. B. einen System-Prompt, ein Tool-Schema, einen Richtlinienblock oder eine stabile Repository-Zusammenfassung.
Zum Beispiel würde eine Anfrage mit 100.000 ungecachten Eingabe-Tokens und 5.000 Ausgabe-Tokens wie folgt geschätzt:
| Komponente | Berechnung | Geschätzte Kosten |
|---|---|---|
| Eingabe | 0,1 Millionen Tokens x 1,40 $ | 0,14 $ |
| Ausgabe | 0,005 Millionen Tokens x 4,40 $ | 0,022 $ |
| Gesamt | Eingabe + Ausgabe | 0,162 $ |
Dies ist nur eine einfache Token-Raten-Schätzung. Die Produktionskosten hängen auch von der Wiederverwendung von Prompts, Wiederholungen, Kürzungen, Streaming-Verhalten, Antwortlänge und davon ab, ob deine Anwendung wiederholt große Kontextblöcke einschließt, die zwischengespeichert oder zusammengefasst werden könnten.
So stellst du deine erste GLM 5.2 API-Anfrage
Beginne mit einem kleinen Prompt, bevor du das volle 1M-Token-Kontextfenster testest. Das gibt dir eine saubere Ausgangsbasis für Authentifizierung, Modell-Routing, Antwortform und Latenz.
Installiere das OpenAI Python SDK und speichere deinen Novita AI Key in einer Umgebungsvariable:
pip install openai
export NOVITA_API_KEY="DEIN_NOVITA_API_KEY"
Rufe dann GLM 5.2 mit der Novita AI Basis-URL auf:
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["NOVITA_API_KEY"],
base_url="https://api.novita.ai/openai",
)
response = client.chat.completions.create(
model="zai-org/glm-5.2",
messages=[
{
"role": "system",
"content": "Du bist ein praktischer Assistent für Softwarearchitektur.",
},
{
"role": "user",
"content": "Überprüfe diesen Migrationsplan und liste die risikoreichsten Schritte auf.",
},
],
max_tokens=1200,
temperature=0.3,
)
print(response.choices[0].message.content)
Wenn du einen direkten REST-Aufruf bevorzugst, verwende den Chat-Completions-Pfad:
curl --request POST \
--url https://api.novita.ai/openai/v1/chat/completions \
--header "Authorization: Bearer $NOVITA_API_KEY" \
--header "Content-Type: application/json" \
--data '{
"model": "zai-org/glm-5.2",
"messages": [
{
"role": "system",
"content": "Du bist ein präziser technischer Prüfer."
},
{
"role": "user",
"content": "Erstelle eine Checkliste für das Release-Risiko bei einer Änderung der Payment-API."
}
],
"max_tokens": 1200,
"temperature": 0.3
}'
Für längere Antworten aktiviere Streaming, damit deine Anwendung Token empfangen kann, bevor die vollständige Antwort abgeschlossen ist:
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["NOVITA_API_KEY"],
base_url="https://api.novita.ai/openai",
)
stream = client.chat.completions.create(
model="zai-org/glm-5.2",
messages=[
{
"role": "user",
"content": "Entwirf einen schrittweisen Plan zur Umstrukturierung eines Monolithen in Dienste.",
}
],
max_tokens=2000,
temperature=0.3,
stream=True,
)
for chunk in stream:
delta = chunk.choices[0].delta.content
if delta:
print(delta, end="")
Halte API-Keys außerhalb der Versionskontrolle, setze explizite max_tokens-Werte und protokolliere Nutzungsdaten, wenn verfügbar. Long-Context-Modelle machen es einfach, sehr große Prompts zu senden, daher beginnt die Kostenkontrolle mit der Messung von Prompt- und Completion-Tokens ab dem ersten Prototyp.
Wann du GLM 5.2 verwenden solltest
GLM 5.2 ist eine gute Wahl, wenn deine Aufgabe zu umfangreich für einen normalen Chat-Kontext ist oder wenn das Modell mehrere Schritte mit Tools, Dateien oder strukturierten Ausgaben koordinieren muss.
Gute Evaluierungsziele sind:
- Repository-Analyse: Bitte das Modell, Architekturnotizen, Dateizuordnungen, Abhängigkeitsbeschreibungen und ausgewählte Code-Auszüge in einer Anfrage zu überprüfen.
- Codierungsagenten: Behalte Aufgabenziele, Einschränkungen, Tool-Schemata, frühere Entscheidungen und Arbeitsnotizen im Kontext, während der Agent iteriert.
- Synthese langer Dokumente: Fasse Richtlinien, technische Spezifikationen, Verträge, Forschungsnotizen oder Produktdokumente ohne aggressive Aufteilung zusammen.
- Migrationsplanung: Gib dem Modell eine Systemkarte, Einschränkungen, Rollout-Plan und Risikoregister und frage nach Lücken oder Sequenzierungsproblemen.
- Strukturierte Extraktion: Kombiniere lange Quelldokumente mit einem strengen JSON-Schema für nachgelagerte Systeme.
GLM 5.2 ist nicht automatisch das richtige Modell für jede Anfrage. Für kurze Klassifikation, einfachen Chat, einfache Extraktion oder hohes Volumen mit niedriger Latenz vergleiche kleinere Modelle in der Novita AI Modellbibliothek und die aktuellen Preise auf der Novita AI Preisseite. Ein 1M-Token-Modell ist am wertvollsten, wenn du den Kontext, die Ausgabebegrenzung oder die agentenorientierten Funktionen tatsächlich benötigst.
Function Calling und strukturierte Ausgaben
Die GLM 5.2 Auflistung zeigt die Unterstützung von Function Calling und strukturierten Ausgaben. Diese Funktionen sind nützlich, wenn das Modell etwas zurückgeben soll, mit dem deine Anwendung arbeiten kann, nicht nur Fließtext.
Function Calling eignet sich gut, wenn deine Anwendung kontrollierte Tools wie die folgenden bereitstellt:
- Abrufen eines Kundenrecords,
- Erstellen eines Tickets,
- Überprüfen des Deployment-Status,
- Durchsuchen einer internen Wissensdatenbank,
- Berechnen eines Angebots,
- oder Weiterleiten einer Anfrage an einen spezialisierten Dienst.
Hier ist ein minimales Muster für Tool-Aufrufe:
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["NOVITA_API_KEY"],
base_url="https://api.novita.ai/openai",
)
tools = [
{
"type": "function",
"function": {
"name": "create_release_ticket",
"description": "Erstelle ein Release-Ticket nach der Risikoprüfung.",
"parameters": {
"type": "object",
"properties": {
"title": {"type": "string"},
"risk_level": {
"type": "string",
"enum": ["low", "medium", "high"],
},
"summary": {"type": "string"},
},
"required": ["title", "risk_level", "summary"],
},
},
}
]
response = client.chat.completions.create(
model="zai-org/glm-5.2",
messages=[
{
"role": "user",
"content": "Bewerte dieses Release und erstelle ein Ticket, wenn das Risiko mittel oder hoch ist.",
}
],
tools=tools,
tool_choice="auto",
max_tokens=1000,
)
print(response.choices[0].message)
Strukturierte Ausgaben sind nützlich, wenn die Antwort in ein vorhersagbares Schema passen soll. Auch wenn du nach JSON fragst, behalte die Validierung in deiner Anwendung. Behandle die Ausgabe des Modells als generierten Kandidaten, parse sie, validiere erforderliche Felder und behandle Fehler mit einem Reparatur-Prompt oder einem Fallback-Pfad.
Weitere Hintergrundinformationen zum Tool-Design findest du im Novita AI Leitfaden zu Function Calling und strukturierten Ausgaben und im GLM-spezifischen Leitfaden zu GLM Function Calling.
Produktionshinweise zur Nutzung langer Kontexte
Das angegebene Kontextfenster ist die Obergrenze, nicht der Standardbetriebsmodus. Eine Anfrage mit 1.048.576 Tokens kann nützlich sein, aber die meisten Anwendungen sollten sich schrittweise auf diese Größe vorarbeiten.
Beginne mit diesen Kontrollen:
- Budgetiere den Prompt: Teile stabile Anweisungen, volatile Benutzereingaben, Abrufergebnisse und Tool-Schemata auf, damit du sehen kannst, welcher Teil die Token-Anzahl bestimmt.
- Verwende Retrieval vor dem vollständigen Einfügen: Sende zuerst die relevantesten Dateien oder Passagen, erweitere den Kontext dann nur, wenn die Aufgabe weitere Belege benötigt.
- Begrenze die Ausgabelänge: GLM 5.2 unterstützt eine hohe maximale Ausgabe, aber die meisten Workflows benötigen keine 131.072 generierten Tokens. Setze
max_tokensauf den kleinsten nützlichen Wert. - Stream lange Antworten: Streaming verbessert die Benutzererfahrung und ermöglicht es deinem Dienst, lange Antworten eleganter zu verarbeiten.
- Validiere strukturierte Ergebnisse: Schemata reduzieren Mehrdeutigkeiten, aber deine Anwendung benötigt dennoch Parser-Prüfungen, Wiederholungen und klare Fehlerbehandlung.
- Verfolge Cache-Möglichkeiten: Wiederholte Kontextblöcke können teuer sein, wenn sie jedes Mal als frische Eingabe gesendet werden. Identifiziere frühzeitig wiederverwendbare Prompts, Richtlinien und Tool-Definitionen.
- Halte einen Fallback mit einem kleineren Modell bereit: Viele Routing-Systeme verwenden ein kleineres Modell für einfache Fälle und reservieren Long-Context-Modelle für Aufgaben, die ihre volle Kapazität benötigen.
Für Codierungsagenten besteht ein praktisches Muster darin, dauerhaften Projektkontext außerhalb des Prompts zu halten, nur die für die aktuelle Aufgabe relevanten Dateien abzurufen und GLM 5.2 zu bitten, einen begrenzten Plan oder eine Patch-Überprüfung zu erstellen, anstatt einen offenen Aufsatz zu verfassen. Dies hält die Kosten nachvollziehbar, während das Modell dennoch genügend Kontext erhält, um über die relevanten Teile des Systems zu argumentieren.
Häufig gestellte Fragen
Ist GLM 5.2 auf Novita AI verfügbar?
Ja. GLM 5.2 ist auf Novita AI als serverloses Modell mit der API-Modell-ID zai-org/glm-5.2 aufgeführt.
Wie groß ist das Kontextfenster von GLM 5.2 auf Novita AI?
Die aktuelle Novita AI Auflistung zeigt ein Kontextfenster von 1.048.576 Tokens für GLM 5.2.
Wie groß ist die maximale Ausgabe von GLM 5.2?
Die aktuelle Novita AI Auflistung zeigt eine maximale Ausgabe von 131.072 Tokens für GLM 5.2. Setze einen kleineren max_tokens-Wert, es sei denn, dein Workflow benötigt wirklich eine sehr lange Antwort.
Wie viel kostet GLM 5.2 auf Novita AI?
Die aktuelle Preisseite listet GLM 5.2 mit 1,40 $ pro Million Eingabe-Tokens, 0,26 $ pro Million gecachter Lese-Eingabe-Tokens und 4,40 $ pro Million Ausgabe-Tokens.
Unterstützt GLM 5.2 Function Calling?
Ja. Die aktuelle GLM 5.2 Auflistung zeigt die Unterstützung von Function Calling. Verwende es, wenn das Modell aus kontrollierten Anwendungstools wählen soll, anstatt nur natürlichsprachlichen Text zurückzugeben.
Unterstützt GLM 5.2 strukturierte Ausgaben?
Ja. Die aktuelle GLM 5.2 Auflistung zeigt die Unterstützung strukturierter Ausgaben. Validiere generierte JSON- oder schemaförmige Antworten in deiner Anwendung, bevor du sie nachgelagert verwendest.
