Timeout und Robustheit in der Produktion
Auf dieser Seite
Ihre Anwendung auf die Realität vorbereiten
In der Produktion können Anfragen an die Responses API Zeit in Anspruch nehmen – insbesondere bei Reasoning-Modellen, die vor der Antwort ausführlich nachdenken. Eine schlechte Behandlung von Timeouts kann zu stillen Fehlern oder einer verschlechterten Benutzererfahrung führen.
Der 3600-Sekunden-Timeout
xAI empfiehlt ein Minimum von 3600 Sekunden (1 Stunde) für Anfragen an Reasoning-Modelle. Dies ist deutlich länger als bei Standard-APIs und wirkt sich auf Ihre Architektur aus.
Warum so lange?
Grok-4.5 Reasoning-Modelle können Hunderttausende interner Reasoning-Tokens verwenden, bevor sie eine Antwort produzieren. Bei komplexen Problemen (fortgeschrittene Mathematik, Code-Analyse, mehrstufiges Reasoning) kann das Modell mehrere Minuten nachdenken.
Client-seitige Konfiguration
import httpx
from openai import OpenAI
# OpenAI SDK mit erweitertem Timeout
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 '{...}'
Fehlerbehandlung
Häufige Fehler
| HTTP-Code | Ursache | Maßnahme |
|---|---|---|
| 401 | Ungültiger API-Schlüssel | Schlüssel verifizieren |
| 429 | Rate-Limit erreicht | Mit exponentiellem Backoff wiederholen |
| 500 | xAI-Serverfehler | Nach wenigen Sekunden wiederholen |
| 503 | Dienst nicht verfügbar | Nach 30 Sekunden wiederholen |
| Timeout | Anfrage dauert zu lange | Timeout erhöhen oder Prompt vereinfachen |
Retry-Muster mit 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)
Rate-Limiting
xAI setzt Rate-Limits basierend auf Ihrem Plan durch. Implementieren Sie einen client-seitigen Rate-Limiter:
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()
# Entferne Zeitstempel, die älter als eine Minute sind
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 Architektur
Bei Webanwendungen sollten Sie den Hauptthread nicht für 3600 Sekunden blockieren. Nutzen Sie eine asynchrone Architektur:
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 ist der beste Ansatz für interaktive Anwendungen: Benutzer sehen die ersten Tokens innerhalb von Sekunden, auch wenn die vollständige Generierung länger dauert.
Circuit Breaker
Schützen Sie Ihre Anwendung vor Ausfällen der 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
Kernaussagen
- Konfigurieren Sie ein Minimum-Timeout von 3600 Sekunden für Reasoning-Modelle.
- Implementieren Sie Retry mit exponentiellem Backoff für Fehler 429 und 500.
- Nutzen Sie Streaming für interaktive Anwendungen – Benutzer sehen Tokens sofort.
- Behandeln Sie Rate-Limiting client-seitig, um Fehler 429 zu vermeiden.
- Erwägen Sie einen Circuit Breaker, um Ihre Anwendung vor API-Ausfällen zu schützen.