Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Optimalizace nákladů ve velkém měřítku

Lekce 10 z 20 Aktualizováno 28. července 2026 Pokročilý
Na této stránce
  1. Náklady jako inženýrské omezení
  2. Vědět, kam peníze jdou
  3. Čtyři páky pro snížení nákladů
  4. Upozornění před příchodem faktury
  5. Klíčové poznatky

Náklady jako inženýrské omezení

Špatně optimalizovaný prompt, který stojí 0,002 $ za volání, je během vývoje zanedbatelný. Při milionu volání však stojí 2 000 $ – a bude tě to stát tolik každý měsíc, dokud ho někdo nepřepíše. Tento posun v měřítku mění náklady na inženýrské omezení: neřešíš je vyjednáváním smlouvy, ale změnou kódu.

Viditelnost je předpokladem jakékoli optimalizace. Měsíční faktura ti řekne, kolik jsi utratil, ale ne kde. Proto tato lekce začíná instrumentací, až poté přechází k pákám pro snížení nákladů.

Vědět, kam peníze jdou

Cenu volání určují čtyři prvky a každý se chová jinak. Vstupní tokeny, které zahrnují systémový prompt, historii konverzace a zprávu uživatele, rostou s délkou relace. Výstupní tokeny – tedy generovaná odpověď – jsou účtovány výrazně dráže než vstup. Tokeny vstupů z mezipaměti (cached input) mají slevu přibližně 50 % oproti běžné vstupní sazbě, takže jejich sledování je klíčové pro pochopení jakékoli faktury. A nakonec samotný model: GPT-5.6 Luna je mnohem levnější než GPT-5.6 Sol a tento faktor převyšuje všechny ostatní.

Sledování znamená převést každý objekt usage vrácený API na dolarovou částku, aplikovat správnou sazbu a izolovat část z mezipaměti.

import openai
from dataclasses import dataclass, field

client = openai.OpenAI()

# Sazby za milion tokenů (červenec 2026) — cached_input je orientační (~50 % vstupu),
# upravte podle oficiálního ceníku
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álném č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 "Žádná volání nezaznamenána."
        return (
            f"Volání: {len(self.calls)} | "
            f"Celkové náklady: ${self.total_cost:.4f} | "
            f"Průměrné náklady: ${self.total_cost / len(self.calls):.6f}"
        )

tracker = CostTracker()

Tabulka RATES vyžaduje neustálou pozornost: zastarává hned, jak se změní oficiální ceník. Zacházej s ní jako s konfiguračními daty, která je třeba ověřovat, nikoliv jako s programovou konstantou, a průměrné náklady na volání měř jako metriku, kterou kontroluješ týdně.

Čtyři páky pro snížení nákladů

První páka a zdaleka nejvýnosnější je vyhnout se placení za špičkový model, když úkol jeho možnosti nevyžaduje. Explicitní směrování založené na složitosti zabraňuje běžnému skluzu, kdy veškerý provoz skončí na nejdražším modelu pouze proto, že se objevil v prvním zkopírovaném příkladu.

async def economic_router(prompt: str, complexity: str) -> str:
    """Směruje na nejlevnější model, který úkol 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 jde ještě dál, když není složitost předem známá. Místo klasifikace požadavku se kaskáda nejprve pokusí použít nejlevnější model a eskaluje pouze tehdy, pokud odpověď neprojde kontrolou kvality. Zde použitá kontrola je záměrně rudimentární – minimální délka a absence přiznání nevědomosti – a právě toto budeš muset vylepšit: kaskáda, která eskaluje příliš často, vyjde dráže než přímé volání správného modelu.

async def model_cascade(prompt: str) -> str:
    """Nejprve zkusí nejlevnější 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ýsledek, i když není dokonalý

Třetí páka cílí na vstupní tokeny, které v jakékoli konverzační aplikaci tiše rostou: u dvacátého obratu platíš za každou zprávu znovu za předchozích devatenáct. Komprese historie zachováním první zprávy (která drží kontext) a poslední (která drží otázku) a vyplněním zbývajícího rozpočtu nejnovějšími výměnami zachovává zásadní soudržnost za zlomek nákladů.

def compress_history(
    messages: list[dict],
    max_tokens: int = 4000,
) -> list[dict]:
    """Udrží v rozpočtu pouze nejnovější zprávy."""
    # Vždy zachovej první (kontext) a poslední (otázka)
    if len(messages) <= 2:
        return messages

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

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

    # Zachovej nejnovější zprá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 algoritmickou finesu, pouze disciplínu: Batch API nabízí snížení o 50 % a stačí jen identifikovat, co může počkat. Nech úkol nést naléhavost již od svého vzniku, místo abys ji odvozoval dodatečně – to je jediný způsob, jak zabránit tomu, aby vše implicitně směřovalo do fronty pro zpracování v reálném čase.

def classify_urgency(tasks: list[dict]) -> dict:
    """Rozdělí úkoly na reálný č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,  # Příklad
    }

Upozornění před příchodem faktury

Všechny tyto optimalizace může zničit jediné nešťastné nasazení: neomezená smyčka opakování, ztrojnásobený systémový prompt nebo omylem změněný model. Alert na náklady je bezpečnostní síť, která tě upozorní během hodin, nikoliv až na konci měsíce. Všimni si průběžného prahu na 80 %: mění brutální poplach v ранний signál, který ti dá čas jednat před překročením limitu.

class CostAlert:
    """Spustí alerty, když náklady překročí práh."""

    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"překračují práh ${self.threshold:.2f}"
            )
        if self.tracker.total_cost > self.threshold * 0.8:
            return (
                f"WARNING: náklady na {self.tracker.total_cost / self.threshold:.0%} "
                f"denního prahu"
            )
        return None

Klíčové poznatky

  • Sleduj své náklady v reálném čase pomocí response.usage
  • Směruj požadavky na nejlevnější model, který úkol zvládne
  • Pro vše, co nevyžaduje zpracování v reálném čase, použij Batch API (–50 %)
  • Sniž počet vstupních tokenů kompresí historie
  • Nastav si alerty na náklady, abys předešel překvapením