Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Adaptív RAG

17. lecke 18 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Kérdések intelligens útvonalterelése
  2. Az útválasztó implementálása
  3. A teljes folyamat
  4. Főbb megállapítások

Kérdések intelligens útvonalterelése

A Self-RAG minden kérdést ugyanúgy kezel, és pontosan ez a hibája. Kérdezd meg tőle, mennyi kettő plusz kettő: kódolni fogja a lekérdezést, átvizsgálja az indexet, osztályoz négy irreleváns dokumentumot, átvált a webre, generál, majd ellenőriz. Ez tucatnyi LLM-hívás egy olyan kérdésnél, amelyet a modell pillanatok alatt megold. Nem minden kérdésnek ugyanaz a komplexitása, és egy egyszerű ténykérdés nem igényel ugyanolyan kezelést, mint egy több dokumentum szintézisét igénylő feladat. Az Adaptív RAG ezért egy intelligens útválasztót (router) helyez a folyamat elejére: ez elemzi a kérdést, és kiválasztja az optimális stratégiát, mielőtt bármilyen költséges feldolgozásba kezdene.

Az útválasztónak három célállomása van. A dokumentumaid által ténylegesen lefedett témákra vonatkozó kérdések a vektoros tárolóba (vector store) kerülnek; ez a teljes RAG útvonal. A aktuális eseményekre vagy az indexelt hatókörön kívül eső témákra vonatkozó kérdések a webes kereséshez kerülnek, mivel az index lekérdezése itt csak zajt eredményezne. Végül az egyszerű vagy általános tudást igénylő kérdések közvetlen választ kapnak a modelltől, visszakeresés nélkül.

Az útválasztó implementálása

A trükkös rész az, hogy az útválasztónak ismernie kell az indexed hatókörét a döntés meghozatalához. A választott megoldás annyira egyszerű, mint amennyire hatékony: átadjuk neki a lefedett témák listáját, az indexed_topics változót, amelyet összehasonlít a kérdéssel. A három szabály explicit módon szerepel a promptban, a kötött JSON formátum pedig garantálja a használható értéket. A result.get("route", "vectorstore") kifejezés figyelmet érdemel: váratlan kimenet esetén az alapértelmezett visszalépés a vektoros tároló. Ez a legbiztonságosabb viselkedés, amely az adataidra támaszkodik a web vagy a modell memóriája helyett.

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

A tesztkészlet minden forgatókönyvet szemléltet, és biztonsági hálóként szolgál majd. A mistral-embeddel kapcsolatos kérdés egyértelműen a deklarált témák közé esik, így a vektoros tárolóba kerül. A részvényárfolyamok vagy versenyeredmények naponta változnak: egyetlen statikus index sem tartalmazhatja ezeket, ezért a webre kerülnek. A kettő plusz kettőhöz sem korpusz, sem keresés nem szükséges. Használd újra ezt a blokkot a saját témáiddal és körülbelül tizenöt, a valós forgalmadat reprezentáló kérdéssel: ez a legköltséghatékonyabb módja annak ellenőrzésére, hogy a topics lista elég pontos-e. Egy olyan útválasztó, amely mindent a vektoros tárolóba küld, nem ad hozzá értéket, míg egy olyan, amely a üzleti témáidra vonatkozóan közvetlen választ ad, kifejezetten veszélyes.

A teljes folyamat

Az AdaptiveRAG egyesíti mindazt, amit az elmúlt három leckében felépítettél. Minden útvonalnak megvan a saját végrehajtási módszere, és az ask metódus úgy olvasható, mint egy switch utasítás. A direct útvonal azonnal visszatér, 0,3-as hőmérséklettel (mivel nincs kontextus, amihez igazodni kellene), és egy üres forráslistával, amely őszintén jelzi a felhasználónak, hogy semmi nem támasztja alá ezt a választ. A websearch útvonal kizárólag webes eredményekből generál. A vectorstore útvonal azonban beveti a teljes arzenált: dokumentum-osztályozás a Corrective RAG stílusában, webes tartalék, ha egyik sem marad életben, majd egy generációs ciklus groundinggal és hasznossági ellenőrzésekkel, amelyeket a Self-RAG-ből örököltünk, és amelyeket itt a grade_and_correct függvény csoportosít.

Egy küszöbérték-különbséget érdemes megjegyezni a Corrective RAG leckéhez képest. A webes tartalék már nem akkor aktiválódik, amikor egy dokumentumot elvetnek, hanem csak akkor, ha a relevant_docs lista üres. Ez a választás toleránsabb: ha négy chunkból kettő továbbra is releváns, ésszerű velük generálni, ahelyett, hogy a webhez fordulnánk, ami megtakarít egy hívást és csökkenti a késleltetést. A doméned követelményei alapján kell döntenied.

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

A három példakérdés egyetlen futtatás során végigvezet az összes útvonalon, és az eredményben szereplő route mező megmondja, melyiket választotta a rendszer. Ezt az értéket érdemes naplózni éles környezetben: a valós forgalomban előforduló útvonalak eloszlása a legjobb egészségjelző a rendszered számára, feltárva mind a túl szűk indexet, mind a rosszul kalibrált útválasztót.

Főbb megállapítások

  • Az Adaptív RAG minden kérdést az optimális stratégiához irányít (vektoros tároló, web, közvetlen)
  • Az útválasztó egy LLM-t használ strukturált kimenettel a kérdések osztályozásához
  • Az indexelt témákra vonatkozó kérdések a vektoros tárolóba kerülnek; a többi a webre
  • Az útválasztás csökkenti a késleltetést és a költségeket azáltal, hogy elkerüli a teljes RAG-ot az egyszerű kérdéseknél
  • Az Adaptív RAG egyesíti a Corrective RAG és a Self-RAG ötleteit az útválasztással