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.
| Feld | Was es tut | Typische Verwendung |
|---|---|---|
temperature | Höhere Werte ergeben abwechslungsreichere Formulierungen | 0,2 für Extraktion, 0,8 für Fiktion |
top_p | Begrenzt die Abtastung auf die wahrscheinlichsten Token | Auf Standard belassen, es sei denn, du stimmst es ab |
stop | Beendet die Antwort, wenn eine Zeichenfolge erscheint | Abbruch bei einem Trennzeichen wie einer Leerzeile |
seed | Macht das Sampling auf Best-Effort-Basis wiederholbar | Vergleichen von zwei Prompt-Versionen |
presence_penalty, frequency_penalty | Vermeidet das Wiederholen von Token | Kleine 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
/v1enden. Wenn du/chat/completionsmanuell 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.loadsin 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 Header | Was zu tun ist | Was zu tun ist |
|---|---|---|
rate_limited | Zu viele Anfragen pro Minute (300 auf einem Voll-Key, 60 im Test) | Warte ab und verteile die Aufrufe |
concurrency | Zu viele gleichzeitig (8 auf einem Voll-Key, 2 im Test) | Warte, bis eine laufende Anfrage abgeschlossen ist |
Retry-After: 5 | Vorübergehende Überlastung | Warte 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.
