Optimizacija troškova u velikom obujmu
Na ovoj stranici
Trošak kao inženjersko ograničenje
Loše optimiziran upit koji košta 0,002 USD po pozivu zanemariv je tijekom razvoja. Pri milijun poziva to iznosi 2000 USD – i taj će te iznos koštati svaki mjesec dok ga netko ne prepiše. Taj skok u obujmu pretvara trošak u inženjersko ograničenje: ne rješavaš ga pregovaranjem ugovora, već promjenom koda.
Vidljivost je preduvjet svake optimizacije. Mjesečni račun govori ti koliko si potrošio, a ne gdje. Zato ova lekcija počinje instrumentiranjem prije nego što prijeđe na poluge za smanjenje troškova.
Gdje novac odlazi
Četiri elementa određuju cijenu poziva i ne ponašaju se jednako. Ulazni tokeni, koji objedinjuju sistemski upit, povijest razgovora i korisničku poruku, rastu s trajanjem sesije. Izlazni tokeni – generirani odgovor – naplaćuju se znatno više od ulaznih. Keširani ulazni tokeni imaju otprilike 50 % popusta na ulaznu stopu, pa je njihovo praćenje ključno za razumijevanje bilo kojeg računa. Konačno, sam model: GPT-5.6 Luna znatno je jeftiniji od GPT-5.6 Sol, a taj faktor nadmašuje sve ostale.
Praćenje znači pretvoriti svaki objekt usage koji API vrati u iznos u dolarima, primijeniti ispravnu stopu i izdvojiti keširani dio.
import openai
from dataclasses import dataclass, field
client = openai.OpenAI()
# Rates per million tokens (July 2026) — cached_input is indicative (~50% of input),
# adjust according to the official pricing grid
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:
"""Tracks costs in real time."""
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 "No calls recorded."
return (
f"Calls: {len(self.calls)} | "
f"Total cost: ${self.total_cost:.4f} | "
f"Average cost: ${self.total_cost / len(self.calls):.6f}"
)
tracker = CostTracker()
Tablica RATES zahtijeva stalnu pozornost: zastarije čim se promijeni službena cjenovna lista. Tretiraj je kao konfiguracijske podatke koje trebaš provjeravati, a ne kao programske konstante, i učini prosječni trošak po pozivu metrikom koju pregledavaš tjedno.
Četiri poluge za smanjenje
Prva i daleko najisplativija poluga izbjegavanje je plaćanja vrhunskog modela kada zadatak to ne zahtijeva. Eksplicitno usmjeravanje na temelju složenosti sprječava zadano klizanje gdje sav promet završi na najskupljem modelu samo zato što se pojavio u prvom kopiranom primjeru.
async def economic_router(prompt: str, complexity: str) -> str:
"""Routes to the cheapest capable model."""
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
Druga poluga ide dalje kada složenost unaprijed nije poznata. Umjesto klasificiranja zahtjeva, kaskada prvo isprobava najjeftiniji model i eskalira samo ako odgovor ne prođe provjeru kvalitete. Ovdje korištena provjera namjerno je rudimentarna – minimalna duljina i odsutnost priznanja neznanja – i to je točka koju ćeš morati doraditi: kaskada koja prečesto eskalira postaje skuplja od izravnog poziva ispravnom modelu.
async def model_cascade(prompt: str) -> str:
"""Tries the cheapest model first."""
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)
# Check quality (simple heuristic)
text = response.output_text
if len(text) > 50 and "i don't know" not in text.lower():
return text
return text # Last result even if imperfect
Treća poluga cilja ulazne tokene, koji tiho rastu u svakoj konverzacijskoj aplikaciji: do dvadesetog okreta, svakom porukom ponovno plaćaš prethodnih devetnaest. Kompresijom povijesti tako da zadržiš prvu poruku (koja nosi kontekst) i zadnju (koja nosi pitanje), a preostali budžet popuniš najnovijim razmjenama, čuvaš bitnu koherentnost uz djelić troška.
def compress_history(
messages: list[dict],
max_tokens: int = 4000,
) -> list[dict]:
"""Keeps the most recent messages within budget."""
# Always keep the first (context) and last (question)
if len(messages) <= 2:
return messages
first = messages[0]
last = messages[-1]
middle = messages[1:-1]
# Estimate tokens (approximation: 1 token ≈ 4 characters)
fixed_tokens = (len(first["content"]) + len(last["content"])) // 4
middle_budget = max_tokens - fixed_tokens
# Keep the most recent messages
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]
Četvrta poluga ne zahtijeva algoritamsku finesu, već disciplinu: Batch API nudi smanjenje od 50 %, a trebaš samo identificirati što može pričekati. Neka sam zadatak nosi hitnost od svog nastanka, umjesto da je naknadno zaključuješ – to je jedini način da spriječiš da sve zadano ne završi u redu za obradu u stvarnom vremenu.
def classify_urgency(tasks: list[dict]) -> dict:
"""Separates tasks into real-time 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, # Example
}
Upozorenja prije računa
Sve ove optimizacije može poništiti jedan nesretan deployment: petlja ponovnih pokušaja bez ograničenja, utrostručeni sistemski upit, model pogrešno promijenjen. Upozorenje o trošku sigurnosna je mreža koja te upozori unutar sati, a ne na kraju mjeseca. Obrati pozornost na međuprag od 80 %: on pretvara brutalni alarm u rani signal, dajući ti vremena da djeluješ prije nego što prijeđeš ograničenje.
class CostAlert:
"""Triggers alerts when costs exceed a threshold."""
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: daily cost ${self.tracker.total_cost:.2f} "
f"exceeds threshold of ${self.threshold:.2f}"
)
if self.tracker.total_cost > self.threshold * 0.8:
return (
f"WARNING: cost at {self.tracker.total_cost / self.threshold:.0%} "
f"of daily threshold"
)
return None
Ključne točke
- Prati troškove u stvarnom vremenu koristeći
response.usage - Usmjeri zahtjev na najjeftiniji model sposoban izvršiti zadatak
- Koristi Batch API (-50 %) za sve što ne zahtijeva obradu u stvarnom vremenu
- Smanji ulazne tokene kompresijom povijesti
- Postavi upozorenja o troškovima kako bi izbjegao iznenađenja