Przejdź do głównej treści
Polski— Wybierz język
Menu

Tokeny, kontekst i okno konwersacji

Lekcja 7 z 22 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Tokeny, kontekst i okno konwersacji
  2. Czym jest token?
  3. Okno kontekstowe
  4. Trzy dźwignie optymalizacji
  5. Kontekst kumuluje się w trakcie konwersacji
  6. Kluczowe wnioski

Tokeny, kontekst i okno konwersacji

Token to jednostka, którą manipuluje model, i jednostka, na podstawie której naliczana jest Twoja faktura. Dopóki ta koncepcja pozostaje niejasna, Twoje koszty również będą nieprzewidywalne, a w końcu napotkasz błąd przekroczenia limitu kontekstu, nie wiedząc dlaczego. Ta lekcja wyjaśnia obie te kwestie.

Czym jest token?

Token to nie słowo. To fragment tekstu, który model traktuje jako niepodzielną całość. W języku polskim jeden token reprezentuje średnio około 0,7 słowa. Biblioteka tiktoken pozwala zobaczyć dokładnie, jak tekst jest dzielony: zauważ, jak „dzień dobry“ może zostać rozbite na dwa tokeny, podczas gdy częstsze wyrazy mieszczą się w jednym. Ten szczegół wyjaśnia, dlaczego tekst polski zużywa więcej tokenów niż tekst angielski o porównywalnej długości.

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

Zawsze sprawdzaj, który enkoder odpowiada wywoływanemu przez Ciebie modelowi. Liczenie wykonane złym enkoderem stanowi użyteczne przybliżenie, ale nie będzie się dokładnie zgadzać z Twoją fakturą.

Okno kontekstowe

Każdy model ma maksymalne okno kontekstowe, a pułapką dla początkujących jest fakt, że obejmuje ono zarówno dane wejściowe, jak i wyjściowe. Nie jest to budżet tylko na wejście: to budżet całkowity. Jeśli Twój prompt zajmuje 190 000 tokenów w oknie 200 000 tokenów, na odpowiedź pozostaje tylko 10 000 tokenów. Model urwie zdanie w połowie bez żadnego dodatkowego ostrzeżenia.

# 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
)

Po fakcie możesz odczytać dokładną liczbę w response.usage, które rozróżnia tokeny wejściowe, tokeny wyjściowe i sumę:

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

Trzy dźwignie optymalizacji

Pierwszą dźwignią jest zwięzłość promptu. Grzecznościowe formułki i retoryczne zastrzeżenia nie poprawiają odpowiedzi, a kosztują tokeny aż do ostatniego: pierwsza wersja poniżej zużywa trzydzieści pięć tokenów dla wyniku identycznego z drugim, który zużywa dziesięć. W skali usługi obsługującej milion żądań różnica przestaje być anegdotyczna.

# 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."
)

Druga dźwignia dotyczy wyjścia, które kosztuje kilka razy więcej niż wejście. Połącz instrukcję w prompcie z technicznym limitem: pierwsza ramuje treść, druga gwarantuje, że zmieścisz się w budżecie, nawet jeśli model zignoruje instrukcję.

# 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
)

Trzecią dźwignią jest szacowanie kosztu przed wywołaniem, co staje się niezbędne, gdy przetwarzasz dokumenty o zmiennej wielkości. Możesz wtedy odrzucić lub podzielić zbyt ciężkie żądanie, zamiast odkrywać to na fakturze.

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 kumuluje się w trakcie konwersacji

Gdy łączysz wymiany za pomocą previous_response_id, każda tura restartuje się od całości poprzednich tur. Tokeny wejściowe więc stale rosną: dialog, który zaczyna się od 50 tokenów, waży 150 w drugiej turze i znacznie więcej w dziesiątej. To najczęstsza przyczyna spiralnego wzrostu kosztów bez zwiększenia ruchu, a monitorowanie response.usage.input_tokens jest Twoim sygnałem ostrzegawczym.

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

W przypadku długich konwersacji obejściem jest aktywne skracanie historii: usuwaj najstarsze wiadomości, aż zejdziesz poniżej wybranego limitu, zachowując jednocześnie pierwszą, która zazwyczaj niesie założycielski kontekst wymiany.

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

Kluczowe wnioski

  • Jeden token to około 0,7 słowa w języku polskim
  • Okno kontekstowe obejmuje wejście I wyjście
  • Okna różnią się w zależności od modelu: w poprzedniej generacji 1 mln tokenów dla GPT-5.4 oraz 200 tys. dla GPT-5.3, o3-pro i o4-mini
  • Używaj tiktoken do liczenia tokenów przed wywołaniem
  • Monitoruj response.usage, aby kontrolować koszty
  • Aktywnie zarządzaj kontekstem w długich konwersacjach