Lekérdezés és generálás
Ezen az oldalon
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
RAGPipelineosztá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