Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Corrective RAG

Lekcia 15 z 18 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Keď vyhľadávanie nestačí
  2. Hodnotiteľ dokumentov
  3. Webová záchranná sieť
  4. Zostavený pipeline
  5. Kľúčové poznatky

Keď vyhľadávanie nestačí

Systém RAG, ktorý si zostavil, vychádza z implicitného predpokladu: úryvky najpodobnejšie otázke sú tie správne. Tento predpoklad často platí, no nie vždy. Ak sa opýtaš indexu na tému, ktorú nepokrýva, FAISS ti aj tak vráti päť najbližších vektorov, bez ohľadu na to, ako sú mimo témy – motor podobnosti nevie povedať „nemám nič“. Model potom dostane nevhodný kontext a keďže ho výzva núti spoliehať sa na tento kontext, vygeneruje odpoveď, ktorá vyzerá autoritatívne, no nemá oporu. Toto je najzákernejší scenár halucinácií, pretože technický reťazec fungoval bez chyby.

Corrective RAG (CRAG) vkladá medzi vyhľadávanie a generovanie krok vyhodnotenia. LLM preskúma každý získaný dokument a rozhodne: relevantný alebo nie. Ak je verdikt záporný, systém negeneruje odpoveď len z toho, čo má – prepne sa na webové vyhľadávanie, aby našiel chýbajúce informácie inde mimo tvojho korpusu. Tok má teda štyri fázy: štandardné vyhľadávanie vo vektorovom úložisku, hodnotenie každého dokumentu voči otázke, rozhodnutie, či spustiť webové vyhľadávanie, ak sa aspoň jeden dokument ukáže ako irelevantný, a nakoniec generovanie s najlepšími dostupnými dokumentmi.

Hodnotiteľ dokumentov

Všetko stojí a padá na hodnotiteľovi. Trik spočíva v tom, požiadať LLM o binárny úsudok vo formáte JSON namiesto voľného hodnotenia: {"score": "yes"} alebo {"score": "no"}, nič viac. Parameter response_format={"type": "json_object"} zaručí výstup, ktorý sa dá analyzovať, a temperature=0 eliminuje variabilitu – rovnaký pár otázka/dokument musí vždy dostať rovnaký verdikt, inak sa správanie tvojho pipeline stane nereprodukovateľným.

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 konci bloku si zaslúži pozornosť. Recept na tiramisu ilustruje presne to, čo vektorová podobnosť prepustí: ak tvoj korpus hovorí len o varení a opýtaš sa ho na RAG, tento úryvok sa zaradi na prvé miesto pre nedostatok konkurencie. Hodnotiteľ však neporovnáva vektory, ale číta obsah a odmietne ho.

Aplikované na všetky získané úryvky toto hodnotenie produkuje dve informácie: filtrovaný zoznam dokumentov na ponechanie a booleovskú hodnotu indikujúcu, či doplniť údaje z webu. Tu zvolený prah je zámerne prísny – stačí jeden vyradený dokument na spustenie záložného mechanizmu, keďže kontext je potom neúplný.

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

Webová záchranná sieť

Keď lokálne dokumenty nestačia, systém sa pozrie inde. Mistral na to poskytuje vstavaný nástroj web_search, ktorý povolíš cez Conversations API: model sám vykoná vyhľadávanie a potom napíše odpoveď s citáciou zdrojov. Tento detail je dôležitý, pretože jednoduché volanie client.chat.complete nevie vyhľadávať na webe: model by odpovedal z pamäte s rizikom, že si vymyslí presne to, čomu sa CRAG snaží vyhnúť. A od verzie SDK 3.0 chatové dokončovania nástroj web_search dokonca odmietajú.

Kľúčovým bodom dizajnu je formát návratovej hodnoty: funkcia vráti zoznam slovníkov s rovnakou štruktúrou ako tvoje lokálne úryvky, pričom pole source je nastavené na web_search a pridajú sa citované URL adresy. Táto uniformita umožňuje nasledujúcim krokom úplne ignorovať pôvod dokumentov a zároveň zachovať stopu pre koncového používateľa.

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

Odpoveď obsahuje dva typy záznamov: záznam tool.execution, ktorý opisuje spustené vyhľadávanie, a záznam message.output, ktorého obsah strieda textové fragmenty a referencie (tool_reference) nesúce titul a URL adresu konzultovaných stránok. Administrátor organizácie môže obmedziť dopytované domény prostredníctvom allowlistu alebo blocklistu; filtrované výsledky zmiznú bez varovania, takže príliš úzky allowlist môže nechať vyhľadávanie bez výsledkov.

Oficiálny zdroj: Websearch (Mistral documentation)

Zostavený pipeline

Trieda CorrectiveRAG preberá štruktúru štandardného pipeline vložením hodnotenia. Predvolené k=4 je o niečo veľkorysejšie ako obvyklé tri úryvky, čo dáva zmysel: keďže filtrovanie niektoré vyradí, je lepšie začať s rezervou. Metóda ask orchestruje štyri fázy a zobrazuje každú z nich, čo ti umožňuje sledovať uvažovanie systému v reálnom čase – koľko dokumentov prešlo hodnotením, či sa spustil záložný mechanizmus. Návratový slovník tiež expose web_search_used: toto je cenný indikátor na monitorovanie v produkcii, pretože abnormálne vysoká miera využívania webu nesignalizuje chybu CRAG, ale medzeru v tvojom korpuse.

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

Táto spoľahlivosť má cenu, ktorú musíš vedome akceptovať: pri k=4 každá otázka spustí štyri volania hodnotenia ešte predtým, než začne generovanie. Latencia vnímaná používateľom sa tým primerane zvyšuje, rovnako ako faktúra. Kompromis sa líši podľa použitia – pre právneho alebo lekárskeho asistenta je overenie nenegotiovateľné; pre interný vyhľadávač, kde používateľ vidí zdroje a posúdi ich sám, je to menej kritické.

Kľúčové poznatky

  • Corrective RAG pridáva krok vyhodnotenia relevantnosti po vyhľadávaní
  • LLM slúži ako „hodnotiteľ“ na posúdenie každého dokumentu: relevantný alebo nie
  • Ak sa dokumenty ukážu ako irelevantné, spustí sa záložné webové vyhľadávanie
  • Tento prístup výrazne znižuje halucinácie spôsobené nevhodným kontextom
  • Hodnotenie pridáva latenciu, no silno zlepšuje spoľahlivosť odpovedí