Načítání a generování
Na této stránce
Od vektoru k odpovědi
Umíš indexovat dokumenty a vyhledávat ty, které jsou otázce nejblíže. Zbývá poslední krok: proměnit seznam úryvků v čitelnou odpověď. To znamená vstříknout načtený kontext do promptu, aby LLM formulovalo odpověď na základě tvých dat, nikoliv svých tréninkových vzpomínek. Stačí k tomu několik řádků kódu, ale dělají zásadní rozdíl v kvalitě. Dobře prezentovaný kontext a jasná instrukce jsou stejně důležité jako přesnost vyhledávání.
Sestavení RAG promptu
Struktura promptu je jednoduchá, ale každé rozhodnutí má své důsledky. Číslij úryvky a opatři je anotací zdroje, aby model mohl přesně citovat. Odděl je viditelným oddělovačem ---, aby model nespojil dva protichůdné dokumenty do jednoho tvrzení. Nejdůležitější je, že instrukce musí explicitně omezit odpověď pouze na poskytnutý kontext a umožnit modelu přiznat, že neví. Bez tohoto povolení bude LLM při dotazu na chybějící informace vyplňovat mezery tím, co se zdá pravděpodobné. To je samotný mechanismus halucinací.
def build_rag_prompt(question, retrieved_chunks):
"""Sestaví RAG prompt s načteným kontextem."""
# Formátování kontextu
context_parts = []
for i, chunk in enumerate(retrieved_chunks):
source = chunk.get("source", "neznámý zdroj")
context_parts.append(f"[Dokument {i+1} - {source}]\n{chunk['text']}")
context = "\n\n---\n\n".join(context_parts)
prompt = f"""Jsi expertní asistent. Odpověz na otázku POUZE
na základě níže uvedeného kontextu. Pokud informace v kontextu
není, jasně to uveď.
## Kontext
{context}
## Otázka
{question}
## Odpověď"""
return prompt
Generování odpovědi
Volání generování je přímočaré: systémová zpráva, která znovu definuje roli, a uživatelská zpráva nesoucí sestavený prompt. Sleduj parametr teploty, zde nastavený na 0,1. Při kreativním psaní chceš rozmanitost; u RAG chceš opak. Chceš, aby model zůstal co nejblíže tomu, co říká kontext, a aby dva běhy se stejnou otázkou produkovaly stejnou odpověď. Vysoká teplota by model tlačila k přeformulování, extrapolaci a vzdalování se od zdroje.
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def generate_answer(question, retrieved_chunks, model="mistral-large-latest"):
"""Generuje RAG odpověď pomocí Mistralu."""
prompt = build_rag_prompt(question, retrieved_chunks)
response = client.chat.complete(
model=model,
messages=[
{
"role": "system",
"content": "Jsi precizní asistent, který odpovídá na základě poskytnutého kontextu."
},
{
"role": "user",
"content": prompt,
}
],
temperature=0.1, # Nízká teplota pro faktické odpovědi
)
return response.choices[0].message.content
# Příklad
question = "Jaké jsou hlavní kroky RAG?"
results = search_index(question, index, chunks, k=3)
answer = generate_answer(question, results)
print(answer)
Zapouzdření toku do třídy
Roztříštěné funkce fungují pro průzkum, ne pro nasazení. Třída RAGPipeline sdružuje stav – úryvky, matici vnoření a index FAISS vytvořený jednou při inicializaci – a tři operace: retrieve zakóduje otázku a dotáže se indexu, generate sestaví prompt a zavolá model a ask řetězí obě operace. Všimni si, co vrací ask: ne řetězec, ale slovník obsahující odpověď, seznam zdrojů a počet použitých úryvků. Tato sledovatelnost odděluje auditovatelného asistenta od černé skříně. Až někdy uživatel zpochybní odpověď, budeš vědět, na které pasáže se spoléhala.
import numpy as np
import faiss
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
class RAGPipeline:
"""Kompletní RAG pipeline s Mistralem a FAISS."""
def __init__(self, chunks, embeddings):
self.chunks = chunks
self.embeddings = embeddings.astype(np.float32)
# Vytvoření indexu FAISS
dimension = embeddings.shape[1]
self.index = faiss.IndexFlatL2(dimension)
self.index.add(self.embeddings)
def retrieve(self, question, k=3):
"""Krok 1: načtení relevantních úryvků."""
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: generování odpovědi s kontextem."""
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 -> odpověď se zdroji."""
# Načtení
context = self.retrieve(question, k=k)
# Generování
answer = self.generate(question, context)
return {
"question": question,
"answer": answer,
"sources": [c["source"] for c in context],
"n_chunks_used": len(context),
}
# Použití
rag = RAGPipeline(chunks, embeddings)
result = rag.ask("Jak funguje indexování ve FAISS?")
print(f"Otázka: {result['question']}")
print(f"Odpověď: {result['answer']}")
print(f"Zdroje: {result['sources']}")
Tři varianty promptu podle použití
Základní prompt můžeš specializovat podle toho, co od asistenta očekáváš. Pokud musí uživatelé ověřit každé tvrzení, explicitně požádej o citace v hranatých závorkách. Model pak připojí každou větu k číslovanému dokumentu. Pokud odpověď napájí rozhraní nebo zprávu, vynutí strukturovaný formát stabilní sekce: stručnou odpověď, podrobnosti, zdroje a úroveň důvěry, která odráží, jak dobře kontext pokrývá otázku. Třetí varianta hraje jinou roli: učí model rozkládat nejistotu rozlišením toho, co může tvrdit, co chybí a kde hledat dál. To často produkuje v praxi nejužitečnější asistenty, protože „chybí mi X“ je lepší než sebevědomá, ale špatná odpověď.
# 1. Prompt s instrukcí pro citaci
prompt_cite = """Odpověz citováním zdrojových dokumentů v hranatých závorkách.
Příklad: „RAG zlepšuje přesnost [Dokument 1].“
Kontext: {context}
Otázka: {question}"""
# 2. Prompt se strukturovaným formátem
prompt_structured = """Odpověz v následujícím formátu:
**Odpověď**: [tvá stručná odpověď]
**Podrobnosti**: [podrobné vysvětlení]
**Zdroje**: [seznam použitých dokumentů]
**Důvěra**: [vysoká/střední/nízká na základě pokrytí kontextem]
Kontext: {context}
Otázka: {question}"""
# 3. Prompt s řešením chybějících informací
prompt_honest = """Pokud kontext neobsahuje dostatek informací pro
úplnou odpověď, jasně uveď:
- Co můžeš tvrdit s jistotou
- Co v kontextu chybí
- Návrhy, jak získat chybějící informace
Kontext: {context}
Otázka: {question}"""
Na straně parametrů volání řídí chování RAG tři nastavení. Nízká teplota uzamkne faktický výstup, max_tokens zabrání odpovědím, které sklouznou do esejů, a konzervativní top_p omezí vzorkovaný slovník na nejpravděpodobnější pokračování.
# Pro RAG použij nízkou teplotu
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.1, # Faktické, nízká kreativita
max_tokens=1024, # Omezení délky odpovědi
top_p=0.95, # Konzervativní vzorkování jádra
)
Klíčové poznatky
- RAG prompt vstřikuje načtený kontext před otázku
- Pro faktické odpovědi použij nízkou teplotu (0,1–0,3)
- Požádej model o citování zdrojů pro sledovatelnost
- Třída RAGPipeline zapouzdřuje celý tok: retrieve, generate, ask
- Ošetři případy, kdy kontext postrádá dostatečné informace