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

Dohvaćanje i generiranje

Lekcija 13 od 18 Ažurirano 2. studenoga 2026. Programer
Na ovoj stranici
  1. Od vektora do odgovora
  2. Izgradnja RAG upita
  3. Generiranje odgovora
  4. Inkapsuliranje tijeka u klasu
  5. Tri varijante upita prema slučaju uporabe
  6. Ključne točke

Od vektora do odgovora

Znaš indeksirati dokumente i dohvatiti one najbliže postavljenom pitanju. Preostaje još jedan korak: pretvoriti popis isječaka u čitljiv odgovor. To znači ubaciti dohvaćeni kontekst u upit (prompt) kako bi veliki jezični model (LLM) formulirao odgovor na temelju tvojih podataka, a ne svojih trening sjećanja. Potrebno je samo nekoliko redaka koda, ali to čini presudnu razliku u kvaliteti. Dobro prezentiran kontekst i jasna instrukcija jednako su važni kao i preciznost dohvaćanja.

Izgradnja RAG upita

Struktura upita jednostavna je, ali svaki izbor ima posljedice. Numeriraj isječke i označi ih izvorom kako bi model mogao precizno citirati. Odvoji ih vidljivim razdjelnikom, ---, kako model ne bi spojio dva kontradiktorna dokumenta u jednu tvrdnju. Najvažnije, instrukcija mora izričito ograničiti odgovor na pruženi kontekst i dopustiti modelu da kaže kako ne zna. Bez te dozvole, LLM upitan o informacijama kojih nema popunit će prazninu onim što mu se čini vjerojatnim. To je upravo mehanizam halucinacije.

def build_rag_prompt(question, retrieved_chunks):
    """Build the RAG prompt with retrieved context."""
    # Format the context
    context_parts = []
    for i, chunk in enumerate(retrieved_chunks):
        source = chunk.get("source", "unknown source")
        context_parts.append(f"[Document {i+1} - {source}]\n{chunk['text']}")

    context = "\n\n---\n\n".join(context_parts)

    prompt = f"""You are an expert assistant. Answer the question using
ONLY the context provided below. If the information is not in the
context, say so clearly.

## Context

{context}

## Question

{question}

## Answer"""

    return prompt

Generiranje odgovora

Poziv za generiranje jednostavan je: sistemska poruka koja ponavlja ulogu i korisnička poruka koja nosi sastavljeni upit. Pazi na parametar temperature, ovdje postavljen na 0.1. U kreativnom pisanju želiš raznolikost; u RAG-u želiš suprotno. Želiš da model ostane što je moguće bliže onome što kontekst kaže i želiš da dva pokretanja na istom pitanju daju isti odgovor. Visoka temperatura natjerala bi model na prepričavanje, ekstrapolaciju i udaljavanje od izvora.

from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def generate_answer(question, retrieved_chunks, model="mistral-large-latest"):
    """Generate a RAG answer with Mistral."""
    prompt = build_rag_prompt(question, retrieved_chunks)

    response = client.chat.complete(
        model=model,
        messages=[
            {
                "role": "system",
                "content": "You are a precise assistant that answers based on the provided context."
            },
            {
                "role": "user",
                "content": prompt,
            }
        ],
        temperature=0.1,  # Low temperature for factual answers
    )

    return response.choices[0].message.content

# Example
question = "What are the main steps of RAG?"
results = search_index(question, index, chunks, k=3)
answer = generate_answer(question, results)
print(answer)

Inkapsuliranje tijeka u klasu

Raspršene funkcije rade za istraživanje, ali ne i za isporuku. Klasa RAGPipeline objedinjuje stanje—isječke, matricu ugradnji (embeddings) i FAISS indeks izgrađen jednom prilikom inicijalizacije—te tri operacije: retrieve kodira pitanje i upituje indeks, generate sastavlja upit i poziva model, a ask povezuje ta dva koraka. Obrati pažnju na ono što ask vraća: ne niz znakova, već rječnik koji sadrži odgovor, popis izvora i broj korištenih isječaka. Ta mogućnost praćenja ono je što odvaja revizibilnog asistenta od crne kutije. Dan kada korisnik ospori odgovor, znat ćeš na koje se odlomke oslanjao.

