Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

xAI SDK AsyncClient

Nodarbība 1 no 12 Atjaunota 2026. gada 2. novembris Augstākais
Šajā lapā
  1. Kāpēc pāriet uz asinhrono režīmu
  2. AsyncClient inicializēšana
  3. Asinhrona pieprasījuma nosūtīšana
  4. Atšķirība no sinhronā klienta
  5. Galvenās atziņas

Kāpēc pāriet uz asinhrono režīmu

Kad veic vaicājumus xAI API sinhroni, katrs izsaukums bloķē tavas programmas izpildi, līdz tiek saņemta atbilde. Spriešanas modelim, piemēram, grok-4.5, viens pieprasījums var ilgt vairākas desmit sekundes. Ja tev jāapstrādā 100 pieprasījumi, kopējais gaidīšanas laiks kļūst nepieņemams.

Asinhronais režīms atrisina šo problēmu. Tava programma nevis gaida katru atbildi, bet gan uzsāk pieprasījumu un turpina izpildi. Rezultātu tu iegūsti vēlāk, kad tas ir pieejams. Šī pieeja ļauj apstrādāt vairākus pieprasījumus paralēli un pilnībā izmantot tavu joslas platumu, strādājot ar API.

3600s
Ieteicamais noildze
5x
Paralēlā caurlaidspēja
-50%
Alternatīva partijas API
RPM
Ievērojamais ātruma ierobežojums

AsyncClient inicializēšana

xAI SDK nodrošina AsyncClient klasi, kas paredzēta asinhroniem izsaukumiem. Inicializēšana ir līdzīga sinhronajam klientam, taču obligāti jākonfigurē parametrs timeout:

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 atbilst vienai stundai. Šī vērtība var šķist liela, taču tā ir nepieciešama spriešanas modeļiem, kuri veic ilgstošu spriešanu pirms atbildes sniegšanas. Pārāk īss noildze sarežģītos pieprasījumos izraisa savienojuma pārtraukuma kļūdas.

Asinhrona pieprasījuma nosūtīšana

Klients ir inicializēts, tagad pieprasījumus vari nosūtīt, izmantojot Python await sintaksi:

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

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

Funkcija ask_grok izmanto async def, padarot to par korutīnu. Izsaukums await chat.sample() aptur šo korutīnu, līdz tiek saņemta atbilde, nebloķējot citus iespējamos uzdevumus.

Atšķirība no sinhronā klienta

Sinhronais klients bloķē pašreizējo pavedienu visa pieprasījuma laikā. Asinhronais klients atbrīvo pavedienu, lai tas varētu izpildīt citas korutīnas. Šī atšķirība nav būtiska, ja nosūti tikai vienu pieprasījumu, taču tā kļūst kritiska, apstrādājot vairākus pieprasījumus paralēli.

# Sinhroni: katrs izsaukums gaida atbildi
for question in questions:
    response = client.chat.completions.create(...)  # bloķējošs
    process(response)

# Asinhroni: izsaukumi darbojas paralēli
async def main():
    tasks = [ask_grok(q) for q in questions]
    responses = await asyncio.gather(*tasks)  # paralēli
    for r in responses:
        process(r)

Sinhronajā piemērā, ja katrs pieprasījums ilgst 10 sekundes un tev ir 20 pieprasījumi, kopējais laiks ir 200 sekundes. Asinhronajā režīmā, izmantojot semaforu ar vērtību 5 (ko apgūsi turpmākajās nodarbībās), laiks samazinās līdz aptuveni 40 sekundēm.

Galvenās atziņas

  • xAI SDK AsyncClient ļauj nosūtīt pieprasījumus, nebloķējot izpildi
  • Parametrs timeout=3600 ir būtisks spriešanas modeļiem
  • xai-sdk prasa Python 3.10 vai jaunāku versiju (versija 1.21.0, sākot no 2026. gada 2. novembra, pēc PyPI datiem)
  • Reālais ieguvums parādās, apstrādājot vairākus pieprasījumus paralēli
  • asyncio.run() kalpo kā ieejas punkts, lai izpildītu korutīnu no sinhrona koda