Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Monitorovanie nákladov a využitia

Lekcia 16 z 22 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Monitorovanie nákladov a využitia
  2. Pochopenie fakturácie
  3. Kalkulačka nákladov
  4. Tracker nákladov v reálnom čase
  5. Klient s kontrolou rozpočtu
  6. Optimalizácia nákladov
  7. Kľúčové poznatky

Monitorovanie nákladov a využitia

Náklady na API môžu rýchlo vymknúť kontrole, ak ich nesleduješ. V tejto lekcii sa naučíš, ako v produkčnom prostredí sledovať, odhadovať a kontrolovať svoje výdavky. Príbeh sa opakuje projekt od projektu: funkcia ide do prevádzky vo štvrtok, cez víkend nikto neskontroluje dashboard a pondelňajší účet sa rovná celému mesačnému rozpočtu. Nasledujúce kroky ti pomôžu zachytiť odklon nákladov v momente, keď nastane, nie až o tridsať dní neskôr.

Pochopenie fakturácie

Náklady sa计算ujú za milión tokenov, pričom ceny za vstup (input) a výstup (output) sa líšia. Táto asymetria má priame dôsledky pre tvoje dizajnové rozhodnutia: odoslanie dlhého dokumentu ako vstupu stojí výrazne menej, než keď model vygeneruje dlhý text. Každá odpoveď vráti presný počet tokenov pre oba smery, takže nikdy nemusíš odhadovať.

from openai import OpenAI
client = OpenAI()

# Every response includes usage metrics
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain OpenAI API billing."
)

usage = response.usage
print(f"Input tokens: {usage.input_tokens}")
print(f"Output tokens: {usage.output_tokens}")
print(f"Total tokens: {usage.total_tokens}")

# Output costs more than input!

Kalkulačka nákladov

Prevod týchto počítadiel na doláre si vyžaduje cenovú mriežku. Izoluj ju do vyhradenej štruktúry namiesto toho, aby si konštanty rozhadzoval po celom kóde: keď sa ceny zmenia alebo pridáš model, stačí upraviť jeden riadok. Nižšie uvedené sadzby sú orientačné a mali by sa overovať pri každej kontrole rozpočtu.

from dataclasses import dataclass

@dataclass
class ModelRate:
    input_per_million: float
    output_per_million: float

# Approximate prices in USD per million tokens
# Always check current prices on platform.openai.com/pricing
RATES = {
    "gpt-5.6-luna": ModelRate(input_per_million=0.20, output_per_million=1.20),
    "gpt-5.6-terra": ModelRate(input_per_million=2.0, output_per_million=12.0),
    "gpt-5.6-sol": ModelRate(input_per_million=5.0, output_per_million=30.0),
}

def calculate_cost(model: str, input_tokens: int,
                   output_tokens: int) -> float:
    """Calculates the cost of a call in USD."""
    rate = RATES.get(model)
    if not rate:
        raise ValueError(f"Unknown model: {model}")

    input_cost = (input_tokens / 1_000_000) * rate.input_per_million
    output_cost = (output_tokens / 1_000_000) * rate.output_per_million

    return input_cost + output_cost

# Example
cost = calculate_cost("gpt-5.6-terra", input_tokens=1000, output_tokens=500)
print(f"Cost: ${cost:.6f}")
# Result: Cost: $0.008000

Osem desatín centu za volanie znie upokojujúco, kým to nevynásobíš päťdesiatimi tisícmi denných volaní produkčného chatbota – to je štyristo dolárov denne. Vždy si zvykaj myslieť v mesačných objemoch, nikdy nie per volanie.

Tracker nákladov v reálnom čase

Výpočty jednotkových cien sú zbytočné, ak nie sú agregované. Tento tracker agreguje výdavky podľa troch osí – podľa dňa, podľa modelu a podľa počtu volaní – a porovnáva denný súčet s rozpočtom, ktorý si nastavil. Upozornenia sú gradované: varovanie, keď zostane menej ako 20 % rozpočtu, nasledované tvrdým alertom po prekročení limitu. Tento medzikrok je cenný, pretože ti dáva čas zasiahnuť skôr, než bude služba odstavená.

import json
from datetime import datetime, date
from collections import defaultdict

class CostTracker:
    """Real-time API cost tracking."""

    def __init__(self, daily_budget_usd: float = 10.0):
        self.daily_budget = daily_budget_usd
        self.costs_per_day: dict[str, float] = defaultdict(float)
        self.costs_per_model: dict[str, float] = defaultdict(float)
        self.calls_per_day: dict[str, int] = defaultdict(int)
        self.total_tokens = 0

    def record(self, model: str, input_tokens: int,
               output_tokens: int):
        """Records the costs of a call."""
        cost = calculate_cost(model, input_tokens, output_tokens)
        today = date.today().isoformat()

        self.costs_per_day[today] += cost
        self.costs_per_model[model] += cost
        self.calls_per_day[today] += 1
        self.total_tokens += input_tokens + output_tokens

        return cost

    def remaining_budget(self) -> float:
        """Returns the remaining budget for today."""
        today = date.today().isoformat()
        return self.daily_budget - self.costs_per_day[today]

    def budget_alert(self) -> bool:
        """Checks if the budget is close to the limit."""
        remaining = self.remaining_budget()
        if remaining <= 0:
            print("ALERT: Daily budget exceeded!")
            return True
        elif remaining < self.daily_budget * 0.2:
            print(f"WARNING: ${remaining:.2f} remaining on daily budget")
            return True
        return False

    def report(self) -> dict:
        """Generates a cost report."""
        return {
            "total_cost_usd": sum(self.costs_per_day.values()),
            "cost_today_usd": self.costs_per_day.get(
                date.today().isoformat(), 0
            ),
            "remaining_budget_usd": self.remaining_budget(),
            "costs_per_model": dict(self.costs_per_model),
            "total_tokens": self.total_tokens,
        }

