Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

RAG Korrettiv

Lezzjoni 15 / 18 Aġġornat 2 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Meta r-riċupru ma jkunx biżżejjed
  2. Il-klassifikatur tad-dokumenti
  3. In-netta ta’ sikurezza tal-web
  4. Il-pipeline assemblat
  5. Punti Ewlenin

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