N completions

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

Le paramètre n permet de demander au modèle de générer plusieurs réponses alternatives pour le même prompt en une seule requête API. C’est un outil puissant pour le A/B testing de prompts, la sélection de la meilleure réponse, et l’exploration de l’espace des solutions.

Le paramètre n

Par défaut, n=1 : l’API renvoie une seule réponse. En passant n=5, vous obtenez 5 réponses différentes :

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}")

Facturation

Point important : les tokens d’entrée (prompt) sont facturés une seule fois, mais les tokens de sortie sont facturés pour chaque completion. Avec n=5 et max_tokens=100, vous payez au maximum 500 tokens de sortie :

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}")

Compatibilité des modèles

Tous les modèles Mistral ne supportent pas le paramètre 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é.

Cas d’usage 1 : sélection de la meilleure réponse

Générez plusieurs candidats et sélectionnez le meilleur selon un critère :

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}")

Cas d’usage 2 : A/B testing de prompts

Comparez deux formulations de prompt en générant N réponses pour chacune :

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']}...")

Cas d’usage 3 : consensus par vote majoritaire

Pour les tâches de classification, générez N réponses et prenez le vote majoritaire :

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

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