xAI SDK : client.chat.create

Le SDK natif xAI

Le SDK officiel de xAI est la manière la plus directe d’utiliser l’endpoint Chat Completions avec les modèles Grok. Il offre un typage complet, une gestion automatique de l’authentification et un accès à toutes les fonctionnalités spécifiques à xAI sans configuration supplémentaire.

Installation

Le SDK est disponible en Python via pip :

pip install xai-sdk

L’authentification se fait via une clé API que vous obtenez depuis la console xAI. Stockez-la dans une variable d’environnement :

export XAI_API_KEY="votre-cle-api"

Première requête avec client.chat.create

La méthode client.chat.create() est l’équivalent de l’endpoint POST /v1/chat/completions. Voici un exemple minimal :

import os
from xai_sdk import Client

client = Client(api_key=os.getenv("XAI_API_KEY"))

response = client.chat.create(
    model="grok-4.20-0309-reasoning",
    messages=[
        {"role": "system", "content": "Tu es un assistant utile."},
        {"role": "user", "content": "Explique le deep learning en 3 phrases."}
    ]
)

print(response.choices[0].message.content)

Le SDK détecte automatiquement la variable XAI_API_KEY si vous ne la passez pas explicitement. Vous pouvez donc simplifier l’initialisation :

client = Client()  # Utilise XAI_API_KEY automatiquement

Paramètres de génération

La méthode chat.create() accepte plusieurs paramètres pour contrôler la génération :

response = client.chat.create(
    model="grok-4.20-0309-reasoning",
    messages=[
        {"role": "system", "content": "Réponds uniquement en JSON."},
        {"role": "user", "content": "Liste 3 langages de programmation populaires."}
    ],
    temperature=0.7,
    max_tokens=500,
    top_p=0.9,
    stop=["\n\n"]
)

Les paramètres principaux

• model : identifiant du modèle (obligatoire). Exemples : grok-4.20-0309-reasoning, grok-4.20
• messages : tableau de messages avec rôles (obligatoire)
• temperature : contrôle la créativité (0.0 = déterministe, 2.0 = très créatif). Défaut : 1.0
• max_tokens : nombre maximum de tokens dans la réponse
• top_p : échantillonnage par noyau (alternative à temperature). Valeur entre 0 et 1
• stop : séquences qui arrêtent la génération (string ou tableau de strings)
• stream : si True, la réponse est envoyée token par token

Streaming des réponses

Pour les réponses longues, le streaming améliore l’expérience utilisateur en affichant le texte au fur et à mesure de la génération :

stream = client.chat.create(
    model="grok-4.20-0309-reasoning",
    messages=[
        {"role": "user", "content": "Écris un article sur l'IA generative."}
    ],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

En mode streaming, chaque chunk contient un objet delta (au lieu de message) avec le fragment de texte généré. Le champ delta.content peut être None pour certains chunks (début et fin de stream).

Gestion des erreurs

Le SDK lève des exceptions spécifiques que vous pouvez intercepter :

from xai_sdk import Client
from xai_sdk.errors import APIError, RateLimitError

client = Client()

try:
    response = client.chat.create(
        model="grok-4.20-0309-reasoning",
        messages=[{"role": "user", "content": "Bonjour"}]
    )
except RateLimitError:
    print("Limite de débit atteinte, réessayez dans quelques secondes.")
except APIError as e:
    print(f"Erreur API : {e.status_code} - {e.message}")

Appel asynchrone

Le SDK propose aussi un client asynchrone pour les applications asyncio :

import asyncio
from xai_sdk import AsyncClient

async def main():
    client = AsyncClient()
    response = await client.chat.create(
        model="grok-4.20-0309-reasoning",
        messages=[{"role": "user", "content": "Bonjour"}]
    )
    print(response.choices[0].message.content)

asyncio.run(main())

Points clés à retenir

• Le SDK xAI s’installe avec pip install xai-sdk et utilise la variable XAI_API_KEY
• La méthode client.chat.create() correspond à l’endpoint POST /v1/chat/completions
• Les paramètres temperature, max_tokens, top_p et stop contrôlent la génération
• Le mode stream=True permet d’afficher la réponse token par token
• Un client asynchrone AsyncClient est disponible pour les applications asyncio