Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

RAG adaptatif

Nodarbība 17 no 18 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Acheminer intelligemment les questions
  2. Implémenter le routeur
  3. Le pipeline complet
  4. Galvenās atziņas

Acheminer intelligemment les questions

Self-RAG applique le même traitement à chaque question, et c’est précisément là son défaut. Demande-lui combien font deux plus deux : il va encoder la requête, fouiller l’index, évaluer quatre documents non pertinents, basculer vers le web, générer, puis vérifier. Cela représente une douzaine d’appels LLM pour une question qu’un modèle résout instantanément. Toutes les questions n’ont pas la même complexité, et une question factuelle simple ne nécessite pas le même traitement qu’une demande de synthèse across plusieurs documents. Le RAG adaptatif ajoute donc un routeur intelligent en amont du pipeline : il analyse la question et sélectionne la stratégie optimale avant d’engager tout traitement coûteux.

Le routeur dispose de trois destinations. Les questions portant sur des sujets effectivement couverts par tes documents vont vers le magasin vectoriel ; c’est le parcours RAG complet. Les questions sur l’actualité ou hors du champ indexé vont vers la recherche web, car interroger l’index ne renverrait que du bruit. Enfin, les questions simples ou de culture générale reçoivent une réponse directe du modèle, sans aucune récupération.

Implémenter le routeur

La difficulté réside dans le fait que le routeur doit connaître l’étendue de ton index pour prendre une décision. La solution choisie est aussi simple qu’efficace : lui transmettre la liste des sujets couverts, indexed_topics, qu’il compare à la question. Les trois règles sont énoncées explicitement dans l’invite, et le format JSON contraint garantit une valeur utilisable. Le result.get("route", "vectorstore") mérite attention : en cas de sortie inattendue, le repli par défaut se fait sur le magasin vectoriel. C’est le comportement le plus sûr, qui s’appuie sur tes données plutôt que sur le web ou la mémoire du modèle.

import json
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def route_question(question, indexed_topics):
    """Route a question to the best strategy."""
    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 the 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}")

L’ensemble de tests illustre chaque scénario et servira de garde-fou. Une question sur mistral-embed tombe squarely dans les sujets déclarés, elle va donc au magasin vectoriel. Les cours boursiers ou les résultats de compétitions changent quotidiennement : aucun index statique ne peut les contenir, ils vont donc sur le web. Deux plus deux ne nécessite ni corpus ni recherche. Réutilise ce bloc avec tes propres sujets et une quinzaine de questions représentatives de ton trafic réel : c’est le moyen le plus économique de vérifier que la liste topics est suffisamment précise. Un routeur qui envoie tout au magasin vectoriel n’apporte aucune valeur, et un routeur qui répond directement sur tes sujets métier est carrément dangereux.

Le pipeline complet

AdaptiveRAG rassemble tout ce que tu as construit au cours des trois dernières leçons. Chaque route possède sa propre méthode d’exécution, et la méthode ask se lit comme une instruction switch. La route direct retourne immédiatement, avec une température de 0,3 puisqu’il n’y a pas de contexte à respecter, et une liste de sources vide qui signale honnêtement à l’utilisateur que rien ne sous-tend cette réponse. La route websearch génère uniquement à partir des résultats web. La route vectorstore, en revanche, déploie toute l’artillerie : évaluation des documents dans le style du RAG correctif, repli web si aucun ne survit, puis une boucle de génération avec vérification d’ancrage et d’utilité héritée de Self-RAG, regroupées ici dans grade_and_correct.

Une différence de seuil mérite d’être notée par rapport à la leçon sur le RAG correctif. Le repli web ne se déclenche plus dès qu’un document est écarté, mais seulement si relevant_docs est vide. Ce choix est plus tolérant : lorsque deux chunks sur quatre restent pertinents, il est raisonnable de générer avec eux plutôt que d’aller sur le web, ce qui économise un appel et réduit la latence. Tu dois arbitrer en fonction des exigences de ton domaine.

import numpy as np

class AdaptiveRAG:
    """Adaptive RAG pipeline with intelligent routing."""

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

    def route(self, question):
        """Determine the optimal strategy."""
        return route_question(question, self.topics)

    def retrieve_from_vectorstore(self, question, k=4):
        """Retrieval from the local vector store."""
        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):
        """Web search for out-of-scope questions."""
        return web_search_fallback(question)

    def direct_answer(self, question):
        """Direct answer without retrieval."""
        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):
        """Generation with context (classic RAG)."""
        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):
        """Self-RAG checks (hallucinations + usefulness)."""
        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):
        """Complete Adaptive RAG pipeline."""
        print(f"\n{'='*60}")
        print(f"Question: {question}")

        # 1. Routing
        route = self.route(question)
        print(f"Chosen route: {route}")

        # 2. Execute based on 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)

            # Document grading
            relevant_docs = []
            for doc in docs:
                if grade_document(question, doc["text"]):
                    relevant_docs.append(doc)

            # Web fallback if not enough relevant documents
            if not relevant_docs:
                print("  No relevant documents, web fallback...")
                relevant_docs = self.search_web(question)

            # Generation loop with verification
            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)

            # Return the last generation even if imperfect
            return {
                "answer": generation,
                "route": "vectorstore",
                "attempts": max_retries + 1,
                "sources": [d.get("source", "") for d in relevant_docs],
            }

# Usage
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]}...")

Les trois questions exemples parcourent tous les chemins en une seule exécution, et le champ route dans le résultat t’indique lequel a été emprunté. C’est la valeur que tu dois journaliser en production : la distribution des routes sur ton trafic réel est le meilleur indicateur de santé de ton système, révélant à la fois un index trop étroit et un routeur mal calibré.

Galvenās atziņas

  • Le RAG adaptatif achemine chaque question vers la stratégie optimale (magasin vectoriel, web, direct)
  • Le routeur utilise un LLM avec une sortie structurée pour classer les questions
  • Les questions sur les sujets indexés vont au magasin vectoriel ; le reste va sur le web
  • Le routage réduit la latence et les coûts en évitant le RAG complet pour les questions simples
  • Le RAG adaptatif combine les idées du RAG correctif et de Self-RAG avec le routage