xAI SDK AsyncClient
Auf dieser Seite
Warum der Wechsel zu asynchron
Wenn Sie die xAI-API synchron abfragen, blockiert jeder Aufruf die Programmausführung, bis die Antwort eingetroffen ist. Bei einem Reasoning-Modell wie grok-4.5 kann eine einzelne Anfrage mehrere Zehntelsekunden dauern. Benötigen Sie die Verarbeitung von 100 Anfragen, wird die gesamte Wartezeit unvertretbar.
Der asynchrone Modus löst dieses Problem. Statt auf jede Antwort zu warten, startet Ihr Programm die Anfrage und setzt die Ausführung fort. Sie rufen das Ergebnis später ab, sobald es verfügbar ist. Dieser Ansatz ermöglicht die parallele Verarbeitung mehrerer Anfragen und die vollständige Auslastung Ihrer Bandbreite zur API.
Initialisierung des AsyncClient
Das xAI SDK stellt eine AsyncClient-Klasse für asynchrone Aufrufe bereit. Die Initialisierung ist dem synchronen Client ähnlich, wobei Sie den Parameter timeout immer konfigurieren müssen:
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 entspricht einer Stunde. Dieser Wert mag zunächst hoch erscheinen, ist jedoch für Reasoning-Modelle notwendig, die vor der Antwort eine ausgedehnte Reasoning-Phase durchführen. Ein zu kurzer Timeout führt bei komplexen Anfragen zu Verbindungsabbruch-Fehlern.
Absenden einer asynchronen Anfrage
Nach der Initialisierung des Clients senden Sie Anfragen unter Verwendung der await-Syntax von Python:
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
# Einstiegspunkt
result = asyncio.run(ask_grok("Explain the algorithmic complexity of quicksort"))
print(result)
Die Funktion ask_grok verwendet async def und ist somit ein Koroutines. Der Aufruf await chat.sample() setzt dieses Koroutine aus, bis die Antwort eingetroffen ist, ohne andere potenzielle Aufgaben zu blockieren.
Unterschied zum synchronen Client
Der synchrone Client blockiert den aktuellen Thread für die gesamte Dauer der Anfrage. Der asynchrone Client gibt den Thread frei, um andere Koroutinen auszuführen. Dieser Unterschied ist irrelevant, wenn Sie nur eine Anfrage senden, wird jedoch kritisch, wenn Sie mehrere Anfragen parallel verarbeiten.
# Synchron: Jeder Aufruf wartet auf die Antwort
for question in questions:
response = client.chat.completions.create(...) # blockierend
process(response)
# Asynchron: Aufrufe laufen parallel ab
async def main():
tasks = [ask_grok(q) for q in questions]
responses = await asyncio.gather(*tasks) # parallel
for r in responses:
process(r)
Im synchronen Beispiel beträgt die Gesamtzeit 200 Sekunden, wenn jede Anfrage 10 Sekunden dauert und Sie 20 Anfragen haben. Im asynchronen Modus mit einem Semaphore von 5 (das Sie in späteren Lektionen entdecken werden) sinkt die Zeit auf etwa 40 Sekunden.
Kernaussagen
- Der xAI SDK
AsyncClientermöglicht das Absenden von Anfragen ohne Blockierung der Ausführung. - Der Parameter
timeout=3600ist für Reasoning-Modelle unerlässlich. - Das
xai-sdkerfordert Python 3.10 oder höher (Version 1.21.0 vom 2. November 2026 laut PyPI). - Der tatsächliche Nutzen zeigt sich bei der parallelen Verarbeitung mehrerer Anfragen.
asyncio.run()dient als Einstiegspunkt, um ein Koroutine aus synchronem Code auszuführen.