xAI SDK AsyncClient
På denne side
Hvorfor skifte til asynkron
Når du spørger xAI-API’en synkront, blokerer hvert kald din programs udførelse, indtil svaret ankommer. For en ræsonneringsmodel som grok-4.5 kan en enkelt anmodning tage flere titusinder af sekunder. Hvis du skal behandle 100 anmodninger, bliver den samlede ventetid uoverkommelig.
Asynkron tilstand løser dette problem. I stedet for at vente på hvert svar, starter dit program anmodningen og fortsætter udførelsen. Du henter resultatet senere, når det er tilgængeligt. Denne tilgang lader dig behandle flere anmodninger parallelt og udnytte din båndbredde til API’en fuldt ud.
Initialisering af AsyncClient
xAI SDK’et leverer en AsyncClient-klasse dedikeret til asynkrone kald. Initialiseringen ligner den synkrone klient, men med en timeout-parameter, som du altid skal konfigurere:
import os
from xai_sdk import AsyncClient
from xai_sdk.chat import user
client = AsyncClient(
api_key=os.getenv("XAI_API_KEY"),
timeout=3600,
)
timeout=3600 svarer til én time. Denne værdi kan virke høj, men den er nødvendig for ræsonneringsmodeller, der udfører omfattende ræsonnementer, før de svarer. En for kort timeout forårsager forbindelsesfejl ved komplekse anmodninger.
Send en asynkron anmodning
Når du har initialiseret klienten, sender du anmodninger ved hjælp af Pythons await-syntaks:
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
# Indgangspunkt
result = asyncio.run(ask_grok("Forklar den algoritmiske kompleksitet af quicksort"))
print(result)
Funktionen ask_grok bruger async def, hvilket gør den til en koroutine. Kaldet await chat.sample() suspenderer denne koroutine, indtil svaret ankommer, uden at blokere andre potentielle opgaver.
Forskel fra den synkrone klient
Den synkrone klient blokerer den aktuelle tråd i hele anmodningens varighed. Den asynkrone klient frigiver tråden til at udføre andre koroutiner. Denne sondring betyder ikke noget, hvis du kun sender én anmodning, men den bliver kritisk, når du behandler flere anmodninger parallelt.
# Synkront: hvert kald venter på svaret
for question in questions:
response = client.chat.completions.create(...) # blokerende
process(response)
# Asynkront: kald kører parallelt
async def main():
tasks = [ask_grok(q) for q in questions]
responses = await asyncio.gather(*tasks) # parallelt
for r in responses:
process(r)
I det synkrone eksempel tager det 200 sekunder i alt, hvis hver anmodning tager 10 sekunder, og du har 20 anmodninger. I asynkron tilstand med en semaphore på 5 (som du vil stifte bekendtskab med i senere lektioner), falder tiden til ca. 40 sekunder.
Vigtige pointer
- xAI SDK’ets
AsyncClientlader dig sende anmodninger uden at blokere udførelsen - Parameteren
timeout=3600er essentiel for ræsonneringsmodeller xai-sdkkræver Python 3.10 eller nyere (version 1.21.0 pr. 2. november 2026 ifølge PyPI)- Den reelle fordel viser sig, når du behandler flere anmodninger parallelt
asyncio.run()fungerer som indgangspunkt for at eksekvere en koroutine fra synkron kode