AsyncClient du xAI SDK

Pourquoi passer à l’asynchrone

Lorsque vous interrogez l’API xAI de manière synchrone, chaque appel bloque l’exécution de votre programme jusqu’à réception de la réponse. Pour un modèle de raisonnement comme grok-4.5, une seule requête peut prendre plusieurs dizaines de secondes. Si vous devez traiter cent requêtes, le temps d’attente total devient prohibitif.

Le mode asynchrone résout ce problème. Au lieu d’attendre chaque réponse, votre programme lance la requête et continue son exécution. Le résultat est récupéré plus tard, quand il est disponible. Cette approche permet de traiter plusieurs requêtes en parallèle et d’exploiter pleinement la bande passante de votre connexion vers l’API.

Initialiser l’AsyncClient

Le xAI SDK fournit une classe AsyncClient dédiée aux appels asynchrones. L’initialisation est similaire au client synchrone, avec un paramètre timeout que vous devez systématiquement configurer :

import os
from xai_sdk import AsyncClient
from xai_sdk.chat import user

client = AsyncClient(
    api_key=os.getenv("XAI_API_KEY"),
    timeout=3600,
)

Le timeout=3600 correspond à une heure. Cette valeur peut sembler élevée, mais elle est nécessaire pour les modèles de raisonnement qui effectuent une réflexion longue avant de répondre. Un timeout trop court provoquerait des erreurs de déconnexion sur les requêtes complexes.

Envoyer une requête asynchrone

Une fois le client initialisé, vous envoyez des requêtes avec la syntaxe await de 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

# Point d'entree
result = asyncio.run(ask_grok("Explique la complexité algorithmique de quicksort"))
print(result)

La fonction ask_grok est déclarée avec async def, ce qui en fait une coroutine. L’appel await chat.sample() suspend l’exécution de cette coroutine jusqu’à réception de la réponse, sans bloquer les autres tâches éventuelles.

Différence avec le client synchrone

Le client synchrone bloque le thread courant pendant toute la durée de la requête. Le client asynchrone, lui, libère le thread pour exécuter d’autres coroutines. Cette distinction n’a pas d’impact si vous n’envoyez qu’une seule requête, mais elle devient décisive dès que vous traitez plusieurs requêtes en parallèle.

# Synchrone : chaque appel attend la réponse
for question in questions:
    response = client.chat.completions.create(...)  # bloquant
    process(response)

# Asynchrone : les appels s'exécutent en parallèle
async def main():
    tasks = [ask_grok(q) for q in questions]
    responses = await asyncio.gather(*tasks)  # parallele
    for r in responses:
        process(r)

Dans l’exemple synchrone, si chaque requête prend 10 secondes et que vous en avez 20, le temps total est de 200 secondes. En asynchrone avec un sémaphore de 5 (que vous découvrirez dans les leçons suivantes), le temps tombe à environ 40 secondes.

Points clés à retenir

• L’AsyncClient du xAI SDK permet d’envoyer des requêtes sans bloquer l’exécution
• Le paramètre timeout=3600 est indispensable pour les modèles de raisonnement
• La syntaxe async/await de Python 3.7+ est requise
• L’avantage réel apparaît lors du traitement de plusieurs requêtes en parallèle
• asyncio.run() sert de point d’entrée pour exécuter une coroutine depuis du code synchrone