Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Grounding: Ancrer les réponses dans les faits

Lezione 8 di 16 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. Grounding : Ancrer les réponses dans les faits
  2. Pourquoi le grounding est essentiel
  3. Technique 1 : Contexte explicite
  4. Technique 2 : Citations obligatoires
  5. Technique 3 : Vérification post-génération
  6. Technique 4 : Prompting défensif anti-hallucination
  7. Combinaison avec les outils API
  8. Punti chiave

Leçon mise à jour le 3 novembre 2026 selon la documentation OpenAI : temperature et top_p ne sont acceptés qu’avec un effort de raisonnement de none, tandis que les modèles GPT-5.6 raisonnent par défaut (medium). Les appels définissant ces paramètres doivent donc spécifier reasoning={"effort": "none"} (API Responses) ou reasoning_effort="none" (Chat Completions). Sources : Using GPT-6 · GPT-5.6 Terra.

Grounding : Ancrer les réponses dans les faits

Le grounding contraint le modèle à baser ses réponses uniquement sur les données que tu fournis, plutôt que sur ses connaissances internes. C’est ta première ligne de défense contre les hallucinations et une exigence non négociable dès qu’une application quitte le stade du prototype. Un assistant support qui invente une clause contractuelle ne fait pas une erreur mignonne : il engage juridiquement ton entreprise vis-à-vis du client qui l’a lue.

Pourquoi le grounding est essentiel

Les LLM génèrent du texte statistiquement probable, ce qui ne correspond pas nécessairement à un texte factuellement correct. Sans grounding, un modèle peut fabriquer des citations, des statistiques ou des références techniques qui semblent parfaitement plausibles : un numéro de version qui n’a jamais existé, un délai de rétractation crédible mais faux, ou un nom de paramètre inventé de toutes pièces. Rien dans la formulation ne trahit la fabrication, et c’est précisément ce qui rend le phénomène dangereux en production. Plus la réponse est bien rédigée, moins l’utilisateur est susceptible de la vérifier, et plus le risque juridique et réputationnel augmente.

Technique 1 : Contexte explicite

La méthode la plus simple est aussi la plus robuste : injecter le texte source dans le prompt et interdire au modèle d’aller au-delà. Tes instructions doivent inclure trois éléments : une restriction au document fourni, la phrase de repli exacte à utiliser lorsque l’information est manquante, et l’obligation de citer le passage utilisé. Teste le résultat sur un cas limite : une demande de remboursement à 45 jours doit déclencher la règle de remboursement partiel à 50 %, et non la réponse accommodante que le client espère entendre.

from openai import OpenAI

client = OpenAI()

document = """
Acme Corp Refund Policy (v3.2, January 2026):
- Full refund within 30 days of purchase
- Partial refund (50%) between 30 and 60 days
- No refund after 60 days
- Customized products are non-refundable
- Refunds are processed within 5 business days
"""

system = """You are an Acme Corp customer support assistant.

STRICT RULES:
- Answer ONLY based on the document provided below
- If the answer is not in the document, say "I do not have
  this information in our current policy"
- NEVER make assumptions beyond the document
- Quote the relevant passage in quotation marks

REFERENCE DOCUMENT:
""" + document

response = client.responses.create(
    model="gpt-5.6-terra",
    reasoning={"effort": "none"},  # temperature requires effort none
    instructions=system,
    input="I would like a refund for an item purchased 45 days ago.",
    temperature=0.1
)

Technique 2 : Citations obligatoires

Le niveau supérieur exige une référence pour chaque affirmation faite. Cela a un double effet. La réponse devient vérifiable par l’utilisateur, qui peut la retracer jusqu’au passage original au lieu de te faire confiance sur parole. Et le modèle s’autocensure sur les affirmations qu’il ne peut rattacher à aucune source, puisque l’instruction lui dit explicitement de les omettre plutôt que de les livrer sans référence. Numéroter les documents dans le contexte, comme le fait la fonction ci-dessous, rend également les citations utilisables dans ton interface : « [Document 2] » peut devenir un lien cliquable vers le fichier correct.

system_with_citations = """You are a research assistant.

For every assertion in your response, add a reference
to the source passage in brackets, for example: [Source: paragraph 3].

If you cannot cite a source passage, do not include the assertion.

Response format:
1. Response with inline citations
2. "Sources Used" section with exact excerpts"""

