Inline Batching: Op til 10.000 forespørgsler uden en fil
På denne side
Opdateret 3. november 2026: Opdatering 3. november:
files.downloadreturnerer et HTTP-svar (httpx2.Response); læs indholdet med.read()før du kalder.decode().
Det lette alternativ til fil-batching
Inline batching giver dig mulighed for at indsende batch-forespørgsler direkte i API-kaldet og dermed springe trinnet med filupload over. Dette er den ideelle metode, når du har et moderat antal forespørgsler (op til 10.000) og ønsker at forenkle din pipeline.
Fil-batching kontra inline batching
Før vi dykker ned i koden, lad os afklare forskellene mellem de to tilgange:
| Kriterium | Fil-batching | Inline batching |
|---|---|---|
| Maks. volumen | 1.000.000 forespørgsler | 10.000 forespørgsler |
| Forudsætninger | Upload af JSONL-fil | Ingen |
| Trin | Upload + Opret job | Opret job (enkelt kald) |
| Use cases | Produktion, store volumener | Test, prototyping, mellemstore volumener |
Oprettelse af et inline-job
I stedet for at sende input_files, sender du en parameter requests, der indeholder din liste over forespørgsler direkte:
from mistralai.client import Mistral
client = Mistral(api_key="your-api-key")
# Forbered inline-forespørgsler
inline_requests = [
{
"custom_id": f"req-{i:04d}",
"body": {
"max_tokens": 150,
"messages": [
{
"role": "system",
"content": "You are a text classification expert."
},
{
"role": "user",
"content": f"Classify this text: {text}"
}
]
}
}
for i, text in enumerate(my_texts)
]
# Opret jobbet med inline-forespørgsler
job = client.batch.jobs.create(
requests=inline_requests,
model="mistral-small-latest",
endpoint="/v1/chat/completions"
)
print(f"Inline job created: {job.id}")
print(f"Number of requests: {len(inline_requests)}")
Forskellen i koden er minimal: requests= i stedet for input_files=. Resten af workflowet (statussporing, download af resultater) er identisk.
Gennemarbejdet eksempel: Klassificering af tickets
Her er et komplet eksempel på klassificering af kundesupport-tickets:
from mistralai.client import Mistral
import json
import time
client = Mistral(api_key="your-api-key")
# Simuler support-tickets
tickets = [
{"id": "TK-001", "message": "I cannot log in to my account"},
{"id": "TK-002", "message": "How do I cancel my subscription?"},
{"id": "TK-003", "message": "The app crashes on startup"},
{"id": "TK-004", "message": "Can you add dark mode?"},
{"id": "TK-005", "message": "My invoice is incorrect"},
]
# Byg inline-forespørgsler
requests = [
{
"custom_id": ticket["id"],
"body": {
"max_tokens": 50,
"messages": [
{
"role": "system",
"content": (
"Classify the ticket into one of these categories: "
"AUTHENTICATION, BILLING, BUG, "
"FEATURE, SUBSCRIPTION. "
"Reply with the category only."
)
},
{"role": "user", "content": ticket["message"]}
]
}
}
for ticket in tickets
]
# Start inline-batchen
job = client.batch.jobs.create(
requests=requests,
model="mistral-small-latest",
endpoint="/v1/chat/completions"
)
# Vent og hent resultater
while True:
status = client.batch.jobs.get(job_id=job.id)
if status.status in ("SUCCESS", "FAILED", "CANCELLED"):
break
time.sleep(5)
# Parse resultater
if status.status == "SUCCESS":
data = client.files.download(file_id=status.output_file)
for line in data.read().decode("utf-8").strip().split("\n"):
entry = json.loads(line)
ticket_id = entry["custom_id"]
category = entry["response"]["body"]["choices"][0]["message"]["content"]
print(f"{ticket_id} -> {category.strip()}")
Hvornår skal du vælge hvilken tilgang?
Den afgørende faktor er ikke kun volumen, men hvor batching passer ind i dit workflow. Under prototyping tester du en prompt på et par hundrede eksempler, forfiner den og kører den igen. At skrive en mellemliggende JSONL-fil ved hver iteration bremser kun løkken. Inline batching fjerner denne friktion – dit script genererer forespørgslerne løbende, indsender dem i samme kald, og du kan iterere på få minutter. Den samme logik gælder for letvægtsintegrationer, engangs-analyseskripter eller daglig behandling, der holder sig under 10.000 forespørgsler.
Fil-batching tager føringen, når batching bliver et led i produktionen. Først mekanisk: ud over 10.000 forespørgsler er det den eneste mulighed. Men vigtigere endnu, strukturelt: en uploadet fil er et holdbart aktiv. Du kan genbruge den til flere jobs, beholde den som en registrering af præcis, hvad der blev indsendt, og klart adskille forberedelsestrinnet (som bygger, validerer og versionerer filen) fra udførelsestrinnet (som starter jobbet). Når et batch-job kører nightly på kundedata, er denne sporbarhed ikke en luksus; det er det, der gør det muligt at svare på spørgsmålet: „Hvad sendte vi til modellen den 12. marts?” seks måneder senere.
I praksis bruger mange teams begge dele: inline under prompt-udvikling og skifter derefter til fil-batching ved industrialisering. Da koden til sporing og hentning af resultater forbliver identisk, begrænser migrationen sig til at udskifte requests= med input_files=.
Vigtige pointer
- Inline batching fjerner upload-trinnet ved at sende forespørgsler direkte via parameteren
requests - Grænse på 10.000 forespørgsler pr. inline-job mod 1 million ved fil-batching
- Statussporing og download af resultater er identiske for begge tilstande
- Foretræk inline til prototyping og moderate volumener; brug fil-batching til storskala produktion