Salt la conținutul principal
Română— Alege o limbă
Meniu

RAG adaptativ

Lecția 17 din 18 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Dirijarea inteligentă a întrebărilor
  2. Implementarea routerului
  3. Pipeline-ul complet
  4. Puncte cheie

Dirijarea inteligentă a întrebărilor

Self-RAG aplică același tratament fiecărei întrebări, iar aceasta este tocmai slăbiciunea sa. Întrebați-l cât face doi plus doi: va codifica interogarea, va scotoci prin index, va evalua patru documente irelevante, va comuta pe web, va genera și va verifica. Aceasta înseamnă o duzină de apeluri LLM pentru o întrebare pe care un model o rezolvă instantaneu. Nu toate întrebările au aceeași complexitate, iar o întrebare factuală simplă nu necesită același tratament ca una care cere sinteza mai multor documente. RAG-ul adaptativ adaugă, prin urmare, un router inteligent în amonte de pipeline: acesta analizează întrebarea și selectează strategia optimă înainte de a angaja orice procesare costisitoare.

Routerul are trei destinații. Întrebările despre subiecte acoperite efectiv de documentele dumneavoastră merg către stocul vectorial; aceasta este calea RAG completă. Întrebările despre evenimente curente sau din afara domeniului indexat merg către căutarea pe web, deoarece interogarea indexului ar returna doar zgomot. În final, întrebările simple sau de cultură generală primesc un răspuns direct de la model, fără nicio recuperare.

Implementarea routerului

Partea delicată este că routerul trebuie să cunoască domeniul de aplicare al indexului dumneavoastră pentru a lua o decizie. Soluția aleasă este la fel de simplă pe cât de eficientă: i se transmite lista subiectelor acoperite, indexed_topics, pe care o compară cu întrebarea. Cele trei reguli sunt enunțate explicit în prompt, iar formatul JSON constrâns garantează o valoare utilizabilă. Expresia result.get("route", "vectorstore") merită atenție: în cazul unui rezultat neașteptat, valoarea implicită revine la stocul vectorial. Acesta este comportamentul cel mai sigur, bazându-se pe datele dumneavoastră plutôt decât pe web sau pe memoria modelului.

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

Setul de teste ilustrează fiecare scenariu și va servi drept garanție pentru dumneavoastră. O întrebare despre mistral-embed se încadrează perfect în subiectele declarate, deci merge la stocul vectorial. Prețurile acțiunilor sau rezultatele competițiilor se schimbă zilnic: niciun index static nu le poate conține, așa că merg pe web. Doi plus doi nu necesită nici corpus, nici căutare. Reutilizați acest bloc cu propriile subiecte și aproximativ cincisprezece întrebări reprezentative pentru traficul dumneavoastră real: aceasta este cea mai economică modalitate de a verifica dacă lista topics este suficient de precisă. Un router care trimite totul la stocul vectorial nu aduce nicio valoare, iar un router care răspunde direct pe subiectele dumneavoastră de activitate este direct periculos.

Pipeline-ul complet

AdaptiveRAG reunește tot ceea ce ați construit în ultimele trei lecții. Fiecare rută are propria metodă de execuție, iar metoda ask se citește ca o instrucțiune switch. Ruta direct returnează imediat, cu o temperatură de 0,3 deoarece nu există niciun context de respectat, și o listă de surse goală care semnalează onest utilizatorului că nimic nu susține acest răspuns. Ruta websearch generează exclusiv din rezultatele web. Ruta vectorstore, însă, desfășoară toată artileria: evaluarea documentelor în stilul Corrective RAG, fallback pe web dacă niciunul nu supraviețuiește, apoi o buclă de generare cu verificări de ancorare și utilitate moștenite de la Self-RAG, grupate aici în grade_and_correct.

O diferență de prag merită menționată în comparație cu lecția despre Corrective RAG. Fallback-ul pe web nu se mai declanșează imediat ce un document este eliminat, ci doar dacă relevant_docs este gol. Această alegere este mai tolerantă: când două din patru fragmente rămân relevante, este rezonabil să se genereze cu ele plutôt decât să se meargă pe web, ceea ce economisește un apel și reduce latența. Trebuie să arbitrați în funcție de cerințele domeniului dumneavoastră.

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

Cele trei întrebări exemplu parcurg toate căile într-o singură execuție, iar câmpul route din rezultat vă indică pe care a fost aleasă. Aceasta este valoarea pe care ar trebui să o înregistrați în producție: distribuția rutelor în traficul dumneavoastră real este cel mai bun indicator de sănătate pentru sistemul dumneavoastră, revelând atât un index prea îngust, cât și un router calibrat necorespunzător.

Puncte cheie

  • RAG-ul adaptativ dirijează fiecare întrebare către strategia optimă (vectorstore, web, direct)
  • Routerul utilizează un LLM cu ieșire structurată pentru a clasifica întrebările
  • Întrebările despre subiectele indexate merg la stocul vectorial; restul merg pe web
  • Dirijarea reduce latența și costurile evitând RAG-ul complet pentru întrebările simple
  • RAG-ul adaptativ combină ideile din Corrective RAG și Self-RAG cu dirijarea