Belajar LangChain - Konsep Dasar & Arsitektur Utama

#Pendahuluan

Di episode 1, kalian memahami sejarah LangChain dan mengapa ia ada: standardisasi provider, composability, dan orkestrasi stateful. Sekarang saatnya membedah arsitektur-nya — komponen apa saja yang akan sering kalian pegang, bagaimana komponen itu disusun menjadi pipeline, dan bagaimana paket-paketnya terorganisir di v1.x.

Episode 2 ini adalah peta konsep. Tidak banyak kode eksekusi di sini, tapi seluruh episode berikutnya akan merujuk pada istilah yang kita bangun di episode ini — primitif langchain-core, LCEL, dan struktur paket. Pahami baik-baik, karena ini akan menjadi bahasa bersama kita ke depan.

#Primitif di langchain-core

langchain-core adalah jantung LangChain. Di dalamnya hidup antarmuka abstrak yang menjadi kontrak bagi semua komponen lain. Kenali tujuh primitif berikut — merekalah bahan bangunan utama hampir semua aplikasi LangChain:

Semua provider model — OpenAI, Anthropic, dan lainnya — mengimplementasikan BaseChatModel. Semua vector store komersial maupun open source mengimplementasikan antarmuka VectorStore. Dengan pola ini, kalian bisa menukar implementasi tanpa mengubah logika aplikasi.

#Chat Models dan Prompt Templates

Chat models adalah primitif yang paling sering dipakai. Ia menerima urutan pesan (biasanya system, lalu human/assistant) dan mengembalikan pesan balasan. Contoh paling sederhana:

Chat model minimal dengan langchain-openai

from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(model="gpt-4o-mini")
response = llm.invoke("Apa itu LangChain dalam satu kalimat?")
print(response.content)

Prompt templates memisahkan prompt dari data. Alih-alih menulis prompt utuh dengan teks terselip, kalian mendefinisikan placeholder dan mengisi nilainya saat invoke:

ChatPromptTemplate dengan input variable

from langchain_core.prompts import ChatPromptTemplate
 
prompt = ChatPromptTemplate.from_messages([
    ("system", "Kamu adalah asisten yang menjawab dengan ringkas."),
    ("human", "Jelaskan konsep {topik} dalam {jumlah} kalimat."),
])
 
formatted = prompt.invoke({"topik": "LCEL", "jumlah": "dua"})
print(formatted.to_messages())

#Output Parsers, Tools, Embeddings, Vector Stores, dan Retrievers

Empat primitif lainnya bekerja pada tahap berbeda dalam pipeline:

• Output parser mengambil jawaban model yang berupa teks bebas dan mengubahnya menjadi bentuk yang bisa dipakai kode — misalnya str polos, JSON, atau objek Pydantic. Detailnya akan kita bedah di episode 6.
• Tool membungkus fungsi Python (query database, panggil API) beserta skema parameternya, sehingga model bisa memilih dan memanggilnya. Ini fondasi dari agent — dibahas di episode 8.
• Embeddings mengubah kalimat menjadi vektor numerik, dan vector store menyimpan vektor itu untuk dicari berdasarkan kemiripan — bahan utama RAG di episode 10.
• Retriever adalah antarmuka yang membungkus pencarian (biasanya dari vector store) untuk mengambil dokumen relevan sebagai konteks jawaban model — inti dari RAG di episode 11.

Semua primitif ini dirancang agar bisa disusun dan saling bertukar tempat — di situlah LCEL berperan.

#LCEL: Bahasa Komposisi Chain

LCEL (LangChain Expression Language) adalah cara deklaratif untuk merangkai komponen menjadi pipeline. Gagasannya: setiap komponen adalah Runnable, dan runnable bisa disambung dengan operator pipa |, persis seperti meneruskan output satu perintah ke perintah berikutnya di terminal.

#Operator Pipa dan Runnable

Konsep dasarnya sangat sederhana — output dari kiri mengalir menjadi input ke kanan:

Membangun chain dengan operator pipa

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
 
prompt = ChatPromptTemplate.from_messages([
    ("system", "Kamu ahli bahasa Indonesia."),
    ("human", "{pertanyaan}"),
])
 
chain = prompt | ChatOpenAI(model="gpt-4o-mini") | StrOutputParser()
 
hasil = chain.invoke({"pertanyaan": "Apa itu operator pipa?"})
print(hasil)

Perhatikan variabel {pertanyaan} di dalam template — di atas operator pipa, nilai input dikirim ke prompt, hasilnya diteruskan ke model, lalu jawaban model diubah menjadi string oleh StrOutputParser. Satu ekspresi, satu pipeline utuh.

Selain rantai sekuensial, LCEL menyediakan runnable khusus untuk orkestrasi:

Contoh paralelisme: satu input diolah dua chain berbeda sekaligus:

RunnableParallel menjalankan dua cabang sekaligus

from langchain_core.runnables import RunnableParallel, RunnablePassthrough
 
rantai_ringkas = prompt | llm | StrOutputParser()
rantai_detail = prompt | llm | StrOutputParser()
 
paralel = RunnableParallel(
    ringkas=rantai_ringkas,
    detail=rantai_detail,
    input_asli=RunnablePassthrough(),
)

#invoke, batch, dan stream

Semua runnable di LCEL berbagi tiga mode eksekusi yang sama — antarmuka seragam inilah yang membuat komposisi begitu mudah:

• invoke — jalankan satu input, tunggu hasil lengkap.
• batch — jalankan daftar input; bisa dengan concurrency.
• stream — terima hasil bertahap per chunk.

Ketiganya punya versi async (ainvoke, abatch, astream) yang akan dipakai saat menangani aplikasi bersamaan. Mode-mode ini selalu tersedia di semua runnable, sehingga kode kalian tidak berubah bentuk hanya karena komponen di belakangnya berganti.

#Struktur Paket LangChain

Memahami struktur paket membantu kalian tahu harus import dari mana. Di v1.x pembagiannya jelas:

Aturan praktisnya: abstraksi di langchain-core, integrasi spesifik di paket per-provider. Import yang diawali langchain_openai atau langchain_anthropic adalah integrasi; yang diawali langchain_core adalah kontrak abstrak. Jangan khawatir menghafal semua paket — kalian akan meng-import yang sama terus-menerus hingga hafal sendiri.

#Penutup

Episode 2 memberi kalian peta arsitektur LangChain: tujuh primitif langchain-core yang menjadi kontrak antar komponen, bahasa komposisi LCEL yang merangkai runnable dengan operator pipa beserta mode invoke, batch, dan stream, serta struktur paket modular yang memisahkan core dari integrasi provider.

Inti yang harus dibawa pulang:

• langchain-core menyediakan primitif abstrak: chat models, prompt templates, output parsers, tools, embeddings, vector stores, dan retrievers.
• Semua primitif mengimplementasikan antarmuka standar, sehingga bisa saling ditukar.
• LCEL merangkai runnable dengan operator pipa |; output kiri mengalir ke kanan.
• RunnableParallel, RunnablePassthrough, dan RunnableLambda memperkaya komposisi non-sekuensial.
• Setiap runnable mendukung invoke, batch, stream, dan varian async-nya.

Di episode 3 berikutnya kita mulai benar-benar menulis kode yang jalan: setup proyek, inisialisasi chat models, dan semua mode invocation — dari invoke dan ainvoke, streaming dengan stream/astream, hingga batch/abatch beserta isi response object. Sampai jumpa!