Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Komplet RAG-arkitektur

Lektion 11 af 22 Opdateret 3. november 2026 Udvikler
På denne side
  1. Mål
  2. Hvad er RAG?
  3. Pipeline-trin
  4. Komplet implementering
  5. Anvendelse
  6. Optimeringspunkter
  7. Vigtige pointer

Lektionen opdateret 3. november 2026 baseret på OpenAI-dokumentation: temperature og top_p accepteres 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 specificere reasoning={"effort": "none"} (API Responses) eller reasoning_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.

TrinMulige optimeringer
ChunkingChunk-størrelse, overlap, semantisk chunking
EmbeddingModelvalg, dimensioner, tekstberigelse
SearchHybrid, reranking, metadatafiltre
PromptSysteminstruktioner, kontekstformat, few-shot
GenerationModel, 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