tl;dr: RAG (Retrieval-Augmented Generation) bikin LLM bisa jawab pertanyaan berbasis dokumen kamu, bukan cuma modal ingatan trainingnya. Pakai LangChain, tinggal load dokumen → split jadi chunks → embed ke vector store → retrieve → gabung sama LLM chain. Panduan ini step-by-step dari instalasi sampai upgrade ke RAG Agent yang bisa multi-tool.

Pendahuluan

LLM seperti GPT-4o dan Gemini memang pintar. Tapi mereka punya kelemahan fatal: data training terpotong di tanggal tertentu dan sering hallucinate kalau ditanya hal spesifik tentang dokumen internal perusahaan.

Solusinya? RAG (Retrieval-Augmented Generation).

RAG adalah arsitektur yang menggabungkan dua kekuatan:

1. Retrieval — Mencari data relevan dari database, dokumen, atau API eksternal

2. Generation — Menggunakan LLM untuk merangkum jawaban berdasarkan data yang ditemukan

Hasilnya? Agent yang bisa menjawab pertanyaan berdasarkan dokumen kamu — bukan cuma modal ingatan LLM.

Di panduan ini, kamu akan belajar cara bikin RAG agent dari nol menggunakan LangChain. Langsung praktik, kode bisa dicopy-paste.

Apa Itu RAG dan Kenapa Penting?

Problem yang Dipecahkan RAG

Problem	Tanpa RAG	Dengan RAG
Data terbaru	LLM hanya tahu data sampai cutoff date	Agent bisa akses dokumen terbaru kapan saja
Data privat	LLM tidak tahu data internal perusahaan	Dokumen internal bisa dijadikan sumber
Hallucination	Sering jawab ngasal kalau tidak tahu	Jawaban berdasarkan konteks yang diberikan
Biaya	Fine-tuning mahal dan perlu ulang	Zero training — cukup upload dokumen
Update pengetahuan	Harus retrain model	Tinggal ganti dokumen sumber

Arsitektur RAG Standard

┌─────────────┐
                    │  Dokumen    │
                    │  PDF/Web/DB │
                    └──────┬──────┘
                           ▼
                    ┌─────────────┐
                    │  Text Split │
                    └──────┬──────┘
                           ▼
                    ┌─────────────┐
                    │  Embedding  │
                    └──────┬──────┘
                           ▼
                    ┌─────────────┐
                    │ Vector Store│
                    └──────┬──────┘
                           │
    ┌──────────────────────┼──────────────────────┐
    │            Query     │                      │
    │              │       │                      │
    │              ▼       ▼                      │
    │       ┌──────────────┐                      │
    │       │  Retriever   │                      │
    │       └──────┬───────┘                      │
    │              │ Retrieved Documents           │
    │              ▼                               │
    │       ┌──────────────┐                      │
    │       │  LLM + Prompt│                      │
    │       └──────┬───────┘                      │
    │              ▼                               │
    │       ┌──────────────┐                      │
    │       │   Jawaban    │                      │
    │       └──────────────┘                      │
    └─────────────────────────────────────────────┘

Step 1: Instalasi Dependensi

Pertama, install semua package yang dibutuhkan:

pip install -U langchain langchain-openai langchain-chroma
pip install pypdf         # Untuk baca PDF
pip install beautifulsoup4 requests  # Untuk web scraping

Step 2: Load Dokumen

LangChain punya Document Loaders untuk berbagai format. Berikut beberapa yang paling berguna:

Load PDF

from langchain_community.document_loaders import PyPDFLoader

loader = PyPDFLoader("laporan-keuangan-2025.pdf")
documents = loader.load()
print(f"Total halaman: {len(documents)}")
documents[0].page_content -> teks halaman 1
documents[0].metadata    -> {'source': '...', 'page': 1}

Load Web Page

from langchain_community.document_loaders import WebBaseLoader

loader = WebBaseLoader("https://www.contoh.com/kebijakan-privasi")
documents = loader.load()

Load CSV / Excel

from langchain_community.document_loaders import CSVLoader

