Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

xAI SDK AsyncClient

Les 1 van 12 Bijgewerkt op 2 november 2026 Gevorderd
Op deze pagina
  1. Waarom overschakelen op asynchroon
  2. De AsyncClient initialiseren
  3. Een asynchroon verzoek verzenden
  4. Verschil met de synchrone client
  5. Belangrijkste punten

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.

3600s
Recommended timeout
5x
Parallel throughput
-50%
Batch API alternative
RPM
Rate limit to respect

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 AsyncClient kunt u verzoeken verzenden zonder de uitvoering te blokkeren
  • De parameter timeout=3600 is essentieel voor redeneermodellen
  • De xai-sdk vereist 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