Token telling en budgettering
Op deze pagina
Tokens begrijpen
Tokens zijn de fundamentele meeteenheid voor LLM’s. Elke API-oproep wordt gefactureerd in tokens, en elk model weigert verzoeken die de contextvenster overschrijden. Het beheersen van token-telling stelt u in staat om drie dingen te doen die benadering niet kan: kosten voorspellen voordat u ze maakt, uw prompts optimaliseren op basis van harde cijfers in plaats van onderbuikgevoel, en contextlimieten respecteren zonder pas een overflow te ontdekken wanneer de API een fout meldt.
Tellen met tiktoken
De tiktoken-bibliotheek past exact dezelfde tokenisatie toe als het model. U instantiateert een encoder voor het doelmodel en telt vervolgens de lengte van de gecodeerde reeks.
import tiktoken
# Encoder voor GPT-modellen
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")
def count_tokens(text: str) -> int:
"""Telt het aantal tokens in een tekst."""
return len(encoder.encode(text))
# Voorbeelden
print(count_tokens("Hello")) # ~1-2 tokens
print(count_tokens("Hello world")) # ~3-4 tokens
print(count_tokens("Development")) # ~2-3 tokens (accenten kosten meer)
Het derde voorbeeld verdient een pauze. “Development” kost meer dan zijn tekenlengte zou doen vermoeden, omdat tekens met accenten minder efficiënt tokeniseren. In de praktijk verbruikt een Frans corpus meer tokens dan een equivalent Engels corpus: als u uw budget schatte met Engelse prompts en vervolgens inzet in het Frans, zal uw uiteindelijke factuur uw prognose overschrijden.
Een API-oproep bevat meer dan ruwe tekst: elk bericht omvat een rol, soms een naam, en de API voegt structurele tokens toe. De volgende functie neemt deze overhead op om een realistisch totaal te bieden.
def count_conversation_tokens(messages: list[dict]) -> int:
"""Telt tokens in een conversatie (berichten + overhead)."""
total = 0
for message in messages:
total += 4 # Overhead per bericht (rol, etc.)
total += count_tokens(message["content"])
if message.get("name"):
total += count_tokens(message["name"])
total += 2 # Eind-tokens
return total
conversation = [
{"role": "system", "content": "You are a technical assistant."},
{"role": "user", "content": "Explain microservices."},
{"role": "assistant", "content": "Microservices are an architecture..."},
]
print(f"Total tokens: {count_conversation_tokens(conversation)}")
Bij een conversatie van drie berichten is de overhead verwaarloosbaar. Bij een geschiedenis van tweehonderd korte berichten—typisch voor een supportchat—loopt dit op tot bijna duizend tokens waar u geen rekening mee hield.
Budgetteren voordat u belt
Het contextvenster is geen invoerbudget: het is een gedeeld budget tussen wat u verzendt en wat het model genereert. Als u het venster tot de rand vult met uw prompt, wordt het antwoord afgekapt. De BudgetTokens-structuur maakt deze toewijzing expliciet door vooraf een deel voor de uitvoer te reserveren.
from dataclasses import dataclass
@dataclass
class BudgetTokens:
"""Beheert het token-budget voor een oproep."""
context_limit: int # Modelvenster
system_tokens: int = 0 # Systeemprompt
history_tokens: int = 0 # Conversatiegeschiedenis
user_tokens: int = 0 # Huidig bericht
output_reserve: int = 2000 # Gereserveerd voor antwoord
@property
def available_tokens(self) -> int:
used = (
self.system_tokens
+ self.history_tokens
+ self.user_tokens
)
return self.context_limit - used - self.output_reserve
@property
def is_over(self) -> bool:
return self.available_tokens < 0
def report(self) -> str:
return (
f"Context: {self.context_limit} | "
f"System: {self.system_tokens} | "
f"History: {self.history_tokens} | "
f"User: {self.user_tokens} | "
f"Output reserve: {self.output_reserve} | "
f"Available: {self.available_tokens}"
)
# Voorbeeld met een contextvenster van 128K tokens
budget = BudgetTokens(
context_limit=128_000,
system_tokens=count_tokens(system_prompt),
history_tokens=count_conversation_tokens(history),
user_tokens=count_tokens(user_message),
)
if budget.is_over:
print("Budget exceeded — compaction required")
De report-methode doet meer dan debuggen vergemakkelijken. Log deze op een steekproef van productieaanvragen, en u ziet direct welk component uw context verbruikt. In de meeste toepassingen komt de verrassing van de geschiedenis, zelden van de systeemprompt die iedereen in de gaten houdt.
Vervolgens moet u handelen wanneer het budget wordt overschreden. De prepare_context-functie past de eenvoudigste en meest robuuste regel toe: houd de meest recente berichten en laat de oudste vallen zodra het budget uitgeput is. De iteratie loopt achterstevoren en voegt aan het begin in om de chronologische volgorde te herstellen.
def prepare_context(
system_prompt: str,
history: list[dict],
message: str,
model_limit: int = 128_000,
output_reserve: int = 4_000,
) -> list[dict]:
"""Bereidt de context voor met inachtneming van het token-budget."""
system_tokens = count_tokens(system_prompt)
message_tokens = count_tokens(message)
history_budget = (
model_limit - system_tokens - message_tokens - output_reserve
)
# Houd de meest recente berichten binnen het budget
kept_messages = []
used_tokens = 0
for msg in reversed(history):
msg_tokens = count_tokens(msg["content"]) + 4
if used_tokens + msg_tokens > history_budget:
break
kept_messages.insert(0, msg)
used_tokens += msg_tokens
return (
[{"role": "system", "content": system_prompt}]
+ kept_messages
+ [{"role": "user", "content": message}]
)
Deze truncatie is bruut: alles dat buiten het budget valt, is verloren. Wanneer oudere context echt belangrijk is—een klantendossier dat over meerdere weken wordt gevolgd—vervangt u puur verwijderen door de compactiestrategie die in de vorige les aan bod kwam.
Kosten schatten voordat u uitgeeft
De duurste factureringsfouten komen voort uit batchverwerking: u voert een pass uit op 10.000 documenten en ontdekt het bedrag de volgende dag. Eerst schatten, in een paar milliseconden lokale berekening, voorkomt dit scenario.
def estimate_cost(
input_tokens: int,
estimated_output_tokens: int,
model: str = "gpt-5.6-terra",
) -> dict:
"""Schat de kosten van een oproep voordat deze wordt uitgevoerd."""
# Tarieven per miljoen tokens (juli 2026 — controleer officiële prijzen)
rates = {
"gpt-5.6-luna": {"input": 0.20, "output": 1.20},
"gpt-5.6-terra": {"input": 2.00, "output": 12.00},
"gpt-5.6-sol": {"input": 5.00, "output": 30.00},
}
rate = rates.get(model, rates["gpt-5.6-terra"])
input_cost = (input_tokens / 1_000_000) * rate["input"]
output_cost = (estimated_output_tokens / 1_000_000) * rate["output"]
return {
"model": model,
"input_tokens": input_tokens,
"estimated_output_tokens": estimated_output_tokens,
"input_cost": f"${input_cost:.6f}",
"output_cost": f"${output_cost:.6f}",
"total_cost": f"${input_cost + output_cost:.6f}",
}
# Voordat u een grote prompt verzendt
estimation = estimate_cost(
input_tokens=50_000,
estimated_output_tokens=2_000,
model="gpt-5.6-sol",
)
print(estimation)
De tarieftabel is in dit voorbeeld hardcoded, met de datum in een commentaar. Behandel dit als configuratiegegevens die u regelmatig verifieert tegen het officiële prijsoverzicht: een schatting berekend op verouderde prijzen is gevaarlijker dan geen schatting, omdat het vals vertrouwen wekt.
Ten slotte kent u de limieten van elk model om uw budget te plannen. Contextvensters variëren per model binnen de GPT-5.6-familie—raadpleeg de officiële OpenAI-modellenpagina voor actuele waarden, en configureer context_limit vanuit uw instellingen in plaats van het hard te coderen in de aanroepcode.
Belangrijkste punten
- Gebruik
tiktokenom tokens te tellen voor elke oproep, rekening houdend met overhead per bericht - Frans verbruikt meer tokens dan Engels voor equivalente inhoud: pas uw schattingen aan
- Reserveer altijd een budget voor uitvoertokens binnen het contextvenster
- Beheer context automatisch door de oudste berichten te verwijderen
- Schat kosten voordat u dure verzoeken verzendt, met geverifieerde tarieven