Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Corrective RAG

15. lecke 18 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Amikor a lekérdezés nem elég
  2. A dokumentum-osztályozó
  3. A webes biztonsági háló
  4. Az összeállított pipeline
  5. Főbb megállapítások

Amikor a lekérdezés nem elég

A felépített RAG-rendszered egy hallgatólagos feltételezésen alapul: a kérdésre leginkább hasonlító töredékek a megfelelőek. Ez a feltételezés gyakran igaz, de nem mindig. Ha egy olyan témában kérdezed le az indexet, amelyet az nem fed le, a FAISS akkor is visszaadja az öt legközelebbi vektort, függetlenül attól, mennyire idegenek a témától – egy hasonlósági motor nem tudja azt mondani, hogy „nincs semmim“. A modell ezután alkalmatlan kontextust kap, és mivel a prompt arra utasítja, hogy erre a kontextusra támaszkodjon, olyan választ generál, amely tekintélyt parancsolónak tűnik, de nincs alapja. Ez a legárulkodóbb hallucinációs forgatókönyv, mert a technikai lánc hiba nélkül működött.

A Corrective RAG (CRAG) egy értékelési lépést iktat be a lekérdezés és a generálás közé. Egy LLM megvizsgál minden visszanyert dokumentumot, és eldönti: releváns vagy sem. Ha az ítélet negatív, a rendszer nem egyszerűen generál a rendelkezésre álló adatokkal – hanem webes keresésre vált, hogy megtalálja a hiányzó információt a korpuszon kívül. A folyamatnak tehát négy szakasza van: szabványos lekérdezés a vektortárból, minden dokumentum osztályozása a kérdés alapján, döntés arról, hogy elindítsunk-e egy webes keresést, ha legalább egy dokumentumot irrelevánsnak ítéltek, és végül a generálás a legjobb elérhető dokumentumokkal.

A dokumentum-osztályozó

Minden az osztályozón múlik. A trükk az, hogy bináris ítéletet kérjünk az LLM-től JSON formátumban, nem pedig szabad szöveges értékelést: {"score": "yes"} vagy {"score": "no"}, semmi más. A response_format={"type": "json_object"} paraméter garantálja a feldolgozható kimenetet, a temperature=0 pedig kiküszöböli a változékonyságot – ugyanannak a kérdés/dokumentum párosnak mindig ugyanazt az ítéletet kell hoznia, különben a pipeline viselkedése reprodukálhatatlanná válik.

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

A blokk végén lévő teszt figyelmet érdemel. A tiramisu recept pontosan azt szemlélteti, amin a vektorhasonlóság átsiklik: ha a korpuszod csak főzésről szól, és RAG-ről kérdezed, ez a töredék fog az első helyen végezni a verseny hiánya miatt. Az osztályozó azonban nem vektorokat hasonlít össze, hanem elolvassa a tartalmat, és elutasítja azt.

Ha ezt az ítéletet az összes visszanyert töredékre alkalmazzuk, két információhoz jutunk: a megtartandó dokumentumok szűrt listájához, és egy boolean értékhez, amely jelzi, hogy szükséges-e kiegészíteni a webes kereséssel. Az itt választott küszöb szándékosan szigorú – egyetlen elvetett dokumentum is elég a tartalék megoldás aktiválásához, azon az alapon, hogy a kontextus ekkor hiányos.

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

A webes biztonsági háló

Amikor a helyi dokumentumok nem elegendőek, a rendszer máshol keresgél. A Mistral erre beépített eszközt kínál, a web_search-t, amelyet a Conversations API-n keresztül aktiválsz: a modell maga futtatja le a keresést, majd források megjelölésével írja meg a választ. Ez a részlet számít, mert egy egyszerű client.chat.complete hívás nem képes webes keresésre: a modell a memóriájából válaszolna, azzal a kockázattal, hogy éppen azt találja ki, amit a CRAG elkerülni kíván. Ráadásul a 3.0-s SDK verziótól kezdve a chat kiegészítések valójában elutasítják a web_search eszközt.

A kulcsfontosságú tervezési pont a visszatérési formátum: a függvény szótárak listáját adja vissza, amelyek megegyeznek a helyi töredékeid szerkezetével, egy source mezővel, amelynek értéke web_search, és hozzáadja az idézett URL-eket. Ez az egységesség lehetővé teszi, hogy a későbbi lépések teljesen figyelmen kívül hagyják a dokumentumok eredetét, miközben megőrzik a nyomvonalat a végfelhasználó számára.

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

A válasz kétféle bejegyzést tartalmaz: egy tool.execution bejegyzést, amely leírja az elindított keresést, és egy message.output bejegyzést, amelynek tartalma szövegrészletek és hivatkozások (tool_reference) között váltakozik, amelyek tartalmazzák a felkeresett oldalak címét és URL-jét. Egy szervezet adminisztrátora korlátozhatja a lekérdezett domaineket egy engedélyezési listával (allowlist) vagy letiltási listával (blocklist); a szűrt eredmények figyelmeztetés nélkül eltűnnek, így egy túl szűk engedélyezési lista eredményezheti azt, hogy a keresésnek nincs eredménye.

Hivatalos forrás: Websearch (Mistral dokumentáció)

Az összeállított pipeline

A CorrectiveRAG osztály újrafelhasználja a szabványos pipeline szerkezetét az osztályozás beillesztésével. Az alapértelmezett k=4 valamivel nagylelkűbb, mint a szokásos három töredék, aminek van értelme: mivel a szűrés kidob majd néhányat, jobb tartalékkal indulni. Az ask módszer orchestrálja a négy szakaszt, és megjeleníti mindegyiket, így valós időben követheted a rendszer gondolkodásmódját – hány dokumentum élte túl az osztályozást, elindult-e a tartalék megoldás. A visszatérő szótár továbbá exposes web_search_used: ez egy értékes mutató, amelyet éles környezetben érdemes figyelni, mert a rendellenesen magas webes használati arány nem a CRAG hibájára utal, hanem a korpuszodban lévő hézagra.

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

Ez a megbízhatóság költséggel jár, amit tudatosan el kell fogadnod: k=4 esetén minden kérdés négy osztályozási hívást indít el, még mielőtt a generálás egyáltalán elkezdődne. A felhasználó által észlelt késleltetés ennek megfelelően nő, ahogy a számla is. Az előny-hátrány mérlegelés esetenként változik – egy jogi vagy orvosi asszisztens esetén az ellenőrzés nem alkupont; egy belső keresőmotornál, ahol a felhasználó látja a forrásokat, és maga ítéli meg őket, ez kevésbé kritikus.

Főbb megállapítások

  • A Corrective RAG egy relevancia-értékelési lépést ad hozzá a lekérdezés után
  • Egy LLM szolgál „osztályozóként“, hogy megítéljen minden dokumentumot: releváns vagy sem
  • Ha a dokumentumokat irrelevánsnak ítélik, egy webes keresésre való visszalépés indul el
  • Ez a megközelítés jelentősen csökkenti a nem megfelelő kontextus miatti hallucinációkat
  • Az osztályozás növeli a késleltetést, de erősen javítja a válaszok megbízhatóságát