Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Arkitektur för komplett RAG

Lektion 11 av 22 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Mål
  2. Vad är RAG?
  3. Pipeline-steg
  4. Komplett implementering
  5. Användning
  6. Optimeringspunkter
  7. Viktiga punkter

Lektionen uppdaterad 3 november 2026 baserat på OpenAI:s dokumentation: temperature och top_p accepteras endast med ett resonemangsarbete (reasoning effort) på none, medan GPT-5.6-modeller resonerar som standard (medium). Anrop som ställer in dessa parametrar måste därför specificera reasoning={"effort": "none"} (API Responses) eller reasoning_effort="none" (Chat Completions). Källor: Using GPT-6 · GPT-5.6 Terra.

Mål

  • Förstå RAG-arkitekturen från början till slut
  • Implementera en fungerande RAG-pipeline
  • Identifiera komponenter att optimera

Vad är RAG?

RAG (Retrieval-Augmented Generation) kombinerar dokumentsökning med textgenerering av en LLM. Istället för att enbart förlita sig på sin interna kunskap, får modellen relevanta dokument som kontext och utformar sedan sitt svar baserat på denna kontext. Allt du har byggt sedan kursens början – inbäddningar, indexering, sökning och utvärdering – blir här den första halvan av ett komplett system.

Varför RAG?

Fyra skäl motiverar detta, och de förstärker varandra. För det första, proprietär data: din policy för distansarbete, interna procedurer och produktkatalog har aldrig funnits med i modellens träningsdata, och ingen prompt kan få dem att hamna där. För det andra, aktuell information: allt som är nyare än träningsdatumet är osynligt för modellen, medan ett index kan uppdateras samma dag. Verifierbarhet är lika viktigt, eftersom varje svar förankras i identifierbara källor som användaren kan öppna och kontrollera – vilket förändrar karaktären hos det förtroende som placeras i systemet. Slutligen spelar kostnad till dess fördel: att lägga till kunskap via RAG kostar betydligt mindre än finjustering, och korrigeringar sker genom att radera ett dokument snarare än att träna om en modell.

Pipeline-steg

Läs RAG som två distinkta faser som du inte får förväxla. Inmatning (Ingestion) sker offline, en gång för alla eller när korpuset uppdateras:

Dokument → Chunking → Inbäddningar → Vektorlagring

Förfrågan (Query) sker online, för varje ställd fråga, och måste vara snabb:

Fråga → Inbäddning → Sökning → Kontext + Fråga → LLM → Svar

Denna separation har en praktisk konsekvens: kostnader för inmatning betalas en gång och kan vara höga, medan kostnader för förfrågan betalas per anrop och styr användarupplevelsen. Du har därför råd med sofistikerad bearbetning vid inmatning, men du måste hålla det lean på förfrågningssidan.

Komplett implementering

Följande klass materialiserar de tre faserna i tre distinkta metoder, plus en fjärde som kedjar ihop dem. Denna separation är inte kosmetisk: den låter dig testa sökningen utan att förbruka genereringstokens, och återspela genereringen på en fast kontext för att jämföra två 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

    # --- Inmatningsfas ---

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

        # Generera inbäddningar i batchar
        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"Inmatning klar: {len(self.chunks)} chunkar indexerade")

    # --- Hämtningssfas ---

    def search(self, question: str, k: int = 5) -> list[dict]:
        """Hittar de k mest relevanta chunkarna."""
        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
        ]

    # --- Genereringsfas ---

    def generate(self, question: str, contexts: list[dict]) -> str:
        """Genererar ett svar baserat på hämtade kontexter."""
        # Bygg prompten
        formatted_context = "\n\n---\n\n".join(
            f"[Källa: {c.get('id', 'okänd')}]\n{c['text']}"
            for c in contexts
        )

        messages = [
            {
                "role": "system",
                "content": (
                    "Du är en assistent som besvarar frågor "
                    "enbart baserat på de tillhandahållna dokumenten. "
                    "Om informationen inte finns i dokumenten, "
                    "ange detta tydligt. Citera dina källor."
                )
            },
            {
                "role": "user",
                "content": (
                    f"Referensdokument:\n\n{formatted_context}\n\n"
                    f"---\n\nFråga: {question}"
                )
            }
        ]

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

        return response.choices[0].message.content

    # --- Komplett Pipeline ---

    def answer(self, question: str, k: int = 5) -> dict:
        """Komplett RAG-pipeline: sökning → generering."""
        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 större delen av kvaliteten. Systemmeddelandet kräver att svar ges enbart från de tillhandahållna dokumenten och att man medger när information saknas: utan denna instruktion kommer modellen att fylla luckor med sin allmänna kunskap, vilket ger ett trovärdigt men påhittat svar. Prefixet [Källa: id] före varje utdrag ger modellen något specifikt att citera, snarare än ett vagt “enligt dokumenten”. Slutligen reducerar en temperature på 0,2 variabiliteten: för faktiska frågor mot en dokumentbas vill du ha konsistens, inte kreativitet.

