RAG Adattivo
In questa pagina
Instrada le domande in modo intelligente
Self-RAG applica lo stesso trattamento a ogni domanda, ed è proprio questo il suo difetto. Chiedigli quanto fa due più due: codificherà la query, setaccerà l’indice, valuterà quattro documenti irrilevanti, passerà al web, genererà e verificherà. Sono una dozzina di chiamate LLM per una domanda che il modello risolve istantaneamente. Non tutte le domande hanno la stessa complessità e una semplice domanda fattuale non richiede lo stesso trattamento di una che esige una sintesi su più documenti. Il RAG Adattivo aggiunge quindi un router intelligente a monte della pipeline: analizza la domanda e seleziona la strategia ottimale prima di avviare qualsiasi elaborazione costosa.
Il router ha tre destinazioni. Le domande su argomenti effettivamente coperti dai tuoi documenti vanno al vector store; questo è il percorso RAG completo. Le domande su eventi attuali o fuori dall’ambito indicizzato vanno alla ricerca web, poiché interrogare l’indice restituirebbe solo rumore. Infine, le domande semplici o di cultura generale ricevono una risposta diretta dal modello, senza alcun recupero.
Implementare il router
La parte delicata è che il router deve conoscere l’ambito del tuo indice per prendere una decisione. La soluzione scelta è semplice quanto efficace: passargli la lista degli argomenti coperti, indexed_topics, che confronterà con la domanda. Le tre regole sono esplicitate nel prompt e il formato JSON vincolato garantisce un valore utilizzabile. Merita attenzione result.get("route", "vectorstore"): in caso di output imprevisto, il default ripiega sul vector store. È il comportamento più sicuro, che si affida ai tuoi dati piuttosto che al web o alla memoria del modello.
import json
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def route_question(question, indexed_topics):
"""Instrada una domanda verso la migliore strategia."""
topics_str = ", ".join(indexed_topics)
prompt = f"""You are a question router. Given a question,
determine the best source of information.
Your indexed documents cover the following topics: {topics_str}
Rules:
- If the question concerns indexed topics -> "vectorstore"
- If the question concerns current events or an uncovered topic -> "websearch"
- If the question is very simple or general knowledge -> "direct"
Respond ONLY with a JSON object: {{"route": "vectorstore"}} or {{"route": "websearch"}} or {{"route": "direct"}}
Question: {question}
Route 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("route", "vectorstore")
# Test del router
topics = ["embeddings", "RAG", "Mistral AI", "vector search", "FAISS"]
tests = [
"How does mistral-embed work?", # -> vectorstore
"What is Apple's stock price today?", # -> websearch
"How much is 2 + 2?", # -> direct
"What are the steps of RAG?", # -> vectorstore
"Who won the 2026 World Cup?", # -> websearch
]
for q in tests:
route = route_question(q, topics)
print(f" [{route:12s}] {q}")
Il set di test illustra ogni scenario e fungerà da tua salvaguardia. Una domanda su mistral-embed rientra pienamente negli argomenti dichiarati, quindi va al vector store. I prezzi delle azioni o i risultati delle competizioni cambiano ogni giorno: nessun indice statico può contenerli, quindi vanno al web. Due più due non richiede né un corpus né una ricerca. Riutilizza questo blocco con i tuoi argomenti e una quindicina di domande rappresentative del tuo traffico reale: è il modo più economico per verificare che la lista topics sia abbastanza accurata. Un router che invia tutto al vector store non aggiunge valore, e un router che risponde direttamente sui tuoi argomenti aziendali è decisamente pericoloso.
La pipeline completa
AdaptiveRAG riunisce tutto ciò che hai costruito nelle ultime tre lezioni. Ogni route ha il suo metodo di esecuzione e il metodo ask si legge come uno switch. La route direct restituisce immediatamente, con una temperatura di 0.3 poiché non c’è contesto a cui aderire, e una lista di fonti vuota che segnala onestamente all’utente che nulla sostiene questa risposta. La route websearch genera esclusivamente dai risultati web. La route vectorstore, invece, spiega tutta l’artiglieria: valutazione dei documenti nello stile del Corrective RAG, ripiego sul web se nessuno sopravvive, poi un ciclo di generazione con controlli di grounding e utilità ereditati da Self-RAG, qui raggruppati in grade_and_correct.
Vale la pena notare una differenza di soglia rispetto alla lezione sul Corrective RAG. Il ripiego sul web non si attiva appena un documento viene scartato, ma solo se relevant_docs è vuoto. Questa scelta è più tollerante: quando due chunk su quattro rimangono rilevanti, è ragionevole generare con essi piuttosto che andare sul web, risparmiando una chiamata e riducendo la latenza. Devi arbitrare in base ai requisiti del tuo dominio.
import numpy as np
class AdaptiveRAG:
"""Pipeline RAG Adattivo con routing intelligente."""
def __init__(self, chunks, embeddings, index, topics):
self.chunks = chunks
self.embeddings = embeddings
self.index = index
self.topics = topics
def route(self, question):
"""Determina la strategia ottimale."""
return route_question(question, self.topics)
def retrieve_from_vectorstore(self, question, k=4):
"""Recupero dal vector store locale."""
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)
return [
{"text": self.chunks[idx]["text"], "source": "vectorstore"}
for dist, idx in zip(distances[0], indices[0]) if idx >= 0
]
def search_web(self, question):
"""Ricerca web per domande fuori ambito."""
return web_search_fallback(question)
def direct_answer(self, question):
"""Risposta diretta senza recupero."""
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": question}],
temperature=0.3,
)
return response.choices[0].message.content
def generate_with_context(self, question, documents):
"""Generazione con contesto (RAG classico)."""
context = "\n\n---\n\n".join([d["text"] for d in documents])
prompt = f"Context:\n{context}\n\nQuestion: {question}"
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{"role": "system", "content": "Answer based on the provided context."},
{"role": "user", "content": prompt},
],
temperature=0.1,
)
return response.choices[0].message.content
def grade_and_correct(self, question, documents, generation):
"""Controlli Self-RAG (allucinazioni + utilità)."""
is_grounded = check_hallucination(documents, generation)
if not is_grounded:
return None, "hallucination"
is_useful = check_answer_usefulness(question, generation)
if not is_useful:
return None, "not_useful"
return generation, "ok"
def ask(self, question, max_retries=2):
"""Pipeline RAG Adattivo completa."""
print(f"\n{'='*60}")
print(f"Question: {question}")
# 1. Routing
route = self.route(question)
print(f"Chosen route: {route}")
# 2. Esecuzione in base alla route
if route == "direct":
answer = self.direct_answer(question)
return {"answer": answer, "route": "direct", "sources": []}
elif route == "websearch":
docs = self.search_web(question)
answer = self.generate_with_context(question, docs)
return {"answer": answer, "route": "websearch", "sources": ["web"]}
else: # vectorstore
docs = self.retrieve_from_vectorstore(question)
# Valutazione documenti
relevant_docs = []
for doc in docs:
if grade_document(question, doc["text"]):
relevant_docs.append(doc)
# Ripiego sul web se non ci sono documenti rilevanti sufficienti
if not relevant_docs:
print(" No relevant documents, web fallback...")
relevant_docs = self.search_web(question)
# Ciclo di generazione con verifica
for attempt in range(max_retries + 1):
generation = self.generate_with_context(question, relevant_docs)
answer, status = self.grade_and_correct(
question, relevant_docs, generation
)
if status == "ok":
return {
"answer": answer,
"route": "vectorstore",
"attempts": attempt + 1,
"sources": [d.get("source", "") for d in relevant_docs],
}
elif status == "not_useful":
web_docs = self.search_web(question)
relevant_docs.extend(web_docs)
# Restituisce l'ultima generazione anche se imperfetta
return {
"answer": generation,
"route": "vectorstore",
"attempts": max_retries + 1,
"sources": [d.get("source", "") for d in relevant_docs],
}
# Utilizzo
adaptive_rag = AdaptiveRAG(chunks, embeddings, index, topics=topics)
questions = [
"How do I create a FAISS index with mistral-embed?",
"What is the weather in Paris tomorrow?",
"How many dimensions does codestral-embed have?",
]
for q in questions:
result = adaptive_rag.ask(q)
print(f"\nRoute: {result['route']}")
print(f"Answer: {result['answer'][:200]}...")
Le tre domande di esempio percorrono tutti i percorsi in una singola esecuzione e il campo route nel risultato ti dice quale è stato scelto. Questo è il valore che dovresti registrare in produzione: la distribuzione delle route sul tuo traffico reale è il miglior indicatore di salute del tuo sistema, rivelando sia un indice troppo stretto sia un router mal calibrato.
Punti chiave
- Il RAG Adattivo instrada ogni domanda verso la strategia ottimale (vectorstore, web, diretta)
- Il router utilizza un LLM con output strutturato per classificare le domande
- Le domande sugli argomenti indicizzati vanno al vector store; le altre vanno al web
- Il routing riduce latenza e costi evitando il RAG completo per domande semplici
- Il RAG Adattivo combina idee del Corrective RAG e del Self-RAG con il routing