Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Grounding: Forankre svar i fakta

Lektion 8 af 16 Opdateret 3. november 2026 Udvikler
På denne side
  1. Grounding: Forankre svar i fakta
  2. Hvorfor grounding er afgørende
  3. Teknik 1: Eksplicit kontekst
  4. Teknik 2: Obligatoriske citationer
  5. Teknik 3: Verifikation efter generering
  6. Teknik 4: Defensiv anti-hallucinations-prompting
  7. Kombination med API-værktøjer
  8. Vigtige pointer

Lektion opdateret 3. november 2026 baseret på OpenAI-dokumentation: temperature og top_p accepteres kun med en ræsonneringsindsats på none, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Kald, der sætter disse parametre, skal derfor specificere reasoning={"effort": "none"} (Responses API) eller reasoning_effort="none" (Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.

Grounding: Forankre svar i fakta

Grounding begrænser modellen til udelukkende at basere sine svar på de data, du leverer, frem for på dens interne viden. Det er dit første forsvarsværk mod hallucinationer og et ufravigeligt krav, så snart en applikation forlader prototypestadiet. En supportassistent, der opfinder en kontraktklausul, begår ikke en uskyldig fejl: den binder juridisk din virksomhed til den kunde, der har læst den.

Hvorfor grounding er afgørende

LLM’er genererer statistisk sandsynlig tekst, hvilket ikke nødvendigvis stemmer overens med faktuelt korrekt tekst. Uden grounding kan en model fabricere citater, statistikker eller tekniske referencer, der lyder fuldstændig troværdige: et versionsnummer, der aldrig har eksisteret, en plausibel men falsk betænkningstid, eller et parameternavn fundet på ud af den blå luft. Intet i formuleringen afslører fabrikationen, hvilket netop er det, der gør fænomenet farligt i produktion. Jo bedre skrevet svaret er, desto mindre sandsynligt er det, at brugeren verificerer det, og desto højere bliver den juridiske og omdømmemæssige risiko.

Teknik 1: Eksplicit kontekst

Den enkleste metode er også den mest robuste: injicér kildeteksten i prompten og forbød modellen at gå ud over den. Dine instrukser skal indeholde tre elementer: en begrænsning til det medfølgende dokument, den nøjagtige fallback-sætning, der skal bruges, når information mangler, og et krav om at citere det anvendte afsnit. Test resultatet på et grænsetilfælde: en anmodning om refusion efter 45 dage skal udløse reglen om 50 % delvis refusion, ikke det imødekommende svar, som kunden håber på at høre.

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
)

Teknik 2: Obligatoriske citationer

Næste niveau kræver en reference for hver eneste påstand, der fremsættes. Dette har en dobbelt effekt. Svaret bliver verificerbart for brugeren, som kan spore det tilbage til det originale afsnit i stedet for blot at tage dit ord for det. Og modellen censurerer sig selv omkring påstande, den ikke kan knytte til nogen kilde, da instruktionen eksplicit beder den om at udelade dem frem for at fremsætte dem uden reference. At nummerere dokumenterne i konteksten, som funktionen nedenfor gør, gør også citationerne brugbare i din grænseflade: „[Dokument 2]” kan blive til et klikbart link til den korrekte fil.

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

Teknik 3: Verifikation efter generering

De to første teknikker reducerer risikoen uden nogensinde at eliminere den helt. I kritiske tilfælde skal du tilføje et andet gennemløb: et dedikeret kald, der nedbryder svaret i elementære påstande og tjekker hver enkelt mod kilderne. Princippet er det samme som ved code review – forfatteren læser sit eget værk dårligt, mens et friskt par øjne læser det meget bedre – og det virker her af samme årsag, da verificatoren ikke har produceret den tekst, den undersøger. At sætte temperaturen til 0,0 er ikke en detalje: en verifikator skal være så reproducerbar som muligt, ellers ved du ikke, om en ændret dom skyldes svaret eller modellens lune.

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}

Teknik 4: Defensiv anti-hallucinations-prompting

Visse formuleringer reducerer hallucinationer markant, og de er ikke udskiftelige: hver især adresserer et distinkt symptom. Den eksplicitte formulering tillader simpelthen modellen at indrømme uvidenhed, hvilket ofte er nok. Den straffende tilgang rangerer fejl i forhold til hinanden, hvilket er nyttigt, når man står over for en model, der spontant foretrækker at sige hvad som helst frem for ingenting. Den strukturelle tilgang fremhæver usikkerhed i selve outputtet, hvilket er værdifuldt, når din grænseflade visuelt skal skelne mellem det, der er sikkert, og det, der er infereret. Endelig afgrænser begrænsningstilgangen kilden med tags, hvilket fungerer særligt godt, når den injicerede kontekst er voluminøs, og grænsen mellem dokument og instruktion risikerer at flyde sammen.

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

Når de bruges korrekt, reducerer disse formuleringer hallucinationer med 60 til 80 %. Du skal dog observere dette i dit eget miljø frem for at stole på et gennemsnit: grounding-raten beregnes ved at afspille verifikation på en batch af svar og aggregere de opnåede scorer.

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

Kombination med API-værktøjer

OpenAI API tilbyder to indbyggede værktøjer, der sparer dig for at bygge dit eget retrieval-lag. File Search gennemsøger dokumenter, du har uploadet, og injicerer automatisk relevante uddrag i konteksten. Web Search forankrer svar i recente webresultater, hvilket hjælper, når emnet udvikler sig hurtigere end dit dokumentgrundlag. I begge tilfælde forbliver begrænsende instrukser essentielle: værktøjet håndterer indhentningen af materialet, men det er din prompt – og kun din prompt – der forbyder modellen at afvige fra det.

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

Sæt nu hele kæden på prøve med et internt virksomhedsdokument – en FAQ, servicevilkår, teknisk dokumentation; det er ligegyldigt, så længe det er ægte. Byg den forankrede assistent ved hjælp af eksplicit kontekst, spørg den med ti spørgsmål, hvor tre bevidst dækker punkter, der mangler i dokumentet, og verificér, at den afviser disse tre i stedet for at pynte på dem. Tilføj derefter verifikation efter generering og mål din faktiske grounding-rate: det er dette tal, ikke den tillid, du har til din prompt, der afgør, om assistenten er klar til produktion.

Vigtige pointer

  • Grounding er afgørende for enhver professionel applikation
  • Injicér kildekontekst direkte i prompten og håndhæv citationer
  • Verificér grounding efter generering i kritiske tilfælde
  • Defensive formuleringer reducerer hallucinationer med 60 til 80 %
  • Brug temperature=0,0-0,1 for at maksimere troskab mod kilderne