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

Kompletna architektura RAG

Lekcja 11 z 22 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Cele
  2. Czym jest RAG?
  3. Etapy potoku
  4. Kompletna implementacja
  5. Użycie
  6. Punkty optymalizacji
  7. Kluczowe wnioski

Lekcja zaktualizowana 3 listopada 2026 na podstawie dokumentacji OpenAI: parametry temperature i top_p są akceptowane wyłącznie przy wysiłku rozumowania (reasoning effort) ustawionym na none, podczas gdy modele GPT-5.6 domyślnie rozumują z wysiłkiem medium. Wywołania ustawiające te parametry muszą zatem określać reasoning={"effort": "none"} (API Responses) lub reasoning_effort="none" (Chat Completions). Źródła: Using GPT-6 · GPT-5.6 Terra.

Cele

  • Zrozumienie architektury RAG od początku do końca
  • Wdrożenie funkcjonalnego potoku RAG
  • Identyfikacja komponentów podlegających optymalizacji

Czym jest RAG?

RAG (Retrieval-Augmented Generation) łączy wyszukiwanie dokumentów z generowaniem tekstu przez LLM. Zamiast polegać wyłącznie na swojej wewnętrznej wiedzy, model otrzymuje odpowiednie dokumenty jako kontekst, a następnie na ich podstawie formułuje odpowiedź. Wszystko, co zbudowałeś od początku tego kursu – embeddingi, indeksowanie, wyszukiwanie, ewaluacja – staje się tutaj górną połową kompletnego systemu.

Dlaczego RAG?

Cztery powody to uzasadniają i wzajemnie się wzmacniają. Po pierwsze, dane zastrzeżone: Twoja polityka pracy zdalnej, procedury wewnętrzne i katalog produktów nigdy nie pojawiły się w danych treningowych modelu i żaden prompt tego nie zmieni. Po drugie, najnowsze informacje: wszystko, co powstało po zakończeniu treningu, jest dla modelu niewidoczne, podczas gdy indeks można zaktualizować tego samego dnia. Weryfikowalność ma równie duże znaczenie, ponieważ każda odpowiedź jest zakotwiczona w identyfikowalnych źródłach, które użytkownik może otworzyć i sprawdzić – co zmienia naturę zaufania pokładanego w systemie. Wreszcie, koszt przemawia na jego korzyść: dodawanie wiedzy poprzez RAG kosztuje znacznie mniej niż fine-tuning, a korekty wprowadza się poprzez usunięcie dokumentu, a nie ponowne trenowanie modelu.

Etapy potoku

Rozpatruj RAG w dwóch odrębnych fazach, których nie wolno mylić. Ingestowanie odbywa się offline, raz na zawsze lub za każdym razem, gdy korpus się aktualizuje:

Documents → Chunking → Embeddings → Vector Storage

Zapytanie odbywa się online, dla każdego zadawanego pytania i musi pozostać szybkie:

Question → Embedding → Search → Context + Question → LLM → Response

Ten podział ma praktyczne konsekwencje: koszty ingestowania ponosisz jednorazowo i mogą one być wysokie, podczas gdy koszty zapytań ponosisz przy każdym wywołaniu i determinują one doświadczenie użytkownika. Możesz więc pozwolić sobie na wyrafinowane przetwarzanie podczas ingestowania, ale po stronie zapytań musisz pozostać lekki.

Kompletna implementacja

Poniższa klasa materializuje trzy fazy w trzech odrębnych metodach, plus czwartą, która łączy je w całość. Ten podział nie jest kosmetyczny: pozwala przetestować wyszukiwanie bez zużywania tokenów generowania oraz odtworzyć generowanie na stałym kontekście, aby porównać dwa prompty.

from openai import OpenAI
import numpy as np

client = OpenAI()

