Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Mezipaměť x-grok-conv-id a časový limit pro uvažování

Lekce 11 z 12 Aktualizováno 30. července 2026 Pokročilý
Na této stránce
  1. Optimalizace nákladů pomocí mezipaměti
  2. Hlavička x-grok-conv-id
  3. Časový limit 3600 sekund pro uvažování
  4. Poznámka k modelu grok-4.5 a uvažování
  5. Kontrola dopadu mezipaměti
  6. Klíčové poznatky

Optimalizace nákladů pomocí mezipaměti

Každý požadavek odeslaný na API xAI je účtován za standardní cenu tokenu. Když však odešleš více souvisejících požadavků (stejná konverzace, stejné téma), část kontextu se opakuje. Hlavička x-grok-conv-id umožňuje xAI identifikovat tyto související požadavky a zvýšit úspěšnost zásahu do mezipaměti (cache hit rate), čímž snížíš své náklady.

Hlavička x-grok-conv-id

Chcete-li povolit mezipaměťování konverzace, přidej vlastní hlavičku s jedinečným UUID v4 pro každou konverzaci:

import uuid

conversation_id = str(uuid.uuid4())

# With the 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
    }
)

Všechny požadavky sdílející stejnou hodnotu x-grok-conv-id těží ze zvýšené úspěšnosti zásahu do mezipaměti. Tokeny uložené v mezipaměti jsou účtovány sníženou sazbou ve srovnání se standardními tokeny.

Pravidla použití

  • Vygeneruj nové UUID pro každou konverzaci nebo logickou relaci.
  • Opakovaně použij stejné UUID pro všechny požadavky v rámci téže konverzace.
  • Nepoužívej stejné UUID napříč různými konverzacemi (toto zhoršuje mezipaměťování).
# Pattern for a chatbot
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

Časový limit 3600 sekund pro uvažování

Modely pro uvažování (grok-4.20-0309-reasoning a podobné) provádějí před odpovědí interní úvahy. U složitých problémů může toto uvažování trvat několik minut. Výchozí časový limit pro většinu HTTP klientů (30–120 sekund) je nedostatečný.

# Correct configuration for reasoning
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,     # fast connection
        read=3600.0,      # 1 hour for read
        write=30.0,       # prompt submission
        pool=10.0         # connection wait
    )
)

Hodnota read=3600.0 je klíčová. Představuje maximální prodlevu mezi okamžikem, kdy server začne zpracovávat tvůj požadavek, a okamžikem, kdy obdržíš odpověď. U modelu pro uvažování, který přemýšlí 5 minut, potřebuješ tuto rezervu.

Kdy snížit časový limit

Časový limit 3600 sekund není vždy nutný:

  • grok-4.5 (bez uvažování): časový limit 120–300 sekund je obvykle dostatečný.
  • Jednoduché požadavky: i u modelu pro uvažování jsou odpovědi na krátké otázky k dispozici do minuty.
  • Testovací prostředí: časový limit 60 sekund umožňuje rychle odhalit problémy.
# Client for fast requests
fast_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(120.0)
)

# Client for complex reasoning
reasoning_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0)
)

Použití dvou klientů s různými časovými limity je v produkčním prostředí běžným vzorem.

Poznámka k modelu grok-4.5 a uvažování

Model grok-4.5 nevrací pole reasoning_content v odpovědi jako prostý text. Interní uvažování probíhá, ale zůstává neprůhledné. Pokud potřebuješ vidět proces uvažování, použij use_encrypted_content=True pro jeho zachování mezi požadavky (bez možnosti čtení), nebo využij model grok-4.20-0309-reasoning, který více odhaluje svůj proces.

Kontrola dopadu mezipaměti

Pro změření efektivity mezipaměti porovnej pole usage mezi požadavky s hlavičkou x-grok-conv-id a bez ní:

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

Vysoká úspěšnost zásahu do mezipaměti znamená, že se tokeny tvého kontextu znovu využívají místo opětovného zpracování, což přímo snižuje tvou fakturu.

Klíčové poznatky

  • x-grok-conv-id s UUID v4 umožňuje mezipaměťování konverzace pro související požadavky.
  • Tokeny v mezipaměti jsou účtovány sníženou sazbou.
  • Pro modely pro uvažování je nezbytný časový limit 3600 sekund.
  • Pro rychlé požadavky a požadavky na uvažování používej oddělené klienty.
  • Model grok-4.5 nevrací reasoning_content jako prostý text.
  • Sleduj úspěšnost zásahu do mezipaměti v usage.prompt_tokens_details pro ověření optimalizace.