Adaptivni RAG
Na tej strani
Pametno usmerjanje vprašanj
Self-RAG obravnava vsako vprašanje enako, kar je prav njegova pomanjkljivost. Vprašaj ga, koliko je dva plus dva: kodiral bo poizvedbo, preiskal indeks, ocenil štiri nepomembne dokumente, preklopil na splet, generiral odgovor in ga preveril. To je ducat klicev LLM za vprašanje, ki ga model reši takoj. Ni vsako vprašanje enako kompleksno in preprosto dejansko vprašanje ne zahteva enake obravnave kot tisto, ki zahteva sintezo iz več dokumentov. Adaptivni RAG zato dodaja pametni usmerjevalnik pred cevovod: analizira vprašanje in izbere optimalno strategijo, preden se loti kakršnega koli dragega procesiranja.
Usmerjevalnik ima tri cilje. Vprašanja o temah, ki jih vaši dokumenti dejansko pokrivajo, gredo v vektorsko shrambo; to je polna pot RAG. Vprašanja o trenutnih dogodkih ali zunaj obsega indeksa gredo na spletno iskanje, saj bi poizvedba v indeksu vrnila le šum. Nazadnje, preprosta vprašanja ali vprašanja splošnega znanja prejmejo neposreden odgovor od modela, brez kakršnega koli pridobivanja podatkov.
Implementacija usmerjevalnika
Težaven del je, da mora usmerjevalnik poznati obseg vašega indeksa, da lahko sprejme odločitev. Izbrana rešitev je tako preprosta kot učinkovita: posredujete mu seznam pokritih tem, indexed_topics, ki jih primerja z vprašanjem. Tri pravila so v pozivu navedena izrecno, omejeni format JSON pa zagotavlja uporabno vrednost. Pozornost si zasluži result.get("route", "vectorstore"): v primeru nepričakovanega izhoda se privzeto vrne v vektorsko shrambo. To je najvarnejše obnašanje, ki se zanaša na vaše podatke namesto na splet ali spomin modela.
import json
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def route_question(question, indexed_topics):
"""Usmeri vprašanje na najboljšo strategijo."""
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}")
Nabor testov ponazarja vsak scenarij in bo služil kot vaša varovalka. Vprašanje o mistral-embed spada neposredno med deklarirane teme, zato gre v vektorsko shrambo. Tečaji delnic ali rezultati tekmovanj se spreminjajo dnevno: noben statični indeks jih ne more vsebovati, zato gredo na splet. Dva plus dva ne zahtevata niti korpusa niti iskanja. Ponovno uporabite ta blok s svojimi temami in približno petnajstimi vprašanji, ki so reprezentativna za vaš dejanski promet: to je najbolj ekonomičen način za preverjanje, ali je seznam topics dovolj natančen. Usmerjevalnik, ki vse pošlje v vektorsko shrambo, nima nobene vrednosti, usmerjevalnik, ki neposredno odgovarja na vaša poslovna vprašanja, pa je naravnost nevaren.
Celoten cevovod
AdaptiveRAG združuje vse, kar ste zgradili v zadnjih treh lekcijah. Vsaka pot ima svojo metodo izvajanja, metoda ask pa deluje kot stikalo. Pot direct se vrne takoj, s temperaturo 0,3, saj ni konteksta, ki bi se ga bilo treba držati, in praznim seznamom virov, ki uporabniku pošteno sporoča, da ta odgovor nima opore. Pot websearch generira izključno iz spletnih rezultatov. Pot vectorstore pa uporabi vso artilerijo: ocenjevanje dokumentov v slogu Corrective RAG, spletno nadomestilo, če noben ne preživi, nato pa zanko generiranja s preverjanji utemeljenosti in uporabnosti, podedovanimi iz Self-RAG, tukaj združenimi v grade_and_correct.
Omeniti velja eno razliko v pragu v primerjavi z lekcijo o Corrective RAG. Spletno nadomestilo se ne sproži takoj, ko je dokument zavržen, ampak le, če je relevant_docs prazen. Ta izbira je bolj strpna: ko sta dva od štirih delčkov še vedno pomembna, je smiselno generirati z njimi, namesto da bi šli na splet, kar prihrani klic in zmanjša zakasnitev. Odločitev morate sprejeti glede na zahteve vaše domene.
import numpy as np
class AdaptiveRAG:
"""Cevovod Adaptivni RAG s pametnim usmerjanjem."""
def __init__(self, chunks, embeddings, index, topics):
self.chunks = chunks
self.embeddings = embeddings
self.index = index
self.topics = topics
def route(self, question):
"""Določi optimalno strategijo."""
return route_question(question, self.topics)
def retrieve_from_vectorstore(self, question, k=4):
"""Pridobivanje iz lokalne vektorske shrambe."""
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):
"""Spletno iskanje za vprašanja zunaj obsega."""
return web_search_fallback(question)
def direct_answer(self, question):
"""Neposreden odgovor brez pridobivanja podatkov."""
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):
"""Generiranje s kontekstom (klasični 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):
"""Preverjanja Self-RAG (halucinacije + uporabnost)."""
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):
"""Celoten cevovod Adaptivni RAG."""
print(f"\n{'='*60}")
print(f"Question: {question}")
# 1. Usmerjanje
route = self.route(question)
print(f"Chosen route: {route}")
# 2. Izvajanje glede na pot
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)
# Ocenjevanje dokumentov
relevant_docs = []
for doc in docs:
if grade_document(question, doc["text"]):
relevant_docs.append(doc)
# Spletno nadomestilo, če ni dovolj pomembnih dokumentov
if not relevant_docs:
print(" No relevant documents, web fallback...")
relevant_docs = self.search_web(question)
# Zanka generiranja s preverjanjem
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)
# Vrni zadnje generiranje, čeprav je nepopolno
return {
"answer": generation,
"route": "vectorstore",
"attempts": max_retries + 1,
"sources": [d.get("source", "") for d in relevant_docs],
}
# Uporaba
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 primerjalna vprašanja prehodijo vse poti v enem zagonu, polje route v rezultatu pa vam pove, katera je bila izbrana. To je vrednost, ki jo morate beležiti v produkciji: porazdelitev poti skozi vaš dejanski promet je najboljši pokazatelj zdravja vašega sistema, ki razkriva tako preozek indeks kot slabo umerjen usmerjevalnik.
Ključne ugotovitve
- Adaptivni RAG usmeri vsako vprašanje na optimalno strategijo (vektorska shramba, splet, neposredno)
- Usmerjevalnik uporablja LLM s strukturiranim izhodom za razvrščanje vprašanj
- Vprašanja o indeksiranih temah gredo v vektorsko shrambo; ostala gredo na splet
- Usmerjanje zmanjša zakasnitev in stroške z izogibanjem polnemu RAG za preprosta vprašanja
- Adaptivni RAG združuje ideje iz Corrective RAG in Self-RAG z usmerjanjem