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

Förankra svar i källor och minska hallucinationer

Lektion 10 av 16 Uppdaterad 2 november 2026 Avancerad
På denna sida
  1. Hallucinationsproblemet i produktion
  2. Systemprompten: ditt första försvar
  3. Verifiera förankring efter generering
  4. Identifiera påståenden utanför scope
  5. Bygg en tillitspipeline
  6. Övervaka förankring över tid
  7. Viktiga punkter

Hallucinationsproblemet i produktion

En hallucination är ett faktamässigt felaktigt svar som levereras med samma självförtroende som ett korrekt svar. Det är just detta självförtroende som gör det farligt. En supportchatbot som hittar på en procedur leder användarna vilse; en juridisk assistent som citerar en lag som inte finns utsätter din klient för risk; ett medicinskt verktyg som rekommenderar fel dosering skapar verklig skada. I alla tre fallen signalerar inget i svarsformatet att något är fel.

Förankring (Grounding) hanterar denna risk genom att begränsa modellen till att basera sina svar uteslutande på verifierade källor. Tillsammans med citatsystemet som behandlades i tidigare lektioner skapas ett flerskiktat säkerhetsnät: prompten definierar förväntat beteende, citatparsning möjliggör verifiering, och pipelinen avgör hur svar som misslyckas med kontrollen ska hanteras.

Systemprompten: ditt första försvar

En vag prompt ger en vag förankring. Du måste ange reglerna som en specifikation: definiera källornas omfattning, ange den exakta fras som ska användas när information saknas, förbjud att fylla luckor med allmän kunskap, kräv citat för varje påstående och specificera hur motsägelser mellan källor ska hanteras.

system_prompt = """
You are a specialized documentation assistant.

ABSOLUTE RULES:
1. Answer ONLY using the sources provided via references.
2. If the information is not in the sources, respond:
   "This information is not available in the provided sources."
3. NEVER supplement with your general knowledge.
4. Cite every claim with the corresponding reference.
5. If two sources contradict each other, mention both versions.
"""

Denna prompt garanterar inte noll hallucinationer, och du måste vara tydlig med detta gentemot dina intressenter: den minskar frekvensen avsevärt. Mistral-modeller, som är tränade för förankring, följer dessa instruktioner med hög efterlevnadsgrad. En hög grad är dock inte 100 %, vilket är varför följande steg är nödvändiga.

Verifiera förankring efter generering

Funktionen validate_grounding omvandlar en intuition – “ser detta svar ut att vara källhänvisat?” – till en metrik. Den itererar genom svarsbitarna, summerar textlängden på ena sidan och räknar citat och distinkta källor på den andra. Därefter härleds en densitet uttryckt som citat per tusen tecken. Ett svar på 2 000 tecken med endast en referens blir omedelbart misstänkt, medan en mänsklig granskare kanske hade missat det.

from mistralai.client.models import TextChunk, ReferenceChunk


def validate_grounding(response, min_citations=1):
    """Verifies that the response is grounded in sources."""
    content = response.choices[0].message.content

    text_length = 0
    citation_count = 0
    cited_refs = set()

    for chunk in content:
        if isinstance(chunk, TextChunk):
            text_length += len(chunk.text)
        elif isinstance(chunk, ReferenceChunk):
            citation_count += 1
            cited_refs.update(chunk.reference_ids)

    # Checks
    checks = {
        "has_citations": citation_count >= min_citations,
        "citation_count": citation_count,
        "unique_sources": len(cited_refs),
        "text_length": text_length,
        "citations_per_1000_chars": round(
            citation_count / max(text_length / 1000, 1), 1
        )
    }

    checks["is_grounded"] = checks["has_citations"]
    return checks


result = validate_grounding(final_response, min_citations=2)
if not result["is_grounded"]:
    print("ALERT: Response potentially ungrounded!")
    print(f"  Citations found: {result['citation_count']}")

Identifiera påståenden utanför scope

