Przejdź do głównej treści
Polski— Wybierz język
Menu

Adaptive RAG

Lekcja 17 z 18 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Kieruj pytaniami inteligentnie
  2. Implementacja routera
  3. Kompletny potok
  4. Kluczowe wnioski

Kieruj pytaniami inteligentnie

Self-RAG traktuje każde pytanie tak samo i właśnie w tym tkwi jego wada. Zapytaj go, ile wynosi dwa plus dwa: zakoduje zapytanie, przeszuka indeks, oceni cztery nieistotne dokumenty, przełączy się na sieć, wygeneruje odpowiedź i ją zweryfikuje. To tuzin wywołań LLM dla pytania, które model rozwiązuje natychmiast. Nie wszystkie pytania mają ten sam poziom złożoności, a proste pytanie faktograficzne nie wymaga takiego samego podejścia jak pytanie wymagające syntezy informacji z wielu dokumentów. Adaptive RAG dodaje zatem na początku potoku inteligentny router: analizuje on pytanie i wybiera optymalną strategię przed rozpoczęciem jakiegokolwiek kosztownego przetwarzania.

Router ma trzy cele wyjściowe. Pytania dotyczące tematów faktycznie objętych Twoimi dokumentami trafiają do wektorowej bazy danych (vector store); jest to pełna ścieżka RAG. Pytania dotyczące bieżących wydarzeń lub wykraczające poza zakres indeksu trafiają do wyszukiwarki internetowej, ponieważ odpytanie indeksu zwróciłoby tylko szum. Wreszcie, proste pytania lub te dotyczące wiedzy ogólnej otrzymują bezpośrednią odpowiedź od modelu, bez żadnego pobierania danych.

Implementacja routera

Najtrudniejszą częścią jest to, że router musi znać zakres Twojego indeksu, aby podjąć decyzję. Wybrane rozwiązanie jest tak proste, jak i skuteczne: przekazujesz mu listę objętych tematów, indexed_topics, którą porównuje on z pytaniem. Trzy zasady są wyraźnie stated w prompcie, a ograniczony format JSON gwarantuje uzyskanie użytecznej wartości. Na result.get("route", "vectorstore") warto zwrócić uwagę: w przypadku nieoczekiwanego wyniku domyślnym zachowaniem jest powrót do bazy wektorowej. Jest to najbezpieczniejsze podejście, polegające na Twoich danych, a nie na sieci czy pamięci modelu.

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

Zestaw testowy ilustruje każdy scenariusz i posłuży Ci jako zabezpieczenie. Pytanie o mistral-embed wpisuje się idealnie w zadeklarowane tematy, więc trafia do bazy wektorowej. Kursy akcji lub wyniki zawodów zmieniają się codziennie: żaden statyczny indeks nie może ich zawierać, więc trafiają do sieci. Dwa plus dwa nie wymaga ani korpusu, ani wyszukiwania. Wykorzystaj ten blok ze swoimi własnymi tematami i około piętnastoma pytaniami reprezentatywnymi dla Twojego rzeczywistego ruchu: to najbardziej ekonomiczny sposób na weryfikację, czy lista topics jest wystarczająco dokładna. Router, który kieruje wszystko do bazy wektorowej, nie wnosi żadnej wartości, a router odpowiadający bezpośrednio na pytania dotyczące Twojej domeny biznesowej jest wręcz niebezpieczny.

Kompletny potok

AdaptiveRAG łączy wszystko, co zbudowałeś w ciągu ostatnich trzech lekcji. Każda trasa ma swoją własną metodę wykonania, a metoda ask czyta się jak instrukcja switch. Trasa direct zwraca wynik natychmiast, z temperaturą 0,3, ponieważ nie ma kontekstu, do którego trzeba by się stosować, oraz pustą listą źródeł, która uczciwie sygnalizuje użytkownikowi, że nic nie stoi za tą odpowiedzią. Trasa websearch generuje odpowiedź wyłącznie na podstawie wyników z sieci. Trasa vectorstore uruchamia jednak całą artylerię: ocenę dokumentów w stylu Corrective RAG, awaryjne przejście do sieci, jeśli żaden dokument nie przetrwa, a następnie pętlę generowania z kontrolą osadzenia w faktach i użyteczności, odziedziczoną po Self-RAG, zgrupowaną tutaj w grade_and_correct.

Warto zauważyć jedną różnicę w progu w porównaniu z lekcją o Corrective RAG. Awaryjne przejście do sieci nie uruchamia się już w momencie odrzucenia dokumentu, ale tylko wtedy, gdy relevant_docs jest puste. Ten wybór jest bardziej tolerancyjny: gdy dwa z czterech fragmentów pozostają istotne, rozsądne jest generowanie na ich podstawie, zamiast przechodzić do sieci, co oszczędza jedno wywołanie i zmniejsza opóźnienie. Musisz dokonać arbitrażu w zależności od wymagań swojej domeny.

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

Trzy przykładowe pytania przeprowadzają Cię przez wszystkie ścieżki w jednym uruchomieniu, a pole route w wyniku informuje, którą z nich obrano. Jest to wartość, którą powinieneś logować w środowisku produkcyjnym: rozkład tras w Twoim rzeczywistym ruchu jest najlepszym wskaźnikiem zdrowia systemu, ujawniającym zarówno zbyt wąski indeks, jak i źle skalibrowany router.

Kluczowe wnioski

  • Adaptive RAG kieruje każde pytanie do optymalnej strategii (vectorstore, sieć, odpowiedź bezpośrednia)
  • Router wykorzystuje LLM ze strukturyzowanym wyjściem do klasyfikacji pytań
  • Pytania dotyczące tematów zindeksowanych trafiają do bazy wektorowej; pozostałe do sieci
  • Routing redukuje opóźnienia i koszty, unikając pełnego RAG dla prostych pytań
  • Adaptive RAG łączy idee z Corrective RAG i Self-RAG z mechanizmem routingu