Buforowanie x-grok-conv-id i limit czasu rozumowania
Na tej stronie
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-idz 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.5nie zwracareasoning_contentw postaci zwykłego tekstu- Monitoruj wskaźnik trafień w pamięci podręcznej w
usage.prompt_tokens_details, aby zweryfikować optymalizację