Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Cache x-grok-conv-id en time-out voor redeneren

Les 11 van 12 Bijgewerkt op 30 juli 2026 Gevorderd
Op deze pagina
  1. Kosten optimaliseren met caching
  2. De x-grok-conv-id Header
  3. Time-out van 3600 seconden voor redeneren
  4. Opmerking over grok-4.5 en redeneren
  5. Cache-impact controleren
  6. Belangrijkste punten

Kosten optimaliseren met caching

Elk verzoek dat naar de xAI API wordt verzonden, wordt gefactureerd tegen de standaard tokenprijs. Maar wanneer u meerdere gerelateerde verzoeken verzendt (dezelfde conversatie, hetzelfde onderwerp), herhaalt een deel van de context zich. De x-grok-conv-id header stelt xAI in staat om deze gerelateerde verzoeken te identificeren en het cache-hitpercentage te verhogen, waardoor uw kosten dalen.

De x-grok-conv-id Header

Om conversatie-caching in te schakelen, voegt u een aangepaste header toe met een unieke v4 UUID per conversatie:

import uuid

conversation_id = str(uuid.uuid4())

# Met de 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 verzoeken die dezelfde x-grok-conv-id delen, profiteren van een verbeterd cache-hitpercentage. Gecachete tokens worden tegen een verlaagd tarief gefactureerd in vergelijking met standaard tokens.

Gebruiksregels

  • Genereer een nieuwe UUID voor elke conversatie of logische sessie
  • Hergebruik dezelfde UUID voor alle verzoeken binnen dezelfde conversatie
  • Hergebruik een UUID niet voor verschillende conversaties (dit verslechtert de caching)
# Patroon voor een 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

Time-out van 3600 seconden voor redeneren

Redeneermodellen (grok-4.20-0309-reasoning en vergelijkbaar) voeren interne redeneringen uit voordat ze reageren. Deze redenering kan enkele minuten duren voor complexe problemen. De standaard time-out voor de meeste HTTP-clients (30-120 seconden) is onvoldoende.

# Correcte configuratie voor redeneren
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,     # snelle verbinding
        read=3600.0,      # 1 uur voor lezen
        write=30.0,       # prompt-indiening
        pool=10.0         # wachttijd verbinding
    )
)

read=3600.0 is de kritieke waarde. Dit is de maximale vertraging tussen het moment dat de server uw verzoek begint te verwerken en het moment dat u het antwoord ontvangt. Voor een redeneermodel dat 5 minuten redeneert, heeft u deze marge nodig.

Wanneer de time-out verlagen

De time-out van 3600 seconden is niet altijd nodig:

  • grok-4.5 (niet-redenerend): een time-out van 120-300 seconden is meestal voldoende
  • Eenvoudige verzoeken: zelfs met een redeneermodel worden korte vragen binnen een minuut beantwoord
  • Testomgeving: een time-out van 60 seconden stelt u in staat problemen snel op te sporen
# Client voor snelle verzoeken
fast_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(120.0)
)

# Client voor complexe redenering
reasoning_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0)
)

Het gebruik van twee clients met verschillende time-outs is een veelvoorkomend patroon in productieomgevingen.

Opmerking over grok-4.5 en redeneren

Het model grok-4.5 retourneert het veld reasoning_content niet als platte tekst in het antwoord. Interne redenering vindt plaats, maar blijft ondoorzichtig. Als u het redeneerproces wilt zien, gebruikt u use_encrypted_content=True om dit tussen verzoeken te behouden zonder het te kunnen lezen, of kiest u voor grok-4.20-0309-reasoning, dat meer van zijn proces blootlegt.

Cache-impact controleren

Om de cache-efficiëntie te meten, vergelijkt u het veld usage tussen verzoeken met en zonder 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}%)")

Een hoog cache-hitpercentage betekent dat uw contexttokens worden hergebruikt in plaats van opnieuw verwerkt, wat uw factuur direct verlaagt.

Belangrijkste punten

  • x-grok-conv-id met een v4 UUID schakelt conversatie-caching in voor gerelateerde verzoeken
  • Gecachete tokens worden tegen een verlaagd tarief gefactureerd
  • Een time-out van 3600 seconden is noodzakelijk voor redeneermodellen
  • Gebruik aparte clients voor snelle verzoeken en redeneerverzoeken
  • grok-4.5 retourneert reasoning_content niet als platte tekst
  • Controleer het cache-hitpercentage in usage.prompt_tokens_details om de optimalisatie te valideren