AI Engineering Academy · Lekcja

Obliczanie i prognozowanie kosztów API

Uczestnicy napiszą pomocniczy skrypt w Pythonie, który przed wysłaniem żądania oszacuje koszt na podstawie liczby tokenów i cennika danego modelu, dzięki czemu unikną nieoczekiwanych opłat.

Obliczanie i prognozowanie kosztów API to bezpłatna lekcja AI Engineering Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Engineering Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Engineering Academy zawiera 4 lekcji w sumie.

Dlaczego prognozowanie kosztów ma znaczenie

Koszty API aplikacji korzystających z LLM mogą przy dużej skali okazać się zaskakująco wysokie. Pojedyncze zapytanie, które wydaje się tanie i kosztuje 0,002 USD, przy 100 000 wywołań kosztuje już 200 USD. Bez prognozowania i monitorowania kosztów funkcje AI mogą generować nieoczekiwane rachunki za chmurę, przewyższające wydatki na całą infrastrukturę.

Dobra wiadomość jest taka, że koszty LLM można w pełni przewidzieć przed wysłaniem żądania: znają Państwo model, mogą policzyć tokeny wejściowe za pomocą tiktoken oraz oszacować liczbę tokenów wyjściowych na podstawie ustawienia max_tokens lub średnich historycznych. Wbudowanie prognozowania kosztów w aplikację od pierwszego dnia zapobiega niespodziankom na rachunkach.

Struktura cen OpenAI

OpenAI pobiera osobne opłaty za tokeny wejściowe i tokeny wyjściowe, przy czym tokeny wyjściowe zazwyczaj kosztują 3–4 razy więcej. Ceny różnią się w zależności od modelu. Orientacyjne ceny na rok 2025 (zawsze należy sprawdzać aktualną stronę z cennikiem, ponieważ ceny się zmieniają):

gpt-4o-mini: około 0,15 USD za milion tokenów wejściowych, około 0,60 USD za milion tokenów wyjściowych
gpt-4o: około 2,50 USD za milion tokenów wejściowych, około 10,00 USD za milion tokenów wyjściowych
text-embedding-3-small: około 0,02 USD za milion tokenów

Różnica w kosztach między modelami jest ogromna: gpt-4o kosztuje około 17 razy więcej za token wejściowy niż gpt-4o-mini. Wybór modelu to najważniejsza dźwignia kontroli kosztów — zawsze należy zacząć od najtańszego modelu spełniającego wymagania dotyczące jakości.

Funkcja pomocnicza do szacowania kosztów

Należy utworzyć estymator kosztów wywoływany przed wysłaniem każdego żądania. Zlicza on tokeny wejściowe za pomocą tiktoken, szacuje liczbę tokenów wyjściowych na podstawie parametru max_tokens, pobiera cenę właściwą dla modelu i zwraca szacowany koszt w dolarach. Należy wywoływać go w środowisku deweloperskim i rejestrować wyniki, aby wyrobić sobie intuicję dotyczącą kosztów różnych typów zapytań.

import tiktoken

# Prices per million tokens as of early 2025
PRICING = {
    'gpt-4o': {'input': 2.50, 'output': 10.00},
    'gpt-4o-mini': {'input': 0.15, 'output': 0.60},
    'gpt-4-turbo': {'input': 10.00, 'output': 30.00},
    'text-embedding-3-small': {'input': 0.02, 'output': 0.0},
}

def estimate_cost(messages, model='gpt-4o-mini', expected_output_tokens=500):
    enc = tiktoken.encoding_for_model(model)
    input_tokens = sum(
        len(enc.encode(m.get('content', ''))) + 4
        for m in messages
    ) + 3

    if model not in PRICING:
        raise ValueError(f'Unknown model: {model}')

    rates = PRICING[model]
    input_cost = (input_tokens / 1_000_000) * rates['input']
    output_cost = (expected_output_tokens / 1_000_000) * rates['output']
    total = input_cost + output_cost

    print(f'Model: {model}')
    print(f'Input tokens: {input_tokens} (${input_cost:.6f})')
    print(f'Est. output tokens: {expected_output_tokens} (${output_cost:.6f})')
    print(f'Estimated total: ${total:.6f}')
    return total

