Voordat je iets uitvoert
Je hebt een sleutel nodig en verder niets. Maak er een aan op de API key-pagina; nieuwe accounts kunnen met één klik $0,50 aan trial credit claimen, zonder kaart. Exporteer deze zodat de voorbeelden deze kunnen lezen:
export API_KEY="YOUR_KEY"
pip install openai
npm install openai
De API volgt het OpenAI chat completions-formaat. Het exposeert POST /v1/chat/completions en GET /v1/models, accepteert Authorization: Bearer, en serveert één model met de ID uncensored. Dit model is een open-weight model dat wordt uitgevoerd door een onafhankelijke provider en is afgestemd op het geven van antwoorden zonder content refusals voor legaal gebruik door volwassenen. Het is niet de officiële API van een modelvendor. Het verwerkt alleen tekst: geen afbeeldingen, audio, embeddings of fine-tuning.
De voorbeelden hieronder gaan van het eenvoudigste verzoek tot function calling. Als je alleen de kortst mogelijke test nodig hebt om te controleren of je sleutel werkt, is het eerste curl-commando genoeg.
Een eerste verzoek met curl, en de parameters die ertoe doen
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
}'
Het antwoord is een JSON-object met choices[0].message.content dat het antwoord bevat en een usage-object met prompt_tokens en completion_tokens. De antwoordheaders bevatten X-Request-Id, X-Balance-USD en de twee X-RateLimit-Limit-headers. Voeg -i toe aan curl om ze te zien.
De velden temperature, top_p, stop, seed en de presence en frequency penalties worden doorgegeven aan het model. max_tokens is optioneel. Zonder dit veld kan de completion wat er overblijft van het 100.000-token contextvenster na je prompt gebruiken.
De chat completions body heeft veel optionele velden, maar vijf doen het meeste werk. Allemaal worden ze doorgegeven aan het model.
| Veld | Wat het doet | Typisch gebruik |
|---|---|---|
temperature | Hogere waarden geven meer gevarieerde wording | 0,2 voor extractie, 0,8 voor fictie |
top_p | Beperkt sampling tot de meest waarschijnlijke tokens | Laat op standaard staan tenzij je het afstelt |
stop | Beëindigt het antwoord wanneer een string verschijnt | Afsnijden bij een delimiter zoals een lege regel |
seed | Maakt sampling repeatable op een best-effort basis | Vergelijken van twee promptversies |
presence_penalty, frequency_penalty | Ontmoedigen van het herhalen van tokens | Kleine waarden zoals 0,3 wanneer tekst loopt |
Verander één waarde tegelijk en houd de prompt hetzelfde, anders kun je niet zeggen welke verandering hielp. Voor alles wat code verwerkt, zoals classificatie of extractie, gebruik je een lage temperature en een vaste seed zodat je een test kunt herhalen en hetzelfde resultaat ziet. Voor creatief schrijven verhoog je de temperature en laat je de penalties repetition afhandelen.
Het veld max_tokens is hier optioneel. Als je het weglaat, kan het antwoord alle ruimte in het 100.000-token contextvenster gebruiken, wat zelden is wat je wilt voor een één-regel antwoord. Stel het in wanneer je weet hoe lang het antwoord moet zijn.
Python: een gesprek met geheugen
De API is stateless, dus je houdt het gesprek zelf bij en stuurt het elke keer. Deze lus houdt een lijst van berichten bij en voegt beide kanten toe:
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)
Omdat elke call de volledige lijst opnieuw stuurt, groeien input tokens met de lengte van het gesprek. Bij $0,15 per 1M input tokens is dat goedkoop, maar het loopt op in lange sessies, dus verwijder oude berichten zodra de thread de grootte passeert waar je voor wilt betalen. De prijzenpagina heeft werkvoorbeelden.
Streaming in Python en Node
Stel stream: true in en de server stuurt tokens zodra ze geproduceerd zijn, via 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)
De stream eindigt met usage informatie, daarom controleert de lus hierop. Hetzelfde 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 ?? "");
}
Eén detail over limits: een gestreamd verzoek houdt zijn concurrency slot vast tot de stream eindigt. Als je een stream start en nooit leest tot het einde, blijft dat slot bezet. Gebruik de stream altijd op of sluit hem.
JSON-modus voor gestructureerde output
Wanneer je code het antwoord moet parseren, vraag dan een JSON-object aan met response_format. Zeg ook in de prompt welke structuur je wilt, omdat het format-flag geldige JSON-syntax garandeert, niet jouw specifieke 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"])
Controleer of de keys die je nodig hebt bestaan voordat je ze gebruikt, en houd de temperature laag voor extractiewerk. Als een parse faalt, werkt een keer opnieuw proberen met dezelfde input meestal wel, en gefaalde requests worden niet in rekening gebracht.
Tool calling: een volledige round trip
Tool calling laat het model je code een functie laten uitvoeren. Je beschrijft de functie in tools, het model antwoordt met een tool_calls entry, je voert het uit en stuurt het resultaat terug als een role: "tool" bericht.
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)
De functie hier retourneert vaste data, dus vervang dit door een echte lookup. Tool arguments komen aan als een JSON-string, dus parse ze altijd en valideer de waarden voordat je actie onderneemt. Met stream: true komen de tool_calls in stukken aan die je assembleert voordat je parseert. Gebruik tool_choice om een specifieke tool af te dwingen als je dat nodig hebt.
Wat de voorbeelden kosten, en fouten die een uur kosten
Voorbeelden uitvoeren kost zeer weinig, maar het helpt om de rekenkunde een keer te zien. Bij $0,15 per 1M input tokens en $0,50 per 1M output tokens:
- De gesprekslus, met een prompt van 1.200 tokens en een antwoord van 300 tokens: $0,00018 voor input plus $0,00015 voor output is $0,00033. Duizend beurten kosten $0,33.
- De tool round trip maakt twee calls. Als de eerste 400 tokens in en 60 out gebruikt, en de tweede 500 in en 150 out, zijn de totalen 900 in en 210 out: $0,000135 plus $0,000105 is $0,00024.
- Streaming kost hetzelfde als een normale call met dezelfde token counts. Het verandert wanneer je de tekst ziet, niet wat het kost.
De trial credit van $0,50 zou meer dan 1.500 beurten van de conversation loop kunnen betalen bij die grootte ($0,50 / $0,00033), dus je kunt vrij experimenteren voordat je tegoed oplaadt. Gefaalde en geweigerde requests worden niet in rekening gebracht, wat betekent dat een bug in je parsing die je laat een call opnieuw uitvoert, je niet kost voor de gefaalde pogingen.
- Een verkeerde base URL. Deze moet eindigen in
/v1. Het zelf toevoegen van/chat/completionsaan een SDK base URL geeft een 404 omdat de SDK het pad toevoegt. - Een andere modelnaam. Namen gekopieerd van andere platforms bestaan hier niet. De ID is
uncensored. - Geheugen verwachten. De API onthoudt eerdere calls niet. Stuur de history elke keer.
- De JSON van het model parseren zonder controle. Wrap
json.loadsin een try-blok en heb een plan voor een slecht antwoord. - Streams open laten lopen. Een onafgemaakte stream houdt een concurrency slot bezet, en een trial key heeft er maar twee.
- De sleutel in front-end code plaatsen. Houd deze op een server.
Als er nog steeds iets vreemd lijkt, stuur dan een verzoek met curl en vergelijk het met wat je code produceert. De curl-vorm haalt de SDK uit de vergelijking en maakt verschillen in de body duidelijk.
Gebruik, saldo en fouten lezen
Om headers van de Python SDK te zien, gebruik je de 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)
Log de request ID bij elke call zodat je later naar een specifiek verzoek kunt verwijzen. Gebruik de balance header om een alert te genereren voordat het tegoed op is.
Wanneer je een limiet overschrijdt, retourneert de API HTTP 429 en de error code vertelt je welke het is:
| Code of header | Wat te doen | Wat te doen |
|---|---|---|
rate_limited | Te veel verzoeken per minuut (300 op een volledige key, 60 op trial) | Back off en spreid je calls uit |
concurrency | Te veel in één keer (8 op een volledige key, 2 op trial) | Wacht tot een lopend verzoek klaar is |
Retry-After: 5 | Tijdelijke overbelasting | Probeer het opnieuw na vijf seconden |
Mislukte of geweigerde verzoeken worden niet in rekening gebracht. De request body kan maximaal 8 MB zijn. Voor de complete referentie en hoe je bestaande client code kunt hergebruiken, zie de docs. Voor een walkthrough over het verkrijgen van een key, zie het GLM API key artikel.
