Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

RAG korektiv

Lekcija 15 od 18 Ažurirano 2. studenoga 2026. Programer
Na ovoj stranici
  1. Kada dohvaćanje nije dovoljno
  2. Ocjenjivač dokumenata
  3. Web sigurnosna mreža
  4. Sastavljeni pipeline
  5. Ključne točke

Kada dohvaćanje nije dovoljno

RAG sustav koji si izgradio počiva na implicitnoj pretpostavci: isječci najsličniji pitanju su oni pravi. Ta pretpostavka često vrijedi, ali ne uvijek. Upitaj svoj indeks o temi koju ne pokriva i FAISS će ipak vratiti pet najbližih vektora, bez obzira na to koliko su izvan teme – motor sličnosti ne zna reći „nemam ništa“. Model tada prima neprikladan kontekst, a budući da ga upit traži da se osloni na taj kontekst, proizvodi odgovor koji izgleda autoritativno, ali nema utemeljenja. To je najpodmukliji scenarij halucinacije jer je tehnički lanac radio bez greške.

RAG korektiv (CRAG) ubacuje korak evaluacije između dohvaćanja i generiranja. LLM pregledava svaki dohvaćeni dokument i odlučuje: relevantan ili ne. Ako je presuda negativna, sustav ne generira odgovor samo s onim što ima – prelazi na pretraživanje weba kako bi pronašao informacije koje nedostaju u tvom korpusu negdje drugdje. Tijek stoga ima četiri faze: standardno dohvaćanje iz vektorske pohrane, ocjenjivanje svakog dokumenta u odnosu na pitanje, odluka hoće li se pokrenuti pretraživanje weba ako se barem jedan dokument smatra nebitnim, i konačno generiranje s najboljim dostupnim dokumentima.

Ocjenjivač dokumenata

Sve ovisi o ocjenjivaču. Trik je tražiti od LLM-a binarnu presudu u JSON formatu umjesto slobodne procjene: {"score": "yes"} ili {"score": "no"}, ništa više. Parametar response_format={"type": "json_object"} jamči parsabilan izlaz, a temperature=0 eliminira varijabilnost – isti par pitanje/dokument uvijek mora dobiti istu presudu, inače ponašanje tvog pipelinea postaje neproduktivno.

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 kraju bloka zaslužuje pozornost. Recept za tiramisu ilustrira točno ono što vektorska sličnost propušta: ako tvoj korpus govori samo o kuhanju, a upitaš ga o RAG-u, ovaj isječak će se rangirati prvi zbog nedostatka konkurencije. Ocjenjivač, međutim, ne uspoređuje vektore već čita sadržaj i odbacuje ga.

Primijenjen na sve dohvaćene isječke, ovaj sud proizvodi dvije informacije: filtrirani popis dokumenata za zadržavanje i boolean vrijednost koja označava treba li dopuniti podatke s weba. Prag odabran ovdje namjerno je strog – jedan odbačeni dokument dovoljan je za pokretanje sigurnosne kopije, s obrazloženjem da je kontekst tada nepotpun.

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

Web sigurnosna mreža

Kada lokalni dokumenti nisu dovoljni, sustav gleda drugamo. Mistral za to pruža ugrađeni alat, web_search, koji omogućuješ putem Conversations API-ja: model sam pokreće pretraživanje, a zatim piše svoj odgovor citirajući izvore. Ova detalj je važan jer jednostavan poziv client.chat.complete ne može pretraživati web: model bi odgovorio iz memorije, s rizikom da izmisli točno ono što CRAG želi izbjeći. A od verzije SDK-a 3.0, chat completions zapravo odbijaju alat web_search.

Ključna točka dizajna je format povrata: funkcija vraća popis rječnika istog oblika kao tvoji lokalni isječci, s poljem source postavljenim na web_search, i dodaje citirane URL-ove. Ta ujednačenost omogućuje nizvodnim koracima da potpuno ignoriraju podrijetlo dokumenata, a da pritom sačuvaju trag za krajnjeg korisnika.

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

Odgovor sadrži dvije vrste unosa: unos tool.execution, koji opisuje pokrenuto pretraživanje, i unos message.output, čiji sadržaj izmjenjuje tekstualne fragmente i reference (tool_reference) koje nose naslov i URL konzultiranih stranica. Administrator organizacije može ograničiti domene koje se upituju putem popisa dopuštenih (allowlist) ili blokiranih (blocklist); filtrirani rezultati nestaju bez upozorenja, pa previše uzak popis dopuštenih može ostaviti pretraživanje bez rezultata.

Službeni izvor: Websearch (Mistral documentation)

Sastavljeni pipeline

Klasa CorrectiveRAG preuzima strukturu standardnog pipelinea ubacivanjem ocjenjivanja. Zadani k=4 nešto je velikodušniji od uobičajena tri isječka, što ima smisla: budući da će filtriranje neke odbaciti, bolje je krenuti s marginom. Metoda ask orchestrira četiri faze i prikazuje svaku od njih, omogućujući ti da pratiš rezoniranje sustava u stvarnom vremenu – koliko je dokumenata preživjelo ocjenjivanje, je li se aktivirala sigurnosna kopija. Rječnik povrata također izlaže web_search_used: to je vrijedan pokazatelj za praćenje u produkciji, jer abnormalno visoka stopa korištenja weba ne signalizira manu CRAG-a već prazninu u tvom korpusu.

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

Ova pouzdanost ima cijenu koju moraš svjesno prihvatiti: s k=4, svako pitanje pokreće četiri poziva ocjenjivanja prije nego što generiranje uopće započne. Latencija koju korisnik percipira sukladno tome raste, kao i račun. Kompromis se razlikuje ovisno o slučaju upotrebe – za pravnog ili medicinskog asistenta, provjera je neupitna; za interni tražilicu gdje korisnik vidi izvore i sam prosuđuje, manje je kritična.

Ključne točke

  • RAG korektiv dodaje korak evaluacije relevantnosti nakon dohvaćanja
  • LLM služi kao „ocjenjivač“ za procjenu svakog dokumenta: relevantan ili ne
  • Ako se dokumenti smatraju nebitnima, aktivira se sigurnosna kopija pretraživanja weba
  • Ovaj pristup značajno smanjuje halucinacije uzrokovane neprikladnim kontekstom
  • Ocjenjivanje dodaje latenciju, ali snažno poboljšava pouzdanost odgovora