Śledzenie rzeczywistych kosztów na podstawie odpowiedzi API

Po każdym wywołaniu API obiekt odpowiedzi zawiera rzeczywiste liczby wykorzystanych tokenów. Należy je odczytać, aby rejestrować rzeczywiste koszty i porównywać je z szacunkami. Z czasem różnica między szacowaną a rzeczywistą liczbą tokenów wyjściowych pokaże, jak dokładnie przewidują Państwo zużycie, a dzienniki dostarczą zestawienia kosztów według funkcji lub segmentu użytkowników.

import openai

client = openai.OpenAI()

PRICING = {
    'gpt-4o-mini': {'input': 0.15, 'output': 0.60},
}

def chat_with_cost_tracking(model, messages):
    response = client.chat.completions.create(
        model=model, messages=messages
    )
    usage = response.usage
    rates = PRICING.get(model, {'input': 0, 'output': 0})
    actual_cost = (
        (usage.prompt_tokens / 1_000_000) * rates['input'] +
        (usage.completion_tokens / 1_000_000) * rates['output']
    )
    print(f'Input: {usage.prompt_tokens} tokens')
    print(f'Output: {usage.completion_tokens} tokens')
    print(f'Total: {usage.total_tokens} tokens')
    print(f'Actual cost: ${actual_cost:.6f}')
    return response, actual_cost

Prognozowanie kosztów miesięcznych

Gdy znają już Państwo średni koszt żądania i oczekiwaną liczbę żądań, prognozowanie kosztów miesięcznych jest proste. Należy utworzyć arkusz kalkulacyjny z modelem kosztów albo prosty skrypt w Pythonie, który pozwoli testować różne założenia: co się stanie, jeśli liczba aktywnych użytkowników dziennie się podwoi? Co się stanie, jeśli dodamy funkcję wykonującą 3 wywołania API na jedną akcję użytkownika zamiast 1?

def project_monthly_cost(
    avg_cost_per_request,
    requests_per_day,
    days=30
):
    daily_cost = avg_cost_per_request * requests_per_day
    monthly_cost = daily_cost * days

    print(f'Avg cost/request: ${avg_cost_per_request:.6f}')
    print(f'Requests/day: {requests_per_day:,}')
    print(f'Daily cost: ${daily_cost:.2f}')
    print(f'Monthly cost: ${monthly_cost:.2f}')

    # Growth scenarios
    for multiplier in [2, 5, 10]:
        scaled = monthly_cost * multiplier
        print(f'  At {multiplier}x traffic: ${scaled:.2f}/month')

# Example: customer support bot
project_monthly_cost(
    avg_cost_per_request=0.002,  # 2 cents per support query
    requests_per_day=5000
)

Wpływ wyboru modelu na koszty

Największą dźwignią obniżenia kosztów jest użycie najtańszego modelu spełniającego wymagania dotyczące jakości. W przypadku wielu zadań gpt-4o-mini działa porównywalnie do gpt-4o, ale kosztuje około 17 razy mniej. Zanim domyślnie wybiorą Państwo najpotężniejszy model, należy przetestować tańszy model na konkretnym zadaniu i przełączyć się na droższy tylko wtedy, gdy jakość spadnie poniżej ustalonego progu.

Jeszcze skuteczniejsza jest strategia routingu warstwowego: należy klasyfikować przychodzące żądania według złożoności i kierować proste zapytania do tanich modeli, a złożone do drogich. Nawet skierowanie 70% ruchu do taniego modelu i 30% do drogiego pozwala zaoszczędzić około 70% kosztów AI.

