Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Načítání a generování

Lekce 13 z 18 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Od vektoru k odpovědi
  2. Sestavení RAG promptu
  3. Generování odpovědi
  4. Zapouzdření toku do třídy
  5. Tři varianty promptu podle použití
  6. Klíčové poznatky

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