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

Költségek optimalizálása nagy léptékben

10. lecke 20 közül Frissítve 2026. július 28. Haladó
Ezen az oldalon
  1. A költség mint mérnöki korlát
  2. Hol fogy a pénz
  3. Négy csökkentési kar
  4. Figyelmeztetés a számla előtt
  5. Főbb megállapítások

A költség mint mérnöki korlát

Egy rosszul optimalizált, hívásonként 0,002 dollárba kerülő prompt a fejlesztés során elhanyagolhatónak tűnhet. egymillió hívásnál ez már 2000 dollárt jelent – és ennyibe kerül majd minden hónapban, amíg valaki át nem írja. A méretarányok e változása a költséget mérnöki korláttá teszi: nem szerződésmódosítással oldod meg, hanem a kód átalakításával.

A láthatóság minden optimalizálás előfeltétele. A havi számla megmutatja, mennyit költöttél, de azt nem, hogy mire. Ezért kezdjük ezt a leckét a műszerezéssel (instrumentation), mielőtt rátérnénk a csökkentési lehetőségekre.

Hol fogy a pénz

Négy tényező határozza meg egy hívás költségét, és ezek nem ugyanúgy viselkednek. A bemeneti tokenek, amelyek aggregálják a rendszerpromptot, a beszélgetés előzményeit és a felhasználói üzenetet, a munkamenet időtartamával nőnek. A kimeneti tokenek – azaz a generált válasz – jelentősen drágábbak, mint a bemenetiek. A gyorsítótárazott bemeneti tokenek körülbelül 50%-os kedvezményt kapnak a bemeneti árból, így nyomon követésük elengedhetetlen bármely számla megértéséhez. Végül maga a modell: a GPT-5.6 Luna sokkal olcsóbb, mint a GPT-5.6 Sol, és ez a tényező minden mást felülmúl.

A nyomon követés azt jelenti, hogy az API által visszaadott minden usage objektumot dollárra váltasz, alkalmazod a megfelelő díjszabást, és elkülöníted a gyorsítótárazott részt.

import openai
from dataclasses import dataclass, field

client = openai.OpenAI()

# Díjak milliónyi tokenenként (2026. július) — a cached_input tájékoztató jellegű (~50% a bemenetből),
# igazítsd a hivatalos ártáblázat szerint
RATES = {
    "gpt-5.6-luna": {"input": 0.20, "output": 1.20, "cached_input": 0.02},
    "gpt-5.6-terra": {"input": 2.00, "output": 12.00, "cached_input": 0.20},
    "gpt-5.6-sol": {"input": 5.00, "output": 30.00, "cached_input": 0.50},
}

@dataclass
class CostTracker:
    """Valós idejű költségnyomon követés."""
    calls: list[dict] = field(default_factory=list)

    def record(self, model: str, usage: dict) -> float:
        input_tokens = usage.input_tokens
        cached_tokens = getattr(
            usage.input_tokens_details, "cached_tokens", 0
        )
        output_tokens = usage.output_tokens
        uncached_input_tokens = input_tokens - cached_tokens

        rate = RATES.get(model, RATES["gpt-5.6-terra"])
        cost = (
            (uncached_input_tokens / 1_000_000) * rate["input"]
            + (cached_tokens / 1_000_000) * rate["cached_input"]
            + (output_tokens / 1_000_000) * rate["output"]
        )

        self.calls.append({
            "model": model,
            "input_tokens": input_tokens,
            "cached_tokens": cached_tokens,
            "output_tokens": output_tokens,
            "cost": cost,
        })
        return cost

    @property
    def total_cost(self) -> float:
        return sum(a["cost"] for a in self.calls)

    def report(self) -> str:
        if not self.calls:
            return "Nincs rögzített hívás."
        return (
            f"Hívások: {len(self.calls)} | "
            f"Összköltség: ${self.total_cost:.4f} | "
            f"Átlagos költség: ${self.total_cost / len(self.calls):.6f}"
        )

tracker = CostTracker()

A RATES táblázat folyamatos figyelmet igényel: amint a hivatalos ártáblázat változik, elavulttá válik. Kezeld konfigurációs adatként, amelyet ellenőrizni kell, ne pedig programkonstansként, és tedd a hívásonkénti átlagos költséget heti szinten áttekintett metrikává.

Négy csökkentési kar

Az első és messze legjövedelmezőbb kar annak elkerülése, hogy csúcskategóriás modellért fizess, amikor a feladat nem igényli azt. A komplexitás alapján történő explicit útvonalválasztás megakadályozza azt a默认的 elcsúszást, amikor minden forgalom a legdrágább modellen landol pusztán azért, mert az jelent meg az első lemásolt példában.

async def economic_router(prompt: str, complexity: str) -> str:
    """A legolcsóbb, alkalmas modellre irányít."""
    if complexity == "simple":
        model = "gpt-5.6-luna"
    elif complexity == "medium":
        model = "gpt-5.6-terra"
    else:
        model = "gpt-5.6-sol"

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

