Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Batch-API und Produktions-Checkliste

Lektion 12 von 12 Aktualisiert am 2. November 2026 Fortgeschritten
Auf dieser Seite
  1. Die Alternative zur Batch-API: 20 % Rabatt auf Tokens
  2. Vergleich der Ansätze
  3. Produktions-Checkliste
  4. Empfohlene Architektur
  5. Kernaussagen
  6. Wissen prüfen

Die Alternative zur Batch-API: 20 % Rabatt auf Tokens

Wenn Echtzeitverarbeitung keine Einschränkung darstellt, bietet die Batch-API von xAI für alle qualifizierten Textmodelle eine 20 %ige Reduzierung der Tokenkosten (ab grok-4.3 bis grok-4.7 laut Stand vom 2. November 2026, gemäß xAI Batch-Preisen). Anstatt Anfragen einzeln zu senden und die Parallelität zu verwalten, übermitteln Sie Ihre Anfragen in Batches über die API oder in einer JSONL-Datei und erhalten die Ergebnisse, sobald die Verarbeitung abgeschlossen ist – typischerweise innerhalb von 24 Stunden. Batch-Anfragen werden nicht auf die Rate Limits angerechnet. Der Kurs Batch API: Bulk Processing erläutert das Workflow-Detail.

Wann die Batch-API verwenden

  • Verarbeitung von Produktkatalogen (tausende Beschreibungen)
  • Massenhafte Klassifizierung von Support-Tickets
  • Generierung von Zusammenfassungen für eine Dokumentenbasis
  • Jede Aufgabe, bei der eine Verzögerung von wenigen Stunden akzeptabel ist

Wann bei klassischem Async bleiben

  • Interaktiver Chatbot (Echtzeit-Antwort)
  • Pipeline, bei der jeder Schritt vom vorherigen abhängt
  • Echtzeit-Monitoring und Alarme
  • Jeder Fall, bei dem die Batch-API-Verzögerung inakzeptabel ist

Vergleich der Ansätze

Kriterium Async + Semaphore Batch-API
Kosten Standardrate -20 % auf Tokens für qualifizierte Modelle
Latenz Sekunden bis Minuten Minuten bis Stunden
Steuerung Echtzeit, sofortige Fehler Ergebnisse bei Abschluss der Verarbeitung, Fehler pro Anfrage
Komplexität Semaphore, Backoff, gather Batch von Anfragen oder JSONL-Datei, Zählerverfolgung
Rate Limits Unterstellt RPM/TPM Von xAI verwaltet

Produktions-Checkliste

Bevor Sie Ihr asynchrones Anfrage-System in die Produktion überführen, prüfen Sie jeden Punkt auf dieser Liste:

Konfiguration

  • Timeout ist auf 3600 Sekunden für Reasoning-Modelle eingestellt
  • Semaphore ist basierend auf Ihren tatsächlichen Rate Limits dimensioniert (nicht Schätzungen)
  • Exponentieller Backoff ist mit Jitter für Fehler 429 implementiert
  • API-Schlüssel werden aus Umgebungsvariablen geladen, niemals hartcodiert im Code
  • Der Header x-grok-conv-id wird für mehrstufige Gespräche verwendet

Fehlerbehandlung

  • return_exceptions=True wird in asyncio.gather verwendet, um Fehler zu isolieren
  • Fehler 429, Timeout und Verbindungsfehler lösen einen Retry aus
  • Fehler ungültiger Anfragen (BadRequestError) lösen keinen Retry aus
  • Fehlgeschlagene Anfragen werden identifiziert und können erneut versucht werden
  • Logs enthalten Fehlertyp, Versuchsnummer und Retry-Verzögerung

Monitoring

  • Anzahl der verbrauchten Tokens wird über response.usage verfolgt
  • Cache-Trefferquote wird gemessen, um die Nutzung von x-grok-conv-id zu validieren
  • Kosten werden in Echtzeit mit cost_in_usd_ticks geschätzt
  • Verbleibende Rate Limits werden überwacht, um den Semaphore dynamisch anzupassen

Leistung

  • Chunking wird für Batches mit mehr als 100 Anfragen verwendet
  • Zwischenergebnisse werden zwischen Sub-Batches gespeichert
  • Fortschritt wird für langlaufende Jobs angezeigt
  • Semaphore wird basierend auf dem verwendeten Modell angepasst (Reasoning = niedriger)

