Grounding: Verankering van antwoorden in feiten
Op deze pagina
Les bijgewerkt op 3 november 2026 op basis van OpenAI-documentatie:
temperatureentop_pworden alleen geaccepteerd met een redeneerinspanning vannone, terwijl GPT-5.6-modellen standaard redeneren (medium). Oproepen die deze parameters instellen, moeten daaromreasoning={"effort": "none"}(Responses API) ofreasoning_effort="none"(Chat Completions) specificeren. Bronnen: Using GPT-6 · GPT-5.6 Terra.
Grounding: Verankering van antwoorden in feiten
Grounding dwingt het model om zijn antwoorden uitsluitend te baseren op de gegevens die u verstrekt, in plaats van op zijn interne kennis. Het is uw eerste verdedigingslinie tegen hallucinaties en een niet-onderhandelbare vereiste zodra een applicatie het prototypestadium verlaat. Een supportassistent die een contractclausule verzint, maakt geen schattige fout: het bindt uw bedrijf juridisch aan de klant die het heeft gelezen.
Waarom grounding essentieel is
LLM’s genereren statistisch waarschijnlijke tekst, wat niet noodzakelijk overeenkomt met feitelijk correcte tekst. Zonder grounding kan een model citaten, statistieken of technische referenties fabriceren die perfect aannemelijk klinken: een versienummer dat nooit heeft bestaan, een geloofwaardige maar valse bedenktijd, of een parameternaam die uit de lucht is gegrepen. Niets in de formulering verraadt de fabricage, en juist dat maakt het fenomeen zo gevaarlijk in productie. Hoe beter de respons is geschreven, hoe minder waarschijnlijk het is dat de gebruiker deze verifieert, en hoe groter het juridische en reputatierisico wordt.
Techniek 1: Expliciete context
De eenvoudigste methode is ook de meest robuuste: injecteer de brontekst in de prompt en verbied het model om daarbuiten te treden. Uw instructies moeten drie elementen bevatten: een beperking tot het verstrekte document, de exacte fallback-zin die moet worden gebruikt wanneer informatie ontbreekt, en de eis om de gebruikte passage te citeren. Test het resultaat op een randgeval: een restitutieverzoek na 45 dagen moet de regel voor 50% gedeeltelijke restitutie activeren, niet het toegeeflijke antwoord dat de klant hoopt te horen.
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
)
Techniek 2: Verplichte citaten
Het volgende niveau vereist een referentie voor elke gedane bewering. Dit heeft een dubbel effect. De respons wordt verifieerbaar voor de gebruiker, die deze kan traceren naar de oorspronkelijke passage in plaats van uw woord aan te nemen. Bovendien censureren modellen zichzelf bij claims die ze niet aan een bron kunnen koppelen, aangezien de instructie hen expliciet opdraagt deze weg te laten in plaats van ze zonder referentie te leveren. Het nummeren van de documenten in de context, zoals de onderstaande functie doet, maakt de citaten ook bruikbaar in uw interface: “[Document 2]” kan een klikbare link naar het juiste bestand worden.
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
Techniek 3: Verificatie na generatie
De eerste twee technieken verminderen het risico zonder het ooit volledig te elimineren. Voeg voor kritieke gevallen een tweede stap toe: een gespecialiseerde oproep die de respons opsplitst in elementaire beweringen en elk daarvan controleert tegen de bronnen. Het principe is hetzelfde als bij code review: de auteur leest zijn eigen werk slecht, terwijl een vers paar ogen het veel beter leest. Dit werkt hier om dezelfde reden, aangezien de verificateur de tekst die hij onderzoekt niet heeft geproduceerd. Het instellen van de temperatuur op 0,0 is geen detail: een verificateur moet zo reproduceerbaar mogelijk zijn, anders weet u niet of een veranderend oordeel voortkomt uit de respons of uit de bui van het model.
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}
Techniek 4: Defensieve anti-hallucinatie prompting
Bepaalde formuleringen verminderen hallucinaties aanzienlijk en zijn niet onderling uitwisselbaar: elk adresseert een ander symptoom. De expliciete formulering stelt het model simpelweg in staat onwetendheid toe te geven, wat vaak genoeg is. De straffende aanpak rangschikt fouten tegenover elkaar, nuttig wanneer u te maken heeft met een model dat spontaan liever iets zegt dan niets. De structurele aanpak brengt onzekerheid naar boven in de output zelf, waardevol wanneer uw interface visueel onderscheid moet maken tussen wat zeker is en wat is afgeleid. Tot slot begrenst de constraint-aanpak de bron met tags, wat bijzonder goed werkt wanneer de geïnjecteerde context omvangrijk is en de grens tussen document en instructie dreigt te vervagen.
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."
}
Wanneer correct gebruikt, verminderen deze formuleringen hallucinaties met 60 tot 80%. U moet dit echter in uw eigen omgeving observeren in plaats van te vertrouwen op een gemiddelde: het grounding-percentage wordt berekend door verificatie opnieuw uit te voeren op een batch responsen en de behaalde scores te aggregeren.
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
Combineren met API-tools
De OpenAI API biedt twee native tools die u besparen een eigen retrieval-laag te bouwen. File Search doorzoekt documenten die u hebt geüpload en injecteert automatisch relevante fragmenten in de context. Web Search verankert antwoorden in recente webresultaten, wat helpt wanneer het onderwerp sneller evolueert dan uw documentbasis. In beide gevallen blijven beperkende instructies essentieel: de tool regelt het aanleveren van het materiaal, maar uw prompt – en alleen uw prompt – verbiedt het model om daarvan af te wijken.
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"}]
)
Stel nu de volledige ketting op de proef met een intern bedrijfsdocument – een FAQ, algemene voorwaarden, technische documentatie, het maakt niet uit zolang het maar echt is. Bouw de grounded assistent met expliciete context, bevraag deze met tien vragen waarvan er drie bewust punten behandelen die afwezig zijn in het document, en verifieer dat het model deze drie weigert in plaats van ze op te smukken. Voeg vervolgens verificatie na generatie toe en meet uw daadwerkelijke grounding-percentage: het is dit cijfer, niet het vertrouwen dat u in uw prompt stelt, dat bepaalt of de assistent klaar is voor productie.
Belangrijkste punten
- Grounding is essentieel voor elke professionele applicatie
- Injecteer broncontext direct in de prompt en dwing citaten af
- Verifieer grounding na generatie voor kritieke gevallen
- Defensieve formuleringen verminderen hallucinaties met 60 tot 80%
- Gebruik temperature=0,0-0,1 om trouw aan de bronnen te maximaliseren