Przejdź do głównej treści
Polski— Wybierz język
Menu

Buforowanie x-grok-conv-id i limit czasu rozumowania

Lekcja 11 z 12 Zaktualizowano 30 lipca 2026 Zaawansowany
Na tej stronie
  1. Optymalizacja kosztów dzięki buforowaniu
  2. Nagłówek x-grok-conv-id
  3. Limit czasu 3600 sekund dla rozumowania
  4. Uwaga dotycząca grok-4.5 i rozumowania
  5. Sprawdź wpływ buforowania
  6. Kluczowe wnioski

Optymalizacja kosztów dzięki buforowaniu

Każde żądanie wysłane do API xAI jest rozliczane według standardowej ceny za token. Jednak gdy wysyłasz wiele powiązanych żądań (ta sama konwersacja, ten sam temat), część kontekstu się powtarza. Nagłówek x-grok-conv-id pozwala xAI zidentyfikować te powiązane żądania i zwiększyć wskaźnik trafień w pamięci podręcznej (cache), co obniża Twoje koszty.

Nagłówek x-grok-conv-id

Aby włączyć buforowanie konwersacyjne, dodaj niestandardowy nagłówek z unikalnym UUID v4 dla każdej konwersacji:

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

Wszystkie żądania udostępniające ten sam x-grok-conv-id korzystają z wyższego wskaźnika trafień w pamięci podręcznej. Tokeny zapisane w cache są rozliczane według obniżonej stawki w porównaniu do tokenów standardowych.

Zasady użytkowania

  • Generuj nowe UUID dla każdej konwersacji lub sesji logicznej
  • Ponownie używaj tego samego UUID dla wszystkich żądań w ramach tej samej konwersacji
  • Nie używaj ponownie UUID w różnych konwersacjach (pogarsza to działanie buforowania)
# 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

Limit czasu 3600 sekund dla rozumowania

Modele rozumujące (grok-4.20-0309-reasoning i podobne) przeprowadzają wewnętrzne rozumowanie przed udzieleniem odpowiedzi. Proces ten może trwać kilka minut w przypadku złożonych problemów. Domyślny limit czasu dla większości klientów HTTP (30–120 sekund) jest niewystarczający.

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

Wartość read=3600.0 jest kluczowa. Określa ona maksymalne opóźnienie między momentem, w którym serwer zaczyna przetwarzać Twoje żądanie, a momentem otrzymania odpowiedzi. Dla modelu rozumującego, który myśli przez 5 minut, potrzebujesz takiego marginesu.

Kiedy zmniejszyć limit czasu

Limit czasu 3600 sekund nie zawsze jest konieczny:

  • grok-4.5 (bez rozumowania): limit czasu 120–300 sekund jest zazwyczaj wystarczający
  • Proste żądania: nawet przy użyciu modelu rozumującego, krótkie pytania otrzymują odpowiedź w czasie poniżej minuty
  • Środowisko testowe: limit czasu 60 sekund pozwala szybko wykryć problemy
# 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)
)

Używanie dwóch klientów z różnymi limitami czasu to powszechny wzorzec w środowisku produkcyjnym.

Uwaga dotycząca grok-4.5 i rozumowania

Model grok-4.5 nie zwraca pola reasoning_content w postaci zwykłego tekstu w odpowiedzi. Wewnętrzne rozumowanie jest przeprowadzane, ale pozostaje nieprzezroczyste. Jeśli potrzebujesz widzieć proces rozumowania, użyj use_encrypted_content=True, aby zachować go między żądaniami bez możliwości odczytu, lub wybierz grok-4.20-0309-reasoning, który udostępnia więcej informacji o swoim procesie.

Sprawdź wpływ buforowania

Aby zmierzyć wydajność pamięci podręcznej, porównaj pole usage między żądaniami z nagłówkiem x-grok-conv-id i bez niego:

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

Wysoki wskaźnik trafień w pamięci podręcznej oznacza, że tokeny kontekstu są ponownie wykorzystywane zamiast być przetwarzane od nowa, co bezpośrednio obniża Twój rachunek.

Kluczowe wnioski

  • x-grok-conv-id z UUID v4 włącza buforowanie konwersacyjne dla powiązanych żądań
  • Tokeny zapisane w cache są rozliczane według obniżonej stawki
  • Limit czasu 3600 sekund jest konieczny dla modeli rozumujących
  • Używaj oddzielnych klientów dla szybkich żądań i żądań wymagających rozumowania
  • grok-4.5 nie zwraca reasoning_content w postaci zwykłego tekstu
  • Monitoruj wskaźnik trafień w pamięci podręcznej w usage.prompt_tokens_details, aby zweryfikować optymalizację