DE ▾
API-Schlüssel erhalten

GLM-API-Beispiele: Python, JSON-Modus und Streaming

Diese GLM-API-Beispiele laufen alle gegen einen OpenAI-kompatiblen Endpunkt, mit der Base URL https://api.glmapikey.com/v1 und dem Modell uncensored. Jedes Snippet ist kurz und eigenständig, sodass du es einfügen, deinen Schlüssel hinzufügen und ausführen kannst.

Aktualisiert

Terminalfenster mit Streaming glühender Datentokens an einen Cloud-Server, veranschaulicht API-Code-Beispiele

Wichtige Punkte

  • Jedes Beispiel verwendet die Base URL https://api.glmapikey.com/v1, Bearer-Authentifizierung und die Modell-ID uncensored.
  • Streaming, JSON-Modus und Function Calling werden alle am selben Chat-Completion-Endpunkt unterstützt.
  • Lies X-Balance-USD und den Nutzungsbereich, um die Ausgaben pro Aufruf zu verfolgen.
  • Behandle 429 per Code: rate_limited, Parallelitätsgrenze oder Retry-After: 5 Überlastung.

Bevor du irgendetwas ausführst

Du brauchst nur einen Schlüssel. Erstelle ihn auf der API-Schlüssel-Seite; neue Konten können mit einem Klick $0,50 Testguthaben beanspruchen, ohne Karte. Exportiere ihn, damit die Beispiele ihn lesen können:

export API_KEY="YOUR_KEY"
pip install openai
npm install openai

Die API folgt dem OpenAI-Chat-Completion-Format. Sie stellt POST /v1/chat/completions und GET /v1/models zur Verfügung, akzeptiert Authorization: Bearer und bedient ein einzelnes Modell mit der ID uncensored. Dieses Modell ist ein Open-Weight-Modell, das von einem unabhängigen Anbieter betrieben wird und darauf abgestimmt ist, ohne Inhaltsablehnungen für die rechtmäßige Nutzung durch Erwachsene zu antworten. Es ist nicht die offizielle API eines Modell-Anbieters. Es verarbeitet nur Text: keine Bilder, Audio, Embeddings oder Fine-Tuning.

Die folgenden Beispiele reichen von der einfachsten Anfrage bis zum Function Calling. Wenn du nur die kürzestmögliche Prüfung benötigst, ob dein Schlüssel funktioniert, reicht der erste curl-Befehl.

Eine erste Anfrage mit curl und die relevanten Parameter

curl https://api.glmapikey.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise assistant."},
      {"role": "user", "content": "What is a mutex, in one sentence?"}
    ],
    "temperature": 0.3,
    "max_tokens": 80
  }'

Die Antwort ist ein JSON-Objekt mit choices[0].message.content, das die Antwort enthält, und einem usage-Objekt mit prompt_tokens und completion_tokens. Die Antwort-Header enthalten X-Request-Id, X-Balance-USD und die beiden X-RateLimit-Limit-Header. Füge -i zu curl hinzu, um sie zu sehen.

Die Felder temperature, top_p, stop, seed und die Präsenz- und Häufigkeitsstrafen werden an das Modell weitergegeben. max_tokens ist optional. Ohne ihn kann die Vervollständigung alles verwenden, was im 100.000-Token-Fenster nach deinem Prompt noch übrig ist.

Der Chat-Completion-Body hat viele optionale Felder, aber fünf erledigen den Großteil der Arbeit. Alle werden an das Modell weitergegeben.

FeldWas es tutTypische Verwendung
temperatureHöhere Werte ergeben abwechslungsreichere Formulierungen0,2 für Extraktion, 0,8 für Fiktion
top_pBegrenzt die Abtastung auf die wahrscheinlichsten TokenAuf Standard belassen, es sei denn, du stimmst es ab
stopBeendet die Antwort, wenn eine Zeichenfolge erscheintAbbruch bei einem Trennzeichen wie einer Leerzeile
seedMacht das Sampling auf Best-Effort-Basis wiederholbarVergleichen von zwei Prompt-Versionen
presence_penalty, frequency_penaltyVermeidet das Wiederholen von TokenKleine Werte wie 0,3 bei Text-Schleifen

Ändere immer nur einen Wert und behalte den Prompt bei, sonst weißt du nicht, welche Änderung geholfen hat. Für alles, was Code liefert, wie Klassifizierung oder Extraktion, verwende eine niedrige Temperatur und einen festen Seed, damit du einen Test wiederholen und das gleiche Ergebnis sehen kannst. Für kreatives Schreiben erhöhe die Temperatur und lass die Strafen die Wiederholung handhaben.

Das Feld max_tokens ist hier optional. Wenn du es weglässt, kann die Antwort den gesamten im 100.000-Token-Fenster verbleibenden Platz nutzen, was für eine einzeilige Antwort selten gewünscht ist. Setze es, wenn du weißt, wie lang die Antwort sein soll.

