Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Kešavimas pagal x-grok-conv-id ir laiko limitas samprotavimams

Paskaita 11 iš 12 Atnaujinta 2026 m. liepos 30 d. Pažengusiems
Šiame puslapyje
  1. Optimizuok išlaidas naudodamas kešavimą
  2. Antraštė x-grok-conv-id
  3. 3600 sekundžių laiko limitas samprotavimams
  4. Pastaba apie grok-4.5 ir samprotavimus
  5. Patikrink kešo poveikį
  6. Svarbiausi punktai

Optimizuok išlaidas naudodamas kešavimą

Už kiekvieną užklausą, siunčiamą į xAI API, mokama pagal standartinę žetono kainą. Tačiau kai siunti kelias susijusias užklausas (tas pats pokalbis, ta pati tema), dalis konteksto kartojasi. Antraštė x-grok-conv-id leidžia xAI atpažinti šias susijusias užklausas ir padidinti kešo pataikymų tikimybę, taip sumažinant tavo išlaidas.

Antraštė x-grok-conv-id

Norėdamas įjungti pokalbių kešavimą, pridėk tinkintą antraštę su unikaliu v4 UUID kiekvienam pokalbiui:

import uuid

conversation_id = str(uuid.uuid4())

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

Visos užklausos, turinčios tą pačią x-grok-conv-id, naudojasi pagerintu kešo pataikymų rodikliu. Už kešuojamus žetonus mokama mažesne kaina nei už standartinius žetonus.

Naudojimo taisyklės

  • Sugeneruok naują UUID kiekvienam pokalbiui arba loginiam seansui.
  • Pakartotinai naudok tą patį UUID visoms to paties pokalbio užklausoms.
  • Nenaudok to paties UUID skirtinguose pokalbiuose (tai pablogina kešavimą).
# Pokalbių botų šablonas
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 sekundžių laiko limitas samprotavimams

Samprotavimo modeliai (grok-4.20-0309-reasoning ir panašūs) prieš atsakydami atlieka vidinius samprotavimus. Sudėtingoms problemoms išspręsti tai gali užtrukti kelias minutes. Numatytasis daugumos HTTP klientų laiko limitas (30–120 sekundžių) yra nepakankamas.

# Teisinga samprotavimų konfigūracija
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,     # greitas prisijungimas
        read=3600.0,      # 1 valanda skaitymui
        write=30.0,       # užuominos pateikimas
        pool=10.0         # laukimas eilėje
    )
)

read=3600.0 yra kritinė vertė. Tai maksimalus delsos laikas tarp momento, kai serveris pradeda apdoroti tavo užklausą, ir momento, kai gauni atsakymą. Samprotavimo modeliui, kuris samprotauja 5 minutes, tau reikia šios atsargos.

Kada mažinti laiko limitą

3600 sekundžių laiko limitas ne visada yra būtinas:

  • grok-4.5 (be samprotavimų): paprastai pakanka 120–300 sekundžių laiko limito.
  • Paprastos užklausos: net ir naudojant samprotavimo modelį, į trumpus klausimus atsakoma per mažiau nei minutę.
  • Testavimo aplinka: 60 sekundžių laiko limitas leidžia greitai nustatyti problemas.
# Klientas greitoms užklausoms
fast_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(120.0)
)

# Klientas sudėtingiems samprotavimams
reasoning_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0)
)

Naudojimas dviejų klientų su skirtingais laiko limitais yra dažnas šablonas gamybinėje aplinkoje.

Pastaba apie grok-4.5 ir samprotavimus

Modelis grok-4.5 atsakyme negrąžina lauko reasoning_content grynuoju tekstu. Vidiniai samprotavimai atliekami, tačiau lieka nematomi. Jei tau reikia matyti samprotavimo procesą, naudok use_encrypted_content=True, kad išsaugotum jį tarp užklausų negalėdamas jo perskaityti, arba pasirink grok-4.20-0309-reasoning, kuris atskleidžia daugiau savo proceso detalių.

Patikrink kešo poveikį

Norėdamas įvertinti kešo efektyvumą, palygink lauką usage užklausose su x-grok-conv-id ir be jos:

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

Didelis kešo pataikymų rodiklis reiškia, kad tavo konteksto žetonai yra pakartotinai naudojami, o ne iš naujo apdorojami, o tai tiesiogiai sumažina tavo sąskaitą.

Svarbiausi punktai

  • x-grok-conv-id su v4 UUID įjungia pokalbių kešavimą susijusioms užklausoms.
  • Už kešuojamus žetonus mokama mažesne kaina.
  • Samprotavimo modeliams būtinas 3600 sekundžių laiko limitas.
  • Naudok atskirus klientus greitoms užklausoms ir samprotavimo užklausoms.
  • grok-4.5 negrąžina reasoning_content grynuoju tekstu.
  • Stebėk kešo pataikymų rodiklį lauke usage.prompt_tokens_details, kad patvirtintum optimizavimą.