Adaptive RAG
Reittitä kysymykset älykkäästi
Self-RAG kohtelee jokaista kysymystä samalla tavalla, ja juuri siinä piilee sen heikkous. Kysy siltä, paljonko on kaksi plus kaksi: se koodaa kyselyn, seuloo indeksin, arvioi neljä epäoleellista dokumenttia, siirtyy verkkoon, generoi vastauksen ja tarkistaa sen. Tusina LLM-kutsuja kysymykseen, jonka malli ratkaisee välittömästi. Kaikki kysymykset eivät ole yhtä monimutkaisia, eikä yksinkertainen faktakysymys vaadi samaa käsittelyä kuin useiden dokumenttien synteesiä vaativa kysymys. Adaptive RAG lisää siksi putkiston eteen älykkään reittittimen: se analysoi kysymyksen ja valitsee optimaalisen strategian ennen kuin ryhtyy mihinkään kalliiseen käsittelyyn.
Reittittimellä on kolme määränpäätä. Kysymykset, jotka koskevat dokumenttiesi kattamia aiheita, ohjataan vektorisäilöön; tämä on koko RAG-polku. Kysymykset ajankohtaisista tapahtumista tai indeksoidun alueen ulkopuolelta ohjataan verkkohakuun, sillä indeksin kysyminen tuottaisi vain kohinaa. Lopuksi hyvin yksinkertaiset tai yleiseen tietämykseen perustuvat kysymykset saavat suoran vastauksen mallilta ilman minkäänlaista hakua.
Reittittimen toteutus
Haastavaa on, että reittittimen on tunnettava indeksisi laajuus pystyäkseen tekemään päätöksen. Valittu ratkaisu on yhtä yksinkertainen kuin tehokas: sille syötetään katettujen aiheiden lista, indexed_topics, jota se vertaa kysymykseen. Kolme sääntöä on määritelty eksplisiittisesti kehotteessa, ja rajoitettu JSON-muoto takaa käyttökelpoisen arvon. Huomiota vaatii lauseke result.get("route", "vectorstore"): odottamattoman tulosteen sattuessa oletusarvona toimii vektorisäilö. Tämä on turvallisin toimintatapa, joka luottaa omaan dataasi verkon tai mallin muistin sijaan.
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}")
Testijoukko havainnollistaa jokaista skenaariota ja toimii varmistuksenasi. Kysymys mistral-embedistä osuu suoraan ilmoitettujen aiheiden piiriin, joten se ohjataan vektorisäilöön. Osakekurssit tai kilpailutulokset muuttuvat päivittäin: mikään staattinen indeksi ei voi sisältää niitä, joten ne ohjataan verkkoon. Kaksi plus kaksi ei vaadi neither tekstikorpus että hakua. Käytä tätä lohkoa omien aiheidesi kanssa ja noin viidellätoista kysymyksellä, jotka edustavat todellista liikennettäsi: tämä on taloudellisin tapa varmistaa, että topics-lista on riittävän tarkka. Reititin, joka lähettää kaiken vektorisäilöön, ei tuota lisäarvoa, ja reititin, joka vastaa suoraan liiketoimintasi aiheisiin, on suorastaan vaarallinen.
Koko putkisto
AdaptiveRAG yhdistää kaiken, mitä olet rakentanut viimeisen kolmen oppitunnin aikana. Jokaisella reitillä on oma toteutusmetodinsa, ja ask-metodi lukee kuin switch-lauseke. direct-reitti palauttaa tuloksen välittömästi lämpötilalla 0,3, koska kontekstia ei tarvitse noudattaa, sekä tyhjällä lähteiden listalla, joka kertoo rehellisesti käyttäjälle, ettei vastauksen taustalla ole mitään dataa. websearch-reitti generoi vastauksen yksinomaan verkkotulosten pohjalta. vectorstore-reitti sen sijaan ottaa käyttöön koko arsenaalin: dokumenttien arviointi Corrective RAG -tyyliin, verkkovarmistus, jos mikään dokumentti ei selviydy, ja sen jälkeen generointisilmukka perustuvuus- ja hyödyllisyystarkistuksineen, jotka on peritty Self-RAGista ja koottu tähän funktioon grade_and_correct.
Yksi kynnysarvoero Corrective RAG -oppituntiin verrattuna on syytä huomata. Verkkovarmistus ei enää käynnisty heti, kun dokumentti hylätään, vaan vain, jos relevant_docs on tyhjä. Tämä valinta on suvaitsevampi: jos neljästä chunkista kaksi pysyy oleellisena, on järkevää generoida niillä kuin siirtyä verkkoon, mikä säästää yhden kutsun ja vähentää viivettä. Sinun on tehtävä kompromissi toimialasi vaatimusten perusteella.
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]}...")
Kolme esimerkkikysymystä käyvät läpi kaikki polut yhdellä ajokerralla, ja tuloksen route-kenttä kertoo, mitä reittiä käytettiin. Tämä on arvo, joka sinun kannattaa kirjata tuotantoympäristössä: reittien jakautuminen todellisessa liikenteessäsi on paras järjestelmäsi terveysmittari, joka paljastaa niin liian kapean indeksin kuin huonosti kalibroidun reittittimenkin.
Keskeiset asiat
- Adaptive RAG reittittää jokaisen kysymyksen optimaaliseen strategiaan (vektorisäilö, verkko, suora)
- Reititin käyttää LLM:ää jäsennellyllä tulosteella kysymysten luokitteluun
- Indeksoituja aiheita koskevat kysymykset ohjataan vektorisäilöön; muut ohjataan verkkoon
- Reititys vähentää viivettä ja kustannuksia välttämällä koko RAG-prosessia yksinkertaisissa kysymyksissä
- Adaptive RAG yhdistää Corrective RAGin ja Self-RAGin ideat reitytykseen