Python: Ein Gespräch mit Speicher

Die API ist zustandslos, also führst du das Gespräch selbst und sendest es jedes Mal. Diese Schleife hält eine Liste von Nachrichten und hängt beide Seiten an:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.glmapikey.com/v1",
    api_key="YOUR_KEY",
)

messages = [{"role": "system", "content": "You are a helpful assistant."}]

while True:
    user = input("you> ")
    if not user:
        break
    messages.append({"role": "user", "content": user})
    resp = client.chat.completions.create(model="uncensored", messages=messages)
    reply = resp.choices[0].message.content
    messages.append({"role": "assistant", "content": reply})
    print("bot>", reply)

Da jeder Aufruf die vollständige Liste sendet, wachsen die Input-Token mit der Länge des Chats. Bei $0,15 pro 1M Input-Token ist das günstig, aber es summiert sich in langen Sessions, also lösche alte Nachrichten, sobald der Thread die Größe überschreitet, für die du zahlen willst. Die Preisseite hat funktionierende Beispiele.

Streaming in Python und Node

Setze stream: true und der Server sendet Token, sobald sie erzeugt werden, über Server-Sent-Events. In Python:

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write four lines about the sea."}],
    stream=True,
)

text = ""
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        piece = chunk.choices[0].delta.content
        text += piece
        print(piece, end="", flush=True)
    if getattr(chunk, "usage", None):
        print("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)

Der Stream endet mit Nutzungsinformationen, weshalb die Schleife danach sucht. Dasselbe in Node:

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.glmapikey.com/v1",
  apiKey: process.env.API_KEY,
});

const stream = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Write four lines about the sea." }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

Ein Detail zu Limits: Eine gestreamte Anfrage belegt ihren Concurrency-Slot, bis der Stream endet. Wenn du einen Stream startest und ihn nie bis zum Ende liest, bleibt dieser Slot belegt. Konsumiere oder schließe den Stream immer.

JSON-Modus für strukturierte Ausgaben

Wenn dein Code die Antwort parsen muss, fordere ein JSON-Objekt mit response_format an. Sage im Prompt auch, welche Struktur du willst, weil das Format-Flag gültige JSON-Syntax garantiert, nicht dein spezifisches Schema.

import json

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply only with JSON: {\"title\": string, \"tags\": [string]}."},
        {"role": "user", "content": "Suggest a title and three tags for a post about home espresso."},
    ],
    temperature=0.2,
)

data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])

Prüfe, ob die benötigten Schlüssel existieren, bevor du sie verwendest, und halte die Temperatur für Extraktionsarbeiten niedrig. Wenn eine Analyse fehlschlägt, funktioniert ein einmaliger Retry mit denselben Eingabedaten meist, und fehlgeschlagene Anfragen werden nicht berechnet.

Function Calling: Ein vollständiger Roundtrip

Function Calling ermöglicht es dem Modell, deinen Code aufzurufen, um eine Funktion auszuführen. Du beschreibst die Funktion in tools, das Modell antwortet mit einem tool_calls-Eintrag, du führst sie aus und sendest das Ergebnis als role: "tool"-Nachricht zurück.

import json

def get_weather(city: str) -> dict:
    return {"city": city, "temp_c": 18, "sky": "cloudy"}

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

messages = [{"role": "user", "content": "Is it warm in Lisbon right now?"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)
msg = first.choices[0].message

if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(get_weather(**args)),
        })
    final = client.chat.completions.create(
        model="uncensored", messages=messages, tools=tools
    )
    print(final.choices[0].message.content)
else:
    print(msg.content)

Die Funktion hier gibt feste Daten zurück, also tausche sie gegen eine echte Suche aus. Tool-Argumente kommen als JSON-String an, also parse sie immer und validiere die Werte, bevor du darauf reagierst. Mit stream: true kommen die tool_calls in Stücken, die du zusammenstellen musst, bevor du sie parst. Verwende tool_choice, um ein bestimmtes Tool zu erzwingen, wenn du das brauchst.

Was die Beispiele kosten und Fehler, die eine Stunde kosten

Beispiele auszuführen kostet wenig, aber es hilft, die Rechnung einmal zu sehen. Bei $0,15 pro 1M Input-Token und $0,50 pro 1M Output-Token:

  • Der Gesprächskreislauf, mit einem 1.200-Token-Prompt und einer 300-Token-Antwort: $0,00018 für Input plus $0,00015 für Output ergibt $0,00033. Tausend Gesprächsrunden kosten $0,33.
  • Der Tool-Roundtrip macht zwei Aufrufe. Wenn der erste 400 Token Input und 60 Output verbraucht und der zweite 500 Input und 150 Output, sind die Gesamtsummen 900 Input und 210 Output: $0,000135 plus $0,000105 ergibt $0,00024.
  • Streaming kostet dasselbe wie ein normaler Aufruf mit denselben Token-Anzahlen. Es ändert, wann du den Text siehst, nicht was es kostet.

