Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Monitorování nákladů a využití

Lekce 16 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Monitorování nákladů a využití
  2. Porozumění fakturaci
  3. Kalkulačka nákladů
  4. Tracker nákladů v reálném čase
  5. Klient s kontrolou rozpočtu
  6. Optimalizace nákladů
  7. Klíčové poznatky

Monitorování nákladů a využití

Náklady na API mohou rychle vymknout kontrole, pokud je nesleduješ. V této lekci se naučíš, jak v produkčním prostředí sledovat, odhadovat a řídit své výdaje. Příběh se opakuje projekt od projektu: funkce jde live ve čtvrtek, o víkendu nikdo nekontroluje dashboard a pondělní faktura odpovídá celému měsíčnímu rozpočtu. Následující kroky ti pomohou zachytit nechtěný nárůst nákladů v okamžiku, kdy nastane, nikoliv až o třicet dní později.

Porozumění fakturaci

Náklady se počítají na milion tokenů, přičemž vstup a výstup mají různé ceny. Tato asymetrie má přímé důsledky pro tvá architektonická rozhodnutí: odeslání dlouhého dokumentu jako vstupu stojí výrazně méně, než když model generuje dlouhý text. Každá odpověď vrací přesný počet tokenů pro oba směry, takže nemusíš nic odhadovat.

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ákladů

Převod těchto čítačů na dolary vyžaduje ceník. Izoluj jej do vyhrazené struktury, místo abys konstanty rozhazoval po celém kódu: když se změní ceny nebo přidáš model, stačí upravit jediný řádek. Níže uvedené sazby jsou orientační a při každé revizi rozpočtu je třeba je ověřit.

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

Osmina centu za volání zní uklidňující, dokud to nevynásobíš padesáti tisíci denními voláními produkčního chatbota – to jsou čtyři sta dolarů denně. Zvykni si vždy myslet v měsíčních objemech, nikdy ne na jednotlivá volání.

Tracker nákladů v reálném čase

Výpočty na úrovni jednotlivých jednotek jsou k ničemu, pokud je neshromažďuješ. Tento tracker agreguje výdaje podél tří os – podle dne, modelu a počtu volání – a porovnává denní součet s rozpočtem, který si nastavíš. Upozornění jsou stupňovaná: varování, když zbývá méně než 20 % rozpočtu, následované tvrdým alertem po překročení limitu. Tento mezistupeň je cenný, protože ti dává čas zasáhnout před tím, než bude služba odstavena.

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

Samotné monitorování někdy nestačí:面对 chybné smyčky, která neustále volá API, potřebuješ finanční jistič. Tento klient zkontroluje zbývající rozpočet před odesláním požadavku a pokud je obálka vyčerpaná, volání rovnou odmítne. Služba se degraduje, ale řízeným způsobem bez překvapivých faktur. Účtování nákladů probíhá až afterward, jakmile je známo skutečné využití.

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}")

Optimalizace nákladů

1. Výběr správného modelu

Nejsilnější pákou zůstává směrování podle složitosti. Úloha klasifikace do tří kategorií nepotřebuje ten nejdražší model: u tohoto úkolu dosahuje rozdíl ve faktuře násobku dvaceti pěti při stejné kvalitě. Udělej ze složitosti explicitní parametr své funkce, nikoliv rozhodnutí natvrdo zakódované v logice.

# 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. Cachování odpovědí

Druhou pákou je vyhnutí se placení dvakrát za stejnou odpověď. FAQ, katalog produktů nebo standardní formulář generují desítkykrát denně zcela totožné prompty. Klíč cache kombinuje model, vstup a parametry – zahrnutí všech je zásadní, jinak by změna teploty tiše vrátila starou odpověď.

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. Omezení výstupních tokenů

Nakonec vždy omez výstup tam, kde je jeho délka předvídatelná. Protože výstup je dražší část, požadavek na jedno slovo při povolení dvou tisíc tokenů nechává dveře dokořán pro upovídanou odpověď, kterou zaplatíš, ale nevyužiješ.

# 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
)

Sazby k 5. srpnu 2026 – ceny se pravidelně mění: před jakýmkoli výpočtem rozpočtu si ověř aktuální ceník na oficiální stránce s cenami OpenAI.

Klíčové poznatky

  • Náklady závisí na modelu A směru (vstup vs. výstup)
  • Implementuj tracker nákladů s alerty na rozpočet
  • Používej správný model pro každý úkol: Luna pro objem, Terra jako výchozí
  • Cachování může drasticky snížit náklady u opakujících se požadavků
  • Nastav max_output_tokens, když je délka odpovědi předvídatelná
  • Pro oficiální sledování spotřeby kontroluj dashboard OpenAI