Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

A x-grok-conv-id gyorsítótárazása és a következtetési időtúllépés

11. lecke 12 közül Frissítve 2026. július 30. Haladó
Ezen az oldalon
  1. Költségek csökkentése gyorsítótárazással
  2. Az x-grok-conv-id fejléc
  3. 3600 másodperces időtúllépés a következtetéshez
  4. Megjegyzés a grok-4.5-höz és a következtetéshez
  5. A gyorsítótár hatásának ellenőrzése
  6. Főbb megállapítások

Költségek csökkentése gyorsítótárazással

Minden, az xAI API-nak küldött kérés után a szabványos tokenár alapján számláznak. Ha azonban több összefüggő kérést küldesz (ugyanazon beszélgetésen vagy témán belül), a kontextus egy része ismétlődik. Az x-grok-conv-id fejléc lehetővé teszi az xAI számára, hogy azonosítsa ezeket az összefüggő kéréseket, növelje a gyorsítótár-találati arányt, és ezzel csökkentse a költségeidet.

Az x-grok-conv-id fejléc

A beszélgetésalapú gyorsítótárazás engedélyezéséhez adj hozzá egy egyedi fejlécet, amely beszélgetésenként egy v4-es UUID-t tartalmaz:

import uuid

conversation_id = str(uuid.uuid4())

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

Minden olyan kérés, amely ugyanazt az x-grok-conv-id értéket használja, javított gyorsítótár-találati arányból profitál. A gyorsítótárazott tokenek díja alacsonyabb, mint a szabványos tokeneké.

Használati szabályok

  • Generálj új UUID-t minden beszélgetéshez vagy logikai munkamenethez
  • Használd ugyanazt az UUID-t a beszélgetésen belüli összes kéréshez
  • Ne használd újra az UUID-t különböző beszélgetések között (ez rontja a gyorsítótárazást)
# Minta egy chatbot számára
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 másodperces időtúllépés a következtetéshez

A következtető modellek (például grok-4.20-0309-reasoning és hasonlók) a válaszadás előtt belső következtetést végeznek. Ez a folyamat összetett problémák esetén több percet is igénybe vehet. A legtöbb HTTP-kliens alapértelmezett időtúllépése (30–120 másodperc) ehhez elégtelen.

# Helyes konfiguráció következtetéshez
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,     # gyors kapcsolódás
        read=3600.0,      # 1 óra az olvasáshoz
        write=30.0,       # prompt beküldése
        pool=10.0         # kapcsolatra várakozás
    )
)

A read=3600.0 a kritikus érték. Ez határozza meg a maximális késleltetést a szerver kérésfeldolgozásának megkezdése és a válasz fogadása között. Egy olyan következtető modellnél, amely 5 percig gondolkodik, szükséged van erre a tartalékra.

Mikor csökkentsd az időtúllépést?

A 3600 másodperces időtúllépés nem mindig szükséges:

  • grok-4.5 (nem következtető): általában elegendő a 120–300 másodperces időtúllépés
  • Egyszerű kérések: még következtető modell esetén is, a rövid kérdésekre egy percen belül válasz érkezik
  • Tesztkörnyezet: a 60 másodperces időtúllépés lehetővé teszi a hibák gyors észlelését
# Kliens gyors kérésekhez
fast_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(120.0)
)

# Kliens összetett következtetéshez
reasoning_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0)
)

Két különböző időtúllépéssel rendelkező kliens használata gyakori minta éles környezetben.

Megjegyzés a grok-4.5-höz és a következtetéshez

A grok-4.5 modell nem adja vissza a reasoning_content mezőt olvasható szövegként a válaszban. Belső következtetést végez, de az átláthatatlan marad. Ha látnod kell a következtetési folyamatot, használd a use_encrypted_content=True beállítást, hogy megőrizd azt a kérések között anélkül, hogy olvasni tudnád, vagy válaszd a grok-4.20-0309-reasoning modellt, amely jobban feltárja a folyamatát.

A gyorsítótár hatásának ellenőrzése

A gyorsítótár hatékonyságának méréséhez hasonlítsd össze a usage mezőt az x-grok-conv-id-vel és anélkül küldött kérések között:

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

A magas gyorsítótár-találati arány azt jelenti, hogy a kontextus tokenjeit újrahasznosítod ahelyett, hogy újra feldolgoznád őket, ami közvetlenül csökkenti a számládat.

Főbb megállapítások

  • A v4-es UUID-val ellátott x-grok-conv-id lehetővé teszi a beszélgetésalapú gyorsítótárazást az összefüggő kérésekhez
  • A gyorsítótárazott tokenek díja csökkentett
  • A következtető modellekhez 3600 másodperces időtúllépés szükséges
  • Használj külön klienseket a gyors és a következtetést igénylő kérésekhez
  • A grok-4.5 nem adja vissza a reasoning_content mezőt olvasható szövegként
  • Figyeld a gyorsítótár-találati arányt az usage.prompt_tokens_details mezőben az optimalizálás igazolásához