loader = CSVLoader("data-pelanggan.csv")
documents = loader.load()

Step 3: Split Dokumen Jadi Chunks

LLM punya context window terbatas. Dokumen panjang harus dipecah jadi potongan kecil (chunks) supaya bisa diproses.

from langchain.text_splitter import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,        # Ukuran per chunk (karakter)
    chunk_overlap=50,      # Overlap antar chunk biar konteks nyambung
    length_function=len,
    separators=["nn", "n", ".", " ", ""]
)

chunks = text_splitter.split_documents(documents)
print(f"Dari {len(documents)} dokumen jadi {len(chunks)} chunks")

Kenapa pakai RecursiveCharacterTextSplitter? Karena splitter ini coba memisah di batas paragraf dulu, baru kalau terlalu panjang pindah ke batas kalimat, dan seterusnya. Hasilnya lebih rapi daripada split per karakter.

Step 4: Buat Vector Embeddings & Simpan

Vector embeddings adalah representasi numerik dari teks. Dokumen yang mirip secara semantik akan punya vector yang berdekatan.

from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma

Pilih model embedding
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

Buat vector store dan simpan embeddings
vector_store = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    collection_name="rag_demo",
    persist_directory="./chroma_db"  # Simpan ke disk
)

print(f"✅ {len(chunks)} chunks berhasil di-index!")

Tips: Untuk production, jangan pakai Chroma untuk data besar (>1M dokumen). Pilih Pinecone, Qdrant, atau Weaviate yang lebih scalable.

Step 5: Buat Retriever

Retriever adalah jembatan antara query user dan vector store. Dia yang mencari dokumen paling relevan.

# Basic retriever — ambil 3 dokumen teratas
retriever = vector_store.as_retriever(search_kwargs={"k": 3})

Advanced: retriever dengan similarity score threshold
retriever = vector_store.as_retriever(
    search_type="similarity_score_threshold",
    search_kwargs={"score_threshold": 0.7, "k": 5}
)

Advanced: MMR (Maximum Marginal Relevance) — variasi hasil
retriever = vector_store.as_retriever(
    search_type="mmr",
    search_kwargs={"k": 3, "fetch_k": 10, "lambda_mult": 0.5}
)

Step 6: Buat RAG Chain

Ini bagian inti: menggabungkan retrieval dengan LLM generation.

from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

Inisialisasi model
model = ChatOpenAI(model="gpt-4o-mini", temperature=0)

Template prompt RAG
template = """Kamu adalah asisten bisnis yang menjawab berdasarkan konteks.
Gunakan informasi berikut untuk menjawab pertanyaan user.
Jika tidak tahu, katakan tidak tahu — jangan mengarang.

Konteks:
{context}

Pertanyaan: {question}

Jawab dalam bahasa Indonesia dengan jelas:"""

prompt = ChatPromptTemplate.from_template(template)

Helper: gabungkan dokumen jadi teks
def format_docs(docs):
    return "nn".join(doc.page_content for doc in docs)

RAG Chain menggunakan LCEL
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | model
    | StrOutputParser()
)

Jalankan!
result = rag_chain.invoke("Berapa total pendapatan perusahaan di 2025?")
print(result)

Step 7: Upgrade ke RAG Agent

Chain di atas statis — dia cuma retrieve sekali lalu generate. Biar lebih powerful, upgrade jadi RAG Agent yang bisa memutuskan kapan perlu retrieve dan bisa panggil multiple tools.

from langchain.agents import create_agent, Tool

Tools untuk agent
def search_documents(query: str) -> str:
    """Cari informasi dari database dokumen internal"""
    docs = retriever.get_relevant_documents(query)
    return format_docs(docs)

def get_current_date(query: str) -> str:
    """Dapatkan tanggal hari ini"""
    from datetime import datetime
    return f"Hari ini: {datetime.now().strftime('%d %B %Y')}"

tools = [
    Tool(name="CariDokumen", func=search_documents, description="Cari di database dokumen internal"),
    Tool(name="TanggalSekarang", func=get_current_date, description="Cek tanggal hari ini"),
]

