Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Cache x-grok-conv-id og timeout for ræsonnement

Lektion 11 af 12 Opdateret 30. juli 2026 Avanceret
På denne side
  1. Optimer omkostninger med caching
  2. Headen x-grok-conv-id
  3. 3600-sekunders timeout for ræsonnement
  4. Bemærkning om grok-4.5 og ræsonnement
  5. Tjek cache-påvirkningen
  6. Vigtige pointer

Optimer omkostninger med caching

Hver anmodning, du sender til xAI API’et, faktureres til standard-tokenprisen. Men når du sender flere relaterede anmodninger (samme samtale, samme emne), gentages en del af konteksten. Headen x-grok-conv-id gør det muligt for xAI at identificere disse relaterede anmodninger og øge cache-hit-raten, hvilket reducerer dine omkostninger.

Headen x-grok-conv-id

For at aktivere samtale-caching skal du tilføje en brugerdefineret header med et unikt v4 UUID pr. samtale:

import uuid

conversation_id = str(uuid.uuid4())

# Med OpenAI SDK
response = await client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": prompt}],
    extra_headers={
        "x-grok-conv-id": conversation_id
    }
)

Alle anmodninger, der deler den samme x-grok-conv-id, drager fordel af en forbedret cache-hit-rate. Cachetokens faktureres til en reduceret sats sammenlignet med standardtokens.

Brugsregler

  • Generer et nyt UUID til hver samtale eller logiske session
  • Genbrug det samme UUID til alle anmodninger inden for den samme samtale
  • Genbrug ikke et UUID på tværs af forskellige samtaler (dette forringer cachingen)
# Mønster for en chatbot
class ConversationManager:
    def __init__(self):
        self.conv_id = str(uuid.uuid4())
        self.messages = []

    async def send(self, user_message: str) -> str:
        self.messages.append({"role": "user", "content": user_message})

        response = await client.chat.completions.create(
            model="grok-4.5",
            messages=self.messages,
            extra_headers={"x-grok-conv-id": self.conv_id}
        )

        assistant_message = response.choices[0].message.content
        self.messages.append({"role": "assistant", "content": assistant_message})
        return assistant_message

3600-sekunders timeout for ræsonnement

Ræsonnementsmodeller (grok-4.20-0309-reasoning og lignende) udfører intern ræsonnement, før de svarer. Dette ræsonnement kan tage flere minutter ved komplekse problemer. Standard-timeout’en for de fleste HTTP-klienter (30-120 sekunder) er utilstrækkelig.

# Korrekt konfiguration for ræsonnement
from openai import AsyncOpenAI
import httpx

client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(
        connect=10.0,     # hurtig forbindelse
        read=3600.0,      # 1 time til læsning
        write=30.0,       # indsendelse af prompt
        pool=10.0         // ventetid på forbindelse
    )
)

read=3600.0 er den kritiske værdi. Dette er den maksimale forsinkelse mellem det tidspunkt, hvor serveren begynder at behandle din anmodning, og det tidspunkt, hvor du modtager svaret. For en ræsonnementsmodel, der ræsonnerer i 5 minutter, har du brug for denne margin.

Hvornår skal du reducere timeout’en?

Timeout’en på 3600 sekunder er ikke altid nødvendig:

  • grok-4.5 (ikke-ræsonnerende): En timeout på 120-300 sekunder er normalt tilstrækkelig
  • Enkle anmodninger: Selv med en ræsonnementsmodel svarer korte spørgsmål på under et minut
  • Testmiljø: En timeout på 60 sekunder giver dig mulighed for hurtigt at opdage problemer
# Klient til hurtige anmodninger
fast_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(120.0)
)

# Klient til komplekst ræsonnement
reasoning_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0)
)

Det er et almindeligt mønster i produktion at bruge to klienter med forskellige timeouts.

Bemærkning om grok-4.5 og ræsonnement

Modellen grok-4.5 returnerer ikke feltet reasoning_content i klartekst i svaret. Internt ræsonnement udføres, men forbliver uigennemsigtigt. Hvis du har brug for at se ræsonnementsprocessen, skal du bruge use_encrypted_content=True for at bevare den mellem anmodninger uden at kunne læse den, eller bruge grok-4.20-0309-reasoning, som eksponerer mere af sin proces.

Tjek cache-påvirkningen

For at måle cache-effektiviteten skal du sammenligne feltet usage mellem anmodninger med og uden x-grok-conv-id:

response = await client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    extra_headers={"x-grok-conv-id": conv_id}
)

usage = response.usage
if hasattr(usage, 'prompt_tokens_details'):
    cached = usage.prompt_tokens_details.cached_tokens
    total = usage.prompt_tokens
    print(f"Cache hit: {cached}/{total} tokens ({cached/total*100:.0f}%)")

En høj cache-hit-rate betyder, at dine konteksttokens genbruges i stedet for at blive genbehandlet, hvilket direkte reducerer din regning.

Vigtige pointer

  • x-grok-conv-id med et v4 UUID aktiverer samtale-caching for relaterede anmodninger
  • Cachetokens faktureres til en reduceret sats
  • En timeout på 3600 sekunder er nødvendig for ræsonnementsmodeller
  • Brug separate klienter til hurtige anmodninger og ræsonnementsanmodninger
  • grok-4.5 returnerer ikke reasoning_content i klartekst
  • Overvåg cache-hit-raten i usage.prompt_tokens_details for at validere optimeringen