# Usage
tracker = CostTracker(daily_budget_usd=5.0)

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Hello!"
)

cost = tracker.record(
    model="gpt-5.6-terra",
    input_tokens=response.usage.input_tokens,
    output_tokens=response.usage.output_tokens
)
print(f"Cost of this call: ${cost:.6f}")
print(json.dumps(tracker.report(), indent=2))

Klient s kontrolou rozpočtu

Monitorovanie nie vždy stačí: ak čelíš chybnému cyklu, ktorý neustále volá API, potrebuješ finančný istič. Tento klient skontroluje zostávajúci rozpočet pred vydaním požiadavky a ak je obálka vyčerpaná, volanie jednoducho odmietne. Služba sa degraduje, ale kontrolovaným spôsobom bez prekvapivých účtov. Účtovanie nákladov prebieha až afterward, keď je známe skutočné využitie.

class BudgetControlledClient:
    """Client that refuses calls if the budget is exceeded."""

    def __init__(self, daily_budget: float = 10.0):
        self.client = OpenAI()
        self.tracker = CostTracker(daily_budget_usd=daily_budget)

    def create(self, model: str, input: str, **kwargs) -> object:
        """API call with budget control."""
        # Check budget before the call
        if self.tracker.remaining_budget() <= 0:
            raise RuntimeError(
                "Daily budget exhausted. "
                f"Spent: ${self.tracker.report()['cost_today_usd']:.2f}"
            )

        response = self.client.responses.create(
            model=model,
            input=input,
            **kwargs
        )

        cost = self.tracker.record(
            model=model,
            input_tokens=response.usage.input_tokens,
            output_tokens=response.usage.output_tokens
        )

        # Alert if budget is low
        self.tracker.budget_alert()

        return response

# Usage
budget_client = BudgetControlledClient(daily_budget=2.0)

try:
    response = budget_client.create("gpt-5.6-terra", "Hello!")
    print(response.output_text)
except RuntimeError as e:
    print(f"Blocked: {e}")

Optimalizácia nákladov

1. Výber správneho modelu

Najsilnejšou pákou zostáva smerovanie podľa zložitosti. Úloha klasifikácie do troch kategórií nepotrebuje najdrahší model: pri tejto úlohe dosahuje rozdiel vo fakturácii násobok dvadsaťpäť pri identickej kvalite. Urob zo zložitosti explicitný parameter svojej funkcie namiesto rozhodnutia natvrdo zakódovaného v logike.

# Relative cost per task (approximate, ~300 input tokens / 20 output):
# Simple classification: gpt-5.6-luna ~$0.0001 vs gpt-5.6-sol ~$0.002
# The right model makes a 25x difference in costs!

def optimized_call(prompt: str, complexity: str) -> str:
    """Chooses the most economical suitable model."""
    model = {
        "simple": "gpt-5.6-luna",
        "standard": "gpt-5.6-terra",
        "complex": "gpt-5.6-sol",
    }.get(complexity, "gpt-5.6-terra")

    response = client.responses.create(model=model, input=prompt)
    return response.output_text

2. Ukladanie odpovedí do cache

Druhou pákou je vyhnutie sa platbe dvakrát za tú istú odpoveď. FAQ, katalóg produktov alebo štandardný formulár generujú desiatkykrát denne úplne totožné výzvy. Kľúč cache kombinuje model, vstup a parametre – zahrnutie všetkých je nevyhnutné, inak by zmena teploty ticho vrátila starú odpoveď.

import hashlib

class CachedClient:
    """Client with cache to avoid redundant calls."""

    def __init__(self):
        self.client = OpenAI()
        self.cache: dict[str, str] = {}

    def create(self, model: str, input: str, **kwargs) -> str:
        # Create a cache key
        cache_key = hashlib.md5(
            f"{model}:{input}:{json.dumps(kwargs, sort_keys=True)}".encode()
        ).hexdigest()

        if cache_key in self.cache:
            print("Cache hit!")
            return self.cache[cache_key]

        response = self.client.responses.create(
            model=model, input=input, **kwargs
        )

        self.cache[cache_key] = response.output_text
        return response.output_text

3. Obmedzenie výstupných tokenov

Nakoniec, vždy obmedz výstup tam, kde je jeho dĺžka predvídateľná. Keďže výstup je drahšia časť, požiadavka na jedno slovo pri povolení dvoch tisíc tokenov necháva dvere otvorené pre ukecanú odpoveď, za ktorú zaplatíš, ale nevyužiješ ju.

# Always set max_output_tokens for predictable tasks
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Classify this text: positive, negative, or neutral.",
    max_output_tokens=10  # Expecting a single word
)

Sadzby platné k 5. augustu 2026 – ceny sa pravidelne menia: pred akýmkoľvek výpočtom rozpočtu si over aktuálnu mriežku na oficiálnej stránke s cenami OpenAI.

Kľúčové poznatky

  • Náklady závisia od modelu A smeru (vstup vs. výstup)
  • Implementuj tracker nákladov s alertmi pre rozpočet
  • Používaj správny model pre každú úlohu: Luna pre objem, Terra ako predvolený
  • Cache môže drasticky znížiť náklady pri opakovaných požiadavkách
  • Nastav max_output_tokens, keď je dĺžka odpovede predvídateľná
  • Kontroluj dashboard OpenAI pre oficiálne sledovanie spotreby