Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Adaptive RAG

Oppitunti 17 / 18 Päivitetty 2. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Reittitä kysymykset älykkäästi
  2. Reittittimen toteutus
  3. Koko putkisto
  4. Keskeiset asiat

Reittitä kysymykset älykkäästi

Self-RAG kohtelee jokaista kysymystä samalla tavalla, ja juuri siinä piilee sen heikkous. Kysy siltä, paljonko on kaksi plus kaksi: se koodaa kyselyn, seuloo indeksin, arvioi neljä epäoleellista dokumenttia, siirtyy verkkoon, generoi vastauksen ja tarkistaa sen. Tusina LLM-kutsuja kysymykseen, jonka malli ratkaisee välittömästi. Kaikki kysymykset eivät ole yhtä monimutkaisia, eikä yksinkertainen faktakysymys vaadi samaa käsittelyä kuin useiden dokumenttien synteesiä vaativa kysymys. Adaptive RAG lisää siksi putkiston eteen älykkään reittittimen: se analysoi kysymyksen ja valitsee optimaalisen strategian ennen kuin ryhtyy mihinkään kalliiseen käsittelyyn.

Reittittimellä on kolme määränpäätä. Kysymykset, jotka koskevat dokumenttiesi kattamia aiheita, ohjataan vektorisäilöön; tämä on koko RAG-polku. Kysymykset ajankohtaisista tapahtumista tai indeksoidun alueen ulkopuolelta ohjataan verkkohakuun, sillä indeksin kysyminen tuottaisi vain kohinaa. Lopuksi hyvin yksinkertaiset tai yleiseen tietämykseen perustuvat kysymykset saavat suoran vastauksen mallilta ilman minkäänlaista hakua.

Reittittimen toteutus

Haastavaa on, että reittittimen on tunnettava indeksisi laajuus pystyäkseen tekemään päätöksen. Valittu ratkaisu on yhtä yksinkertainen kuin tehokas: sille syötetään katettujen aiheiden lista, indexed_topics, jota se vertaa kysymykseen. Kolme sääntöä on määritelty eksplisiittisesti kehotteessa, ja rajoitettu JSON-muoto takaa käyttökelpoisen arvon. Huomiota vaatii lauseke result.get("route", "vectorstore"): odottamattoman tulosteen sattuessa oletusarvona toimii vektorisäilö. Tämä on turvallisin toimintatapa, joka luottaa omaan dataasi verkon tai mallin muistin sijaan.

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

Testijoukko havainnollistaa jokaista skenaariota ja toimii varmistuksenasi. Kysymys mistral-embedistä osuu suoraan ilmoitettujen aiheiden piiriin, joten se ohjataan vektorisäilöön. Osakekurssit tai kilpailutulokset muuttuvat päivittäin: mikään staattinen indeksi ei voi sisältää niitä, joten ne ohjataan verkkoon. Kaksi plus kaksi ei vaadi neither tekstikorpus että hakua. Käytä tätä lohkoa omien aiheidesi kanssa ja noin viidellätoista kysymyksellä, jotka edustavat todellista liikennettäsi: tämä on taloudellisin tapa varmistaa, että topics-lista on riittävän tarkka. Reititin, joka lähettää kaiken vektorisäilöön, ei tuota lisäarvoa, ja reititin, joka vastaa suoraan liiketoimintasi aiheisiin, on suorastaan vaarallinen.

Koko putkisto

AdaptiveRAG yhdistää kaiken, mitä olet rakentanut viimeisen kolmen oppitunnin aikana. Jokaisella reitillä on oma toteutusmetodinsa, ja ask-metodi lukee kuin switch-lauseke. direct-reitti palauttaa tuloksen välittömästi lämpötilalla 0,3, koska kontekstia ei tarvitse noudattaa, sekä tyhjällä lähteiden listalla, joka kertoo rehellisesti käyttäjälle, ettei vastauksen taustalla ole mitään dataa. websearch-reitti generoi vastauksen yksinomaan verkkotulosten pohjalta. vectorstore-reitti sen sijaan ottaa käyttöön koko arsenaalin: dokumenttien arviointi Corrective RAG -tyyliin, verkkovarmistus, jos mikään dokumentti ei selviydy, ja sen jälkeen generointisilmukka perustuvuus- ja hyödyllisyystarkistuksineen, jotka on peritty Self-RAGista ja koottu tähän funktioon grade_and_correct.

Yksi kynnysarvoero Corrective RAG -oppituntiin verrattuna on syytä huomata. Verkkovarmistus ei enää käynnisty heti, kun dokumentti hylätään, vaan vain, jos relevant_docs on tyhjä. Tämä valinta on suvaitsevampi: jos neljästä chunkista kaksi pysyy oleellisena, on järkevää generoida niillä kuin siirtyä verkkoon, mikä säästää yhden kutsun ja vähentää viivettä. Sinun on tehtävä kompromissi toimialasi vaatimusten perusteella.

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

Kolme esimerkkikysymystä käyvät läpi kaikki polut yhdellä ajokerralla, ja tuloksen route-kenttä kertoo, mitä reittiä käytettiin. Tämä on arvo, joka sinun kannattaa kirjata tuotantoympäristössä: reittien jakautuminen todellisessa liikenteessäsi on paras järjestelmäsi terveysmittari, joka paljastaa niin liian kapean indeksin kuin huonosti kalibroidun reittittimenkin.

Keskeiset asiat

  • Adaptive RAG reittittää jokaisen kysymyksen optimaaliseen strategiaan (vektorisäilö, verkko, suora)
  • Reititin käyttää LLM:ää jäsennellyllä tulosteella kysymysten luokitteluun
  • Indeksoituja aiheita koskevat kysymykset ohjataan vektorisäilöön; muut ohjataan verkkoon
  • Reititys vähentää viivettä ja kustannuksia välttämällä koko RAG-prosessia yksinkertaisissa kysymyksissä
  • Adaptive RAG yhdistää Corrective RAGin ja Self-RAGin ideat reitytykseen