Sicherheit

  • API-Schlüssel werden nicht in Logs oder Fehlermeldungen offengelegt
  • Antworten mit sensiblen Daten werden im Arbeitsspeicher verarbeitet, nicht auf die Festplatte geschrieben
  • Remote-Speicher (store_messages) ist für vertrauliche Daten deaktiviert
  • use_encrypted_content ist aktiviert, wenn Reasoning-Vertraulichkeit erforderlich ist

Empfohlene Architektur

import os
import asyncio
import uuid
from asyncio import Semaphore
from openai import AsyncOpenAI, RateLimitError, APITimeoutError
import httpx

class GrokAsyncProcessor:
    def __init__(self, max_concurrent: int = 5):
        self.client = AsyncOpenAI(
            api_key=os.getenv("XAI_API_KEY"),
            base_url="https://api.x.ai/v1",
            timeout=httpx.Timeout(3600.0)
        )
        self.sem = Semaphore(max_concurrent)
        self.conv_id = str(uuid.uuid4())

    async def request(self, prompt: str, max_retries: int = 5) -> str:
        async with self.sem:
            for attempt in range(max_retries):
                try:
                    response = await self.client.chat.completions.create(
                        model="grok-4.5",
                        messages=[{"role": "user", "content": prompt}],
                        extra_headers={"x-grok-conv-id": self.conv_id}
                    )
                    return response.choices[0].message.content
                except RateLimitError:
                    if attempt == max_retries - 1:
                        raise
                    await asyncio.sleep(2 ** attempt)
                except APITimeoutError:
                    if attempt == max_retries - 1:
                        raise
                    await asyncio.sleep(2 ** attempt)

    async def batch(self, prompts: list[str]) -> list[str | Exception]:
        tasks = [self.request(p) for p in prompts]
        return await asyncio.gather(*tasks, return_exceptions=True)

Diese Klasse kapselt alle Muster dieses Kurses: asynchroner Client, Semaphore, Backoff, Cache und Fehlerbehandlung. Sie bietet einen soliden Ausgangspunkt für Ihre Produktionsprojekte.

Kernaussagen

  • Die Batch-API bietet 20 % Rabatt auf qualifizierte Modelle, unterliegt aber einer Verarbeitungsverzögerung
  • Wählen Sie zwischen Echtzeit-Async und Batch basierend auf Ihren Latenzanforderungen
  • Die Produktions-Checkliste abdeckt Konfiguration, Fehler, Monitoring, Leistung und Sicherheit
  • Die Klasse GrokAsyncProcessor kapselt alle Kursmuster in einer einzigen Abstraktion
  • Testen Sie Ihre Konfiguration immer mit einem kleinen Batch, bevor Sie die Massenvorverarbeitung starten

Wissen prüfen

Async, Limits, Cache: Produktionsmuster in fünf Fragen.

1. Wann überwiegt Async gegenüber Sync?

Antwort: Immer bei der Behandlung mehrerer unabhängiger Anfragen: Der AsyncClient (oder AsyncOpenAI) überlappt Netzwerkwartezeiten – die Durchsatzleistung vervielfacht sich, ohne die Anzahl der Threads zu erhöhen.

2. Wie verarbeiten Sie einen Batch, ohne Limits zu überschreiten?

Antwort: asyncio.gather für Parallelität, ein Semaphore zur Begrenzung gleichzeitiger Anfragen und exponentieller Backoff bei HTTP 429 – unter Einhaltung der RPM/TPM-Limits des Konsolen-Interfaces.

3. Wie behandeln Sie mehrstufigen Kontext im großen Maßstab?

Antwort: Durch serverseitige Antwortspeicherung und wiederverwendetes verschlüsseltes Reasoning – der Zustand lebt auf der API-Seite, Ihr Code verfolgt lediglich Identifikatoren.

4. Was müssen Sie über Cache und Timeouts wissen?

Antwort: Gesprächs-Cache (x-grok-conv-id) beschleunigt nachfolgende Threads, und Reasoning-Anfragen erfordern angepasste Timeouts – zwei Einstellungen, die die Produktion transformieren.

5. Was enthält die Kurs-Produktions-Checkliste?

Antwort: Beherrschter Async, respektierte Limits (Semaphore + Backoff), Batch für kalte Volumina, konfigurierte Timeouts und Retries, verfolgte Kosten – Robustheit als Checkliste.

Begrenzte Parallelität, geplante Ausfälle, serverseitiger Zustand: Async-Muster verwandeln Ihre Skripte in Dienste – die finale Checkliste sichert sie ab.