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

Batchning inline: upp till 10 000 förfrågningar utan fil

Lektion 4 av 16 Uppdaterad 3 november 2026 Avancerad
På denna sida
  1. Det lätta alternativet till filbatchning
  2. Filbatchning kontra inline-batchning
  3. Skapa ett inline-jobb
  4. Genomgångsexempel: Klassificering av ärenden
  5. När ska du välja vilken metod?
  6. Viktiga punkter

Uppdaterad 3 november 2026: Uppdatering 3 november: files.download returnerar 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