Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Adaptive RAG

Les 17 van 18 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Routeer vragen intelligent
  2. Implementeer de router
  3. De complete pipeline
  4. Belangrijkste punten

Routeer vragen intelligent

Self-RAG behandelt elke vraag op dezelfde manier, en dat is precies het nadeel. Vraag het wat twee plus twee is: het codeert de query, doorzoekt de index, beoordeelt vier irrelevante documenten, schakelt over naar het web, genereert en verifieert. Dat zijn een dozijn LLM-aanroepen voor een vraag die het model direct oplost. Niet alle vragen hebben dezelfde complexiteit, en een simpele feitelijke vraag vereist niet dezelfde aanpak als een vraag die synthese over meerdere documenten vraagt. Adaptive RAG voegt daarom een intelligente router toe stroomopwaarts van de pipeline: deze analyseert de vraag en kiest de optimale strategie voordat dure verwerking begint.

De router heeft drie bestemmingen. Vragen over onderwerpen die daadwerkelijk in uw documenten staan, gaan naar de vectorstore; dit is het volledige RAG-traject. Vragen over actuele gebeurtenissen of buiten de geïndexeerde reikwijdte gaan naar web search, omdat een query op de index alleen ruis zou opleveren. Simpele of algemene kennisvragen krijgen tenslotte een direct antwoord van het model, zonder enige retrieval.

Implementeer de router

Het lastige is dat de router de reikwijdte van uw index moet kennen om een beslissing te nemen. De gekozen oplossing is even simpel als effectief: geef de lijst met behandelde onderwerpen mee, indexed_topics, waarmee de router de vraag vergelijkt. De drie regels worden expliciet in de prompt gesteld, en het beperkte JSON-formaat garandeert een bruikbare waarde. De regel result.get("route", "vectorstore") verdient aandacht: bij onverwachte output valt de standaard terug op de vectorstore. Dit is het veiligste gedrag, waarbij u vertrouwt op uw eigen data in plaats van op het web of het geheugen van het model.

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}")

De testset illustreert elk scenario en dient als uw veiligheidsnet. Een vraag over mistral-embed valt duidelijk binnen de gedeclareerde onderwerpen en gaat dus naar de vectorstore. Aandelenkoersen of competitieresultaten veranderen dagelijks: geen statische index kan deze bevatten, dus gaan ze naar het web. Twee plus twee vereist noch een corpus, noch zoekwerk. Hergebruik dit blok met uw eigen onderwerpen en ongeveer vijftien vragen die representatief zijn voor uw daadwerkelijke verkeer: dit is de zuinigste manier om te verifiëren of de topics-lijst nauwkeurig genoeg is. Een router die alles naar de vectorstore stuurt, voegt geen waarde toe, en een router die direct antwoordt op uw bedrijfsonderwerpen is ronduit gevaarlijk.

De complete pipeline

AdaptiveRAG brengt alles samen wat u de afgelopen drie lessen heeft gebouwd. Elke route heeft zijn eigen uitvoeringsmethode, en de ask-methode leest als een switch-instructie. De direct-route keert onmiddellijk terug, met een temperatuur van 0,3 omdat er geen context is om aan te houden, en een lege bronnenlijst die de gebruiker eerlijk signaleert dat niets dit antwoord onderbouwt. De websearch-route genereert uitsluitend op basis van webresultaten. De vectorstore-route zet echter het volledige arsenaal in: documentbeoordeling in de stijl van Corrective RAG, web-fallback als er niets overblijft, en vervolgens een generatielus met grounding- en nuttigheidscontroles overgeërfd van Self-RAG, hier gegroepeerd in grade_and_correct.

Eén drempelwaardeverschil is het vermelden waard ten opzichte van de les over Corrective RAG. De web-fallback wordt niet langer geactiveerd zodra een document wordt verworpen, maar alleen als relevant_docs leeg is. Deze keuze is toleranter: wanneer twee van de vier chunks relevant blijven, is het redelijk om daarmee te genereren in plaats van naar het web te gaan, wat een aanroep bespaart en de latentie verlaagt. U moet afwegen op basis van de eisen van uw domein.

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

De drie voorbeeldvragen doorlopen alle paden in één uitvoering, en het veld route in het resultaat vertelt u welk pad is genomen. Dit is de waarde die u in productie moet loggen: de verdeling van routes over uw echte verkeer is de beste gezondheidsindicator voor uw systeem, die zowel een te smalle index als een slecht gekalibreerde router onthult.

Belangrijkste punten

  • Adaptive RAG routeert elke vraag naar de optimale strategie (vectorstore, web, direct)
  • De router gebruikt een LLM met gestructureerde output om vragen te classificeren
  • Vragen over geïndexeerde onderwerpen gaan naar de vectorstore; de rest gaat naar het web
  • Routing verlaagt latentie en kosten door volledig RAG voor simpele vragen te vermijden
  • Adaptive RAG combineert ideeën uit Corrective RAG en Self-RAG met routing