Tutorial Membangun RAG Chatbot Lokal dengan LangChain dan Ollama

Retrieval Augmented Generation (RAG) adalah teknik yang memungkinkan LLM menjawab pertanyaan berdasarkan dokumen pribadi atau knowledge base milik kita. Alih-alih mengirim semua dokumen ke context window yang terbatas, RAG bekerja dengan mencari bagian dokumen yang paling relevan terlebih dahulu, lalu memberikan hasilnya sebagai context untuk LLM.

Di tutorial ini kita akan membangun chatbot RAG sederhana yang berjalan secara lokal tanpa cloud API. Kita memakai Ollama untuk menjalankan model LLM di laptop dan LangChain untuk orkestrasi pipeline retrieval dan generation. Hasil akhirnya: sebuah script Python yang bisa tanya-jawab berdasarkan file PDF atau dokumen teks.

Prasyarat dan Setup Environment

Sebelum mulai coding, pastikan environment kamu sudah siap:

• Ollama terinstall di mesin. Download dari ollama.com dan jalankan daemon-nya.

• Python 3.10+ dengan pip siap pakai.

• Model LLM yang sudah di-pull via Ollama, misalnya ollama pull llama3.2 atau ollama pull mistral.

LangChain memiliki banyak modul. Untuk tutorial ini kita install beberapa package spesifik:

pip install langchain langchain-ollama langchain-community
pip install pypdf chromadb sentence-transformers

Package pypdf untuk membaca file PDF, chromadb sebagai vector store lokal, dan sentence-transformers untuk menghasilkan embedding teks.

Mengapa Lokal Lebih Menarik untuk Developer

Banyak tutorial RAG di internet menggunakan OpenAI API sebagai LLM backend. Pendekatan itu valid, tapi ada beberapa alasan mengapa setup lokal lebih menarik untuk development:

• Tanpa biaya: Ollama dan model open weight tidak mengenakan charge per token. Cocok untuk eksplorasi tanpa khawatir tagihan.

• Privasi data: Dokumen sensitif tidak perlu keluar dari mesin lokal. Penting untuk internal company knowledge base atau data pribadi.

• Offline capable: Setelah model dan vector store siap, chatbot bisa berjalan tanpa koneksi internet sama sekali.

Tentu saja, untuk production dengan traffic tinggi, solusi cloud tetap lebih scalable. Tapi untuk prototyping dan pembelajaran, lokal adalah jalan terbaik.

Langkah 1: Membaca Dokumen PDF

Pertama kita buat fungsi untuk mengekstrak teks dari file PDF. LangChain sudah menyediakan loader bawaan untuk ini:

from langchain_community.document_loaders import PyPDFLoader

loader = PyPDFLoader("dokumen.pdf")
pages = loader.load_and_split()
print(f"Total halaman: {len(pages)}")

Metode load_and_split() mengembalikan list objek Document di mana setiap item merepresentasikan satu halaman PDF dengan properti page_content dan metadata.

Kalau dokumen kamu berformat teks biasa atau Markdown, gunakan TextLoader atau UnstructuredMarkdownLoader sebagai gantinya.

Langkah 2: Membuat Vector Store dengan ChromaDB

Setelah teks diekstrak, kita perlu mengubahnya jadi vector embedding supaya bisa dicari secara semantic. Kita pakai HuggingFaceEmbeddings yang berjalan lokal tanpa memanggil API eksternal:

from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma

embedding = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
vectorstore = Chroma.from_documents(pages, embedding, persist_directory="./chroma_db")

Model all-MiniLM-L6-v2 dipilih karena ringan dan performanya cukup bagus untuk Bahasa Indonesia maupun Inggris. Directory ./chroma_db akan berisi database SQLite yang menyimpan embedding dan teks asli.

Proses ini bisa memakan waktu beberapa menit tergantung jumlah halaman PDF. Setelah selesai, vector store bisa dipakai berkali-kali tanpa perlu rebuild.

