Corrective RAG
Šiame puslapyje
Kai paieškos nepakanka
Tavo sukurtos RAG sistemos veikimas remiasi numanoma prielaida: klausimui artimiausi fragmentai yra tie, kurių reikia. Ši prielaida dažnai pasitvirtina, bet ne visada. Jei užklausi savo indeksą tema, kurios jis neapima, FAISS vis tiek grąžins penkis artimiausius vektorius, nesvarbu, kiek jie būtų nesusiję – panašumo variklis nemoka pasakyti „aš nieko neturiu“. Tuomet modelis gauna netinkamą kontekstą, o kadangi raginamas remtis būtent tuo kontekstu, jis sugeneruoja atsakymą, kuris atrodo autoritetingas, bet neturi jokio pagrindo. Tai klastingiausias haliucinacijų scenarijus, nes techninė grandinė suveikė be klaidų.
Corrective RAG (CRAG) tarp paieškos ir generavimo įterpia vertinimo etapą. Didysis kalbos modelis (LLM) peržiūri kiekvieną gautą dokumentą ir nusprendžia: aktualu ar ne. Jei verdiktas neigiamas, sistema negeneruoja atsakymo remdamasi tuo, ką turi – ji pereina prie paieškos internete, kad rastų informacijos, kurios trūksta tavo duomenų bazėje, kitur. Taigi srautą sudaro keturi etapai: standartinė paieška vektorinėje duomenų bazėje, kiekvieno dokumento vertinimas pagal klausimą, sprendimas inicijuoti paiešką internete, jei bent vienas dokumentas pripažintas nereikšmingu, ir galiausiai atsakymo generavimas naudojant geriausius turimus dokumentus.
Dokumentų vertintojas
Viskas priklauso nuo vertintojo. Gudrybė ta, kad reikia paprašyti LLM pateikti dvejetainį sprendimą JSON formatu, o ne laisvos formos įvertinimą: {"score": "yes"} arba {"score": "no"}, ir nieko daugiau. Parametras response_format={"type": "json_object"} garantuoja, kad išvestį bus galima analizuoti, o temperature=0 pašalina kintamumą – tai pačiai klausimo ir dokumento porai visada turi būti priimtas tas pats sprendimas, kitaip tavo sistemos elgsena taps nepakartojama.
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
Testas bloko pabaigoje nusipelno dėmesio. Tiramisu receptas puikiai iliustruoja tai, ką praleidžia vektorių panašumas: jei tavo duomenų bazėje kalbama tik apie maisto gaminimą, o tu klausi apie RAG, šis fragmentas dėl konkurencijos nebuvimo bus pirmoje vietoje. Tačiau vertintojas lygina ne vektorius, o skaito turinį ir jį atmeta.
Pritaikius šį vertinimą visiems gautiems fragmentams, gaunami du duomenys: filtruotas dokumentų, kuriuos reikia palikti, sąrašas ir loginė reikšmė, nurodanti, ar reikia papildyti informaciją iš interneto. Čia pasirinkta slenkstinė vertė sąmoningai griežta – pakanka vieno atmesto dokumento, kad būtų suaktyvintas atsarginis variantas, remiantis tuo, jog kontekstas tuomet yra neišsamus.
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
Interneto saugos tinklas
Kai vietinių dokumentų nepakanka, sistema ieško kitur. Mistral tam turi integruotą įrankį web_search, kurį galima įjungti per Conversations API: modelis pats atlieka paiešką, o tada rašo atsakymą, cituodamas šaltinius. Ši detalė svarbi, nes paprastas client.chat.complete iškvietimas negali ieškoti internete: modelis atsakytų iš atminties, rizikuodamas sugalvoti būtent tai, ko CRAG siekia išvengti. Be to, nuo SDK 3.0 versijos pokalbių užbaigimai iš tikrųjų atmeta web_search įrankį.
Pagrindinis projektavimo aspektas – grąžinimo formatas: funkcija grąžina žodynų sąrašą, kurio struktūra tokia pati kaip ir tavo vietinių fragmentų, su lauku source, nustatytu į web_search, ir pridėtomis cituojamomis URL adresais. Dėl šio vienodumo tolesni žingsniai gali visiškai ignoruoti dokumentų kilmę, kartu išsaugant pėdsaką galutiniam naudotojui.
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,
}]
Atsakyme yra dviejų tipų įrašai: tool.execution įrašas, aprašantis paleistą paiešką, ir message.output įrašas, kurio turinys kaitalioja teksto fragmentus ir nuorodas (tool_reference) su peržiūrėtų puslapių pavadinimais ir URL adresais. Organizacijos administratorius gali apriboti užklausiamus domenus naudodamas leidimų sąrašą (allowlist) arba blokavimo sąrašą (blocklist); filtruoti rezultatai išnyksta be įspėjimo, todėl per siauras leidimų sąrašas gali palikti paiešką be jokių rezultatų.
Oficialus šaltinis: Websearch (Mistral documentation)
Surinkta sistema
Klasė CorrectiveRAG perima standartinę sistemos struktūrą, įterpdama vertinimą. Numatytoji k=4 reikšmė yra šiek tiek dosnesnė nei įprasti trys fragmentai, ir tai logiška: kadangi filtravimas kai kuriuos pašalins, geriau pradėti su atsarga. Metodas ask koordinuoja keturis etapus ir rodo kiekvieną iš jų, leisdamas stebėti sistemos samprotavimus realiuoju laiku – kiek dokumentų išgyveno vertinimą, ar suveikė atsarginis variantas. Grąžinamas žodynas taip pat atskleidžia web_search_used: tai vertingas rodiklis stebėti gamybinėje aplinkoje, nes nenormaliai didelis naudojimosi internetu rodiklis signalizuoja ne CRAG trūkumą, o spragą tavo duomenų bazėje.
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']}")
Šis patikimumas turi kainą, kurią turi sąmoningai priimti: esant k=4, kiekvienas klausimas prieš pradedant generavimą sukelia keturis vertinimo iškvietimus. Naudotojo suvokiama delsos trukmė atitinkamai didėja, kaip ir sąskaita. Kompromisas priklauso nuo naudojimo atvejo – teisiniam ar medicininiam asistentui patikrinimas yra būtinas; vidinei paieškos sistemai, kurioje naudotojas mato šaltinius ir pats vertina, tai mažiau kritiška.
Svarbiausi punktai
- Corrective RAG po paieškos prideda aktualumo vertinimo etapą
- LLM veikia kaip „vertintojas“, sprendžiantis apie kiekvieną dokumentą: aktualu ar ne
- Jei dokumentai pripažįstami nereikšmingais, suaktyvinamas atsarginis variantas – paieška internete
- Šis požiūris žymiai sumažina haliucinacijas, kylančias dėl netinkamo konteksto
- Vertinimas padidina delsą, tačiau labai pagerina atsakymų patikimumą