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

Časové limity a odolnost v produkci

Lekce 15 z 16 Aktualizováno 30. července 2026 Vývojář
Na této stránce
  1. Připrav svou aplikaci na reálný svět
  2. Časový limit 3600 sekund
  3. Zpracování chyb
  4. Asynchronní architektura
  5. Jistič (Circuit Breaker)
  6. Klíčové poznatky

Připrav svou aplikaci na reálný svět

V produkčním prostředí mohou požadavky na API Responses trvat dlouho – zejména u modelů s odůvodněním, které před odpovědí intenzivně přemýšlejí. Špatné zpracování časových limitů může vést k tichým selháním nebo zhoršené uživatelské zkušenosti.

Časový limit 3600 sekund

xAI doporučuje pro požadavky na modely s odůvodněním nastavit minimální časový limit 3600 sekund (1 hodina). To je výrazně déle než u běžných API, což má dopad na tvou architekturu.

Proč tak dlouho?

Modely Grok-4.5 s odůvodněním mohou před vygenerováním odpovědi spotřebovat stovky tisíc interních tokenů pro úvahy. U složitých problémů (pokročilá matematika, analýza kódu, vícekrokové odůvodnění) může model přemýšlet několik minut.

Konfigurace na straně klienta

import httpx
from openai import OpenAI

# OpenAI SDK s prodlouženým časovým limitem
client = OpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0, connect=10.0)
)

V curl:

curl --max-time 3600 https://api.x.ai/v1/responses \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{...}'

Zpracování chyb

Běžné chyby

Kód HTTPPříčinaAkce
401Neplatný API klíčOvěř klíč
429Dosažen limit rychlostiOpakuj s exponenciálním zpětným čekáním
500Chyba serveru xAIOpakuj po několika sekundách
503Služba nedostupnáOpakuj po 30 sekundách
Časový limitPožadavek příliš dlouhýZvyš časový limit nebo zjednoduš prompt

Vzorec opakování s exponenciálním zpětným čekáním

import time

def call_with_retry(client, max_retries=3, **kwargs):
    for attempt in range(max_retries):
        try:
            return client.responses.create(**kwargs)
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            wait = 2 ** attempt  # 1s, 2s, 4s
            print(f"Error: {e}. Retrying in {wait}s...")
            time.sleep(wait)

Omezování rychlosti (Rate Limiting)

xAI vynucuje limity rychlosti na základě tvého plánu. Implementuj omezovač rychlosti na straně klienta:

import time
from collections import deque

class RateLimiter:
    def __init__(self, max_requests_per_minute=60):
        self.max_rpm = max_requests_per_minute
        self.timestamps = deque()

    def wait_if_needed(self):
        now = time.time()
        # Odstraň časová razítka starší než jedna minuta
        while self.timestamps and self.timestamps[0] < now - 60:
            self.timestamps.popleft()
        if len(self.timestamps) >= self.max_rpm:
            sleep_time = 60 - (now - self.timestamps[0])
            time.sleep(max(0, sleep_time))
        self.timestamps.append(time.time())

Asynchronní architektura

U webových aplikací neblokuj hlavní vlákno na 3600 sekund. Použij asynchronní architekturu:

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1"
)

async def process_request(user_input):
    response = await client.responses.create(
        model="grok-4.20-0309-reasoning",
        input=user_input,
        stream=True
    )
    async for event in response:
        if event.type == "response.output_text.delta":
            yield event.delta

Streamování je nejlepší přístup pro interaktivní aplikace: uživatelé vidí první tokeny během několika sekund, i když úplné generování trvá déle.

Jistič (Circuit Breaker)

Pro ochranu své aplikace před výpadky API xAI:

class CircuitBreaker:
    def __init__(self, failure_threshold=5, reset_timeout=60):
        self.failures = 0
        self.threshold = failure_threshold
        self.reset_timeout = reset_timeout
        self.last_failure = 0
        self.is_open = False

    def call(self, func, *args, **kwargs):
        if self.is_open:
            if time.time() - self.last_failure > self.reset_timeout:
                self.is_open = False
                self.failures = 0
            else:
                raise Exception("Circuit open — API unavailable")

        try:
            result = func(*args, **kwargs)
            self.failures = 0
            return result
        except Exception as e:
            self.failures += 1
            self.last_failure = time.time()
            if self.failures >= self.threshold:
                self.is_open = True
            raise

Klíčové poznatky

  • Nastav minimální časový limit 3600 sekund pro modely s odůvodněním
  • Implementuj opakování s exponenciálním zpětným čekáním pro chyby 429 a 500
  • Pro interaktivní aplikace používej streamování – uživatelé okamžitě vidí tokeny
  • Zpracovávej omezování rychlosti na straně klienta, abys předešel chybám 429
  • Zvaž použití jističe (circuit breaker) na ochranu aplikace před výpadky API