1~
2Store sprogmodeller (LLMs) som GPT-4 og Claude er ekstraordinært kraftfulde, men lider af en fundamental begrænsning: deres viden er frosset på træningstidspunktet. **Retrieval-Augmented Generation (RAG)** løser præcis dette problem ved at kombinere den generative kraft i LLMs med evnen til at hente information fra eksterne kilder.
3~
4## Problemet: LLM-begrænsninger
5~
61.  **Statisk viden**: En LLM ved kun, hvad den så under træning.
72.  **Hallucinationer**: Når en LLM ikke kender svaret, har den tendens til at opfinde et.
83.  **Ingen adgang til private data**: En generisk LLM har ingen adgang til din virksomheds interne dokumentation.
9~
10## Hvad er RAG?
11~
12```mermaid
13graph LR
14    User["User"] -- "Question" --> Retriever
15    Retriever -- "Search relevant\ndocuments" --> VectorStore["Vector Store"]
16    VectorStore -- "Relevant\ndocuments" --> Retriever
17    Retriever -- "Context + Question" --> LLM
18    LLM -- "Grounded\nresponse" --> User
19```
20~
21## Sådan fungerer RAG i detaljer
22~
23### Fase 1: Indeksering (Dokumentindtagelse)
24~
25```mermaid
26graph TD
27    A["Documents\n(PDF, HTML, MD, DB)"] --> B["Document Loader"]
28    B --> C["Text Splitter"]
29    C --> D["Text Chunks"]
30    D --> E["Embedding Model"]
31    E --> F["Numerical Vectors"]
32    F --> G["Vector Store\n(ChromaDB, Pinecone, FAISS)"]
33```
34~
35#### 1. Dokumentindlæsning
36Dokumenter kan komme fra enhver kilde: PDF-filer, websider, databaser, Markdown-filer, APIer.
37~
38#### 2. Tekstopdeling (Chunking)
39**Text Splitter** opdeler dokumenter i mindre fragmenter kaldet *chunks*.
40~
41#### 3. Embedding
42Hver chunk transformeres til en **numerisk vektor** (embedding) via en embedding-model.
43~
44#### 4. Vector Store
45Vektorerne gemmes i en **Vector Store**, optimeret til **lighedssøgning**.
46~
47### Fase 2: Retrieval + Generation
48~
491.  Spørgsmålet transformeres til et embedding.
502.  Vector Store finder de mest lignende chunks.
513.  De hentede chunks indsættes i prompten som kontekst.
524.  LLM genererer et svar baseret på den givne kontekst.
53~
54## Opbygning af en RAG-pipeline med LangChain
55~
56### Installation
57~
58```bash
59pip install langchain langchain-openai langchain-community chromadb
60```
61~
62### Trin 1: Indlæs dokumenter
63~
64```python
65from langchain_community.document_loaders import (
66    PyPDFLoader,
67    WebBaseLoader,
68    DirectoryLoader,
69    TextLoader,
70)
71~
72# Load a PDF
73pdf_loader = PyPDFLoader("docs/manual.pdf")
74pdf_docs = pdf_loader.load()
75~
76# Load a web page
77web_loader = WebBaseLoader("https://docs.example.com/guide")
78web_docs = web_loader.load()
79~
80# Load all .md files from a directory
81dir_loader = DirectoryLoader("./knowledge_base", glob="**/*.md", loader_cls=TextLoader)
82md_docs = dir_loader.load()
83~
84all_docs = pdf_docs + web_docs + md_docs
85```
86~
87### Trin 2: Opdel dokumenter i chunks
88~
89```python
90from langchain.text_splitter import RecursiveCharacterTextSplitter
91~
92text_splitter = RecursiveCharacterTextSplitter(
93    chunk_size=1000,
94    chunk_overlap=200,
95    separators=["\n\n", "\n", ". ", " ", ""],
96)
97~
98chunks = text_splitter.split_documents(all_docs)
99print(f"Original documents: {len(all_docs)}, Chunks: {len(chunks)}")
100```
101~
102### Trin 3: Opret embeddings og Vector Store
103~
104```python
105from langchain_openai import OpenAIEmbeddings
106from langchain_community.vectorstores import Chroma
107~
108embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
109~
110vectorstore = Chroma.from_documents(
111    documents=chunks,
112    embedding=embedding_model,
113    persist_directory="./chroma_db",
114)
115```
116~
117### Trin 4: Opret Retriever
118~
119```python
120retriever = vectorstore.as_retriever(
121    search_type="similarity",
122    search_kwargs={"k": 4},
123)
124~
125relevant_docs = retriever.invoke("How does authentication work?")
126for doc in relevant_docs:
127    print(doc.page_content[:200])
128    print("---")
129```
130~
131### Trin 5: Byg RAG-kæden
132~
133```python
134from langchain_openai import ChatOpenAI
135from langchain_core.prompts import ChatPromptTemplate
136from langchain_core.runnables import RunnablePassthrough
137from langchain_core.output_parsers import StrOutputParser
138~
139llm = ChatOpenAI(model="gpt-4o", temperature=0)
140~
141prompt = ChatPromptTemplate.from_template("""
142Answer the question based only on the provided context.
143If the context does not contain enough information, say you don't know.
144~
145Context:
146{context}
147~
148Question: {question}
149~
150Answer:
151""")
152~
153def format_docs(docs):
154    return "\n\n".join(doc.page_content for doc in docs)
155~
156rag_chain = (
157    {"context": retriever | format_docs, "question": RunnablePassthrough()}
158    | prompt
159    | llm
160    | StrOutputParser()
161)
162~
163response = rag_chain.invoke("How does authentication work in the system?")
164print(response)
165```
166~
167## Avancerede RAG-teknikker
168~
169### Multi-Query Retrieval
170~
171```python
172from langchain.retrievers import MultiQueryRetriever
173~
174multi_retriever = MultiQueryRetriever.from_llm(
175    retriever=vectorstore.as_retriever(),
176    llm=llm,
177)
178~
179docs = multi_retriever.invoke("What are the security best practices?")
180```
181~
182### Kontekstuel komprimering
183~
184```python
185from langchain.retrievers import ContextualCompressionRetriever
186from langchain.retrievers.document_compressors import LLMChainExtractor
187~
188compressor = LLMChainExtractor.from_llm(llm)
189compression_retriever = ContextualCompressionRetriever(
190    base_compressor=compressor,
191    base_retriever=retriever,
192)
193```
194~
195### Hybrid søgning
196~
197```python
198from langchain.retrievers import EnsembleRetriever
199from langchain_community.retrievers import BM25Retriever
200~
201bm25_retriever = BM25Retriever.from_documents(chunks)
202bm25_retriever.k = 4
203~
204semantic_retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
205~
206hybrid_retriever = EnsembleRetriever(
207    retrievers=[bm25_retriever, semantic_retriever],
208    weights=[0.4, 0.6],
209)
210```
211~
212### Konversationel RAG (med hukommelse)
213~
214```python
215from langchain.chains import create_history_aware_retriever
216from langchain_core.prompts import MessagesPlaceholder
217~
218contextualize_prompt = ChatPromptTemplate.from_messages([
219    ("system", "Given the chat history and the user's latest question, "
220               "reformulate the question so it is understandable without the history."),
221    MessagesPlaceholder("chat_history"),
222    ("human", "{input}"),
223])
224~
225history_aware_retriever = create_history_aware_retriever(
226    llm, retriever, contextualize_prompt
227)
228```
229~
230## Bedste praksis
231~
2321.  **Vælg den rigtige chunk-størrelse**: Eksperimenter med forskellige størrelser (500-1500 tokens).
2332.  **Brug dokumentmetadata**: Tilføj kilde, dato og kategori som metadata.
2343.  **Evaluer kvalitet**: Brug frameworks som [RAGAS](https://docs.ragas.io/).
2354.  **Håndter dokumentopdateringer**: Implementer en re-ingestion pipeline.
2365.  **Tilføj en re-ranker**: Brug en re-ranking model efter initial retrieval.
237~
238## Konklusion
239~
240RAG er blevet standardarkitekturen for at bygge AI-applikationer, der har brug for adgang til specifik, opdateret viden. LangChain forenkler implementeringen enormt.
241~
242**Næste trin:**
243- **Eksperimenter lokalt**: Start med ChromaDB og et par dokumenter.
244- **Udforsk LangSmith**: Brug [LangSmith](https://smith.langchain.com/) til at overvåge og fejlsøge dine kæder.
245- **Prøv forskellige embedding-modeller**.
246- **Tjek dokumentationen**: [LangChain-dokumentationen](https://python.langchain.com/docs/) er en fremragende ressource.
247~