Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Adaptiivne RAG

Õppetund 17 / 18 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Suuna küsimusi intelligentselt
  2. Marsruutija rakendamine
  3. Täielik töövoog
  4. Peamised punktid

Suuna küsimusi intelligentselt

Self-RAG kohtleb iga küsimust ühtmoodi ja selles seisnebki selle viga. Küsi temalt, quanto fa due più due: ta kodeerib päringu, kammitseb indeksi läbi, hindab nelja ebaolulist dokumenti, lülitub veebi, genereerib vastuse ja kontrollib seda. See tähendab tosinat LLM-i väljakutset küsimusele, mille mudel lahendab silmapilkselt. Mitte kõik küsimused ei ole sama keerukad ja lihtne faktiline küsimus ei vaja sama käsitlust kui sünteesi nõudev päring, mis hõlmab mitut dokumenti. Adaptiivne RAG lisab seetõttu töövoogu enne kulusid tekitavat töötlemist intelligentse marsruutija: see analüüsib küsimust ja valib optimaalse strateegia.

Marsruutijal on kolm sihtkohta. Küsimused teemadel, mida sinu dokumendid tegelikult käsitlevad, suunatakse vektorhoidlasse; see on täielik RAG-i tee. Küsimused aktuaalsete sündmuste kohta või väljaspool indekseeritud ulatust suunatakse veebiotsingusse, kuna indeksi pärimine tooks vaid müra. Lõpuks saavad lihtsad või üldteadmisi nõudvad küsimused mudelilt otsese vastuse ilma igasuguse otsinguta.

Marsruutija rakendamine

keeruline osa on see, et marsruutija peab otsuse tegemiseks teadma sinu indeksi ulatust. Valitud lahendus on sama lihtne kui tõhus: edasta talle kaetud teemade loend indexed_topics, mida ta võrdleb küsimusega. Kolm reeglit on viibas selgelt sõnastatud ja piiratud JSON-vorming tagab kasutatava väärtuse. Avaldis result.get("route", "vectorstore") väärib tähelepanu: ootamatu väljundi korral langeb vaikeväärtus tagasi vektorhoidlale. See on kõige ohutum käitumine, tuginedes sinu andmetele, mitte veebile või mudeli mälule.

import json
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def route_question(question, indexed_topics):
    """Suuna küsimus parimale strateegiale."""
    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")

# Testi marsruutijat
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}")

Testkomplekt illustreerib iga stsenaariumi ja toimib sinu kindlustusena. Küsimus mistral-embedi kohta kuulub otseselt deklareeritud teemade hulka, seega suunatakse see vektorhoidlasse. Aktsiahinnad või võistlustulemused muutuvad iga päev: ükski staatiline indeks ei saa neid sisaldada, seega suunatakse need veebi. Kaks pluss kaks ei vaja ei korpust ega otsingut. Kasuta seda plokki oma teemade ja umbes viieteistkümne tegelikku liiklust kajastava küsimusega: see on kõige ökonoomsem viis kontrollida, kas topics-loend on piisavalt täpne. Marsruutija, mis saadab kõik vektorhoidlasse, ei lisa mingit väärtust, ja marsruutija, mis vastab otseselt sinu äriteemadele, on lausa ohtlik.

Täielik töövoog

AdaptiveRAG ühendab kõik, mida oled viimase kolme õppetunni jooksul ehitanud. Igal marsruudil on oma täitmismeetod ja ask-meetod loetakse nagu lülituslause. direct-marsruut tagastab tulemuse koheselt temperatuuriga 0,3, kuna konteksti pole, millest kinni pidada, ning tühja allikate loendiga, mis annab kasutajale ausalt märku, et seda vastust ei toeta ükski dokument. websearch-marsruut genereerib vastuse üksnes veebitulemuste põhjal. vectorstore-marsruut kasutab seevastu kogu arsenali: dokumentide hindamine Corrective RAG-i stiilis, veebi varuvariant, kui ükski dokument ellu ei jää, ning seejärel genereerimistsükkel koos põhjendatuse ja kasulikkuse kontrollidega, mis on päritud Self-RAG-ist ja siin rühmitatud funktsiooni grade_and_correct.

Üht lävendierinevust võrreldes Corrective RAG-i õppetunniga tasub märkida. Veebi varuvariant ei käivitu enam kohe, kui dokument kõrvale heidetakse, vaid ainult siis, kui relevant_docs on tühi. See valik on tolerantsem: kui neljast tükist kaks jäävad asjakohaseks, on mõistlik genereerida nende põhjal, mitte minna veebi, mis säästab ühe väljakutse ja vähendab latentsust. Pead leidma tasakaalu oma valdkonna nõudmiste põhjal.

import numpy as np

class AdaptiveRAG:
    """Adaptiivne RAG-i töövoog intelligentse marsruutimisega."""

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

    def route(self, question):
        """Määra optimaalne strateegia."""
        return route_question(question, self.topics)

    def retrieve_from_vectorstore(self, question, k=4):
        """Otsing kohalikust vektorhoidlast."""
        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):
        """Veebiotsing ulatusest väljas olevate küsimuste jaoks."""
        return web_search_fallback(question)

    def direct_answer(self, question):
        """Otsene vastus ilma otsinguta."""
        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):
        """Genereerimine kontekstiga (klassikaline 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-i kontrollid (hallutsinatsioonid + kasulikkus)."""
        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):
        """Täielik Adaptiivne RAG-i töövoog."""
        print(f"\n{'='*60}")
        print(f"Question: {question}")

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

        # 2. Täitmine vastavalt marsruudile
        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)

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

            # Veebi varuvariant, kui asjakohaseid dokumente pole piisavalt
            if not relevant_docs:
                print("  No relevant documents, web fallback...")
                relevant_docs = self.search_web(question)

            # Genereerimistsükkel kontrolliga
            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)

            # Tagasta viimane genereering isegi siis, kui see on ebatäiuslik
            return {
                "answer": generation,
                "route": "vectorstore",
                "attempts": max_retries + 1,
                "sources": [d.get("source", "") for d in relevant_docs],
            }

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

Kolm näidisküsimust läbivad ühe käivitusega kõik teed ja tulemuses olev väli route ütleb sulle, millist teed pidi mindi. See on väärtus, mida peaksid tootmises logima: marsruutide jaotus sinu reaalses liikluses on parim näitaja sinu süsteemi tervisest, paljastades nii liiga kitsa indeksi kui ka halvasti häälestatud marsruutija.

Peamised punktid

  • Adaptiivne RAG suunab iga küsimuse optimaalsele strateegiale (vektorhoidla, veeb, otsene)
  • Marsruutija kasutab struktureeritud väljundiga LLM-i küsimuste klassifitseerimiseks
  • Indekseeritud teemasid käsitlevad küsimused suunatakse vektorhoidlasse; ülejäänud suunatakse veebi
  • Marsruutimine vähendab latentsust ja kulusid, vältides täielikku RAG-i lihtsate küsimuste puhul
  • Adaptiivne RAG ühendab Corrective RAG-i ja Self-RAG-i ideid marsruutimisega