Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Tokens, kontekst og samtalevindue

Lektion 7 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Tokens, kontekst og samtalevindue
  2. Hvad er et token?
  3. Kontekstvinduet
  4. Tre optimeringsgreb
  5. Kontekst akkumuleres gennem samtalen
  6. Vigtige pointer

Tokens, kontekst og samtalevindue

Tokenet er den enhed, modellen manipulerer, og den enhed, din faktura sporer. Så længe dette begreb står uklart for dig, vil dine omkostninger også gøre det, og du vil uundgåeligt støde på en fejl vedrørende kontekstgrænse uden at vide hvorfor. Denne lektion rydder op i begge dele.

Hvad er et token?

Et token er ikke et ord. Det er en tekstfragment, som modellen behandler som en udelelig enhed. På dansk svarer ét token i gennemsnit til ca. 0,7 ord. Biblioteket tiktoken lader dig se præcis, hvordan tekst opdeles: læg mærke til, hvordan „allez-vous” brydes i to tokens, mens „aujourd’hui”, som forekommer hyppigere i træningskorpusset, passer ind i ét. Denne detalje forklarer, hvorfor en fransk tekst forbruger flere tokens end en engelsk tekst af tilsvarende længde.

from openai import OpenAI
client = OpenAI()

# To estimate tokens, use the tiktoken library
import tiktoken

# cl200k_base is used here as an example: each model generation has its own encoder.
# Check the encoder for the model you call before relying on the count.
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]}")

# Result:
# 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", ' ?']

Kontrollér altid, hvilken encoder der matcher den model, du kalder. En optælling udført med den forkerte encoder er stadig en nyttig tilnærmelse, men vil ikke matche din faktura nøjagtigt.

Kontekstvinduet

Hver model har et maksimalt kontekstvindue, og fælden for begyndere er, at det inkluderer både input og output. Dette er ikke et input-budget: det er et samlet budget. Hvis din prompt optager 190.000 tokens af et vindue på 200.000 tokens, er der kun 10.000 tokens tilbage til svaret. Modellen vil afbryde midt i en sætning uden yderligere advarsel.

# Previous generation, for reference:
# GPT-5.4: 1,000,000 context tokens
# GPT-5.3: 200,000 context tokens
# gpt-5.6-sol  : 200,000 context tokens
# gpt-5.6-terra : 200,000 context tokens

# Example: if your input is 190,000 tokens in a 200,000-token window,
# only 10,000 tokens remain for the response

response = client.responses.create(
    model="gpt-5.6-terra",
    input="A very long text...",
    max_output_tokens=10000  # Limit explicitly
)

Efterfølgende kan du aflæse den nøjagtige optælling i response.usage, som skelner mellem input-tokens, output-tokens og det samlede antal:

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}")

# Result:
# Input tokens: 12
# Output tokens: 58
# Total: 70

Tre optimeringsgreb

Det første greb er promptens koncision. Høflighedsfraser og retoriske forbehold forbedrer ikke svaret og koster tokens ned til det sidste: den første version nedenfor bruger femogtredive tokens til et resultat, der er identisk med den anden, som bruger ti. I skalaen for en tjeneste, der håndterer en million anmodninger, er forskellen ikke længere anekdotisk.

# BAD — verbose 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?"
)

# GOOD — concise prompt (10 tokens)
response = client.responses.create(
    model="gpt-5.6-terra",
    input="List 3 red fruits."
)

Det andet greb retter sig mod output, som koster flere gange mere end input. Kombinér instruktionen i prompten med et teknisk loft: den første rammer skrivningen ind, den anden garanterer, at dit budget holder, selv hvis modellen ignorerer instruktionen.

# No limit — the model can generate many tokens
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain photosynthesis."
)

# With limit — cost control
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain photosynthesis in 2 sentences maximum.",
    max_output_tokens=100
)

Det tredje greb er at estimere omkostningerne før kaldet, hvilket bliver essentielt, så snart du behandler dokumenter af variabel størrelse. Du kan derefter afvise eller opdele en anmodning, der er for tung, i stedet for at opdage det på din faktura.

import tiktoken

def estimate_cost(text: str, model: str = "gpt-5.6-terra") -> dict:
    """Estimate the cost of an API call."""
    enc = tiktoken.get_encoding("cl200k_base")
    input_tokens = len(enc.encode(text))

    # Approximate prices per million tokens (check current prices)
    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."))
# Result: {'input_tokens': 10, 'input_cost_usd': 2.5e-05, 'model': 'gpt-5.6-terra'}

Kontekst akkumuleres gennem samtalen

Når du kæder udvekslinger sammen ved hjælp af previous_response_id, starter hver omgang forfra med hele indholdet af tidligere omgange. Input-tokens vokser derfor konstant: en dialog, der starter på 50 tokens, vejer 150 på anden omgang og meget mere på tiende. Dette er den hyppigste årsag til, at fakturaer spiralerer uden øget trafik, og overvågning af response.usage.input_tokens er dit advarselssignal.

# Turn 1: 50 tokens
r1 = client.responses.create(
    model="gpt-5.6-terra",
    input="Hello, I am a Python developer."
)

# Turn 2: 50 + 100 = 150 tokens (cumulative context)
r2 = client.responses.create(
    model="gpt-5.6-terra",
    input="Which web frameworks do you recommend?",
    previous_response_id=r1.id
)

# Turn 10: tokens accumulate!
# Monitor response.usage.input_tokens to avoid surprises
print(f"Cumulative tokens at turn 2: {r2.usage.input_tokens}")

Ved lange samtaler er løsningen aktivt at beskære historikken: fjern de ældste beskeder, indtil du falder under en valgt grænse, mens du beholder den første, som normalt bærer udvekslingens grundlæggende kontekst.

def conversation_with_limit(messages: list, token_limit: int = 50000):
    """Keep the conversation under a token limit."""
    enc = tiktoken.get_encoding("cl200k_base")

    total = sum(len(enc.encode(m["content"])) for m in messages)

    # Remove oldest messages if necessary
    while total > token_limit and len(messages) > 2:
        removed = messages.pop(1)  # Keep the first message (context)
        total -= len(enc.encode(removed["content"]))

    return messages

Vigtige pointer

  • Ét token svarer til ca. 0,7 ord på dansk
  • Kontekstvinduet inkluderer både input OG output
  • Vinduer varierer efter model: i den forrige generation 1 mio. tokens til GPT-5.4 og 200.000 til GPT-5.3, o3-pro og o4-mini
  • Brug tiktoken til at tælle tokens før kaldet
  • Overvåg response.usage for at styre dine omkostninger
  • Håndtér kontekst aktivt i lange samtaler