RAG Corectiv
Pe această pagină
Când recuperarea nu este suficientă
Sistemul RAG pe care l-ați construit se bazează pe o presupunere implicită: fragmentele cele mai similare cu întrebarea sunt cele corecte. Această presupunere este adesea valabilă, dar nu întotdeauna. Dacă interogați indexul despre un subiect pe care nu îl acoperă, FAISS va returna totuși cei cinci vectori cei mai apropiați, indiferent cât de departe de subiect sunt – un motor de similaritate nu știe să spună „nu am nimic“. Modelul primește apoi un context nepotrivit și, deoarece promptul îi cere să se bazeze pe acel context, generează un răspuns care pare autoritar, dar nu are niciun fundament. Acesta este cel mai insidios scenariu de halucinație, deoarece lanțul tehnic a funcționat fără erori.
RAG Corectiv (CRAG) introduce un pas de evaluare între recuperare și generare. Un LLM examinează fiecare document recuperat și decide: relevant sau nu. Dacă verdictul este negativ, sistemul nu generează doar cu ceea ce are – comută la o căutare pe web pentru a găsi informațiile lipsă din corpusul dumneavoastră elsewhere. Fluxul are astfel patru etape: recuperarea standard din stocul de vectori, notarea fiecărui document în funcție de întrebare, deciderea dacă se declanșează o căutare pe web dacă cel puțin un document este considerat irelevant și, în final, generarea cu cele mai bune documente disponibile.
Notatorul de documente
Totul depinde de notator. Trucul este să cereți LLM-ului o judecată binară în format JSON, în loc de o evaluare liberă: {"score": "yes"} sau {"score": "no"}, nimic altceva. Parametrul response_format={"type": "json_object"} garantează un output parsabil, iar temperature=0 elimină variabilitatea – aceeași pereche întrebare/document trebuie să primească întotdeauna același verdict, altfel comportamentul pipeline-ului dumneavoastră devine ireproductibil.
from mistralai.client import Mistral
import json
client = Mistral(api_key=api_key)
def grade_document(question, document):
"""Evaluează dacă un document este relevant pentru o întrebare."""
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
Testul de la sfârșitul blocului merită atenție. Rețeta de tiramisu ilustrează exact ceea ce similaritatea vectorială lasă să treacă: dacă corpusul dumneavoastră vorbește doar despre gătit și îl interogați despre RAG, acest fragment se va clasa pe primul loc din lipsă de concurență. Notatorul, însă, nu compară vectori, ci citește conținutul și îl respinge.
Aplicată tuturor fragmentelor recuperate, această judecată produce două informații: lista filtrată de documente de păstrat și un boolean care indică dacă este necesară completarea cu web-ul. Pragul ales aici este deliberat strict – un singur document respins este suficient pentru a declanșa fallback-ul, pe motiv că contextul este atunci incomplet.
def grade_documents(question, retrieved_chunks):
"""Evaluează și filtrează documentele recuperate."""
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
Plasa de siguranță web
Când documentele locale nu sunt suficiente, sistemul caută elsewhere. Mistral oferă un instrument integrat pentru aceasta, web_search, pe care îl activați prin API-ul Conversations: modelul rulează căutarea singur, apoi scrie răspunsul citându-și sursele. Acest detaliu contează deoarece un simplu apel client.chat.complete nu poate căuta pe web: modelul ar răspunde din memorie, cu riscul de a inventa exact ceea ce CRAG încearcă să evite. Și, din versiunea SDK 3.0, completările chat resping efectiv instrumentul web_search.
Punctul cheie de design este formatul de returnare: funcția returnează o listă de dicționare cu aceeași structură ca fragmentele locale, cu un câmp source setat la web_search, și adaugă URL-urile citate. Această uniformitate permite pașilor următori să ignore complet originea documentelor, păstrând totuși urma pentru utilizatorul final.
def web_search_fallback(question):
"""Fallback de căutare pe web când documentele locale sunt insuficiente."""
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, # nu este nevoie să păstrați conversația pe partea Mistral
)
texte, urls = "", []
for entry in response.outputs:
if entry.type != "message.output":
continue # ignorați intrarea care descrie execuția instrumentului
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)
# Returnați ca un document „web“, cu sursele citate
return [{
"text": texte,
"source": "web_search",
"urls": urls,
}]
Răspunsul conține două tipuri de intrări: o intrare tool.execution, care descrie căutarea lansată, și o intrare message.output, al cărei conținut alternează fragmente de text și referințe (tool_reference) care poartă titlul și URL-ul paginilor consultate. Un administrator al organizației poate restricționa domeniile interogate printr-o listă de允许 (allowlist) sau o listă de blocare (blocklist); rezultatele filtrate dispar fără avertisment, astfel încât o allowlist prea îngustă poate lăsa căutarea fără rezultate.
Sursă oficială: Websearch (documentație Mistral)
Pipeline-ul asamblat
Clasa CorrectiveRAG reia structura pipeline-ului standard inserând notarea. Valoarea implicită k=4 este puțin mai generoasă decât cele trei fragmente uzuale, ceea ce are sens: deoarece filtrarea va elimina unele, este mai bine să începeți cu o marjă. Metoda ask orchestrează cele patru etape și afișează fiecare, permițându-vă să urmăriți raționamentul sistemului în timp real – câte documente au supraviețuit notării, dacă fallback-ul s-a declanșat. Dicționarul de returnare expune, de asemenea, web_search_used: acesta este un indicator valoros de monitorizat în producție, deoarece o rată de utilizare web anormal de mare nu semnalează o deficiență a CRAG, ci o lacună în corpusul dumneavoastră.
class CorrectiveRAG:
"""Pipeline RAG Corectiv cu evaluare și fallback web."""
def __init__(self, chunks, embeddings, index):
self.chunks = chunks
self.embeddings = embeddings
self.index = index
def retrieve(self, question, k=4):
"""Etapa 1: recuperare standard."""
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):
"""Etapa 2: evaluarea relevanței."""
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):
"""Etapa 3: generarea răspunsului."""
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):
"""Pipeline complet."""
print(f"\n=== Question : {question} ===")
# 1. Recuperare
print("1. Retrieval...")
docs = self.retrieve(question, k=k)
# 2. Notare
print("2. Grading...")
relevant_docs, need_web = self.grade(question, docs)
# 3. Fallback căutare web dacă este necesar
if need_web:
print("3. Fallback web search...")
web_docs = web_search_fallback(question)
relevant_docs.extend(web_docs)
# 4. Generare
print("4. Generation...")
answer = self.generate(question, relevant_docs)
return {
"answer": answer,
"sources_used": len(relevant_docs),
"web_search_used": need_web,
}
# Utilizare
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']}")
Această fiabilitate are un cost pe care trebuie să îl acceptați în cunoștință de cauză: cu k=4, fiecare întrebare declanșează patru apeluri de notare înainte chiar ca generarea să înceapă. Latența percepută de utilizator crește corespunzător, la fel și factura. Compromisul diferă în funcție de cazul de utilizare – pentru un asistent juridic sau medical, verificarea este non-negociabilă; pentru un motor de căutare intern unde utilizatorul vede sursele și judecă singur, este mai puțin critic.
Puncte cheie
- RAG Corectiv adaugă un pas de evaluare a relevanței după recuperare
- Un LLM servește drept „notator“ pentru a judeca fiecare document: relevant sau nu
- Dacă documentele sunt considerate irelevante, se declanșează un fallback către căutarea pe web
- Această abordare reduce semnificativ halucinațiile datorate unui context nepotrivit
- Notarea adaugă latență, dar îmbunătățește puternic fiabilitatea răspunsurilor