Komplet RAG-arkitektur
På denne side
Lektionen opdateret 3. november 2026 baseret på OpenAI-dokumentation:
temperatureogtop_paccepteres kun med en ræsonneringsindsats pånone, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Kald, der sætter disse parametre, skal derfor specificerereasoning={"effort": "none"}(API Responses) ellerreasoning_effort="none"(Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.
Mål
- Forstå RAG-arkitekturen fra ende til anden
- Implementere en funktionel RAG-pipeline
- Identificere komponenter, der kan optimeres
Hvad er RAG?
RAG (Retrieval-Augmented Generation) kombinerer dokumentsøgning med tekstgenerering via en LLM. I stedet for udelukkende at stole på sin interne viden modtager modellen relevante dokumenter som kontekst og udarbejder derefter sit svar baseret på denne kontekst. Alt det, du har bygget siden starten af dette kursus – embeddings, indeksering, søgning, evaluering – bliver her den upstream-del af et komplet system.
Hvorfor RAG?
Fire grunde taler for det, og de forstærker hinanden. For det første propriære data: din politik for fjernarbejde, interne procedurer og produktkatalog har aldrig indgået i modellens træningsdata, og ingen prompt vil få dem til at gøre det. For det andet nyeste information: alt, der er nyere end træningsdatoen, er usynligt for modellen, hvorimod et indeks kan opdateres samme dag. Verificerbarhed er lige så vigtig, fordi hvert svar er forankret i identificerbare kilder, som brugeren kan åbne og tjekke – hvilket transformerer arten af den tillid, der placeres i systemet. Endelig spiller omkostninger til fordel for løsningen: det koster langt mindre at tilføje viden via RAG end ved finjustering, og rettelser sker ved at slette et dokument frem for at genoptræne en model.
Pipeline-trin
Læs RAG som to distinkte faser, som du ikke må forveksle. Ingestion sker offline, én gang for alle eller når corpus opdateres:
Documents → Chunking → Embeddings → Vector Storage
Forespørgslen sker online for hvert stillet spørgsmål og skal forblive hurtig:
Question → Embedding → Search → Context + Question → LLM → Response
Denne adskillelse har en praktisk konsekvens: omkostninger ved ingestion betales én gang og kan være tunge, mens omkostninger ved forespørgsler betales pr. kald og dikterer brugeroplevelsen. Du har derfor råd til sofistikeret ingestion-behandling, men skal holde det slankt på forespørgselssiden.
Komplet implementering
Den følgende klasse materialiserer de tre faser i tre distinkte metoder plus en fjerde, der kæder dem sammen. Denne adskillelse er ikke kosmetisk: den lader dig teste søgning uden at bruge genereringstokens og genafspille generering på en fast kontekst for at sammenligne to prompts.
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
]
}
Tre detaljer i genereringsfasen driver det meste af kvaliteten. Systembeskeden kræver, at du svarer udelukkende ud fra de medfølgende dokumenter og indrømmer, når information mangler: uden denne instruktion vil modellen fylde huller med sin generelle viden, hvilket giver et plausibelt, men opfundet svar. Præfikset [Source: id] før hvert uddrag giver modellen noget konkret at citere i stedet for en vag „ifølge dokumenterne”. Endelig reducerer en temperature på 0,2 variabiliteten: til faktuelle spørgsmål mod et dokumentgrundlag ønsker du konsistens, ikke kreativitet.
Anvendelse
Lad os teste pipelinen på et minimalt forretningstilfælde – tre interne politikker og et spørgsmål, der ikke kopierer nogen af deres præcise ordlyd.
# 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']}")
Pres øvelsen yderligere ved at stille et spørgsmål, som intet dokument besvarer, f.eks. et om virksomhedens sundhedsordning. Pipelinen vil stadig returnere tre kilder – søgning returnerer altid sine k bedste kandidater – og det er systembeskeden, der skal forhindre modellen i at opfinde et svar. Det er bedre at verificere denne adfærd før produktion end at opdage den gennem en klage.
Optimeringspunkter
Hvert trin i pipelinen kan forbedres uafhængigt, hvilket muliggør fremskridt gennem små, målbare justeringer.
| Trin | Mulige optimeringer |
|---|---|
| Chunking | Chunk-størrelse, overlap, semantisk chunking |
| Embedding | Modelvalg, dimensioner, tekstberigelse |
| Search | Hybrid, reranking, metadatafiltre |
| Prompt | Systeminstruktioner, kontekstformat, few-shot |
| Generation | Model, temperature, citater |
De følgende lektioner uddyber hver af disse optimeringer. Grib dem an i denne rækkefølge: chunking bestemmer, hvad der kan hentes, og ingen reranking vil fixe et dårligt chunket dokument.
Vigtige pointer
- RAG = Søgning + Kontekst + LLM-generering
- Pipelinen splittes i ingestion (offline) og forespørgsel (online)
- Hver komponent (chunking, embedding, søgning, prompt, generering) kan optimeres uafhængigt
- RAG er mere fleksibelt og mindre omkostningstungt end finjustering til at tilføje viden