Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Batching in-line : jusqu'à 10 000 requêtes sans fichier

Lezione 4 di 16 Aggiornata il 3 novembre 2026 Avanzato
In questa pagina
  1. L’alternative légère au batching par fichier
  2. Batching par fichier vs Batching in-line
  3. Création d’un job in-line
  4. Exemple concret : Classification de tickets
  5. Quand choisir chaque approche
  6. Punti chiave

Mis à jour le 3 novembre 2026 : Mise à jour du 3 novembre : files.download renvoie une réponse HTTP (httpx2.Response) ; lis son contenu avec .read() avant d’appeler .decode().

L’alternative légère au batching par fichier

Le batching in-line te permet de soumettre des lots de requêtes directement dans l’appel API, en sautant l’étape de téléchargement du fichier. C’est la méthode idéale lorsque tu as un volume modéré de requêtes (jusqu’à 10 000) et que tu souhaites simplifier ton pipeline.

Batching par fichier vs Batching in-line

Avant de plonger dans le code, clarifions les différences entre ces deux approches :

Critère Batching par fichier Batching in-line
Volume max 1 000 000 de requêtes 10 000 requêtes
Prérequis Téléchargement d'un fichier JSONL Aucun
Étapes Téléchargement + Création de job Création de job (appel unique)
Cas d'usage Production, gros volumes Tests, prototypage, volumes moyens

Création d’un job in-line

Au lieu de passer input_files, tu passes un paramètre requests contenant directement ta liste de requêtes :

from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")

# Préparer les requêtes in-line
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)
]

# Créer le job avec les requêtes in-line
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)}")

La différence de code est minime : requests= au lieu de input_files=. Le reste du flux de travail (suivi du statut, téléchargement des résultats) est identique.

Exemple concret : Classification de tickets

Voici un exemple complet de classification de tickets de support client :

from mistralai.client import Mistral
import json
import time

client = Mistral(api_key="your-api-key")

# Simuler des tickets de support
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"},
]

# Construire les requêtes in-line
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
]

# Lancer le batch in-line
job = client.batch.jobs.create(
    requests=requests,
    model="mistral-small-latest",
    endpoint="/v1/chat/completions"
)

# Attendre et récupérer les résultats
while True:
    status = client.batch.jobs.get(job_id=job.id)
    if status.status in ("SUCCESS", "FAILED", "CANCELLED"):
        break
    time.sleep(5)

# Analyser les résultats
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()}")

Quand choisir chaque approche

Le facteur décisif n’est pas seulement le volume, mais la place du batching dans ton flux de travail. Lors du prototypage, tu testes un prompt sur quelques centaines d’exemples, tu l’affines, puis tu relances. Écrire un fichier JSONL intermédiaire à chaque itération ne fait que ralentir la boucle. Le batching in-line supprime cette friction : ton script génère les requêtes à la volée, les soumet dans le même appel, et tu itères en quelques minutes. La même logique s’applique aux intégrations légères, aux scripts d’analyse ponctuels ou au traitement quotidien restant sous la barre des 10 000 requêtes.

Le batching par fichier prend le relais une fois que le batching devient un maillon de production. D’abord, mécaniquement : au-delà de 10 000 requêtes, c’est la seule option. Mais surtout, structurellement : un fichier téléchargé est un artefact durable. Tu peux le réutiliser pour plusieurs jobs, le conserver comme trace exacte de ce qui a été soumis, et séparer proprement l’étape de préparation (qui construit, valide et versionne le fichier) de l’étape d’exécution (qui lance le job). Lorsqu’un job batch s’exécute nightly sur des données clients, cette traçabilité n’est pas un luxe ; c’est ce qui te permet de répondre à la question « Qu’avons-nous envoyé au modèle le 12 mars ? » six mois plus tard.

En pratique, de nombreuses équipes utilisent les deux : in-line durant le développement des prompts, puis bascule vers le batching par fichier lors de l’industrialisation. Comme le code pour le suivi et la récupération des résultats reste identique, la migration se limite à remplacer requests= par input_files=.

Punti chiave

  • Le batching in-line supprime l’étape de téléchargement en passant les requêtes directement via le paramètre requests
  • Limite de 10 000 requêtes par job in-line, contre 1 million pour le batching par fichier
  • Le suivi du statut et le téléchargement des résultats sont identiques pour les deux modes
  • Privilégie le mode in-line pour le prototypage et les volumes modérés ; utilise le batching par fichier pour la production à grande échelle