1~
2Modelele de limbaj mari (LLM-uri) precum GPT-4 si Claude sunt extraordinar de puternice, dar sufera de o limitare fundamentala: cunostintele lor sunt inghetate la momentul antrenamentului. **Retrieval-Augmented Generation (RAG)** rezolva exact aceasta problema combinand puterea generativa a LLM-urilor cu capacitatea de a recupera informatii din surse externe.
3~
4## Problema: Limitarile LLM
5~
61.  **Cunostinte statice**: Un LLM stie doar ce a vazut in timpul antrenamentului.
72.  **Halucinatii**: Cand un LLM nu stie raspunsul, tinde sa fabrice unul.
83.  **Fara acces la date private**: Un LLM generic nu are acces la documentatia interna a companiei tale.
9~
10## Ce este RAG?
11~
12RAG este o arhitectura care imbogateste promptul trimis unui LLM cu informatii recuperate dintr-o baza de cunostinte externa.
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## Cum functioneaza RAG in detaliu
24~
25### Faza 1: Indexare (Ingestia documentelor)
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### Faza 2: Recuperare + Generare
38~
391.  Intrebarea este transformata intr-un embedding.
402.  Vector Store gaseste cele mai similare fragmente.
413.  Fragmentele recuperate sunt inserate in prompt ca context.
424.  LLM-ul genereaza un raspuns bazat pe context.
43~
44## Construirea unui pipeline RAG cu LangChain
45~
46```bash
47pip install langchain langchain-openai langchain-community chromadb
48```
49~
50### Pasul 1: Incarcarea documentelor
51~
52```python
53from langchain_community.document_loaders import (
54    PyPDFLoader,
55    WebBaseLoader,
56    DirectoryLoader,
57    TextLoader,
58)
59~
60pdf_loader = PyPDFLoader("docs/manual.pdf")
61pdf_docs = pdf_loader.load()
62~
63web_loader = WebBaseLoader("https://docs.example.com/guide")
64web_docs = web_loader.load()
65~
66dir_loader = DirectoryLoader("./knowledge_base", glob="**/*.md", loader_cls=TextLoader)
67md_docs = dir_loader.load()
68~
69all_docs = pdf_docs + web_docs + md_docs
70```
71~
72### Pasul 2: Impartirea documentelor in fragmente
73~
74```python
75from langchain.text_splitter import RecursiveCharacterTextSplitter
76~
77text_splitter = RecursiveCharacterTextSplitter(
78    chunk_size=1000,
79    chunk_overlap=200,
80    separators=["\n\n", "\n", ". ", " ", ""],
81)
82~
83chunks = text_splitter.split_documents(all_docs)
84```
85~
86### Pasul 3: Crearea Embedding-urilor si Vector Store
87~
88```python
89from langchain_openai import OpenAIEmbeddings
90from langchain_community.vectorstores import Chroma
91~
92embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
93~
94vectorstore = Chroma.from_documents(
95    documents=chunks,
96    embedding=embedding_model,
97    persist_directory="./chroma_db",
98)
99```
100~
101### Pasul 4: Crearea Retriever-ului
102~
103```python
104retriever = vectorstore.as_retriever(
105    search_type="similarity",
106    search_kwargs={"k": 4},
107)
108```
109~
110### Pasul 5: Construirea lantului RAG
111~
112```python
113from langchain_openai import ChatOpenAI
114from langchain_core.prompts import ChatPromptTemplate
115from langchain_core.runnables import RunnablePassthrough
116from langchain_core.output_parsers import StrOutputParser
117~
118llm = ChatOpenAI(model="gpt-4o", temperature=0)
119~
120prompt = ChatPromptTemplate.from_template("""
121Answer the question based only on the provided context.
122If the context does not contain enough information, say you don't know.
123~
124Context:
125{context}
126~
127Question: {question}
128~
129Answer:
130""")
131~
132def format_docs(docs):
133    return "\n\n".join(doc.page_content for doc in docs)
134~
135rag_chain = (
136    {"context": retriever | format_docs, "question": RunnablePassthrough()}
137    | prompt
138    | llm
139    | StrOutputParser()
140)
141~
142response = rag_chain.invoke("How does authentication work in the system?")
143print(response)
144```
145~
146## Tehnici RAG avansate
147~
148### Recuperare Multi-Query
149~
150```python
151from langchain.retrievers import MultiQueryRetriever
152~
153multi_retriever = MultiQueryRetriever.from_llm(
154    retriever=vectorstore.as_retriever(),
155    llm=llm,
156)
157```
158~
159### Compresie contextuala
160~
161```python
162from langchain.retrievers import ContextualCompressionRetriever
163from langchain.retrievers.document_compressors import LLMChainExtractor
164~
165compressor = LLMChainExtractor.from_llm(llm)
166compression_retriever = ContextualCompressionRetriever(
167    base_compressor=compressor,
168    base_retriever=retriever,
169)
170```
171~
172### Cautare hibrida
173~
174```python
175from langchain.retrievers import EnsembleRetriever
176from langchain_community.retrievers import BM25Retriever
177~
178bm25_retriever = BM25Retriever.from_documents(chunks)
179bm25_retriever.k = 4
180~
181semantic_retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
182~
183hybrid_retriever = EnsembleRetriever(
184    retrievers=[bm25_retriever, semantic_retriever],
185    weights=[0.4, 0.6],
186)
187```
188~
189## Bune practici
190~
1911.  **Alege dimensiunea corecta a fragmentului**: Experimenteaza cu dimensiuni diferite (500-1500 tokeni).
1922.  **Foloseste metadate ale documentelor**: Adauga sursa, data si categoria ca metadate.
1933.  **Evalueaza calitatea**: Foloseste framework-uri precum [RAGAS](https://docs.ragas.io/).
1944.  **Gestioneaza actualizarile documentelor**: Implementeaza un pipeline de re-ingestie.
1955.  **Adauga un re-ranker**: Dupa recuperarea initiala, foloseste un model de re-clasificare.
196~
197## Concluzie
198~
199RAG a devenit arhitectura standard pentru construirea aplicatiilor AI care au nevoie de acces la cunostinte specifice si actualizate. LangChain simplifica semnificativ implementarea.
200~
201**Pasii urmatori:**
202- **Experimenteaza local**: Incepe cu ChromaDB si cateva documente.
203- **Exploreaza LangSmith**: Foloseste [LangSmith](https://smith.langchain.com/) pentru monitorizare.
204- **Incearca modele de embedding diferite**: Compara modele precum `text-embedding-3-small`, `text-embedding-3-large`.
205- **Consulta documentatia**: [Documentatia LangChain](https://python.langchain.com/docs/) este excelenta.
206~