xAI SDK AsyncClient
Op deze pagina
Waarom overschakelen op asynchroon
Wanneer u de xAI API synchroon bevraagt, blokkeert elke aanroep de uitvoering van uw programma totdat het antwoord binnenkomt. Voor een redeneermodel zoals grok-4.5 kan een enkel verzoek enkele tientallen seconden duren. Als u 100 verzoeken moet verwerken, wordt de totale wachttijd onaanvaardbaar.
De asynchrone modus lost dit probleem op. In plaats van op elk antwoord te wachten, start uw programma het verzoek en gaat door met de uitvoering. U haalt het resultaat later op, zodra het beschikbaar is. Deze aanpak stelt u in staat meerdere verzoeken parallel te verwerken en uw bandbreedte naar de API optimaal te benutten.
De AsyncClient initialiseren
De xAI SDK biedt een AsyncClient-klasse die specifiek is ontworpen voor asynchrone aanroepen. De initialisatie lijkt op die van de synchrone client, maar vereist dat u altijd een timeout-parameter configureert:
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 komt overeen met één uur. Deze waarde lijkt misschien hoog, maar is noodzakelijk voor redeneermodellen die uitgebreide denkprocessen uitvoeren voordat ze antwoorden. Een te korte time-out leidt tot verbindingsfouten bij complexe verzoeken.
Een asynchroon verzoek verzenden
Zodra u de client hebt geïnitialiseerd, verzendt u verzoeken met behulp van de Python-syntaxis await:
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
# Entry point
result = asyncio.run(ask_grok("Explain the algorithmic complexity of quicksort"))
print(result)
De functie ask_grok gebruikt async def, waardoor het een coroutine wordt. De aanroep await chat.sample() onderbreekt deze coroutine totdat het antwoord binnenkomt, zonder andere potentiële taken te blokkeren.
Verschil met de synchrone client
De synchrone client blokkeert de huidige thread gedurende de volledige duur van het verzoek. De asynchrone client maakt de thread vrij om andere coroutines uit te voeren. Dit onderscheid maakt geen verschil als u slechts één verzoek verzendt, maar wordt cruciaal wanneer u meerdere verzoeken parallel verwerkt.
# Sync: each call waits for the response
for question in questions:
response = client.chat.completions.create(...) # blocking
process(response)
# Async: calls run in parallel
async def main():
tasks = [ask_grok(q) for q in questions]
responses = await asyncio.gather(*tasks) # parallel
for r in responses:
process(r)
In het synchrone voorbeeld duurt elk verzoek 10 seconden; bij 20 verzoeken is de totale tijd 200 seconden. In de asynchrone modus, met een semaphore van 5 (wat u in latere lessen zult ontdekken), daalt de tijd tot ongeveer 40 seconden.
Belangrijkste punten
- Met de xAI SDK
AsyncClientkunt u verzoeken verzenden zonder de uitvoering te blokkeren - De parameter
timeout=3600is essentieel voor redeneermodellen - De
xai-sdkvereist Python 3.10 of later (versie 1.21.0 per 2 november 2026, volgens PyPI) - Het echte voordeel komt naar voren bij het parallel verwerken van meerdere verzoeken
asyncio.run()dient als startpunt om een coroutine vanuit synchrone code uit te voeren