Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Batch-API og produktionscheckliste

Lektion 12 af 12 Opdateret 2. november 2026 Avanceret
På denne side
  1. Batch-API’et som alternativ: 20 % rabat på tokens
  2. Sammenligning af tilgange
  3. Produktionscheckliste
  4. Anbefalet arkitektur
  5. Vigtige pointer
  6. Test din viden

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-id bruges til samtaler over flere omgange

Fejlhåndtering

  • return_exceptions=True bruges i asyncio.gather for 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_content aktiveres, 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 GrokAsyncProcessor kapsler 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.