Large Language Model (LLM) seperti GPT, Claude, dan Gemini sudah sangat canggih. Namun, memanggil API-nya secara langsung punya banyak keterbatasan: kamu harus mengelola prompt secara manual, memecah konteks yang panjang, menyimpan riwayat percakapan, dan menghubungkan model ke data eksternal — semuanya dari nol. Di sinilah LangChain berperan. LangChain adalah framework open-source untuk membangun aplikasi berbasis LLM secara modular, mulai dari chatbot sederhana hingga sistem Retrieval-Augmented Generation (RAG) dan AI agent. Di tutorial ini, kita akan membangun semuanya langkah demi langkah dengan Python.

Apa Itu LangChain dan Kenapa Kamu Perlu Mempelajarinya?

LangChain menyediakan sekumpulan building block yang saling terhubung, sehingga kamu tidak perlu menulis kode boilerplate berulang-ulang. Konsep inti yang akan kita pelajari:

  • Model — antarmuka seragam untuk LLM (OpenAI, Anthropic, model lokal, dan lainnya).
  • Prompt Template — templat prompt yang bisa diisi variabel secara dinamis.
  • Chain (LCEL) — rangkaian langkah yang disusun dengan operator |.
  • Memory — penyimpanan riwayat percakapan antar-interaksi.
  • Retrieval — menghubungkan LLM ke dokumen eksternal (RAG).
  • Agent & Tools — LLM yang bisa "memanggil" fungsi untuk menyelesaikan tugas.

Menguasai LangChain akan membuatmu jauh lebih produktif saat membangun produk AI, dan menjadi salah satu skill yang paling dicari di roadmap menjadi AI Engineer.

Prasyarat: kamu perlu memahami dasar Python (variabel, fungsi, list) dan punya API key dari penyedia LLM (misalnya OpenAI). Kalau belum punya, kamu bisa menggunakan model open-source secara gratis lewat Ollama sebagai alternatif.

Persiapan: Instalasi dan API Key

Pertama, buat virtual environment dan instal paket yang dibutuhkan. LangChain kini dibagi menjadi beberapa paket modular agar lebih ringan.

bash
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate

pip install langchain langchain-openai langchain-community \
            langchain-text-splitters langchain-chroma langgraph

Selanjutnya, siapkan API key. Jangan pernah menuliskan key langsung di kode — simpan di environment variable.

python
import os
from getpass import getpass

os.environ["OPENAI_API_KEY"] = getpass("Masukkan OpenAI API Key: ")
# Saat produksi, gunakan dotenv atau secret manager, bukan getpass().

Langkah 1: Memanggil Model LLM

Langkah paling dasar adalah memanggil model chat. Dengan LangChain, kamu cukup membuat objek ChatOpenAI lalu memanggil invoke().

python
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)

response = llm.invoke("Jelaskan apa itu list comprehension di Python dalam 2 kalimat.")
print(response.content)

Parameter temperature mengontrol seberapa "kreatif" jawaban model. Nilai mendekati 0 membuat jawaban lebih deterministik (cocok untuk tugas teknis), sedangkan nilai mendekati 1 membuatnya lebih variatif.

Langkah 2: Prompt Template

Menulis string prompt secara manual sulit di-maintain. ChatPromptTemplate memungkinkan kamu mendefinisikan templat dengan placeholder yang diisi saat runtime.

python
from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "Kamu adalah asisten programming yang ramah dan menjelaskan dengan bahasa sederhana."),
    ("human", "Jelaskan konsep {konsep} untuk {level}."),
])

messages = prompt.invoke({"konsep": "closure di JavaScript", "level": "pemula"})
print(messages.to_messages())

Langkah 3: Merangkai Chain dengan LCEL

LCEL (LangChain Expression Language) adalah cara modern merangkai komponen menggunakan operator |. Output satu komponen otomatis menjadi input komponen berikutnya.

python
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

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

prompt = ChatPromptTemplate.from_messages([
    ("system", "Kamu adalah asisten programming yang ramah."),
    ("human", "Jelaskan konsep {konsep} untuk {level}."),
])

chain = prompt | llm | StrOutputParser()

hasil = chain.invoke({"konsep": "recursion", "level": "pemula"})
print(hasil)

StrOutputParser mengubah objek respons LLM menjadi string polos. Tanpa parser, kamu akan menerima objek AIMessage lengkap dengan metadata. Selalu tambahkan parser di ujung chain agar hasilnya bersih dan mudah dipakai.

Langkah 4: Menambahkan Memory ke Chatbot

Secara default, LLM tidak mengingat percakapan sebelumnya. Untuk membuat chatbot yang sadar konteks, gunakan RunnableWithMessageHistory. Kita juga menambahkan MessagesPlaceholder pada prompt sebagai tempat riwayat percakapan.

python
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.chat_history import InMemoryChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

llm = ChatOpenAI(model="gpt-4o-mini")

