Timeout og robusthed i produktion
På denne side
Forbered din applikation til den virkelige verden
I produktion kan anmodninger til Responses API tage tid – især med ræsonnementsmodeller, der tænker grundigt, før de svarer. Dårlig håndtering af timeout kan føre til stille fejl eller en forringet brugeroplevelse.
Timeout på 3600 sekunder
xAI anbefaler en minimumstimeout på 3600 sekunder (1 time) for anmodninger til ræsonnementsmodeller. Dette er væsentligt længere end for standard-API’er, hvilket påvirker din arkitektur.
Hvorfor så længe?
Grok-4.5 ræsonnementsmodeller kan bruge hundredtusindvis af interne ræsonnementstokens, før de producerer et svar. Ved komplekse problemer (avanceret matematik, kodeanalyse, flertrins-ræsonnement) kan modellen tænke i flere minutter.
Klient-side konfiguration
import httpx
from openai import OpenAI
# OpenAI SDK med udvidet timeout
client = OpenAI(
api_key="xai-...",
base_url="https://api.x.ai/v1",
timeout=httpx.Timeout(3600.0, connect=10.0)
)
I curl:
curl --max-time 3600 https://api.x.ai/v1/responses \
-H "Authorization: Bearer $XAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{...}'
Fejlhåndtering
Almindelige fejl
| HTTP-kode | Årsag | Handling |
|---|---|---|
| 401 | Ugyldig API-nøgle | Verificér nøglen |
| 429 | Rate-grænse nået | Genforsøg med eksponentiel backoff |
| 500 | xAI-serverfejl | Genforsøg efter få sekunder |
| 503 | Tjenesten utilgængelig | Genforsøg efter 30 sekunder |
| Timeout | Anmodning for lang | Øg timeout eller forenkl prompten |
Genforsøgsmønster med 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-begrænsning
xAI håndhæver rate-grænser baseret på din plan. Implementér en rate-begrænser på klientsiden:
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()
# Fjern tidsstempler ældre end ét 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())
Asynkron arkitektur
Til webapplikationer må du ikke blokere hovedtråden i 3600 sekunder. Brug en asynkron arkitektur:
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 er den bedste tilgang til interaktive applikationer: brugere ser de første tokens inden for få sekunder, selvom den fulde generering tager længere tid.
Circuit Breaker
For at beskytte din applikation mod nedetid hos 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
Vigtige pointer
- Konfigurér en minimumstimeout på 3600 sekunder til ræsonnementsmodeller
- Implementér genforsøg med eksponentiel backoff for 429- og 500-fejl
- Brug streaming til interaktive applikationer – brugere ser tokens med det samme
- Håndtér rate-begrænsning på klientsiden for at undgå 429-fejl
- Overvej en circuit breaker for at beskytte din applikation mod API-nedtid