Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Quellen verankern und Halluzinationen reduzieren

Lektion 10 von 16 Aktualisiert am 2. November 2026 Fortgeschritten
Auf dieser Seite
  1. Das Halluzinationsproblem in der Produktion
  2. Der System-Prompt: Ihre erste Verteidigungslinie
  3. Verifizierung des Groundings nach der Generierung
  4. Identifizierung von Behauptungen außerhalb des Geltungsbereichs
  5. Aufbau eines Vertrauens-Pipelines
  6. Überwachung des Groundings über die Zeit
  7. Kernaussagen

Das Halluzinationsproblem in der Produktion

Eine Halluzination ist eine faktisch falsche Antwort, die mit der Sicherheit einer korrekten Antwort geliefert wird. Genau diese Sicherheit macht sie so gefährlich. Ein Support-Chatbot, der ein Verfahren erfindet, führt Nutzer in eine Sackgasse; ein Rechtsassistent, der ein nicht existierendes Gesetz zitiert, setzt den Mandanten einem Risiko aus; ein medizinisches Tool, das die falsche Dosierung empfiehlt, verursacht echten Schaden. In allen drei Fällen signalisiert nichts im Antwortformat das Problem.

Grounding adressiert dieses Risiko, indem das Modell daran gehindert wird, seine Antworten ausschließlich auf verifizierte Quellen zu stützen. In Kombination mit dem Zitationssystem, das in vorherigen Lektionen behandelt wurde, entsteht ein mehrschichtiges Sicherheitsnetz: Der Prompt definiert das erwartete Verhalten, die Zitationsauswertung ermöglicht die Verifizierung und die Pipeline entscheidet, wie mit Antworten umgegangen wird, die die Prüfung nicht bestehen.

Der System-Prompt: Ihre erste Verteidigungslinie

Ein vager Prompt erzeugt vages Grounding. Sie müssen die Regeln wie eine Spezifikation formulieren: Definieren Sie den Geltungsbereich der Quellen, geben Sie den exakten Satz an, der verwendet werden soll, wenn Informationen fehlen, verbieten Sie das Auffüllen von Lücken mit Allgemeinwissen, verlangen Sie Zitate für jede Behauptung und legen Sie fest, wie mit Widersprüchen zwischen Quellen umgegangen werden soll.

system_prompt = """
Sie sind ein spezialisierter Dokumentationsassistent.

ABSOLUTE REGELN:
1. Beantworten Sie NUR unter Verwendung der bereitgestellten Quellen über Referenzen.
2. Wenn die Informationen nicht in den Quellen enthalten sind, antworten Sie:
   "Diese Informationen sind in den bereitgestellten Quellen nicht verfügbar."
3. Ergänzen Sie NIE mit Ihrem Allgemeinwissen.
4. Zitieren Sie jede Behauptung mit der entsprechenden Referenz.
5. Wenn sich zwei Quellen widersprechen, erwähnen Sie beide Versionen.
"""

Dieser Prompt garantiert keine halluzinationsfreie Antwort, und Sie müssen dies gegenüber Ihren Stakeholdern klarstellen: Er reduziert deren Häufigkeit signifikant. Mistral-Modelle, die für Grounding trainiert wurden, folgen diesen Anweisungen mit einer hohen Compliance-Rate. Eine hohe Rate ist jedoch keine 100%-ige Rate, weshalb die folgenden Schritte notwendig sind.

Verifizierung des Groundings nach der Generierung

Die Funktion validate_grounding verwandelt eine Intuition – „sieht diese Antwort aus, als wäre sie quellenbasiert?” – in eine Metrik. Sie durchläuft die Antwortabschnitte, summiert die Textlänge auf der einen Seite und zählt Zitate sowie eindeutige Quellen auf der anderen. Anschließend leitet sie eine Dichte ab, ausgedrückt als Zitate pro Tausend Zeichen. Eine 2.000-Zeichen-Antwort mit nur einer Referenz wird sofort verdächtig, während ein menschlicher Prüfer sie möglicherweise übersehen hätte.

from mistralai.client.models import TextChunk, ReferenceChunk


def validate_grounding(response, min_citations=1):
    """Verifiziert, dass die Antwort in Quellen verankert ist."""
    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)

    # Prüfungen
    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: Antwort potenziell nicht verankert!")
    print(f"  Gefundene Zitate: {result['citation_count']}")

Identifizierung von Behauptungen außerhalb des Geltungsbereichs

