Salt la conținutul principal
Română— Alege o limbă
Meniu

Cache x-grok-conv-id și Timeout pentru Raționament

Lecția 11 din 12 Actualizată 30 iulie 2026 Avansat
Pe această pagină
  1. Optimizarea costurilor prin caching
  2. Antetul x-grok-conv-id
  3. Timeout de 3600 de secunde pentru raționament
  4. Notă despre grok-4.5 și raționament
  5. Verificarea impactului cache-ului
  6. Puncte cheie

Optimizarea costurilor prin caching

Fiecare cerere trimisă către API-ul xAI este facturată la prețul standard per token. Totuși, atunci când trimiteți mai multe cereri corelate (aceeași conversație, același subiect), o parte din context se repetă. Antetul x-grok-conv-id permite xAI să identifice aceste cereri conexe și să crească rata de succes a cache-ului (cache hit rate), reducându-vă astfel costurile.

Antetul x-grok-conv-id

Pentru a activa caching-ul conversațional, adăugați un antet personalizat cu un UUID v4 unic pentru fiecare conversație:

import uuid

conversation_id = str(uuid.uuid4())

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

Toate cererile care partajează același x-grok-conv-id beneficiază de o rată de succes a cache-ului îmbunătățită. Token-urile din cache sunt facturate la o tarifă redusă comparativ cu token-urile standard.

Reguli de utilizare

  • Generați un nou UUID pentru fiecare conversație sau sesiune logică.
  • Reutilizați același UUID pentru toate cererile din cadrul aceleiași conversații.
  • Nu reutilizați un UUID între conversații diferite (acest lucru degradează performanța cache-ului).
# Model pentru un 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

Timeout de 3600 de secunde pentru raționament

Modelele de raționament (grok-4.20-0309-reasoning și similare) efectuează un proces intern de raționament înainte de a răspunde. Acest raționament poate dura câteva minute pentru problemele complexe. Timeout-ul implicit al majorității clienților HTTP (30-120 de secunde) este insuficient.

# Configurare corectă pentru raționament
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,     # conexiune rapidă
        read=3600.0,      # 1 oră pentru citire
        write=30.0,       # trimiterea promptului
        pool=10.0         # așteptarea în pool
    )
)

Valoarea read=3600.0 este cea critică. Aceasta reprezintă întârzierea maximă admisă între momentul în care serverul începe procesarea cererii dumneavoastră și momentul în care primiți răspunsul. Pentru un model de raționament care gândeste timp de 5 minute, aveți nevoie de această marjă.

Când să reduceți timeout-ul

Timeout-ul de 3600 de secunde nu este întotdeauna necesar:

  • grok-4.5 (fără raționament): un timeout de 120-300 de secunde este de obicei suficient.
  • Cereri simple: chiar și cu un model de raționament, întrebările scurte primesc un răspuns în mai puțin de un minut.
  • Mediu de testare: un timeout de 60 de secunde vă permite să detectați rapid problemele.
# Client pentru cereri rapide
fast_client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(120.0)
)

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

Utilizarea a doi clienți cu timeout-uri diferite este un model comun în producție.

Notă despre grok-4.5 și raționament

Modelul grok-4.5 nu returnează câmpul reasoning_content în text clar (plaintext) în răspuns. Raționamentul intern este efectuat, dar rămâne opac. Dacă aveți nevoie să păstrați procesul de raționament, utilizați use_encrypted_content=True pentru a-l conserva între cereri fără a-l putea citi, sau folosiți grok-4.20-0309-reasoning, care expune o parte mai mare din procesul său.

Verificarea impactului cache-ului

Pentru a măsura eficiența cache-ului, comparați câmpul usage între cererile cu și fără x-grok-conv-id:

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

O rată mare de succes a cache-ului înseamnă că token-urile de context sunt reutilizate în loc să fie reprocesate, ceea ce reduce direct factura dumneavoastră.

Puncte cheie

  • x-grok-conv-id cu un UUID v4 activează caching-ul conversațional pentru cererile corelate.
  • Token-urile din cache sunt facturate la o tarifă redusă.
  • Un timeout de 3600 de secunde este necesar pentru modelele de raționament.
  • Utilizați clienți separați pentru cererile rapide și pentru cele de raționament.
  • grok-4.5 nu returnează reasoning_content în text clar.
  • Monitorizați rata de succes a cache-ului în usage.prompt_tokens_details pentru a valida optimizarea.