Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Comhaireamh agus buiséadú token

Ceacht 12 as 20 Nuashonraithe 28 Iúil 2026 Ardleibhéal
Ar an leathanach seo
  1. Tuiscint a fháil ar thoken
  2. Comhaireamh le tiktoken
  3. Buiséadú sula ndéanann tú glaoch
  4. Meastachán a dhéanamh ar chostas sula gcaitear airgead
  5. Príomhphointí

Tuiscint a fháil ar thoken

Is iad na token an t-aonad tomhais bunúsach do LLManna. Billeáiltear gach glaoch API i dtoken, agus diúltaíonn gach múnla d’iarratais a sháraíonn a bhfuinneog comhthéacs. Má mháistiríonn tú comhaireamh token, is féidir leat trí rud a dhéanamh nach féidir le meastacháin: costais a thuar sula dtarlaíonn siad, do leideanna a optamú bunaithe ar uimhreacha crua seachas ar bhraistint, agus teorainneacha comhthéacs a urramú gan teacht ar shárú ach nuair a chaitheann an API earráid.

Comhaireamh le tiktoken

Cuirtear an tócanú céanna i bhfeidhm ag an leabharlann tiktoken agus atá ag an múnla. Cruthaíonn tú ionchódóir don mhúnla sprioc, ansin comhairíonn tú fad an seicheamh ionchódaithe.

import tiktoken

# Encoder for GPT models
encoder = tiktoken.encoding_for_model("gpt-5.6-terra")

def count_tokens(text: str) -> int:
    """Counts the number of tokens in a text."""
    return len(encoder.encode(text))

# Examples
print(count_tokens("Hello"))           # ~1-2 tokens
print(count_tokens("Hello world"))     # ~3-4 tokens
print(count_tokens("Development"))     # ~2-3 tokens (accents cost more)

Is fiú stopadh ag an tríú sampla. Cosnaíonn “Development” níos mó ná mar a mholadh a fhad carachtair toisc go dtócanann carachtair faoi stróc níos mí-éifeachtaí. Go praiticiúil, ídíonn corpas Fraincise níos mó token ná corpas Béarla coibhéiseach: má rinne tú meastachán ar do bhuiséad ag baint úsáide as leideanna Béarla agus ansin d’impléáil tú i bhFraincis, sáróidh do bhille iarbhír do thuar.

Bíonn níos mó ná téacs amh i nglaoch API: áirítear ról, agus uaireanta ainm, i ngach teachtaireacht, agus cuireann an API token struchtúrtha leis. Cuireann an fheidhm seo a leanas an t-uallach seo san áireamh chun iomlán réadach a sholáthar.

def count_conversation_tokens(messages: list[dict]) -> int:
    """Counts tokens in a conversation (messages + overhead)."""
    total = 0
    for message in messages:
        total += 4  # Overhead per message (role, etc.)
        total += count_tokens(message["content"])
        if message.get("name"):
            total += count_tokens(message["name"])
    total += 2  # End 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)}")

Ar chomhrá trí theachtaireacht, is beag an t-uallach. Ar stair dhá chéad teachtaireacht ghairid—gnách do chomhrá tacaíochta—suimíonn sé suas le beagnach míle token nár chuir tú san áireamh.

Buiséadú sula ndéanann tú glaoch

Ní buiséad ionchuir é an fhuinneog comhthéacs: is buiséad roinnte é idir an méid a sheolann tú agus an méid a ghineann an múnla. Má líonann tú an fhuinneog go barr le do leid, gearrfar an freagra. Déanann an struchtúr BudgetTokens an leithdháileadh seo soiléir trí chuid a chur in áirithe don aschur roimh ré.

from dataclasses import dataclass

@dataclass
class BudgetTokens:
    """Manages the token budget for a call."""
    context_limit: int       # Model window
    system_tokens: int = 0   # System prompt
    history_tokens: int = 0  # Conversation history
    user_tokens: int = 0     # Current message
    output_reserve: int = 2000 # Reserved for response

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