Das Zählen von Zitationen sagt Ihnen nicht, ob der Text zwischen ihnen den Quellen treu bleibt. detect_ungrounded_claims adressiert diese Blindstelle mit einer einfachen lexikalischen Heuristik: Sie teilt die Antwort in Sätze auf, vergleicht Wörter mit mehr als fünf Zeichen in jedem Satz mit den verketteten Snippets und markiert jeden Satz, bei dem weniger als 30 % der Schlüsselwörter in den Quellen vorkommen. Bei einem Dokumentationsassistenten sind die Sätze, die an der Spitze der verdächtigen Liste stehen, typischerweise die „Allgemeinwissen”-Fülltexte, die das Modell hinzugefügt hat.

def detect_ungrounded_claims(response_text, source_snippets):
    """Erkennt Sätze, die keinem Snippet entsprechen."""
    import re

    # Antwort in Sätze aufteilen
    sentences = re.split(r'[.!?]+', response_text)
    sentences = [s.strip() for s in sentences if len(s.strip()) > 20]

    # Alle Snippets zu einem einzigen Text verkett
    all_sources = " ".join(source_snippets).lower()

    suspicious = []
    for sentence in sentences:
        # Wichtige Schlüsselwörter extrahieren (> 5 Zeichen)
        keywords = [
            w.lower() for w in sentence.split()
            if len(w) > 5
        ]
        # Abdeckung prüfen
        matches = sum(1 for kw in keywords if kw in all_sources)
        coverage = matches / max(len(keywords), 1)

        if coverage < 0.3:  # Weniger als 30 % der Schlüsselwörter gefunden
            suspicious.append({
                "sentence": sentence,
                "coverage": round(coverage, 2)
            })

    return suspicious

Aufbau eines Vertrauens-Pipelines

In der Produktion sind diese Prüfungen nicht nur Analyse-Skripte: Sie werden zu einem Tor, durch das die Antwort passieren muss, bevor sie den Nutzer erreicht. Die Klasse GroundedRAG implementiert dieses Tor. Sie generiert die zitierte Antwort, validiert sie und lehnt im strengen Modus Antworten mit unzureichendem Grounding ab und gibt einen expliziten Status statt zweifelhaften Text zurück. Der Vertrauenswert aggregiert drei Signale – Vorhandensein von Zitationen, Quellenvielfalt und Dichte –, sodass Ihr Interface ein Zuverlässigkeitsniveau anzeigen oder Fälle mit niedrigem Vertrauen zur menschlichen Prüfung weiterleiten kann.

class GroundedRAG:
    """RAG-Pipeline mit Grounding und Validierung."""

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

    def query(self, question, references, strict=True):
        """Führt eine RAG-Abfrage mit Grounding-Validierung aus."""

        # 1. Antwort mit Zitationen generieren
        response = self._generate_with_citations(
            question, references
        )

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

        # 3. Im strengen Modus nicht verankerte Antworten ablehnen
        if strict and not grounding["is_grounded"]:
            return {
                "status": "rejected",
                "reason": "Antwort nicht ausreichend in Quellen verankert",
                "grounding_score": grounding
            }

        # 4. Validierte Antwort zurückgeben
        return {
            "status": "ok",
            "response": response,
            "grounding_score": grounding,
            "confidence": self._compute_confidence(grounding)
        }

    def _compute_confidence(self, grounding):
        """Berechnet einen Vertrauenswert basierend auf 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)

Überwachung des Groundings über die Zeit

Ein verankertes Pipeline kann am ersten Produktionstag über die Zeit degradieren, weil die Dokumentationsbasis altert, weil ein Prompt angepasst wurde oder weil der Verkehr zu schlecht abgedeckten Themen verschoben wird. Die folgenden fünf Metriken werden direkt aus den Ausgaben von validate_grounding berechnet und verdienen ein dauerhaftes Dashboard: Es ist deren Drift, mehr als ihr absoluter Wert, der Sie alarmiert.

MetrikWas sie misst
ZitationsrateProzentsatz der Antworten, die mindestens eine Zitation enthalten
ZitationsdichteDurchschnittliche Anzahl von Zitationen pro 1.000 Zeichen
QuellenvielfaltDurchschnittliche Anzahl von eindeutigen Quellen pro Antwort
AblehnungsrateProzentsatz der Antworten, die wegen unzureichenden Groundings abgelehnt wurden
Durchschnittlicher VertrauenswertEntwicklung des Vertrauenswerts über die Zeit

Kernaussagen

  • Grounding begrenzt das Modell darauf, nur aus verifizierten Quellen zu antworten
  • Ein strenger System-Prompt ist die erste Verteidigungslinie gegen Halluzinationen
  • Die Validierung nach der Generierung verifiziert programmatisch das Grounding jeder Antwort
  • Kombinieren Sie diese Strategien in einer mehrstufigen Vertrauens-Pipeline
  • Überwachen Sie Grounding-Metriken kontinuierlich, um Degradation zu erkennen