Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Adaptive RAG

Lekcija 17 od 18 Ažurirano 2. studenoga 2026. Programer
Na ovoj stranici
  1. Usmjeri pitanja pametno
  2. Implementiraj usmjerivač
  3. Kompletan pipeline
  4. Ključne točke

Usmjeri pitanja pametno

Self-RAG tretira svako pitanje jednako, i upravo je to njegova mana. Pitaj ga koliko je dva plus dva: kodirat će upit, pretražiti indeks, ocijeniti četiri nebitna dokumenta, prebaciti se na web, generirati odgovor i verificirati ga. To je desetak poziva LLM-u za pitanje koje model rješava trenutno. Nisu sva pitanja iste složenosti, a jednostavno činjenično pitanje ne zahtijeva isti tretman kao ono koje zahtijeva sintezu iz više dokumenata. Adaptive RAG stoga dodaje pametni usmjerivač (intelligent router) na početak pipelinea: on analizira pitanje i odabire optimalnu strategiju prije nego što se krene u bilo kakvu skupu obradu.

Usmjerivač ima tri odredišta. Pitanja o temama koje su stvarno pokrivene tvojim dokumentima idu u vektorsku pohranu (vector store); to je puni RAG put. Pitanja o aktualnim događajima ili onima izvan opsega indeksa idu na web pretragu, jer bi upit indeksu vratio samo šum. Konačno, jednostavna pitanja ili ona općeg znanja dobivaju izravan odgovor od modela, bez ikakvog dohvaćanja podataka.

Implementiraj usmjerivač

Zahtjevan dio je što usmjerivač mora znati opseg tvog indeksa kako bi donio odluku. Odabrano rješenje jednostavno je koliko i učinkovito: proslijedi mu popis pokrivenih tema, indexed_topics, koje on uspoređuje s pitanjem. Tri su pravila eksplicitno navedena u promptu, a ograničeni JSON format jamči upotrebljivu vrijednost. Dio result.get("route", "vectorstore") zaslužuje pažnju: u slučaju neočekivanog izlaza, zadana vrijednost preusmjerava na vektorsku pohranu. To je najsigurnije ponašanje, koje se oslanja na tvoje podatke umjesto na web ili memoriju modela.

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

Skup testova ilustrira svaki scenarij i poslužit će ti kao zaštita. Pitanje o mistral-embedu jasno spada u deklarirane teme, pa ide u vektorsku pohranu. Cijene dionica ili rezultati natjecanja mijenjaju se svakodnevno: nijedan statički indeks ne može ih sadržavati, pa idu na web. Dva plus dva ne zahtijeva ni korpus ni pretragu. Ponovno iskoristi ovaj blok sa svojim temama i petnaestak pitanja reprezentativnih za tvoj stvarni promet: to je najekonomičniji način da provjeriš je li popis topics dovoljno točan. Usmjerivač koji sve šalje u vektorsku pohranu ne donosi vrijednost, a usmjerivač koji izravno odgovara na tvoje poslovne teme izravno je opasan.

Kompletan pipeline

AdaptiveRAG objedinjuje sve što si izgradio u posljednje tri lekcije. Svaka ruta ima svoju metodu izvršavanja, a metoda ask čita se poput switch naredbe. Ruta direct vraća rezultat odmah, s temperaturom od 0,3 jer nema konteksta kojeg se treba držati, i praznim popisom izvora koji iskreno signalizira korisniku da ništa ne podupire ovaj odgovor. Ruta websearch generira isključivo iz web rezultata. Ruta vectorstore, međutim, razmješta svu artiljeriju: ocjenjivanje dokumenata u stilu Corrective RAG-a, web rezervu ako ništa ne preživi, zatim petlju generiranja s provjerama utemeljenosti i korisnosti naslijeđenim od Self-RAG-a, ovdje grupiranima u grade_and_correct.

Jedna razlika u pragu vrijedi napomene u usporedbi s lekcijom o Corrective RAG-u. Web rezerva se više ne aktivira čim se dokument odbaci, već samo ako je relevant_docs prazan. Ovaj je izbor tolerantniji: kada dva od četiri chunka ostanu relevantna, razumno je generirati s njima umjesto ići na web, što štedi jedan poziv i smanjuje kašnjenje. Moraš arbitrirati na temelju zahtjeva svoje domene.

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

Tri primjera pitanja prolaze kroz sve putove u jednom pokretanju, a polje route u rezultatu govori ti koji je put odabran. To je vrijednost koju trebaš bilježiti u produkciji: distribucija ruta kroz tvoj stvarni promet najbolji je pokazatelj zdravlja tvog sustava, otkrivajući i indeks koji je preuzak i loše kalibriran usmjerivač.

Ključne točke

  • Adaptive RAG usmjerava svako pitanje na optimalnu strategiju (vektorska pohrana, web, izravno)
  • Usmjerivač koristi LLM sa strukturiranim izlazom za klasifikaciju pitanja
  • Pitanja o indeksiranim temama idu u vektorsku pohranu; ostala idu na web
  • Usmjeravanje smanjuje kašnjenje i troškove izbjegavanjem punog RAG-a za jednostavna pitanja
  • Adaptive RAG kombinira ideje iz Corrective RAG-a i Self-RAG-a s usmjeravanjem