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

Költségek és használat monitorozása

16. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Költségek és használat monitorozása
  2. Számlázás megértése
  3. Költségszámoló
  4. Valós idejű költségnyelvő
  5. Költségvetés-vezérelt kliens
  6. Költségek optimalizálása
  7. Főbb megállapítások

Költségek és használat monitorozása

Az API-költségek gyorsan elszabadulhatnak, ha nem figyeled őket. Ez a lecke megtanít, hogyan követheted nyomon, becsülheted meg és tarthatod kordában a kiadásaidat éles környezetben. A történet projektől projektig ismétli önmagát: egy funkció csütörtökön élesedik, hétvégén senki nem nézi a vezérlőpultot, hétfő reggelre pedig a számla eléri a teljes havi keretet. Az alábbi lépések segítenek abban, hogy a költségvetési eltérést azonnal észleld, ne harminc nappal később.

Számlázás megértése

A költségeket milliónyi tokenre számítják, különböző árakkal a bemeneti (input) és kimeneti (output) adatokra. Ennek az aszimmetriának közvetlen hatása van a tervezési döntéseidre: egy hosszú dokumentum bemenetként való elküldése jelentősen olcsóbb, mint ha a modell generálna egy hosszú választ. Minden válasz pontosan visszaadja mindkét irány tokenszámát, így sosem kell becslésekkel dolgoznod.

from openai import OpenAI
client = OpenAI()

# Minden válasz tartalmazza a használati metrikákat
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain OpenAI API billing."
)

usage = response.usage
print(f"Input tokens: {usage.input_tokens}")
print(f"Output tokens: {usage.output_tokens}")
print(f"Total tokens: {usage.total_tokens}")

# A kimenet többe kerül, mint a bemenet!

Költségszámoló

Ezeknek a számlálóknak dollárra való átváltása egy ártáblázatot igényel. Zárd ezt egy dedikált szerkezetbe, ahelyett, hogy konstansokat szór szét a kódodban: ha az árak változnak vagy új modellt adsz hozzá, csak egy sort kell módosítanod. Az alábbi árak tájékoztató jellegűek, és minden költségvetési felülvizsgálatkor ellenőrizni kell őket.

from dataclasses import dataclass

@dataclass
class ModelRate:
    input_per_million: float
    output_per_million: float

# Hozzávetőleges árak USD-ben milliónyi tokenre
# Mindig ellenőrizd az aktuális árakat a platform.openai.com/pricing oldalon
RATES = {
    "gpt-5.6-luna": ModelRate(input_per_million=0.20, output_per_million=1.20),
    "gpt-5.6-terra": ModelRate(input_per_million=2.0, output_per_million=12.0),
    "gpt-5.6-sol": ModelRate(input_per_million=5.0, output_per_million=30.0),
}

def calculate_cost(model: str, input_tokens: int,
                   output_tokens: int) -> float:
    """Kiszámítja egy hívás költségét USD-ben."""
    rate = RATES.get(model)
    if not rate:
        raise ValueError(f"Unknown model: {model}")

    input_cost = (input_tokens / 1_000_000) * rate.input_per_million
    output_cost = (output_tokens / 1_000_000) * rate.output_per_million

    return input_cost + output_cost

# Példa
cost = calculate_cost("gpt-5.6-terra", input_tokens=1000, output_tokens=500)
print(f"Cost: ${cost:.6f}")
# Eredmény: Cost: $0.008000

Hívásonként nyolctized cent megnyugtatónak hangozhat, egészen addig, amíg meg nem szorzod egy éles chatbot napi ötvenezer hívásával – ez napi négyszáz dollár. Szokd rá magad, hogy mindig havi volumenben gondolkodj, sosem hívásonként.

Valós idejű költségnyelvő

Az egységszámítások önmagukban haszontalanok, ha nem aggregálod őket. Ez a nyelvező három tengely mentén összesíti a kiadásokat – naponta, modellenként és hívásszámonként –, és összehasonlítja a napi összeget az általad meghatározott költségvetéssel. A riasztások fokozatosak: figyelmeztetés, ha a költségvetés kevesebb mint 20%-a maradt, majd hard riasztás a limit túllépésekor. Ez a közbenső lépés értékes, mert időt ad a beavatkozásra, mielőtt a szolgáltatást leállítanák.

