Lähe põhisisu juurde
Eesti— Vali keel
Menüü

xAI SDK AsyncClient

Õppetund 1 / 12 Värskendatud 2. november 2026 Edasijõudnutele
Sellel lehel
  1. Miks minna asünkroonsele režiimile
  2. AsyncClient’i initsialiseerimine
  3. Asünkroonse päringu saatmine
  4. Erinevus sünkroonsest kliendist
  5. Peamised punktid

Miks minna asünkroonsele režiimile

Kui pärid xAI API-lt sünkroonselt, blokeerib iga väljakutse sinu programmi täitmise kuni vastuse saabumiseni. Põhjendusmudeli nagu grok-4.5 puhul võib üks päring võtta mitukümmend sekundit. Kui sul on vaja töödelda 100 päringut, muutub ooteaeg lubamatuks.

Asünkroonne režiim lahendab selle probleemi. Selle asemel, et oodata iga vastust järele, käivitab sinu programm päringu ja jätkab kohe tegutsemist. Tulemuse tood hiljem, kui see on valmis. See lähenemine võimaldab sul töödelda mitut päringut paralleelselt ja kasutada API ribalaiust täielikult ära.

3600s
Soovitatud aegumine
5x
Paralleelne läbilaskevõime
-50%
Batch API alternatiiv
RPM
Järgitav kiirusepiirang

AsyncClient’i initsialiseerimine

xAI SDK pakub asünkroonsete väljakutsete jaoks mõeldud AsyncClient klassi. Initsialiseerimine sarnaneb sünkroonse kliendiga, kuid sisaldab parameetrit timeout, mille pead alati seadistama:

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

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

timeout=3600 võrdub ühe tunniga. See väärtus võib tunduda kõrge, kuid see on vajalik põhjendusmudelite jaoks, mis teevad enne vastamist pikki arutluskäike. Liiga lühike aegumine põhjustab keerukate päringute korral ühenduse katkemise vigu.

Asünkroonse päringu saatmine

Kui klient on initsialiseeritud, saadad päringuid, kasutades Pythoni await süntaksit:

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

# Sisendpunkt
result = asyncio.run(ask_grok("Explain the algorithmic complexity of quicksort"))
print(result)

Funktsioon ask_grok kasutab async def, muutes selle korutiiniks. Väljakutse await chat.sample() peatab selle korutiini kuni vastuse saabumiseni, blokeerimata seejuures muid võimalikke ülesandeid.

Erinevus sünkroonsest kliendist

Sünkroonne klient blokeerib jooksva lõime kogu päringu kestuse ajaks. Asünkroonne klient vabastab lõime teiste korutiinide käivitamiseks. See erinevus ei oma tähtsust, kui saadad ainult ühe päringu, kuid muutub kriitiliseks mitme päringu paralleelsel töötlemisel.

# Sünkroonne: iga väljakutse ootab vastust
for question in questions:
    response = client.chat.completions.create(...)  # blokeeriv
    process(response)

# Asünkroonne: väljakutsed jooksevad paralleelselt
async def main():
    tasks = [ask_grok(q) for q in questions]
    responses = await asyncio.gather(*tasks)  # paralleelne
    for r in responses:
        process(r)

Sünkroonses näites, kui iga päring võtab 10 sekundit ja sul on neid 20, on koguaeg 200 sekundit. Asünkroonses režiimis, kasutades semafori väärtusega 5 (millest saad teada hilisemates tundides), langeb aeg umbes 40 sekundini.

Peamised punktid

  • xAI SDK AsyncClient võimaldab saata päringuid ilma täitmist blokeerimata
  • Parameeter timeout=3600 on põhjendusmudelite jaoks hädavajalik
  • xai-sdk nõuab Pythoni versiooni 3.10 või uuemat (versioon 1.21.0 seisuga 2. november 2026, vastavalt PyPI-le)
  • Tegelik kasu ilmneb mitme päringu paralleelsel töötlemisel
  • asyncio.run() toimib sisendpunktina korutiini käivitamiseks sünkroonsest koodist