Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Brojanje tokena i upravljanje proračunom

Lekcija 12 od 20 Ažurirano 28. srpnja 2026. Napredno
Na ovoj stranici
  1. Razumijevanje tokena
  2. Brojanje pomoću tiktokena
  3. Planiranje proračuna prije poziva
  4. Procjena troškova prije potrošnje
  5. Ključne točke

Razumijevanje tokena

Tokeni su temeljna mjerna jedinica za velike jezične modele (LLM). Svaki poziv API-ju naplaćuje se u tokenima, a svaki model odbija zahtjeve koji premašuju njegov prozor konteksta. Savladavanje brojanja tokena omogućuje ti tri stvari koje aproksimacija ne može: predvidjeti troškove prije nego što nastanu, optimizirati svoje upite na temelju tvrdih brojki umjesto osjećaja te poštovati ograničenja konteksta bez da tek kad API izbaci grešku shvatiš da si ga premašio.

Brojanje pomoću tiktokena

Biblioteka tiktoken primjenjuje istu tokenizaciju kao i sam model. Instanciraš enkoder za ciljni model, a zatim brojiš duljinu kodiranog niza.

import tiktoken

# Encoder za GPT modele
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")

def count_tokens(text: str) -> int:
    """Broji broj tokena u tekstu."""
    return len(encoder.encode(text))

# Primjeri
print(count_tokens("Hello"))           # ~1-2 tokena
print(count_tokens("Hello world"))     # ~3-4 tokena
print(count_tokens("Development"))     # ~2-3 tokena (akcenti koštaju više)

Treći primjer zaslužuje pauzu. Riječ “Development” košta više nego što bi njezina duljina u znakovima sugerirala jer se znakovi s dijakritičkim oznakama tokeniziraju manje učinkovito. U praksi, francuski korpus troši više tokena od ekvivalentnog engleskog: ako si procijenio proračun koristeći upite na engleskom, a zatim deployao na francuskom, tvoj će stvarni račun premašiti prognozu.

API poziv nosi više od sirovog teksta: svaka poruka uključuje ulogu, ponekad ime, a API dodaje i strukturne tokene. Sljedeća funkcija uključuje ovo opterećenje kako bi pružila realističan ukupni zbroj.

def count_conversation_tokens(messages: list[dict]) -> int:
    """Broji tokene u razgovoru (poruke + opterećenje)."""
    total = 0
    for message in messages:
        total += 4  # Opterećenje po poruci (uloga, itd.)
        total += count_tokens(message["content"])
        if message.get("name"):
            total += count_tokens(message["name"])
    total += 2  # Tokeni za kraj
    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)}")

Kod razgovora od tri poruke, opterećenje je zanemarivo. No kod povijesti od dvjesto kratkih poruka—što je tipično za chat podrške—to se zbraja u gotovo tisuću tokena koje nisi uzeo u obzir.

Planiranje proračuna prije poziva

Prozor konteksta nije proračun samo za ulaz: to je zajednički proračun za ono što šalješ i ono što model generira. Ako prozor napuniš do vrha svojim upitom, odgovor će biti odrezan. Struktura BudgetTokens čini ovu raspodjelu eksplicitnom rezerviranjem dijela za izlaz unaprijed.

from dataclasses import dataclass

@dataclass
class BudgetTokens:
    """Upravlja proračunom tokena za poziv."""
    context_limit: int       # Prozor modela
    system_tokens: int = 0   # Sistemski upit
    history_tokens: int = 0  # Povijest razgovora
    user_tokens: int = 0     # Trenutna poruka
    output_reserve: int = 2000 # Rezervirano za odgovor

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

# Primjer s prozorom konteksta od 128K tokena
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")

Metoda report služi za više od samo debugiranja. Zabilježi je na uzorku produkcijskih zahtjeva i odmah ćeš vidjeti koja komponenta troši tvoj kontekst. U većini aplikacija iznenađenje dolazi iz povijesti, rijetko iz sistemskog upita koji svi prate.

Dalje, moraš djelovati kada se proračun premaši. Funkcija prepare_context primjenjuje najjednostavnije i najrobusnije pravilo: zadrži najnovije poruke, a najstarije odbaci čim se proračun iscrpi. Iteracija teče unatrag, umetanjem na početak kako bi se obnovio kronološki redoslijed.

def prepare_context(
    system_prompt: str,
    history: list[dict],
    message: str,
    model_limit: int = 128_000,
    output_reserve: int = 4_000,
) -> list[dict]:
    """Priprema kontekst uz poštovanje proračuna tokena."""

    system_tokens = count_tokens(system_prompt)
    message_tokens = count_tokens(message)
    history_budget = (
        model_limit - system_tokens - message_tokens - output_reserve
    )

    # Zadrži najnovije poruke unutar proračuna
    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}]
    )

Ovo skraćivanje je brutalno: sve što padne izvan proračuna je izgubljeno. Kada stariji kontekst doista ima važnost—poput dosjea klijenta praćenog nekoliko tjedana—zamijeni čisto brisanje strategijom sažimanja obrađenom u prethodnoj lekciji.

Procjena troškova prije potrošnje

Najskuplje greške u naplati dolaze iz serijske obrade: pokreneš prolaz kroz 10.000 dokumenata i iznos otkriješ tek sutradan. Procjena unaprijed, uz nekoliko milisekundi lokalnog računanja, izbjegava ovaj scenarij.

def estimate_cost(
    input_tokens: int,
    estimated_output_tokens: int,
    model: str = "gpt-5.6-terra",
) -> dict:
    """Procjenjuje trošak poziva prije njegovog izvršenja."""
    # Cijene po milijun tokena (srpanj 2026. — provjeri službene cijene)
    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}",
    }

# Prije slanja velikog upita
estimation = estimate_cost(
    input_tokens=50_000,
    estimated_output_tokens=2_000,
    model="gpt-5.6-sol",
)
print(estimation)

Tablica cijena je u ovom primjeru ukodirana, s datumom u komentaru. Tretiraj je kao konfiguracijski podatak koji trebaš redovito provjeravati prema službenom cjeniku: procjena izračunata na zastarjelim cijenama opasnija je od nepostojanja procjene jer stvara lažno povjerenje.

Konačno, upoznaj ograničenja svakog modela kako bi isplanirao svoj proračun. Prozori konteksta variraju od modela do modela unutar obitelji GPT-5.6—posjeti službenu stranicu OpenAI modela za trenutne vrijednosti i konfiguriraj context_limit iz svojih postavki umjesto da ga ukodiraš u kod koji vrši pozive.

Ključne točke

  • Koristi tiktoken za brojanje tokena prije svakog poziva, uzimajući u obzir opterećenje po poruci
  • Francuski troši više tokena od engleskog za ekvivalentan sadržaj: prilagodi svoje procjene
  • Uvijek rezerviraj proračun za izlazne tokene unutar prozora konteksta
  • Automatski upravljaj kontekstom odbacivanjem najstarijih poruka
  • Procijeni troškove prije slanja skupih zahtjeva koristeći verificirane cijene