Spring til hovedindhold
Dansk— Vælg et sprog
Menu

xAI SDK: client.chat.create

Lektion 4 af 12 Opdateret 3. november 2026 Udvikler
På denne side
  1. Det native xAI SDK
  2. Installation og godkendelse
  3. En samtale, ikke en anmodning
  4. Genereringsparametre
  5. Streaming af svar
  6. Fejlhåndtering
  7. Asynkrone kald
  8. Vigtige pointer

Opdateret 3. november 2026. Den tidligere version antog, at xai-sdk brugte OpenAI SDK-grænsefladen: beskeder som ordbøger, response.choices[0].message.content, parameteren stream=True og et ikke-eksisterende xai_sdk.errors-modul. Med det faktiske SDK (version 1.21.0) fejler den kode ved første kald: ValueError: unknown enum label "user". Denne lektion følger nu den officielle SDK-README, og hvert eksempel er blevet kørt mod xAI-API’en (med en dummy-nøgle for at verificere kaldstien og fejl). Kilder: xAI Python SDK · Best practices (xAI) · Debugging Errors (xAI).

Det native xAI SDK

Det officielle xAI SDK til Python, xai-sdk, bruger ikke REST Chat Completions-endepunktet: det er et gRPC-bibliotek med en synkron klient (Client) og en asynkron klient (AsyncClient) til Python 3.10 og nyere. Det forsøger ikke at efterligne OpenAI SDK, og det er det første, du skal huske: dets objekter, metoder og fejl har deres egen struktur. Hvis du vil genbruge kode skrevet til OpenAI, viser næste lektion den anden vej: OpenAI SDK konfigureret til xAI-API’en.

Installation og godkendelse

pip install xai-sdk

Godkendelse sker via en API-nøgle oprettet i xAI-konsollen. Placér den i miljøvariablen XAI_API_KEY, som klienten læser automatisk:

export XAI_API_KEY="your-api-key"

En samtale, ikke en anmodning

Med dette SDK sender client.chat.create() ingenting: det opretter et samtaleobjekt (chat), som du tilføjer beskeder til med append, hvorefter du anmoder om et svar med sample(). Beskeder bygges med funktionerne system, user og assistant fra modulet xai_sdk.chat, ikke med ordbøger.

from xai_sdk import Client
from xai_sdk.chat import system, user

client = Client()  # læser XAI_API_KEY

chat = client.chat.create(
    model="grok-4.7",
    messages=[system("You are a helpful assistant. Respond in French.")],
)
chat.append(user("Explain deep learning in 3 sentences."))

response = chat.sample()
print(response.content)

Svaret eksponerer sin tekst direkte i response.content sammen med finish_reason, usage (forbrugte tokens), reasoning_content for modeller, der eksponerer dette, og citations, når der er udført en søgning.

API’en forbliver tilstandsløs: objektet chat holder historikken for dig. Ved en samtale over flere omgange skal du tilføje svaret til tråden før næste spørgsmål:

chat.append(response)
chat.append(user("Give a concrete example of an application."))
print(chat.sample().content)

Genereringsparametre

Parametre sendes til client.chat.create() og gælder for hele samtalen:

chat = client.chat.create(
    model="grok-4.7",
    messages=[system("Respond only in JSON.")],
    temperature=0.7,
    top_p=0.95,
    reasoning_effort="medium",
)
  • model: Modelidentifikatoren. xAI anbefaler grok-4.7 til alle anvendelser.
  • messages: De indledende beskeder, bygget med system, user og assistant.
  • temperature: API’en accepterer værdier fra 0 til 2, men xAI sætter loftet ved 1 derudover og anbefaler 0,7 med top_p sat til 0,95.
  • max_tokens: Det maksimale antal genererede tokens. xAI’s bedste praksis anbefaler at sætte denne værdi højere end det længste forventede svar eller at beholde standardværdien.
  • reasoning_effort: Dybden af ræsonnementet, fra none til high (og xhigh på nogle modeller). Standardværdien afhænger af modellen: xAI anbefaler at indstille den eksplicit ved hver anmodning og notere den sammen med hvert resultat.
  • response_format, tools, tool_choice: Strukturerede output og værktøjskald, som dækkes senere i kurset.

