Adaptive RAG
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