Das Testguthaben von $0,50 würde mehr als 1.500 Durchgänge des Gesprächs-Loops bei dieser Größe bezahlen ($0,50 / $0,00033), also kannst du frei experimentieren, bevor du das Guthaben auflädst. Fehlgeschlagene und verweigerte Anfragen werden nicht berechnet, was bedeutet, dass ein Fehler in deinem Parser, der dich dazu bringt, einen Aufruf wiederholt auszuführen, dich die fehlgeschlagenen Versuche nichts kostet.

  • Eine falsche Basis-URL. Sie muss mit /v1 enden. Wenn du /chat/completions manuell zur Basis-URL eines SDK hinzufügst, erhältst du einen 404-Fehler, da das SDK den Pfad selbst hinzufügt.
  • Ein anderer Modellname. Namen, die von anderen Plattformen kopiert wurden, existieren hier nicht. Die ID ist uncensored.
  • Erwartung von Speicher. Die API erinnert sich nicht an frühere Aufrufe. Sende den Verlauf jedes Mal.
  • Das Parsen des JSON des Modells ohne Guard. Packe json.loads in einen try-Block und habe einen Plan für eine schlechte Antwort.
  • Offene Streams lassen. Ein unvollendeter Stream hält einen Concurrency-Slot belegt, und ein Test-Schlüssel hat nur zwei.
  • Den Schlüssel im Frontend-Code speichern. Behalte ihn auf einem Server.

Wenn noch etwas falsch aussieht, sende eine Anfrage mit curl und vergleiche sie mit dem, was dein Code erzeugt. Die curl-Variante entfernt das SDK aus dem Bild und macht Unterschiede im Body offensichtlich.

Nutzung, Guthaben und Fehler lesen

Um Header aus dem Python SDK zu sehen, verwende den Raw-Response-Wrapper:

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Say ok."}],
)
print("request id:", raw.headers.get("x-request-id"))
print("balance usd:", raw.headers.get("x-balance-usd"))
print("rpm limit:", raw.headers.get("x-ratelimit-limit-requests"))
completion = raw.parse()
print(completion.usage.total_tokens)

Logge die Request-ID bei jedem Aufruf, damit du später auf eine einzelne Anfrage verweisen kannst. Nutze den Balance-Header, um eine Warnung auszulösen, bevor das Guthaben aufgebraucht ist.

Wenn du ein Limit überschreitest, gibt die API HTTP 429 zurück, und der Error-Code sagt dir, welches es ist:

Code oder HeaderWas zu tun istWas zu tun ist
rate_limitedZu viele Anfragen pro Minute (300 auf einem Voll-Key, 60 im Test)Warte ab und verteile die Aufrufe
concurrencyZu viele gleichzeitig (8 auf einem Voll-Key, 2 im Test)Warte, bis eine laufende Anfrage abgeschlossen ist
Retry-After: 5Vorübergehende ÜberlastungWarte fünf Sekunden und versuche es erneut

Fehlgeschlagene oder verweigerte Anfragen werden nicht berechnet. Der Anfragekörper kann bis zu 8 MB groß sein. Für die vollständige Referenz und wie du bestehenden Client-Code wiederverwenden kannst, sieh dir die Dokumentation an. Für eine Anleitung, wie du einen Schlüssel erhältst, sieh dir den GLM-API-Schlüssel-Artikel an.

Fragen und Antworten

Welche Base URL verwenden die Beispiele?

Jedes Beispiel verwendet https://api.glmapikey.com/v1 mit der Modell-ID uncensored und einem Bearer-Token. Jedes OpenAI SDK funktioniert, sobald du diese Werte änderst.

Unterstützt die API Streaming?

Ja. Setze stream auf true und lese Server-Sent Events. Die Nutzung wird am Ende des Streams gemeldet.

Wie bekomme ich gültiges JSON zurück?

Übergebe response_format mit dem Typ json_object und beschreibe die gewünschte Struktur im Prompt. Analysiere das Ergebnis in deinem Code und prüfe die benötigten Keys.

Kann ich Function Calling verwenden?

Ja. Übergib tools und tool_choice, führe die vom Modell angeforderte Funktion aus und gib das Ergebnis als Nachricht mit der Rolle tool zurück.

Wo kann ich mein verbleibendes Guthaben sehen?

Jede Antwort enthält einen X-Balance-USD-Header mit deinem verbleibenden Guthaben, und der Usage-Block gibt die Token-Anzahlen an.

Dein Schlüssel ist nur ein Formular entfernt

Erstelle ein Konto, kopiere den Schlüssel, ändere die Basis-URL. Das ist die gesamte Einrichtung.

API-Schlüssel erhalten