Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Timeout und Robustheit in der Produktion

Lektion 15 von 16 Aktualisiert am 30. Juli 2026 Entwickler
Auf dieser Seite
  1. Ihre Anwendung auf die Realität vorbereiten
  2. Der 3600-Sekunden-Timeout
  3. Fehlerbehandlung
  4. Asynchrone Architektur
  5. Circuit Breaker
  6. Kernaussagen

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-CodeUrsacheMaßnahme
401Ungültiger API-SchlüsselSchlüssel verifizieren
429Rate-Limit erreichtMit exponentiellem Backoff wiederholen
500xAI-ServerfehlerNach wenigen Sekunden wiederholen
503Dienst nicht verfügbarNach 30 Sekunden wiederholen
TimeoutAnfrage dauert zu langeTimeout 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.