A második kar tovább megy, amikor a komplexitás nem ismert előre. A kérés osztályozása helyett a kaszkád először a legolcsóbb modellt próbálja ki, és csak akkor lép feljebb, ha a válasz nem megy át egy minőségellenőrzésen. Az itt használt ellenőrzés szándékosan egyszerűsített – egy minimális hossz és a tudatlanság beismerésének hiánya –, és pontosan ezt a pontot kell majd finomítanod: egy túl gyakran feljebb lépő kaszkád drágábbá válik, mint a megfelelő modellhez intézett közvetlen hívás.

async def model_cascade(prompt: str) -> str:
    """Először a legolcsóbb modellt próbálja ki."""
    models = ["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol"]

    for model in models:
        response = client.responses.create(
            model=model,
            input=prompt,
            max_output_tokens=500,
        )
        tracker.record(model, response.usage)

        # Minőségellenőrzés (egyszerű heurisztika)
        text = response.output_text
        if len(text) > 50 and "i don't know" not in text.lower():
            return text

    return text  # Utolsó eredmény, még ha nem is tökéletes

A harmadik kar a bemeneti tokeneket célozza meg, amelyek bármely beszélgetésalapú alkalmazásban csendesen növekednek: a huszadik fordulóra már a megelőző tizenkilencet is újra fizeted minden egyes üzenettel. Az előzmények tömörítése úgy, hogy megtartod az első üzenetet (ami a kontextust hordozza) és az utolsót (ami a kérdést tartalmazza), majd a fennmaradó keretet a legfrissebb váltásokkal töltöd fel, a lényeges koherenciát a költség töredékéért őrzi meg.

def compress_history(
    messages: list[dict],
    max_tokens: int = 4000,
) -> list[dict]:
    """Megőrzi a legfrissebb üzeneteket a kereten belül."""
    # Mindig tartsd meg az elsőt (kontextus) és az utolsót (kérdés)
    if len(messages) <= 2:
        return messages

    first = messages[0]
    last = messages[-1]
    middle = messages[1:-1]

    # Tokenek becslése (közelítés: 1 token ≈ 4 karakter)
    fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
    middle_budget = max_tokens - fixed_tokens

    # Tartsd meg a legfrissebb üzeneteket
    result = []
    tokens_used = 0
    for msg in reversed(middle):
        msg_tokens = len(msg["content"]) // 4
        if tokens_used + msg_tokens > middle_budget:
            break
        result.insert(0, msg)
        tokens_used += msg_tokens

    return [first] + result + [last]

A negyedik karhoz nincs szükség algoritmikus fineszre, csak fegyelemre: a Batch API 50%-os csökkentést kínál, és csak azt kell azonosítanod, ami várhat. Hagyd, hogy maga a feladat hordozza a sürgősséget a létrehozásától kezdve, ahelyett, hogy utólag következtetnél rá – ez az egyetlen módja annak, hogy megakadályozd: minden alapértelmezetten a valós idejű sorba kerüljön.

def classify_urgency(tasks: list[dict]) -> dict:
    """Szétválasztja a feladatokat valós idejű és kötegelt kategóriákra."""
    real_time = []
    batch = []

    for task in tasks:
        if task.get("urgency") == "immediate":
            real_time.append(task)
        else:
            batch.append(task)

    return {
        "real_time": real_time,
        "batch": batch,
        "estimated_savings": len(batch) * 0.001,  # Példa
    }

Figyelmeztetés a számla előtt

Ezeket az optimalizálásokat egyetlen szerencsétlen telepítés semmisítheti meg: egy korlátlan újrapróbálkozási ciklus, egy megháromszorozott rendszerprompt, egy véletlenül megváltoztatott modell. A költségriasztás az a biztonsági háló, amely órákon belül figyelmeztet, nem pedig a hónap végén. Figyeld meg a 80%-os köztes küszöbértéket: ez a brutális riasztást korai jelzéssé alakítja, időt adva neked a cselekvésre, mielőtt túllépnéd a limitet.

class CostAlert:
    """Riasztást indít, ha a költségek meghaladnak egy küszöbértéket."""

    def __init__(self, daily_threshold: float = 50.0):
        self.threshold = daily_threshold
        self.tracker = CostTracker()

    def check(self) -> str | None:
        if self.tracker.total_cost > self.threshold:
            return (
                f"RIASZTÁS: a napi költség ${self.tracker.total_cost:.2f} "
                f"meghaladja a ${self.threshold:.2f} küszöbértéket"
            )
        if self.tracker.total_cost > self.threshold * 0.8:
            return (
                f"FIGYELMEZTETÉS: a költség a napi küszöbérték "
                f"{self.tracker.total_cost / self.threshold:.0%}-ánál tart"
            )
        return None

Főbb megállapítások

  • Kövesd nyomon a költségeidet valós időben a response.usage segítségével
  • Irányítsd a kéréseket a feladatra képes legolcsóbb modellre
  • Használd a Batch API-t (-50%) mindenre, ami nem igényel valós idejű feldolgozást
  • Csökkentsd a bemeneti tokeneket az előzmények tömörítésével
  • Állíts be költségriasztásokat a meglepetések elkerülése érdekében