Vai al contenuto principale
Italiano— Scegli una lingua
Menu

RAG Correttivo

Lezione 15 di 18 Aggiornata il 2 novembre 2026 Sviluppatore
In questa pagina
  1. Quando il recupero non basta
  2. Il valutatore di documenti
  3. La rete di sicurezza web
  4. La pipeline assemblata
  5. Punti chiave

Quando il recupero non basta

Il sistema RAG che hai costruito si basa su un’assunzione implicita: i chunk più simili alla domanda sono quelli giusti. Questa assunzione è spesso valida, ma non sempre. Se interroghi il tuo indice su un argomento che non copre, FAISS restituirà comunque i cinque vettori più vicini, indipendentemente da quanto siano fuori tema: un motore di similarità non sa dire «non ho nulla». Il modello riceve quindi un contesto inadeguato e, poiché il prompt gli chiede di basarsi su quel contesto, produce una risposta che sembra autorevole ma non ha alcun fondamento. Questo è lo scenario di allucinazione più insidioso, perché la catena tecnica ha funzionato senza errori.

Il RAG Correttivo (CRAG) inserisce una fase di valutazione tra il recupero e la generazione. Un LLM esamina ogni documento recuperato e decide: rilevante o no. Se il verdetto è negativo, il sistema non si limita a generare con ciò che ha: passa a una ricerca web per trovare altrove le informazioni mancanti dal tuo corpus. Il flusso prevede quindi quattro fasi: recupero standard dal vector store, valutazione di ogni documento rispetto alla domanda, decisione di attivare una ricerca web se almeno un documento è giudicato irrilevante e, infine, generazione con i migliori documenti disponibili.

Il valutatore di documenti

Tutto dipende dal valutatore. Il trucco consiste nel chiedere all’LLM un giudizio binario in formato JSON invece di una valutazione libera: {"score": "yes"} o {"score": "no"}, nient’altro. Il parametro response_format={"type": "json_object"} garantisce un output analizzabile e temperature=0 elimina la variabilità: la stessa coppia domanda/documento deve ricevere sempre lo stesso verdetto, altrimenti il comportamento della tua pipeline diventa irriproducibile.

from mistralai.client import Mistral
import json

client = Mistral(api_key=api_key)

def grade_document(question, document):
    """Valuta se un documento è rilevante per una domanda."""
    prompt = f"""Sei un valutatore di rilevanza. Data una domanda
e un documento, determina se il documento contiene informazioni rilevanti
per rispondere alla domanda.

Rispondi SOLO con un oggetto JSON: {{"score": "yes"}} o {{"score": "no"}}

Domanda : {question}
Documento : {document}

Valutazione JSON:"""

    response = client.chat.complete(
        model="mistral-large-latest",
        messages=[{"role": "user", "content": prompt}],
        temperature=0,
        response_format={"type": "json_object"},
    )

    result = json.loads(response.choices[0].message.content)
    return result.get("score", "no") == "yes"

# Test
question = "Quali sono le fasi del RAG?"
doc_pertinent = "Il RAG si scompone in recupero, augmentation e generazione."
doc_non_pertinent = "La ricetta del tiramisù richiede mascarpone."

print(grade_document(question, doc_pertinent))      # True
print(grade_document(question, doc_non_pertinent))   # False

Il test alla fine del blocco merita attenzione. La ricetta del tiramisù illustra esattamente ciò che la similarità vettoriale lascia passare: se il tuo corpus parla solo di cucina e lo interroghi sul RAG, questo chunk si classificherà al primo posto per mancanza di concorrenza. Il valutatore, invece, non confronta vettori ma legge il contenuto e lo scarta.

Applicato a tutti i chunk recuperati, questo giudizio produce due informazioni: l’elenco filtrato dei documenti da mantenere e un booleano che indica se integrare con il web. La soglia scelta qui è volutamente rigorosa: un solo documento scartato è sufficiente ad attivare il fallback, sulla base del fatto che il contesto è allora incompleto.

def grade_documents(question, retrieved_chunks):
    """Valuta e filtra i documenti recuperati."""
    relevant_docs = []
    irrelevant_count = 0

    for chunk in retrieved_chunks:
        is_relevant = grade_document(question, chunk["text"])
        if is_relevant:
            relevant_docs.append(chunk)
        else:
            irrelevant_count += 1

    need_web_search = irrelevant_count > 0

    print(f"  Rilevanti: {len(relevant_docs)}/{len(retrieved_chunks)}")
    print(f"  Ricerca web necessaria: {need_web_search}")

    return relevant_docs, need_web_search

La rete di sicurezza web

Quando i documenti locali non bastano, il sistema cerca altrove. Mistral fornisce uno strumento integrato per questo, web_search, che abiliti tramite le Conversations API: il modello esegue la ricerca stessa, poi scrive la sua risposta citando le fonti. Questo dettaglio conta perché una semplice chiamata client.chat.complete non può cercare sul web: il modello risponderebbe a memoria, con il rischio di inventare esattamente ciò che il CRAG cerca di evitare. E dalla versione 3.0 dell’SDK, le completazioni chat rifiutano effettivamente lo strumento web_search.

Il punto chiave del design è il formato di ritorno: la funzione restituisce una lista di dizionari con la stessa forma dei tuoi chunk locali, con un campo source impostato su web_search, e aggiunge gli URL citati. Questa uniformità permette ai passaggi successivi di ignorare completamente l’origine dei documenti preservando al contempo la traccia per l’utente finale.

