Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Tidsgränser och robusthet i produktion

Lektion 15 av 16 Uppdaterad 30 juli 2026 Utvecklare
På denna sida
  1. Förbered din applikation för verkligheten
  2. Tidsgränsen på 3600 sekunder
  3. Felhantering
  4. Asynkron arkitektur
  5. Kretsbrytare
  6. Viktiga punkter

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-kodOrsakÅtgärd
401Ogiltig API-nyckelKontrollera nyckeln
429Hastighetsbegränsning nåddFörsök igen med exponentiell backoff
500Serverfel hos xAIFörsök igen efter några sekunder
503Tjänsten inte tillgängligFörsök igen efter 30 sekunder
TimeoutFö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