Przejdź do głównej treści
Polski— Wybierz język
Menu

Optymalizacja kosztów na dużą skalę

Lekcja 10 z 20 Zaktualizowano 28 lipca 2026 Zaawansowany
Na tej stronie
  1. Koszt jako ograniczenie inżynierskie
  2. Wiedza o tym, gdzie uciekają pieniądze
  3. Cztery dźwignie redukcji
  4. Ostrzeżenia przed otrzymaniem rachunku
  5. Kluczowe wnioski

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