AsyncClient du xAI SDK

Pourquoi passer a l’asynchrone

Lorsque vous interrogez l’API xAI de maniere synchrone, chaque appel bloque l’execution de votre programme jusqu’a reception de la reponse. Pour un modele de raisonnement comme grok-4, une seule requete peut prendre plusieurs dizaines de secondes. Si vous devez traiter cent requetes, le temps d’attente total devient prohibitif.

Le mode asynchrone resout ce probleme. Au lieu d’attendre chaque reponse, votre programme lance la requete et continue son execution. Le resultat est recupere plus tard, quand il est disponible. Cette approche permet de traiter plusieurs requetes en parallele et d’exploiter pleinement la bande passante de votre connexion vers l’API.

Initialiser l’AsyncClient

Le xAI SDK fournit une classe AsyncClient dediee aux appels asynchrones. L’initialisation est similaire au client synchrone, avec un parametre timeout que vous devez systematiquement 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 a une heure. Cette valeur peut sembler elevee, mais elle est necessaire pour les modeles de raisonnement qui effectuent une reflexion longue avant de repondre. Un timeout trop court provoquerait des erreurs de deconnexion sur les requetes complexes.

Envoyer une requete asynchrone

Une fois le client initialise, vous envoyez des requetes avec la syntaxe await de Python :

import asyncio

async def ask_grok(question: str) -> str:
    chat = client.chat.create(
        model="grok-4.20-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 complexite algorithmique de quicksort"))
print(result)

La fonction ask_grok est declaree avec async def, ce qui en fait une coroutine. L’appel await chat.sample() suspend l’execution de cette coroutine jusqu’a reception de la reponse, sans bloquer les autres taches eventuelles.

Difference avec le client synchrone

Le client synchrone bloque le thread courant pendant toute la duree de la requete. Le client asynchrone, lui, libere le thread pour executer d’autres coroutines. Cette distinction n’a pas d’impact si vous n’envoyez qu’une seule requete, mais elle devient decisive des que vous traitez plusieurs requetes en parallele.

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

# Asynchrone : les appels s'executent en parallele
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 requete prend 10 secondes et que vous en avez 20, le temps total est de 200 secondes. En asynchrone avec un semaphore de 5 (que vous decouvrirez dans les lecons suivantes), le temps tombe a environ 40 secondes.

Points cles a retenir

• L’AsyncClient du xAI SDK permet d’envoyer des requetes sans bloquer l’execution
• Le parametre timeout=3600 est indispensable pour les modeles de raisonnement
• La syntaxe async/await de Python 3.7+ est requise
• L’avantage reel apparait lors du traitement de plusieurs requetes en parallele
• asyncio.run() sert de point d’entree pour executer une coroutine depuis du code synchrone