N completions

Générer plusieurs réponses en un seul appel

Le paramètre n demande au modèle de produire plusieurs réponses alternatives au même prompt, dans une seule requête API. L’idée paraît anecdotique et elle ouvre pourtant trois usages sérieux : comparer deux formulations de prompt sur un échantillon, sélectionner automatiquement la meilleure réponse d’un lot, et explorer l’espace des solutions possibles plutôt que d’accepter la première venue.

Par défaut, n=1 et l’API renvoie une seule réponse dans choices. En passant n=5, ce tableau contient cinq entrées, chacune avec son index. Notez la température à 1.0 dans l’exemple : sans randomisation suffisante, les cinq réponses seraient identiques et l’appel n’aurait servi à rien.

from mistralai import Mistral
import os

client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

response = client.chat.complete(
    model="ministral-3b-latest",
    messages=[
        {"role": "user", "content": "Quel est le meilleur langage de programmation pour débuter ? Un seul mot."}
    ],
    temperature=1.0,  # Température élevée pour maximiser la diversité
    n=5
)

for choice in response.choices:
    print(f"Réponse {choice.index} : {choice.message.content}")

Deux points conditionnent l’usage réel de ce paramètre. Le premier est la facturation : les tokens d’entrée ne sont facturés qu’une seule fois, puisque le prompt n’est envoyé qu’une fois, mais les tokens de sortie sont facturés pour chaque completion. Avec n=5 et max_tokens=100, votre plafond de sortie passe à 500 tokens. C’est précisément ce qui rend n intéressant sur des prompts longs — un contexte volumineux amorti sur cinq réponses coûte bien moins que cinq appels séparés.

print(f"Tokens prompt  : {response.usage.prompt_tokens}")     # Facturé 1x
print(f"Tokens réponse : {response.usage.completion_tokens}")  # Facturé nx
print(f"Total          : {response.usage.total_tokens}")

Le second point est la compatibilité : tous les modèles Mistral ne supportent pas n. En avril 2026, mistral-large dans ses versions récentes ne supporte pas n > 1. Utilisez ministral-3b-latest ou d’autres modèles compatibles pour cette fonctionnalité — c’est la raison pour laquelle tous les exemples de cette leçon s’appuient sur ce modèle.

Sélectionner la meilleure réponse

Le premier usage consiste à générer plusieurs candidats puis à retenir le meilleur selon un critère que vous définissez. Le mécanisme est volontairement générique : best_of_n accepte une fonction de scoring quelconque, ce qui vous laisse mesurer ce qui compte dans votre contexte — présence d’un mot-clé obligatoire, validité d’un JSON, respect d’une longueur cible. C’est ce dernier critère qu’illustre length_scorer, dont le score décroît proportionnellement à l’écart avec la longueur visée.

def best_of_n(client, messages, n=5, scorer=None, **kwargs):
    """Génère N réponses et sélectionne la meilleure."""
    response = client.chat.complete(
        model="ministral-3b-latest",
        messages=messages,
        n=n,
        temperature=0.9,
        **kwargs
    )

    candidates = [
        {
            "index": c.index,
            "content": c.message.content,
            "score": scorer(c.message.content) if scorer else 0
        }
        for c in response.choices
    ]

    if scorer:
        candidates.sort(key=lambda x: x["score"], reverse=True)

    return candidates

# Scorer : longueur appropriée (ni trop court, ni trop long)
def length_scorer(text: str, target=200) -> float:
    """Score basé sur la proximité avec une longueur cible."""
    diff = abs(len(text) - target)
    return max(0, 1 - diff / target)

candidates = best_of_n(
    client,
    [{"role": "user", "content": "Rédigez un résumé de l'IA générative en 2026."}],
    n=5,
    scorer=length_scorer,
    max_tokens=300
)

print("Meilleure réponse :")
print(candidates[0]["content"])
print(f"Score : {candidates[0]['score']:.2f}")

Comparer deux prompts sur un échantillon

