Spring til hovedindhold
Dansk— Vælg et sprog
Menu

xAI SDK AsyncClient

Lektion 1 af 12 Opdateret 2. november 2026 Avanceret
På denne side
  1. Hvorfor skifte til asynkron
  2. Initialisering af AsyncClient
  3. Send en asynkron anmodning
  4. Forskel fra den synkrone klient
  5. Vigtige pointer

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.

3600s
Anbefalet timeout
5x
Parallel gennemstrømning
-50%
Alternativ til Batch API
RPM
Rate limit der skal overholdes

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 AsyncClient lader dig sende anmodninger uden at blokere udførelsen
  • Parameteren timeout=3600 er essentiel for ræsonneringsmodeller
  • xai-sdk kræ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