Optymalizacja kosztów na dużą skalę
Na tej stronie
Koszt jako ograniczenie inżynierskie
Słabo zoptymalizowany prompt kosztujący 0,002 USD za wywołanie jest pomijalny podczas rozwoju. Przy milionie wywołań koszt ten wynosi 2000 USD – i będzie Cię obciążał co miesiąc, dopóki ktoś go nie przepisze. Ta zmiana skali przekształca koszt w ograniczenie inżynierskie: nie rozwiążesz go, negocjując umowę, lecz zmieniając kod.
Widoczność jest warunkiem wstępnej każdej optymalizacji. Miesięczny rachunek mówi Ci, ile wydałeś, ale nie gdzie. Dlatego lekcja ta zaczyna się od instrumentacji, zanim przejdzie do dźwigni redukcji kosztów.
Wiedza o tym, gdzie uciekają pieniądze
Cztery elementy determinują koszt wywołania i nie zachowują się one tak samo. Tokeny wejściowe, które agregują prompt systemowy, historię rozmowy i wiadomość użytkownika, rosną wraz z czasem trwania sesji. Tokeny wyjściowe – czyli wygenerowana odpowiedź – są rozliczane znacznie drożej niż tokeny wejściowe. Zbuforowane tokeny wejściowe otrzymują rabat wynoszący około 50% stawki za tokeny wejściowe, co czyni ich śledzenie niezbędnym do zrozumienia dowolnego rachunku. Na koniec sam model: GPT-5.6 Luna jest znacznie tańszy niż GPT-5.6 Sol, a czynnik ten dominuje nad wszystkimi innymi.
Śledzenie oznacza konwersję każdego obiektu usage zwracanego przez API na kwotę w dolarach, zastosowanie właściwej stawki i wyizolowanie części zbuforowanej.
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()
Tabela RATES wymaga stałej uwagi: staje się nieaktualna natychmiast po zmianie oficjalnego cennika. Traktuj ją jako dane konfiguracyjne do weryfikacji, a nie jako stałą programistyczną, i sprawdzaj średni koszt jednego wywołania jako metrykę przeglądany co tydzień.
Cztery dźwignie redukcji
Pierwsza dźwignia, zdecydowanie najbardziej opłacalna, to unikanie płacenia za model wysokiej klasy, gdy zadanie tego nie wymaga. Jawne routowanie oparte na złożoności zapobiega domyślnemu dryfowi, w którym cały ruch trafia do najdroższego modelu jedynie dlatego, że pojawił się on w pierwszym skopiowanym przykładzie.
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 dźwignia idzie dalej, gdy złożoność nie jest znana z góry. Zamiast klasyfikować żądanie, kaskada najpierw próbuje najtańszego modelu i eskaluje tylko wtedy, gdy odpowiedź nie przejdzie kontroli jakości. Kontrola użyta tutaj jest celowo prymitywna – minimalna długość i brak przyznania się do niewiedzy – i to jest punkt, który będziesz musiał dopracować: kaskada, która eskaluje zbyt często, staje się droższa niż bezpośrednie wywołanie właściwego 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
Trzecia dźwignia celuje w tokeny wejściowe, które cicho rosną w każdej aplikacji konwersacyjnej: przy dwudziestej turze płacisz za poprzednie dziewiętnaście z każdą wiadomością. Kompresja historii poprzez zachowanie pierwszej wiadomości (która zawiera kontekst) i ostatniej (która zawiera pytanie), a następnie wypełnienie pozostałego budżetu najbardziej świeżymi wymianami, zachowuje niezbędną spójność przy ułamku kosztów.
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]
Czwarta dźwignia nie wymaga finezji algorytmicznej, jedynie dyscypliny: Batch API oferuje redukcję o 50%, a Ty musisz jedynie zidentyfikować to, co może poczekać. Pozwól, aby samo zadanie niosło pilność od momentu swojego utworzenia, zamiast wnioskować o niej afterward – to jedyny sposób, aby zapobiec domyślnemu kierowaniu wszystkiego do kolejki czasu rzeczywistego.
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
}
Ostrzeżenia przed otrzymaniem rachunku
Wszystkie te optymalizacje mogą zostać zniweczone przez jedno pechowe wdrożenie: nieskończona pętla ponawiania prób, potrojony prompt systemowy, model zmieniony przez pomyłkę. Alert kosztowy to siatka bezpieczeństwa, która ostrzeże Cię w ciągu godzin, a nie na koniec miesiąca. Zwróć uwagę na próg pośredni na poziomie 80%: zamienia on brutalny alarm w wczesny sygnał, dając Ci czas na działanie przed przekroczeniem limitu.
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
Kluczowe wnioski
- Śledź swoje koszty w czasie rzeczywistym, używając
response.usage - Kieruj ruch do najtańszego modelu zdolnego do wykonania zadania
- Używaj Batch API (-50%) dla wszystkiego, co nie wymaga przetwarzania w czasie rzeczywistym
- Redukuj tokeny wejściowe poprzez kompresję historii
- Skonfiguruj alerty kosztowe, aby uniknąć niespodzianek