Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Cacha x-grok-conv-id och tidsgräns för resonemang

Lektion 11 av 12 Uppdaterad 30 juli 2026 Avancerad
På denna sida
  1. Optimera kostnader med cachelagring
  2. Headern x-grok-conv-id
  3. Tidsgräns på 3600 sekunder för resonemang
  4. Notering om grok-4.5 och resonemang
  5. Kontrollera cache-effekten
  6. Viktiga punkter

Optimera kostnader med cachelagring

Varje begäran som skickas till xAI:s API debiteras till standardpriset per token. Men när du skickar flera relaterade begäranden (samma konversation, samma ämne) upprepas delar av kontexten. Headern x-grok-conv-id låter xAI identifiera dessa relaterade begäranden och öka träffsäkerheten i cachen, vilket sänker dina kostnader.

Headern x-grok-conv-id

För att aktivera cachelagring för konversationer lägger du till en anpassad header med ett unikt v4-UUID per konversation:

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
    }
)

Alla begäranden som delar samma x-grok-conv-id gynnas av en förbättrad träffsäkerhet i cachen. Cachade token debiteras till en lägre taxa jämfört med vanliga token.

Användningsregler

  • Generera ett nytt UUID för varje konversation eller logisk session
  • Återanvänd samma UUID för alla begäranden inom samma konversation
  • Återanvänd inte ett UUID över olika konversationer (detta försämrar cachelagringen)
# Mönster för en chattbot
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

Tidsgräns på 3600 sekunder för resonemang

Resonemangsmodeller (grok-4.20-0309-reasoning och liknande) utför internt resonemang innan de svarar. Detta resonemang kan ta flera minuter för komplexa problem. Standardtidsgränsen för de flesta HTTP-klienter (30–120 sekunder) är otillräcklig.

# Korrekt konfiguration för resonemang
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,     # snabb anslutning
        read=3600.0,      # 1 timme för läsning
        write=30.0,       # inlämning av prompt
        pool=10.0         # väntan på anslutning
    )
)

read=3600.0 är det kritiska värdet. Detta är den maximala fördröjningen mellan när servern börjar bearbeta din begäran och när du tar emot svaret. För en resonemangsmodell som resonerar i 5 minuter behöver du denna marginal.

När du bör minska tidsgränsen

Tidsgränsen på 3600 sekunder är inte alltid nödvändig:

  • grok-4.5 (icke-resonemang): en tidsgräns på 120–300 sekunder räcker oftast
  • Enkla begäranden: även med en resonemangsmodell besvaras korta frågor på under en minut
  • Testmiljö: en tidsgräns på 60 sekunder låter dig upptäcka problem snabbt
# Klient för snabba begäranden
fast_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(120.0)
)

# Klient för komplext resonemang
reasoning_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0)
)

Att använda två klienter med olika tidsgränser är ett vanligt mönster i produktion.

Notering om grok-4.5 och resonemang

Modellen grok-4.5 returnerar inte fältet reasoning_content i klartext i svaret. Internt resonemang utförs men förblir ogenomskinligt. Om du behöver se resonemangsprocessen använder du use_encrypted_content=True för att bevara den mellan begäranden utan att kunna läsa den, eller så använder du grok-4.20-0309-reasoning, som exponerar mer av sin process.

Kontrollera cache-effekten

För att mäta cache-effektiviteten jämför du fältet usage mellan begäranden med och utan 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ög träffsäkerhet i cachen betyder att dina kontext-token återanvänds istället för att bearbetas på nytt, vilket direkt minskar din faktura.

Viktiga punkter

  • x-grok-conv-id med ett v4-UUID aktiverar cachelagring för konversationer för relaterade begäranden
  • Cachade token debiteras till en reducerad taxa
  • En tidsgräns på 3600 sekunder är nödvändig för resonemangsmodeller
  • Använd separata klienter för snabba begäranden och resonemangsbegäranden
  • grok-4.5 returnerar inte reasoning_content i klartext
  • Övervaka träffsäkerheten i cachen i usage.prompt_tokens_details för att validera optimeringen