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

Batch API i lista kontrolna produkcyjna

Lekcja 12 z 12 Zaktualizowano 2 listopada 2026 Zaawansowany
Na tej stronie
  1. Alternatywa: Batch API – 20% taniej za tokeny
  2. Porównanie podejść
  3. Lista kontrolna produkcyjna
  4. Zalecana architektura
  5. Kluczowe wnioski
  6. Sprawdź swoją wiedzę

Alternatywa: Batch API – 20% taniej za tokeny

Gdy przetwarzanie w czasie rzeczywistym nie jest wymagane, Batch API od xAI oferuje obniżkę o 20% dla wszystkich tokenów w kwalifikujących się modelach tekstowych (od grok-4.3 do grok-4.7 według stanu na 2 listopada 2026 r., zgodnie z cennikiem Batch API od xAI). Zamiast wysyłać żądania pojedynczo i zarządzać współbieżnością, przesyłasz je wsadowo przez API lub w pliku JSONL, a wyniki odbierasz po zakończeniu przetwarzania – zazwyczaj w ciągu 24 godzin. Żądania wsadowe nie są wliczane do limitów szybkości (rate limits). Kurs Batch API: Przetwarzanie masowe szczegółowo opisuje ten proces.

Kiedy używać Batch API

  • Przetwarzanie katalogów produktów (tysiące opisów)
  • Masowa klasyfikacja zgłoszeń wsparcia
  • Generowanie podsumowań dla bazy dokumentów
  • Każde zadanie, w którym opóźnienie rzędu kilku godzin jest akceptowalne

Kiedy pozostać przy klasycznym podejściu Async

  • Interaktywny chatbot (odpowiedź w czasie rzeczywistym)
  • Potok, w którym każdy krok zależy od poprzedniego
  • Monitorowanie i alerty w czasie rzeczywistym
  • Każdy przypadek, w którym opóźnienie Batch API jest nie do przyjęcia

Porównanie podejść

Kryterium Async + Semaphore Batch API
Koszt Stawka standardowa -20% na tokeny dla kwalifikujących się modeli
Opóźnienie (Latency) Sekundy do minut Minuty do godzin
Kontrola Czas rzeczywisty, natychmiastowe błędy Wyniki po zakończeniu przetwarzania, błędy per żądanie
Złożoność Semaphore, backoff, gather Wszech żądań lub plik JSONL, śledzenie liczników
Limity szybkości Podlegają RPM/TPM Zarządzane przez xAI

Lista kontrolna produkcyjna

Przed wdrożeniem systemu asynchronicznych żądań do środowiska produkcyjnego sprawdź każdy punkt na tej liście:

Konfiguracja

  • Timeout ustawiony na 3600 sekund dla modeli rozumujących
  • Semaphore dostosowany do rzeczywistych limitów szybkości (nie szacunkowych)
  • Zaimplementowano wykładniczy backoff z jitterem dla błędów 429
  • Klucze API ładowane ze zmiennych środowiskowych, nigdy nie hardkodowane w kodzie
  • Nagłówek x-grok-conv-id używany do konwersacji wieloetapowych

Obsługa błędów

  • W asyncio.gather użyto return_exceptions=True w celu izolacji błędów
  • Błędy 429, timeout i błędy połączenia uruchamiają ponowną próbę
  • Błędy nieprawidłowego żądania (BadRequestError) nie uruchamiają ponownej próby
  • Nieudane żądania są identyfikowane i mogą zostać ponowione
  • Logi zawierają typ błędu, numer próby i czas oczekiwania przed ponowną próbą

Monitorowanie

  • Liczba zużytych tokenów śledzona poprzez response.usage
  • Mierzony wskaźnik trafień w cache (cache hit rate) w celu walidacji użycia x-grok-conv-id
  • Koszty szacowane w czasie rzeczywistym za pomocą cost_in_usd_ticks
  • Monitorowanie pozostałych limitów szybkości w celu dynamicznego dostosowania semaphore

Wydajność

  • Użycie chunkingu dla wsadów większych niż 100 żądań
  • Zapisywanie wyników pośrednich między pod-wsadami
  • Wyświetlanie postępu dla długotrwałych zadań
  • Dostosowanie Semaphore w zależności od używanego modelu (rozumowanie = niższa wartość)

