Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Token telling en budgettering

Les 12 van 20 Bijgewerkt op 28 juli 2026 Gevorderd
Op deze pagina
  1. Tokens begrijpen
  2. Tellen met tiktoken
  3. Budgetteren voordat u belt
  4. Kosten schatten voordat u uitgeeft
  5. Belangrijkste punten

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 tiktoken om 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