Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Vahemälu x-grok-conv-id ja põhjendamise ajalõpp

Õppetund 11 / 12 Värskendatud 30. juuli 2026 Edasijõudnutele
Sellel lehel
  1. Optimeeri kulusid vahemälu abil
  2. Päis x-grok-conv-id
  3. 3600-sekundiline ajalõpp põhjendamisel
  4. Märkus grok-4.5 ja põhjendamise kohta
  5. Kontrolli vahemälu mõju
  6. Peamised punktid

Optimeeri kulusid vahemälu abil

Iga xAI API-le saadetud päringu eest tasutakse standardse tokeni hinna alusel. Kui saadad aga mitu seotud päringut (sama vestlus, sama teema), kordub osa kontekstist. Päise x-grok-conv-id abil tuvastab xAI need seotud päringud ja suurendab vahemälu tabamuste määra, vähendades sinu kulusid.

Päis x-grok-conv-id

Vestluse vahemälu lubamiseks lisa kohandatud päis, mis sisaldab iga vestluse kohta unikaalset v4 UUID-d:

import uuid

conversation_id = str(uuid.uuid4())

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

Kõik päringud, mis jagavad sama x-grok-conv-id-d, saavad kasu paremast vahemälu tabamuste määrast. Vahemällu salvestatud tokenite eest tasutakse madalama hinnaga võrreldes standardsete tokenitega.

Kasutuseeskirjad

  • Genereeri iga vestluse või loogilise seansi jaoks uus UUID.
  • Kasuta sama UUID-d kõigi sama vestluse sees olevate päringute puhul.
  • Ära kasuta sama UUID-d erinevates vestlustes (see halvendab vahemälu toimimist).
# Vestlusroboti muster
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-sekundiline ajalõpp põhjendamisel

Põhjendamismudelid (grok-4.20-0309-reasoning ja sarnased) teostavad enne vastamist sisemist põhjendamist. See protsess võib keerukate ülesannete puhul võtta mitu minutit. Enamiku HTTP-klientide vaikimisi ajalõpp (30–120 sekundit) ei ole selleks piisav.

# Õige konfiguratsioon põhjendamiseks
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,     # kiire ühendus
        read=3600.0,      # lugemiseks 1 tund
        write=30.0,       # sisendi saatmine
        pool=10.0         # ühenduse ooteaeg
    )
)

read=3600.0 on kriitiline väärtus. See on maksimaalne viide ajast, kui server alustab sinu päringu töötlemist, kuni saad vastuse. Põhjendamismudeli puhul, mis mõtleb 5 minutit, on see varu vajalik.

Millal ajalõppu vähendada

3600-sekundiline ajalõpp pole alati vajalik:

  • grok-4.5 (mitte-põhjendav): tavaliselt piisab 120–300 sekundilisest ajalõpust.
  • Lihtsad päringud: isegi põhjendamismudeli puhul vastatakse lühikestele küsimustele alla minuti.
  • Testkeskkond: 60-sekundiline ajalõpp võimaldab vigu kiiresti tuvastada.
# Klient kiirete päringute jaoks
fast_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(120.0)
)

# Klient keeruka põhjendamise jaoks
reasoning_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0)
)

Kahe erineva ajalõpuga kliendi kasutamine on tootmises levinud muster.

Märkus grok-4.5 ja põhjendamise kohta

Mudel grok-4.5 ei tagasta väljal reasoning_content sisemist põhjendamist lihttekstina. Sisemine põhjendamine toimub, kuid jääb läbipaistmatuks. Kui soovid põhjendusprotsessi säilitada, kasuta use_encrypted_content=True, et hoida see päringute vahel alles ilma seda lugemata, või vali mudel grok-4.20-0309-reasoning, mis avaldab oma protsessist rohkem.

Kontrolli vahemälu mõju

Vahemälu tõhususe mõõtmiseks võrdle välja usage sisu päringutes, kus on kasutatud ja mitte kasutatud x-grok-conv-id-d:

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

Kõge vahemälu tabamuste määr tähendab, et sinu konteksti tokeneid kasutatakse uuesti selle asemel, et neid uuesti töödelda, mis vähendab otseselt sinu arvet.

Peamised punktid

  • x-grok-conv-id koos v4 UUID-ga võimaldab seotud päringute jaoks vestluse vahemälu.
  • Vahemällu salvestatud tokenite eest tasutakse madalama hinnaga.
  • Põhjendamismudelite jaoks on vajalik 3600-sekundiline ajalõpp.
  • Kasuta eraldi kliente kiirete päringute ja põhjendamispäringute jaoks.
  • grok-4.5 ei tagasta reasoning_content lihttekstina.
  • Jälgi vahemälu tabamuste määra väljal usage.prompt_tokens_details, et optimeerimist valideerida.