Salt la conținutul principal
Română— Alege o limbă
Meniu

Timeout și robustețe în producție

Lecția 15 din 16 Actualizată 30 iulie 2026 Dezvoltator
Pe această pagină
  1. Pregătiți aplicația pentru lumea reală
  2. Timeout-ul de 3600 de secunde
  3. Gestionarea erorilor
  4. Arhitectură asincronă
  5. Circuit Breaker
  6. Puncte cheie

Pregătiți aplicația pentru lumea reală

În mediul de producție, cererile către API-ul Responses pot dura mult timp – în special atunci când utilizați modele de raționament care „gândesc“ extensiv înainte de a genera un răspuns. O gestionare necorespunzătoare a timeout-urilor poate duce la erori silențioase sau la o experiență degradată pentru utilizator.

Timeout-ul de 3600 de secunde

xAI recomandă un timeout minim de 3600 de secunde (1 oră) pentru cererile adresate modelelor de raționament. Această durată este semnificativ mai mare decât cea a API-urilor standard, ceea ce are un impact direct asupra arhitecturii dumneavoastră.

De ce o durată atât de mare?

Modelele de raționament Grok-4.5 pot consuma sute de mii de tokeni interni de raționament înainte de a produce un răspuns. În cazul problemelor complexe (matematică avansată, analiză de cod, raționament în mai mulți pași), modelul poate procesa informația timp de câteva minute.

Configurare lato-client

import httpx
from openai import OpenAI

# SDK OpenAI cu timeout extins
client = OpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0, connect=10.0)
)

În curl:

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

Gestionarea erorilor

Erori frecvente

Cod HTTPCauzăAcțiune
401Cheie API invalidăVerificați cheia
429Limită de rată atinsăReîncercați cu backoff exponențial
500Eroare server xAIReîncercați după câteva secunde
503Serviciu indisponibilReîncercați după 30 de secunde
TimeoutCerere prea lungăMăriți timeout-ul sau simplificați promptul

Model de reîncercare cu backoff

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)

Limitarea ratei (Rate Limiting)

xAI impune limite de rată în funcție de planul dumneavoastră. Implementați un limitator de rată lato-client:

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()
        # Elimină timestamp-urile mai vechi de un minut
        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())

Arhitectură asincronă

Pentru aplicațiile web, nu blocați firul principal de execuție timp de 3600 de secunde. Utilizați o arhitectură asincronă:

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

Streaming-ul reprezintă cea mai bună abordare pentru aplicațiile interactive: utilizatorii văd primii tokeni în câteva secunde, chiar dacă generarea completă durează mai mult.

Circuit Breaker

Pentru a vă proteja aplicația de întreruperile API-ului 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

Puncte cheie

  • Configurați un timeout minim de 3600 de secunde pentru modelele de raționament
  • Implementați un mecanism de reîncercare cu backoff exponențial pentru erorile 429 și 500
  • Utilizați streaming-ul pentru aplicațiile interactive – utilizatorii văd tokenii imediat
  • Gestionați limitarea ratei lato-client pentru a evita erorile 429
  • Luați în considerare utilizarea unui circuit breaker pentru a proteja aplicația de întreruperile API-ului