Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

xAI SDK AsyncClient

Lektion 1 von 12 Aktualisiert am 2. November 2026 Fortgeschritten
Auf dieser Seite
  1. Warum der Wechsel zu asynchron
  2. Initialisierung des AsyncClient
  3. Absenden einer asynchronen Anfrage
  4. Unterschied zum synchronen Client
  5. Kernaussagen

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.

3600s
Empfohlene Timeout-Dauer
5x
Paralleler Durchsatz
-50%
Alternative zur Batch-API
RPM
Rate Limit, der beachtet werden muss

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 AsyncClient ermöglicht das Absenden von Anfragen ohne Blockierung der Ausführung.
  • Der Parameter timeout=3600 ist für Reasoning-Modelle unerlässlich.
  • Das xai-sdk erfordert 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.