Apa Itu RAG?

Retrieval-Augmented Generation (RAG) adalah teknik yang menggabungkan kemampuan Large Language Model (LLM) dengan basis pengetahuan eksternal. Alih-alih mengandalkan pengetahuan yang sudah ada di dalam model (yang bisa sudah usang atau tidak lengkap), RAG mengambil dokumen relevan terlebih dahulu, lalu memberikannya sebagai konteks saat LLM menghasilkan jawaban.

Ini memecahkan tiga masalah utama LLM:

• Hallucination — LLM cenderung mengarang fakta
• Knowledge cutoff — pengetahuan model terbatas pada data training
• Domain specificity — model tidak tahu data internal perusahaan kamu

Arsitektur Pipeline RAG

Pipeline RAG memiliki dua fase utama:

Fase 1: Indexing (Offline)

Dokumen dipecah menjadi chunk, diubah menjadi vector embedding, dan disimpan di vector database.

from langchain.document_loaders import DirectoryLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_pinecone import PineconeVectorStore

1. Load dokumen
loader = DirectoryLoader(
    './docs',
    glob='*/.md',
    loader_cls=TextLoader
)
documents = loader.load()

2. Split menjadi chunks
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["\n## ", "\n\n", "\n", " "]
)
chunks = text_splitter.split_documents(documents)

3. Buat embedding dan simpan ke vector store
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vector_store = PineconeVectorStore.from_documents(
    documents=chunks,
    embedding=embeddings,
    index_name="knowledge-base"
)

Fase 2: Retrieval & Generation (Online)

Saat user bertanya, pipeline mengambil dokumen relevan dan mengirimkannya ke LLM sebagai konteks.

from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA

Setup retriever
retriever = vector_store.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 5}
)

Setup LLM
llm = ChatOpenAI(model="gpt-4o", temperature=0)

Buat RAG chain
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=retriever,
    return_source_documents=True
)

Query
result = qa_chain.invoke({"query": "Bagaimana cara mengatur CI/CD?"})
print(result["result"])

Strategi Chunking yang Efektif

Cara kamu memecah dokumen sangat mempengaruhi kualitas retrieval:

| Strategi | Kapan Digunakan | Ukuran Chunk | |----------|----------------|--------------| | Fixed size | Dokumen seragam | 500-1000 token | | Recursive | Dokumen dengan struktur campuran | 1000 token + overlap 200 | | Semantic | Dokumen dengan topik bervariasi | Berdasarkan boundary makna | | Document-level | FAQ atau pasal hukum | 1 dokumen = 1 chunk |

# Semantic splitting — pecah berdasarkan makna
from langchain_experimental.text_splitter import SemanticChunker

semantic_splitter = SemanticChunker(
    OpenAIEmbeddings(),
    breakpoint_threshold_type="percentile"
)
semantic_chunks = semantic_splitter.split_documents(documents)

Advanced Retrieval Techniques

Hybrid Search

Gabungkan keyword search (BM25) dengan semantic search untuk hasil lebih baik:

from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import BM25Retriever

BM25 retriever (keyword-based)
bm25_retriever = BM25Retriever.from_documents(chunks)
bm25_retriever.k = 5

Vector retriever (semantic)
vector_retriever = vector_store.as_retriever(search_kwargs={"k": 5})

Gabungkan keduanya
ensemble_retriever = EnsembleRetriever(
    retrievers=[bm25_retriever, vector_retriever],
    weights=[0.3, 0.7]
)

Re-ranking

Gunakan model re-ranking untuk menyaring hasil retrieval:

from langchain.retrievers import ContextualCompressionRetriever
from langchain_cohere import CohereRerank

compressor = CohereRerank(model="rerank-v3.5", top_n=3)
compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=ensemble_retriever
)

Tips Produksi

1. Evaluasi secara rutin — buat test set dengan pertanyaan dan jawaban yang diharapkan, ukur precision dan recall
2. Metadata filtering — tambahkan metadata (tanggal, kategori, penulis) pada setiap chunk untuk filtering yang lebih presisi
3. Cache — pertanyaan yang sering muncul bisa di-cache untuk mengurangi latency dan biaya API
4. Guardrails — tambahkan validasi agar LLM hanya menjawab berdasarkan konteks yang diberikan, bukan pengetahuan umum

Kesimpulan

RAG adalah cara paling praktis untuk memberdayakan LLM dengan data spesifik kamu. Mulai dari setup sederhana — chunking dasar dan similarity search — lalu tingkatkan dengan hybrid search dan re-ranking seiring evaluasi hasilnya. Kuncinya ada di kualitas chunking dan relevansi retrieval.