Grounding : ancrer les réponses dans des faits

Le grounding consiste à contraindre le modèle à baser ses réponses uniquement sur des données fournies, plutôt que sur ses connaissances internes. C’est la première ligne de défense contre les hallucinations et une exigence fondamentale pour toute application professionnelle.

Pourquoi le grounding est indispensable

Les LLMs génèrent du texte statistiquement probable, pas nécessairement factuellement correct. Sans grounding, un modèle peut inventer des citations, des statistiques ou des références techniques qui semblent plausibles mais sont fausses. En production, cela crée un risque juridique et de réputation.

Technique 1 : contexte explicite

La méthode la plus simple et la plus fiable. Vous injectez le texte source dans le prompt et demandez au modèle de s’y limiter :

from openai import OpenAI

client = OpenAI()

document = """
Politique de remboursement Acme Corp (v3.2, janvier 2026) :
- Remboursement intégral dans les 30 jours suivant l'achat
- Remboursement partiel (50%) entre 30 et 60 jours
- Aucun remboursement après 60 jours
- Les produits personnalisés ne sont pas remboursables
- Le remboursement est effectué sous 5 jours ouvrés
"""

system = """Tu es un assistant de support client Acme Corp.

RÈGLES STRICTES :
- Réponds UNIQUEMENT à partir du document fourni ci-dessous
- Si la réponse n'est pas dans le document, dis "Je n'ai pas
  cette information dans notre politique actuelle"
- Ne fais JAMAIS de supposition au-delà du document
- Cite le passage pertinent entre guillemets

DOCUMENT DE RÉFÉRENCE :
""" + document

response = client.responses.create(
    model="gpt-5.3",
    instructions=system,
    input="Je voudrais me faire rembourser un article acheté il y a 45 jours.",
    temperature=0.1
)

Technique 2 : citations obligatoires

Forcez le modèle à citer ses sources pour chaque affirmation :

system_with_citations = """Tu es un assistant de recherche.

Pour chaque affirmation dans ta réponse, ajoute une référence
au passage source entre crochets, par exemple : [Source: paragraphe 3].

Si tu ne peux pas citer un passage source, n'inclus pas l'affirmation.

Format de réponse :
1. Réponse avec citations inline
2. Section "Sources utilisées" avec les extraits exacts"""

def reponse_grounded(question: str, documents: list[str]) -> str:
    """Génère une réponse ancrée avec citations."""
    context = "\n\n---\n\n".join(
        f"[Document {i+1}]\n{doc}"
        for i, doc in enumerate(documents)
    )

    response = client.responses.create(
        model="gpt-5.3",
        instructions=system_with_citations + f"\n\nDOCUMENTS :\n{context}",
        input=question,
        temperature=0.1
    )
    return response.output_text

Technique 3 : vérification post-génération

Générez la réponse, puis vérifiez qu’elle est bien ancrée dans les sources :

def verifier_grounding(reponse: str, sources: str) -> dict:
    """Vérifie si une réponse est bien ancrée dans les sources."""
    verification_prompt = f"""Analyse si cette réponse est fidèle aux sources.

RÉPONSE À VÉRIFIER :
{reponse}

SOURCES :
{sources}

Pour chaque affirmation de la réponse, indique :
- L'affirmation
- Si elle est supportée par les sources (OUI/NON)
- Le passage source correspondant (ou "Aucun")

Termine par un score de grounding : X affirmations supportées / Y total."""

    response = client.responses.create(
        model="gpt-5.3",
        input=verification_prompt,
        temperature=0.0
    )
    return {"verification": response.output_text}

Technique 4 : prompt défensif anti-hallucination

Certaines formulations réduisent significativement les hallucinations :

defensive_prompts = {
    "explicite": "Si tu ne connais pas la réponse, dis 'Je ne sais pas'.",

    "penalisant": "Il est INTERDIT d'inventer des informations. "
                  "Une réponse 'je ne sais pas' est toujours préférable "
                  "à une information incorrecte.",

    "structurel": "Pour chaque point de ta réponse, indique ton niveau "
                  "de confiance : [CERTAIN] basé sur le document, "
                  "[PROBABLE] déduit du contexte, [INCERTAIN] non vérifié.",

    "contrainte": "Réponds en utilisant EXCLUSIVEMENT les informations "
                  "entre les balises <source> et </source>. "
                  "Toute information extérieure est interdite."
}

Mesurer le taux de grounding

def taux_grounding(reponses: list[dict]) -> float:
    """Calcule le taux de grounding sur un ensemble de réponses.

    Chaque réponse est un dict avec 'reponse' et 'sources'.
    """
    scores = []
    for item in reponses:
        verif = verifier_grounding(item["reponse"], item["sources"])
        # Extraire le score (à adapter au format de sortie)
        scores.append(verif)
    return scores

Combinaison avec les outils de l’API

L’API OpenAI propose des outils natifs pour le grounding :

File Search : cherche automatiquement dans vos documents uploadés
Web Search : ancre les réponses dans des résultats web récents

response = client.responses.create(
    model="gpt-5.3",
    instructions="Réponds en te basant uniquement sur les documents fournis.",
    input="Quelles sont les conditions de garantie ?",
    tools=[{"type": "file_search"}]
)

Mise en pratique

Prenez un document interne de votre entreprise (FAQ, CGV, documentation)
Créez un assistant groundé avec la technique du contexte explicite
Testez avec 10 questions dont 3 hors du document
Vérifiez que le modèle refuse de répondre aux questions hors scope
Ajoutez la vérification post-génération et mesurez le taux de grounding

Points clés à retenir

Le grounding est indispensable pour toute application professionnelle
Injectez le contexte source directement dans le prompt
Forcez les citations pour chaque affirmation
Vérifiez le grounding après génération pour les cas critiques
Les formulations défensives réduisent les hallucinations de 60 à 80 %
Utilisez temperature=0.0-0.1 pour maximiser la fidélité aux sources