Salt la conținutul principal
Română— Alege o limbă
Meniu

Batching inline : jusqu'à 10 000 requêtes sans fichier

Lecția 4 din 16 Actualizată 3 noiembrie 2026 Avansat
Pe această pagină
  1. L’alternative légère au batching par fichier
  2. Batching par fichier vs Batching inline
  3. Création d’un job inline
  4. Exemple concret : Classification de tickets
  5. Quand choisir chaque approche
  6. Puncte cheie

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

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

Le batching inline vous permet de soumettre des lots de requêtes directement dans l’appel API, en évitant l’étape de téléchargement de fichier. C’est la méthode idéale lorsque vous avez un volume modéré de requêtes (jusqu’à 10 000) et que vous souhaitez simplifier votre pipeline.

Batching par fichier vs Batching inline

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

Critère Batching par fichier Batching inline
Volume maximal 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, grands volumes Tests, prototypage, volumes moyens

Création d’un job inline

Au lieu de passer input_files, vous passez un paramètre requests contenant directement votre liste de requêtes :

from mistralai.client import Mistral

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

# Préparer les requêtes inline
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 inline
job = client.batch.jobs.create(
    requests=inline_requests,
    model="mistral-small-latest",
    endpoint="/v1/chat/completions"
)

print(f"Job inline créé : {job.id}")
print(f"Nombre de requêtes : {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 inline
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 inline
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 votre flux de travail. Lors du prototypage, vous testez un prompt sur quelques centaines d’exemples, vous l’affinez, puis vous le relancez. Écrire un fichier JSONL intermédiaire à chaque itération ne fait que ralentir la boucle. Le batching inline supprime cette friction : votre script génère les requêtes à la volée, les soumet dans le même appel, et vous itérez 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. Vous pouvez 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 vous 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 : inline durant le développement des prompts, puis bascule vers le batching par fichier lors de l’industrialisation. Comme le code de suivi et de récupération des résultats reste identique, la migration se limite à remplacer requests= par input_files=.

Puncte cheie

  • Le batching inline 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 inline, 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égiez le inline pour le prototypage et les volumes modérés ; utilisez le batching par fichier pour la production à grande échelle