Le deuxième usage relève de la méthode plutôt que du produit. Quand vous hésitez entre deux formulations de prompt, comparer une réponse à une réponse ne prouve rien : la variance du modèle suffit à expliquer l’écart. En générant N réponses pour chaque version et en mesurant longueur moyenne et taux de réponses distinctes, vous obtenez un début de preuve. Une diversité de 1.0 sur un prompt censé produire un format stable est un signal d’alarme, pas une bonne nouvelle.

def ab_test_prompts(client, prompt_a: str, prompt_b: str, n: int = 5):
    """Compare deux prompts en générant N réponses pour chacun."""
    results = {}

    for label, prompt in [("A", prompt_a), ("B", prompt_b)]:
        response = client.chat.complete(
            model="ministral-3b-latest",
            messages=[{"role": "user", "content": prompt}],
            n=n,
            temperature=0.8,
            max_tokens=200
        )

        texts = [c.message.content for c in response.choices]
        avg_length = sum(len(t) for t in texts) / len(texts)
        unique_ratio = len(set(texts)) / len(texts)

        results[label] = {
            "avg_length": round(avg_length),
            "diversity": round(unique_ratio, 2),
            "sample": texts[0][:150]
        }

    return results

# Test
results = ab_test_prompts(
    client,
    "Résumez les avantages de Python.",
    "Listez les 3 principaux avantages de Python en une phrase chacun."
)

for label, data in results.items():
    print(f"\nPrompt {label} :")
    print(f"  Longueur moyenne : {data['avg_length']} chars")
    print(f"  Diversité        : {data['diversity']}")
    print(f"  Exemple          : {data['sample']}...")

Fiabiliser une classification par vote

Le troisième usage est le plus rentable en production. Sur une tâche de classification, une réponse unique ne vous dit rien de la confiance du modèle : elle est peut-être évidente, peut-être arrachée de justesse entre deux catégories. Générez sept réponses, comptez les votes, et vous obtenez à la fois un label et un taux de confiance exploitable — une classification à 4/7 peut être routée vers une validation humaine, là où un 7/7 passe directement. Le nombre impair évite les égalités.

from collections import Counter

def majority_vote(client, messages, n=7, **kwargs):
    """Classification par vote majoritaire sur N completions."""
    response = client.chat.complete(
        model="ministral-3b-latest",
        messages=messages,
        n=n,
        temperature=0.7,
        max_tokens=20,
        **kwargs
    )

    votes = [c.message.content.strip().upper() for c in response.choices]
    counts = Counter(votes)
    winner, count = counts.most_common(1)[0]
    confidence = count / n

    return {
        "result": winner,
        "confidence": round(confidence, 2),
        "votes": dict(counts),
        "n": n
    }

# Classification de sentiment
result = majority_vote(
    client,
    messages=[
        {"role": "system", "content": "Classifiez le sentiment : POSITIF, NÉGATIF ou NEUTRE. Répondez en un seul mot."},
        {"role": "user", "content": "Le produit est correct mais la livraison était très lente."}
    ],
    n=7
)

print(f"Résultat  : {result['result']}")
print(f"Confiance : {result['confidence']:.0%}")
print(f"Votes     : {result['votes']}")

Quand utiliser n > 1

Ce paramètre ne se justifie pas partout : sur un trafic standard, chaque completion supplémentaire est un coût de sortie sans contrepartie. Le tableau ci-dessous résume les valeurs qui se défendent selon le scénario.

Points clés à retenir

• Le paramètre n génère plusieurs réponses en un seul appel API
• Les tokens d’entrée sont facturés une seule fois, les tokens de sortie sont multipliés par N
• Tous les modèles ne supportent pas n > 1 — vérifiez la compatibilité
• Le vote majoritaire améliore la fiabilité des classifications
• Le best-of-N sélectionne la meilleure réponse selon un critère mesurable
• Utilisez une température élevée avec n > 1 pour maximiser la diversité des réponses