Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Ancorare le risposte alle fonti e ridurre le allucinazioni

Lezione 10 di 16 Aggiornata il 2 novembre 2026 Avanzato
In questa pagina
  1. Il problema delle allucinazioni in produzione
  2. Il prompt di sistema: la tua prima linea di difesa
  3. Verificare l’ancoraggio dopo la generazione
  4. Identificare le affermazioni fuori ambito
  5. Assemblare una pipeline di fiducia
  6. Monitorare l’ancoraggio nel tempo
  7. Punti chiave

Il problema delle allucinazioni in produzione

Un’allucinazione è una risposta fattualmente errata fornita con la stessa sicurezza di una corretta. È proprio questa sicurezza a renderla pericolosa. Un chatbot di supporto che inventa una procedura indirizza gli utenti verso un vicolo cieco; un assistente legale che cita una norma inesistente espone il tuo cliente a rischi; uno strumento medico che raccomanda un dosaggio sbagliato causa danni reali. In tutti e tre i casi, nulla nel formato della risposta segnala il problema.

L’ancoraggio (grounding) affronta questo rischio costringendo il modello a basare le sue risposte esclusivamente su fonti verificate. Combinato con il sistema di citazioni trattato nelle lezioni precedenti, crea una rete di sicurezza multilivello: il prompt definisce il comportamento atteso, l’analisi delle citazioni ne permette la verifica e la pipeline decide come gestire le risposte che non superano il controllo.

Il prompt di sistema: la tua prima linea di difesa

Un prompt vago produce un ancoraggio vago. Devi enunciare le regole come una specifica tecnica: definisci l’ambito delle fonti, fornisci la frase esatta da usare quando le informazioni mancano, vieta di colmare le lacune con conoscenze generali, richiedi citazioni per ogni affermazione e specifica come gestire le contraddizioni tra le fonti.

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

Questo prompt non garantisce zero allucinazioni e devi essere chiaro su questo punto con i tuoi stakeholder: ne riduce significativamente la frequenza. I modelli Mistral, addestrati per l’ancoraggio, seguono queste istruzioni con un alto tasso di conformità. Tuttavia, un tasso elevato non è un tasso del 100%, motivo per cui i passaggi successivi sono necessari.

Verificare l’ancoraggio dopo la generazione

La funzione validate_grounding trasforma un’intuizione («questa risposta sembra basata su fonti?») in una metrica. Itera attraverso i chunk della risposta, sommando la lunghezza del testo da un lato e contando citazioni e fonti distinte dall’altro. Ne deriva poi una densità espressa come citazioni per mille caratteri. Una risposta di 2.000 caratteri con un solo riferimento diventa immediatamente sospetta, mentre un revisore umano potrebbe non accorgersene.

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

Identificare le affermazioni fuori ambito

Contare le citazioni non ti dice se il testo tra di esse rimane fedele alle fonti. detect_ungrounded_claims affronta questo punto cieco con una semplice euristica lessicale: divide la risposta in frasi, confronta le parole più lunghe di cinque caratteri in ogni frase con gli snippet concatenati e segnala qualsiasi frase in cui meno del 30% delle parole chiave appare nelle fonti. Per un assistente alla documentazione, le frasi che salgono in cima alla lista dei sospetti sono tipicamente i riempitivi di «conoscenza generale» aggiunti dal modello.

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

Assemblare una pipeline di fiducia

In produzione, questi controlli non sono solo script di analisi: diventano un cancello che la risposta deve attraversare prima di raggiungere l’utente. La classe GroundedRAG implementa questo cancello. Genera la risposta citata, la valida e, in modalità rigorosa, rifiuta outright le risposte con un ancoraggio insufficiente, restituendo uno stato esplicito invece di testo dubbio. Il punteggio di fiducia aggrega tre segnali—presenza di citazioni, diversità delle fonti e densità—così che la tua interfaccia possa visualizzare un livello di affidabilità o instradare i casi a bassa fiducia per una revisione umana.

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)

Monitorare l’ancoraggio nel tempo

Una pipeline ancorata al primo giorno di produzione può degradarsi nel tempo perché la base documentale invecchia, perché un prompt è stato modificato o perché il traffico si sposta su argomenti poco coperti. Le cinque metriche seguenti si calcolano direttamente dagli output di validate_grounding e meritano una dashboard permanente: è la loro deriva, più del loro valore assoluto, ad allertarti.

MetricaCosa misura
Tasso di citazionePercentuale di risposte contenenti almeno una citazione
Densità di citazioneNumero medio di citazioni per 1.000 caratteri
Diversità delle fontiNumero medio di fonti distinte per risposta
Tasso di rifiutoPercentuale di risposte rifiutate per ancoraggio insufficiente
Punteggio di fiducia medioEvoluzione del punteggio di fiducia nel tempo

Punti chiave

  • L’ancoraggio costringe il modello a rispondere solo basandosi su fonti verificate
  • Un prompt di sistema rigoroso è la prima linea di difesa contro le allucinazioni
  • La validazione post-generazione verifica programmaticamente l’ancoraggio di ogni risposta
  • Combina queste strategie in una pipeline di fiducia multilivello
  • Monitora continuamente le metriche di ancoraggio per rilevare il degrado