Batch-API och produktionschecklista
På denna sida
Alternativet Batch-API: 20 % rabatt på tokens
När realtidsbearbetning inte är ett krav erbjuder xAI:s Batch-API en rabatt på 20 % på alla tokens för berättigade textmodeller (från grok-4.3 till grok-4.7 per den 2 november 2026, enligt xAI:s priser för batch-API). Istället för att skicka förfrågningar en efter en och hantera samtidighet skickar du dina förfrågningar i batchar via API:t eller i en JSONL-fil, och hämtar resultaten när bearbetningen är klar – vanligtvis inom 24 timmar. Batch-förfrågningar räknas inte mot hastighetsbegränsningar. Kursen Batch-API: Massbearbetning beskriver arbetsflödet i detalj.
När du ska använda Batch-API
- Bearbetning av produktkataloger (tusentals beskrivningar)
- Massklassificering av supportärenden
- Generering av sammanfattningar för en dokumentbas
- Alla uppgifter där en fördröjning på några timmar är acceptabel
När du ska hålla dig till klassisk asynkron bearbetning
- Interaktiv chattbot (svar i realtid)
- Pipeline där varje steg beror på det föregående
- Övervakning och larm i realtid
- Alla fall där fördröjningen i Batch-API är oacceptabel
Jämförelse av tillvägagångssätt
| Kriterium | Asynkron + Semaphore | Batch-API |
|---|---|---|
| Kostnad | Standardtaxa | -20 % på tokens för berättigade modeller |
| Latens | Sekunder till minuter | Minuter till timmar |
| Kontroll | Realtid, omedelbara fel | Resultat när bearbetningen slutförs, fel per förfrågan |
| Komplexitet | Semaphore, backoff, gather | Batch av förfrågningar eller JSONL-fil, spårning av räknare |
| Hastighetsbegränsningar | Underkastad RPM/TPM | Hanteras av xAI |
Produktionschecklista
Innan du distribuerar ditt asynkrona förfrågningssystem till produktion, kontrollera varje punkt på denna lista:
Konfiguration
- Timeout är inställd på 3600 sekunder för resonemangsmodeller
- Semaphore är dimensionerad baserat på dina faktiska hastighetsbegränsningar (inte uppskattningar)
- Exponentiell backoff är implementerad med jitter för 429-fel
- API-nycklar laddas från miljövariabler, aldrig hårdkodade i koden
- Headern
x-grok-conv-idanvänds för flerstegskonversationer
Felhantering
return_exceptions=Trueanvänds iasyncio.gatherför att isolera fel- 429-, timeout- och anslutningsfel utlöser ett nytt försök
- Ogiltiga förfrågningsfel (
BadRequestError) utlöser inget nytt försök - Misslyckade förfrågningar identifieras och kan försökas igen
- Loggar inkluderar feltyp, försöksnummer och fördröjning inför nytt försök
Övervakning
- Antal konsumerade tokens spåras via
response.usage - Cache-träfffrekvens mäts för att validera användningen av
x-grok-conv-id - Kostnader uppskattas i realtid med
cost_in_usd_ticks - Återstående hastighetsbegränsningar övervakas för att justera semaforen dynamiskt
Prestanda
- Chunking används för batchar större än 100 förfrågningar
- Intermediära resultat sparas mellan delbatchar
- Förlopp visas för långvariga jobb
- Semaphore justeras baserat på vilken modell som används (resonemang = lägre)
Säkerhet
- API-nycklar exponeras inte i loggar eller felmeddelanden
- Svar som innehåller känslig data bearbetas i minnet, inte skrivna till disk
- Fjärrlagring (
store_messages) är inaktiverad för konfidentiell data use_encrypted_contentär aktiverat när konfidentialitet för resonemang krävs
Rekommenderad arkitektur
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)
Denna klass kapslar in alla mönster som behandlats i denna kurs: asynkron klient, semaphore, backoff, cache och felhantering. Den ger en solid utgångspunkt för dina produktionsprojekt.
Viktiga punkter
- Batch-API erbjuder 20 % rabatt på berättigade modeller men innebär en bearbetningsfördröjning
- Välj mellan asynkron bearbetning i realtid och batch baserat på dina latenskrav
- Produktionschecklistan täcker konfiguration, fel, övervakning, prestanda och säkerhet
- Klassen
GrokAsyncProcessorkapslar in alla kursmönster i en enda abstraktion - Testa alltid din konfiguration med en liten batch innan du startar massbearbetning
Testa dina kunskaper
Asynkron, begränsningar, cache: produktionsmönster i fem frågor.
1. När föredras asynkron framför synkron?
Svar: Vid hantering av flera oberoende förfrågningar: AsyncClient (eller AsyncOpenAI) överlappar nätverksväntan – genomströmningen multipliceras utan att multiplicera trådar.
2. Hur bearbetar du en batch utan att nå begränsningarna?
Svar: asyncio.gather för parallellism, en semaphore för att begränsa samtidiga förfrågningar och exponentiell backoff vid HTTP 429 – med respekt för konsolens RPM/TPM-begränsningar.
3. Hur hanterar du flerstegskontext i stor skala?
Svar: Genom serversidig lagring av svar och återanvändning av krypterat resonemang – tillståndet finns på API-sidan, din kod spårar endast identifierare.
4. Vad behöver du veta om cache och timeouts?
Svar: Konversationscache (x-grok-conv-id) snabbar upp uppföljande trådar, och resonemangsförfrågningar kräver anpassade timeouts – två inställningar som transformerar produktionen.
5. Vad innehåller kursens produktionschecklista?
Svar: Behärskad asynkron, respekterade begränsningar (semaphore + backoff), batch för kall volym, konfigurerade timeouts och försök, spårade kostnader – robusthet som en checklista.
Begränsad samtidighet, planerade fel, serversidigt tillstånd: asynkrona mönster transformerar dina skript till tjänster – den slutgiltiga checklistan låser fast dem.