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

Lekérdezés és generálás

13. lecke 18 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Vektortól a válaszig
  2. A RAG prompt felépítése
  3. A válasz generálása
  4. A folyamat osztályba zárása
  5. Három promptvariáns használati esettől függően
  6. Főbb megállapítások

Vektortól a válaszig

Már tudod, hogyan indexelj dokumentumokat, és hogyan keresd ki a kérdéshez legközelebb állókat. Csak egy lépés maradt: a kiválasztott szövegrészletek listájából olvasható választ készíteni. Ehhez be kell illesztened a lekért kontextust egy promptba, így az LLM a saját tanítási emlékei helyett a te adataid alapján fogalmazza meg a választ. Néhány sor kódról van szó csupán, de ez döntő különbséget jelent a minőségben. A jól felépített kontextus és az egyértelmű utasítás ugyanolyan fontos, mint a lekérdezés pontossága.

A RAG prompt felépítése

A prompt szerkezete egyszerű, de minden választásnak következményei vannak. Számozd meg a szövegrészleteket, és lássd el őket forrásmegjelöléssel, hogy a modell pontosan hivatkozni tudjon rájuk. Válaszd el őket egy jól látható elválasztójellel, például ----sal, hogy a modell ne vonjon össze két ellentmondó dokumentumot egyetlen állítássá. A legfontosabb: az utasításnak kifejezetten korlátoznia kell a választ a megadott kontextusra, és lehetővé kell tennie a modell számára, hogy azt mondja: nem tudja a választ. Ezen engedély nélkül az LLM, ha hiányzó információra kérdezik, bármi plauzibilisnek tűnővel kitölti a hézagot. Ez maga a hallucináció mechanizmusa.

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

A válasz generálása

A generálási hívás egyszerű: egy rendszerüzenet, amely újra meghatározza a szerepet, és egy felhasználói üzenet, amely tartalmazza az összeállított promptot. Figyeld a temperature paramétert, amelyet itt 0,1-re állítottunk. Kreatív írásnál a változatosságra törekszel; a RAG esetében恰恰 az ellenkezőjére. Azt szeretnéd, ha a modell a lehető legközelebb maradna ahhoz, amit a kontextus mond, és azt is, hogy ugyanarra a kérdésre két futtatás ugyanazt a választ adja. Egy magas hőmérséklet arra késztetné a modellt, hogy átfogalmazza, extrapolálja a tartalmat, és eltávolodjon a forrástól.

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)

A folyamat osztályba zárása

Szétszórt függvények megfelelnek a felfedezéshez, de nem az éles交付hoz. A RAGPipeline osztály csomagolja az állapotot – a szövegrészleteket, a beágyazási mátrixot és a FAISS indexet, amelyek egyszer jönnek létre a példányosításkor –, valamint három műveletet: a retrieve kódolja a kérdést és lekérdezi az indexet, a generate összeállítja a promptot és meghívja a modellt, az ask pedig láncolja a kettőt. Figyeld meg, mit ad vissza az ask: nem egy sztringet, hanem egy szótárat, amely tartalmazza a választ, a források listáját és a felhasznált szövegrészletek számát. Ez a nyomon követhetőség választja el az ellenőrizhető asszisztenst a fekete doboztól. Amikor egy felhasználó megkérdőjelez egy választ, tudni fogod, mely passages-re támaszkodott.

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

Három promptvariáns használati esettől függően

Az alap promptot specializálhatod attól függően, mit vársz az asszisztenstől. Ha a felhasználóidnak ellenőrizniük kell minden állítást, kérj expliciten hivatkozásokat szögletes zárójelben. A modell ekkor minden mondathoz hozzárendel egy számozott dokumentumot. Ha a válasz egy felületet vagy jelentést táplál, egy strukturált formátum stabil szakaszokat kényszerít ki: egy tömör választ, részleteket, forrásokat és egy megbízhatósági szintet, amely azt tükrözi, mennyire fedi le a kontextus a kérdést. A harmadik variáns más szerepet játszik: arra tanítja a modellt, hogy bontsa fel a bizonytalanságot azáltal, hogy megkülönbözteti, mit állíthat biztosan, mi hiányzik, és merre érdemes tovább keresgélni. Ez gyakran a leghasznosabb asszisztenseket eredményezi a gyakorlatban, mert az „hiányzik az X információ“ jobb, mint egy magabiztos, de helytelen válasz.

# 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}"""

A hívási paraméterek oldalán három beállítás szabályozza a RAG viselkedését. Egy alacsony hőmérséklet rögzíti a ténybeli kimenetet, a max_tokens megakadályozza, hogy a válaszok esszékbe csússzanak át, egy konzervatív top_p pedig a legvalószínűbb folytatásokra korlátozza a mintavételezett szókincset.

# 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
)

Főbb megállapítások

  • A RAG prompt a lekért kontextust illeszti be a kérdés elé
  • Használj alacsony hőmérsékletet (0,1–0,3) a ténybeli válaszokhoz
  • Kérd a modellt források megjelölésére a nyomon követhetőség érdekében
  • A RAGPipeline osztály kapszulázza a teljes folyamatot: lekérdezés, generálás, kérdezés
  • Kezeld azokat az eseteket, amikor a kontextus nem tartalmaz elegendő információt