RAG Korrettiv
F'din il-paġna
Meta r-riċupru ma jkunx biżżejjed
Is-sistema RAG li bnejt tiddependi fuq preżunzjoni impliċita: il-frammenti l-aktar simili għall-mistoqsija huma d-dritt. Din il-preżunzjoni spiss tkun vera, iżda mhux dejjem. Jekk tistaqsi l-indiċi tiegħek dwar suġġett li ma jkoprix, FAISS xorta se jirritorna l-ħames vetturi l-eqreb, kemm jekk ikunu barra mit-tema—magna tas-similarità ma tafx tgħid “M’għandi xejn”. Il-mudell imbagħad jirċievi kuntest mhux xieraq, u peress li l-prompt jitlobu jiddependi fuq dak il-kuntest, jipproduċi tweġiba li tidher awtorevoli iżda m’għandha l-ebda bażi. Dan huwa l-aktar xenarju insidjuż ta’ alluċinazzjoni għax il-katina teknika ħadmet mingħajr żball.
Ir-RAG Korrettiv (CRAG) idaħħal pass ta’ evalwazzjoni bejn ir-riċupru u l-ġenerazzjoni. LLM jeżamina kull dokument irkuprat u jiddeċiedi: rilevanti jew le. Jekk il-verdett ikun negattiv, is-sistema ma tiġġenerax sempliċement b’dak li għandha—timxi għal tiftix fil-web biex issib l-informazzjoni nieqsa mill-korpus tiegħek f’post ieħor. Il-fluss għalhekk għandu erba’ stadji: riċupru standard mill-ħażna tal-vetturi, klassifikazzjoni ta’ kull dokument kontra l-mistoqsija, deċiżjoni jekk tistigax tiftix fil-web jekk mill-inqas dokument wieħed jitqies mhux rilevanti, u finalment il-ġenerazzjoni bl-aqwa dokumenti disponibbli.
Il-klassifikatur tad-dokumenti
Kollox jiddependi mill-klassifikatur. It-trikka hija li titlob lill-LLM ġudizzju binarju f’format JSON minflok valutazzjoni f’forma libera: {"score": "yes"} jew {"score": "no"}, xejn aktar. Il-parametru response_format={"type": "json_object"} jiggarantixxi output li jista’ jiġi analizzat, u temperature=0 telimina l-varjabbiltà—l-istess par mistoqsija/dokument irid dejjem jirċievi l-istess verdett, inkella l-imġiba tal-pipeline tiegħek issir mhux riproduċibbli.
from mistralai.client import Mistral
import json
client = Mistral(api_key=api_key)
def grade_document(question, document):
"""Evalwa jekk dokument huwiex rilevanti għal mistoqsija."""
prompt = f"""Inti evalwatur tar-rilevanza. Mogħti mistoqsija
u dokument, iddetermina jekk id-dokument fihx informazzjoni rilevanti
biex twieġeb il-mistoqsija.
Irrispondi BISS b'oġġett JSON: {{"score": "yes"}} jew {{"score": "no"}}
Mistoqsija : {question}
Dokument : {document}
Evalwazzjoni JSON:"""
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 = "X'inhuma l-passi ta' RAG?"
doc_pertinent = "RAG jinqasam f'riċupru, awgmentazzjoni u ġenerazzjoni."
doc_non_pertinent = "Ir-riċetta tat-tiramisu teħtieġ mascarpone."
print(grade_document(question, doc_pertinent)) # True
print(grade_document(question, doc_non_pertinent)) # False
It-test fl-aħħar tal-blokk jistħoqqilu attenzjoni. Ir-riċetta tat-tiramisu turi eżattament x’jħalli tgħaddi s-similarità tal-vetturi: jekk il-korpus tiegħek jitkellem biss dwar it-tisjir u tistaqsih dwar RAG, dan il-framment se jkun l-ewwel fin-nuqqas ta’ kompetizzjoni. Il-klassifikatur, madankollu, ma jqabblx vetturi iżda jaqra l-kontenut, u jiċħdu.
Meta tiġi applikata għall-frammenti irkuprati kollha, din il-ġudizzjoni tipproduċi żewġ biċċiet ta’ informazzjoni: il-lista filtrata ta’ dokumenti biex tinżamm, u boolean li jindika jekk hemmx bżonn tiżdied mal-web. Il-limitu magħżul hawnhekk huwa deliberatament strett—dokument wieħed miċħud huwa biżżejjed biex jistiga l-fall-back, fuq il-bażi li l-kuntest imbagħad ikun mhux sħiħ.
def grade_documents(question, retrieved_chunks):
"""Evalwa u ffiltra d-dokumenti irkuprati."""
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" Rilevanti: {len(relevant_docs)}/{len(retrieved_chunks)}")
print(f" Tiftix fil-web meħtieġ: {need_web_search}")
return relevant_docs, need_web_search
In-netta ta’ sikurezza tal-web
Meta d-dokumenti lokali ma jkunux biżżejjed, is-sistema tfittex f’post ieħor. Mistral jipprovdi għodda integrata għal dan, web_search, li tattivaha permezz tal-API tal-Konversazzjonijiet: il-mudell iwettaq it-tiftix innifsu, imbagħad jikteb it-tweġiba tiegħu billi jikkonferma s-sorsi tiegħu. Dan id-dettall huwa importanti għax sejħa sempliċi client.chat.complete ma tistax tfittex fil-web: il-mudell iwieġeb mill-memorja, bir-riskju li jinventa eżattament dak li CRAG ifittex li jevita. U peress mill-verżjoni 3.0 tal-SDK, it-tlestijiet taċ-chat fil-fatt jiċħdu l-għodda web_search.
Il-punt ewlieni tad-disinn huwa l-format tar-ritorn: il-funzjoni tirritorna lista ta’ dizzjunarji bl-istess forma tal-frammenti lokali tiegħek, b’kamp source issettjat għal web_search, u żżid l-URLs ikkonfermati. Din l-uniformità tippermetti lill-passi downstream jinjoraw kompletament l-oriġini tad-dokumenti filwaqt li jippreservaw il-mogħdija għall-utent finali.
def web_search_fallback(question):
"""Fall-back tat-tiftix fil-web meta d-dokumenti lokali ma jkunux biżżejjed."""
response = client.beta.conversations.start(
model="mistral-medium-latest",
inputs=question,
instructions="Iwieġeb b'mod fattwali, jiddependi fuq ir-riżultati tat-tiftix fil-web.",
tools=[{"type": "web_search"}],
store=False, # m'hemmx bżonn tinżamm il-konversazzjoni fuq in-naħa ta' Mistral
)
texte, urls = "", []
for entry in response.outputs:
if entry.type != "message.output":
continue # injora d-dħul li jiddeskrivi l-eżekuzzjoni tal-għodda
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)
# Irritorna bħala dokument "web", b'sorsi kkonfermati
return [{
"text": texte,
"source": "web_search",
"urls": urls,
}]
Ir-risposta fiha żewġ tipi ta’ dħul: dħul tool.execution, li jiddeskrivi t-tiftix imnedija, u dħul message.output, li l-kontenut tiegħu jalternaw frammenti ta’ test u referenzi (tool_reference) li jġorru t-titlu u l-URL tal-paġni kkonsultati. Amministratur tal-organizzazzjoni jista’ jirrestrinġi d-dominji mistoqsija permezz ta’ allowlist jew blocklist; ir-riżultati ffiltrati jisparixxu mingħajr twissija, allura allowlist dejqa wisq tista’ tħalli t-tiftix mingħajr riżultati.
Sors uffiċjali: Websearch (Dokumentazzjoni ta’ Mistral)
Il-pipeline assemblat
Il-klassi CorrectiveRAG terġa’ tieħu l-istruttura standard tal-pipeline billi tdaħħal il-klassifikazzjoni. Il-k=4 default huwa ftit aktar ġeneruż mit-tliet frammenti tas-soltu, li jagħmel sens: peress li l-iffiltrar se jiċħad uħud, aħjar tibda b’marġni. Il-metodu ask jorganizza l-erba’ stadji u juri kull wieħed, u jħallik issegwi r-raġunar tas-sistema f’ħin reali—kemm-il dokument baqa’ ħaj wara l-klassifikazzjoni, jekk il-fall-back ġiex attivat. Id-dizzjunarju tar-ritorn jesponi wkoll web_search_used: dan huwa indikatur prezzjuż biex timmonitorjah fil-produzzjoni, għax rata ta’ użu tal-web għolja b’mod anormali ma tissinjalax difett f’CRAG iżda lakuna fil-korpus tiegħek.
class CorrectiveRAG:
"""Pipeline ta' RAG Korrettiv b'evalwazzjoni u fall-back tal-web."""
def __init__(self, chunks, embeddings, index):
self.chunks = chunks
self.embeddings = embeddings
self.index = index
def retrieve(self, question, k=4):
"""Pass 1: riċupru 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):
"""Pass 2: evalwa r-rilevanza."""
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):
"""Pass 3: iġġenera t-tweġiba."""
context = "\n\n---\n\n".join([d["text"] for d in documents])
prompt = f"""Kuntest :\n{context}\n\nMistoqsija : {question}"""
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{"role": "system", "content": "Iwieġeb ibbażat fuq il-kuntest."},
{"role": "user", "content": prompt},
],
temperature=0.1,
)
return response.choices[0].message.content
def ask(self, question, k=4):
"""Pipeline sħiħa."""
print(f"\n=== Mistoqsija : {question} ===")
# 1. Riċupru
print("1. Riċupru...")
docs = self.retrieve(question, k=k)
# 2. Klassifikazzjoni
print("2. Klassifikazzjoni...")
relevant_docs, need_web = self.grade(question, docs)
# 3. Fall-back tat-tiftix fil-web jekk meħtieġ
if need_web:
print("3. Fall-back tat-tiftix fil-web...")
web_docs = web_search_fallback(question)
relevant_docs.extend(web_docs)
# 4. Ġenerazzjoni
print("4. Ġenerazzjoni...")
answer = self.generate(question, relevant_docs)
return {
"answer": answer,
"sources_used": len(relevant_docs),
"web_search_used": need_web,
}
# Użu
crag = CorrectiveRAG(chunks, embeddings, index)
result = crag.ask("Kif Mistral jimplimenta l-embeddings?")
print(f"\nTweġiba : {result['answer']}")
print(f"Tiftix fil-web użat : {result['web_search_used']}")
Din l-affidabbiltà tiġi bi prezz li trid taċċetta b’mod konxju: b’k=4, kull mistoqsija tistiga erba’ sejħiet ta’ klassifikazzjoni qabel ma tibda anke l-ġenerazzjoni. Il-latency perċepita mill-utent tiżdied skont dan, u hekk ukoll il-kont. Il-kompromess ivarja skont il-każ ta’ użu—għal assistent legali jew mediku, il-verifika mhix negozjabbli; għal magna ta’ tfittxija interna fejn l-utent jara s-sorsi u jiddeċiedi għalih innifsu, hija inqas kritika.
Punti Ewlenin
- Ir-RAG Korrettiv iżid pass ta’ evalwazzjoni tar-rilevanza wara r-riċupru
- LLM iservi bħala “klassifikatur” biex jiġġudika kull dokument: rilevanti jew le
- Jekk id-dokumenti jitqiesu mhux rilevanti, fall-back għat-tiftix fil-web jistiga
- Dan l-approċċ inaqqas b’mod sinifikanti l-alluċinazzjonijiet minħabba kuntest mhux xieraq
- Il-klassifikazzjoni żżid il-latency iżda ttejjeb b’mod qawwi l-affidabbiltà tat-tweġibiet