RAG korektiv
Na ovoj stranici
Kada dohvaćanje nije dovoljno
RAG sustav koji si izgradio počiva na implicitnoj pretpostavci: isječci najsličniji pitanju su oni pravi. Ta pretpostavka često vrijedi, ali ne uvijek. Upitaj svoj indeks o temi koju ne pokriva i FAISS će ipak vratiti pet najbližih vektora, bez obzira na to koliko su izvan teme – motor sličnosti ne zna reći „nemam ništa“. Model tada prima neprikladan kontekst, a budući da ga upit traži da se osloni na taj kontekst, proizvodi odgovor koji izgleda autoritativno, ali nema utemeljenja. To je najpodmukliji scenarij halucinacije jer je tehnički lanac radio bez greške.
RAG korektiv (CRAG) ubacuje korak evaluacije između dohvaćanja i generiranja. LLM pregledava svaki dohvaćeni dokument i odlučuje: relevantan ili ne. Ako je presuda negativna, sustav ne generira odgovor samo s onim što ima – prelazi na pretraživanje weba kako bi pronašao informacije koje nedostaju u tvom korpusu negdje drugdje. Tijek stoga ima četiri faze: standardno dohvaćanje iz vektorske pohrane, ocjenjivanje svakog dokumenta u odnosu na pitanje, odluka hoće li se pokrenuti pretraživanje weba ako se barem jedan dokument smatra nebitnim, i konačno generiranje s najboljim dostupnim dokumentima.
Ocjenjivač dokumenata
Sve ovisi o ocjenjivaču. Trik je tražiti od LLM-a binarnu presudu u JSON formatu umjesto slobodne procjene: {"score": "yes"} ili {"score": "no"}, ništa više. Parametar response_format={"type": "json_object"} jamči parsabilan izlaz, a temperature=0 eliminira varijabilnost – isti par pitanje/dokument uvijek mora dobiti istu presudu, inače ponašanje tvog pipelinea postaje 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 kraju bloka zaslužuje pozornost. Recept za tiramisu ilustrira točno ono što vektorska sličnost propušta: ako tvoj korpus govori samo o kuhanju, a upitaš ga o RAG-u, ovaj isječak će se rangirati prvi zbog nedostatka konkurencije. Ocjenjivač, međutim, ne uspoređuje vektore već čita sadržaj i odbacuje ga.
Primijenjen na sve dohvaćene isječke, ovaj sud proizvodi dvije informacije: filtrirani popis dokumenata za zadržavanje i boolean vrijednost koja označava treba li dopuniti podatke s weba. Prag odabran ovdje namjerno je strog – jedan odbačeni dokument dovoljan je za pokretanje sigurnosne kopije, s obrazloženjem da je kontekst tada nepotpun.
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
Web sigurnosna mreža
Kada lokalni dokumenti nisu dovoljni, sustav gleda drugamo. Mistral za to pruža ugrađeni alat, web_search, koji omogućuješ putem Conversations API-ja: model sam pokreće pretraživanje, a zatim piše svoj odgovor citirajući izvore. Ova detalj je važan jer jednostavan poziv client.chat.complete ne može pretraživati web: model bi odgovorio iz memorije, s rizikom da izmisli točno ono što CRAG želi izbjeći. A od verzije SDK-a 3.0, chat completions zapravo odbijaju alat web_search.
Ključna točka dizajna je format povrata: funkcija vraća popis rječnika istog oblika kao tvoji lokalni isječci, s poljem source postavljenim na web_search, i dodaje citirane URL-ove. Ta ujednačenost omogućuje nizvodnim koracima da potpuno ignoriraju podrijetlo dokumenata, a da pritom sačuvaju trag za krajnjeg korisnika.
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 sadrži dvije vrste unosa: unos tool.execution, koji opisuje pokrenuto pretraživanje, i unos message.output, čiji sadržaj izmjenjuje tekstualne fragmente i reference (tool_reference) koje nose naslov i URL konzultiranih stranica. Administrator organizacije može ograničiti domene koje se upituju putem popisa dopuštenih (allowlist) ili blokiranih (blocklist); filtrirani rezultati nestaju bez upozorenja, pa previše uzak popis dopuštenih može ostaviti pretraživanje bez rezultata.
Službeni izvor: Websearch (Mistral documentation)
Sastavljeni pipeline
Klasa CorrectiveRAG preuzima strukturu standardnog pipelinea ubacivanjem ocjenjivanja. Zadani k=4 nešto je velikodušniji od uobičajena tri isječka, što ima smisla: budući da će filtriranje neke odbaciti, bolje je krenuti s marginom. Metoda ask orchestrira četiri faze i prikazuje svaku od njih, omogućujući ti da pratiš rezoniranje sustava u stvarnom vremenu – koliko je dokumenata preživjelo ocjenjivanje, je li se aktivirala sigurnosna kopija. Rječnik povrata također izlaže web_search_used: to je vrijedan pokazatelj za praćenje u produkciji, jer abnormalno visoka stopa korištenja weba ne signalizira manu CRAG-a već prazninu u tvom 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']}")
Ova pouzdanost ima cijenu koju moraš svjesno prihvatiti: s k=4, svako pitanje pokreće četiri poziva ocjenjivanja prije nego što generiranje uopće započne. Latencija koju korisnik percipira sukladno tome raste, kao i račun. Kompromis se razlikuje ovisno o slučaju upotrebe – za pravnog ili medicinskog asistenta, provjera je neupitna; za interni tražilicu gdje korisnik vidi izvore i sam prosuđuje, manje je kritična.
Ključne točke
- RAG korektiv dodaje korak evaluacije relevantnosti nakon dohvaćanja
- LLM služi kao „ocjenjivač“ za procjenu svakog dokumenta: relevantan ili ne
- Ako se dokumenti smatraju nebitnima, aktivira se sigurnosna kopija pretraživanja weba
- Ovaj pristup značajno smanjuje halucinacije uzrokovane neprikladnim kontekstom
- Ocjenjivanje dodaje latenciju, ali snažno poboljšava pouzdanost odgovora