Användning

Låt oss testa pipelinen på ett minimalt affärsscenario – tre interna policyer och en fråga som inte kopierar någon av deras exakta formuleringar.

# Förbered dokument
documents = [
    {
        "id": "leave-policy",
        "text": "Anställda får 25 dagars betald semester "
                 "per år. Semester måste begäras minst 2 veckor "
                 "i förväg via HR-portalen.",
        "metadata": {"type": "hr", "date": "2026-01"}
    },
    {
        "id": "remote-work-policy",
        "text": "Distansarbete är tillåtet upp till 3 dagar per vecka. "
                 "Tisdagar och torsdagar är obligatoriska kontorsdagar. "
                 "Skriftlig överenskommelse med chefen krävs.",
        "metadata": {"type": "hr", "date": "2026-01"}
    },
    {
        "id": "reimbursement-procedure",
        "text": "Kostnadsrapporter måste lämnas in inom 30 dagar "
                 "från utgiften. Bifoga originalkvittot. "
                 "Validering av närmaste chef krävs för belopp över 200 euro.",
        "metadata": {"type": "finance", "date": "2026-01"}
    },
]

# Skapa pipelinen
rag = PipelineRAG()
rag.ingest(documents)

# Ställ en fråga
result = rag.answer("Hur många dagar distansarbete per vecka?")
print(result["response"])
print("\nAnvända källor:")
for s in result["sources"]:
    print(f"  [{s['score']:.3f}] {s['id']}: {s['excerpt']}")

Utmana övningen ytterligare genom att ställa en fråga som inget dokument besvarar, till exempel om företagets sjukförsäkringsplan. Pipelinen kommer fortfarande att returnera tre källor – sökningen returnerar alltid sina k bästa kandidater – och det är systemmeddelandet som måste hindra modellen från att hitta på ett svar. Att verifiera detta beteende före produktion är bättre än att upptäcka det genom ett klagomål.

Optimeringspunkter

Varje steg i pipelinen kan förbättras oberoende, vilket möjliggör framsteg genom små, mätbara justeringar.

StegMöjliga optimeringar
ChunkingChunk-storlek, överlappning, semantisk chunking
InbäddningModellval, dimensioner, textberikning
SökningHybrid, reranking, metadatafilter
PromptSysteminstruktioner, kontextformat, few-shot
GenereringModell, temperature, citeringar

Följande lektioner detaljerar var och en av dessa optimeringar. Ta dig an dem i denna ordning: chunking avgör vad som kan hämtas, och ingen reranking kommer att fixa ett dåligt chunkat dokument.

Viktiga punkter

  • RAG = Sökning + Kontext + LLM-generering
  • Pipelinen delas upp i inmatning (offline) och förfrågan (online)
  • Varje komponent (chunking, inbäddning, sökning, prompt, generering) kan optimeras oberoende
  • RAG är mer flexibelt och mindre kostsamt än finjustering för att lägga till kunskap