Tokens, context en conversatievenster
Op deze pagina
Tokens, context en conversatievenster
De token is de eenheid die het model manipuleert en de eenheid waarop uw factuur gebaseerd is. Zolang dit concept vaag blijft, blijven uw kosten dat ook, en loopt u uiteindelijk tegen een contextlimietfout aan zonder te weten waarom. Deze les lost beide problemen op.
Wat is een token?
Een token is geen woord. Het is een tekstfragment dat het model als een ondeelbare eenheid behandelt. In het Frans staat één token gemiddeld voor ongeveer 0,7 woorden. De tiktoken-bibliotheek laat u precies zien hoe tekst wordt opgesplitst: merk op hoe “allez-vous” in twee tokens breekt, terwijl “aujourd’hui”, dat vaker voorkomt in de trainingscorpus, in één token past. Dit detail verklaart waarom een Franse tekst meer tokens verbruikt dan een even lange Engelse tekst.
from openai import OpenAI
client = OpenAI()
# Om tokens te schatten, gebruikt u de tiktoken-bibliotheek
import tiktoken
# cl200k_base wordt hier als voorbeeld gebruikt: elke modelgeneratie heeft zijn eigen encoder.
# Controleer de encoder voor het model dat u aanroept voordat u op de telling vertrouwt.
enc = tiktoken.get_encoding("cl200k_base")
texte = "Bonjour, comment allez-vous aujourd'hui ?"
tokens = enc.encode(texte)
print(f"Text: {texte}")
print(f"Number of tokens: {len(tokens)}")
print(f"Tokens: {tokens}")
print(f"Decoded: {[enc.decode([t]) for t in tokens]}")
# Resultaat:
# Text: Bonjour, comment allez-vous aujourd'hui ?
# Number of tokens: 9
# Tokens: [38025, 11, 4068, 67590, 5072, 76439, 30, ...]
# Decoded: ['Bonjour', ',', ' comment', ' allez', '-vous', " aujourd'hui", ' ?']
Controleer altijd welke encoder overeenkomt met het model dat u aanroept. Een telling uitgevoerd met de verkeerde encoder blijft een nuttige benadering, maar komt niet exact overeen met uw factuur.
Het contextvenster
Elk model heeft een maximaal contextvenster, en de valkuil voor beginners is dat dit zowel de input als de output omvat. Dit is geen inputbudget: het is een totaalbudget. Als uw prompt 190.000 tokens inneemt van een venster van 200.000 tokens, blijven er slechts 10.000 tokens over voor het antwoord. Het model zal midden in een zin afbreken zonder verdere waarschuwing.
# Vorige generatie, ter referentie:
# GPT-5.4: 1.000.000 contexttokens
# GPT-5.3: 200.000 contexttokens
# gpt-5.6-sol : 200.000 contexttokens
# gpt-5.6-terra : 200.000 contexttokens
# Voorbeeld: als uw input 190.000 tokens is in een venster van 200.000 tokens,
# blijven er slechts 10.000 tokens over voor het antwoord
response = client.responses.create(
model="gpt-5.6-terra",
input="A very long text...",
max_output_tokens=10000 # Expliciete limiet
)
Achteraf kunt u het exacte aantal aflezen in response.usage, dat onderscheid maakt tussen inputtokens, outputtokens en het totaal:
response = client.responses.create(
model="gpt-5.6-terra",
input="Explain tokens in three sentences."
)
usage = response.usage
print(f"Input tokens: {usage.input_tokens}")
print(f"Output tokens: {usage.output_tokens}")
print(f"Total: {usage.total_tokens}")
# Resultaat:
# Input tokens: 12
# Output tokens: 58
# Total: 70
Drie optimalisatiehefbomen
De eerste hefboom is beknoptheid van de prompt. Beleefdheidsformules en retorische voorzorgsmaatregelen verbeteren het antwoord niet en kosten tot op de laatste token: de eerste versie hieronder gebruikt vijfendertig tokens voor een resultaat dat identiek is aan de tweede, die er tien gebruikt. Op de schaal van een dienst die een miljoen verzoeken afhandelt, is het verschil niet langer anekdotisch.
# SLECHT — uitgebreide prompt (35 tokens)
response = client.responses.create(
model="gpt-5.6-terra",
input="Could you please give me a list "
"of three fruits that are red in color, if that "
"does not bother you of course?"
)
# GOED — beknopte prompt (10 tokens)
response = client.responses.create(
model="gpt-5.6-terra",
input="List 3 red fruits."
)
De tweede hefboom richt zich op de output, die meerdere keren duurder is dan de input. Combineer de instructie in de prompt met een technisch plafond: de eerste kadert het schrijven, de tweede garandeert dat uw budget wordt aangehouden, zelfs als het model de instructie negeert.
# Geen limiet — het model kan veel tokens genereren
response = client.responses.create(
model="gpt-5.6-terra",
input="Explain photosynthesis."
)
# Met limiet — kostenbeheersing
response = client.responses.create(
model="gpt-5.6-terra",
input="Explain photosynthesis in 2 sentences maximum.",
max_output_tokens=100
)
De derde hefboom is het schatten van de kosten vóór de oproep, wat essentieel wordt zodra u documenten van variabele grootte verwerkt. U kunt dan een te zwaar verzoek weigeren of splitsen in plaats van dit pas op uw factuur te ontdekken.
import tiktoken
def estimate_cost(text: str, model: str = "gpt-5.6-terra") -> dict:
"""Schat de kosten van een API-oproep."""
enc = tiktoken.get_encoding("cl200k_base")
input_tokens = len(enc.encode(text))
# Geschatte prijzen per miljoen tokens (controleer actuele prijzen)
prices = {
"gpt-5.6-sol": {"input": 5.0, "output": 30.0},
"gpt-5.6-terra": {"input": 2.0, "output": 12.0},
"gpt-5.6-luna": {"input": 0.20, "output": 1.20},
}
input_cost = (input_tokens / 1_000_000) * prices[model]["input"]
return {
"input_tokens": input_tokens,
"input_cost_usd": round(input_cost, 6),
"model": model
}
print(estimate_cost("Explain relativity in 3 sentences."))
# Resultaat: {'input_tokens': 10, 'input_cost_usd': 2.5e-05, 'model': 'gpt-5.6-terra'}
Context accumuleert tijdens het gesprek
Wanneer u uitwisselingen ketent met previous_response_id, begint elke beurt opnieuw met de totaliteit van vorige beurten. Inputtokens blijven dus groeien: een dialoog die begint bij 50 tokens weegt 150 bij de tweede beurt en veel meer bij de tiende. Dit is de meest voorkomende oorzaak van facturen die spiraleren zonder toename van het verkeer, en het monitoren van response.usage.input_tokens is uw waarschuwingssignaal.
# Beurt 1: 50 tokens
r1 = client.responses.create(
model="gpt-5.6-terra",
input="Hello, I am a Python developer."
)
# Beurt 2: 50 + 100 = 150 tokens (cumulatieve context)
r2 = client.responses.create(
model="gpt-5.6-terra",
input="Which web frameworks do you recommend?",
previous_response_id=r1.id
)
# Beurt 10: tokens accumuleren!
# Monitor response.usage.input_tokens om verrassingen te voorkomen
print(f"Cumulative tokens at turn 2: {r2.usage.input_tokens}")
Voor lange gesprekken is de workaround om de geschiedenis actief in te korten: verwijder de oudste berichten totdat u onder een gekozen limiet zakt, terwijl u het eerste bericht behoudt, dat meestal de stichtende context van de uitwisseling draagt.
def conversation_with_limit(messages: list, token_limit: int = 50000):
"""Houd het gesprek onder een tokenlimiet."""
enc = tiktoken.get_encoding("cl200k_base")
total = sum(len(enc.encode(m["content"])) for m in messages)
# Verwijder oudste berichten indien nodig
while total > token_limit and len(messages) > 2:
removed = messages.pop(1) # Behoud het eerste bericht (context)
total -= len(enc.encode(removed["content"]))
return messages
Belangrijkste punten
- Eén token staat voor ongeveer 0,7 woorden in het Frans
- Het contextvenster omvat input EN output
- Vensters variëren per model: in de vorige generatie 1 miljoen tokens voor GPT-5.4 en 200.000 voor GPT-5.3, o3-pro en o4-mini
- Gebruik
tiktokenom tokens te tellen vóór de oproep - Monitor
response.usageom uw kosten onder controle te houden - Beheer context actief bij lange gesprekken