Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Batch-API och produktionschecklista

Lektion 12 av 12 Uppdaterad 2 november 2026 Avancerad
På denna sida
  1. Alternativet Batch-API: 20 % rabatt på tokens
  2. Jämförelse av tillvägagångssätt
  3. Produktionschecklista
  4. Rekommenderad arkitektur
  5. Viktiga punkter
  6. Testa dina kunskaper

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-id används för flerstegskonversationer

Felhantering

  • return_exceptions=True används i asyncio.gather fö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 GrokAsyncProcessor kapslar 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.