Długość promptu a koszt

Każdy token w promptcie kosztuje. Rozbudowany prompt systemowy, który można skrócić bez utraty znaczenia, bezpośrednio zwiększa koszt API przy każdym żądaniu. Należy mierzyć liczbę tokenów w promptach i szukać możliwości skrócenia ich treści. Podobnie długie przykłady few-shot często można zastąpić krótszymi odpowiednikami bez pogorszenia dokładności.

W systemach RAG pobrany kontekst często stanowi największą część promptu. Zwracanie 10 dużych fragmentów, gdy wystarczyłyby 3 mniejsze i dobrze dobrane, powoduje marnowanie tokenów przy każdym zapytaniu. Należy dostosować mechanizm wyszukiwania tak, aby ograniczyć nadmiarowy kontekst, jednocześnie maksymalizując trafność.

Batchowanie w celu zwiększenia efektywności kosztowej

OpenAI oferuje Batch API, które przetwarza żądania asynchronicznie, za 50% standardowej ceny. Jeśli Państwa przypadek użycia nie jest wrażliwy na opóźnienia — na przykład przetwarzanie dokumentów, nocne zadania analityczne lub masowe generowanie treści — Batch API może zmniejszyć koszty o połowę przy minimalnych zmianach w kodzie.

Żądania wsadowe są przesyłane jako pliki JSONL, przetwarzane w ciągu 24 godzin, a następnie wyniki są pobierane z API. To idealne rozwiązanie dla potoków przetwarzania uruchamianych zgodnie z harmonogramem, które nie wymagają odpowiedzi w czasie rzeczywistym.

import openai
import json

client = openai.OpenAI()

# Create batch request file
requests = [
    {'custom_id': f'doc-{i}',
     'method': 'POST',
     'url': '/v1/chat/completions',
     'body': {
         'model': 'gpt-4o-mini',
         'messages': [{'role': 'user', 'content': f'Summarize document {i}'}],
         'max_tokens': 200
     }}
    for i in range(100)
]

# Write to JSONL
with open('/tmp/batch_input.jsonl', 'w') as f:
    for req in requests:
        f.write(json.dumps(req) + '\n')

# Upload and submit (50% off list price)
print('Would submit batch for 100 documents at 50% discount')
# batch_file = client.files.create(file=open('/tmp/batch_input.jsonl','rb'), purpose='batch')
# batch = client.batches.create(input_file_id=batch_file.id, endpoint='/v1/chat/completions', completion_window='24h')

Ustalanie limitów wydatków

Należy zawsze skonfigurować limity wydatków, aby zapobiec niekontrolowanemu wzrostowi kosztów. W panelu OpenAI można ustawić miesięczne limity wydatków, które zablokują dostęp do API po osiągnięciu limitu. Należy ustawić twardy limit na maksymalnym akceptowalnym poziomie wydatków, a miękki limit na poziomie 80% tej wartości, aby otrzymać ostrzeżenie e-mail przed osiągnięciem twardego limitu.

W kodzie aplikacji należy zaimplementować budżet dla użytkownika lub funkcji, śledzony w bazie danych. Przed każdym wywołaniem API należy sprawdzić budżet i zwrócić błąd, jeśli został wyczerpany. Zapobiega to sytuacji, w której pojedynczy użytkownik powodujący niekontrolowany wzrost kosztów lub błąd w zadaniu wsadowym zużywa całość miesięcznego limitu w ciągu kilku godzin.

Buforowanie w celu unikania zbędnych wywołań API

Najtańsze wywołanie API to takie, którego nie trzeba wykonywać. Należy zaimplementować buforowanie na poziomie aplikacji, aby obsługiwać identyczne żądania z cache zamiast ponownie wywoływać API. Nawet prosty cache Redis, którego klucze są oparte na skrócie SHA256 promptu, może wyeliminować znaczną część zbędnych wywołań w aplikacji produkcyjnej.