Att räkna citat berättar inte om texten mellan dem är trogen källorna. detect_ungrounded_claims tacklar denna blindfläck med en enkel lexikalisk heuristik: den delar upp svaret i meningar, jämför ord längre än fem tecken i varje mening mot de sammanfogade utdragen och flaggar varje mening där mindre än 30 % av nyckelorden förekommer i källorna. För en dokumentationsassistent är de meningar som hamnar högst upp på misstänktlistan vanligtvis det “allmänna kunskaps”-fyllmaterial som modellen har lagt till.

def detect_ungrounded_claims(response_text, source_snippets):
    """Detects sentences that do not match any snippet."""
    import re

    # Split response into sentences
    sentences = re.split(r'[.!?]+', response_text)
    sentences = [s.strip() for s in sentences if len(s.strip()) > 20]

    # Concatenate all snippets into a single text
    all_sources = " ".join(source_snippets).lower()

    suspicious = []
    for sentence in sentences:
        # Extract significant keywords (> 5 chars)
        keywords = [
            w.lower() for w in sentence.split()
            if len(w) > 5
        ]
        # Check coverage
        matches = sum(1 for kw in keywords if kw in all_sources)
        coverage = matches / max(len(keywords), 1)

        if coverage < 0.3:  # Less than 30% of keywords found
            suspicious.append({
                "sentence": sentence,
                "coverage": round(coverage, 2)
            })

    return suspicious

Bygg en tillitspipeline

I produktion är dessa kontroller inte bara analyskript: de blir en port som svaret måste passera innan det når användaren. Klassen GroundedRAG implementerar denna port. Den genererar det citerade svaret, validerar det och i strikt läge avvisar den rakt ut svar med otillräcklig förankring, vilket returnerar en explicit status istället för tvivelaktig text. Tillitsscoren aggregerar tre signaler – förekomst av citat, källmångfald och densitet – så att ditt gränssnitt kan visa en tillförlitlighetsnivå eller dirigera fall med låg tillit för mänsklig granskning.

class GroundedRAG:
    """RAG pipeline with grounding and validation."""

    def __init__(self, client, model="mistral-large-latest"):
        self.client = client
        self.model = model

    def query(self, question, references, strict=True):
        """Executes a RAG query with grounding validation."""

        # 1. Generate response with citations
        response = self._generate_with_citations(
            question, references
        )

        # 2. Validate grounding
        grounding = validate_grounding(response, min_citations=1)

        # 3. In strict mode, reject ungrounded responses
        if strict and not grounding["is_grounded"]:
            return {
                "status": "rejected",
                "reason": "Response insufficiently grounded in sources",
                "grounding_score": grounding
            }

        # 4. Return validated response
        return {
            "status": "ok",
            "response": response,
            "grounding_score": grounding,
            "confidence": self._compute_confidence(grounding)
        }

    def _compute_confidence(self, grounding):
        """Calculates a confidence score based on grounding."""
        score = 0.0
        if grounding["has_citations"]:
            score += 0.4
        if grounding["unique_sources"] >= 2:
            score += 0.3
        if grounding["citations_per_1000_chars"] >= 1.0:
            score += 0.3
        return round(score, 2)

Övervaka förankring över tid

En förankrad pipeline vid produktionsstart kan försämras över tid eftersom dokumentationsbasen åldras, eftersom en prompt har justerats eller eftersom trafiken skiftar mot dåligt täckta ämnen. De fem metrarna nedan beräknas direkt från utdata från validate_grounding och förtjänar en permanent dashboard: det är deras drift, snarare än deras absoluta värde, som varnar dig.

MetrikVad den mäter
CitatfrekvensProcentandel svar som innehåller minst ett citat
CitatdensitetGenomsnittligt antal citat per 1 000 tecken
KällmångfaldGenomsnittligt antal distinkta källor per svar
AvvisningsfrekvensProcentandel svar som avvisats på grund av otillräcklig förankring
Genomsnittlig tillitsscoreUtvecklingen av tillitsscoren över tid

Viktiga punkter

  • Förankring begränsar modellen till att endast svara utifrån verifierade källor
  • En strikt systemprompt är det första försvaret mot hallucinationer
  • Validering efter generering verifierar programmässigt förankringen i varje svar
  • Kombinera dessa strategier i en tillitspipeline på flera nivåer
  • Övervaka kontinuerligt metrarna för förankring för att upptäcka försämringar