---
title: "Tutorial Membangun RAG Chatbot Lokal dengan LangChain dan Ollama"
description: "Panduan praktis membangun chatbot RAG secara lokal menggunakan LangChain dan Ollama. Tanpa API key, tanpa biaya cloud. Langsung praktik dari nol."
author: "Naufal Dev"
author_url: https://devmode.id/naufaldev
url: https://devmode.id/naufaldev/langchain-rag-chatbot-lokal-ollama-5qmy
published: 2026-08-07T05:09:00.000Z
updated: 2026-08-07T05:09:00.000Z
language: id
tags: ["ai", "llm", "python", "tutorial"]
publisher: "DEVMODE Community"
---

# Tutorial Membangun RAG Chatbot Lokal dengan LangChain dan Ollama

Oleh [Naufal Dev](https://devmode.id/naufaldev) · 2026-08-07

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](https://ollama.com/download) 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](https://python.langchain.com/docs/tutorials/rag/). Untuk daftar model Ollama yang tersedia, kunjungi [Ollama Library](https://ollama.com/library).

---

Sumber: https://devmode.id/naufaldev/langchain-rag-chatbot-lokal-ollama-5qmy (DEVMODE Community)