Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Kešatmiņa x-grok-conv-id un spriešanas laika limits

Nodarbība 11 no 12 Atjaunota 2026. gada 30. jūlijs Augstākais
Šajā lapā
  1. Optimizē izmaksas, izmantojot kešatmiņu
  2. Galvene x-grok-conv-id
  3. 3600 sekunžu laika limits spriešanai
  4. Piezīme par grok-4.5 un spriešanu
  5. Pārbaudi kešatmiņas ietekmi
  6. Galvenās atziņas

Optimizē izmaksas, izmantojot kešatmiņu

Par katru xAI API nosūtīto pieprasījumu tiek iekasēta maksa par standarta tokeniem. Taču, sūtot vairākus saistītus pieprasījumus (viena saruna, viena tēma), daļa konteksta atkārtojas. Galvene x-grok-conv-id ļauj xAI identificēt šos saistītos pieprasījumus un palielināt kešatmiņas trāpījumu biežumu, tādējādi samazinot tavas izmaksas.

Galvene x-grok-conv-id

Lai aktivizētu sarunu kešatmiņu, pievieno pielāgotu galveni ar unikālu v4 UUID katrai sarunai:

import uuid

conversation_id = str(uuid.uuid4())

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

Visi pieprasījumi, kuriem ir kopīga x-grok-conv-id vērtība, gūst labumu no uzlabota kešatmiņas trāpījumu rādītāja. Kešatmiņā esošie tokeni tiek tarifēti zemāk nekā standarta tokeni.

Lietošanas noteikumi

  • Ģenerē jaunu UUID katrai sarunai vai loģiskajai sesijai.
  • Atkārtoti izmanto to pašu UUID visiem pieprasījumiem vienā sarunā.
  • Neatkārto UUID dažādās sarunās (tas pasliktina kešatmiņas efektivitāti).
# Čatbota paraugs
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 sekunžu laika limits spriešanai

Spriešanas modeļi (grok-4.20-0309-reasoning un līdzīgi) veic iekšēju spriešanu pirms atbildes sniegšanas. Sarežģītām problēmām šī spriešana var ilgt vairākas minūtes. Noklusējuma laika limits lielākajai daļai HTTP klientu (30–120 sekundes) ir nepietiekams.

# Pareiza konfigurācija spriešanai
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,     # ātrs savienojums
        read=3600.0,      # 1 stunda lasīšanai
        write=30.0,       # uzdevuma nosūtīšana
        pool=10.0         # gaidīšana savienojumam
    )
)

read=3600.0 ir kritiskā vērtība. Tas ir maksimālais aiztures laiks starp brīdi, kad serveris sāk apstrādāt tavu pieprasījumu, un brīdi, kad saņem atbildi. Spriešanas modelim, kas domā 5 minūtes, šī rezerve ir nepieciešama.

Kad samazināt laika limitu

3600 sekunžu laika limits ne vienmēr ir nepieciešams:

  • grok-4.5 (bez spriešanas): parasti pietiek ar 120–300 sekunžu limitu.
  • Vienkārši pieprasījumi: pat izmantojot spriešanas modeli, īsi jautājumi tiek apstrādāti mazāk nekā minūtē.
  • Testa vide: 60 sekunžu limits ļauj ātri noteikt problēmas.
# Klients ātriem pieprasījumiem
fast_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(120.0)
)

# Klients sarežģītai spriešanai
reasoning_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0)
)

Divu klientu izmantošana ar dažādiem laika limitiem ir izplatīts risinājums ražošanas vidē.

Piezīme par grok-4.5 un spriešanu

Modelis grok-4.5 neatgriež lauku reasoning_content atbildē skaidrā tekstā. Iekšējā spriešana tiek veikta, taču tā paliek neredzama. Ja tev ir nepieciešams redzēt spriešanas procesu, izmanto use_encrypted_content=True, lai saglabātu to starp pieprasījumiem, nespējot to nolasīt, vai izvēlies grok-4.20-0309-reasoning, kas atklāj vairāk no sava procesa.

Pārbaudi kešatmiņas ietekmi

Lai novērtētu kešatmiņas efektivitāti, salīdzini lauku usage pieprasījumos ar x-grok-conv-id un bez tā:

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

Augsts kešatmiņas trāpījumu rādītājs nozīmē, ka tavu konteksta tokeni tiek atkārtoti izmantoti, nevis atkārtoti apstrādāti, kas tieši samazina tavu rēķinu.

Galvenās atziņas

  • x-grok-conv-id ar v4 UUID aktivizē sarunu kešatmiņu saistītiem pieprasījumiem.
  • Kešatmiņā esošie tokeni tiek tarifēti zemāk.
  • Spriešanas modeļiem ir nepieciešams 3600 sekunžu laika limits.
  • Izmanto atsevišķus klientus ātriem pieprasījumiem un spriešanas pieprasījumiem.
  • grok-4.5 neatgriež reasoning_content skaidrā tekstā.
  • Uzraugi kešatmiņas trāpījumu rādītāju laukā usage.prompt_tokens_details, lai validētu optimizāciju.