RAG Correttivo
In questa pagina
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