1 
2Ang mga Large Language Model (LLMs) tulad ng GPT-4 at Claude ay extraordinaryong makapangyarihan, ngunit dumaranas sila ng isang pundamental na limitasyon: ang kanilang kaalaman ay nakapirming sa oras ng training. Ang **Retrieval-Augmented Generation (RAG)** ang solusyon.
3 
4## Ang Problema: Mga Limitasyon ng LLM
5 
61.  **Static na kaalaman**.
72.  **Hallucination**: gumagawa ng mga plausible ngunit maling impormasyon.
83.  **Walang access sa private data**.
9 
10## Ano ang 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## Paano Gumagana ang RAG
22 
23### Phase 1: Indexing
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### Phase 2: Retrieval + Generation
36 
37## Paggawa ng RAG Pipeline gamit ang LangChain
38 
39### Installation
40 
41```bash
42pip install langchain langchain-openai langchain-community chromadb
43```
44 
45### Hakbang 1: Mag-load ng mga Dokumento
46 
47```python
48from langchain_community.document_loaders import (
49    PyPDFLoader,
50    WebBaseLoader,
51    DirectoryLoader,
52    TextLoader,
53)
54 
55pdf_loader = PyPDFLoader("docs/manual.pdf")
56pdf_docs = pdf_loader.load()
57 
58web_loader = WebBaseLoader("https://docs.example.com/guide")
59web_docs = web_loader.load()
60 
61dir_loader = DirectoryLoader("./knowledge_base", glob="**/*.md", loader_cls=TextLoader)
62md_docs = dir_loader.load()
63 
64all_docs = pdf_docs + web_docs + md_docs
65```
66 
67### Hakbang 2: Hatiin ang mga Dokumento sa Chunks
68 
69```python
70from langchain.text_splitter import RecursiveCharacterTextSplitter
71 
72text_splitter = RecursiveCharacterTextSplitter(
73    chunk_size=1000,
74    chunk_overlap=200,
75    separators=["\n\n", "\n", ". ", " ", ""],
76)
77 
78chunks = text_splitter.split_documents(all_docs)
79print(f"Original documents: {len(all_docs)}, Chunks: {len(chunks)}")
80```
81 
82### Hakbang 3: Gumawa ng Embeddings at Vector Store
83 
84```python
85from langchain_openai import OpenAIEmbeddings
86from langchain_community.vectorstores import Chroma
87 
88embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
89 
90vectorstore = Chroma.from_documents(
91    documents=chunks,
92    embedding=embedding_model,
93    persist_directory="./chroma_db",
94)
95```
96 
97### Hakbang 4: Gumawa ng Retriever
98 
99```python
100retriever = vectorstore.as_retriever(
101    search_type="similarity",
102    search_kwargs={"k": 4},
103)
104 
105relevant_docs = retriever.invoke("How does authentication work?")
106for doc in relevant_docs:
107    print(doc.page_content[:200])
108    print("---")
109```
110 
111### Hakbang 5: Itayo ang RAG Chain
112 
113```python
114from langchain_openai import ChatOpenAI
115from langchain_core.prompts import ChatPromptTemplate
116from langchain_core.runnables import RunnablePassthrough
117from langchain_core.output_parsers import StrOutputParser
118 
119llm = ChatOpenAI(model="gpt-4o", temperature=0)
120 
121prompt = ChatPromptTemplate.from_template("""
122Answer the question based only on the provided context.
123If the context does not contain enough information, say you don't know.
124 
125Context:
126{context}
127 
128Question: {question}
129 
130Answer:
131""")
132 
133def format_docs(docs):
134    return "\n\n".join(doc.page_content for doc in docs)
135 
136rag_chain = (
137    {"context": retriever | format_docs, "question": RunnablePassthrough()}
138    | prompt
139    | llm
140    | StrOutputParser()
141)
142 
143response = rag_chain.invoke("How does authentication work in the system?")
144print(response)
145```
146 
147## Mga Advanced RAG Technique
148 
149### Multi-Query Retrieval, Contextual Compression, Hybrid Search, at Conversational RAG ay mga pangunahing advanced technique para mapabuti ang kalidad ng sagot.
150 
151## Pinakamahusay na Kasanayan
152 
1531.  **Piliin ang tamang chunk size**.
1542.  **Gumamit ng document metadata**.
1553.  **I-evaluate ang kalidad** gamit ang [RAGAS](https://docs.ragas.io/).
1564.  **Pamahalaan ang mga document update**.
1575.  **Magdagdag ng re-ranker**.
158 
159## Kongklusyon
160 
161Ang RAG ay naging standard architecture para sa paggawa ng mga AI application. Pinapadali ng LangChain ang implementation.
162 
163**Mga susunod na hakbang:**
164- **Mag-eksperimento nang lokal**: Magsimula sa ChromaDB.
165- **Tuklasin ang LangSmith**: [LangSmith](https://smith.langchain.com/).
166- **Subukan ang iba't ibang embedding model**.
167- **Tingnan ang documentation**: [LangChain docs](https://python.langchain.com/docs/).
168