xAI SDK : client.chat.create

Le SDK natif xAI

Le SDK officiel de xAI est la maniere la plus directe d’utiliser l’endpoint Chat Completions avec les modeles Grok. Il offre un typage complet, une gestion automatique de l’authentification et un acces a toutes les fonctionnalites specifiques a xAI sans configuration supplementaire.

Installation

Le SDK est disponible en Python via pip :

pip install xai-sdk

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

export XAI_API_KEY="votre-cle-api"

Premiere requete avec client.chat.create

La methode client.chat.create() est l’equivalent 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-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 detecte 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

Parametres de generation

La methode chat.create() accepte plusieurs parametres pour controler la generation :

response = client.chat.create(
    model="grok-4.20-reasoning",
    messages=[
        {"role": "system", "content": "Reponds 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 parametres principaux

• model : identifiant du modele (obligatoire). Exemples : grok-4.20-reasoning, grok-4.20
• messages : tableau de messages avec roles (obligatoire)
• temperature : controle la creativite (0.0 = deterministe, 2.0 = tres creatif). Defaut : 1.0
• max_tokens : nombre maximum de tokens dans la reponse
• top_p : echantillonnage par noyau (alternative a temperature). Valeur entre 0 et 1
• stop : sequences qui arretent la generation (string ou tableau de strings)
• stream : si True, la reponse est envoyee token par token

Streaming des reponses

Pour les reponses longues, le streaming ameliore l’experience utilisateur en affichant le texte au fur et a mesure de la generation :

stream = client.chat.create(
    model="grok-4.20-reasoning",
    messages=[
        {"role": "user", "content": "Ecris 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 genere. Le champ delta.content peut etre None pour certains chunks (debut et fin de stream).

Gestion des erreurs

Le SDK leve des exceptions specifiques 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-reasoning",
        messages=[{"role": "user", "content": "Bonjour"}]
    )
except RateLimitError:
    print("Limite de debit atteinte, reessayez 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-reasoning",
        messages=[{"role": "user", "content": "Bonjour"}]
    )
    print(response.choices[0].message.content)

asyncio.run(main())

Points cles a retenir

• Le SDK xAI s’installe avec pip install xai-sdk et utilise la variable XAI_API_KEY
• La methode client.chat.create() correspond a l’endpoint POST /v1/chat/completions
• Les parametres temperature, max_tokens, top_p et stop controlent la generation
• Le mode stream=True permet d’afficher la reponse token par token
• Un client asynchrone AsyncClient est disponible pour les applications asyncio