def reponse_grounded(question: str, documents: list[str]) -> str:
    """Generate a grounded response with 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.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        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

Les deux premières techniques réduisent le risque sans jamais l’éliminer. Pour les cas critiques, ajoute un second passage : un appel dédié qui décompose la réponse en affirmations élémentaires et vérifie chacune d’elles contre les sources. Le principe est le même que pour la revue de code : l’auteur lit mal son propre travail, tandis qu’une paire d’yeux neufs le lit beaucoup mieux, et cela fonctionne ici pour la même raison, car le vérificateur n’a pas produit le texte qu’il examine. Définir la température à 0,0 n’est pas un détail : un vérificateur doit être aussi reproductible que possible, sinon tu ne sauras pas si un verdict changeant vient de la réponse ou de l’humeur du modèle.

def verifier_grounding(reponse: str, sources: str) -> dict:
    """Verify whether a response is properly grounded in the sources."""
    verification_prompt = f"""Analyze whether this response is faithful to the sources.

RESPONSE TO VERIFY:
{reponse}

SOURCES:
{sources}

For each assertion in the response, indicate:
- The assertion
- Whether it is supported by the sources (YES/NO)
- The corresponding source passage (or "None")

End with a grounding score: X supported assertions / Y total."""

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=verification_prompt,
        temperature=0.0
    )
    return {"verification": response.output_text}

Technique 4 : Prompting défensif anti-hallucination

Certaines formulations réduisent considérablement les hallucinations, et elles ne sont pas interchangeables : chacune traite un symptôme distinct. La formulation explicite permet simplement au modèle d’admettre son ignorance, ce qui suffit souvent. L’approche pénalisante hiérarchise les erreurs les unes par rapport aux autres, utile face à un modèle qui préfère spontanément dire n’importe quoi plutôt que rien. L’approche structurelle fait ressortir l’incertitude dans la sortie elle-même, précieuse lorsque ton interface doit distinguer visuellement ce qui est certain de ce qui est déduit. Enfin, l’approche par contrainte délimite la source avec des balises, ce qui fonctionne particulièrement bien lorsque le contexte injecté est volumineux et que la frontière entre document et instruction risque de s’estomper.

defensive_prompts = {
    "explicit": "If you do not know the answer, say 'I don't know'.",

    "penalizing": "It is FORBIDDEN to invent information. "
                  "An 'I don't know' response is always preferable "
                  "to incorrect information.",

    "structural": "For each point in your response, indicate your confidence level: "
                  "[CERTAIN] based on the document, "
                  "[PROBABLE] inferred from context, [UNCERTAIN] unverified.",

    "constrained": "Answer using EXCLUSIVELY the information "
                   "between the <source> and </source> tags. "
                   "Any external information is forbidden."
}

Lorsqu’elles sont utilisées correctement, ces formulations réduisent les hallucinations de 60 à 80 %. Cependant, tu dois observer cela dans ton propre environnement plutôt que de te fier à une moyenne : le taux de grounding se calcule en rejouant la vérification sur un lot de réponses et en agrégeant les scores obtenus.

def taux_grounding(reponses: list[dict]) -> float:
    """Calculate the grounding rate across a set of responses.

    Each response is a dict with 'reponse' and 'sources'.
    """
    scores = []
    for item in reponses:
        verif = verifier_grounding(item["reponse"], item["sources"])
        # Extract the score (adapt to output format)
        scores.append(verif)
    return scores

Combinaison avec les outils API

L’API OpenAI propose deux outils natifs qui t’évitent de construire ta propre couche de récupération. File Search parcourt les documents que tu as téléchargés et injecte automatiquement les extraits pertinents dans le contexte. Web Search ancre les réponses dans des résultats web récents, ce qui aide lorsque le sujet évolue plus vite que ta base documentaire. Dans les deux cas, les instructions de restriction restent essentielles : l’outil se charge d’apporter le matériel, mais c’est ton prompt — et lui seul — qui interdit au modèle de s’en écarter.

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions="Answer based only on the provided documents.",
    input="What are the warranty conditions?",
    tools=[{"type": "file_search"}]
)

Mets maintenant toute la chaîne à l’épreuve sur un document interne de l’entreprise — une FAQ, des conditions générales d’utilisation, une documentation technique, peu importe tant que c’est réel. Construis l’assistant grounded en utilisant un contexte explicite, interroge-le avec dix questions dont trois portent délibérément sur des points absents du document, et vérifie qu’il refuse ces trois-là au lieu de broder. Ajoute ensuite la vérification post-génération et mesure ton taux de grounding réel : c’est ce chiffre, et non la confiance que tu places dans ton prompt, qui décide si l’assistant est prêt pour la production.

Punti chiave

  • Le grounding est essentiel pour toute application professionnelle
  • Injecte le contexte source directement dans le prompt et impose les citations
  • Vérifie le grounding après la génération pour les cas critiques
  • Les formulations défensives réduisent les hallucinations de 60 à 80 %
  • Utilise temperature=0,0-0,1 pour maximiser la fidélité aux sources