Buat RAG Agent
agent = create_agent(
    model="openai:gpt-4o",
    tools=tools,
    system_prompt="""Kamu adalah asisten bisnis dengan akses ke database dokumen.
Gunakan tool CariDokumen untuk mencari informasi dari dokumen internal.
Gunakan tool TanggalSekarang untuk informasi tanggal.

Selalu gunakan CariDokumen dulu sebelum menjawab pertanyaan spesifik tentang data perusahaan."""
)

Test
result = agent.run("Berapa laba bersih perusahaan di Q4 2025?")
print(result)

Advanced RAG Techniques

Setelah menguasai basic RAG, kamu bisa tingkatkan dengan teknik berikut:

1. Parent Document Retriever

Ambil chunk kecil untuk relevansi, tapi kembalikan dokumen induk yang lebih panjang untuk konteks:

from langchain.retrievers import ParentDocumentRetriever
from langchain.storage import InMemoryStore

parent_splitter = RecursiveCharacterTextSplitter(chunk_size=2000)
child_splitter = RecursiveCharacterTextSplitter(chunk_size=400)

store = InMemoryStore()
parent_retriever = ParentDocumentRetriever(
    vectorstore=vector_store,
    docstore=store,
    child_splitter=child_splitter,
    parent_splitter=parent_splitter,
)

2. Hybrid Search (BM25 + Vector)

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

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

bm25_retriever = BM25Retriever.from_documents(chunks)
bm25_retriever.k = 3

ensemble_retriever = EnsembleRetriever(
    retrievers=[bm25_retriever, retriever],
    weights=[0.3, 0.7]  # Bobot BM25 30%, Vector 70%
)

RAG vs Fine-Tuning

Aspek	RAG	Fine-Tuning
Kebutuhan data	Dokumen referensi	Dataset Q&A terlabel
Biaya	Rendah (API LLM + storage)	Tinggi (GPU + dataset)
Update pengetahuan	Ganti dokumen, langsung efek	Retrain model, butuh waktu
Akurasi fakta	Tinggi (karena pakai konteks)	Sedang (bisa hallucinate)
Personalisasi	Terbatas	Tinggi
Waktu implementasi	1-2 hari	2-4 minggu

Kapan pakai RAG: Untuk knowledge base, customer support FAQ, legal doc review, research assistant — apapun yang butuh akurasi fakta tinggi.

Kapan pakai Fine-Tuning: Untuk personalisasi gaya bicara, domain-specific terminology, atau output format yang rigid.

RAG Agent x KomuniTech

Membangun RAG agent production-ready bukan cuma soal kode. Ada banyak hal yang sering luput dari tutorial online:

Chunking strategy apa yang cocok untuk dokumen Bahasa Indonesia?
Embedding model mana yang performanya terbaik untuk domain bisnis lokal?
Bagaimana handle dokumen dengan tabel dan gambar?
Monitoring — gimana detect kalau RAG agent mulai ngawur?
Security — gimana pastikan agent cuma akses dokumen yang diizinkan?

Di KomuniTech, semua ini dibahas tuntas.

KomuniTech adalah platform belajar Karyawan AI untuk bisnis. Bukan kursus rekaman — kamu didampingi tim sampai AI Agent-mu benar-benar jalan, didukung komunitas praktisi aktif dan garansi hasil.

Robbie Jeo, CEO KomuniTech, menegaskan,

RAG adalah teknologi yang langsung bisa diaplikasikan di bisnis hari ini. Kami di KomuniTech fokus memastikan peserta tidak cuma paham teorinya, tapi bisa bikin RAG agent yang benar-benar bekerja untuk perusahaan mereka.

FAQ

Q: Berapa biaya operasional RAG agent?

A: Biaya utamanya dari API LLM (sekitar $0.01-0.05 per 1000 pertanyaan untuk GPT-4o-mini) dan storage vector (gratis untuk Chroma lokal, ~$10-50/bulan untuk Pinecone/Qdrant untuk skala kecil).

