Przejdź do głównej treści
Polski— Wybierz język
Menu

Pobieranie i generowanie

Lekcja 13 z 18 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Od wektora do odpowiedzi
  2. Budowanie promptu RAG
  3. Generowanie odpowiedzi
  4. Hermetyzacja przepływu w klasie
  5. Trzy warianty promptu w zależności od przypadku użycia
  6. Kluczowe wnioski

Od wektora do odpowiedzi

Wiesz już, jak indeksować dokumenty i pobierać te najbardziej zbliżone do zadanego pytania. Pozostał ostatni krok: zamiana listy fragmentów tekstu w czytelną odpowiedź. Oznacza to wstrzyknięcie pobranego kontekstu do promptu, aby model językowy (LLM) sformułował odpowiedź na podstawie Twoich danych, a nie swojej wiedzy treningowej. Wymaga to zaledwie kilku linii kodu, ale decyduje o jakości wyniku. Dobrze przedstawiony kontekst i jasna instrukcja są równie ważne jak precyzja samego pobierania.

Budowanie promptu RAG

Struktura promptu jest prosta, ale każdy wybór ma swoje konsekwencje. Ponumeruj fragmenty i opatrz je adnotacją źródłową, aby model mógł precyzyjnie cytować. Oddziel je widocznym separatorem, ---, aby model nie połączył dwóch sprzecznych dokumentów w jedno twierdzenie. Najważniejsze jednak, by instrukcja wyraźnie ograniczała odpowiedź do dostarczonego kontekstu i pozwalała modelowi przyznać, że nie zna odpowiedzi. Bez takiego upoważnienia LLM zapytany o brakujące informacje wypełni lukę tym, co wydaje się prawdopodobne. To właśnie mechanizm halucynacji.

def build_rag_prompt(question, retrieved_chunks):
    """Buduje prompt RAG z pobranym kontekstem."""
    # Formatowanie kontekstu
    context_parts = []
    for i, chunk in enumerate(retrieved_chunks):
        source = chunk.get("source", "nieznane źródło")
        context_parts.append(f"[Dokument {i+1} - {source}]\n{chunk['text']}")

    context = "\n\n---\n\n".join(context_parts)

    prompt = f"""Jesteś ekspertem-asystentem. Odpowiedz na pytanie, używając
WYŁĄCZNIE poniższego kontekstu. Jeśli informacji nie ma w kontekście,
powiedz o tym wyraźnie.

## Kontekst

{context}

## Pytanie

{question}

## Odpowiedź"""

    return prompt

Generowanie odpowiedzi

Wywołanie generujące jest proste: wiadomość systemowa przypominająca o roli oraz wiadomość użytkownika zawierająca złożony prompt. Zwróć uwagę na parametr temperatury, ustawiony tutaj na 0.1. W pisaniu kreatywnym zależy Ci na różnorodności; w RAG chcesz dokładnie odwrotnie. Zależy Ci, aby model trzymał się jak najbliżej tego, co mówi kontekst, i aby dwa uruchomienia dla tego samego pytania dały tę samą odpowiedź. Wysoka temperatura skłoniłaby model do parafrazowania, ekstrapolowania i oddalania się od źródła.

from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def generate_answer(question, retrieved_chunks, model="mistral-large-latest"):
    """Generuje odpowiedź RAG przy użyciu Mistral."""
    prompt = build_rag_prompt(question, retrieved_chunks)

    response = client.chat.complete(
        model=model,
        messages=[
            {
                "role": "system",
                "content": "Jesteś precyzyjnym asystentem, który odpowiada na podstawie dostarczonego kontekstu."
            },
            {
                "role": "user",
                "content": prompt,
            }
        ],
        temperature=0.1,  # Niska temperatura dla odpowiedzi faktograficznych
    )

    return response.choices[0].message.content

# Przykład
question = "Jakie są główne kroki procesu RAG?"
results = search_index(question, index, chunks, k=3)
answer = generate_answer(question, results)
print(answer)

Hermetyzacja przepływu w klasie

Rozproszone funkcje sprawdzają się podczas eksploracji, ale nie przy wdrażaniu rozwiązania. Klasa RAGPipeline grupuje stan – fragmenty tekstu, macierz osadzeń i indeks FAISS zbudowany raz podczas inicjalizacji – oraz trzy operacje: retrieve koduje pytanie i odpytuje indeks, generate składa prompt i wywołuje model, a ask łączy te dwie czynności. Zwróć uwagę, co zwraca metoda ask: nie ciąg znaków, lecz słownik zawierający odpowiedź, listę źródeł i liczbę użytych fragmentów. Ta możliwość śledzenia pochodzenia danych odróżnia asystenta poddającego się audytowi od czarnej skrzynki. Gdy użytkownik zakwestionuje odpowiedź, będziesz wiedział, na jakich fragmentach się opierała.

