Laika limiti un noturība ražošanas vidē
Šajā lapā
Sagatavo savu lietotni reālajai videi
Ražošanas vidē pieprasījumi Responses API var aizņemt ilgu laiku, it īpaši, ja izmanto spriešanas modeļus, kas pirms atbildes sniegšanas veic plašu domāšanas procesu. Nepareiza laika limitu apstrāde var izraisīt klusas kļūmes vai pasliktināt lietotāja pieredzi.
3600 sekunžu laika limits
xAI iesaka iestatīt minimālo laika limitu 3600 sekundēm (1 stunda) pieprasījumiem spriešanas modeļiem. Tas ir ievērojami ilgāk nekā standarta API gadījumā, kas ietekmē tavu arhitektūru.
Kāpēc tik ilgi?
Grok-4.5 spriešanas modeļi pirms atbildes ģenerēšanas var izmantot simtiem tūkstošu iekšējo spriešanas tokenus. Risinot sarežģītas problēmas (augstākā matemātika, koda analīze, daudzsoloņu spriešana), modelis var domāt vairākas minūtes.
Klienta puses konfigurācija
import httpx
from openai import OpenAI
# OpenAI SDK ar pagarinātu laika limitu
client = OpenAI(
api_key="xai-...",
base_url="https://api.x.ai/v1",
timeout=httpx.Timeout(3600.0, connect=10.0)
)
Izmantojot curl:
curl --max-time 3600 https://api.x.ai/v1/responses \
-H "Authorization: Bearer $XAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{...}'
Kļūdu apstrāde
Biežāk sastopamās kļūdas
| HTTP kods | Cēlonis | Darbība |
|---|---|---|
| 401 | Nederīga API atslēga | Pārbaudi atslēgu |
| 429 | Sasniegts ātruma limits | Mēģini vēlreiz ar eksponenciālu pauzi |
| 500 | xAI servera kļūda | Mēģini vēlreiz pēc dažām sekundēm |
| 503 | Pakalpojums nav pieejams | Mēģini vēlreiz pēc 30 sekundēm |
| Laika limits | Pieprasījums pārāk garš | Palielini laika limitu vai vienkāršo uzdevumu |
Atkārtošanas shēma ar eksponenciālu pauzi
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)
Ātruma ierobežošana
xAI piemēro ātruma ierobežojumus atkarībā no tava tarifa plāna. Implementē klienta puses ātruma ierobežotāju:
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()
# Dzēš laika zīmogus, kas vecāki par vienu minūti
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())
Asinhrona arhitektūra
Tīmekļa lietotnēm nebloķē galveno pavedienu uz 3600 sekundēm. Izmanto asinhronu arhitektūru:
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
Straumēšana ir labākā pieeja interaktīvām lietotnēm: lietotāji redz pirmos tokenus dažu sekunžu laikā, pat ja pilnīga ģenerēšana aizņem ilgāku laiku.
Ķēdes pārtraucējs (Circuit Breaker)
Lai pasargātu savu lietotni no xAI API pārtraukumiem:
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
Galvenās atziņas
- Konfigurē minimālo laika limitu 3600 sekundēm spriešanas modeļiem
- Implementē atkārtošanu ar eksponenciālu pauzi 429 un 500 kļūdām
- Izmanto straumēšanu interaktīvām lietotnēm — lietotāji uzreiz redz tokenus
- Apstrādā ātruma ierobežojumus klienta pusē, lai izvairītos no 429 kļūdām
- Apsver ķēdes pārtraucēja izmantošanu, lai pasargātu lietotni no API pārtraukumiem