import json
from datetime import datetime, date
from collections import defaultdict

class CostTracker:
    """Valós idejű API-költségkövetés."""

    def __init__(self, daily_budget_usd: float = 10.0):
        self.daily_budget = daily_budget_usd
        self.costs_per_day: dict[str, float] = defaultdict(float)
        self.costs_per_model: dict[str, float] = defaultdict(float)
        self.calls_per_day: dict[str, int] = defaultdict(int)
        self.total_tokens = 0

    def record(self, model: str, input_tokens: int,
               output_tokens: int):
        """Rögzíti egy hívás költségeit."""
        cost = calculate_cost(model, input_tokens, output_tokens)
        today = date.today().isoformat()

        self.costs_per_day[today] += cost
        self.costs_per_model[model] += cost
        self.calls_per_day[today] += 1
        self.total_tokens += input_tokens + output_tokens

        return cost

    def remaining_budget(self) -> float:
        """Visszaadja a mai napra fennmaradó költségvetést."""
        today = date.today().isoformat()
        return self.daily_budget - self.costs_per_day[today]

    def budget_alert(self) -> bool:
        """Ellenőrzi, hogy a költségvetés közel van-e a limithez."""
        remaining = self.remaining_budget()
        if remaining <= 0:
            print("ALERT: Daily budget exceeded!")
            return True
        elif remaining < self.daily_budget * 0.2:
            print(f"WARNING: ${remaining:.2f} remaining on daily budget")
            return True
        return False

    def report(self) -> dict:
        """Költségjelentést generál."""
        return {
            "total_cost_usd": sum(self.costs_per_day.values()),
            "cost_today_usd": self.costs_per_day.get(
                date.today().isoformat(), 0
            ),
            "remaining_budget_usd": self.remaining_budget(),
            "costs_per_model": dict(self.costs_per_model),
            "total_tokens": self.total_tokens,
        }

# Használat
tracker = CostTracker(daily_budget_usd=5.0)

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Hello!"
)

cost = tracker.record(
    model="gpt-5.6-terra",
    input_tokens=response.usage.input_tokens,
    output_tokens=response.usage.output_tokens
)
print(f"Cost of this call: ${cost:.6f}")
print(json.dumps(tracker.report(), indent=2))

Költségvetés-vezérelt kliens

A monitorozás nem mindig elég: egy hibás, folyamatosan API-t hívó ciklus esetén pénzügyi megszakítóra (circuit breaker) van szükséged. Ez a kliens a kérés elküldése előtt ellenőrzi a fennmaradó költségvetést, és határozottan elutasítja a hívást, ha a keret kimerült. A szolgáltatás degradálódik, de ellenőrzött módon, meglepetésszámlák nélkül. A költségelszámolás utólag történik, miután a tényleges használat ismertté vált.

class BudgetControlledClient:
    """Kliens, amely elutasítja a hívásokat, ha a költségvetés túllépi a limitet."""

    def __init__(self, daily_budget: float = 10.0):
        self.client = OpenAI()
        self.tracker = CostTracker(daily_budget_usd=daily_budget)

    def create(self, model: str, input: str, **kwargs) -> object:
        """API-hívás költségvetés-ellenőrzéssel."""
        # Költségvetés ellenőrzése a hívás előtt
        if self.tracker.remaining_budget() <= 0:
            raise RuntimeError(
                "Daily budget exhausted. "
                f"Spent: ${self.tracker.report()['cost_today_usd']:.2f}"
            )

        response = self.client.responses.create(
            model=model,
            input=input,
            **kwargs
        )

        cost = self.tracker.record(
            model=model,
            input_tokens=response.usage.input_tokens,
            output_tokens=response.usage.output_tokens
        )

        # Riasztás, ha alacsony a költségvetés
        self.tracker.budget_alert()

        return response