# Example with a 128K token context window
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")

Ní chun cabhrú le dífhabhtú amháin a dhéanann an modh report. Logáil é ar shampla d’iarratais táirgeachta, agus feicfidh tú láithreach cé acu comhpháirt atá ag ídiú do chomhthéacs. I bhformhór na bhfeidhmchlár, is ón stair a thagann an t-iontas, go hannamh ón leid córais a dhéanann gach duine monatóireacht air.

Anois, ní mór duit gníomhú nuair a sháraítear an buiséad. Cuirtear an riail is simplí agus is láidre i bhfeidhm ag an bhfeidhm prepare_context: coinnigh na teachtaireachtaí is déanaí agus caith na cinn is sine amach chomh luath agus a ídítear an buiséad. Ritheann an t-iteráil ar gcúl, ag cur isteach ag an gceann chun an t-ord croineolaíoch a athbhunú.

def prepare_context(
    system_prompt: str,
    history: list[dict],
    message: str,
    model_limit: int = 128_000,
    output_reserve: int = 4_000,
) -> list[dict]:
    """Prepares the context while respecting the token budget."""

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

    # Keep the most recent messages within 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}]
    )

Tá an gearradh seo brúidiúil: caillear aon rud a thiteann lasmuigh den bhuiséad. Nuair a bhíonn tábhacht leis an gcomhthéacs níos sine i ndáiríre—comhad cliant arna rianú thar roinnt seachtainí—cuir an straitéis comhbhrúite a clúdaíodh sa cheacht roimhe seo in ionad scriosta íon.

Meastachán a dhéanamh ar chostas sula gcaitear airgead

Tagann na hearráidí billeála is costasaí ó phróiseáil bhaisce: ritheann tú pas ar 10,000 doiciméad agus faigheann tú amach an méid an lá dár gcionn. Seachnaíonn meastachán a dhéanamh ar dtús, i gcúpla millisoicind ríomhaireachta áitiúla, an cás seo.

def estimate_cost(
    input_tokens: int,
    estimated_output_tokens: int,
    model: str = "gpt-5.6-terra",
) -> dict:
    """Estimates the cost of a call before executing it."""
    # Rates per million tokens (July 2026 — check official pricing)
    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}",
    }

# Before sending a large prompt
estimation = estimate_cost(
    input_tokens=50_000,
    estimated_output_tokens=2_000,
    model="gpt-5.6-sol",
)
print(estimation)

Tá an tábla rátaí crua-chódaithe sa sampla seo, leis an dáta i nóta tráchta. Déileáil leis mar shonraí cumraíochta le seiceáil go rialta i gcoinne an ghrid praghsála oifigiúil: tá meastachán a ríomhtar ar phraghsanna seanbhunaithe níos contúirtí ná gan aon mheastachán ar chor ar bith, toisc go spreagann sé muinín bhréige.

Ar deireadh, bí ar an eolas faoi theorainneacha gach múnla chun do bhuiséad a phleanáil. Athraíonn fuinneoga comhthéacs ó mhúnla go múnla laistigh den teaghlach GPT-5.6—consultáil leathanach oifigiúil múnlaí OpenAI le haghaidh luachanna reatha, agus cumraigh context_limit ó do shocruithe seachas é a chrua-chódú sa chód glaoite.

Príomhphointí

  • Úsáid tiktoken chun token a chomhaireamh roimh gach glaoch, ag cur uallaigh in aghaidh na teachtaireachta san áireamh
  • Ídíonn an Fhraincis níos mó token ná an Béarla do chomhábhar coibhéiseach: coigeartaigh do mheastacháin
  • Cuir buiséad in áirithe i gcónaí do thoken aschuir laistigh den fhuinneog comhthéacs
  • Bainistigh an comhthéacs go huathoibríoch trí na teachtaireachtaí is sine a chaitheamh amach
  • Déan meastachán ar chostais sula seolann tú iarratais chostacha, ag baint úsáide as rátaí fíoraithe