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

Batch API és ellenőrző lista éles környezethez

12. lecke 12 közül Frissítve 2026. november 2. Haladó
Ezen az oldalon
  1. A Batch API alternatíva: 20%-os tokenkedvezmény
  2. Megközelítések összehasonlítása
  3. Ellenőrző lista éles környezethez
  4. Ajánlott architektúra
  5. Főbb megállapítások
  6. Teszteld a tudásod!

A Batch API alternatíva: 20%-os tokenkedvezmény

Ha a valós idejű feldolgozás nem követelmény, az xAI Batch API-ja 20%-os kedvezményt biztosít minden jogosult szöveges modell tokenjeire (a grok-4.3-tól a grok-4.7-ig, 2026. november 2-i állapot szerint, lásd: xAI batch árazás). Ahelyett, hogy egyesével küldenéd le a kéréseket és kezelnéd a párhuzamosítást, a kéréseidet kötegelve nyújthatod be az API-n keresztül vagy egy JSONL fájlban, majd a feldolgozás befejeztével – jellemzően 24 órán belül – lekérheted az eredményeket. A batch kérések nem számítanak bele a sebességkorlátokba (rate limits). A Batch API: Tömeges feldolgozás című kurzus részletezi a munkafolyamatot.

Mikor használd a Batch API-t?

  • Termékkatalógusok feldolgozása (ezernyi leírás)
  • Ügyfélszolgálati jegyek tömeges osztályozása
  • Összefoglalók generálása egy dokumentumbázishoz
  • Bármely feladat, ahol elfogadható a néhány órás késleltetés

Mikor maradj a klasszikus aszinkron megoldásnál?

  • Interaktív chatbot (valós idejű válasz szükséges)
  • Olyan folyamat, ahol minden lépés az előzőtől függ
  • Valós idejű monitorozás és riasztások
  • Bármely eset, ahol a Batch API késleltetése elfogadhatatlan

Megközelítések összehasonlítása

Szempont Aszinkron + Szemafór Batch API
Költség Standard díjszabás -20% a tokenekre jogosult modelleknél
Késleltetés Másodpercek percektől Percek óráktól
Kontroll Valós idejű, azonnali hibakezelés Eredmények a feldolgozás végén, kérésenkénti hibák
Komplexitás Szemafór, backoff, gather Kérések kötege vagy JSONL fájl, számláló követése
Sebességkorlátok RPM/TPM alá esik Az xAI kezeli

Ellenőrző lista éles környezethez

Mielőtt éles környezetbe telepítenéd az aszinkron kéréskezelő rendszeredet, ellenőrizd a lista minden pontját:

Konfiguráció

  • A time-out értéke 3600 másodpercre van állítva a következtető (reasoning) modelleknél
  • A szemafór méretezése a tényleges sebességkorlátok alapján történik (nem becslések alapján)
  • Exponenciális backoff implementálva jitterrel a 429-es hibákhoz
  • Az API-kulcsok környezeti változókból töltődnek be, soha nincsenek beégetve a kódba
  • Az x-grok-conv-id fejléc használata többmenetes beszélgetésekhez

Hibakezelés

  • A return_exceptions=True paraméter használata az asyncio.gather hívásnál a hibák izolálására
  • A 429-es, time-out és kapcsolódási hibák újrapróbálkozást indítanak el
  • Érvénytelen kérés hibák (BadRequestError) nem indítanak újrapróbálkozást
  • A sikertelen kérések azonosíthatók és újra elküldhetők
  • A naplók tartalmazzák a hiba típusát, a próbálkozások számát és az újrapróbálkozás késleltetését

Monitorozás

  • A felhasznált tokenek számának követése a response.usage alapján
  • A gyorsítótár találati arányának mérése az x-grok-conv-id használatának validálására
  • A költségek valós idejű becslése a cost_in_usd_ticks segítségével
  • A fennmaradó sebességkorlátok figyelése a szemafór dinamikus igazításához

Teljesítmény

  • Darabolás (chunking) alkalmazása 100 kérésnél nagyobb kötegeknél
  • Közbenső eredmények mentése az al-kötegek között
  • Haladás megjelenítése hosszú ideig futó feladatoknál
  • A szemafór igazítása a használt modell alapján (következtető modelleknél alacsonyabb érték)

