Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Laiko limitai ir patikimumas gamyboje

Paskaita 15 iš 16 Atnaujinta 2026 m. liepos 30 d. Kūrėjas
Šiame puslapyje
  1. Paruošk savo programą realiam pasauliui
  2. 3600 sekundžių laiko limitas
  3. Klaidų valdymas
  4. Asinchroninė architektūra
  5. Grandinės jungiklis (Circuit Breaker)
  6. Svarbiausi punktai

Paruošk savo programą realiam pasauliui

Gamybos aplinkoje užklausos „Responses“ API gali užtrukti ilgai – ypač naudojant samprotavimo modelius, kurie prieš pateikdami atsakymą ilgai „galvoja“. Netinkamas laiko limitų valdymas gali sukelti tylius gedimus arba pabloginti naudotojo patirtį.

3600 sekundžių laiko limitas

„xAI“ rekomenduoja nustatyti ne mažesnį kaip 3600 sekundžių (1 valandos) laiko limitą užklausoms samprotavimo modeliams. Tai gerokai ilgiau nei įprastuose API, todėl tai turi įtakos tavo architektūrai.

Kodėl taip ilgai?

„Grok-4.5“ samprotavimo modeliai gali sugeneruoti šimtus tūkstančių vidinių samprotavimo tokenų, prieš pateikdami atsakymą. Spręsdami sudėtingas problemas (pažangi matematika, kodo analizė, daugiapakopiai samprotavimai), modeliai gali „galvoti“ kelias minutes.

Kliento pusės konfigūravimas

import httpx
from openai import OpenAI

# OpenAI SDK su pratęstu laiko limitu
client = OpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0, connect=10.0)
)

Naudojant curl:

curl --max-time 3600 https://api.x.ai/v1/responses \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{...}'

Klaidų valdymas

Dažniausios klaidos

HTTP kodasPriežastisVeiksmas
401Neteisingas API raktasPatikrink raktą
429Pasiektas užklausų limitasKartok su eksponentine pauze
500„xAI“ serverio klaidaKartok po kelių sekundžių
503Paslauga nepasiekiamaKartok po 30 sekundžių
Laiko limitasUžklausa per ilgaPadidink laiko limitą arba supaprastink užuominą

Kartojimo šablonas su pauzėmis

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)

Užklausų ribojimas

„xAI“ taiko užklausų ribojimus pagal tavo planą. Įgyvendink kliento pusės ribotuvą:

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()
        # Pašalink laiko žymas, senesnes nei viena 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())

Asinchroninė architektūra

Kurdami žiniatinklio programas, neužblokuokite pagrindinės gijos 3600 sekundžių. Naudokite asinchroninę architektūrą:

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

Srautinis perdavimas yra geriausias būdas interaktyvioms programoms: naudotojai pirmuosius tokenus pamato per kelias sekundes, net jei visas generavimas trunka ilgiau.

Grandinės jungiklis (Circuit Breaker)

Norėdami apsaugoti savo programą nuo „xAI“ API sutrikimų:

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

Svarbiausi punktai

  • Samprotavimo modeliams nustatyk ne mažesnį kaip 3600 sekundžių laiko limitą
  • Įgyvendink kartojimą su eksponentine pauze 429 ir 500 klaidoms
  • Interaktyvioms programoms naudok srautinį perdavimą – naudotojai tokenus mato iškart
  • Kliento pusėje valdyk užklausų ribojimą, kad išvengtum 429 klaidų
  • Apsvarstyk grandinės jungiklio naudojimą, kad apsaugotum programą nuo API sutrikimų