Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Time-outs en robuustheid in productie

Les 15 van 16 Bijgewerkt op 30 juli 2026 Ontwikkelaar
Op deze pagina
  1. Bereid uw applicatie voor op de echte wereld
  2. De time-out van 3600 seconden
  3. Foutafhandeling
  4. Asynchrone architectuur
  5. Circuit breaker
  6. Belangrijkste punten

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-codeOorzaakActie
401Ongeldige API-sleutelVerifieer de sleutel
429Ratiolimiet bereiktOpnieuw proberen met exponentiële back-off
500xAI-serverfoutOpnieuw proberen na enkele seconden
503Dienst niet beschikbaarOpnieuw proberen na 30 seconden
Time-outVerzoek te langVerhoog 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