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~