stop findes også (op til fire sekvenser), men xAI’s bedste praksis specificerer, at ræsonnementsmodeller ikke accepterer denne, ligesom de ikke accepterer presence_penalty og frequency_penalty.

Streaming af svar

xAI anbefaler streaming, især med ræsonnementsmodeller, hvis svar kan tage lang tid at modtage. Det bruger ikke en parameter: samtalen tilbyder en anden metode, stream(), som returnerer et par (response, chunk) ved hvert trin. chunk.content indeholder det tekstfragment, der netop er ankommet, og response akkumulerer det komplette svar gennem hele streamet.

chat = client.chat.create(model="grok-4.7")
chat.append(user("Write a short article on generative AI."))

for response, chunk in chat.stream():
    print(chunk.content, end="", flush=True)
print()

chat.append(response)  # det komplette svar føjes til historikken

Fejlhåndtering

Da SDK’en taler gRPC, er dens fejl grpc.RpcError (asynkront grpc.aio.AioRpcError, som arver fra dem). Du læser deres kode med .code() og beskeden med .details():

import grpc
from xai_sdk import Client
from xai_sdk.chat import user

client = Client()
chat = client.chat.create(model="grok-4.7")
chat.append(user("Hello"))

try:
    response = chat.sample()
    print(response.content)
except grpc.RpcError as error:
    if error.code() == grpc.StatusCode.DEADLINE_EXCEEDED:
        print("Timeout exceeded: the request took too long.")
    else:
        print(f"Error {error.code().name}: {error.details()}")

Der er tre adfærdsmønstre, det er værd at kende. SDK’en genforsøger automatisk anmodninger, der fejler med UNAVAILABLE, op til fem forsøg med stigende forsinkelse; dens README viser, hvordan du tilføjer andre koder til denne liste, f.eks. RESOURCE_EXHAUSTED, som er gRPC-koden for udtømte kvoter. Ventetidsgrænsen (timeout) er som standard 27 minutter for enhver anmodning og indstilles ved oprettelse af klienten (Client(timeout=…), i sekunder). Reducér den ikke for meget: xAI råder til at planlægge med mindst 900 sekunder pr. anmodning med deres ræsonnementsmodeller. Endelig manifesterer en ugyldig API-nøgle sig som kode INVALID_ARGUMENT og beskeden “Incorrect API key provided”: dette er, hvad API’en returnerer i dag, verificeret 3. november 2026.

Asynkrone kald

Til en asyncio-applikation erstatter du Client med AsyncClient. Oprettelse af samtalen forbliver synkron; det er sample() og stream(), der venter (await):

import asyncio

from xai_sdk import AsyncClient
from xai_sdk.chat import user


async def main():
    client = AsyncClient()
    chat = client.chat.create(model="grok-4.7")
    chat.append(user("Hello"))

    response = await chat.sample()
    print(response.content)

    chat.append(response)
    chat.append(user("Summarize your response in one sentence."))
    async for response, chunk in chat.stream():
        print(chunk.content, end="", flush=True)


asyncio.run(main())

Vigtige pointer

  • xai-sdk er en gRPC-SDK med sin egen grænseflade: den genbruger ikke formen eller objekterne fra OpenAI SDK
  • client.chat.create() opretter en samtale; chat.append(user(...)) tilføjer en besked, chat.sample() returnerer svaret, som læses i response.content
  • Beskeder bygges med system, user og assistant fra xai_sdk.chat; ordbøger får kaldet til at fejle
  • Streaming bruger chat.stream(), som returnerer parrene (response, chunk)
  • Fejl er grpc.RpcError; UNAVAILABLE genforsøges automatisk, og standard-timeout er 27 minutter