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

Arbetsflöde i fyra steg

Lektion 2 av 12 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. En batchs livscykel
  2. Steg 1: Skapa en batch
  3. Steg 2: Lägg till förfrågningar
  4. Steg 3: Övervaka framdriften
  5. Steg 4: Hämta resultat
  6. Arbetsflödet i praktiken
  7. Felhantering i arbetsflödet
  8. Viktiga punkter

Uppdaterat 2 november 2026 baserat på xAI:s dokumentation: rabatten för batch-körningar är 20 % på berättigade textmodeller (inte 50 %); exemplen använder REST API:t och den officiella xai-sdk (client.batch.*; xAI:s Batch API följer inte OpenAIs format, så OpenAI SDK gäller inte); och Responses API har företräde framför Chat Completions, som är en föråldrad slutpunkt hos xAI. Källor: Batch API · REST-referens · Prissättning för batch.

En batchs livscykel

Varje batch följer samma cykel: skapa, lägg till förfrågningar, bearbeta, hämta resultat. Det är avgörande att du förstår denna cykel innan du går vidare till implementering, eftersom varje steg har sina egna begränsningar och bästa praxis.

Steg 1: Skapa en batch

Allt börjar med ett anrop till POST /v1/batches, med ett obligatoriskt fält: batchens namn. API:t returnerar en unik identifierare (batch_id) som du använder för alla efterföljande operationer.

curl -X POST https://api.x.ai/v1/batches \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "customer_review_analysis"}'

Svaret innehåller också datum för skapande och utgång (create_time, expire_time) samt ett state-objekt där alla räknare fortfarande står på noll.

Steg 2: Lägg till förfrågningar

Det finns två metoder:

Via API:t: du skickar förfrågningar med POST /v1/batches/{batch_id}/requests. Varje anrop innehåller en lista med förfrågningar, och du kan fortsätta lägga till så länge batchen inte är avbruten. Detta är vägen för batchar som byggs upp successivt.

Via en JSONL-fil: du förbereder en fil som innehåller alla dina förfrågningar, laddar upp den via Files API och skapar sedan batchen från den filen. Batchen förseglas då: inga fler tillägg är möjliga. Detta är vägen för stora volymer som förberetts i förväg.

Varje förfrågan har en unik identifierare inom batchen: batch_request_id i API:t, custom_id i JSONL-filen. Om du utelämnar den i API:t genererar xAI ett UUID; ange istället ditt eget (till exempel en databas-ID). Det fungerar som nyckel för att matcha din data mot resultaten och garanterar att en förfrågan bara bearbetas en gång.

Steg 3: Övervaka framdriften

Bearbetningen startar så snart förfrågningar anländer; det finns inget separat “start”-steg. Under tiden returnerar GET /v1/batches/{batch_id} state-objektet och dess räknare: num_requests (totalt), num_pending (väntande), num_success (lyckade), num_error (misslyckade) och num_cancelled (avbrutna).

curl https://api.x.ai/v1/batches/$BATCH_ID \
  -H "Authorization: Bearer $XAI_API_KEY"

När num_pending sjunker till noll har alla förfrågningar bearbetats, oavsett om de lyckades eller inte. Periodisk polling räcker: några sekunder för en liten testbatch, några minuter för en stor batch.

Steg 4: Hämta resultat

Resultat läses med GET /v1/batches/{batch_id}/results, utan att vänta på att batchen ska bli klar: varje förfrågan är tillgänglig så snart den är bearbetad. Svaret är paginerat: limit anger sidstorleken (max 1 000) och den returnerade pagination_token används för att begära nästa sida; den är tom på den sista sidan.

curl "https://api.x.ai/v1/batches/$BATCH_ID/results?limit=100" \
  -H "Authorization: Bearer $XAI_API_KEY"

Varje resultat innehåller batch_request_id från sin förfrågan: detta låter dig återskapa kopplingen mellan dina indata och Groks svar.

Arbetsflödet i praktiken

I en produktionsmiljö översätts arbetsflödet oftast till två separata processer:

  • En inlämningsprocess som skapar batchen, förbereder och lägger till förfrågningar, och sedan lagrar batch_id
  • En hämtningsprocess som periodiskt kontrollerar räknarna och laddar ner resultat när de blir tillgängliga

Denna separation låter dig integrera Batch API:t i händelsestyrda arkitekturer eller befintliga datapipelines (cron-jobb, Apache Airflow, köer).

Felhantering i arbetsflödet

En batch har inget globalt tillstånd för “lyckad” eller “misslyckad”: du läser av den via dess räknare. En misslyckad förfrågan ökar num_error och visas i resultaten med sitt felmeddelande, utan att blockera de andra. Du måste därför granska varje resultat och hantera fel fall för fall.

Två händelser påverkar hela batchen. Den första är avbrott, av dig eller av xAI, som då förklarar orsaken i fältet cancel_by_xai_message. Detta händer särskilt om en rad i en JSONL-fil är ogiltig. Den andra är utgång (expire_time), varefter resultaten inte längre är tillgängliga: hämta dem promptly.

Viktiga punkter

  • Arbetsflödet följer ordningen: skapa (med ett namn), lägg till, övervaka, hämta
  • Förfrågningsidentifieraren (batch_request_id, eller custom_id i JSONL) är din matchningsnyckel
  • Framdriften läses från state-räknarna; allt är bearbetat när num_pending är noll
  • Resultat är paginerade (limit, pagination_token) och tillgängliga i takt med att de bearbetas
  • Fel hanteras förfrågan för förfrågan; avbrott och utgång påverkar hela batchen