Batchning inline: upp till 10 000 förfrågningar utan fil
På denna sida
Uppdaterad 3 november 2026: Uppdatering 3 november:
files.downloadreturnerar ett HTTP-svar (httpx2.Response); läs innehållet med.read()innan du anropar.decode().
Det lätta alternativet till filbatchning
Inline-batchning låter dig skicka batchförfrågningar direkt i API-anropet och hoppa över steget att ladda upp en fil. Detta är den idealiska metoden när du har en måttlig volym förfrågningar (upp till 10 000) och vill förenkla din pipeline.
Filbatchning kontra inline-batchning
Innan vi dyker ner i koden, låt oss klargöra skillnaderna mellan de två metoderna:
| Kriterium | Filbatchning | Inline-batchning |
|---|---|---|
| Maxvolym | 1 000 000 förfrågningar | 10 000 förfrågningar |
| Förutsättningar | Ladda upp JSONL-fil | Inga |
| Steg | Uppladdning + skapa jobb | Skapa jobb (ett enda anrop) |
| Användningsområden | Produktion, stora volymer | Testning, prototyping, medelstora volymer |
Skapa ett inline-jobb
Istället för att skicka input_files skickar du en parameter requests som innehåller din lista med förfrågningar direkt:
from mistralai.client import Mistral
client = Mistral(api_key="your-api-key")
# Förbered inline-förfrågningar
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)
]
# Skapa jobbet med inline-förfrågningar
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)}")
Skillnaden i kod är minimal: requests= istället för input_files=. Resten av arbetsflödet (statusövervakning, nedladdning av resultat) är identiskt.
Genomgångsexempel: Klassificering av ärenden
Här är ett komplett exempel på hur du klassificerar kundsupportärenden:
from mistralai.client import Mistral
import json
import time
client = Mistral(api_key="your-api-key")
# Simulera supportärenden
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"},
]
# Bygg inline-förfrågningar
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
]
# Starta inline-batchen
job = client.batch.jobs.create(
requests=requests,
model="mistral-small-latest",
endpoint="/v1/chat/completions"
)
# Vänta och hämta resultat
while True:
status = client.batch.jobs.get(job_id=job.id)
if status.status in ("SUCCESS", "FAILED", "CANCELLED"):
break
time.sleep(5)
# Analysera resultat
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()}")
När ska du välja vilken metod?
Den avgörande faktorn är inte bara volymen, utan var batchningen passar in i ditt arbetsflöde. Under prototyping testar du en prompt på några hundra exempel, förfinar den och kör igen. Att skriva en mellanliggande JSONL-fil vid varje iteration bromsar bara loopen. Inline-batchning tar bort detta friktion – ditt skript genererar förfrågningar i farten, skickar dem i samma anrop och du kan iterera på några minuter. Samma logik gäller för lätta integrationer, engångsanalysskript eller daglig bearbetning som håller sig under 10 000 förfrågningar.
Filbatchning tar över när batchning blir en länk i produktionen. För det första mekaniskt: över 10 000 förfrågningar är det enda alternativet. Men viktigare än så, strukturellt: en uppladdad fil är ett bestående artefakt. Du kan återanvända den för flera jobb, behålla den som register över exakt vad som skickades in, och tydligt separera förberedelsesteget (som bygger, validerar och versionshanterar filen) från körsteget (som startar jobbet). När ett batchjobb körs varje natt på kunddata är denna spårbarhet ingen lyx; det är vad som låter dig svara på frågan »Vad skickade vi till modellen den 12 mars?« sex månader senare.
I praktiken använder många team båda: inline under promptutveckling, och byter sedan till filbatchning vid industrialisering. Eftersom koden för spårning och hämtning av resultat förblir identisk, begränsas migreringen till att byta ut requests= mot input_files=.
Viktiga punkter
- Inline-batchning tar bort uppladdningssteget genom att skicka förfrågningar direkt via parametern
requests - Gräns på 10 000 förfrågningar per inline-jobb, jämfört med 1 miljon för filbatchning
- Statusövervakning och nedladdning av resultat är identiska för båda lägena
- Föredra inline för prototyping och måttliga volymer; använd filbatchning för storskalig produktion