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

Batch API a kontrolní seznam pro nasazení do produkce

Lekce 12 z 12 Aktualizováno 2. listopadu 2026 Pokročilý
Na této stránce
  1. Alternativa Batch API: Sleva 20 % na tokeny
  2. Srovnání přístupů
  3. Kontrolní seznam pro nasazení do produkce
  4. Doporučená architektura
  5. Klíčové poznatky
  6. Ověř si své znalosti

Alternativa Batch API: Sleva 20 % na tokeny

Pokud není vyžadováno zpracování v reálném čase, nabízí Batch API od xAI slevu 20 % na všechny tokeny pro způsobilé textové modely (od grok-4.3 po grok-4.7 k 2. listopadu 2026, podle ceníku Batch API od xAI). Místo odesílání požadavků jeden po druhém a správy souběžnosti odešleš své požadavky v dávkách prostřednictvím API nebo v souboru JSONL a výsledky získáš, jakmile se zpracování dokončí – obvykle do 24 hodin. Požadavky typu Batch se nezapočítávají do limitů rychlosti (rate limits). Kurz Batch API: Hromadné zpracování podrobně popisuje celý pracovní postup.

Kdy použít Batch API

  • Zpracování katalogů produktů (tisíce popisů)
  • Hromadná klasifikace tiketů podpory
  • Generování shrnutí pro dokumentovou základnu
  • Jakýkoli úkol, kde je přijatelné zpoždění několika hodin

Kdy zůstat u klasického asynchronního přístupu

  • Interaktivní chatbot (odezva v reálném čase)
  • Pipeline, kde každý krok závisí na předchozím
  • Monitorování a alerty v reálném čase
  • Jakýkoli případ, kdy je zpoždění Batch API nepřijatelné

Srovnání přístupů

Kritérium Async + Semaphore Batch API
Náklady Standardní sazba -20 % na tokeny pro způsobilé modely
Latence Sekundy až minuty Minuty až hodiny
Kontrola Reálný čas, okamžité chyby Výsledky po dokončení zpracování, chyby na úrovni požadavku
Složitost Semaphore, backoff, gather Dávka požadavků nebo soubor JSONL, sledování čítače
Limity rychlosti Podléhá RPM/TPM Spravováno xAI

Kontrolní seznam pro nasazení do produkce

Než nasadíš svůj systém asynchronních požadavků do produkce, zkontroluj každý bod v tomto seznamu:

Konfigurace

  • Časový limit (timeout) je nastaven na 3600 sekund pro modely s odůvodněním (reasoning)
  • Semaphore je dimenzována na základě tvých skutečných limitů rychlosti (ne odhadů)
  • Exponenciální backoff je implementován s jitterem pro chyby 429
  • Klíče API jsou načítány z proměnných prostředí, nikdy nejsou natvrdo zakódovány v kódu
  • Hlavička x-grok-conv-id se používá pro konverzace s více obraty

Zpracování chyb

  • V asyncio.gather se používá return_exceptions=True pro izolaci chyb
  • Chyby 429, timeout a chyby připojení spouští opakovaný pokus
  • Chyby neplatného požadavku (BadRequestError) nespouští opakovaný pokus
  • Neúspěšné požadavky jsou identifikovány a lze je znovu zkusit
  • Logy obsahují typ chyby, číslo pokusu a dobu čekání před dalším pokusem

Monitorování

  • Počet spotřebovaných tokenů je sledován prostřednictvím response.usage
  • Míra úspěšnosti cache (cache hit rate) se měří pro ověření použití x-grok-conv-id
  • Náklady se odhadují v reálném čase pomocí cost_in_usd_ticks
  • Zbývající limity rychlosti se monitorují pro dynamické nastavení semaphore

Výkon

  • Pro dávky větší než 100 požadavků se používá chunking (rozdělení na části)
  • Průběžné výsledky se ukládají mezi poddávkami
  • U dlouho běžících úloh se zobrazuje průběh
  • Semaphore se upravuje podle použitého modelu (reasoning = nižší hodnota)

Bezpečnost

  • Klíče API nejsou vystaveny v logách ani chybových zprávách
  • Odpovědi obsahující citlivá data se zpracovávají v paměti, nikoliv se nezapisují na disk
  • Vzdálené úložiště (store_messages) je pro důvěrná data zakázáno
  • use_encrypted_content je povoleno, když je vyžadována důvěrnost odůvodnění

Doporučená 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)

Tato třída zapouzdřuje všechny vzory probírané v tomto kurzu: asynchronní klient, semaphore, backoff, cache a zpracování chyb. Poskytuje solidní výchozí bod pro tvé produkční projekty.

Klíčové poznatky

  • Batch API nabízí slevu 20 % na způsobilé modely, ale ukládá zpoždění při zpracování
  • Volba mezi asynchronním zpracováním v reálném čase a dávkovým zpracováním závisí na tvých požadavcích na latenci
  • Kontrolní seznam pro produkci pokrývá konfiguraci, chyby, monitorování, výkon a bezpečnost
  • Třída GrokAsyncProcessor zapouzdřuje všechny vzory z kurzu do jedné abstrakce
  • Před spuštěním hromadného zpracování vždy otestuj svou konfiguraci na malé dávce

Ověř si své znalosti

Async, limity, cache: produkční vzory v pěti otázkách.

1. Kdy převládá async nad sync?

Odpověď: Kdykoli zpracováváš více nezávislých požadavků: AsyncClient (nebo AsyncOpenAI) překrývá čekání na síť – propustnost se násobí bez nutnosti násobit vlákna.

2. Jak zpracovat dávku, aniž bys narazil na limity?

Odpověď: asyncio.gather pro paralelismus, semaphore pro omezení souběžných požadavků a exponenciální backoff u HTTP 429 – s respektem k limitům RPM/TPM v konzoli.

3. Jak řešit kontext více obratů ve velkém měřítku?

Odpověď: Prostřednictvím ukládání odpovědí na straně serveru a opětovného použití šifrovaného odůvodnění – stav žije na straně API, tvůj kód pouze sleduje identifikátory.

4. Co potřebuješ vědět o cache a timeoutech?

Odpověď: Cache konverzace (x-grok-conv-id) zrychluje navazující vlákna a požadavky s odůvodněním vyžadují přizpůsobené timeoutry – dvě nastavení, která změní produkci.

5. Co obsahuje produkční kontrolní seznam kurzu?

Odpověď: Zvládnuté async, respektované limity (semaphore + backoff), batch pro objem „za studena“, nakonfigurované timeoutry a opakování, sledování nákladů – robustnost jako kontrolní seznam.

Omezená souběžnost, plánované selhání, stav na straně serveru: asynchronní vzory transformují tvé skripty na služby – finální kontrolní seznam je zajistí.