Forankr svar i kilder og reducer hallucinationer
På denne side
Hallucinationsproblemet i produktion
En hallucination er et faktuel forkert svar, der leveres med samme selvsikkerhed som et korrekt svar. Det er netop denne selvsikkerhed, der gør det farligt. En support-chatbot, der opfinder en procedure, sender brugere ned i en blindgyde; en juridisk assistent, der citerer en ikke-eksisterende lov, udsætter din klient for risiko; et medicinsk værktøj, der anbefaler en forkert dosering, skaber reel skade. I alle tre tilfælde signalerer intet i svarformatet, at der er et problem.
Forankring (Grounding) adresserer denne risiko ved at begrænse modellen til udelukkende at basere sine svar på verificerede kilder. Kombineret med citationsystemet, som vi dækkede i tidligere lektioner, skaber det et flerlaget sikkerhedsnet: prompten definerer den forventede adfærd, citationstolkning muliggør verifikation, og pipelinen beslutter, hvordan svar, der ikke består tjekket, skal håndteres.
System-prompten: Dit første forsvarsværk
En vag prompt giver vag forankring. Du skal angive reglerne som en specifikation: definer kildernes omfang, angiv den nøjagtige frase, der skal bruges, når information mangler, forbud mod at udfylde huller med generel viden, krav om citationer for hvert eneste udsagn, og specificér, hvordan modsigelser mellem kilder skal håndteres.
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.
"""
Denne prompt garanterer ikke nul hallucinationer, og du skal være helt åben omkring dette over for dine interessenter: den reducerer hyppigheden markant. Mistral-modeller, der er trænet til forankring, følger disse instrukser med en høj overholdelsesgrad. En høj grad er dog ikke det samme som 100 %, hvilket er grunden til, at de følgende trin er nødvendige.
Verificér forankring efter generering
Funktionen validate_grounding omdanner en intuition – „ser dette svar ud til at være kildebaseret?” – til en metrik. Den itererer gennem svar-blokke (chunks), summerer tekstlængden på den ene side og tæller citationer og unikke kilder på den anden. Derefter udledes en densitet udtrykt som citationer per tusind tegn. Et svar på 2.000 tegn med kun én reference bliver straks mistænkeligt, hvorimod en menneskelig gennemgåer måske havde overset 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']}")
Identificér udsagn uden for scope
At tælle citationer fortæller dig ikke, om teksten mellem dem forbliver tro mod kilderne. Funktionen detect_ungrounded_claims tackler dette blinde punkt med en simpel leksikalsk heuristik: den splitter svaret op i sætninger, sammenligner ord længere end fem tegn i hver sætning med de sammenkædede uddrag og flagger enhver sætning, hvor mindre end 30 % af nøgleordene findes i kilderne. For en dokumentationsassistent er de sætninger, der ryger øverst på listen over mistænkelige, typisk det „generelle videns”-fyld, som modellen har tilføjet.
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
Saml en tillidspipeline
I produktion er disse tjek ikke blot analysescripts: de bliver til en port, som svaret skal passere igennem, før det når brugeren. Klassen GroundedRAG implementerer denne port. Den genererer det citerede svar, validerer det, og i streng tilstand afviser den direkte svar med utilstrækkelig forankring og returnerer en eksplicit status i stedet for tvivlsom tekst. Konfidensscoren aggregerer tre signaler – tilstedeværelse af citationer, kildediversitet og densitet – så din grænseflade kan vise et pålidelighedsniveau eller videresende tilfælde med lav konfidens til menneskelig gennemgang.
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)
Overvåg forankring over tid
En forankret pipeline på dag ét i produktionen kan forringes over tid, fordi dokumentationsbasen forældes, fordi en prompt er blevet justeret, eller fordi trafikken skifter til emner, der er dårligt dækket. De fem metrikker nedenfor beregnes direkte fra outputtet af validate_grounding og fortjener en permanent dashboard-plads: det er deres drift, mere end deres absolutte værdi, der skal alarmere dig.
| Metrik | Hvad den måler |
|---|---|
| Citation rate | Procentdel af svar, der indeholder mindst én citation |
| Citation density | Gennemsnitligt antal citationer per 1.000 tegn |
| Source diversity | Gennemsnitligt antal unikke kilder per svar |
| Rejection rate | Procentdel af svar afvist pga. utilstrækkelig forankring |
| Average confidence score | Udviklingen i konfidensscoren over tid |
Vigtige pointer
- Forankring begrænser modellen til kun at svare ud fra verificerede kilder
- En streng system-prompt er det første forsvarsværk mod hallucinationer
- Validering efter generering verificerer programmatisk forankringen af hvert svar
- Kombiner disse strategier i en tillidspipeline på flere niveauer
- Overvåg løbende forankringsmetrikker for at opdage forringelse