Timeout și robustețe în producție
Pe această pagină
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 HTTP | Cauză | Acțiune |
|---|---|---|
| 401 | Cheie API invalidă | Verificați cheia |
| 429 | Limită de rată atinsă | Reîncercați cu backoff exponențial |
| 500 | Eroare server xAI | Reîncercați după câteva secunde |
| 503 | Serviciu indisponibil | Reîncercați după 30 de secunde |
| Timeout | Cerere 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