Few-shot via l'API

Enseigner par l’exemple

Le few-shot prompting consiste à fournir au modèle quelques exemples d’entrées et de sorties avant de lui soumettre la vraie requête. Via l’API Chat Completions, ces exemples n’occupent pas une place à part : ils sont injectés dans l’historique de conversation sous forme de paires de messages user/assistant factices, comme si l’échange avait réellement eu lieu. Le modèle ne fait pas la différence entre un tour de parole authentique et un tour fabriqué par vos soins, et c’est précisément ce qui rend la technique si efficace. Sans passer par le fine-tuning, c’est le moyen le plus fiable d’obtenir un format de sortie précis.

Le principe tient en une inversion : au lieu de décrire longuement le format attendu dans le system prompt, vous le montrez. Sur une tâche de classification de sentiment, trois exemples suffisent à faire comprendre au modèle qu’il doit répondre par un label en majuscules et rien d’autre.

from mistralai import Mistral
import os

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

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "Vous classifiez le sentiment des avis clients."
        },
        # Exemple 1
        {"role": "user", "content": "Avis : Livraison rapide, produit conforme. Très satisfait !"},
        {"role": "assistant", "content": "POSITIF"},
        # Exemple 2
        {"role": "user", "content": "Avis : Colis arrivé abîmé, service client injoignable."},
        {"role": "assistant", "content": "NÉGATIF"},
        # Exemple 3
        {"role": "user", "content": "Avis : Le produit est correct mais un peu cher pour ce que c'est."},
        {"role": "assistant", "content": "MITIGÉ"},
        # Vraie requête
        {"role": "user", "content": "Avis : Excellente qualité, je recommande vivement cette boutique."}
    ],
    temperature=0.0
)

print(response.choices[0].message.content)
# POSITIF

Le modèle a extrait le pattern — avis en entrée, label en majuscules en sortie — puis l’a appliqué à la nouvelle entrée. Aucune consigne de format n’a été écrite noir sur blanc : les trois paires ont suffi.

Combien d’exemples fournir

Le nombre d’exemples dépend de la difficulté de la tâche, et il obéit à des rendements décroissants nets.

Au-delà de dix exemples, vous consommez beaucoup de tokens d’entrée sans gain proportionnel : chaque requête traîne le même bloc d’exemples, facturé à chaque appel. À ce stade, le fine-tuning devient l’option économiquement raisonnable.

Deux usages qui changent la sortie

L’extraction d’entités nommées illustre bien ce que les exemples apportent en plus d’un schéma décrit en toutes lettres. Ils fixent non seulement les clés du JSON, mais aussi le traitement des catégories vides — le second exemple montre explicitement des listes vides plutôt qu’un champ absent, ce qui évite au parseur de tomber sur une structure inattendue.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "Extrayez les entités nommées au format JSON."
        },
        # Exemple 1
        {
            "role": "user",
            "content": "Pierre Martin a rejoint Google France à Paris en janvier 2025."
        },
        {
            "role": "assistant",
            "content": '{"personnes": ["Pierre Martin"], "organisations": ["Google France"], "lieux": ["Paris"], "dates": ["janvier 2025"]}'
        },
        # Exemple 2
        {
            "role": "user",
            "content": "La conférence VivaTech organisée par Publicis se tiendra en juin."
        },
        {
            "role": "assistant",
            "content": '{"personnes": [], "organisations": ["Publicis"], "lieux": [], "dates": ["juin"]}'
        },
        # Vraie requête
        {
            "role": "user",
            "content": "Sophie Leclerc, directrice de Mistral AI, a annoncé un partenariat avec Microsoft lors du salon AI Paris le 15 mars 2026."
        }
    ],
    temperature=0.0
)

import json
result = json.loads(response.choices[0].message.content)
print(json.dumps(result, indent=2, ensure_ascii=False))