import numpy as np
import faiss
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

class RAGPipeline:
    """Kompletny potok RAG z wykorzystaniem Mistral i FAISS."""

    def __init__(self, chunks, embeddings):
        self.chunks = chunks
        self.embeddings = embeddings.astype(np.float32)

        # Tworzenie indeksu FAISS
        dimension = embeddings.shape[1]
        self.index = faiss.IndexFlatL2(dimension)
        self.index.add(self.embeddings)

    def retrieve(self, question, k=3):
        """Krok 1: pobranie odpowiednich fragmentów."""
        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: generowanie odpowiedzi z kontekstem."""
        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):
        """Pełny potok: pytanie -> odpowiedź ze źródłami."""
        # Pobieranie
        context = self.retrieve(question, k=k)

        # Generowanie
        answer = self.generate(question, context)

        return {
            "question": question,
            "answer": answer,
            "sources": [c["source"] for c in context],
            "n_chunks_used": len(context),
        }

# Użycie
rag = RAGPipeline(chunks, embeddings)
result = rag.ask("Jak działa indeksowanie w FAISS?")

print(f"Pytanie: {result['question']}")
print(f"Odpowiedź: {result['answer']}")
print(f"Źródła: {result['sources']}")

Trzy warianty promptu w zależności od przypadku użycia

Możesz specjalizować bazowy prompt w zależności od oczekiwań wobec asystenta. Jeśli użytkownicy muszą weryfikować każde twierdzenie, wyraźnie poproś o cytowania w nawiasach. Model dołączy wtedy każde zdanie do ponumerowanego dokumentu. Jeśli odpowiedź zasila interfejs lub raport, ustrukturyzowany format wymusi stabilne sekcje: zwięzła odpowiedź, szczegóły, źródła i poziom pewności odzwierciedlający stopień pokrycia pytania przez kontekst. Trzeci wariant pełni inną rolę: uczy model rozbijania niepewności poprzez rozróżnienie tego, co może stwierdzić z pewnością, tego, czego brakuje, oraz wskazówek, gdzie szukać dalej. Często daje to w praktyce najbardziej użytecznych asystentów, ponieważ stwierdzenie „brakuje mi X“ jest lepsze niż pewna, lecz błędna odpowiedź.

# 1. Prompt z instrukcją cytowania
prompt_cite = """Odpowiedz, cytując dokumenty źródłowe w nawiasach.
Przykład: „RAG poprawia dokładność [Dokument 1]“.

Kontekst: {context}
Pytanie: {question}"""

# 2. Prompt ze sformatowaną strukturą
prompt_structured = """Odpowiedz w następującym formacie:

**Odpowiedź**: [twoja zwięzła odpowiedź]
**Szczegóły**: [szczegółowe wyjaśnienie]
**Źródła**: [lista użytych dokumentów]
**Poziom pewności**: [wysoki/średni/niski w zależności od pokrycia kontekstem]

Kontekst: {context}
Pytanie: {question}"""

# 3. Prompt z obsługą brakujących informacji
prompt_honest = """Jeśli kontekst nie zawiera wystarczających informacji,
aby odpowiedzieć w pełni, wyraźnie stwierdź:
- Co możesz potwierdzić z pewnością
- Czego brakuje w kontekście
- Sugestie, gdzie uzyskać brakujące informacje

Kontekst: {context}
Pytanie: {question}"""

Jeśli chodzi o parametry wywołania, trzy ustawienia rządzą zachowaniem RAG. Niska temperatura blokuje wyjście na faktach, max_tokens zapobiega odpowiedziom rozlewającym się w eseje, a konserwatywne top_p ogranicza próbkowane słownictwo do najbardziej prawdopodobnych kontynuacji.

# Dla RAG użyj niskiej temperatury
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1,   # Faktograficzne, niska kreatywność
    max_tokens=1024,    # Ograniczenie długości odpowiedzi
    top_p=0.95,         # Konserwatywne próbkowanie jądra
)

Kluczowe wnioski

  • Prompt RAG wstrzykuje pobrany kontekst przed pytaniem
  • Używaj niskiej temperatury (0.1–0.3) dla odpowiedzi faktograficznych
  • Poproś model o cytowanie źródeł dla zapewnienia możliwości śledzenia
  • Klasa RAGPipeline hermetyzuje cały przepływ: pobieranie, generowanie, zadawanie pytań
  • Obsługuj przypadki, w których kontekst nie zawiera wystarczających informacji