Адаптивен RAG
На тази страница
Интелигентно насочване на въпросите
Self-RAG прилага едно и също лечение към всеки въпрос и точно в това се крие неговият недостатък. Попитайте го колко прави две плюс две: той ще кодира заявката, ще претърси индекса, ще оцени четири нерелевантни документа, ще превключи към уеб търсене, ще генерира отговор и ще го верифицира. Това са дузина повиквания към LLM за въпрос, който моделът решава мигновено. Не всички въпроси имат еднаква сложност и един прост фактологичен въпрос не изисква същото отношение като такъв, който изисква синтез на информация от множество документи. Адаптивният RAG следователно добавя интелигентен маршрутизатор в началото на пайплайна: той анализира въпроса и избира оптималната стратегия, преди да започне каквато и да е скъпа обработка.
Маршрутизаторът има три дестинации. Въпросите относно теми, които действително са обхванати от Вашите документи, отиват към векторното хранилище; това е пълният RAG път. Въпросите относно текущи събития или извън обхвата на индекса отиват към уеб търсене, тъй като заявката към индекса би върнала само шум. Накрая, простите въпроси или тези за общи знания получават директен отговор от модела, без никакво извличане на информация.
Имплементиране на маршрутизатора
Трудната част е, че маршрутизаторът трябва да познава обхвата на Вашия индекс, за да вземе решение. Избраното решение е толкова просто, колкото и ефективно: му се предава списъкът с обхванатите теми, indexed_topics, който той сравнява със въпроса. Трите правила са формулирани изрично в промпта, а ограниченият JSON формат гарантира използваема стойност. Изразът result.get("route", "vectorstore") заслужава внимание: в случай на неочакван изход, по подразбиране системата се връща към векторното хранилище. Това е най-безопасното поведение, което разчита на Вашите данни, а не на уеб мрежата или паметта на модела.
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}")
Тестовият набор илюстрира всеки сценарий и ще послужи като Ваша гаранция за сигурност. Въпросът за mistral-embed попада изцяло в рамките на обявените теми, затова отива във векторното хранилище. Цените на акциите или резултатите от състезания се променят ежедневно: никой статичен индекс не може да ги съдържа, затова те отиват в уеб мрежата. Две плюс две не изисква нито корпус, нито търсене. Използвайте отново този блок със собствените си теми и около петнадесет въпроса, представителни за реалния Ви трафик: това е най-икономичният начин да проверите дали списъкът с topics е достатъчно точен. Маршрутизатор, който изпраща всичко към векторното хранилище, не добавя стойност, а такъв, който отговаря директно на Вашите бизнес теми, е направо опасен.
Пълният пайплайн
AdaptiveRAG обединява всичко, което сте изградили през последните три урока. Всеки маршрут има свой собствен метод за изпълнение, а методът ask прилича на инструкция switch. Маршрутът direct връща резултат незабавно, с температура 0.3, тъй като няма контекст, към който да се придържа, и празен списък с източници, който честно сигнализира на потребителя, че нищо не подкрепя този отговор. Маршрутът websearch генерира отговор единствено въз основа на уеб резултатите. Маршрутът vectorstore обаче разгръща цялата артилерия: оценяване на документите в стила на Corrective RAG, резервно уеб търсене, ако нищо не оцелее, след което цикъл на генериране с проверки за обоснованост и полезност, наследени от Self-RAG, групирани тук в grade_and_correct.
Заслужава да се отбележи една разлика в прага спрямо урока за Corrective RAG. Резервното уеб търсене вече не се задейства веднага щом един документ бъде отхвърлен, а само ако relevant_docs е празно. Този избор е по-толерантен: когато два от четири чънка остават релевантни, е разумно да се генерира с тях, вместо да се отива в уеб мрежата, което спестява едно повикване и намалява латентността. Трябва да направите преценка въз основа на изискванията на Вашата предметна област.
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]}...")
Трите примерни въпроса преминават през всички пътища в едно изпълнение, а полето route в резултата Ви показва кой път е избран. Това е стойността, която трябва да записвате в логовете при продуктивна употреба: разпределението на маршрутите спрямо реалния Ви трафик е най-добрият индикатор за здравето на Вашата система, разкривайки както твърде тесен индекс, така и лошо калибриран маршрутизатор.
Ключови изводи
- Адаптивният RAG насочва всеки въпрос към оптималната стратегия (векторно хранилище, уеб, директно)
- Маршрутизаторът използва LLM със структуриран изход за класифициране на въпросите
- Въпросите относно индексирани теми отиват във векторното хранилище; останалите отиват в уеб мрежата
- Насочването намалява латентността и разходите, като избягва пълния RAG процес за прости въпроси
- Адаптивният RAG комбинира идеи от Corrective RAG и Self-RAG с интелигентно насочване