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

xAI SDK AsyncClient

1. lecke 12 közül Frissítve 2026. november 2. Haladó
Ezen az oldalon
  1. Miért válts aszinkron módra?
  2. Az AsyncClient inicializálása
  3. Aszinkron kérés küldése
  4. Különbség a szinkron klienshez képest
  5. Főbb megállapítások

Miért válts aszinkron módra?

Ha szinkron módon kérdezed le az xAI API-t, minden hívás blokkolja a programod futását a válasz megérkezéséig. Egy olyan következtető modellnél, mint a grok-4.5, egyetlen kérés is több tíz másodpercig tarthat. Ha 100 kérést kell feldolgoznod, a teljes várakozási idő elfogadhatatlanná válik.

Az aszinkron mód megoldja ezt a problémát. Ahelyett, hogy minden válaszra várni kellene, a programod elindítja a kérést, és folytatja a végrehajtást. Az eredményt később, annak elérhetővé válásakor kapod meg. Ez a megközelítés lehetővé teszi több kérés párhuzamos feldolgozását, és az API-sávszélességed teljes kihasználását.

3600s
Ajánlott időtúllépés
5x
Párhuzamos átvitel
-50%
Batch API alternatíva
RPM
Betartandó sebességkorlát

Az AsyncClient inicializálása

Az xAI SDK biztosít egy AsyncClient osztályt, kifejezetten aszinkron hívásokhoz. Az inicializálás hasonló a szinkron klienséhez, de tartalmaz egy timeout paramétert, amelyet mindig konfigurálnod kell:

import os
from xai_sdk import AsyncClient
from xai_sdk.chat import user

client = AsyncClient(
    api_key=os.getenv("XAI_API_KEY"),
    timeout=3600,
)

A timeout=3600 egy órát jelent. Ez az érték magasnak tűnhet, de szükséges azokhoz a következtető modellekhez, amelyek a válaszadás előtt hosszas következtetési folyamatot végeznek. A túl rövid időtúllépés kapcsolati hibákat okoz összetett kérések esetén.

Aszinkron kérés küldése

Miután inicializáltad a klienst, a kéréseket Python await szintaxisával küldheted el:

import asyncio

async def ask_grok(question: str) -> str:
    chat = client.chat.create(
        model="grok-4.20-0309-reasoning",
        max_tokens=500
    )
    chat.append(user(question))
    response = await chat.sample()
    return response.text

# Belépési pont
result = asyncio.run(ask_grok("Explain the algorithmic complexity of quicksort"))
print(result)

Az ask_grok függvény az async def kulcsszót használja, így koroutinná válik. Az await chat.sample() hívás felfüggeszti ezt a koroutint a válasz megérkezéséig anélkül, hogy blokkolna más lehetséges feladatokat.

Különbség a szinkron klienshez képest

A szinkron kliens a kérés teljes időtartamára blokkolja az aktuális szálat. Az aszinkron kliens felszabadítja a szálat más koroutinok végrehajtásához. Ennek a különbségnek nincs jelentősége, ha csak egyetlen kérést küldesz, de kritikussá válik, amikor több kérést dolgozol fel párhuzamosan.

# Szinkron: minden hívás vár a válaszra
for question in questions:
    response = client.chat.completions.create(...)  # blokkoló
    process(response)

# Aszinkron: a hívások párhuzamosan futnak
async def main():
    tasks = [ask_grok(q) for q in questions]
    responses = await asyncio.gather(*tasks)  # párhuzamos
    for r in responses:
        process(r)

A szinkron példában, ha minden kérés 10 másodpercig tart, és 20 kérésed van, a teljes idő 200 másodperc. Aszinkron módban, 5-ös szemafórral (amit a későbbi leckékben ismersz meg), az idő körülbelül 40 másodpercre csökken.

Főbb megállapítások

  • Az xAI SDK AsyncClient osztálya lehetővé teszi a kérések küldését a végrehajtás blokkolása nélkül
  • A timeout=3600 paraméter elengedhetetlen a következtető modellekhez
  • Az xai-sdk Python 3.10 vagy újabb verziót igényel (a PyPI adatai szerint 2026. november 2-án az 1.21.0 verzió volt elérhető)
  • A valódi előny több kérés párhuzamos feldolgozásakor mutatkozik meg
  • Az asyncio.run() szolgál belépési pontként egy koroutin szinkron kódból történő végrehajtásához