W przypadku embeddingów buforowanie jest szczególnie skuteczne: ten sam tekst powinien być poddawany embeddingowi tylko raz. Należy przechowywać embeddingi w bazie wektorowej, używając oryginalnego tekstu jako klucza, i przed wywołaniem API embeddingów sprawdzać, czy embedding już istnieje. W potoku RAG embeddingi dokumentów są obliczane raz podczas indeksowania i ponownie wykorzystywane przy każdym zapytaniu, które zwraca dany dokument.

import hashlib
import json

# Simple in-memory cache (use Redis in production)
_cache = {}

def cached_completion(client, model, messages, **kwargs):
    cache_key = hashlib.sha256(
        json.dumps({'model': model, 'messages': messages}).encode()
    ).hexdigest()

    if cache_key in _cache:
        print('Cache HIT - no API call made')
        return _cache[cache_key]

    response = client.chat.completions.create(
        model=model, messages=messages, **kwargs
    )
    _cache[cache_key] = response
    print('Cache MISS - API call made')
    return response

Tworzenie panelu kosztów

W środowisku produkcyjnym potrzebują Państwo wglądu w koszty AI z podziałem na funkcję, użytkownika i model. Należy utworzyć panel kosztów, rejestrując liczbę tokenów każdego wywołania API oraz powiązane metadane (identyfikator użytkownika, nazwa funkcji, model) w bazie danych szeregów czasowych. Następnie należy agregować dane, aby uzyskać odpowiedzi na pytania takie jak: która funkcja generuje największe wydatki? Czy zaawansowani użytkownicy generują nieproporcjonalnie wysokie koszty? Czy koszt zapytania wzrósł po zmianie promptu?

Taka widoczność jest niezbędna do podejmowania opartych na danych decyzji dotyczących optymalizacji, zamiast zgadywania, gdzie można obniżyć koszty. Większość firm odkrywa, że 20% ich funkcji odpowiada za 80% wydatków na AI, a optymalizacja tych funkcji przynosi nieproporcjonalnie duże korzyści.

Szybki sprawdzian

Sprawdź swoją wiedzę na temat koncepcji inżynierii AI omówionych w tej lekcji.

Podsumowanie lekcji

W tej lekcji dowiedziałeś się, że: koszty API można przewidzieć przed wysłaniem żądania, zliczając tokeny wejściowe za pomocą tiktoken i szacując liczbę tokenów wyjściowych, wybór modelu ma największy wpływ na koszty — gpt-4o-mini może być 17 razy tańszy niż gpt-4o w przypadku odpowiednich zadań, a także że buforowanie, batchowanie i limity wydatków zapobiegają niekontrolowanemu wzrostowi kosztów w środowisku produkcyjnym. Następnie omówimy strategie zarządzania długimi rozmowami, które przekraczają okno kontekstu.

Często zadawane pytania

Czy lekcja „Obliczanie i prognozowanie kosztów API” jest bezpłatna?

Tak — pełny tekst „Obliczanie i prognozowanie kosztów API” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Engineering Academy, przejdź na CoddyKit PRO. Kurs AI Engineering Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Obliczanie i prognozowanie kosztów API”?

Uczestnicy napiszą pomocniczy skrypt w Pythonie, który przed wysłaniem żądania oszacuje koszt na podstawie liczby tokenów i cennika danego modelu, dzięki czemu unikną nieoczekiwanych opłat. Ćwiczysz AI Engineering Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć AI Engineering Academy?

Nie wymagamy żadnego doświadczenia. AI Engineering Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Obliczanie i prognozowanie kosztów API”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji AI Engineering Academy?

Tak. Każda lekcja AI Engineering Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Czym jest token?
Okna kontekstu: rozmiar i znaczenie
Obliczanie i prognozowanie kosztów API
Strategie mieszczące się w oknie kontekstu

← Powrót do AI Engineering Academy