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

Rozliczenia i zarządzanie kosztami

Lekcja 14 z 16 Zaktualizowano 30 lipca 2026 Programista
Na tej stronie
  1. Zrozum, za co płacisz
  2. Pułapka skumulowanej historii
  3. Odczytywanie kosztów w odpowiedzi
  4. Strategie optymalizacji
  5. Śledzenie kosztów w produkcji
  6. Alerty kosztowe
  7. Kluczowe wnioski

Zrozum, za co płacisz

API Responses ma istotny szczegół rozliczeniowy: w rozmowie łańcuchowej otrzymujesz fakturę za całą historię, nawet jeśli nie przesyłasz jej jawnie ponownie. Zrozumienie tego mechanizmu jest kluczowe dla kontrolowania kosztów w środowisku produkcyjnym.

Pułapka skumulowanej historii

Dzięki parametrowi previous_response_id serwer automatycznie odtwarza pełny kontekst. Jest to wygodne dla programisty, ale oznacza kumulację tokenów:

TuraTwoja wiadomośćObciążone tokeny (wejście)
150 tokenów50
230 tokenów + historia tury 1130
340 tokenów + historia tur 1–2350
425 tokenów + historia tur 1–3725

Wzrost jest kwadratowy. Już przy 10. turze rozmowy liczba tokenów wejściowych może być od 10 do 50 razy wyższa niż w Twojej początkowej wiadomości.

Odczytywanie kosztów w odpowiedzi

Każda odpowiedź zawiera obiekt usage z dokładnym kosztem:

{
  "usage": {
    "input_tokens": 450,
    "output_tokens": 280,
    "total_tokens": 730,
    "output_tokens_details": {
      "reasoning_tokens": 200
    },
    "cost_in_nano_usd": 1500000
  }
}

cost_in_nano_usd

Pole cost_in_nano_usd podaje koszt w nanodolarach:

1 000 000 000 nano-USD = 1 USD

Aby przeliczyć:

cost_usd = response.usage.cost_in_nano_usd / 1_000_000_000
print(f"Koszt tego żądania: ${cost_usd:.6f}")

Tokeny rozumowania

Tokeny reasoning_tokens w sekcji output_tokens_details są rozliczane według stawki za tokeny wyjściowe. W modelach rozumujących mogą one stanowić od 50% do 80% wszystkich tokenów wyjściowych.

Strategie optymalizacji

Ogranicz długość rozmowy

Zamiast łańcuchować rozmowę w nieskończoność, okresowo twórz podsumowania:

# Po N turach podsumuj i zacznij od nowa
if turn_count > 5:
    summary = client.responses.create(
        model="grok-4.20-0309-reasoning",
        input="Podsumuj tę rozmowę w 3 kluczowych punktach.",
        previous_response_id=last_id
    )
    # Restart z podsumowaniem jako nowym kontekstem
    new_start = client.responses.create(
        model="grok-4.20-0309-reasoning",
        instructions=f"Poprzedni kontekst: {summary.output[0].content[0].text}",
        input=user_message
    )

Wybierz odpowiedni model

Nie wszystkie modele kosztują tyle samo. Do prostych zadań używaj modelu mniej wydajnego (i tańszego). Modele rozumowania zostawiaj tylko do złożonych problemów.

Kontroluj max_output_tokens

Ogranicz długość odpowiedzi, gdy nie potrzebujesz długich wypowiedzi:

{
  "model": "grok-4.20-0309-reasoning",
  "input": "Odpowiedz jednym zdaniem: jaka jest stolica Japonii?",
  "max_output_tokens": 100
}

Używaj store: false, gdy to możliwe

Odpowiedzi niezapisywane nie są przechowywane na serwerze. Nie zmniejsza to bezpośredniego kosztu, ale pozwala uniknąć gromadzenia niepotrzebnych danych.

Śledzenie kosztów w produkcji

Wdróż systematyczne śledzenie:

import json
from datetime import datetime

def log_usage(response, user_id, feature):
    log_entry = {
        "timestamp": datetime.now().isoformat(),
        "user_id": user_id,
        "feature": feature,
        "response_id": response.id,
        "model": response.model,
        "input_tokens": response.usage.input_tokens,
        "output_tokens": response.usage.output_tokens,
        "reasoning_tokens": response.usage.output_tokens_details.reasoning_tokens,
        "cost_nano_usd": response.usage.cost_in_nano_usd,
        "cost_usd": response.usage.cost_in_nano_usd / 1e9
    }
    # Zapisz do swojego systemu logowania
    save_to_db(log_entry)

Alerty kosztowe

Skonfiguruj progi alertów:

MAX_COST_PER_REQUEST = 0.05  # 5 centów USD

cost = response.usage.cost_in_nano_usd / 1e9
if cost > MAX_COST_PER_REQUEST:
    alert(f"Wykryto drogie żądanie: ${cost:.4f} (użytkownik: {user_id})")

Kluczowe wnioski

  • Rozmowy łańcuchowe obciążają kosztami całą historię przy każdej turze – wzrost jest kwadratowy
  • cost_in_nano_usd / 1 miliard = koszt w USD
  • Tokeny rozumowania są płatne, choć niewidoczne w treści odpowiedzi
  • Podsumowuj długie rozmowy, aby utrzymać koszty pod kontrolą
  • Wdróż systematyczne śledzenie kosztów w podziale na użytkowników i funkcje