# Használat
budget_client = BudgetControlledClient(daily_budget=2.0)

try:
    response = budget_client.create("gpt-5.6-terra", "Hello!")
    print(response.output_text)
except RuntimeError as e:
    print(f"Blocked: {e}")

Költségek optimalizálása

1. A megfelelő modell kiválasztása

A leghatékonyabb eszköz továbbra is a komplexitás szerinti útvonalválasztás. Egy három kategóriás osztályozási feladatnak nincs szüksége a legdrágább modellre: ennél a feladatnál a számla különbsége huszonötszörös lehet azonos minőség mellett. Tedd a komplexitást a függvényed explicit paraméterévé, ne pedig a logikába hardcoded döntéssé.

# Relatív költség feladatonként (hozzávetőleges, ~300 bemeneti token / 20 kimeneti):
# Egyszerű osztályozás: gpt-5.6-luna ~0,0001 $ vs gpt-5.6-sol ~0,002 $
# A megfelelő modell 25-szörös különbséget jelent a költségekben!

def optimized_call(prompt: str, complexity: str) -> str:
    """Kiválasztja a leggazdaságosabb megfelelő modellt."""
    model = {
        "simple": "gpt-5.6-luna",
        "standard": "gpt-5.6-terra",
        "complex": "gpt-5.6-sol",
    }.get(complexity, "gpt-5.6-terra")

    response = client.responses.create(model=model, input=prompt)
    return response.output_text

2. Válaszok gyorsítótárazása

A második eszköz, hogy elkerüld ugyanazon válasz kétszeri kifizetését. Egy GYIK, termékkatalógus vagy szabványos űrlap naponta tucatszor generál szigorúan azonos promptokat. A gyorsítótár kulcsa egyesíti a modellt, a bemenetet és a paramétereket – mindet beleértve elengedhetetlen, különben egy hőmérséklet-változás csendesen a régi választ adná vissza.

import hashlib

class CachedClient:
    """Kliens gyorsítótárral a felesleges hívások elkerülésére."""

    def __init__(self):
        self.client = OpenAI()
        self.cache: dict[str, str] = {}

    def create(self, model: str, input: str, **kwargs) -> str:
        # Gyorsítótár kulcs létrehozása
        cache_key = hashlib.md5(
            f"{model}:{input}:{json.dumps(kwargs, sort_keys=True)}".encode()
        ).hexdigest()

        if cache_key in self.cache:
            print("Cache hit!")
            return self.cache[cache_key]

        response = self.client.responses.create(
            model=model, input=input, **kwargs
        )

        self.cache[cache_key] = response.output_text
        return response.output_text

3. Kimeneti tokenek korlátozása

Végül, korlátozd a kimenetet, amikor annak hossza előre jelezhető. Mivel a kimenet a drága rész, ha egyetlen szót kérsz, de engedélyezel kétezer tokent, az utat nyitja egy bőbeszédű válasz előtt, amit kifizetsz, de nem használsz fel.

# Mindig állítsd be a max_output_tokens értéket előre jelezhető feladatoknál
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Classify this text: positive, negative, or neutral.",
    max_output_tokens=10  # Egyetlen szóra számítunk
)

Árak 2026. augusztus 5-i állapot szerint — az árak rendszeresen változnak: bármilyen költségvetési számítás előtt ellenőrizd az aktuális ártáblázatot a hivatalos OpenAI árazási oldalon.

Főbb megállapítások

  • A költségek a modelltől ÉS az iránytól függenek (bemenet vs. kimenet)
  • Implementálj költségkövetőt költségvetési riasztásokkal
  • Használd a megfelelő modellt minden feladathoz: Luna nagy volumenhez, Terra alapértelmezettként
  • A gyorsítótárazás drasztikusan csökkentheti a költségeket az ismétlődő kéréseknél
  • Állítsd be a max_output_tokens értéket, ha a válasz hossza előre jelezhető
  • Ellenőrizd az OpenAI vezérlőpultot a hivatalos fogyasztáskövetéshez