Corrective RAG
Sellel lehel
Kui otsingust ei piisa
Sinu loodud RAG-süsteem tugineb vaikimisi eeldusele: küsimusega kõige sarnasemad tükid on õiged. See eeldus kehtib sageli, kuid mitte alati. Kui pärid oma indeksilt teemat, mida see ei kata, tagastab FAISS ikkagi viis lähimat vektorit, olenemata sellest, kui võõrast teemat need käsitlevad – sarnasusmootor ei oska öelda „mul pole midagi“. Mudel saab seejärel sobimatu konteksti ja kuna vihje palub tal sellele kontekstile tugineda, toodab ta vastuse, mis näib autoriteetne, kuid millel puudub alus. See on kõige salakavalam hallutsinatsioonistsenaarium, sest tehniline ahel töötas veatult.
Corrective RAG (CRAG) lisab otsingu ja genereerimise vahele hindamise etapi. Suur keelemudel (LLM) analüüsib iga leitud dokumenti ja otsustab: asjakohane või mitte. Kui otsus on negatiivne, ei genereeri süsteem lihtsalt olemasolevaga – see lülitub ümber veebiotsingule, et leida teavet, mida sinu korpusest puudu on. Voog koosneb seega neljast etapist: standardne otsing vektorpoest, iga dokumendi hindamine küsimuse suhtes, otsus käivitada veebiotsing, kui vähemalt üks dokument tunnistatakse ebaasjakohaseks, ja lõpuks vastuse genereerimine parimate saadaolevate dokumentide põhjal.
Dokumendi hindaja
Kõik sõltub hindajast. Nipp seisneb selles, et küsida LLM-ilt binaarset otsust JSON-vormingus, mitte vabas vormis hinnangut: {"score": "yes"} või {"score": "no"}, mitte midagi muud. Parameeter response_format={"type": "json_object"} garanteerib parsitava väljundi ja temperature=0 kõrvaldab varieeruvuse – sama küsimuse/dokumendi paar peab alati saama sama otsuse, vastasel juhul muutub sinu torustiku käitumine kordamatuks.
from mistralai.client import Mistral
import json
client = Mistral(api_key=api_key)
def grade_document(question, document):
"""Hinda, kas dokument on küsimuse seisukohalt asjakohane."""
prompt = f"""You are a relevance evaluator. Given a question
and a document, determine if the document contains relevant information
to answer the question.
Respond ONLY with a JSON object: {{"score": "yes"}} or {{"score": "no"}}
Question : {question}
Document : {document}
JSON Evaluation:"""
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("score", "no") == "yes"
# Test
question = "What are the steps of RAG?"
doc_pertinent = "RAG breaks down into retrieval, augmentation, and generation."
doc_non_pertinent = "The tiramisu recipe requires mascarpone."
print(grade_document(question, doc_pertinent)) # True
print(grade_document(question, doc_non_pertinent)) # False
Ploki lõpus olev test väärib tähelepanu. Tiramisu retsept illustreerib täpselt seda, mida vektorsarnasus läbi lasta võib: kui sinu korpuses räägitakse ainult toiduvalmistamisest ja pärid sellelt RAG-i kohta, tõuseb see tükk konkurentsi puudumise tõttu esikohale. Hindaja aga ei võrdle vektoreid, vaid loeb sisu ja lükkab selle tagasi.
Kõigile leitud tükkidele rakendatuna tekitab see hinnang kaks teabetükki: säilitatavate dokumentide filtreeritud loetelu ja boole’i väärtuse, mis näitab, kas veebi kaudu tuleb teavet täiendada. Siin valitud lävi on tahtlikult range – isegi üks tagasilükatud dokument piisab varuvariandi käivitamiseks, lähtudes põhimõttest, et kontekst on siis puudulik.
def grade_documents(question, retrieved_chunks):
"""Hinda ja filtreeri leitud dokumente."""
relevant_docs = []
irrelevant_count = 0
for chunk in retrieved_chunks:
is_relevant = grade_document(question, chunk["text"])
if is_relevant:
relevant_docs.append(chunk)
else:
irrelevant_count += 1
need_web_search = irrelevant_count > 0
print(f" Relevant: {len(relevant_docs)}/{len(retrieved_chunks)}")
print(f" Web search needed: {need_web_search}")
return relevant_docs, need_web_search
Veebi ohutusvõrk
Kui kohalikud dokumendid ei piisa, vaatab süsteem mujale. Mistral pakub selleks sisseehitatud tööriista web_search, mille saad lubada Conversations API kaudu: mudel viib otsingu ise läbi ja kirjutab seejärel oma vastuse, viidates allikatele. See detail on oluline, sest lihtne client.chat.complete väljakutse ei saa veebi otsida: mudel vastaks mälust, riskides leiutada täpselt seda, mida CRAG püüab vältida. Pealegi lükkavad alates SDK versioonist 3.0 vestluse täiendused tööriista web_search tegelikult tagasi.
Disaini võtmepunkt on tagastusvorming: funktsioon tagastab sõnastike loendi, mille kuju on sama mis sinu kohalikel tükkidel, väljaga source, mille väärtuseks on web_search, ning lisab viidatud URL-id. See ühtlus võimaldab järgmistel etappidel dokumentide päritolu täielikult ignoreerida, säilitades samal ajal raja lõppkasutaja jaoks.
def web_search_fallback(question):
"""Veebiotsingu varuvariant, kui kohalikud dokumendid on ebapiisavad."""
response = client.beta.conversations.start(
model="mistral-medium-latest",
inputs=question,
instructions="Answer factually, relying on web search results.",
tools=[{"type": "web_search"}],
store=False, # pole vaja vestlust Mistrali poolel säilitada
)
texte, urls = "", []
for entry in response.outputs:
if entry.type != "message.output":
continue # ignoreeri kirjet, mis kirjeldab tööriista käivitamist
if isinstance(entry.content, str):
texte += entry.content
continue
for chunk in entry.content:
if chunk.type == "text":
texte += chunk.text
elif chunk.type == "tool_reference" and chunk.url:
urls.append(chunk.url)
# Tagasta "veebi" dokumendina koos viidatud allikatega
return [{
"text": texte,
"source": "web_search",
"urls": urls,
}]
Vastus sisaldab kahte tüüpi kirjeid: tool.execution kirje, mis kirjeldab käivitatud otsingut, ja message.output kirje, mille sisu vaheldub tekstifragmentide ja viidetega (tool_reference), mis kannavad vaadatud lehtede pealkirja ja URL-i. Organisatsiooni administraator saab päritud domeene piirata lubatud nimekirja (allowlist) või keelatud nimekirja (blocklist) kaudu; filtreeritud tulemused kaovad ilma hoiatuseta, nii et liiga kitsas lubatud nimekiri võib jätta otsingu tulemusteta.
Ametlik allikas: Websearch (Mistral documentation)
Kokkupandud torustik
Klass CorrectiveRAG kordab standardset torustiku struktuuri, lisades hindamise. Vaikimisi k=4 on veidi heldem kui tavalised kolm tükki, mis on mõistlik: kuna filtreerimine viskab mõned välja, on parem alustada varuga. Meetod ask korraldab neli etappi ja kuvab igaüht, võimaldades sul reaalajas jälgida süsteemi arutluskäiku – mitu dokumenti hindamise üle elas, kas varuvariant käivitus. Tagastatav sõnastik paljastab ka web_search_used: see on väärtuslik näitaja, mida tootmises jälgida, sest ebanormaalselt kõrge veebi kasutamise määr ei viita CRAG-i veale, vaid lüngale sinu korpuses.
class CorrectiveRAG:
"""Corrective RAG torustik hindamise ja veebi varuvariandiga."""
def __init__(self, chunks, embeddings, index):
self.chunks = chunks
self.embeddings = embeddings
self.index = index
def retrieve(self, question, k=4):
"""1. etapp: standardne otsing."""
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)
results = []
for dist, idx in zip(distances[0], indices[0]):
if idx >= 0:
results.append({
"text": self.chunks[idx]["text"],
"source": self.chunks[idx].get("source", "local"),
})
return results
def grade(self, question, documents):
"""2. etapp: hinda asjakohasust."""
relevant = []
for doc in documents:
if grade_document(question, doc["text"]):
relevant.append(doc)
need_web = len(relevant) < len(documents)
return relevant, need_web
def generate(self, question, documents):
"""3. etapp: genereeri vastus."""
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 context."},
{"role": "user", "content": prompt},
],
temperature=0.1,
)
return response.choices[0].message.content
def ask(self, question, k=4):
"""Täielik torustik."""
print(f"\n=== Question : {question} ===")
# 1. Otsing
print("1. Retrieval...")
docs = self.retrieve(question, k=k)
# 2. Hindamine
print("2. Grading...")
relevant_docs, need_web = self.grade(question, docs)
# 3. Veebiotsingu varuvariant vajadusel
if need_web:
print("3. Fallback web search...")
web_docs = web_search_fallback(question)
relevant_docs.extend(web_docs)
# 4. Genereerimine
print("4. Generation...")
answer = self.generate(question, relevant_docs)
return {
"answer": answer,
"sources_used": len(relevant_docs),
"web_search_used": need_web,
}
# Kasutamine
crag = CorrectiveRAG(chunks, embeddings, index)
result = crag.ask("How does Mistral implement embeddings?")
print(f"\nAnswer : {result['answer']}")
print(f"Web search used : {result['web_search_used']}")
See usaldusväärsus toob kaasa kulu, mille pead teadlikult aktsepteerima: k=4 korral käivitab iga küsimus enne genereerimise algust neli hindamiskõnet. Kasutaja tajutav latentsus suureneb vastavalt ja seda teeb ka arve. Kompromiss erineb kasutusjuhtumi põhjal – juriidilise või meditsiinilise assistendi puhul on kontrollimine tingimatu; sisemise otsingumootori puhul, kus kasutaja näeb allikaid ja hindab ise, on see vähem kriitiline.
Peamised punktid
- Corrective RAG lisab pärast otsingut asjakohasuse hindamise etapi
- LLM toimib „hindajana“, otsustades iga dokumendi üle: asjakohane või mitte
- Kui dokumendid tunnistatakse ebaasjakohaseks, käivitub veebiotsingu varuvariant
- See lähenemine vähendab oluliselt hallutsinatsioone, mis tulenevad sobimatust kontekstist
- Hindamine suurendab latentsust, kuid parandab tugevalt vastuste usaldusväärsust