Tidsgränser och robusthet i produktion
På denna sida
Förbered din applikation för verkligheten
I produktionsmiljö kan förfrågningar till Responses API ta tid – särskilt med resonemangsmodeller som tänker igenom svaret noggrant innan de svarar. Dålig hantering av tidsgränser kan leda till tysta fel eller en försämrad användarupplevelse.
Tidsgränsen på 3600 sekunder
xAI rekommenderar en minsta tidsgräns på 3600 sekunder (1 timme) för förfrågningar till resonemangsmodeller. Detta är betydligt längre än för vanliga API:er, vilket påverkar din arkitektur.
Varför så lång tid?
Resonemangsmodeller som Grok-4.5 kan använda hundratusentals interna resonemangstokens innan de producerar ett svar. Vid komplexa problem (avancerad matematik, kodanalys, flerstegsresonemang) kan modellen tänka i flera minuter.
Konfiguration på klientsidan
import httpx
from openai import OpenAI
# OpenAI SDK med utökad tidsgräns
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 '{...}'
Felhantering
Vanliga fel
| HTTP-kod | Orsak | Åtgärd |
|---|---|---|
| 401 | Ogiltig API-nyckel | Kontrollera nyckeln |
| 429 | Hastighetsbegränsning nådd | Försök igen med exponentiell backoff |
| 500 | Serverfel hos xAI | Försök igen efter några sekunder |
| 503 | Tjänsten inte tillgänglig | Försök igen efter 30 sekunder |
| Timeout | Förfrågan för lång | Öka tidsgränsen eller förenkla prompten |
Mönster för återförsök 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)
Hastighetsbegränsning
xAI tillämpar hastighetsbegränsningar baserat på din abonnemangsplan. Implementera en hastighetsbegränsare på klientsidan:
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()
# Ta bort tidsstämplar äldre än en 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
För webbapplikationer ska du inte blockera huvudtråden i 3600 sekunder. Använd 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
Strömning är det bästa tillvägagångssättet för interaktiva applikationer: användaren ser de första tokenen inom sekunder, även om hela genereringen tar längre tid.
Kretsbrytare
För att skydda din applikation mot avbrott i xAI:s 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
Viktiga punkter
- Konfigurera en minsta tidsgräns på 3600 sekunder för resonemangsmodeller
- Implementera återförsök med exponentiell backoff för felkoderna 429 och 500
- Använd strömning för interaktiva applikationer – användaren ser tokenen omedelbart
- Hantera hastighetsbegränsningar på klientsidan för att undvika felkod 429
- Överväg en kretsbrytare för att skydda din applikation mot API-avbrott