Biztonság

  • Az API-kulcsok nem látszanak a naplókban vagy hibaüzenetekben
  • Érzékeny adatokat tartalmazó válaszok memóriában kerülnek feldolgozásra, nem íródnak lemezre
  • A távoli tárolás (store_messages) letiltva bizalmas adatok esetén
  • A use_encrypted_content engedélyezve, amikor a következtetés titkossága követelmény

Ajánlott architektúra

import os
import asyncio
import uuid
from asyncio import Semaphore
from openai import AsyncOpenAI, RateLimitError, APITimeoutError
import httpx

class GrokAsyncProcessor:
    def __init__(self, max_concurrent: int = 5):
        self.client = AsyncOpenAI(
            api_key=os.getenv("XAI_API_KEY"),
            base_url="https://api.x.ai/v1",
            timeout=httpx.Timeout(3600.0)
        )
        self.sem = Semaphore(max_concurrent)
        self.conv_id = str(uuid.uuid4())

    async def request(self, prompt: str, max_retries: int = 5) -> str:
        async with self.sem:
            for attempt in range(max_retries):
                try:
                    response = await self.client.chat.completions.create(
                        model="grok-4.5",
                        messages=[{"role": "user", "content": prompt}],
                        extra_headers={"x-grok-conv-id": self.conv_id}
                    )
                    return response.choices[0].message.content
                except RateLimitError:
                    if attempt == max_retries - 1:
                        raise
                    await asyncio.sleep(2 ** attempt)
                except APITimeoutError:
                    if attempt == max_retries - 1:
                        raise
                    await asyncio.sleep(2 ** attempt)

    async def batch(self, prompts: list[str]) -> list[str | Exception]:
        tasks = [self.request(p) for p in prompts]
        return await asyncio.gather(*tasks, return_exceptions=True)

Ez az osztály magába foglalja a kurzus során tárgyalt összes mintát: aszinkron kliens, szemafór, backoff, gyorsítótár és hibakezelés. Szilárd kiindulópontot biztosít az éles projektekhez.

Főbb megállapítások

  • A Batch API 20% kedvezményt kínál jogosult modelleknél, de feldolgozási késleltetéssel jár
  • Válassz a valós idejű aszinkron és a batch megoldás között a késleltetési követelményeid alapján
  • Az éles környezeti ellenőrző lista kiterjed a konfigurációra, hibákra, monitorozásra, teljesítményre és biztonságra
  • A GrokAsyncProcessor osztály egyetlen absztrakcióba zárja a kurzus összes mintáját
  • Mindig teszteld a konfigurációdat egy kis köteggel, mielőtt elindítanád a tömeges feldolgozást

Teszteld a tudásod!

Aszinkron műveletek, korlátok, gyorsítótár: éles környezeti minták öt kérdésben.

1. Mikor előnyösebb az aszinkron a szinkronnal szemben?

Válasz: Amikor több független kérést kezelsz: az AsyncClient (vagy AsyncOpenAI) átfedi a hálózati várakozási időket – a throughput szorzódik anélkül, hogy szálakat szoroznánk.

2. Hogyan dolgozol fel egy köteget anélkül, hogy túllépnéd a korlátokat?

Válasz: asyncio.gather a párhuzamosításhoz, egy szemafór a párhuzamos kérések korlátozására, és exponenciális backoff a HTTP 429-es hibákra – tiszteletben tartva a konzol RPM/TPM korlátait.

3. Hogyan kezeled a többmenetes kontextust nagy méretben?

Válasz: Szerveroldali válaszok tárolásával és újrafelhasznált titkosított következtetéssel – az állapot az API oldalán él, a kódod csak az azonosítókat követi.

4. Mit kell tudnod a gyorsítótárról és a time-outokról?

Válasz: A beszélgetés gyorsítótár (x-grok-conv-id) felgyorsítja a folytatott szálakat, a következtető kérések pedig igazított time-outot igényelnek – két beállítás, amely átalakítja az éles működést.

5. Mit tartalmaz a kurzus éles környezeti ellenőrző listája?

Válasz: Elsajátított aszinkron műveletek, betartott korlátok (szemafór + backoff), batch a hideg adatmennyiséghez, konfigurált time-outok és újrapróbálkozások, követett költségek – a robusztusság ellenőrző lista formájában.

Korlátozott párhuzamosítás, tervezett hibakezelés, szerveroldali állapot: az aszinkron minták szolgáltatássá alakítják a szkriptjeidet – a végső ellenőrző lista pedig biztosítja őket.