Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Optimalizácia nákladov vo veľkom meradle

Lekcia 10 z 20 Aktualizované 28. júla 2026 Pokročilý
Na tejto strane
  1. Náklady ako inžinierske obmedzenie
  2. Vedieť, kam peniaze idú
  3. Štyri páky na znižovanie nákladov
  4. Dostať varovanie pred účtom
  5. Kľúčové poznatky

Náklady ako inžinierske obmedzenie

Zle optimalizovaný prompt, ktorý stojí 0,002 $ za volanie, je počas vývoja zanedbateľný. Pri milióne volaní to však znamená 2 000 $ – a bude ťa to stáť toľko každý mesiac, kým to niekto neprepíše. Tento posun v rozsahu mení náklady na inžinierske obmedzenie: neriešiš ho vyjednávaním zmluvy, ale zmenou kódu.

Viditeľnosť je predpokladom akejkoľvek optimalizácie. Mesačný účet ti povie, koľko si minul, nie kde. Preto táto lekcia začína inštrumentáciou až potom prechádza k pákam na znižovanie nákladov.

Vedieť, kam peniaze idú

Náklady na volanie určujú štyri prvky a každý sa správa inak. Vstupné tokeny, ktoré zahŕňajú systémový prompt, históriu konverzácie a správu používateľa, rastú s dĺžkou relácie. Výstupné tokeny – generovaná odpoveď – sú fakturované výrazne drahšie ako vstupné. Tokeny vstupnej medzipamäte (cache) získavajú približne 50 % zľavu oproti vstupnej sadzbe, preto je ich sledovanie kľúčové pre pochopenie akéhokoľvek účtu. Nakoniec je tu samotný model: GPT-5.6 Luna je oveľa lacnejší ako GPT-5.6 Sol a tento faktor dominuje všetkým ostatným.

Sledovanie znamená previesť každý objekt usage vrátený API na dolárovú sumu, aplikovať správnu sadzbu a izolovať časť z medzipamäte.

import openai
from dataclasses import dataclass, field

client = openai.OpenAI()

# Sadzby za milión tokenov (júl 2026) — cached_input je orientačné (~50 % zo vstupu),
# upravte podľa oficiálneho cenníka
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:
    """Sleduje náklady v reálnom čase."""
    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 "Žiadne volania neboli zaznamenané."
        return (
            f"Volania: {len(self.calls)} | "
            f"Celkové náklady: ${self.total_cost:.4f} | "
            f"Priemerné náklady: ${self.total_cost / len(self.calls):.6f}"
        )

tracker = CostTracker()

Tabuľka RATES si vyžaduje neustálu pozornosť: zastará hneď, ako sa zmení oficiálny cenník. Považuj ju za konfiguračné údaje, ktoré treba overovať, nie za programovú konštantu, a urob z priemerných nákladov na volanie metriku, ktorú budeš týždenne kontrolovať.

Štyri páky na znižovanie nákladov

Prvou pákou a zďaleka najvýhodnejšou je vyhnúť sa plateniu za špičkový model, keď úloha jeho výkon nevyžaduje. Explicitné smerovanie založené na zložitosti zabraňuje postupnému driftu, pri ktorom sa všetka premávka skončí na najdrahšom modeli len preto, že sa objavil v prvom skopírovanom príklade.

async def economic_router(prompt: str, complexity: str) -> str:
    """Smeruje na najlacnejší model, ktorý úlohu zvládne."""
    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

Druhá páka ide ešte ďalej, keď nie je zložitosť vopred známa. Namiesto klasifikácie požiadavky sa kaskáda najprv pokúsi použiť najlacnejší model a eskaluje len vtedy, ak odpoveď neprejde kontrolou kvality. Kontrola použitá tu je zámerne rudimentárna – minimálna dĺžka a absencia priznania nevedomosti – a práve toto je bod, ktorý budeš musieť vylepšiť: kaskáda, ktorá eskaluje príliš často, sa stane drahšou než priame volanie správneho modelu.

async def model_cascade(prompt: str) -> str:
    """Najprv skúsi najlacnejší model."""
    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)

        # Kontrola kvality (jednoduchá heuristika)
        text = response.output_text
        if len(text) > 50 and "i don't know" not in text.lower():
            return text

    return text  # Posledný výsledok, aj keď nie je dokonalý

Tretia páka cieli na vstupné tokeny, ktoré v akejkoľvek konverzačnej aplikácii ticho rastú: pri dvadsiatom kole platíš za každú správu aj za predchádzajúcich devätnásť. Kompresia histórie zachovaním prvej správy (ktorá drží kontext) a poslednej (ktorá drží otázku) a vyplnením zostávajúceho rozpočtu najnovšími výmenami zachováva základnú koherenciu za zlomok nákladov.

def compress_history(
    messages: list[dict],
    max_tokens: int = 4000,
) -> list[dict]:
    """Udrží najnovšie správy v rámci rozpočtu."""
    # Vždy zachovaj prvú (kontext) a poslednú (otázka)
    if len(messages) <= 2:
        return messages

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

    # Odhad tokenov (aproximácia: 1 token ≈ 4 znaky)
    fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
    middle_budget = max_tokens - fixed_tokens

    # Zachovaj najnovšie správy
    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]

Štvrtá páka nevyžaduje algoritmickú finesu, iba disciplínu: Batch API ponúka 50 % zľavu a stačí identifikovať, čo môže počkať. Nechaj úlohu niesť naliehavosť už od jej vytvorenia, namiesto toho, aby si ju odvodzoval dodatočne – toto je jediný spôsob, ako zabrániť tomu, aby všetko implicitne smerovalo do fronty reálneho času.

def classify_urgency(tasks: list[dict]) -> dict:
    """Rozdeľuje úlohy na reálny čas vs. batch."""
    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,  # Príklad
    }

Dostať varovanie pred účtom

Všetky tieto optimalizácie môže zničiť jediné nešťastné nasadenie: neobmedzená slučka opakovaných pokusov, strojnásobený systémový prompt alebo omylom zmenený model. Upozornenie na náklady je bezpečnostnou sieťou, ktorá ťa varuje v priebehu hodín, nie až na konci mesiaca. Všimni si stredný prah na 80 %: mení brutálny alarm na včasný signál, ktorý ti dáva čas konať skôr, ako prekročíš limit.

class CostAlert:
    """Spúšťa upozornenia, keď náklady prekročia prah."""

    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"ALERT: denné náklady ${self.tracker.total_cost:.2f} "
                f"prekročili prah ${self.threshold:.2f}"
            )
        if self.tracker.total_cost > self.threshold * 0.8:
            return (
                f"WARNING: náklady dosiahli {self.tracker.total_cost / self.threshold:.0%} "
                f"denného prahu"
            )
        return None

Kľúčové poznatky

  • Sleduj svoje náklady v reálnom čase pomocou response.usage
  • Smeruj požiadavky na najlacnejší model, ktorý úlohu zvládne
  • Pre všetko, čo nevyžaduje spracovanie v reálnom čase, použi Batch API (-50 %)
  • Znižuj počet vstupných tokenov kompresiou histórie
  • Nastav si upozornenia na náklady, aby ťa nič neprekvapilo