Kompletna architektura RAG
Na tej stronie
Lekcja zaktualizowana 3 listopada 2026 na podstawie dokumentacji OpenAI: parametry
temperatureitop_psą akceptowane wyłącznie przy wysiłku rozumowania (reasoning effort) ustawionym nanone, podczas gdy modele GPT-5.6 domyślnie rozumują z wysiłkiemmedium. Wywołania ustawiające te parametry muszą zatem określaćreasoning={"effort": "none"}(API Responses) lubreasoning_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.
| Krok | Możliwe optymalizacje |
|---|---|
| Chunking | Rozmiar chunka, nakładanie się, chunking semantyczny |
| Embedding | Wybór modelu, wymiary, wzbogacanie tekstu |
| Search | Hybrydowe, reranking, filtry metadanych |
| Prompt | Instrukcje systemowe, format kontekstu, few-shot |
| Generation | Model, 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