Retrieval a generovanie
Na tejto strane
Od vektora k odpovedi
Vieš, ako indexovať dokumenty a vyhľadať tie, ktoré sú najbližšie k otázke. Zostáva už len jeden krok: premeniť zoznam chunkov na čitateľnú odpoveď. To znamená vstreknúť získaný kontext do promptu, aby LLM formulovalo odpoveď na základe tvojich dát, nie svojich tréningových spomienok. Stačí na to niekoľko riadkov kódu, no robí to zásadný rozdiel v kvalite. Dobre prezentovaný kontext a jasná inštrukcia sú rovnako dôležité ako presnosť vyhľadávania.
Vytvorenie RAG promptu
Štruktúra promptu je jednoduchá, no každé rozhodnutie má svoje dôsledky. Čísluj chunky a označ ich zdrojom, aby model mohol presne citovať. Oddeľ ich viditeľným oddeľovačom ---, aby model nespojil dva protichodné dokumenty do jedného tvrdenia. Najdôležitejšie je, že inštrukcia musí explicitne obmedziť odpoveď na poskytnutý kontext a dovoliť modelu priznať, že niečo nevie. Bez tohto povolenia bude LLM pri otázke na chýbajúce informácie medzeru vyplniť čímkoľvek, čo sa zdá byť vierohodné. Presne to je mechanizmus halucinácií.
def build_rag_prompt(question, retrieved_chunks):
"""Vytvorí RAG prompt so získaným kontextom."""
# Formátovanie kontextu
context_parts = []
for i, chunk in enumerate(retrieved_chunks):
source = chunk.get("source", "neznámy zdroj")
context_parts.append(f"[Dokument {i+1} - {source}]\n{chunk['text']}")
context = "\n\n---\n\n".join(context_parts)
prompt = f"""Si expertný asistent. Odpovedz na otázku použitím
LEN kontextu poskytnutého nižšie. Ak informácia nie je v
kontexte, jasne to povedz.
## Kontext
{context}
## Otázka
{question}
## Odpoveď"""
return prompt
Generovanie odpovede
Volanie generovania je priamočiare: systémová správa, ktorá opakuje rolu, a používateľská správa, ktorá nesie zostavený prompt. Sleduj parameter teploty, nastavený tu na 0.1. Pri kreatívnom písaní chceš variabilitu; pri RAG chceš opak. Chceš, aby model zostal čo najbližšie k tomu, čo hovorí kontext, a aby dva behy na tú istú otázku vyprodukovali rovnakú odpoveď. Vysoká teplota by nútila model prepisovať, extrapolovať a vzďaľovať sa od zdroja.
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def generate_answer(question, retrieved_chunks, model="mistral-large-latest"):
"""Generuje RAG odpoveď pomocou Mistral."""
prompt = build_rag_prompt(question, retrieved_chunks)
response = client.chat.complete(
model=model,
messages=[
{
"role": "system",
"content": "Si presný asistent, ktorý odpovedá na základe poskytnutého kontextu."
},
{
"role": "user",
"content": prompt,
}
],
temperature=0.1, # Nízka teplota pre faktické odpovede
)
return response.choices[0].message.content
# Príklad
question = "Aké sú hlavné kroky RAG?"
results = search_index(question, index, chunks, k=3)
answer = generate_answer(question, results)
print(answer)
Zapuzdrenie toku do triedy
Roztrúsené funkcie fungujú na prieskum, nie na nasadenie. Trieda RAGPipeline zlučuje stav – chunky, maticu vektorových reprezentácií (embeddings) a FAISS index vytvorený raz pri inicializácii – a tri operácie: retrieve zakóduje otázku a dopytuje index, generate zostaví prompt a zavolá model a ask spája obe tieto činnosti. Všimni si, čo vracia ask: nie reťazec, ale slovník obsahujúci odpoveď, zoznam zdrojov a počet použitých chunkov. Práve táto sledovateľnosť oddeľuje auditovateľného asistenta od čiernej skrinky. V deň, keď používateľ napadne odpoveď, budeš vedieť, na ktoré pasáže sa spoliehala.
import numpy as np
import faiss
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
class RAGPipeline:
"""Kompletný RAG pipeline s Mistral a FAISS."""
def __init__(self, chunks, embeddings):
self.chunks = chunks
self.embeddings = embeddings.astype(np.float32)
# Vytvorenie FAISS indexu
dimension = embeddings.shape[1]
self.index = faiss.IndexFlatL2(dimension)
self.index.add(self.embeddings)
def retrieve(self, question, k=3):
"""Krok 1: získanie relevantných chunkov."""
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):
"""Krok 2: generovanie odpovede s kontextom."""
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):
"""Celý pipeline: otázka -> odpoveď so zdrojmi."""
# Vyhľadanie
context = self.retrieve(question, k=k)
# Generovanie
answer = self.generate(question, context)
return {
"question": question,
"answer": answer,
"sources": [c["source"] for c in context],
"n_chunks_used": len(context),
}
# Použitie
rag = RAGPipeline(chunks, embeddings)
result = rag.ask("Ako funguje indexovanie vo FAISS?")
print(f"Otázka: {result['question']}")
print(f"Odpoveď: {result['answer']}")
print(f"Zdroje: {result['sources']}")
Tri varianty promptu podľa použitia
Základný prompt môžeš špecializovať podľa toho, čo od asistenta očakávaš. Ak musia používatelia overiť každé tvrdenie, explicitne požiadaj o citácie v hranatých zátvorkách. Model potom pripojí každú vetu k číslovanému dokumentu. Ak odpoveď slúži ako vstup pre rozhranie alebo správu, štruktúrovaný formát vynúti stabilné sekcie: stručná odpoveď, podrobnosti, zdroje a úroveň dôvery, ktorá odráža, ako dobre kontext pokrýva otázku. Tretí variant hrá inú úlohu: učí model rozkladať neistotu tým, že rozlišuje medzi tým, čo môže tvrdiť, čo chýba a kde hľadať ďalej. To často produkuje v praxi najužitočnejších asistentov, pretože „Chýba mi X“ je lepšie než sebavedomá, no nesprávna odpoveď.
# 1. Prompt s inštrukciou na citovanie
prompt_cite = """Odpovedz citovaním zdrojových dokumentov v zátvorkách.
Príklad: „RAG zlepšuje presnosť [Dokument 1].“
Kontext: {context}
Otázka: {question}"""
# 2. Prompt so štruktúrovaným formátom
prompt_structured = """Odpovedz v nasledujúcom formáte:
**Odpoveď**: [tvoja stručná odpoveď]
**Podrobnosti**: [podrobné vysvetlenie]
**Zdroje**: [zoznam použitých dokumentov]
**Dôvera**: [vysoká/stredná/nízka na základe pokrytia kontextom]
Kontext: {context}
Otázka: {question}"""
# 3. Prompt s riešením chýbajúcich informácií
prompt_honest = """Ak kontext neobsahuje dostatok informácií na
úplnú odpoveď, jasne uveď:
- Čo môžeš tvrdiť s istotou
- Čo v kontexte chýba
- Návrhy na získanie chýbajúcich informácií
Kontext: {context}
Otázka: {question}"""
Pokiaľ ide o parametre volania, tri nastavenia riadia správanie RAG. Nízka teplota uzamkne faktický výstup, max_tokens zabráni odpovediam, ktoré sa zmenia na eseje, a konzervatívny top_p obmedzí vzorkovaný slovník na najpravdepodobnejšie pokračovania.
# Pre RAG používaj nízku teplotu
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.1, # Faktické, nízka kreativita
max_tokens=1024, # Obmedzenie dĺžky odpovede
top_p=0.95, # Konzervatívne vzorkovanie jadra
)
Kľúčové poznatky
- RAG prompt vstrekne získaný kontext pred otázku
- Na faktické odpovede používaj nízku teplotu (0.1–0.3)
- Požiadaj model o citovanie zdrojov kvôli sledovateľnosti
- Trieda RAGPipeline zapuzdruje celý tok: retrieve, generate, ask
- Rieš prípady, keď kontext neobsahuje dostatok informácií