import numpy as np
import faiss
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

class RAGPipeline:
    """Complete RAG pipeline with Mistral and FAISS."""

    def __init__(self, chunks, embeddings):
        self.chunks = chunks
        self.embeddings = embeddings.astype(np.float32)

        # Create the FAISS index
        dimension = embeddings.shape[1]
        self.index = faiss.IndexFlatL2(dimension)
        self.index.add(self.embeddings)

    def retrieve(self, question, k=3):
        """Step 1: retrieve relevant chunks."""
        response = client.embeddings.create(
            model="mistral-embed",
            inputs=[question],
        )
        query_vector = np.array(
            [response.data[0].embedding], dtype=np.float32
        )

        distances, indices = self.index.search(query_vector, 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", ""),
                    "distance": float(dist),
                })
        return results

    def generate(self, question, context_chunks):
        """Step 2: generate the answer with context."""
        prompt = build_rag_prompt(question, context_chunks)

        response = client.chat.complete(
            model="mistral-large-latest",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.1,
        )
        return response.choices[0].message.content

    def ask(self, question, k=3):
        """Full pipeline: question -> sourced answer."""
        # Retrieval
        context = self.retrieve(question, k=k)

        # Generation
        answer = self.generate(question, context)

        return {
            "question": question,
            "answer": answer,
            "sources": [c["source"] for c in context],
            "n_chunks_used": len(context),
        }

# Usage
rag = RAGPipeline(chunks, embeddings)
result = rag.ask("How does indexing work in FAISS?")

print(f"Question: {result['question']}")
print(f"Answer: {result['answer']}")
print(f"Sources: {result['sources']}")

Tri varijante upita prema slučaju uporabe

Osnovni upit možeš specijalizirati ovisno o tome što očekuješ od asistenta. Ako tvoji korisnici moraju verificirati svaku tvrdnju, izričito zatraži citate u zagradama. Model tada svaku rečenicu veže uz numerirani dokument. Ako odgovor napaja sučelje ili izvješće, strukturirani format nameće stabilne dijelove: sažeti odgovor, pojedinosti, izvore i razinu pouzdanosti koja odražava koliko dobro kontekst pokriva pitanje. Treća varijanta igra drugačiju ulogu: uči model raščlaniti nesigurnost razlikovanjem onoga što može tvrditi, onoga što nedostaje i gdje dalje tražiti. To često u praksi proizvodi najkorisnije asistente, jer „nedostaje mi X“ vrijedi više od samouvjerenog, ali pogrešnog odgovora.

# 1. Prompt with citation instruction
prompt_cite = """Answer by citing source documents in brackets.
Example: "RAG improves accuracy [Document 1]."

Context: {context}
Question: {question}"""

# 2. Prompt with structured format
prompt_structured = """Answer in the following format:

**Answer**: [your concise answer]
**Details**: [detailed explanation]
**Sources**: [list of documents used]
**Confidence**: [high/medium/low based on context coverage]

Context: {context}
Question: {question}"""

# 3. Prompt with missing-information handling
prompt_honest = """If the context does not contain enough information to
answer completely, state clearly:
- What you can assert with certainty
- What is missing from the context
- Suggestions for obtaining the missing information

Context: {context}
Question: {question}"""

Što se tiče parametara poziva, tri postavke upravljaju ponašanjem RAG-a. Niska temperatura zaključava činjenični izlaz, max_tokens sprječava odgovore koji skreću u eseje, a konzervativni top_p ograničava uzorkovani rječnik na najvjerojatnije nastavke.

# For RAG, use a low temperature
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1,   # Factual, low creativity
    max_tokens=1024,    # Limit answer length
    top_p=0.95,         # Conservative nucleus sampling
)

Ključne točke

  • RAG upit ubacuje dohvaćeni kontekst prije pitanja
  • Koristi nisku temperaturu (0.1–0.3) za činjenične odgovore
  • Zatraži od modela da citira izvore radi mogućnosti praćenja
  • Klasa RAGPipeline inkapsulira cijeli tijek: dohvaćanje, generiranje, postavljanje pitanja
  • Rukuj slučajevima gdje kontekst nema dovoljno informacija