Bezpieczeństwo

  • Klucze API nie są ujawniane w logach ani komunikatach o błędach
  • Odpowiedzi zawierające dane wrażliwe przetwarzane w pamięci, a nie zapisywane na dysku
  • Zdalne przechowywanie (store_messages) wyłączone dla danych poufnych
  • use_encrypted_content włączone, gdy wymagana jest poufność rozumowania

Zalecana architektura

import os
import asyncio
import uuid
from asyncio import Semaphore
from openai import AsyncOpenAI, RateLimitError, APITimeoutError
import httpx

class GrokAsyncProcessor:
    def __init__(self, max_concurrent: int = 5):
        self.client = AsyncOpenAI(
            api_key=os.getenv("XAI_API_KEY"),
            base_url="https://api.x.ai/v1",
            timeout=httpx.Timeout(3600.0)
        )
        self.sem = Semaphore(max_concurrent)
        self.conv_id = str(uuid.uuid4())

    async def request(self, prompt: str, max_retries: int = 5) -> str:
        async with self.sem:
            for attempt in range(max_retries):
                try:
                    response = await self.client.chat.completions.create(
                        model="grok-4.5",
                        messages=[{"role": "user", "content": prompt}],
                        extra_headers={"x-grok-conv-id": self.conv_id}
                    )
                    return response.choices[0].message.content
                except RateLimitError:
                    if attempt == max_retries - 1:
                        raise
                    await asyncio.sleep(2 ** attempt)
                except APITimeoutError:
                    if attempt == max_retries - 1:
                        raise
                    await asyncio.sleep(2 ** attempt)

    async def batch(self, prompts: list[str]) -> list[str | Exception]:
        tasks = [self.request(p) for p in prompts]
        return await asyncio.gather(*tasks, return_exceptions=True)

Ta klasa inkapsuluje wszystkie wzorce omówione w tym kursie: klient async, semaphore, backoff, cache i obsługę błędów. Stanowi solidny punkt wyjścia dla Twoich projektów produkcyjnych.

Kluczowe wnioski

  • Batch API oferuje 20% zniżki na kwalifikujące się modele, ale narzuca opóźnienie przetwarzania
  • Wybierz między async w czasie rzeczywistym a batch w zależności od ograniczeń dotyczących opóźnień
  • Lista kontrolna produkcyjna obejmuje konfigurację, błędy, monitorowanie, wydajność i bezpieczeństwo
  • Klasa GrokAsyncProcessor inkapsuluje wszystkie wzorce z kursu w jednej abstrakcji
  • Zawsze testuj swoją konfigurację na małym wsadzie przed uruchomieniem przetwarzania masowego

Sprawdź swoją wiedzę

Async, limity, cache: wzorce produkcyjne w pięciu pytaniach.

1. Kiedy async przeważa nad sync?

Odpowiedź: Zawsze przy obsłudze wielu niezależnych żądań: AsyncClient (lub AsyncOpenAI) nakłada na siebie czasy oczekiwania sieciowego – przepustowość rośnie wielokrotnie bez mnożenia wątków.

2. Jak przetworzyć wsad bez przekraczania limitów?

Odpowiedź: asyncio.gather dla równoległości, semaphore do ograniczenia współbieżnych żądań oraz wykładniczy backoff przy HTTP 429 – z poszanowaniem limitów RPM/TPM z konsoli.

3. Jak obsługiwać kontekst wieloetapowy na dużą skalę?

Odpowiedź: Poprzez serwerowe przechowywanie odpowiedzi i ponowne użycie zaszyfrowanego rozumowania – stan żyje po stronie API, Twój kod śledzi tylko identyfikatory.

4. Co musisz wiedzieć o cache i timeoutach?

Odpowiedź: Cache konwersacji (x-grok-conv-id) przyspiesza kontynuowane wątki, a żądania rozumowania wymagają dostosowanych timeoutów – dwa ustawienia, które zmieniają produkcję.

5. Co zawiera lista kontrolna produkcyjna z kursu?

Odpowiedź: Opanowany async, przestrzegane limity (semaphore + backoff), batch dla dużych wolumenów, skonfigurowane timeouty i ponowne próby, śledzenie kosztów – solidność jako lista kontrolna.

Ograniczona współbieżność, zaplanowane awarie, stan po stronie serwera: wzorce async przekształcają Twoje skrypty w usługi – finalna lista kontrolna je zabezpiecza.