Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Batch-API en productiecontrolelijst

Les 12 van 12 Bijgewerkt op 2 november 2026 Gevorderd
Op deze pagina
  1. Het Batch-API-alternatief: 20% korting op tokens
  2. Vergelijking van benaderingen
  3. Productiecontrolelijst
  4. Aanbevolen architectuur
  5. Belangrijkste punten
  6. Test uw kennis

Het Batch-API-alternatief: 20% korting op tokens

Wanneer realtime verwerking geen vereiste is, biedt de Batch-API van xAI een korting van 20% op alle tokens voor in aanmerking komende tekstmodellen (van grok-4.3 tot grok-4.7 per 2 november 2026, volgens xAI batch-prijzen). In plaats van verzoeken één voor één te verzenden en gelijktijdigheid te beheren, dient u uw verzoeken in batches in via de API of in een JSONL-bestand. U haalt de resultaten op zodra de verwerking is voltooid, doorgaans binnen 24 uur. Batch-verzoeken tellen niet mee voor de tarieflimieten. De cursus Batch API: Bulk Processing beschrijft de workflow in detail.

Wanneer u de Batch-API gebruikt

  • Verwerking van productcatalogi (duizenden beschrijvingen)
  • Massale classificatie van supporttickets
  • Genereren van samenvattingen voor een documentbasis
  • Elke taak waarbij een vertraging van enkele uren aanvaardbaar is

Wanneer u kiest voor klassieke async

  • Interactieve chatbot (realtime respons)
  • Pipeline waarbij elke stap afhangt van de vorige
  • Realtime monitoring en waarschuwingen
  • Elk geval waarin de vertraging van de Batch-API onaanvaardbaar is

Vergelijking van benaderingen

Criterium Async + Semaphore Batch-API
Kosten Standaardtarief -20% op tokens voor in aanmerking komende modellen
Latentie Seconden tot minuten Minuten tot uren
Controle Realtime, onmiddellijke fouten Resultaten naarmate verwerking voltooid wordt, fouten per verzoek
Complexiteit Semaphore, backoff, gather Batch verzoeken of JSONL-bestand, teller bijhouden
Tarieflimieten Onderhevig aan RPM/TPM Beheerd door xAI

Productiecontrolelijst

Controleer voordat u uw asynchrone verzoeksysteem naar productie brengt elk punt op deze lijst:

Configuratie

  • Time-out is ingesteld op 3600 seconden voor redeneermodellen
  • Semaphore is gedimensioneerd op basis van uw werkelijke tarieflimieten (niet op schattingen)
  • Exponentiële backoff is geïmplementeerd met jitter voor 429-fouten
  • API-sleutels worden geladen vanuit omgevingsvariabelen, nooit hardcoded in de code
  • De header x-grok-conv-id wordt gebruikt voor conversaties met meerdere beurten

Foutafhandeling

  • return_exceptions=True wordt gebruikt in asyncio.gather om fouten te isoleren
  • 429-, time-out- en verbindingsfouten leiden tot een nieuwe poging
  • Ongeldige verzoekfouten (BadRequestError) leiden niet tot een nieuwe poging
  • Mislukte verzoeken worden geïdentificeerd en kunnen opnieuw worden geprobeerd
  • Logs bevatten het fouttype, het pogingsnummer en de vertraging voor de nieuwe poging

Monitoring

  • Het aantal verbruikte tokens wordt bijgehouden via response.usage
  • Het cache-hitpercentage wordt gemeten om het gebruik van x-grok-conv-id te valideren
  • Kosten worden in realtime geschat met cost_in_usd_ticks
  • Resterende tarieflimieten worden bewaakt om de semaphore dynamisch aan te passen

Prestaties

  • Chunking wordt gebruikt voor batches groter dan 100 verzoeken
  • Tussenresultaten worden opgeslagen tussen sub-batches
  • Voortgang wordt weergegeven voor langlopende taken
  • Semaphore wordt aangepast op basis van het gebruikte model (redeneren = lager)

Beveiliging

  • API-sleutels worden niet blootgelegd in logs of foutberichten
  • Reacties met gevoelige gegevens worden in het geheugen verwerkt, niet op schijf geschreven
  • Externe opslag (store_messages) is uitgeschakeld voor vertrouwelijke gegevens
  • use_encrypted_content is ingeschakeld wanneer vertrouwelijkheid van redeneringen vereist is

Aanbevolen architectuur

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)

Deze klasse kapselt alle patronen uit deze cursus in: async-client, semaphore, backoff, cache en foutafhandeling. Het biedt een solide uitgangspunt voor uw productieprojecten.

Belangrijkste punten

  • De Batch-API biedt 20% korting op in aanmerking komende modellen, maar legt een verwerkingsvertraging op
  • Kies tussen realtime async en batch op basis van uw latentievereisten
  • De productiecontrolelijst behandelt configuratie, fouten, monitoring, prestaties en beveiliging
  • De klasse GrokAsyncProcessor kapselt alle cursuspatronen samen in één abstractie
  • Test uw configuratie altijd met een kleine batch voordat u massaverwerking start

Test uw kennis

Async, limieten, cache: productiepatronen in vijf vragen.

1. Wanneer heeft async de voorkeur boven sync?

Antwoord: Altijd bij het afhandelen van meerdere onafhankelijke verzoeken: de AsyncClient (of AsyncOpenAI) overlapt netwerkwachttijden—de doorvoer vermenigvuldigt zich zonder dat het aantal threads toeneemt.

2. Hoe verwerkt u een batch zonder limieten te overschrijden?

Antwoord: asyncio.gather voor parallelisme, een semaphore om gelijktijdige verzoeken te beperken, en exponentiële backoff bij HTTP 429—met respect voor de RPM/TPM-limieten in de console.

3. Hoe beheert u context met meerdere beurten op grote schaal?

Antwoord: Via server-side opslag van antwoorden en hergebruik van versleutelde redeneringen—de staat blijft aan de API-kant, uw code houdt alleen identifiers bij.

4. Wat moet u weten over cache en time-outs?

Antwoord: Conversatiecache (x-grok-conv-id) versnelt vervolggesprekken en verzoeken voor redeneren vereisen aangepaste time-outs—twee instellingen die productie transformeren.

5. Wat bevat de productiecontrolelijst van de cursus?

Antwoord: Beheerste async, gerespecteerde limieten (semaphore + backoff), batch voor koude volumes, geconfigureerde time-outs en nieuwe pogingen, bijgehouden kosten—robuustheid als controlelijst.

Begrensde gelijktijdigheid, geplande fouten, server-side staat: async-patronen transformeren uw scripts in diensten—de laatste controlelijst zet ze veilig.