Adaptivní RAG
Na této stránce
Inteligentní směrování dotazů
Self-RAG zachází s každým dotazem stejně, a to je právě jeho slabina. Zeptej se ho, kolik je dva plus dva: zakóduje dotaz, prohledá index, ohodnotí čtyři irelevantní dokumenty, přepne se na web, vygeneruje odpověď a ověří ji. To je tucet volání LLM pro otázku, kterou model vyřeší okamžitě. Ne všechny dotazy mají stejnou složitost a jednoduchá faktická otázka nevyžaduje stejné zacházení jako ta, která demands syntézu z více dokumentů. Adaptivní RAG proto přidává před pipeline inteligentní směrovač: analyzuje otázku a vybere optimální strategii ještě předtím, než dojde k jakémukoli nákladnému zpracování.
Směrovač má tři cíle. Dotazy týkající se témat, která jsou skutečně pokryta tvými dokumenty, směřují do vektorového úložiště; toto je plná cesta RAG. Dotazy na aktuální události nebo mimo rozsah indexu směřují na vyhledávání na webu, protože dotazování indexu by vrátilo pouze šum. Nakonec jednoduché nebo obecné znalostní otázky dostanou přímou odpověď od modelu, bez jakékoli retrievalu.
Implementace směrovače
Trik spočívá v tom, že směrovač musí znát rozsah tvého indexu, aby mohl rozhodnout. Zvolené řešení je stejně jednoduché jako účinné: předáš mu seznam pokrytých témat, indexed_topics, který porovná s otázkou. Tři pravidla jsou explicitně uvedena v promptu a vynucený formát JSON zaručuje použitelnou hodnotu. Výraz result.get("route", "vectorstore") si zaslouží pozornost: v případě neočekávaného výstupu se výchozí hodnota vrátí k vektorovému úložišti. To je nejbezpečnější chování, které spoléhá na tvá data spíše než na web nebo paměť modelu.
import json
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def route_question(question, indexed_topics):
"""Směruje otázku k nejlepší strategii."""
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 směrovače
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}")
Sada testů ilustruje každý scénář a bude sloužit jako tvoje pojistka. Otázka týkající se mistral-embed spadá přímo do deklarovaných témat, takže směřuje do vektorového úložiště. Ceny akcií nebo výsledky soutěží se mění denně: žádný statický index je nemůže obsahovat, takže směřují na web. Dva plus dva nevyžaduje ani korpus, ani vyhledávání. Znovu použij tento blok se svými vlastními tématy a asi patnácti otázkami reprezentativními pro tvůj skutečný provoz: je to nejúspornější způsob, jak ověřit, zda je seznam topics dostatečně přesný. Směrovač, který posílá vše do vektorového úložiště, nepřináší žádnou hodnotu, a směrovač, který odpovídá přímo na tvá obchodní témata, je přímo nebezpečný.
Kompletní pipeline
AdaptiveRAG spojuje vše, co jsi vybudoval během posledních tří lekcí. Každá trasa má svou vlastní prováděcí metodu a metoda ask působí jako příkaz switch. Trasa direct se vrátí okamžitě, s teplotou 0,3, protože není třeba dodržovat žádný kontext, a s prázdným seznamem zdrojů, který uživateli čestně signalizuje, že tuto odpověď nic nepodkládá. Trasa websearch generuje pouze z výsledků z webu. Trasa vectorstore však nasazuje těžké dělostřelectvo: hodnocení dokumentů ve stylu Corrective RAG, záloha na webu, pokud žádné nepřežijí, a poté generační smyčka s kontrolami zakotvení a užitečnosti zděděnými od Self-RAG, zde seskupenými v grade_and_correct.
Jeden rozdíl v prahu stojí za zmínku oproti lekci o Corrective RAG. Záloha na webu se nespustí hned, jakmile je dokument vyřazen, ale pouze pokud je relevant_docs prázdné. Tato volba je tolerantnější: když zůstanou relevantní dva ze čtyř chunků, je rozumné s nimi generovat, než jít na web, což ušetří jedno volání a sníží latenci. Musíš rozhodnout podle požadavků své domény.
import numpy as np
class AdaptiveRAG:
"""Pipeline Adaptivního RAG s inteligentním směrováním."""
def __init__(self, chunks, embeddings, index, topics):
self.chunks = chunks
self.embeddings = embeddings
self.index = index
self.topics = topics
def route(self, question):
"""Určí optimální strategii."""
return route_question(question, self.topics)
def retrieve_from_vectorstore(self, question, k=4):
"""Retrieval z lokálního vektorového úložiště."""
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):
"""Vyhledávání na webu pro otázky mimo rozsah."""
return web_search_fallback(question)
def direct_answer(self, question):
"""Přímá odpověď bez retrievalu."""
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):
"""Generování s kontextem (klasické 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):
"""Kontroly Self-RAG (halucinace + užitečnost)."""
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):
"""Kompletní pipeline Adaptivního RAG."""
print(f"\n{'='*60}")
print(f"Question: {question}")
# 1. Směrování
route = self.route(question)
print(f"Chosen route: {route}")
# 2. Provedení podle trasy
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)
# Hodnocení dokumentů
relevant_docs = []
for doc in docs:
if grade_document(question, doc["text"]):
relevant_docs.append(doc)
# Záloha na webu, pokud není dostatek relevantních dokumentů
if not relevant_docs:
print(" No relevant documents, web fallback...")
relevant_docs = self.search_web(question)
# Generační smyčka s ověřením
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)
# Vrátí poslední generaci, i když není dokonalá
return {
"answer": generation,
"route": "vectorstore",
"attempts": max_retries + 1,
"sources": [d.get("source", "") for d in relevant_docs],
}
# Použití
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]}...")
Tři ukázkové otázky projdou všemi cestami v jediném běhu a pole route ve výsledku ti řekne, která byla zvolena. Toto je hodnota, kterou bys měl logovat v produkci: rozložení tras napříč tvým skutečným provozem je nejlepším indikátorem zdraví tvého systému, odhalující jak příliš úzký index, tak špatně nakalibrovaný směrovač.
Klíčové poznatky
- Adaptivní RAG směruje každý dotaz k optimální strategii (vektorové úložiště, web, přímá odpověď)
- Směrovač využívá LLM se strukturovaným výstupem ke klasifikaci otázek
- Otázky týkající se indexovaných témat směřují do vektorového úložiště; ostatní na web
- Směrování snižuje latenci a náklady vyhnutím se plnému RAG pro jednoduché otázky
- Adaptivní RAG kombinuje myšlenky z Corrective RAG a Self-RAG se směrováním