1~
2Model Bahasa Besar (LLM) seperti GPT-4 dan Claude sangat kuat, tetapi mereka memiliki keterbatasan mendasar: pengetahuan mereka terhenti pada saat pelatihan. Mereka tidak dapat mengakses dokumen internal Anda, database Anda, atau informasi real-time. **Retrieval-Augmented Generation (RAG)** memecahkan masalah ini dengan menggabungkan kekuatan generatif LLM dengan kemampuan untuk mengambil informasi dari sumber eksternal.
3~
4## Masalah: Keterbatasan LLM
5~
6Sebelum membahas RAG, penting untuk memahami mengapa kita membutuhkannya.
7~
81.  **Pengetahuan statis**: LLM hanya mengetahui apa yang dilihatnya selama pelatihan. Jika Anda bertanya tentang peristiwa yang terjadi setelah batas waktu pelatihannya, ia tidak dapat menjawab.
92.  **Halusinasi**: Ketika LLM tidak mengetahui jawabannya, ia cenderung mengarangnya, menghasilkan informasi yang masuk akal tetapi sepenuhnya salah.
103.  **Tidak ada akses ke data privat**: LLM generik tidak memiliki akses ke dokumentasi internal perusahaan Anda, tiket, atau basis kode.
11~
12RAG mengatasi ketiga masalah ini dengan menyediakan **konteks yang relevan** yang diambil dari sumber eksternal pada saat kueri.
13~
14## Apa itu RAG?
15~
16Retrieval-Augmented Generation adalah arsitektur yang memperkaya prompt yang dikirim ke LLM dengan informasi yang diambil dari basis pengetahuan eksternal. Alih-alih hanya mengandalkan pengetahuan parametrik model, RAG terlebih dahulu **mencari** informasi yang relevan kemudian **menyuntikkannya** ke dalam prompt, memungkinkan model menghasilkan respons yang akurat dan berdasar.
17~
18```mermaid
19graph LR
20    User["User"] -- "Question" --> Retriever
21    Retriever -- "Search relevant\ndocuments" --> VectorStore["Vector Store"]
22    VectorStore -- "Relevant\ndocuments" --> Retriever
23    Retriever -- "Context + Question" --> LLM
24    LLM -- "Grounded\nresponse" --> User
25```
26~
27## Cara Kerja RAG secara Detail
28~
29Arsitektur RAG terdiri dari dua fase utama: **Pengindeksan** (offline) dan **Pengambilan + Pembuatan** (online).
30~
31### Fase 1: Pengindeksan (Ingesti Dokumen)
32~
33Fase pengindeksan mempersiapkan dokumen Anda untuk pencarian semantik. Terdiri dari empat langkah.
34~
35```mermaid
36graph TD
37    A["Documents\n(PDF, HTML, MD, DB)"] --> B["Document Loader"]
38    B --> C["Text Splitter"]
39    C --> D["Text Chunks"]
40    D --> E["Embedding Model"]
41    E --> F["Numerical Vectors"]
42    F --> G["Vector Store\n(ChromaDB, Pinecone, FAISS)"]
43```
44~
45#### 1. Pemuatan Dokumen
46~
47Dokumen dapat berasal dari sumber mana pun: file PDF, halaman web, database, file Markdown, API. **Document Loader** membaca dokumen-dokumen ini dan mengubahnya menjadi teks terstruktur.
48~
49#### 2. Pemisahan Teks (Chunking)
50~
51LLM memiliki jendela konteks yang terbatas, dan dokumen bisa sangat panjang. **Text Splitter** membagi dokumen menjadi fragmen-fragmen kecil yang disebut *chunks*. Kualitas chunking sangat penting: chunks yang terlalu kecil kehilangan konteks, sementara chunks yang terlalu besar mengencerkan relevansi.
52~
53Strategi yang paling umum adalah:
54-   **Recursive Character Splitting**: Memisahkan teks secara rekursif menggunakan pemisah seperti `\n\n`, `\n`, `. `, dengan menghormati struktur dokumen.
55-   **Semantic Splitting**: Menggunakan embeddings untuk menemukan titik pemisahan alami dalam teks.
56-   **Chunk Overlap**: Menyertakan tumpang tindih antara chunks berurutan untuk menjaga konteks di batas.
57~
58#### 3. Embedding
59~
60Setiap chunk diubah menjadi **vektor numerik** (embedding) melalui model embedding (seperti `text-embedding-3-small` dari OpenAI). Vektor-vektor ini menangkap makna semantik teks: kalimat dengan makna serupa akan memiliki vektor yang berdekatan dalam ruang multidimensi.
61~
62#### 4. Vector Store
63~
64Vektor-vektor disimpan dalam **Vector Store** (atau database vektor), seperti ChromaDB, Pinecone, Weaviate, atau FAISS. Database ini dioptimalkan untuk **pencarian kesamaan**: diberikan sebuah kueri, ia menemukan vektor-vektor yang paling mirip (dan karenanya chunks teks yang paling relevan).
65~
66### Fase 2: Pengambilan + Pembuatan
67~
68Ketika pengguna mengajukan pertanyaan:
69~
701.  Pertanyaan diubah menjadi embedding menggunakan model embedding yang sama.
712.  Vector Store menemukan chunks yang paling mirip melalui **pencarian kesamaan** (biasanya cosine similarity atau jarak Euclidean).
723.  Chunks yang diambil disisipkan ke dalam prompt sebagai konteks.
734.  LLM menghasilkan respons berdasarkan konteks yang diberikan.
74~
75## Membangun Pipeline RAG dengan LangChain
76~
77**LangChain** adalah framework Python (dan JavaScript) paling populer untuk membangun aplikasi berbasis LLM. Framework ini menyediakan abstraksi tingkat tinggi untuk setiap komponen pipeline RAG.
78~
79### Instalasi
80~
81```bash
82pip install langchain langchain-openai langchain-community chromadb
83```
84~
85### Langkah 1: Muat Dokumen
86~
87LangChain menyediakan puluhan Document Loader untuk berbagai sumber data.
88~
89```python
90from langchain_community.document_loaders import (
91    PyPDFLoader,
92    WebBaseLoader,
93    DirectoryLoader,
94    TextLoader,
95)
96~
97# Load a PDF
98pdf_loader = PyPDFLoader("docs/manual.pdf")
99pdf_docs = pdf_loader.load()
100~
101# Load a web page
102web_loader = WebBaseLoader("https://docs.example.com/guide")
103web_docs = web_loader.load()
104~
105# Load all .md files from a directory
106dir_loader = DirectoryLoader("./knowledge_base", glob="**/*.md", loader_cls=TextLoader)
107md_docs = dir_loader.load()
108~
109all_docs = pdf_docs + web_docs + md_docs
110```
111~
112### Langkah 2: Pisahkan Dokumen menjadi Chunks
113~
114```python
115from langchain.text_splitter import RecursiveCharacterTextSplitter
116~
117text_splitter = RecursiveCharacterTextSplitter(
118    chunk_size=1000,
119    chunk_overlap=200,
120    separators=["\n\n", "\n", ". ", " ", ""],
121)
122~
123chunks = text_splitter.split_documents(all_docs)
124print(f"Original documents: {len(all_docs)}, Chunks: {len(chunks)}")
125```
126~
127Parameter `chunk_overlap` sangat penting: ia menciptakan tumpang tindih antara chunks berurutan sehingga konteks tidak hilang di batas.
128~
129### Langkah 3: Buat Embeddings dan Vector Store
130~
131```python
132from langchain_openai import OpenAIEmbeddings
133from langchain_community.vectorstores import Chroma
134~
135embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
136~
137vectorstore = Chroma.from_documents(
138    documents=chunks,
139    embedding=embedding_model,
140    persist_directory="./chroma_db",
141)
142```
143~
144### Langkah 4: Buat Retriever
145~
146Retriever adalah komponen yang, diberikan sebuah kueri, mengambil chunks yang paling relevan dari vector store.
147~
148```python
149retriever = vectorstore.as_retriever(
150    search_type="similarity",
151    search_kwargs={"k": 4},
152)
153~
154relevant_docs = retriever.invoke("How does authentication work?")
155for doc in relevant_docs:
156    print(doc.page_content[:200])
157    print("---")
158```
159~
160### Langkah 5: Bangun RAG Chain
161~
162Sekarang mari kita satukan semuanya dengan LLM dan template prompt.
163~
164```python
165from langchain_openai import ChatOpenAI
166from langchain_core.prompts import ChatPromptTemplate
167from langchain_core.runnables import RunnablePassthrough
168from langchain_core.output_parsers import StrOutputParser
169~
170llm = ChatOpenAI(model="gpt-4o", temperature=0)
171~
172prompt = ChatPromptTemplate.from_template("""
173Answer the question based only on the provided context.
174If the context does not contain enough information, say you don't know.
175~
176Context:
177{context}
178~
179Question: {question}
180~
181Answer:
182""")
183~
184def format_docs(docs):
185    return "\n\n".join(doc.page_content for doc in docs)
186~
187rag_chain = (
188    {"context": retriever | format_docs, "question": RunnablePassthrough()}
189    | prompt
190    | llm
191    | StrOutputParser()
192)
193~
194response = rag_chain.invoke("How does authentication work in the system?")
195print(response)
196```
197~
198## Teknik RAG Lanjutan
199~
200Pipeline dasar bekerja dengan baik, tetapi ada beberapa teknik untuk meningkatkan kualitas respons secara signifikan.
201~
202### Pengambilan Multi-Kueri
203~
204Terkadang kueri pengguna ambigu atau tidak selaras dengan bahasa yang digunakan dalam dokumen. **Multi-Query Retriever** secara otomatis menghasilkan varian dari pertanyaan asli untuk menangkap berbagai perspektif.
205~
206```python
207from langchain.retrievers import MultiQueryRetriever
208~
209multi_retriever = MultiQueryRetriever.from_llm(
210    retriever=vectorstore.as_retriever(),
211    llm=llm,
212)
213~
214docs = multi_retriever.invoke("What are the security best practices?")
215```
216~
217### Kompresi Kontekstual
218~
219Tidak semua konten dalam sebuah chunk relevan dengan kueri. **Contextual Compression Retriever** menggunakan LLM untuk mengekstrak hanya bagian yang relevan dari setiap chunk yang diambil.
220~
221```python
222from langchain.retrievers import ContextualCompressionRetriever
223from langchain.retrievers.document_compressors import LLMChainExtractor
224~
225compressor = LLMChainExtractor.from_llm(llm)
226compression_retriever = ContextualCompressionRetriever(
227    base_compressor=compressor,
228    base_retriever=retriever,
229)
230```
231~
232### Pencarian Hibrida
233~
234Pencarian murni semantik tidak selalu optimal. **Pencarian Hibrida** menggabungkan pencarian semantik (embeddings) dengan pencarian leksikal (BM25, pencocokan kata kunci) untuk mencapai hasil yang lebih baik.
235~
236```python
237from langchain.retrievers import EnsembleRetriever
238from langchain_community.retrievers import BM25Retriever
239~
240bm25_retriever = BM25Retriever.from_documents(chunks)
241bm25_retriever.k = 4
242~
243semantic_retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
244~
245hybrid_retriever = EnsembleRetriever(
246    retrievers=[bm25_retriever, semantic_retriever],
247    weights=[0.4, 0.6],
248)
249```
250~
251### RAG Percakapan (dengan Memori)
252~
253Untuk membangun chatbot RAG yang mengingat konteks percakapan, Anda perlu menambahkan memori yang merumuskan ulang pertanyaan pengguna dengan mempertimbangkan riwayat percakapan.
254~
255```python
256from langchain.chains import create_history_aware_retriever
257from langchain_core.prompts import MessagesPlaceholder
258~
259contextualize_prompt = ChatPromptTemplate.from_messages([
260    ("system", "Given the chat history and the user's latest question, "
261               "reformulate the question so it is understandable without the history."),
262    MessagesPlaceholder("chat_history"),
263    ("human", "{input}"),
264])
265~
266history_aware_retriever = create_history_aware_retriever(
267    llm, retriever, contextualize_prompt
268)
269```
270~
271## Praktik Terbaik
272~
2731.  **Pilih ukuran chunk yang tepat**: Bereksperimen dengan berbagai ukuran (500-1500 token). Chunks lebih kecil untuk jawaban presisi, lebih besar untuk konteks yang lebih luas.
2742.  **Gunakan metadata dokumen**: Tambahkan sumber, tanggal, dan kategori sebagai metadata ke chunks. Ini memungkinkan pemfilteran hasil selama pengambilan.
2753.  **Evaluasi kualitas**: Gunakan framework seperti [RAGAS](https://docs.ragas.io/) untuk mengukur metrik seperti *faithfulness*, *relevancy*, dan *context precision*.
2764.  **Kelola pembaruan dokumen**: Implementasikan pipeline re-ingesti untuk menjaga vector store tetap tersinkronisasi dengan sumber data Anda.
2775.  **Tambahkan re-ranker**: Setelah pengambilan awal, gunakan model re-ranking (seperti Cohere Rerank) untuk mengurutkan ulang hasil berdasarkan relevansi aktual.
278~
279## Kesimpulan
280~
281RAG telah menjadi arsitektur standar untuk membangun aplikasi AI yang membutuhkan akses ke pengetahuan spesifik dan terkini. LangChain sangat menyederhanakan implementasi, menyediakan abstraksi untuk setiap komponen pipeline.
282~
283**Langkah selanjutnya:**
284- **Bereksperimen secara lokal**: Mulai dengan ChromaDB dan beberapa dokumen untuk membiasakan diri dengan pipeline.
285- **Jelajahi LangSmith**: Gunakan [LangSmith](https://smith.langchain.com/) untuk memantau dan men-debug chain Anda di produksi.
286- **Coba model embedding yang berbeda**: Bandingkan model seperti `text-embedding-3-small`, `text-embedding-3-large`, dan model open-source dari Sentence Transformers.
287- **Periksa dokumentasi**: [Dokumentasi LangChain](https://python.langchain.com/docs/) adalah sumber yang sangat baik dan terus diperbarui.
288~