Langkah 3: Inisialisasi LLM via Ollama

LangChain punya integrasi resmi untuk Ollama. Kita cukup inisialisasi objek OllamaLLM dengan nama model yang sudah di-pull:

from langchain_ollama import OllamaLLM

llm = OllamaLLM(model="llama3.2", temperature=0.3)

Parameter temperature=0.3 membuat output lebih deterministik. Naikkan nilainya kalau kamu ingin respons yang lebih kreatif. Model llama3.2 adalah pilihan solid karena ukurannya seimbang antara kualitas dan kecepatan di hardware consumer.

Langkah 4: Membuat RAG Pipeline

Ini inti dari tutorial. Kita gabungkan retrieval (mencari dokumen relevan) dengan generation (membuat jawaban). LangChain menyediakan RetrievalQA chain yang sudah mengabstraksi logika ini:

from langchain.chains import RetrievalQA

retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=retriever,
    return_source_documents=True
)

result = qa_chain.invoke({"query": "Apa poin utama dari dokumen ini?"})
print(result["result"])

Objek retriever mencari top-3 chunk paling mirip dengan pertanyaan user. Kemudian qa_chain mengirimkan pertanyaan dan context tersebut ke LLM untuk dijawab. Properti return_source_documents=True memungkinkan kita melihat dokumen mana saja yang dijadikan referensi jawaban.

Langkah 5: Membuat Interactive Chat Loop

Untuk pengalaman yang lebih natural, kita bisa bungkus pipeline di atas jadi fungsi chat interaktif di terminal:

def chat():
    print("RAG Chatbot siap. Ketik 'exit' untuk keluar.")
    while True:
        q = input("\nPertanyaan: ")
        if q.lower() == "exit":
            break
        result = qa_chain.invoke({"query": q})
        print(f"Jawaban: {result['result']}")
        print("\nSumber:")
        for doc in result["source_documents"]:
            print(f"- Halaman {doc.metadata['page']}")

if __name__ == "__main__":
    chat()

Script ini akan terus membaca input user sampai kata exit diketik. Setiap jawaban disertai informasi halaman sumber, jadi user bisa verifikasi kebenaran jawaban dengan mudah.

Optimasi dan Troubleshooting

Berikut tips untuk meningkatkan kualitas RAG dan menangani masalah umum:

• Chunking strategy: Default load_and_split() memecah per halaman. Untuk dokumen teknis panjang, pertimbangkan pakai RecursiveCharacterTextSplitter dengan chunk size 500-1000 karakter dan overlap 100 karakter supaya konteks tidak putus di tengah kalimat.

• Embedding model: Kalau dokumen mayoritas Bahasa Indonesia, coba model paraphrase-multilingual-MiniLM-L12-v2 yang mendukung lebih dari 50 bahasa.

• Model LLM: Kalau llama3.2 terasa lambat, ganti dengan phi4 atau gemma2:2b yang lebih ringan meskipun sedikit mengorbankan kualitas reasoning.

• Memory usage: ChromaDB menyimpan embedding di RAM untuk query cepat. Kalau dokumen sangat besar, pertimbangkan pakai SQLite mode disk-based atau split dokumen menjadi beberapa collection.

Kesimpulan

Kita sudah berhasil membangun pipeline RAG lengkap yang berjalan 100 persen lokal. Kombinasi LangChain, Ollama, dan ChromaDB memungkinkan developer membuat chatbot knowledge base tanpa dependensi cloud atau biaya API.

Setup ini cocok untuk internal tool, asisten dokumentasi teknis, atau prototipe sebelum migrasi ke solusi enterprise seperti Pinecone atau Weaviate. Selanjutnya kamu bisa eksplorasi fitur agentic RAG, web search integration, atau multimodal retrieval dengan gambar.

Dokumentasi resmi LangChain untuk RAG bisa dibaca di LangChain RAG Tutorial. Untuk daftar model Ollama yang tersedia, kunjungi Ollama Library.