prompt = ChatPromptTemplate.from_messages([
    ("system", "Kamu adalah asisten programming yang ramah."),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{pertanyaan}"),
])

chain = prompt | llm

store = {}

def get_session_history(session_id: str):
    if session_id not in store:
        store[session_id] = InMemoryChatMessageHistory()
    return store[session_id]

chatbot = RunnableWithMessageHistory(chain, get_session_history)

chatbot.invoke(
    {"pertanyaan": "Nama saya Budi dan saya sedang belajar Python."},
    config={"configurable": {"session_id": "sesi-1"}},
)

resp = chatbot.invoke(
    {"pertanyaan": "Siapa nama saya?"},
    config={"configurable": {"session_id": "sesi-1"}},
)
print(resp.content)  # LLM akan menjawab "Budi" karena ingat percakapan sebelumnya

Pada produksi nyata, ganti InMemoryChatMessageHistory dengan penyimpanan persisten seperti Redis atau database, karena data di memori akan hilang saat proses berhenti.

Langkah 5: Membangun RAG dengan LangChain

LLM hanya "tahu" data yang ada di training-nya. Untuk menjawab berdasarkan dokumen kamu sendiri, gunakan RAG: ambil potongan dokumen paling relevan, lalu sisipkan ke prompt sebagai konteks. Konsep dasarnya sudah kami bahas mendalam di artikel membangun chatbot RAG dari nol, dan penyimpanan vektor di artikel semantic search dengan ChromaDB. Sekarang kita rakit dengan LangChain.

Langkah pertama: muat dokumen, pecah menjadi chunk, buat embedding, lalu simpan ke vector store.

python
from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma

# 1. Muat dokumen
loader = TextLoader("panduan_python.txt")
docs = loader.load()

# 2. Pecah menjadi chunk agar muat di konteks LLM
splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = splitter.split_documents(docs)

# 3. Buat vector store + retriever
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=OpenAIEmbeddings(),
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

Kemudian rakit chain RAG yang mengambil konteks relevan sebelum menjawab.

python
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

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

prompt = ChatPromptTemplate.from_messages([
    ("system", "Jawab pertanyaan HANYA berdasarkan konteks berikut:\n\n{context}\n\nJika tidak ada di konteks, katakan 'Saya tidak tahu'."),
    ("human", "{question}"),
])

rag_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

jawaban = rag_chain.invoke("Bagaimana cara membaca file di Python?")
print(jawaban)

Langkah 6: Membuat AI Agent dengan Tools

Agent adalah LLM yang bisa memutuskan sendiri untuk memanggil fungsi (tools) ketika perlu, alih-alih hanya menghasilkan teks. Misalnya, agent bisa melakukan kalkulasi matematika lewat fungsi Python daripada menebak hasilnya.

python
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent

@tool
def kali(a: float, b: float) -> float:
    """Kalikan dua angka dan kembalikan hasilnya."""
    return a * b

@tool
def tambah(a: float, b: float) -> float:
    """Jumlahkan dua angka dan kembalikan hasilnya."""
    return a + b

llm = ChatOpenAI(model="gpt-4o-mini")
agent = create_react_agent(llm, tools=[kali, tambah])

result = agent.invoke({
    "messages": [("user", "Berapa hasil (12 + 8) lalu dikalikan 3?")],
})

print(result["messages"][-1].content)  # 60

Agent dapat memanggil tools berkali-kali dalam satu permintaan, sehingga konsumsi token bisa jauh lebih besar daripada chain biasa. Pantau penggunaan API-mu dan beri batasan (rate limit) atau anggaran pada akun LLM kamu.

Kesimpulan

Selamat! Kamu baru saja membangun fondasi lengkap aplikasi LLM dengan LangChain: memanggil model, prompt template, chain LCEL, chatbot dengan memory, sistem RAG, hingga AI agent dengan tools. Dari sini, kamu bisa menggabungkan ketiganya menjadi produk nyata — misalnya chatbot layanan pelanggan yang menjawab berdasarkan dokumen perusahaan. Untuk melanjutkan perjalananmu, lihat roadmap menjadi AI Engineer agar tahu skill apa yang harus dipelajari berikutnya. Selamat bereksperimen!

Apakah LangChain gratis untuk dipakai?

Ya, LangChain adalah framework open-source (lisensi MIT) dan gratis. Namun, biaya muncul dari API LLM yang kamu gunakan (misalnya OpenAI atau Anthropic). Kamu bisa menekan biaya dengan memakai model open-source lokal seperti via Ollama.

Apakah saya wajib menggunakan OpenAI dengan LangChain?

Tidak. LangChain mendukung banyak penyedia model (Anthropic, Google Gemini, Mistral, Cohere) dan juga model open-source lokal lewat Ollama atau Hugging Face. Kamu tinggal mengganti kelas modelnya, misalnya ChatAnthropic atau ChatOllama.