Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Cache x-grok-conv-id und Timeout für Reasoning

Lektion 11 von 12 Aktualisiert am 30. Juli 2026 Fortgeschritten
Auf dieser Seite
  1. Kostenoptimierung durch Caching
  2. Der Header x-grok-conv-id
  3. 3600-Sekunden-Timeout für Reasoning
  4. Hinweis zu grok-4.5 und Reasoning
  5. Cache-Auswirkung prüfen
  6. Kernaussagen

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-id mit 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.5 gibt reasoning_content nicht im Klartext zurück.
  • Überwachen Sie die Cache-Trefferquote in usage.prompt_tokens_details, um die Optimierung zu validieren.