Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Adaptívne RAG

Lekcia 17 z 18 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Inteligentné smerovanie otázok
  2. Implementácia smerovača
  3. Kompletná pipeline
  4. Kľúčové poznatky

Inteligentné smerovanie otázok

Self-RAG zaobchádza s každou otázkou rovnako, a to je presne jeho slabina. Opýtaj sa ho, koľko je dva plus dva: zakóduje dopyt, prečeše index, ohodnotí štyri irelevantné dokumenty, prepne sa na web, vygeneruje odpoveď a overí ju. To je tucet volaní LLM pre otázku, ktorú model vyrieši okamžite. Nie všetky otázky majú rovnakú zložitosť a jednoduchá faktografická otázka si nevyžaduje rovnaký prístup ako tá, ktorá si vyžaduje syntézu z viacerých dokumentov. Adaptívne RAG preto pridáva do pipeline inteligentný smerovač (router): analyzuje otázku a predtým, než spustí akékoľvek nákladné spracovanie, vyberie optimálnu stratégiu.

Smerovač má tri ciele. Otázky týkajúce sa tém, ktoré sú skutočne pokryté tvojimi dokumentmi, smerujú do vektorového úložiska; toto je plná cesta RAG. Otázky o aktuálnom dianí alebo mimo rozsahu indexu smerujú na vyhľadávanie na webe, keďže dopyt do indexu by vrátil len šum. Nakoniec, jednoduché otázky alebo otázky všeobecnej povahy dostanú priamu odpoveď od modelu bez akéhokoľvek vyhľadávania.

Implementácia smerovača

Zložité je, že smerovač musí poznať rozsah tvojho indexu, aby sa mohol rozhodnúť. Zvolené riešenie je také jednoduché, ako účinné: odovzdáš mu zoznam pokrytých tém, indexed_topics, ktoré porovná s otázkou. Tri pravidlá sú v prompte uvedené explicitne a vynútený formát JSON zaručuje použiteľnú hodnotu. Výraz result.get("route", "vectorstore") si zaslúži pozornosť: v prípade neočakávaného výstupu sa predvolená hodnota vráti späť k vektorovému úložisku. Toto je najbezpečnejšie správanie, ktoré sa spolieha na tvoje dáta namiesto webu alebo pamäte modelu.

import json
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def route_question(question, indexed_topics):
    """Smeruj otázku na najlepšiu stratégiu."""
    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}")

Testovacia sada ilustruje každý scenár a bude slúžiť ako tvoja poistka. Otázka o mistral-embed presne zapadá do deklarovaných tém, takže smeruje do vektorového úložiska. Ceny akcií alebo výsledky súťaží sa menia denne: žiadny statický index ich nemôže obsahovať, preto smerujú na web. Dva plus dva si nevyžadujú ani korpus, ani vyhľadávanie. Použi tento blok so svojimi vlastnými témami a asi pätnástimi otázkami reprezentatívnymi pre tvoju skutočnú prevádzku: je to najekonomickejší spôsob, ako overiť, či je zoznam topics dostatočne presný. Smerovač, ktorý posiela všetko do vektorového úložiska, neprináša žiadnu hodnotu a smerovač, ktorý priamo odpovedá na tvoje business témy, je vyslovene nebezpečný.

Kompletná pipeline

AdaptiveRAG spája všetko, čo si vybudoval za posledné tri lekcie. Každá trasa má svoju vlastnú metódu vykonania a metóda ask pripomína príkaz switch. Trasa direct sa vráti okamžite s teplotou 0,3, keďže nie je kontext, ktorého by sa mala držať, a s prázdnym zoznamom zdrojov, ktorý úprimne signalizuje používateľovi, že táto odpoveď nie je ničím podložená. Trasa websearch generuje výlučne z výsledkov z webu. Trasa vectorstore však nasadzuje ťažké delostrelectvo: hodnotenie dokumentov v štýle Corrective RAG, zálohu na webe, ak žiadne neprežijú, a následne generačnú slučku s kontrolami ukotvenia a užitočnosti zdedenými od Self-RAG, ktoré sú tu zoskupené v grade_and_correct.

Stojí za zmienku jeden rozdiel v prahu oproti lekcii o Corrective RAG. Záloha na webe sa nespustí hneď, ako sa dokument vyradí, ale až vtedy, keď je relevant_docs prázdne. Táto voľba je tolerantnejšia: ak zostanú relevantné dva zo štyroch chunkov, je rozumné generovať s nimi, než ísť na web, čo ušetrí jedno volanie a zníži latenciu. Musíš rozhodnúť podľa požiadaviek tvojej domény.

import numpy as np

class AdaptiveRAG:
    """Adaptívna RAG pipeline s inteligentným smerovaním."""

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

    def route(self, question):
        """Urči optimálnu stratégiu."""
        return route_question(question, self.topics)

    def retrieve_from_vectorstore(self, question, k=4):
        """Vyhľadávanie z lokálneho vektorového úložiska."""
        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):
        """Vyhľadávanie na webe pre otázky mimo rozsahu."""
        return web_search_fallback(question)

    def direct_answer(self, question):
        """Priama odpoveď bez vyhľadávania."""
        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):
        """Generovanie s kontextom (klasické 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):
        """Kontroly Self-RAG (halucinácie + užitočnosť)."""
        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):
        """Kompletná pipeline Adaptívneho RAG."""
        print(f"\n{'='*60}")
        print(f"Question: {question}")

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

        # 2. Vykonanie podľa trasy
        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)

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

            # Záloha na webe, ak nie je dostatok relevantných dokumentov
            if not relevant_docs:
                print("  No relevant documents, web fallback...")
                relevant_docs = self.search_web(question)

            # Generačná slučka s overením
            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)

            # Vrát poslednú generáciu, aj keď nie je dokonalá
            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]}...")

Tri príkladové otázky prejdú všetkými cestami v rámci jedného spustenia a pole route vo výsledku ti povie, ktorá bola zvolená. Toto je hodnota, ktorú by si mal logovať v produkcii: rozdelenie trás naprieč tvojou skutočnou prevádzkou je najlepším indikátorom zdravia tvojho systému, odhaľujúcim príliš úzky index aj zle nakalibrovaný smerovač.

Kľúčové poznatky

  • Adaptívne RAG smeruje každú otázku na optimálnu stratégiu (vektorové úložisko, web, priamo)
  • Smerovač využíva LLM so štruktúrovaným výstupom na klasifikáciu otázok
  • Otázky o indexovaných témach smerujú do vektorového úložiska; ostatné na web
  • Smerovanie znižuje latenciu a náklady vyhýbaním sa plnému RAG pri jednoduchých otázkach
  • Adaptívne RAG kombinuje myšlienky z Corrective RAG a Self-RAG so smerovaním