Cache x-grok-conv-id und Timeout für Reasoning
Auf dieser Seite
Kostenoptimierung durch Caching
Jede Anfrage an die xAI-API wird zum Standard-Tokenpreis abgerechnet. Wenn Sie jedoch mehrere verwandte Anfragen senden (gleicher Gesprächsverlauf, gleiches Thema), wiederholen sich Teile des Kontexts. Der Header x-grok-conv-id ermöglicht es der xAI, diese verwandten Anfragen zu identifizieren und die Cache-Trefferquote zu erhöhen, wodurch Ihre Kosten gesenkt werden.
Der Header x-grok-conv-id
Um das konversationale Caching zu aktivieren, fügen Sie einen benutzerdefinierten Header hinzu, der eine eindeutige v4 UUID pro Gespräch enthält:
import uuid
conversation_id = str(uuid.uuid4())
# Mit dem 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
}
)
Alle Anfragen, die denselben x-grok-conv-id teilen, profitieren von einer verbesserten Cache-Trefferquote. Gecachte Tokens werden zu einem reduzierten Satz gegenüber Standard-Tokens abgerechnet.
Nutzungsregeln
- Generieren Sie für jedes Gespräch oder jede logische Sitzung eine neue UUID.
- Nutzen Sie dieselbe UUID für alle Anfragen innerhalb desselben Gesprächs.
- Wiederverwenden Sie eine UUID nicht über verschiedene Gespräche hinweg (dies verschlechtert das Caching).
# Muster für einen 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
3600-Sekunden-Timeout für Reasoning
Reasoning-Modelle (grok-4.20-0309-reasoning und ähnliche) führen interne Reasoning-Prozesse durch, bevor sie antworten. Dieses Reasoning kann bei komplexen Problemen mehrere Minuten dauern. Der Standard-Timeout für die meisten HTTP-Clients (30–120 Sekunden) ist hierfür unzureichend.
# Korrekte Konfiguration für 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, # schnelle Verbindung
read=3600.0, # 1 Stunde für die Lesezeit
write=30.0, # Prompt-Übermittlung
pool=10.0 # Verbindungs-Wartezeit
)
)
read=3600.0 ist der kritische Wert. Dies ist die maximale Verzögerung zwischen dem Zeitpunkt, an dem der Server Ihre Anfrage verarbeitet, und dem Zeitpunkt, an dem Sie die Antwort erhalten. Für ein Reasoning-Modell, das 5 Minuten zum Nachdenken benötigt, ist diese Pufferzeit erforderlich.
Wann der Timeout reduziert werden kann
Der 3600-Sekunden-Timeout ist nicht immer notwendig:
- grok-4.5 (nicht-Reasoning): Ein Timeout von 120–300 Sekunden ist in der Regel ausreichend.
- Einfache Anfragen: Selbst bei einem Reasoning-Modell antworten kurze Fragen meist innerhalb einer Minute.
- Testumgebung: Ein 60-Sekunden-Timeout ermöglicht es Ihnen, Probleme schnell zu erkennen.
# Client für schnelle Anfragen
fast_client = AsyncOpenAI(
api_key=os.getenv("XAI_API_KEY"),
base_url="https://api.x.ai/v1",
timeout=httpx.Timeout(120.0)
)
# Client für komplexes Reasoning
reasoning_client = AsyncOpenAI(
api_key=os.getenv("XAI_API_KEY"),
base_url="https://api.x.ai/v1",
timeout=httpx.Timeout(3600.0)
)
Der Einsatz von zwei Clients mit unterschiedlichen Timeouts ist ein gängiges Muster in der Produktion.
Hinweis zu grok-4.5 und Reasoning
Das Modell grok-4.5 gibt das Feld reasoning_content im Klartext nicht in der Antwort zurück. Internes Reasoning wird durchgeführt, bleibt jedoch undurchsichtig. Wenn Sie den Reasoning-Prozess einsehen möchten, verwenden Sie use_encrypted_content=True, um ihn zwischen Anfragen zu erhalten, ohne ihn lesen zu können, oder grok-4.20-0309-reasoning, das mehr von seinem Prozess offenlegt.
Cache-Auswirkung prüfen
Um die Caching-Effizienz zu messen, vergleichen Sie das Feld usage zwischen Anfragen mit und ohne 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-Treffer: {cached}/{total} Tokens ({cached/total*100:.0f}%)")
Eine hohe Cache-Trefferquote bedeutet, dass Ihre Kontext-Token wiederverwendet und nicht erneut verarbeitet werden, was Ihre Abrechnung direkt senkt.
Kernaussagen
x-grok-conv-idmit einer v4 UUID ermöglicht konversationales Caching für verwandte Anfragen.- Gecachte Tokens werden zu einem reduzierten Satz abgerechnet.
- Ein 3600-Sekunden-Timeout ist für Reasoning-Modelle erforderlich.
- Nutzen Sie separate Clients für schnelle Anfragen und Reasoning-Anfragen.
grok-4.5gibtreasoning_contentnicht im Klartext zurück.- Überwachen Sie die Cache-Trefferquote in
usage.prompt_tokens_details, um die Optimierung zu validieren.