Cacha x-grok-conv-id och tidsgräns för resonemang
På denna sida
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-idmed 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.5returnerar intereasoning_contenti klartext- Övervaka träffsäkerheten i cachen i
usage.prompt_tokens_detailsför att validera optimeringen