Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Költségmezők a válaszokban

8. lecke 14 közül Frissítve 2026. július 29. Haladó
Ezen az oldalon
  1. Költségek nyomon követése valós időben
  2. A usage objektum
  3. Két skála ugyanarra a költségre
  4. Költségkövető építése
  5. A gyorsítótárazási arány elemzése
  6. Főbb megállapítások

Költségek nyomon követése valós időben

Minden Grok API-válasz tartalmazza a frissen felmerült költségek részleteit. Sok csapat túl későn fedezi fel ezeket az információkat, amikor megérkezik a havi számla, pedig azok kérésről kérésre elérhetők. Ha már az integráció kezdetétől kiaknázod ezt az adatot, egy órán belül észleled az eltérést: például egy rendszerüzenet, amely deploy után megduplázódott, egy rosszul bekalibrált újrapróbálkozási ciklus, amely ugyanazokat a hívásokat ismétli, vagy egy kontextus, amely átlépte a számlázási küszöböt. Ezen követés nélkül ezek az incidensek láthatatlanok maradnak egészen a számla kézhezvételéig.

A usage objektum

Minden válasz tartalmaz egy usage objektumot, amely részletezi a tokenfogyasztást és a kapcsolódó költséget:

{
  "usage": {
    "prompt_tokens": 1250,
    "completion_tokens": 340,
    "total_tokens": 1590,
    "cached_tokens": 800,
    "cost_in_usd_ticks": 5000000000,
    "cost_in_nano_usd": 500000000
  }
}

A négy számláló mező jelentése a következő.

MezőJelentés
prompt_tokensbemeneti tokenek száma (a teljes rendszerüzeneted)
completion_tokenskimeneti tokenek száma (a modell válasza)
total_tokensa bemeneti és kimeneti tokenek összege
cached_tokensgyorsítótárból kiszolgált bemeneti tokenek

Egy részlet megelőz egy gyakori hibát: a cached_tokens bele van számítva a prompt_tokens értékébe, nem pedig hozzáadódik ahhoz. A fenti példában 1250 token lépett be a modellbe, ebből 800 a gyorsítótárból származott, és csak 450-et számláztak teljes áron. Ha az aggregátorod összeadja mindkét mezőt, duplán számolja a gyorsítótárazott részt, és mesterségesen felfújja a volumened statisztikáit.

Két skála ugyanarra a költségre

A kérés költségét két egész számú egységben adjuk meg. Ez a választás nem önkényes: a centtöredékek lebegőpontos számokkal történő kifejezése kerekítési hibákat vezet be, amelyek milliószámra összegzett hívások esetén válnak láthatóvá. Az egész számok ezt a problémát teljesen kiküszöbölik.

A cost_in_usd_ticks mező „tick“ekben számol, ahol egy dollár 10 milliárd ticknek felel meg. A példában szereplő 5 000 000 000 érték tehát 0,50 USD-nak felel meg, és egymillió tick egyenlő 0,0001 USD-val. Az átváltás egyetlen sorba fér:

cost_usd = cost_in_usd_ticks / 10_000_000_000

A cost_in_nano_usd mező nanodollárokban számol, ahol egy dollár egymilliárd nanodollárnak felel meg. A példában szereplő 500 000 000 ugyanazt az összeget, 0,50 USD-t jelenti, és ezer nanodollár egyenlő 0,000001 USD-val. Az átváltás ugyanazon logika szerint történik:

cost_usd = cost_in_nano_usd / 1_000_000_000

Mindkét mező ugyanazt az összeget írja le különböző skálákon. A cost_in_nano_usd intuitívabb kezelni, míg a cost_in_usd_ticks kissé nagyobb pontosságot kínál. Válassz egyet, és tartsd magad hozzá a teljes mérési láncod során: mindkettő ugyanabban az aggregátumban való keverése a legjobb módja annak, hogy inkonzisztens végösszegeket kapj.

Költségkövető építése

Éles környezetben egyetlen akkumulátor is elég ahhoz, hogy ezeket a mezőket irányítópulttá alakítsd. Az alábbi osztály rögzíti az egyes usage objektumokat, és elérhetővé teszi a halmozott költséget valamint a gyorsítótárazási arányt:

class CostTracker:
    def __init__(self):
        self.total_nano_usd = 0
        self.requests = 0
        self.input_tokens = 0
        self.output_tokens = 0
        self.cached_tokens = 0

    def record(self, usage):
        self.total_nano_usd += usage.get("cost_in_nano_usd", 0)
        self.requests += 1
        self.input_tokens += usage.get("prompt_tokens", 0)
        self.output_tokens += usage.get("completion_tokens", 0)
        self.cached_tokens += usage.get("cached_tokens", 0)

    @property
    def total_cost_usd(self):
        return self.total_nano_usd / 1_000_000_000

    @property
    def cache_rate(self):
        if self.input_tokens == 0:
            return 0
        return self.cached_tokens / self.input_tokens

Ezután állíts be küszöbértékeket a total_cost_usd alapján. Az első küszöb, amely a napi költségvetés 80%-át éri el, tájékoztató jellegű riasztást vált ki a technikai csapat számára; a második, 95%-os küszöb kritikus riasztássá válik, amely emberi döntést igényel; 100%-nál az alkalmazás automatikusan leállítja a nem kritikus kéréseket – kötegelt feladatok, előszámítások, késleltetett dúsítások –, és csak a közvetlen felhasználói forgalmat engedi át. Ez a fokozatos teljesítménycsökkenés jobb, mint a hirtelen szolgáltatásleállás egy csúcsnapon.

A gyorsítótárazási arány elemzése

A cache_rate tulajdonság megérdemel egy saját irányítópultot, mivel közvetlenül tükrözi a rendszerüzeneted szerkezetének minőségét.

Gyorsítótárazási arányÉrtelmezés
0–20%nincs hatékony gyorsítótárazás, vizsgáld felül a rendszerüzenet szerkezetét
20–50%részleges gyorsítótárazás, ellenőrizd a rendszerüzeneteid stabilitását
50–80%jó arány beszélgetések esetén
80% és afölöttkiváló, jellemző a hosszú, stabil rendszerüzenetekre

Ha az arány egyik hétről a másikra meredeken csökken, az szinte mindig arra utal, hogy egy olyan deploy történt, amely változót vezetett be a rendszerüzenet elejére. A következő lecke részletezi a mechanizmust; egyelőre jegyezd meg, hogy ez az érték ugyanolyan értékes regressziós mutató, mint a hibaarány.

Árak 2026. augusztus 5-i állapot szerint – az árak rendszeresen változnak: bármilyen költségvetés-számítás előtt ellenőrizd az aktuális díjszabást a hivatalos xAI modell- és árlapon.

Főbb megállapítások

  • Minden API-válasz tartalmaz egy usage objektumot tokenrészletekkel és költséggel
  • cost_in_usd_ticks: 10 milliárd tick = 1 USD
  • cost_in_nano_usd: 1 milliárd nano-USD = 1 USD
  • A cached_tokens mező a gyorsítótárazás hatékonyságát méri
  • Építs költségkövetőt éles környezetben költségvetési riasztásokkal