Czas oczekiwania i odporność w środowisku produkcyjnym
Na tej stronie
Przygotuj swoją aplikację do świata rzeczywistego
W środowisku produkcyjnym żądania wysyłane do API Responses mogą trwać długo – zwłaszcza w przypadku modeli rozumujących, które poświęcają dużo czasu na analizę przed udzieleniem odpowiedzi. Nieprawidłowe obsługiwanie limitów czasu może prowadzić do cichych awarii lub pogorszenia doświadczeń użytkownika.
Limit czasu 3600 sekund
xAI zaleca ustawienie minimalnego limitu czasu na 3600 sekund (1 godzina) dla żądań kierowanych do modeli rozumujących. Jest to wartość znacznie wyższa niż w przypadku standardowych API, co ma istotny wpływ na architekturę Twojego systemu.
Dlaczego aż tak długo?
Modele rozumujące Grok-4.5 mogą zużyć setki tysięcy wewnętrznych tokenów rozumowania przed wygenerowaniem odpowiedzi. Przy złożonych problemach (zaawansowana matematyka, analiza kodu, rozumowanie wieloetapowe) model może „myśleć“ przez kilka minut.
Konfiguracja po stronie klienta
import httpx
from openai import OpenAI
# OpenAI SDK z wydłużonym limitem czasu
client = OpenAI(
api_key="xai-...",
base_url="https://api.x.ai/v1",
timeout=httpx.Timeout(3600.0, connect=10.0)
)
W przypadku curl:
curl --max-time 3600 https://api.x.ai/v1/responses \
-H "Authorization: Bearer $XAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{...}'
Obsługa błędów
Typowe błędy
| Kod HTTP | Przyczyna | Działanie |
|---|---|---|
| 401 | Nieprawidłowy klucz API | Zweryfikuj klucz |
| 429 | Osiągnięto limit szybkości | Ponów próbę z wykładniczym opóźnieniem |
| 500 | Błąd serwera xAI | Ponów próbę po kilku sekundach |
| 503 | Usługa niedostępna | Ponów próbę po 30 sekundach |
| Timeout | Żądanie trwa zbyt długo | Zwiększ limit czasu lub uprość prompt |
Wzorzec ponawiania z wykładniczym opóźnieniem
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"Błąd: {e}. Ponawiam za {wait}s...")
time.sleep(wait)
Limitowanie szybkości (Rate Limiting)
xAI egzekwuje limity szybkości w zależności od Twojego planu. Zaimplementuj mechanizm limitowania po stronie klienta:
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()
# Usuń znaczniki czasu starsze niż jedna minuta
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())
Architektura asynchroniczna
W aplikacjach internetowych nie blokuj głównego wątku przez 3600 sekund. Wykorzystaj architekturę asynchroniczną:
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
Strumieniowanie to najlepsze podejście dla aplikacji interaktywnych: użytkownicy widzą pierwsze tokeny w ciągu kilku sekund, nawet jeśli pełne generowanie zajmuje więcej czasu.
Wyłącznik awaryjny (Circuit Breaker)
Aby chronić swoją aplikację przed przerwami w działaniu API xAI:
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("Obwód otwarty — API niedostępne")
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
Kluczowe wnioski
- Skonfiguruj minimalny limit czasu na 3600 sekund dla modeli rozumujących
- Wdróż mechanizm ponawiania z wykładniczym opóźnieniem dla błędów 429 i 500
- Używaj strumieniowania w aplikacjach interaktywnych – użytkownicy natychmiast widzą tokeny
- Obsługuj limitowanie szybkości po stronie klienta, aby unikać błędów 429
- Rozważ wdrożenie wyłącznika awaryjnego, aby chronić aplikację przed przerwami w działaniu API