Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Időtúllépés és robusztusság éles környezetben

15. lecke 16 közül Frissítve 2026. július 30. Fejlesztő
Ezen az oldalon
  1. Készítsd fel alkalmazásodat a valós világra
  2. A 3600 másodperces időtúllépés
  3. Hibakezelés
  4. Aszinkron architektúra
  5. Áramkör-megszakító (Circuit Breaker)
  6. Főbb megállapítások

Készítsd fel alkalmazásodat a valós világra

Éles környezetben a Responses API felé irányuló kérések időigényesek lehetnek – különösen az olyan következtető modellek esetén, amelyek a válaszadás előtt alaposan „elgondolkodnak“. A helytelen időtúllépés-kezelés csendes hibákhoz vagy a felhasználói élmény romlásához vezethet.

A 3600 másodperces időtúllépés

Az xAI legalább 3600 másodperces (1 órás) időtúllépést javasol a következtető modelleknek küldött kérésekhez. Ez jelentősen hosszabb, mint a szabványos API-k esetében megszokott, ami hatással van az architektúrádra.

Miért ilyen hosszú?

A Grok-4.5 következtető modellek százezernyi belső következtetési tokent is felhasználhatnak, mielőtt választ adnának. Összetett feladatoknál (haladó matematika, kódelemzés, többlépéses következtetés) a modell perceken át is „gondolkodhat“.

Kliensoldali konfiguráció

import httpx
from openai import OpenAI

# OpenAI SDK kibővített időtúllépéssel
client = OpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0, connect=10.0)
)

curl esetén:

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

Hibakezelés

Gyakori hibák

HTTP-kódOkTeendő
401Érvénytelen API-kulcsEllenőrizd a kulcsot
429Elérted a sebességkorlátotPróbáld újra exponenciális visszalépéssel
500xAI szerverhibaPróbáld újra néhány másodperc múlva
503Szolgáltatás nem elérhetőPróbáld újra 30 másodperc múlva
IdőtúllépésTúl hosszú kérésNöveld az időtúllépést vagy egyszerűsítsd a promptot

Újrapróbálási minta visszalépéssel

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)

Sebességkorlátozás

Az xAI az előfizetési csomagod alapján érvényesít sebességkorlátokat. Implementálj kliensoldali sebességkorlátozót:

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()
        # Töröld az egy percnél régebbi időbélyegeket
        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())

Aszinkron architektúra

Webalkalmazások esetén ne blokkold a fő szálat 3600 másodpercre. Használj aszinkron architektúrát:

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

A streamelés a legjobb megoldás interaktív alkalmazásokhoz: a felhasználók már másodperceken belül látják az első tokeneket, még akkor is, ha a teljes generálás tovább tart.

Áramkör-megszakító (Circuit Breaker)

Alkalmazásod védelme érdekében az xAI API kimaradásai ellen:

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

Főbb megállapítások

  • Állíts be legalább 3600 másodperces időtúllépést a következtető modellekhez
  • Implementálj exponenciális visszalépéssel történő újrapróbálást 429-es és 500-as hibák esetén
  • Használj streamelést interaktív alkalmazásokhoz – a felhasználók azonnal látják a tokeneket
  • Kezeld a sebességkorlátozást kliensoldalon a 429-es hibák elkerülése érdekében
  • Fontold meg egy áramkör-megszakító használatát, hogy megvédd alkalmazásodat az API-kimaradásoktól