Počítání tokenů a správa rozpočtu
Na této stránce
Pochopení tokenů
Tokeny jsou základní jednotkou měření pro velké jazykové modely (LLM). Každé volání API je účtováno v tocenech a každý model odmítne požadavky, které překročí jeho kontextové okno. Ovládnutí počítání tokenů ti umožní tři věci, kterých pouhým odhadem nedosáhneš: předpovědět náklady před jejich vznikem, optimalizovat své prompty na základě tvrdých čísel místo pocitu a respektovat limity kontextu, aniž bys zjistil přeplnění až ve chvíli, kdy API vyhodí chybu.
Počítání pomocí tiktoken
Knihovna tiktoken aplikuje přesně stejnou tokenizaci jako model. Vytvoříš instanci enkodéru pro cílový model a poté spočítáš délku zakódované sekvence.
import tiktoken
# Enkodér pro modely GPT
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")
def count_tokens(text: str) -> int:
"""Spočítá počet tokenů v textu."""
return len(encoder.encode(text))
# Příklady
print(count_tokens("Hello")) # ~1-2 tokeny
print(count_tokens("Hello world")) # ~3-4 tokeny
print(count_tokens("Development")) # ~2-3 tokeny (akcenty stojí více)
Třetí příklad si zaslouží zastavení. Slovo „Development“ stojí více, než by naznačovala jeho délka v znacích, protože znaky s diakritikou se tokenizují méně efektivně. V praxi francouzský korpus spotřebuje více tokenů než ekvivalentní anglický: pokud jsi odhadoval svůj rozpočet pomocí anglických promptů a následně nasadil řešení ve francouzštině, tvůj skutečný účet překročí tvůj odhad.
Volání API nese více než jen čistý text: každá zpráva obsahuje roli, někdy jméno a API přidává strukturální tokeny. Následující funkce zahrnuje tuto režii a poskytuje realistický součet.
def count_conversation_tokens(messages: list[dict]) -> int:
"""Spočítá tokeny v konverzaci (zprávy + režie)."""
total = 0
for message in messages:
total += 4 # Režie na zprávu (role atd.)
total += count_tokens(message["content"])
if message.get("name"):
total += count_tokens(message["name"])
total += 2 # Koncové tokeny
return total
conversation = [
{"role": "system", "content": "Jsi technický asistent."},
{"role": "user", "content": "Vysvětli mikroslužby."},
{"role": "assistant", "content": "Mikroslužby jsou architektura..."},
]
print(f"Celkový počet tokenů: {count_conversation_tokens(conversation)}")
U konverzace o třech zprávách je režie zanedbatelná. U historie dvou set krátkých zpráv – což je typické pro podporu chatem – se to vyšplhá na téměř tisíc tokenů, které jsi nezapočítal.
Plánování rozpočtu před voláním
Kontextové okno není rozpočet pouze pro vstup: je to sdílený rozpočet mezi tím, co odešleš, a tím, co model vygeneruje. Pokud naplníš okno až po okraj svým promptem, odpověď bude oříznuta. Struktura BudgetTokens činí toto přidělení explicitním tím, že předem vyhrazuje část pro výstup.
from dataclasses import dataclass
@dataclass
class BudgetTokens:
"""Spravuje tokenový rozpočet pro volání."""
context_limit: int # Okno modelu
system_tokens: int = 0 # Systémový prompt
history_tokens: int = 0 # Historie konverzace
user_tokens: int = 0 # Aktuální zpráva
output_reserve: int = 2000 # Rezerva pro odpověď
@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"Kontext: {self.context_limit} | "
f"Systém: {self.system_tokens} | "
f"Historie: {self.history_tokens} | "
f"Uživatel: {self.user_tokens} | "
f"Rezerva výstupu: {self.output_reserve} | "
f"Dostupné: {self.available_tokens}"
)
# Příklad s kontextovým oknem 128K tokenů
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("Rozpočet překročen — je nutná komprese")
Metoda report slouží k více než jen ladění. Pokud ji budeš logovat u vzorku produkčních požadavků, okamžitě uvidíš, která komponenta spotřebovává tvůj kontext. Ve většině aplikací přichází překvapení z historie, zřídka kdy ze systémového promptu, který všichni hlídají.
Dále musíš jednat, když je rozpočet překročen. Funkce prepare_context aplikuje nejjednodušší a nejrobustnější pravidlo: ponech nejnovější zprávy a zahraň ty nejstarší, jakmile je rozpočet vyčerpán. Iterace probíhá pozpátku, přičemž se vkládá na začátek, aby se obnovilo chronologické pořadí.
def prepare_context(
system_prompt: str,
history: list[dict],
message: str,
model_limit: int = 128_000,
output_reserve: int = 4_000,
) -> list[dict]:
"""Připraví kontext při respektování tokenového rozpočtu."""
system_tokens = count_tokens(system_prompt)
message_tokens = count_tokens(message)
history_budget = (
model_limit - system_tokens - message_tokens - output_reserve
)
# Ponech nejnovější zprávy v rámci rozpočtu
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}]
)
Toto ořezávání je brutální: cokoli, co spadne mimo rozpočet, je ztraceno. Když na starším kontextu skutečně záleží – například u spisů klienta sledovaných několik týdnů – nahraď pouhé mazání strategií komprese, kterou jsme probírali v předchozí lekci.
Odhad nákladů před utracením peněz
Nejnákladnější chyby v fakturaci pocházejí z dávkového zpracování: spustíš průchod 10 000 dokumenty a částku zjistíš až druhý den. Předchozí odhad, který zabere jen několik milisekund lokálního výpočtu, této situaci předejde.
def estimate_cost(
input_tokens: int,
estimated_output_tokens: int,
model: str = "gpt-5.6-terra",
) -> dict:
"""Odhadne náklady volání před jeho provedením."""
# Sazby za milion tokenů (červenec 2026 — ověř oficiální ceník)
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}",
}
# Před odesláním velkého promptu
estimation = estimate_cost(
input_tokens=50_000,
estimated_output_tokens=2_000,
model="gpt-5.6-sol",
)
print(estimation)
Tabulka sazeb je v tomto příkladu natvrdo zakódována s datem v komentáři. Ber ji jako konfigurační data, která musíš pravidelně ověřovat proti oficiálnímu ceníku: odhad vypočítaný na zastaralých cenách je nebezpečnější než žádný odhad, protože vytváří falešnou jistotu.
Nakonec znaj limity každého modelu, abys mohl plánovat svůj rozpočet. Kontextová okna se liší model od modelu v rámci rodiny GPT-5.6 – aktuální hodnoty najdeš na oficiální stránce modelů OpenAI a context_limit nastavuj ze svých nastavení, místo abys ho natvrdo kódoval přímo do volacího kódu.
Klíčové poznatky
- Používej
tiktokenk počítání tokenů před každým voláním, včetně režie na zprávu - Francouzština spotřebuje pro ekvivalentní obsah více tokenů než angličtina: uprav své odhady
- Vždy vyhrazuj rozpočet pro výstupní tokeny v rámci kontextového okna
- Spravuj kontext automaticky zahazováním nejstarších zpráv
- Odhaduj náklady před odesláním drahých požadavků pomocí ověřených sazeb