Arkitektur för komplett RAG
På denna sida
Lektionen uppdaterad 3 november 2026 baserat på OpenAI:s dokumentation:
temperatureochtop_paccepteras 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 specificerareasoning={"effort": "none"}(API Responses) ellerreasoning_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.
| Steg | Möjliga optimeringar |
|---|---|
| Chunking | Chunk-storlek, överlappning, semantisk chunking |
| Inbäddning | Modellval, dimensioner, textberikning |
| Sökning | Hybrid, reranking, metadatafilter |
| Prompt | Systeminstruktioner, kontextformat, few-shot |
| Generering | Modell, 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