Corrective RAG
På denne side
Når opslag ikke er nok
Det RAG-system, du har bygget, hviler på en implicit antagelse: de chunks, der ligner spørgsmålet mest, er de rigtige. Denne antagelse holder ofte, men ikke altid. Spørg dit indeks om et emne, det ikke dækker, og FAISS vil stadig returnere de fem nærmeste vektorer, uanset hvor langt væk fra emnet de er – en lighedsmotor ved ikke, hvordan man siger „jeg har ingenting”. Modellen modtager derefter uegnet kontekst, og da prompten beder den om at stole på denne kontekst, producerer den et svar, der ser autoritært ud, men som mangler fundament. Dette er det mest snigende hallucinationsscenarie, fordi den tekniske kæde fungerede uden fejl.
Corrective RAG (CRAG) indsætter et evalueringstrin mellem opslag og generering. En LLM undersøger hvert hentet dokument og afgør: relevant eller ej. Hvis dommen er negativ, genererer systemet ikke bare med det, det har – det skifter til en websøgning for at finde de oplysninger, der mangler i dit korpus, andre steder. Flowet har derfor fire faser: standardopslag fra vektorlageret, vurdering af hvert dokument i forhold til spørgsmålet, beslutning om at udløse en websøgning, hvis mindst ét dokument anses for irrelevant, og endelig generering med de bedst tilgængelige dokumenter.
Dokumentvurdereren
Alt afhænger af vurdereren. Tricket er at bede LLM’en om en binær dom i JSON-format i stedet for en fri vurdering: {"score": "yes"} eller {"score": "no"}, intet andet. Parameteren response_format={"type": "json_object"} garanterer et parserbart output, og temperature=0 eliminerer variabilitet – det samme spørgsmål/dokument-par skal altid modtage samme dom, ellers bliver din pipelines adfærd ureproducerbar.
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
Testen i slutningen af blokken fortjener opmærksomhed. Tiramisu-opskriften illustrerer præcis, hvad vektorlighed lader slippe igennem: Hvis dit korpus kun taler om madlavning, og du spørger det om RAG, vil denne chunk rangere først af mangel på konkurrence. Vurdereren sammenligner dog ikke vektorer, men læser indholdet og afviser det.
Anvendt på alle hentede chunks producerer denne dom to oplysninger: den filtrerede liste over dokumenter, der skal beholdes, og en boolean, der angiver, om der skal suppleres med webbet. Tærsklen, der vælges her, er bevidst streng – et enkelt kasseret dokument er nok til at udløse fallback’en, med den begrundelse at konteksten derefter er ufuldstændig.
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
Websikkerhedsnettet
Når lokale dokumenter ikke er nok, kigger systemet andre steder hen. Mistral leverer et indbygget værktøj til dette, web_search, som du aktiverer via Conversations API: Modellen udfører selv søgningen og skriver derefter sit svar med kildehenvisninger. Denne detalje er vigtig, fordi et simpelt client.chat.complete-kald ikke kan søge på nettet: Modellen ville svare ud fra hukommelsen med risikoen for at opfinde netop det, CRAG søger at undgå. Og siden SDK-version 3.0 afviser chat completions faktisk værktøjet web_search.
Det centrale designpunkt er returneringsformatet: Funktionen returnerer en liste over ordbøger med samme form som dine lokale chunks, med et felt source sat til web_search, og tilføjer de citerede URL’er. Denne ensartethed lader efterfølgende trin fuldstændig ignorere dokumenternes oprindelse, mens sporet bevares til slutbrugeren.
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,
}]
Svaret indeholder to typer poster: en tool.execution-post, der beskriver den igangsatte søgning, og en message.output-post, hvis indhold skifter mellem tekstfragmenter og referencer (tool_reference), der bærer titlen og URL’en på de konsulterede sider. En organisationsadministrator kan begrænse de queried domæner via en allowlist eller blocklist; filtrerede resultater forsvinder uden advarsel, så en for snæver allowlist kan efterlade søgningen uden resultater.
Officiel kilde: Websearch (Mistral documentation)
Den samlede pipeline
Klassen CorrectiveRAG genoptager den standard pipeline-struktur ved at indsætte vurdering. Standardværdien k=4 er lidt mere generøs end de sædvanlige tre chunks, hvilket giver mening: Da filtrering vil kassere nogle, er det bedre at starte med en margin. Metoden ask orchestrerer de fire faser og viser hver enkelt, så du kan følge systemets ræsonnement i realtid – hvor mange dokumenter overlevede vurderingen, om fallback’en blev udløst. Returneringsordbogen eksponerer også web_search_used: Dette er en værdifuld indikator at overvåge i produktion, fordi en unormalt høj web-brugsrate ikke signalerer en CRAG-fejl, men et hul i dit korpus.
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']}")
Denne pålidelighed har en pris, du skal acceptere bevidst: Med k=4 udløser hvert spørgsmål fire vurderingskald, før genereringen overhovedet starter. Den ventetid, brugeren oplever, stiger tilsvarende, og det gør regningen også. Afvejningen varierer efter brugssag – for en juridisk eller medicinsk assistent er verifikation ikke-forhandlingsbar; for en intern søgemaskine, hvor brugeren ser kilderne og selv dømmer, er det mindre kritisk.
Vigtige pointer
- Corrective RAG tilføjer et trin til evaluering af relevans efter opslag
- En LLM fungerer som „vurderer” for at bedømme hvert dokument: relevant eller ej
- Hvis dokumenter anses for irrelevante, udløses en fallback til websøgning
- Denne tilgang reducerer hallucinationer betydeligt på grund af uegnet kontekst
- Vurdering tilføjer ventetid, men forbedrer svarenes pålidelighed markant