class PipelineRAG:
    def __init__(
        self,
        model_embedding: str = "text-embedding-3-large",
        model_generation: str = "gpt-5.6-terra"
    ):
        self.client = OpenAI()
        self.model_embedding = model_embedding
        self.model_generation = model_generation
        self.chunks: list[dict] = []
        self.embeddings: np.ndarray | None = None

    # --- Ingestion Phase ---

    def ingest(self, documents: list[dict]):
        """Ingests documents {id, text, metadata}."""
        self.chunks = documents
        texts = [d["text"] for d in documents]

        # Generate embeddings in batches
        all_emb = []
        for i in range(0, len(texts), 100):
            batch = texts[i:i + 100]
            resp = self.client.embeddings.create(
                input=batch, model=self.model_embedding
            )
            batch_emb = sorted(resp.data, key=lambda x: x.index)
            all_emb.extend([e.embedding for e in batch_emb])

        self.embeddings = np.array(all_emb, dtype=np.float32)
        print(f"Ingestion complete: {len(self.chunks)} chunks indexed")

    # --- Retrieval Phase ---

    def search(self, question: str, k: int = 5) -> list[dict]:
        """Finds the k most relevant chunks."""
        query_emb = self.client.embeddings.create(
            input=question, model=self.model_embedding
        ).data[0].embedding

        scores = self.embeddings @ np.array(query_emb)
        top_k = np.argsort(scores)[-k:][::-1]

        return [
            {**self.chunks[i], "score": float(scores[i])}
            for i in top_k
        ]

    # --- Generation Phase ---

    def generate(self, question: str, contexts: list[dict]) -> str:
        """Generates a response based on retrieved contexts."""
        # Build the prompt
        formatted_context = "\n\n---\n\n".join(
            f"[Source: {c.get('id', 'unknown')}]\n{c['text']}"
            for c in contexts
        )

        messages = [
            {
                "role": "system",
                "content": (
                    "You are an assistant that answers questions "
                    "based solely on the provided documents. "
                    "If the information is not in the documents, "
                    "state this clearly. Cite your sources."
                )
            },
            {
                "role": "user",
                "content": (
                    f"Reference documents:\n\n{formatted_context}\n\n"
                    f"---\n\nQuestion: {question}"
                )
            }
        ]

        response = self.client.chat.completions.create(
            model=self.model_generation,
            reasoning_effort="none",  # temperature requires effort none
            messages=messages,
            temperature=0.2
        )

        return response.choices[0].message.content

    # --- Complete Pipeline ---

    def answer(self, question: str, k: int = 5) -> dict:
        """Complete RAG pipeline: search → generation."""
        contexts = self.search(question, k=k)
        response = self.generate(question, contexts)

        return {
            "question": question,
            "response": response,
            "sources": [
                {"id": c["id"], "score": c["score"],
                 "excerpt": c["text"][:150]}
                for c in contexts
            ]
        }

Trzy szczegóły w fazie generowania decydują o większości jakości. Wiadomość systemowa nakazuje odpowiadanie wyłącznie na podstawie dostarczonych dokumentów i przyznawanie się do braku informacji: bez tej instrukcji model uzupełni luki swoją ogólną wiedzą, tworząc prawdopodobną, ale zmyśloną odpowiedź. Prefiks [Source: id] przed każdym fragmentem daje modelowi coś konkretnego do cytowania, zamiast mglistego „zgodnie z dokumentami“. Na koniec, temperature ustawione na 0.2 redukuje zmienność: w przypadku pytań faktograficznych opartych na bazie dokumentów potrzebujesz spójności, a nie kreatywności.

Użycie

Przetestujmy potok na minimalnym przypadku biznesowym – trzech politykach wewnętrznych i pytaniu, które nie kopiuje żadnego z ich dokładnych sformułowań.

# Prepare documents
documents = [
    {
        "id": "leave-policy",
        "text": "Employees receive 25 days of paid leave "
                 "per year. Leave must be requested at least 2 weeks "
                 "in advance via the HR portal.",
        "metadata": {"type": "hr", "date": "2026-01"}
    },
    {
        "id": "remote-work-policy",
        "text": "Remote work is authorized up to 3 days per week. "
                 "Tuesdays and Thursdays are mandatory office days. "
                 "Written agreement with the manager is required.",
        "metadata": {"type": "hr", "date": "2026-01"}
    },
    {
        "id": "reimbursement-procedure",
        "text": "Expense reports must be submitted within 30 days "
                 "of the expense. Attach the original receipt. "
                 "Validation by the direct supervisor required for amounts over 200 euros.",
        "metadata": {"type": "finance", "date": "2026-01"}
    },
]

# Create the pipeline
rag = PipelineRAG()
rag.ingest(documents)

# Ask a question
result = rag.answer("How many days of remote work per week?")
print(result["response"])
print("\nSources used:")
for s in result["sources"]:
    print(f"  [{s['score']:.3f}] {s['id']}: {s['excerpt']}")

Posuń ćwiczenie dalej, zadając pytanie, na które żaden dokument nie odpowiada, np. dotyczące firmowego planu zdrowotnego. Potok nadal zwróci trzy źródła – wyszukiwanie zawsze zwraca swoje k najlepszych kandydatów – i to wiadomość systemowa musi powstrzymać model przed zmyśleniem odpowiedzi. Zweryfikowanie tego zachowania przed wdrożeniem produkcyjnym jest lepsze niż odkrycie go dzięki skardze użytkownika.

Punkty optymalizacji

Każdy krok potoku można ulepszyć niezależnie, co pozwala na postęp dzięki małym, mierzalnym poprawkom.

KrokMożliwe optymalizacje
ChunkingRozmiar chunka, nakładanie się, chunking semantyczny
EmbeddingWybór modelu, wymiary, wzbogacanie tekstu
SearchHybrydowe, reranking, filtry metadanych
PromptInstrukcje systemowe, format kontekstu, few-shot
GenerationModel, temperatura, cytowania

Kolejne lekcje szczegółowo opisują każdą z tych optymalizacji. Rozwiązuj je w tej kolejności: chunking determinuje to, co można odzyskać, a żaden reranking nie naprawi źle podzielonego na chunki dokumentu.

Kluczowe wnioski

  • RAG = Wyszukiwanie + Kontekst + Generowanie LLM
  • Potok dzieli się na ingestowanie (offline) i zapytanie (online)
  • Każdy komponent (chunking, embedding, wyszukiwanie, prompt, generowanie) można optymalizować niezależnie
  • RAG jest bardziej elastyczny i mniej kosztowny niż fine-tuning przy dodawaniu wiedzy