Batch-API og produktionscheckliste
På denne side
Batch-API’et som alternativ: 20 % rabat på tokens
Når realtidsbehandling ikke er et krav, tilbyder xAI’s Batch-API en reduktion på 20 % af alle tokens for berettigede tekstmodeller (fra grok-4.3 til grok-4.7 pr. 2. november 2026, jf. xAI batch pricing). I stedet for at sende anmodninger én ad gangen og styre samtidighed, indsender du dine anmodninger i batches via API’et eller i en JSONL-fil og henter resultaterne, efterhånden som behandlingen fuldføres – typisk inden for 24 timer. Batch-anmodninger tæller ikke med i rate limits. Kurset Batch API: Bulk Processing gennemgår workflowet i detaljer.
Hvornår skal du bruge Batch-API’et?
- Behandling af produktkataloger (tusindvis af beskrivelser)
- Masseklassificering af supporttickets
- Generering af resuméer for et dokumentarkiv
- Enhver opgave, hvor en forsinkelse på få timer er acceptabel
Hvornår skal du holde fast i klassisk async?
- Interaktiv chatbot (svar i realtid)
- Pipeline, hvor hvert trin afhænger af det foregående
- Overvågning og alarmer i realtid
- Ethvert tilfælde, hvor Batch-API’ets forsinkelse er uacceptabel
Sammenligning af tilgange
| Kriterium | Async + Semaphore | Batch-API |
|---|---|---|
| Omkostninger | Standardtakst | -20 % på tokens for berettigede modeller |
| Latens | Sekunder til minutter | Minutter til timer |
| Kontrol | Realtid, øjeblikkelige fejl | Resultater efterhånden som behandling fuldføres, fejl pr. anmodning |
| Kompleksitet | Semaphore, backoff, gather | Batch af anmodninger eller JSONL-fil, sporing af tæller |
| Rate limits | Underlagt RPM/TPM | Administreret af xAI |
Produktionscheckliste
Før du deployer dit system for asynkrone anmodninger til produktion, skal du gennemgå hvert punkt på denne liste:
Konfiguration
- Timeout er sat til 3600 sekunder for ræsonnementsmodeller
- Semaphore er dimensioneret ud fra dine faktiske rate limits (ikke estimater)
- Eksponentiel backoff er implementeret med jitter for 429-fejl
- API-nøgler indlæses fra miljøvariabler og hardcodes aldrig i koden
- Headeren
x-grok-conv-idbruges til samtaler over flere omgange
Fejlhåndtering
return_exceptions=Truebruges iasyncio.gatherfor at isolere fejl- 429-, timeout- og forbindelsesfejl udløser et genforsøg
- Ugyldige anmodningsfejl (
BadRequestError) udløser ikke et genforsøg - Mislykkede anmodninger identificeres og kan genforsøges
- Logs indeholder fejltype, forsøgsnummer og ventetid før genforsøg
Overvågning
- Antal forbrugte tokens spores via
response.usage - Cache-hit-rate måles for at validere brugen af
x-grok-conv-id - Omkostninger estimeres i realtid med
cost_in_usd_ticks - Resterende rate limits overvåges for dynamisk at justere semaphoren
Ydeevne
- Chunking bruges til batches større end 100 anmodninger
- Mellemliggende resultater gemmes mellem del-batches
- Fremskridt vises for langvarige jobs
- Semaphore justeres baseret på den anvendte model (ræsonnement = lavere)
Sikkerhed
- API-nøgler eksponeres ikke i logs eller fejlmeddelelser
- Svar, der indeholder følsomme data, behandles i hukommelsen og skrives ikke til disk
- Fjernlagring (
store_messages) deaktiveres for fortrolige data use_encrypted_contentaktiveres, når fortrolighed i ræsonnement er påkrævet
Anbefalet 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)
Denne klasse kapsler alle mønstre, der er dækket i dette kursus: async-klient, semaphore, backoff, cache og fejlhåndtering. Den giver et solidt udgangspunkt for dine produktionsprojekter.
Vigtige pointer
- Batch-API’et giver 20 % rabat på berettigede modeller, men pålægger en behandlingsforsinkelse
- Vælg mellem realtids-async og batch baseret på dine latenskrav
- Produktionschecklisten dækker konfiguration, fejl, overvågning, ydeevne og sikkerhed
- Klassen
GrokAsyncProcessorkapsler alle kursussens mønstre i én enkelt abstraktion - Test altid din konfiguration med et lille batch, før du lancerer massebehandling
Test din viden
Async, limits, cache: produktionsmønstre i fem spørgsmål.
1. Hvornår foretrækkes async frem for sync?
Svar: Når du håndterer flere uafhængige anmodninger: AsyncClient (eller AsyncOpenAI) overlapper netværksventetid – throughput ganget op uden at gange antallet af tråde.
2. Hvordan behandler du et batch uden at ramme limits?
Svar: asyncio.gather til parallelisme, en semaphore til at begrænse samtidige anmodninger og eksponentiel backoff ved HTTP 429 – med respekt for konsollens RPM/TPM-limits.
3. Hvordan håndterer du kontekst over flere omgange i stor skala?
Svar: Gennem serversidelagring af svar og genbrug af krypteret ræsonnement – tilstanden lever på API-siden, din kode sporer kun identifikatorer.
4. Hvad skal du vide om cache og timeouts?
Svar: Samtalecache (x-grok-conv-id) accelererer efterfølgende tråde, og ræsonnementsanmodninger kræver tilpassede timeouts – to indstillinger, der transformerer produktionen.
5. Hvad indeholder kursussens produktionscheckliste?
Svar: Behersket async, respekterede limits (semaphore + backoff), batch til koldt volumen, konfigurerede timeouts og genforsøg, sporede omkostninger – robusthed som en checkliste.
Begrænset samtidighed, planlagte fejl, serversidetilstand: async-mønstre transformerer dine scripts til tjenester – den endelige checkliste låser dem fast.