Time-outs en robuustheid in productie
Op deze pagina
Bereid uw applicatie voor op de echte wereld
In een productieomgeving kunnen verzoeken aan de Responses API lang duren, zeker bij redeneermodellen die uitgebreid nadenken voordat ze antwoorden. Slechte afhandeling van time-outs kan leiden tot stille fouten of een verslechterde gebruikerservaring.
De time-out van 3600 seconden
xAI adviseert een minimale time-out van 3600 seconden (1 uur) voor verzoeken aan redeneermodellen. Dit is aanzienlijk langer dan bij standaard-API’s, wat gevolgen heeft voor uw architectuur.
Waarom zo lang?
Grok-4.5-redeneermodellen kunnen honderdduizenden interne redeneertokens verbruiken voordat ze een respons genereren. Bij complexe problemen (geavanceerde wiskunde, code-analyse, meerstapsredenering) kan het model enkele minuten nadenken.
Configuratie aan de clientzijde
import httpx
from openai import OpenAI
# OpenAI SDK met verlengde time-out
client = OpenAI(
api_key="xai-...",
base_url="https://api.x.ai/v1",
timeout=httpx.Timeout(3600.0, connect=10.0)
)
In curl:
curl --max-time 3600 https://api.x.ai/v1/responses \
-H "Authorization: Bearer $XAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{...}'
Foutafhandeling
Veelvoorkomende fouten
| HTTP-code | Oorzaak | Actie |
|---|---|---|
| 401 | Ongeldige API-sleutel | Verifieer de sleutel |
| 429 | Ratiolimiet bereikt | Opnieuw proberen met exponentiële back-off |
| 500 | xAI-serverfout | Opnieuw proberen na enkele seconden |
| 503 | Dienst niet beschikbaar | Opnieuw proberen na 30 seconden |
| Time-out | Verzoek te lang | Verhoog de time-out of vereenvoudig de prompt |
Retry-patroon met back-off
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)
Ratiolimitering
xAI handhaaft ratiolimieten op basis van uw abonnement. Implementeer een ratiolimiter aan de clientzijde:
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()
# Verwijder tijdstempels ouder dan één minuut
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())
Asynchrone architectuur
Blokkeer bij webapplicaties de hoofdthread niet gedurende 3600 seconden. Gebruik een asynchrone architectuur:
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 is de beste aanpak voor interactieve applicaties: gebruikers zien de eerste tokens binnen enkele seconden, zelfs als de volledige generatie langer duurt.
Circuit breaker
Om uw applicatie te beschermen tegen uitval van de xAI-API:
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
Belangrijkste punten
- Stel een minimale time-out van 3600 seconden in voor redeneermodellen
- Implementeer opnieuw proberen met exponentiële back-off voor 429- en 500-fouten
- Gebruik streaming voor interactieve applicaties – gebruikers zien tokens direct
- Handel ratiolimitering aan de clientzijde af om 429-fouten te voorkomen
- Overweeg een circuit breaker om uw applicatie te beschermen tegen API-uitval