Vai al contenuto principale
Italiano— Scegli una lingua
Menu

RAG Adattivo

Lezione 17 di 18 Aggiornata il 2 novembre 2026 Sviluppatore
In questa pagina
  1. Instrada le domande in modo intelligente
  2. Implementare il router
  3. La pipeline completa
  4. Punti chiave

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