Премини към основното съдържание
Български— Изберете език
Меню

Corrective RAG

Урок 15 от 18 Обновен 2 ноември 2026 г. Програмист
На тази страница
  1. Когато извличането не е достатъчно
  2. Оценителят на документи
  3. Уеб мрежата за безопасност
  4. Сглобеният конвейер
  5. Ключови изводи

Когато извличането не е достатъчно

Системата RAG, която изградихте, почива на едно имплицитно допускане: фрагментите, най-близки до въпроса, са правилните. Това допускане често е вярно, но не винаги. Ако заявите индекс по тема, която той не обхваща, FAISS все пак ще върне петте най-близки вектора, колкото и да са извън темата – двигател за сходство не умее да каже „нямам нищо“. Моделът тогава получава неподходящ контекст и тъй като подканата го задължава да разчита на този контекст, той генерира отговор, който изглежда авторитетен, но няма основа. Това е най-коварният сценарий на халюцинации, защото техническата верига е работила без грешка.

Corrective RAG (CRAG) вмъква стъпка за оценка между извличането и генерирането. Голям езиков модел (LLM) разглежда всеки извлечен документ и решава: релевантен или не. Ако присъдата е отрицателна, системата не просто генерира с наличното – тя преминава към уеб търсене, за да открие липсващата информация извън Вашия корпус. Потокът следователно има четири етапа: стандартно извличане от векторното хранилище, оценяване на всеки документ спрямо въпроса, решение дали да се задейства уеб търсене, ако поне един документ е счетен за нерелевантен, и накрая генериране с най-добрите налични документи.

Оценителят на документи

Всичко зависи от оценителя. Триъкът е да поискате от LLM бинарна преценка във формат JSON, а не свободна оценка: {"score": "yes"} или {"score": "no"}, нищо друго. Параметърът response_format={"type": "json_object"} гарантира резултат, който може да се анализира, а temperature=0 елиминира вариативността – една и съща двойка въпрос/документ трябва винаги да получава една и съща присъда, в противен случай поведението на Вашия конвейер става невъзпроизводимо.

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

Тестът в края на блока заслужава внимание. Рецептата за тирамису илюстрира точно онова, което векторното сходство пропуска: ако Вашият корпус говори само за готвене и го запитате за RAG, този фрагмент ще се класира пръв поради липса на конкуренция. Оценителят обаче не сравнява вектори, а чете съдържанието и го отхвърля.

Приложен към всички извлечени фрагменти, тази преценка произвежда две информации: филтрирания списък с документи за запазване и булева стойност, указваща дали да се допълни с уеб. Избраният праг е умишлено строг – един единствен отхвърлен документ е достатъчен, за да задейства резервния вариант, на основание че контекстът тогава е непълен.

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

Уеб мрежата за безопасност

Когато локалните документи не са достатъчни, системата търси другаде. Mistral предоставя вграден инструмент за това, web_search, който активирате чрез Conversations API: моделът сам изпълнява търсенето, след което написва отговора си, цитирайки източниците си. Този детайл е важен, защото обикновено извикване на client.chat.complete не може да търси в уеб: моделът би отговорил от паметта си, с риска да измисли точно онова, което CRAG цели да избегне. Освен това, от версия 3.0 на SDK насам, завършванията на чатове всъщност отхвърлят инструмента web_search.

Ключовият проектен момент е форматът на връщане: функцията връща списък от речници със същата структура като Вашите локални фрагменти, с поле source, зададено на web_search, и добавя цитираните URL адреси. Тази униформеност позволява на следващите стъпки напълно да игнорират произхода на документите, като същевременно запазват следа за крайния потребител.

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

Отговорът съдържа два вида записи: запис tool.execution, който описва стартираното търсене, и запис message.output, чието съдържание редува текстови фрагменти и препратки (tool_reference), носещи заглавието и URL адреса на консултираните страници. Администратор на организацията може да ограничи заявяваните домейни чрез списък с позволени (allowlist) или забранени (blocklist) адреси; филтрираните резултати изчезват без предупреждение, така че твърде тесен списък с позволени адреси може да остави търсенето без резултати.

Официален източник: Websearch (Mistral documentation)

Сглобеният конвейер

Класът CorrectiveRAG възпроизвежда стандартната структура на конвейера, като вмъква оценяването. Стойността по подразбиране k=4 е малко по-щедра от обичайните три фрагмента, което има смисъл: тъй като филтрирането ще отхвърли някои, по-добре е да започнете с марж. Методът ask оркестрира четирите етапа и показва всеки от тях, позволявайки Ви да следите разсъжденията на системата в реално време – колко документа са оцелели след оценяването, дали резервният вариант е задействан. Речникът за връщане също излага web_search_used: това е ценен индикатор за мониторинг в продукция, защото необичайно висока честота на използване на уеб не сигнализира за дефект в CRAG, а за пропуск във Вашия корпус.

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

Тази надеждност има цена, която трябва да приемете съзнателно: при k=4, всеки въпрос задейства четири обаждания за оценяване, преди генерирането дори да започне. Латентността, възприемана от потребителя, се увеличава съответно, както и сметката. Компромисът се различава според случая на употреба – за юридически или медицински асистент проверката е задължителна; за вътрешна търсачка, където потребителят вижда източниците и преценява сам, тя е по-малко критична.

Ключови изводи

  • Corrective RAG добавя стъпка за оценка на релевантността след извличането
  • LLM служи като „оценител“, за да прецени всеки документ: релевантен или не
  • Ако документите се счетат за нерелевантни, се задейства резервно уеб търсене
  • Този подход значително намалява халюцинациите, дължащи се на неподходящ контекст
  • Оценяването добавя латентност, но силно подобрява надеждността на отговорите