def web_search_fallback(question):
    """Fallback di ricerca web quando i documenti locali sono insufficienti."""
    response = client.beta.conversations.start(
        model="mistral-medium-latest",
        inputs=question,
        instructions="Rispondi fattualmente, basandoti sui risultati della ricerca web.",
        tools=[{"type": "web_search"}],
        store=False,  # non serve mantenere la conversazione lato Mistral
    )

    texte, urls = "", []
    for entry in response.outputs:
        if entry.type != "message.output":
            continue  # ignora la voce che descrive l'esecuzione dello strumento
        if isinstance(entry.content, str):
            texte += entry.content
            continue
        for chunk in entry.content:
            if chunk.type == "text":
                texte += chunk.text
            elif chunk.type == "tool_reference" and chunk.url:
                urls.append(chunk.url)

    # Restituisci come documento "web", con le fonti citate
    return [{
        "text": texte,
        "source": "web_search",
        "urls": urls,
    }]

La risposta contiene due tipi di voci: una voce tool.execution, che descrive la ricerca avviata, e una voce message.output, il cui contenuto alterna frammenti di testo e riferimenti (tool_reference) che riportano titolo e URL delle pagine consultate. Un amministratore dell’organizzazione può limitare i domini interrogati tramite una allowlist o una blocklist; i risultati filtrati scompaiono senza preavviso, quindi una allowlist troppo stretta può lasciare la ricerca senza risultati.

Fonte ufficiale: Websearch (documentazione Mistral)

La pipeline assemblata

La classe CorrectiveRAG riprende la struttura della pipeline standard inserendo la valutazione. Il valore predefinito k=4 è leggermente più generoso dei soliti tre chunk, il che ha senso: poiché il filtraggio ne scarterà alcuni, è meglio partire con un margine. Il metodo ask orchestra le quattro fasi e ne visualizza ciascuna, permettendoti di seguire il ragionamento del sistema in tempo reale: quanti documenti sono sopravvissuti alla valutazione, se il fallback si è attivato. Il dizionario di ritorno espone anche web_search_used: questo è un indicatore prezioso da monitorare in produzione, perché un tasso di utilizzo web anormalmente alto non segnala un difetto del CRAG ma una lacuna nel tuo corpus.

class CorrectiveRAG:
    """Pipeline RAG correttiva con valutazione e fallback web."""

    def __init__(self, chunks, embeddings, index):
        self.chunks = chunks
        self.embeddings = embeddings
        self.index = index

    def retrieve(self, question, k=4):
        """Fase 1: recupero standard."""
        response = client.embeddings.create(
            model="mistral-embed",
            inputs=[question],
        )
        query_vec = np.array([response.data[0].embedding], dtype=np.float32)
        distances, indices = self.index.search(query_vec, k)

        results = []
        for dist, idx in zip(distances[0], indices[0]):
            if idx >= 0:
                results.append({
                    "text": self.chunks[idx]["text"],
                    "source": self.chunks[idx].get("source", "local"),
                })
        return results

    def grade(self, question, documents):
        """Fase 2: valuta la rilevanza."""
        relevant = []
        for doc in documents:
            if grade_document(question, doc["text"]):
                relevant.append(doc)
        need_web = len(relevant) < len(documents)
        return relevant, need_web

    def generate(self, question, documents):
        """Fase 3: genera la risposta."""
        context = "\n\n---\n\n".join([d["text"] for d in documents])
        prompt = f"""Contesto :\n{context}\n\nDomanda : {question}"""

        response = client.chat.complete(
            model="mistral-large-latest",
            messages=[
                {"role": "system", "content": "Rispondi basandoti sul contesto."},
                {"role": "user", "content": prompt},
            ],
            temperature=0.1,
        )
        return response.choices[0].message.content

    def ask(self, question, k=4):
        """Pipeline completa."""
        print(f"\n=== Domanda : {question} ===")

        # 1. Recupero
        print("1. Recupero...")
        docs = self.retrieve(question, k=k)

        # 2. Valutazione
        print("2. Valutazione...")
        relevant_docs, need_web = self.grade(question, docs)

        # 3. Fallback ricerca web se necessario
        if need_web:
            print("3. Fallback ricerca web...")
            web_docs = web_search_fallback(question)
            relevant_docs.extend(web_docs)

        # 4. Generazione
        print("4. Generazione...")
        answer = self.generate(question, relevant_docs)

        return {
            "answer": answer,
            "sources_used": len(relevant_docs),
            "web_search_used": need_web,
        }

# Utilizzo
crag = CorrectiveRAG(chunks, embeddings, index)
result = crag.ask("Come implementa Mistral gli embeddings?")

print(f"\nRisposta : {result['answer']}")
print(f"Ricerca web utilizzata : {result['web_search_used']}")

Questa affidabilità ha un costo che devi accettare consapevolmente: con k=4, ogni domanda attiva quattro chiamate di valutazione prima ancora che inizi la generazione. La latenza percepita dall’utente aumenta di conseguenza, così come la fattura. Il compromesso differisce a seconda del caso d’uso: per un assistente legale o medico, la verifica è non negoziabile; per un motore di ricerca interno dove l’utente vede le fonti e giudica da sé, lo è meno.

Punti chiave

  • Il RAG correttivo aggiunge una fase di valutazione della rilevanza dopo il recupero
  • Un LLM funge da «valutatore» per giudicare ogni documento: rilevante o no
  • Se i documenti sono giudicati irrilevanti, si attiva un fallback verso la ricerca web
  • Questo approccio riduce significativamente le allucinazioni dovute a un contesto inadeguato
  • La valutazione aggiunge latenza ma migliora fortemente l’affidabilità delle risposte