Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Adaptiv RAG

Lektion 17 af 18 Opdateret 2. november 2026 Udvikler
På denne side
  1. Rout spørgsmål intelligent
  2. Implementér routeren
  3. Den komplette pipeline
  4. Vigtige pointer

Rout spørgsmål intelligent

Self-RAG behandler alle spørgsmål ens, og det er netop dens svaghed. Spørg den, hvad to plus to er: den vil kode forespørgslen, gennemsøge indekset, vurdere fire irrelevante dokumenter, skifte til webbet, generere og verificere. Det er et dusin LLM-kald for et spørgsmål, som modellen løser øjeblikkeligt. Ikke alle spørgsmål har samme kompleksitet, og et simpelt faktaspørgsmål kræver ikke samme behandling som et, der kræver syntese på tværs af flere dokumenter. Adaptiv RAG tilføjer derfor en intelligent router upstream i pipelinen: den analyserer spørgsmålet og vælger den optimale strategi, før den går i gang med nogen dyr behandling.

Routeren har tre destinationer. Spørgsmål om emner, der faktisk er dækket af dine dokumenter, sendes til vektorbutikken; dette er den fulde RAG-sti. Spørgsmål om aktuelle begivenheder eller uden for det indekserede omfang sendes til websøgning, da en forespørgsel til indekset kun ville returnere støj. Endelig modtager simple eller generelle vidensspørgsmål et direkte svar fra modellen uden nogen hentning overhovedet.

Implementér routeren

Det vanskelige er, at routeren skal kende omfanget af dit indeks for at kunne træffe en beslutning. Den valgte løsning er lige så simpel, som den er effektiv: giv den listen over dækkede emner, indexed_topics, som den sammenligner med spørgsmålet. De tre regler er angivet eksplicit i prompten, og det begrænsede JSON-format garanterer en brugbar værdi. result.get("route", "vectorstore") fortjener opmærksomhed: i tilfælde af uventet output falder standarden tilbage til vektorbutikken. Dette er den sikreste adfærd, der stole på dine data frem for webbet eller modellens hukommelse.

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

Testsættet illustrerer hvert scenarie og vil fungere som din sikkerhedsnet. Et spørgsmål om mistral-embed falder squarely inden for de erklærede emner, så det går til vektorbutikken. Aktiekurser eller konkurrenceresultater ændrer sig dagligt: intet statisk indeks kan indeholde dem, så de går til webbet. To plus to kræver hverken et korpus eller søgning. Genbrug denne blok med dine egne emner og omkring femten spørgsmål, der er repræsentative for din faktiske trafik: dette er den mest økonomiske måde at verificere, at listen over topics er nøjagtig nok. En router, der sender alt til vektorbutikken, tilføjer ingen værdi, og en router, der svarer direkte på dine forretningsmæssige emner, er ligefrem farlig.

Den komplette pipeline

AdaptiveRAG samler alt, hvad du har bygget i de sidste tre lektioner. Hver rute har sin egen eksekveringsmetode, og ask-metoden læses som en switch-sætning. Ruten direct returnerer øjeblikkeligt med en temperatur på 0,3, da der ingen kontekst er at overholde, og en tom kildeliste, der ærligt signalerer til brugeren, at intet underbygger dette svar. Ruten websearch genererer udelukkende fra webresultater. Ruten vectorstore indsætter derimod hele artilleriet: dokumentvurdering i stil med Corrective RAG, web-backup hvis ingen overlever, derefter en genereringssløjfe med grounding- og nyttechecks arvet fra Self-RAG, her grupperet i grade_and_correct.

En tærskelforskel er værd at bemærke sammenlignet med lektionen om Corrective RAG. Web-backuppen udløses ikke længere, så snart et dokument kasseres, men kun hvis relevant_docs er tom. Dette valg er mere tolerant: når to ud af fire chunks forbliver relevante, er det rimeligt at generere med dem frem for at gå til webbet, hvilket sparer et kald og reducerer ventetid. Du skal arbitere baseret på kravene i dit domæne.

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 tre eksempelspørgsmål gennemgår alle stier i en enkelt kørsel, og feltet route i resultatet fortæller dig, hvilken der blev taget. Dette er den værdi, du bør logge i produktion: fordelingen af ruter på tværs af din rigtige trafik er den bedste sundhedsindikator for dit system, der afslører både et indeks, der er for smalt, og en dårligt kalibreret router.

Vigtige pointer

  • Adaptiv RAG routerer hvert spørgsmål til den optimale strategi (vektorbutik, web, direkte)
  • Routeren bruger en LLM med struktureret output til at klassificere spørgsmål
  • Spørgsmål om indekserede emner går til vektorbutikken; resten går til webbet
  • Routing reducerer ventetid og omkostninger ved at undgå fuld RAG for simple spørgsmål
  • Adaptiv RAG kombinerer idéer fra Corrective RAG og Self-RAG med routing