1 
2Large Language Models (LLM) som GPT-4 och Claude är extraordinärt kraftfulla, men de lider av en fundamental begränsning: deras kunskap är frusen vid träningstillfället. **Retrieval-Augmented Generation (RAG)** löser exakt detta problem genom att kombinera LLM:ers generativa kraft med förmågan att hämta information från externa källor.
3 
4## Problemet: LLM-begränsningar
5 
61.  **Statisk kunskap**: En LLM vet bara vad den såg under träning.
72.  **Hallucinationer**: När en LLM inte vet svaret tenderar den att fabricera ett.
83.  **Ingen åtkomst till privat data**: Ett generiskt LLM har ingen åtkomst till din interna dokumentation.
9 
10## Vad är RAG?
11 
12RAG är en arkitektur som berikar prompten med information hämtad från en extern kunskapsbas.
13 
14```mermaid
15graph LR
16    User["User"] -- "Question" --> Retriever
17    Retriever -- "Search relevant\ndocuments" --> VectorStore["Vector Store"]
18    VectorStore -- "Relevant\ndocuments" --> Retriever
19    Retriever -- "Context + Question" --> LLM
20    LLM -- "Grounded\nresponse" --> User
21```
22 
23## Hur RAG Fungerar
24 
25### Fas 1: Indexering
26 
27```mermaid
28graph TD
29    A["Documents\n(PDF, HTML, MD, DB)"] --> B["Document Loader"]
30    B --> C["Text Splitter"]
31    C --> D["Text Chunks"]
32    D --> E["Embedding Model"]
33    E --> F["Numerical Vectors"]
34    F --> G["Vector Store\n(ChromaDB, Pinecone, FAISS)"]
35```
36 
37### Fas 2: Retrieval + Generation
38 
391.  Frågan omvandlas till en embedding.
402.  Vector Store hittar de mest liknande chunkarna.
413.  De hämtade chunkarna infogas i prompten som kontext.
424.  LLM:en genererar ett svar baserat på kontexten.
43 
44## Bygga en RAG Pipeline med LangChain
45 
46```bash
47pip install langchain langchain-openai langchain-community chromadb
48```
49 
50### Steg 1-5: Ladda, Splitta, Skapa Embeddings, Hämta, Generera
51 
52```python
53from langchain_community.document_loaders import PyPDFLoader, WebBaseLoader, DirectoryLoader, TextLoader
54 
55pdf_loader = PyPDFLoader("docs/manual.pdf")
56pdf_docs = pdf_loader.load()
57web_loader = WebBaseLoader("https://docs.example.com/guide")
58web_docs = web_loader.load()
59dir_loader = DirectoryLoader("./knowledge_base", glob="**/*.md", loader_cls=TextLoader)
60md_docs = dir_loader.load()
61all_docs = pdf_docs + web_docs + md_docs
62```
63 
64```python
65from langchain.text_splitter import RecursiveCharacterTextSplitter
66 
67text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200, separators=["\n\n", "\n", ". ", " ", ""])
68chunks = text_splitter.split_documents(all_docs)
69```
70 
71```python
72from langchain_openai import OpenAIEmbeddings
73from langchain_community.vectorstores import Chroma
74 
75embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
76vectorstore = Chroma.from_documents(documents=chunks, embedding=embedding_model, persist_directory="./chroma_db")
77retriever = vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 4})
78```
79 
80```python
81from langchain_openai import ChatOpenAI
82from langchain_core.prompts import ChatPromptTemplate
83from langchain_core.runnables import RunnablePassthrough
84from langchain_core.output_parsers import StrOutputParser
85 
86llm = ChatOpenAI(model="gpt-4o", temperature=0)
87prompt = ChatPromptTemplate.from_template("""
88Answer the question based only on the provided context.
89If the context does not contain enough information, say you don't know.
90 
91Context:
92{context}
93 
94Question: {question}
95 
96Answer:
97""")
98 
99def format_docs(docs):
100    return "\n\n".join(doc.page_content for doc in docs)
101 
102rag_chain = (
103    {"context": retriever | format_docs, "question": RunnablePassthrough()}
104    | prompt | llm | StrOutputParser()
105)
106 
107response = rag_chain.invoke("How does authentication work in the system?")
108```
109 
110## Avancerade RAG-tekniker
111 
112### Multi-Query, Contextual Compression, Hybrid Search, Conversational RAG
113 
114```python
115from langchain.retrievers import MultiQueryRetriever
116multi_retriever = MultiQueryRetriever.from_llm(retriever=vectorstore.as_retriever(), llm=llm)
117```
118 
119```python
120from langchain.retrievers import EnsembleRetriever
121from langchain_community.retrievers import BM25Retriever
122 
123bm25_retriever = BM25Retriever.from_documents(chunks)
124bm25_retriever.k = 4
125semantic_retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
126hybrid_retriever = EnsembleRetriever(retrievers=[bm25_retriever, semantic_retriever], weights=[0.4, 0.6])
127```
128 
129## Bästa Praxis
130 
1311.  **Välj rätt chunkstorlek**: Experimentera med 500-1500 tokens.
1322.  **Använd dokumentmetadata**: Lägg till källa, datum och kategori.
1333.  **Utvärdera kvalitet**: Använd ramverk som [RAGAS](https://docs.ragas.io/).
1344.  **Hantera dokumentuppdateringar**: Implementera en re-ingest pipeline.
1355.  **Lägg till en re-ranker**: Använd en re-ranking-modell.
136 
137## Slutsats
138 
139RAG har blivit standardarkitekturen för AI-applikationer som behöver åtkomst till specifik, aktuell kunskap. LangChain förenklar implementeringen avsevärt.
140