Optimalizace nákladů ve velkém měřítku
Na této stránce
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