Corrective RAG
Na tej strani
Ko pridobivanje ni dovolj
Sistem RAG, ki si ga zgradil, temelji na implicitnem predpostavku: delčki, ki so najbolj podobni vprašanju, so tisti pravi. Ta predpostavka pogosto drži, a ne vedno. Če svoj indeks poizveduješ o temi, ki je ne pokriva, bo FAISS kljub temu vrnil pet najbližjih vektorjev, ne glede na to, kako nepomembni so – motor za iskanje podobnosti ne zna reči „nimam ničesar”. Model nato prejme neustrezen kontekst in ker ga poziv zahteva, da se zanaša na ta kontekst, ustvari odgovor, ki izgleda avtoritativno, a nima podlage. To je najbolj zahrbtni scenarij halucinacij, saj je tehnična veriga delovala brez napak.
Corrective RAG (CRAG) vstavi korak ocenjevanja med pridobivanje in generiranje. LLM pregleda vsak pridobljeni dokument in odloči: relevanten ali ne. Če je sodba negativna, sistem ne generira le s tem, kar ima – preklopi na spletno iskanje, da najde informacije, ki manjkajo v tvojem korpusu, drugje. Tok ima torej štiri faze: standardno pridobivanje iz vektorskega skladišča, ocenjevanje vsakega dokumenta glede na vprašanje, odločitev, ali sprožiti spletno iskanje, če je vsaj en dokument ocenjen kot nerelevanten, in končno generiranje z najboljšimi razpoložljivimi dokumenti.
Ocenjevalec dokumentov
Vse je odvisno od ocenjevalca. Trik je v tem, da od LLM zahtevaš binarno sodbo v formatu JSON namesto proste ocene: {"score": "yes"} ali {"score": "no"}, nič drugega. Parameter response_format={"type": "json_object"} zagotavlja razčlenljiv izhod, temperature=0 pa odpravi variabilnost – isti par vprašanje/dokument mora vedno prejeti isto sodbo, sicer postane obnašanje tvoje cevovoda neproduktivno.
from mistralai.client import Mistral
import json
client = Mistral(api_key=api_key)
def grade_document(question, document):
"""Evaluate whether a document is relevant to a question."""
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
Test na koncu bloka si zasluži pozornost. Recept za tiramisu ilustrira prav to, kar vektorska podobnost spusti skozi: če tvoj korpus govori samo o kuhanju in ga poizveduješ o RAG, se bo ta delček uvrstil na prvo mesto zaradi pomanjkanja konkurence. Ocenjevalec pa ne primerja vektorjev, temveč bere vsebino in ga zavrne.
Ko se ta sodba uporabi za vse pridobljene delčke, proizvede dva podatka: filtrirani seznam dokumentov, ki jih obdržiš, in boolean, ki kaže, ali je treba dopolniti s spletom. Prag, izbran tukaj, je namerno strog – že en zavržen dokument zadostuje za sprožitev nadomestila, saj je kontekst takrat nepopoln.
def grade_documents(question, retrieved_chunks):
"""Evaluate and filter retrieved documents."""
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
Spletna varnostna mreža
Ko lokalni dokumenti niso dovolj, sistem poišče drugje. Mistral za to ponuja vgrajeno orodje web_search, ki ga omogočiš prek Conversations API: model sam izvede iskanje, nato zapiše svoj odgovor z navedbo virov. Ta podrobnost je pomembna, ker preprost klic client.chat.complete ne more iskati po spletu: model bi odgovoril iz spomina s tveganjem, da izumi prav tisto, česar se CRAG želi izogniti. In ker različice SDK 3.0, zaključki klepeta dejansko zavračajo orodje web_search.
Ključna točka zasnove je format vračila: funkcija vrne seznam slovarjev z enako obliko kot tvoji lokalni delčki, s poljem source, nastavljenim na web_search, in doda navedene URL-je. Ta enotnost omogoča, da nadaljnji koraki popolnoma ignorirajo izvor dokumentov, hkrati pa ohranjajo sled za končnega uporabnika.
def web_search_fallback(question):
"""Web search fallback when local documents are insufficient."""
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, # no need to keep the conversation on Mistral's side
)
texte, urls = "", []
for entry in response.outputs:
if entry.type != "message.output":
continue # ignore the entry describing tool execution
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)
# Return as a "web" document, with cited sources
return [{
"text": texte,
"source": "web_search",
"urls": urls,
}]
Odgovor vsebuje dve vrsti vnosov: vnos tool.execution, ki opisuje zagnano iskanje, in vnos message.output, katerega vsebina izmenjuje besedilne fragmente in reference (tool_reference), ki nosijo naslov in URL obiskanih strani. Skrbnik organizacije lahko omeji poizvedovane domene prek dovoljenega ali blokiranega seznama; filtrirani rezultati izginejo brez opozorila, zato lahko preozek seznam dovoljenih domen pusti iskanje brez rezultatov.
Uradni vir: Websearch (Mistral documentation)
Sestavljeni cevovod
Razred CorrectiveRAG ponovi strukturo standardnega cevovoda z vstavljanjem ocenjevanja. Privzeti k=4 je nekoliko bolj velikodušen kot običajni trije delčki, kar ima smisel: ker bo filtriranje nekatere zavrglo, je bolje začeti z rezervo. Metoda ask usklajuje štiri faze in prikazuje vsako, kar ti omogoča, da v realnem času spremljaš razmišljanje sistema – koliko dokumentov je preživelo ocenjevanje, ali se je sprožilo nadomestilo. Slovar za vračilo tudi razkriva web_search_used: to je dragocen kazalnik za spremljanje v proizvodnji, saj nenormalno visoka stopnja uporabe spleta ne signalizira napake CRAG, temveč vrzel v tvojem korpusu.
class CorrectiveRAG:
"""Corrective RAG pipeline with evaluation and web fallback."""
def __init__(self, chunks, embeddings, index):
self.chunks = chunks
self.embeddings = embeddings
self.index = index
def retrieve(self, question, k=4):
"""Step 1: standard retrieval."""
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):
"""Step 2: evaluate relevance."""
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):
"""Step 3: generate the answer."""
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):
"""Full pipeline."""
print(f"\n=== Question : {question} ===")
# 1. Retrieval
print("1. Retrieval...")
docs = self.retrieve(question, k=k)
# 2. Grading
print("2. Grading...")
relevant_docs, need_web = self.grade(question, docs)
# 3. Web search fallback if needed
if need_web:
print("3. Fallback web search...")
web_docs = web_search_fallback(question)
relevant_docs.extend(web_docs)
# 4. Generation
print("4. Generation...")
answer = self.generate(question, relevant_docs)
return {
"answer": answer,
"sources_used": len(relevant_docs),
"web_search_used": need_web,
}
# Usage
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']}")
Ta zanesljivost ima ceno, ki jo moraš zavestno sprejeti: pri k=4 vsako vprašanje sproži štiri klice ocenjevanja, preden se generiranje sploh začne. Latenca, ki jo zazna uporabnik, se ustrezno poveča, prav tako pa tudi račun. Kompromis se razlikuje glede na primer uporabe – za pravnega ali medicinskega pomočnika je preverjanje nepogrešljivo; za notranji iskalnik, kjer uporabnik vidi vire in sodi sam, je manj kritično.
Ključne ugotovitve
- Corrective RAG doda korak ocenjevanja relevantnosti po pridobivanju
- LLM služi kot „ocenjevalec” za sodbo o vsakem dokumentu: relevanten ali ne
- Če so dokumenti ocenjeni kot nerelevantni, se sproži nadomestilo s spletnim iskanjem
- Ta pristop znatno zmanjša halucinacije zaradi neustreznega konteksta
- Ocenjevanje doda latenco, a močno izboljša zanesljivost odgovorov