Batch-API und Produktions-Checkliste
Auf dieser Seite
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-idwird für mehrstufige Gespräche verwendet
Fehlerbehandlung
return_exceptions=Truewird inasyncio.gatherverwendet, 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.usageverfolgt - Cache-Trefferquote wird gemessen, um die Nutzung von
x-grok-conv-idzu validieren - Kosten werden in Echtzeit mit
cost_in_usd_ticksgeschä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_contentist 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
GrokAsyncProcessorkapselt 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.