Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Grounding: Förankra svar i fakta

Lektion 8 av 16 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Grounding: Förankra svar i fakta
  2. Varför grounding är avgörande
  3. Teknik 1: Explicit kontext
  4. Teknik 2: Obligatoriska citat
  5. Teknik 3: Verifiering efter generering
  6. Teknik 4: Defensiv anti-hallucinations-prompting
  7. Kombinera med API-verktyg
  8. Viktiga punkter

Lektionen uppdaterad 3 november 2026 baserat på OpenAI:s dokumentation: temperature och top_p accepteras endast med ett resonemangsarbete på none, medan GPT-5.6-modeller resonerar som standard (medium). Anrop som ställer in dessa parametrar måste därför specificera reasoning={"effort": "none"} (Responses API) eller reasoning_effort="none" (Chat Completions). Källor: Using GPT-6 · GPT-5.6 Terra.

Grounding: Förankra svar i fakta

Grounding begränsar modellen till att basera sina svar enbart på data du tillhandahåller, snarare än på dess interna kunskap. Det är ditt första försvar mot hallucinationer och ett icke-förhandlingsbart krav så snart en applikation lämnar prototypstadiet. En supportassistent som hittar på en avtalsklausul gör inte ett charmigt misstag: den binder juridiskt ditt företag gentemot kunden som läste det.

Varför grounding är avgörande

LLM:er genererar statistiskt sannolik text, vilket inte nödvändigtvis överensstämmer med faktiskt korrekt text. Utan grounding kan en modell fabricera citat, statistik eller tekniska referenser som låter helt trovärdiga: ett versionsnummer som aldrig har existerat, en trovärdig men falsk ångerfrist, eller ett parameternamn hittat på ur tomma luften. Inget i formuleringen avslöjar fabriceringen, vilket är precis vad som gör fenomenet farligt i produktion. Ju bättre skriven responsen är, desto mindre sannolikt är det att användaren verifierar den, och desto högre blir den juridiska och reputationsmässiga risken.

Teknik 1: Explicit kontext

Den enklaste metoden är också den mest robusta: injicera källtexten i prompten och förbjud modellen att gå bortom den. Dina instruktioner måste innehålla tre element: en begränsning till det tillhandahållna dokumentet, den exakta frasen som ska användas när information saknas, och ett krav på att citera det stycke som använts. Testa resultatet på ett gränsfall: en återbetalningsbegäran efter 45 dagar måste utlösa regeln om 50 % partiell återbetalning, inte det tillmötesgående svar kunden hoppas få höra.

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: Obligatoriska citat

Nästa nivå kräver en referens för varje påstående som görs. Detta har en dubbel effekt. Svaret blir verifierbart för användaren, som kan spåra det tillbaka till det ursprungliga stycket istället för att lita på ditt ord. Och modellen censurerar sig själv gällande påståenden den inte kan koppla till någon källa, eftersom instruktionen uttryckligen säger åt den att utelämna dem snarare än att leverera dem utan referens. Att numrera dokumenten i kontexten, som funktionen nedan gör, gör också citaten användbara i ditt gränssnitt: “[Document 2]” kan bli en klickbar länk till rätt 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: Verifiering efter generering

De två första teknikerna minskar risken utan att någonsin eliminera den helt. För kritiska fall, lägg till ett andra steg: ett dedikerat anrop som bryter ner svaret i elementära påståenden och kontrollerar var och en mot källorna. Principen är densamma som vid kodgranskning – författaren läser sitt eget arbete dåligt, medan ett färskt par ögon läser det mycket bättre – och det fungerar här av samma anledning, eftersom verifieraren inte har producerat texten den granskar. Att ställa in temperaturen på 0,0 är inte en detalj: en verifierare måste vara så reproducerbar som möjligt, annars vet du inte om ett ändrat omdöme kommer från svaret eller modellens humör.

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

Vissa formuleringar minskar hallucinationer avsevärt, och de är inte utbytbara: var och en adresserar ett distinkt symptom. Den explicita formuleringen tillåter helt enkelt modellen att medge okunnighet, vilket ofta räcker. Den bestraffande approachen rangordnar fel mot varandra, användbart när man står inför en modell som spontant föredrar att säga vad som helst framför ingenting. Den strukturella approachen lyfter fram osäkerhet i själva utdata, värdefullt när ditt gränssnitt behöver visuellt skilja på vad som är säkert från vad som är härlett. Slutligen avgränsar begränsningsapproachen källan med taggar, vilket fungerar särskilt bra när den injicerade kontexten är voluminös och gränsen mellan dokument och instruktion riskerar att suddas ut.

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 används korrekt reducerar dessa formuleringar hallucinationer med 60 till 80 %. Du måste dock observera detta i din egen miljö snarare än att lita på ett genomsnitt: grounding-frekvensen beräknas genom att spela upp verifiering på en batch av svar och aggregera de erhållna poängen.

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

Kombinera med API-verktyg

OpenAI API erbjuder två inbyggda verktyg som sparar dig från att bygga ditt eget hämtningsskikt. File Search bläddrar igenom dokument du har laddat upp och injicerar automatiskt relevanta utdrag i kontexten. Web Search förankrar svar i färska webbresultat, vilket hjälper när ämnet utvecklas snabbare än din dokumentbas. I båda fallen förblir begränsningsinstruktioner avgörande: verktyget hanterar framtagandet av materialet, men din prompt – och endast din prompt – förbjuder modellen att avvika från 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ätt nu hela kedjan på prov med ett internt företagsdokument – en FAQ, användarvillkor, teknisk dokumentation, det spelar ingen roll så länge det är på riktigt. Bygg den grounded assistenten med explicit kontext, fråga den med tio frågor där tre avsiktligt täcker punkter som saknas i dokumentet, och verifiera att den vägrar dessa tre istället för att utsmycka dem. Lägg sedan till verifiering efter generering och mät din faktiska grounding-frekvens: det är denna siffra, inte det förtroende du har för din prompt, som avgör om assistenten är redo för produktion.

Viktiga punkter

  • Grounding är avgörande för varje professionell applikation
  • Injicera källkontext direkt i prompten och tillämpa citeringskrav
  • Verifiera grounding efter generering för kritiska fall
  • Defensiva formuleringar reducerar hallucinationer med 60 till 80 %
  • Använd temperature=0.0–0.1 för att maximera troheten mot källorna