Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Corrective RAG

Paskaita 15 iš 18 Atnaujinta 2026 m. lapkričio 2 d. Kūrėjas
Šiame puslapyje
  1. Kai paieškos nepakanka
  2. Dokumentų vertintojas
  3. Interneto saugos tinklas
  4. Surinkta sistema
  5. Svarbiausi punktai

Kai paieškos nepakanka

Tavo sukurtos RAG sistemos veikimas remiasi numanoma prielaida: klausimui artimiausi fragmentai yra tie, kurių reikia. Ši prielaida dažnai pasitvirtina, bet ne visada. Jei užklausi savo indeksą tema, kurios jis neapima, FAISS vis tiek grąžins penkis artimiausius vektorius, nesvarbu, kiek jie būtų nesusiję – panašumo variklis nemoka pasakyti „aš nieko neturiu“. Tuomet modelis gauna netinkamą kontekstą, o kadangi raginamas remtis būtent tuo kontekstu, jis sugeneruoja atsakymą, kuris atrodo autoritetingas, bet neturi jokio pagrindo. Tai klastingiausias haliucinacijų scenarijus, nes techninė grandinė suveikė be klaidų.

Corrective RAG (CRAG) tarp paieškos ir generavimo įterpia vertinimo etapą. Didysis kalbos modelis (LLM) peržiūri kiekvieną gautą dokumentą ir nusprendžia: aktualu ar ne. Jei verdiktas neigiamas, sistema negeneruoja atsakymo remdamasi tuo, ką turi – ji pereina prie paieškos internete, kad rastų informacijos, kurios trūksta tavo duomenų bazėje, kitur. Taigi srautą sudaro keturi etapai: standartinė paieška vektorinėje duomenų bazėje, kiekvieno dokumento vertinimas pagal klausimą, sprendimas inicijuoti paiešką internete, jei bent vienas dokumentas pripažintas nereikšmingu, ir galiausiai atsakymo generavimas naudojant geriausius turimus dokumentus.

Dokumentų vertintojas

Viskas priklauso nuo vertintojo. Gudrybė ta, kad reikia paprašyti LLM pateikti dvejetainį sprendimą JSON formatu, o ne laisvos formos įvertinimą: {"score": "yes"} arba {"score": "no"}, ir nieko daugiau. Parametras response_format={"type": "json_object"} garantuoja, kad išvestį bus galima analizuoti, o temperature=0 pašalina kintamumą – tai pačiai klausimo ir dokumento porai visada turi būti priimtas tas pats sprendimas, kitaip tavo sistemos elgsena taps nepakartojama.

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

Testas bloko pabaigoje nusipelno dėmesio. Tiramisu receptas puikiai iliustruoja tai, ką praleidžia vektorių panašumas: jei tavo duomenų bazėje kalbama tik apie maisto gaminimą, o tu klausi apie RAG, šis fragmentas dėl konkurencijos nebuvimo bus pirmoje vietoje. Tačiau vertintojas lygina ne vektorius, o skaito turinį ir jį atmeta.

Pritaikius šį vertinimą visiems gautiems fragmentams, gaunami du duomenys: filtruotas dokumentų, kuriuos reikia palikti, sąrašas ir loginė reikšmė, nurodanti, ar reikia papildyti informaciją iš interneto. Čia pasirinkta slenkstinė vertė sąmoningai griežta – pakanka vieno atmesto dokumento, kad būtų suaktyvintas atsarginis variantas, remiantis tuo, jog kontekstas tuomet yra neišsamus.

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

Interneto saugos tinklas

Kai vietinių dokumentų nepakanka, sistema ieško kitur. Mistral tam turi integruotą įrankį web_search, kurį galima įjungti per Conversations API: modelis pats atlieka paiešką, o tada rašo atsakymą, cituodamas šaltinius. Ši detalė svarbi, nes paprastas client.chat.complete iškvietimas negali ieškoti internete: modelis atsakytų iš atminties, rizikuodamas sugalvoti būtent tai, ko CRAG siekia išvengti. Be to, nuo SDK 3.0 versijos pokalbių užbaigimai iš tikrųjų atmeta web_search įrankį.

Pagrindinis projektavimo aspektas – grąžinimo formatas: funkcija grąžina žodynų sąrašą, kurio struktūra tokia pati kaip ir tavo vietinių fragmentų, su lauku source, nustatytu į web_search, ir pridėtomis cituojamomis URL adresais. Dėl šio vienodumo tolesni žingsniai gali visiškai ignoruoti dokumentų kilmę, kartu išsaugant pėdsaką galutiniam naudotojui.

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,
    }]

Atsakyme yra dviejų tipų įrašai: tool.execution įrašas, aprašantis paleistą paiešką, ir message.output įrašas, kurio turinys kaitalioja teksto fragmentus ir nuorodas (tool_reference) su peržiūrėtų puslapių pavadinimais ir URL adresais. Organizacijos administratorius gali apriboti užklausiamus domenus naudodamas leidimų sąrašą (allowlist) arba blokavimo sąrašą (blocklist); filtruoti rezultatai išnyksta be įspėjimo, todėl per siauras leidimų sąrašas gali palikti paiešką be jokių rezultatų.

Oficialus šaltinis: Websearch (Mistral documentation)

Surinkta sistema

Klasė CorrectiveRAG perima standartinę sistemos struktūrą, įterpdama vertinimą. Numatytoji k=4 reikšmė yra šiek tiek dosnesnė nei įprasti trys fragmentai, ir tai logiška: kadangi filtravimas kai kuriuos pašalins, geriau pradėti su atsarga. Metodas ask koordinuoja keturis etapus ir rodo kiekvieną iš jų, leisdamas stebėti sistemos samprotavimus realiuoju laiku – kiek dokumentų išgyveno vertinimą, ar suveikė atsarginis variantas. Grąžinamas žodynas taip pat atskleidžia web_search_used: tai vertingas rodiklis stebėti gamybinėje aplinkoje, nes nenormaliai didelis naudojimosi internetu rodiklis signalizuoja ne CRAG trūkumą, o spragą tavo duomenų bazėje.

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']}")

Šis patikimumas turi kainą, kurią turi sąmoningai priimti: esant k=4, kiekvienas klausimas prieš pradedant generavimą sukelia keturis vertinimo iškvietimus. Naudotojo suvokiama delsos trukmė atitinkamai didėja, kaip ir sąskaita. Kompromisas priklauso nuo naudojimo atvejo – teisiniam ar medicininiam asistentui patikrinimas yra būtinas; vidinei paieškos sistemai, kurioje naudotojas mato šaltinius ir pats vertina, tai mažiau kritiška.

Svarbiausi punktai

  • Corrective RAG po paieškos prideda aktualumo vertinimo etapą
  • LLM veikia kaip „vertintojas“, sprendžiantis apie kiekvieną dokumentą: aktualu ar ne
  • Jei dokumentai pripažįstami nereikšmingais, suaktyvinamas atsarginis variantas – paieška internete
  • Šis požiūris žymiai sumažina haliucinacijas, kylančias dėl netinkamo konteksto
  • Vertinimas padidina delsą, tačiau labai pagerina atsakymų patikimumą