Q: Apakah RAG bisa handle dokumen berformat PDF dengan tabel?

A: Bisa, tapi perlu preprocessing tambahan. LangChain punya PyMuPDFLoader dan DocX2TxtLoader. Untuk tabel kompleks, pertimbangkan unstructured.io atau layout detection model.

Q: Model embedding apa yang terbaik untuk Bahasa Indonesia?

A: OpenAI text-embedding-3-small atau 3-large adalah pilihan aman. Untuk open-source, coba BGE-M3 atau multilingual-e5-large yang mendukung Bahasa Indonesia.

Q: Gimana cara update dokumen di RAG tanpa rebuild semua?

A: Pakai vector store yang support incremental update. Chroma dan Qdrant bisa add/delete dokumen individual tanpa rebuild seluruh index.

Q: Apa kelemahan RAG?

A: RAG sangat bergantung pada kualitas retrieval. Kalau retriever gagal menemukan dokumen relevan, LLM akan jawab berdasarkan pengetahuannya sendiri (rawan hallucination). Butuh eval dan tuning retriever secara berkala.

Disclaimer

Informasi dalam artikel ini berdasarkan praktik terbaik RAG menggunakan LangChain per Juni 2026. Harga API dan performa model dapat berubah. Lakukan pengujian sendiri sebelum implementasi production.

dYOR (Do Your Own Research)

Sebelum deploy RAG agent:

Evaluasi kualitas retrieval dengan metrics seperti Hit Rate dan MRR (Mean Reciprocal Rank)
Bandingkan embedding model: OpenAI vs BGE vs Cohere
Uji berbagai chunk size: 256, 512, 1024 tokens
Buat test set pertanyaan spesifik domain untuk eval

Saatnya Bangun AI Agent-mu!

RAG adalah teknologi yang paling cepat memberikan nilai bisnis dari seluruh ekosistem AI Agent. Tidak perlu nunggu fine-tuning berbulan-bulan — cukup upload dokumen, dan agent kamu langsung bisa menjawab pertanyaan berdasarkan data perusahaan.

KomuniTech siap mendampingi kamu dari konsep sampai deployment.

Robbie Jeo, CEO KomuniTech, menegaskan, *”Kami tidak hanya mengajarkan teori — kami memastikan setiap peserta bisa membangun dan menjalankan AI Agent nyata untuk bisnis mereka.

👉 Gabung KomuniTech sekarang dan bikin RAG agent pertamamu!

Referensi

LangChain — RAG Tutorial (Official) — panduan resmi LangChain buat build RAG
Lewis et al. (2020) — Retrieval-Augmented Generation for Knowledge-Intensive NLP — paper original yang mendefinisikan RAG
Chroma — Documentation — docs resmi vector store yang dipakai di contoh
OpenAI — Embeddings Guide — panduan resmi model embedding text-embedding-3

Artikel telah diupdate pada 11/07/2026 untuk memastikan artikel tetap sesuai kondisi terkini.

Products

Company

Resources

Support

Cara Bikin RAG Agent dengan LangChain: Panduan Step-by-Step

Pendahuluan

Apa Itu RAG dan Kenapa Penting?

Problem yang Dipecahkan RAG

Arsitektur RAG Standard

Step 1: Instalasi Dependensi

Step 2: Load Dokumen

Load PDF

documents[0].page_content -> teks halaman 1

documents[0].metadata -> {'source': '...', 'page': 1}

Load Web Page

Load CSV / Excel

Step 3: Split Dokumen Jadi Chunks

Step 4: Buat Vector Embeddings & Simpan

Pilih model embedding

Buat vector store dan simpan embeddings

Step 5: Buat Retriever

Advanced: retriever dengan similarity score threshold

Advanced: MMR (Maximum Marginal Relevance) — variasi hasil

Step 6: Buat RAG Chain

Inisialisasi model

Template prompt RAG

Helper: gabungkan dokumen jadi teks

RAG Chain menggunakan LCEL

Jalankan!