La transformation de texte relève d’une autre logique : ce n’est plus un schéma que vous transmettez, mais un registre de langue. Un seul exemple de vulgarisation — architecture transformer traduite en phrase accessible — enseigne au modèle le niveau d’abstraction souhaité, ce qu’aucune consigne du type « soyez pédagogique » n’obtiendrait avec cette précision.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "Transformez le texte technique en résumé grand public."
        },
        # Exemple
        {
            "role": "user",
            "content": "Le modèle utilise une architecture transformer encoder-décoder avec attention multi-têtes et normalisation RMS pré-couche."
        },
        {
            "role": "assistant",
            "content": "Ce système d'IA utilise une technologie avancée qui lui permet de comprendre et générer du texte en analysant les relations entre les mots de manière parallèle et efficace."
        },
        # Vraie requête
        {
            "role": "user",
            "content": "L'API utilise le nucleus sampling avec top_p pour tronquer la distribution de probabilité des tokens candidats lors de la génération auto-régressive."
        }
    ]
)

print(response.choices[0].message.content)

Few-shot dynamique

En production, un jeu d’exemples figé finit par desservir la moitié des requêtes : les exemples techniques encombrent inutilement une question de facturation. La solution consiste à constituer une base d’exemples par catégorie, puis à n’injecter que ceux qui correspondent au contexte détecté en amont. La fonction ci-dessous assemble le system prompt, les exemples de la catégorie et la question réelle dans le bon ordre.

# Base d'exemples
EXAMPLES = {
    "technique": [
        {"user": "Comment configurer un VPN ?", "assistant": "Voici les étapes..."},
        {"user": "Mon serveur renvoie une erreur 502.", "assistant": "L'erreur 502..."},
    ],
    "commercial": [
        {"user": "Quels sont vos tarifs ?", "assistant": "Nos offres commencent à..."},
        {"user": "Y a-t-il une période d'essai ?", "assistant": "Oui, 14 jours..."},
    ],
    "facturation": [
        {"user": "Je n'ai pas reçu ma facture.", "assistant": "Vérifiez votre..."},
        {"user": "Comment changer de plan ?", "assistant": "Rendez-vous dans..."},
    ]
}

def build_messages(category: str, user_question: str) -> list:
    """Construit les messages avec few-shot dynamique."""
    messages = [
        {"role": "system", "content": "Assistant de support technique."}
    ]

    # Ajouter les exemples de la catégorie
    for ex in EXAMPLES.get(category, []):
        messages.append({"role": "user", "content": ex["user"]})
        messages.append({"role": "assistant", "content": ex["assistant"]})

    # Ajouter la vraie question
    messages.append({"role": "user", "content": user_question})
    return messages

# Utilisation
messages = build_messages("technique", "Mon déploiement Docker échoue.")
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages
)

Ce qui fait la qualité d’un jeu d’exemples

Un few-shot rate surtout par manque de diversité : trois avis franchement positifs et le modèle classera tout en POSITIF. Couvrez les cas normaux et les cas limites, y compris un exemple de ce que le modèle ne doit PAS faire — montrer un refus est souvent plus efficace que l’interdire par une règle. La cohérence de forme compte tout autant : si un exemple renvoie POSITIF et un autre Positif, vous venez d’enseigner au modèle que la casse est libre.

Deux réflexes complètent l’exercice. Comptez les tokens, puisque chaque exemple est facturé en entrée à chaque appel — un jeu de huit paires devient vite le poste de coût principal d’une API de classification à fort volume. Et testez d’abord sans exemples : les modèles récents traitent en zero-shot des tâches qui exigeaient cinq exemples il y a deux ans, et vous économiserez ce que vous n’aurez pas eu besoin d’écrire.

Points clés à retenir

• Le few-shot injecte des paires user/assistant factices avant la vraie requête
• 3-5 exemples suffisent pour la plupart des tâches de classification et d’extraction
• Utilisez temperature=0 avec le few-shot pour maximiser la cohérence
• Le few-shot dynamique sélectionne les exemples pertinents en fonction du contexte
• Au-delà de 10 exemples, envisagez le fine-tuning plutôt que le few-shot