LangChain vs LangGraph vs LangSmith vs LangFlow: Perbedaan Utama yang Perlu Dipahami

Artikel ini memberikan perbandingan formal berdampingan antara LangChain vs LangGraph, serta bagaimana LangSmith dan LangFlow masuk dalam gambaran. Kita akan membangun di atas konsep yang dibahas di artikel DataCamp lainnya dan membahas kapan memilih tiap kerangka untuk mengirim sistem AI agentic siap produksi. Jika Anda mencari awal yang praktis untuk LangChain, saya merekomendasikan kursus Developing LLM Applications with LangChain.

Ringkasan Singkat (TL;DR) 

Sebelum masuk ke detail, berikut ringkasan cepat tentang bagaimana LangChain, LangGraph, LangSmith, dan LangFlow saling melengkapi dan kapan Anda mungkin memilih masing-masing.

• LangChain: Fondasi, membangun alur kerja LLM modular (prompt, alat, memori, retriever) menggunakan API sederhana seperti LCEL. Terbaik untuk pembuatan prototipe dan aplikasi linear.
• LangGraph: Orkestrator, mengelola alur kerja kompleks, bertahan, bercabang dengan retry, loop, dan persistensi. Terbaik untuk sistem multi‑agen yang tangguh dan siap produksi.
• LangSmith: Pengamat, tracing, evaluasi, dan pemantauan aplikasi LLM yang agnostik terhadap kerangka. Terbaik untuk debugging, uji regresi, dan pelacakan kualitas.
• LangFlow: Builder visual, antarmuka drag‑and‑drop untuk cepat membuat prototipe flow dan mengekspornya ke kode. Terbaik untuk tim, lokakarya, dan non‑koder.

Heuristik cepat: Mulai dengan LangChain, beralih ke LangGraph saat alur kerja tumbuh, tambahkan LangSmith untuk observabilitas, gunakan LangFlow saat Anda butuh iterasi cepat atau kolaborasi.

Pengantar LangChain dan LangGraph

Large language models (LLM) sangat hebat untuk satu prompt. Ini sudah cukup dikenal, mengingat kita begitu sering menggunakan model-model ini sekarang. 

Namun, aplikasi nyata membutuhkan alur kerja: mengambil data, bernalar, memanggil alat, menanyakan tindak lanjut, retry saat gagal, dan terkadang jeda untuk intervensi manusia. Karena itu, ada dua kerangka yang akan sering Anda dengar: LangChain dan LangGraph. Keduanya berada di ekosistem yang sama dan sering bekerja bersama, tetapi menyelesaikan bagian masalah yang berbeda:

• LangChain membantu kita membangun langkah-langkahnya
• LangGraph membantu kita mengorkestrasi langkah-langkah ini saat semuanya menjadi kompleks.

Berbicara tentang ekosistem, kita juga akan membahas LangSmith (untuk tugas observabilitas/evaluasi) dan LangFlow (builder visual drag‑and‑drop), karena keduanya juga bagian dari ekosistem ini. 

Sejarah Singkat Ekosistem LangChain (2022–2025)

Masuk akal untuk memulai dengan sedikit sejarah tentang ekosistem LangChain; ini telah menjadi kerangka utama untuk AI agentic, dan mengetahui bagaimana ia sampai di sini akan memudahkan kita melihat mengapa LangGraph, LangSmith, dan LangFlow penting. 

• 2022 — Lahirnya LangChain: LangChain diluncurkan sebagai proyek open‑source pada Okt 2022 oleh Harrison Chase dan tim. Dengan cepat menjadi kerangka andalan untuk menyusun aplikasi LLM dan, karenanya, menarik komunitas dan integrasi yang berkembang pesat.
• 2023 — Dari popularitas ke platform: LangChain memformalkan abstraksi inti dan menambahkan LCEL (LangChain Expression Language) untuk komposisi gaya pipa. Cara baru untuk menerapkan chain ke produksi via API juga dibuat, disebut LangServe. Perusahaan di balik LangChain menggalang dana untuk mempercepat pekerjaan ekosistem.
• 2023–2024 — Observabilitas hadir dengan LangSmith: Pertengahan 2023, dan tersedia umum awal 2024, LangSmith memperkenalkan tracing, evaluasi, dan pemantauan terpadu agar tim bisa debug dan menguji chain/agen serta melacak kualitas dari waktu ke waktu.
• 2024 — Orkestrasi dengan LangGraph: Untuk mendukung aplikasi multi‑langkah/agen yang berjalan lama, LangGraph memperkenalkan runtime graf dengan state eksplisit, router/cabang, loop, retry, dan checkpointer untuk persistensi. Ini krusial karena meletakkan fondasi bagi agen yang tahan lama dan siap produksi. Pembaruan selanjutnya memperluas kustomisasi dan integrasi dengan berbagai penyedia LLM, termasuk Ollama (model open‑source). 
• 2024–2025 — Pembangunan visual dengan LangFlow. Editor visual LangFlow berkembang pesat (rilis besar hingga akhir 2024 dan Launch Week pada 2025), memungkinkan tim drag‑and‑drop komponen LLM, beriterasi cepat, dan mengekspor flow ke kode. Ini langkah penting karena mulai memungkinkan non‑koder membangun AI Agent yang andal juga.
• 2025 — Menuju platform agen terkelola. LangChain mengumumkan tonggak besar: Functional API untuk LangGraph, templat agen siap pakai, dan Platform LangGraph untuk menerapkan dan mengelola agen stateful dalam skala besar. Ini juga krusial karena memungkinkan kita mengoperasikan agen yang andal di produksi.

Pengantar singkat LangChain dan LangGraph

Sekarang mari kita mulai menyelami ekosistem inti, dimulai dari LangChain dan LangGraph. 

LangChain adalah kerangka modular untuk membangun aplikasi bertenaga LLM. Ia memberi kita blok bangunan — prompt, model, memori, alat, retriever — dan cara sederhana untuk merangkainya menjadi pipeline menggunakan API Runnable/LCEL (akan kita bahas sebentar lagi). Saya membayangkannya sebagai set balok Lego untuk pola LLM umum seperti RAG, tanya‑jawab, chatbot, dan agen pengguna alat. 

LangGraph lebih baru, merupakan lapisan orkestrasi berbasis graf yang dibangun di atas komponen LangChain. Alih-alih satu garis lurus langkah-langkah, aplikasi dimodelkan sebagai node (aksi) dan edge (transisi), dengan objek state eksplisit yang mengalir melalui graf. Kita akan membahas ini lebih dalam, tetapi untuk saat ini, ingat bahwa desain ini memudahkan untuk bercabang (mengambil jalur berbeda), berulang (bertanya klarifikasi hingga yakin), retry (pada error alat/model), dan jeda untuk tinjauan manusia; persis yang kita butuhkan untuk agen yang berjalan lama dan kelas produksi.

Sekarang mungkin Anda bertanya:

“Mengapa perlu dibandingkan?”

Begini: meski berbagi komponen, keduanya menyasar tingkat kompleksitas yang berbeda:

• LangChain unggul untuk alur kerja cepat dan linear. Contoh: Muat PDF → pecah → embed → retrieve → jawab. Anda bisa membuat prototipe ini dalam hitungan menit.
• LangGraph unggul saat logika harus adaptif. Contoh: Jika confidence < 0,7 → ajukan pertanyaan klarifikasi (loop); jika pembayaran gagal → retry dengan backoff; jika permintaan berisiko → jeda untuk manusia. Perilaku ini adalah warga kelas satu dalam graf.

Dalam praktiknya, banyak pengembang mulai dengan LangChain untuk memvalidasi ide, lalu meningkatkan ke LangGraph saat mereka menambahkan percabangan, penanganan error, koordinasi multi‑agen, atau daya tahan.

Apa itu LangChain?

Sekarang, kita akan membahas LangChain secara mendalam, memahami penggunaannya, dan menulis aplikasi dengannya. Perlu dicatat lagi bahwa LangChain adalah pustaka yang memungkinkan kita membangun fondasi untuk alur kerja LLM berurutan. 

LCEL

Untuk mulai, saya ingin menjelaskan apa itu LCEL. LCEL atau LangChain Expression Language hanyalah cara untuk menyambungkan blok dengan pipa (|). Setiap blok bisa berupa prompt, model, retriever, atau parser. Saat kita menggabungkannya, kita mendapatkan chain yang bisa dijalankan berulang kali, membuat penulisan kode jauh lebih efisien. 

Mari lihat beberapa contoh.

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

llm    = ChatOpenAI(model="gpt-4o-mini")
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are concise."),
    ("human", "{question}")
])
chain = prompt | llm | StrOutputParser() # This is our chain

print(chain.invoke({"question": "Give me 3 focus tips."}))     # making a single call

qs = [{"question": q} for q in ["One tactic for RAG?", "Explain LCEL in 1 line."]]
print(chain.batch(qs))                                         # many calls at onceDidukung oleh

Menurut saya, kode di atas menunjukkan cara paling sederhana menggunakan LCEL. Kita terlebih dahulu membuat templat prompt yang selalu menyertakan pesan sistem (“you are concise”) dan menyisakan tempat untuk pertanyaan manusia. Pesan sistem seperti instruksi ke LLM yang mengarahkannya merespons/bertindak dengan cara tertentu. Lalu kita hubungkan templat ini ke model OpenAI — GPT‑4o‑mini. 

Terakhir, saya menambahkan output parser, yang pada dasarnya mengonversi respons menjadi teks biasa.

Bagian terpentingnya: Operator | adalah perekat yang menyatukan blok-blok ini menjadi satu pipeline.

Saya juga ingin membahas invoke() dan batch(). Saat kita memanggil chain.invoke(...), pipeline berjalan sekali: templat mengisi pertanyaan, model menghasilkan jawaban, dan parser mengembalikan teks yang rapi. 

Namun, saat kita memanggil chain.batch(...), chain yang sama berjalan pada banyak input sekaligus, yang jauh lebih cepat daripada melakukannya satu per satu. Dalam praktiknya, ini memudahkan beralih dari satu panggilan sederhana ke menangani seluruh dataset hampir tanpa kode tambahan. 

Saya ingin menampilkan contoh lain di sini:

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

stream_chain = (ChatPromptTemplate.from_template("{topic}")  | ChatOpenAI(model="gpt-4o-mini")  | StrOutputParser())

# Simple stream
for chunk in stream_chain.stream({"topic": "Explain PID in 2 lines"}):
    print(chunk, end="")Didukung oleh

Kode ini mirip dengan yang pertama, tetapi alih-alih hanya sekali panggil, kita menggunakan streaming. Dengan .stream(...), model tidak menunggu sampai seluruh jawaban siap. Sebaliknya, model mengirim potongan teks saat dihasilkan, dan kita mencetaknya secara waktu nyata. 

Inti yang perlu diingat dari subbagian ini adalah bahwa LCEL adalah sistem “pipa dan blok” sederhana yang memungkinkan kita menyatukan prompt, model, alat, dan parser, dan seketika memberi kita sebuah chain yang dapat kita jalankan, batch, atau stream tanpa kode tambahan.

Output terstruktur menggunakan Pydantic

Output terstruktur adalah komponen penting dari agen AI. Artinya, alih-alih memberikan teks panjang yang berantakan, agen memberikan jawaban dalam format jelas seperti JSON, tabel, atau daftar. Ini memudahkan komputer dan manusia untuk membaca, menggunakan, dan menghubungkannya dengan alat lain.

Salah satu kerangka utama yang digunakan industri untuk ini adalah Pydantic.

from pydantic import BaseModel, Field
from typing import List
from langchain_openai import ChatOpenAI

class TaskPlan(BaseModel):
    title: str
    steps: List[str] = Field(..., min_items=3, description="actionable steps")

structured = ChatOpenAI(model="gpt-4o-mini").with_structured_output(TaskPlan)
plan = structured.invoke("Plan a 20-minute deep-work session for AI Agent notes.")
print(plan.model_dump())Didukung oleh

Pada contoh ini, metode .with_structured_output() adalah bagian penting karena memberi tahu LLM untuk mengeluarkan hasil dalam bentuk model Pydantic yang kita buat. Di balik layar, LangChain memastikan jawaban agen kita berupa JSON asli yang sesuai bentuknya, lalu mengubahnya menjadi objek Python yang langsung bisa Anda gunakan. 

Jadi alih-alih teks berantakan, kita mendapatkan sesuatu seperti TaskPlan(title="...", steps=["...", "...", "..."]). Ini sangat berguna saat menggunakan Tools. 

Pemanggilan alat (tool) di LangChain

Alat (tools) penting karena memperluas kemampuan LLM untuk menyelesaikan tugas yang sebelumnya tidak mampu dilakukannya, seperti menelusuri internet. 

Hal yang paling saya sukai dari tools adalah LangChain (dan banyak kerangka agentic lainnya) menyediakan alat siap pakai yang disebut Built-In Tools yang cukup mudah digunakan. Selain itu, kita juga bisa membuat alat kita sendiri dengan menggunakan dekorator @tool, yang memberi tahu LangChain bahwa fungsi ini adalah fungsi khusus. 

from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

@tool
def multiply(a: int, b: int) -> int:
    """This tool multiplies two numbers."""
    return a * b

llm = ChatOpenAI(model="gpt-4o-mini")
llm_tools = llm.bind_tools([multiply])   # exposing the tools to the model

resp = llm_tools.invoke("What is 9*5? If needed, use a tool.")
print(resp.tool_calls or resp.content)   # model may emit a tool call with argumentsDidukung oleh

Pada kode di atas, saya membuat alat yang sangat sederhana, yang menerima dua angka dan mengembalikan hasil perkaliannya. Untuk memberi model internal (dalam contoh ini GPT‑4o‑mini) akses ke alat seperti itu, kita gunakan metode llm.bind_tools() dan menyuplai daftar alat, mengekspos alat ke model. 

Memori percakapan

Memori juga sangat penting saat membangun agen AI. Agen AI dengan memori dapat mengingat hal-hal dari percakapan sebelumnya, seperti apa yang kita tanya, preferensi kita, atau apa yang berhasil/tidak berhasil. Tanpa memori, setiap kali terasa seperti bertemu orang baru — kita harus mengulang konteks dasar berulang-ulang, yang cukup merepotkan. 

Di LangChain, memori berarti menyimpan pesan atau fakta masa lalu dalam sebuah store (di memori, basis data, atau vector store). Lalu saat agen berjalan lagi, ia bisa menarik memori itu agar respons terasa konsisten dan lebih cerdas.

Ada dua jenis utama: memori jangka pendek (pesan terbaru dalam obrolan yang sama) dan memori jangka panjang (fakta atau preferensi yang diingat di banyak sesi). Perhatikan bahwa sesi adalah satu percakapan atau jendela interaksi, tempat agen kita melacak apa yang telah dikatakan hingga berakhir.

Memori jangka pendek menjaga konteks selama satu percakapan, sedangkan jangka panjang membuat agen terasa lebih personal dan membantu seiring waktu.

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

prompt = ChatPromptTemplate.from_messages([
    ("system", "Be brief"),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])
chain = prompt | ChatOpenAI(model="gpt-4o")

store = {}  # session_id -> history
def get_history(session_id: str):
    if session_id not in store:
        store[session_id] = InMemoryChatMessageHistory()
    return store[session_id]

with_history = RunnableWithMessageHistory(
    chain,
    lambda cfg: get_history(cfg["configurable"]["session_id"]),
    input_messages_key="input",
    history_messages_key="history",
)

cfg = {"configurable": {"session_id": "u1"}}
print(with_history.invoke({"input": "My name is Vaibhav."}, config=cfg))
print(with_history.invoke({"input": "What is my name?"}, config=cfg))Didukung oleh

Pada contoh di atas, kode terlebih dahulu membuat chat chain yang dapat mengingat pesan sebelumnya dalam satu sesi. Prompt memiliki placeholder riwayat, dan RunnableWithMessageHistory secara otomatis mengisinya dengan percakapan yang tepat setiap kali. Store menyimpan riwayat untuk sesi yang berbeda. 

Perlu dicatat, kita harus menggunakan memori dengan hati-hati. Kita perlu memutuskan dan menulis kode tentang apa yang layak disimpan, kapan menyimpannya, dan seberapa banyak yang dikembalikan ke prompt. Terlalu banyak memori bisa memperlambat atau melampaui batas, tetapi keseimbangan yang tepat membuat agen jauh lebih berguna.

Apa itu LangGraph?

Sekarang kita beralih ke kerangka agentic lainnya — LangGraph. 

Untuk menjelaskan LangGraph secara sederhana, saya akan menggunakan analogi: Analogi Bagan Alir Ransel. 

Kita bisa menganggap LangGraph sebagai sebuah bagan alir kecil untuk aplikasi AI kita. Setiap kotak (disebut node) hanyalah fungsi Python kecil yang melakukan satu tugas. Panah (edge) menunjukkan kotak mana yang berjalan berikutnya. Sebuah ransel kecil berisi data (“state”) bergerak melalui bagan alir, sehingga setiap node dapat membacanya dan menambahkannya. Misalnya, dalam aplikasi chat, ranselnya biasanya adalah daftar pesan yang berjalan.

Graf dasar

Ini akan lebih masuk akal jika kita menelusuri contoh bersama: 

pip install langgraph langchain-openaiDidukung oleh

from typing import TypedDict, Annotated, List
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

# This is the backpack that moves through the graph.
class State(TypedDict):
	# To add messages to the state
    messages: Annotated[List, add_messages]

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

# This is a node that asks the model and adds the reply to the backpack.
def model_node(state: State):
    reply = llm.invoke(state["messages"])
    return {"messages": [reply]}

# Building the graph
graph = StateGraph(State)
graph.add_node("model", model_node)
graph.add_edge(START, "model")
graph.add_edge("model", END)

# Building and running once
app = graph.compile()

result = app.invoke({"messages": [HumanMessage(content="Explain LangGraph in one sentence.")]} )
print(result["messages"][-1].content)Didukung oleh

Mari kita telusuri kodenya. Di sini, kita membangun aplikasi LangGraph yang paling sederhana. State seperti ransel yang membawa pesan melalui graf. Kita mendefinisikannya dengan State, yang memberi tahu LangGraph untuk selalu menyimpan daftar pesan chat yang berjalan.

Lalu ada node, yang di sini hanya satu fungsi, model_node, yang melihat ke dalam ransel, mengirim pesan ke LLM, dan mengembalikan balasan. LangGraph kemudian otomatis menambahkan balasan ini kembali ke ransel.

Graf itu sendiri adalah bagan alir kecil: START → model → END. Saat kita compile, LangGraph mengubah gambar ini menjadi aplikasi yang bisa dijalankan.

Terakhir, kita menjalankan aplikasi (bukan grafnya — melainkan graf yang sudah dikompilasi) dengan ransel yang sudah berisi pesan manusia.

Untuk membantu pemahaman visual, kita bisa menjalankan kode ini untuk melihat grafnya:

from IPython.display import Image, display
display(Image(app.get_graph().draw_mermaid_png()))Didukung oleh

Perlu dicatat, walau visualisasi dihasilkan, bukan berarti graf akan berjalan! Mungkin ada kesalahan logika yang perlu ditangani terlebih dahulu.

Graf bercabang

Mari melangkah lebih jauh, ke arah Branching, komponen penting (namun mudah) dari sistem agentic yang andal. Ini memberi agen kita lebih banyak kebebasan untuk membuat pilihan, mengubahnya dari alur kerja menjadi sistem agentic.

Berikut kodenya:

from typing import TypedDict, Annotated, List
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessage

# Defining the state
class State(TypedDict):
    messages: Annotated[List, add_messages]

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

def answer_node(state: State):
    # Normal answer using the whole chat history.
    return {"messages": [llm.invoke(state["messages"])]}

def clarify_node(state: State):
    # LLm asking for a short follow-up to get enough detail (clarifying)
    return {"messages": [AIMessage(content="Could you share a bit more so I can be precise?")]}

# Router function
def route(state: State):
    # Look for the latest human message and count words.
    last_human = next((m for m in reversed(state["messages"]) if m.type == "human"), None)
    if not last_human:
        return "clarify"
    words = len(str(last_human.content).split())
    return "answer" if words >= 3 else "clarify"

graph = StateGraph(State)
graph.add_node("answer", answer_node)
graph.add_node("clarify", clarify_node)

# Adding a conditional edge to connect the router function 
graph.add_conditional_edges(START, route, {"answer": "answer", "clarify": "clarify"})
graph.add_edge("answer", END)
graph.add_edge("clarify", END)
app = graph.compile() # Compiling the graphDidukung oleh

Sebagian besar mirip dengan agen pertama, kecuali edge bersyarat. Ini memungkinkan kita memberi sistem rute berbeda berdasarkan penilaian LLM. Secara visual, sistemnya tampak seperti ini:

Dengan kekuatan edge bersyarat, kita sudah bisa membangun sistem agentic yang cukup andal dengan pengetahuan saat ini. Jika Anda ingin tutorial yang lebih komprehensif, saya sarankan menonton video tutorial LangGraph.

Baru-baru ini, ada tambahan baru pada LangGraph bernama LangGraph Studio, dan saya sangat merekomendasikan panduan LangGraph Studio ini.

Apa itu LangFlow?

Walaupun LangChain dan LangGraph adalah dua pustaka yang paling sering dipakai pengembang dalam keluarga Lang, saya rasa tetap layak membahas singkat LangFlow. 

Anggap LangFlow sebagai kanvas drag‑and‑drop untuk aplikasi LLM. Setiap node = satu langkah (prompt, model, tool, retriever, basis data vektor, operasi berkas, dll.). Kita menyambungkan node menjadi sebuah flow, lalu menjalankannya, mengekspornya, atau menerapkannya. Ini sangat bagus untuk iterasi cepat dan kolaborasi dengan non‑koder serta mengubah ide menjadi agen yang berfungsi dengan cepat. 

Memang, ini tidak setangguh LangGraph dan LangChain untuk membangun agen; namun, ada beberapa alasan untuk menggunakannya:

• Builder visual untuk membuat sketsa flow dengan cepat
• Memberi non‑koder kemampuan membuat sistem agentic
• Berjalan di mana saja: web, dan kini LangFlow Desktop untuk pengembangan lokal
• Ekspor/impor flow sebagai JSON dan untuk serving sebagai API
• Sangat baik untuk pengajaran, lokakarya, dan prototipe cepat tanpa banyak kode

• Ekspor ke kode: serahkan ke engineer saat sudah stabil.

Saya akan berasumsi Anda adalah non‑koder; jadi, gunakan LangFlow saat menjelajah opsi arsitektur (varian RAG, penggunaan alat, dll.) dan ingin membandingkan dengan cepat atau perlu mengomunikasikan desain secara visual kepada pemangku kepentingan.

Untuk mempelajari lebih lanjut tentang LangFlow dan menyelesaikan proyek seperti membangun Tutor, saya sangat merekomendasikan panduan LangFlow dengan proyek demo. 

Apa itu LangSmith?

Pustaka terakhir yang ingin saya bahas adalah LangSmith. LangSmith adalah lapisan observabilitas + evaluasi untuk aplikasi LLM. Ia menyediakan tracing (pada dasarnya memungkinkan kita melihat setiap langkah, panggilan alat, token, error), evaluasi (dataset, penilaian otomatis & human‑in‑the‑loop) serta pemantauan/peringatan (melacak drift, regresi). Contoh trace di LangSmith dapat dilihat di bawah: 

Ada banyak alasan mengapa pengembang menggunakan LangSmith:

1. Melacak chain/agen kompleks end‑to‑end (input, output, latensi, error)
2. Mengevaluasi perubahan dengan aman menggunakan dataset + penilai otomatis/manusia
3. Memantau trafik live; menangkap regresi; membandingkan versi
4. Plug‑and‑play dengan LangChain/LangGraph
5. Agnostik kerangka, artinya LangSmith dapat digunakan dengan LangChain, LangGraph, atau tumpukan yang sama sekali berbeda. 
6. Dapat digunakan pada tumpukan bahasa apa pun — JavaScript, TypeScript, Python

Untuk informasi lebih lanjut tentang LangSmith, saya sangat merekomendasikan pengantar LangSmith yang mendetail dan tutorial LangSmith Agent Builder.

LangChain vs LangGraph vs LangSmith vs LangFlow 

Di bagian ini saya ingin membandingkan keempat pustaka ini agar Anda benar-benar paham apa mereka dan kapan menggunakannya.

Apa mereka

• LangChain: Untuk membangun aplikasi LLM dari potongan modular seperti prompt, model, alat, dan memori.
• LangGraph: Untuk mengorkestrasi alur kerja kompleks, stateful, bercabang/berulang di atas komponen LangChain.
• LangSmith: Untuk mengamati, mengevaluasi, dan menguji aplikasi LLM (ingat, agnostik kerangka).
• LangFlow: Editor visual untuk mendesain dan membuat prototipe flow via drag‑and‑drop.

Komponen utama

• LangChain: Chains, Runnables, LCEL.
• LangGraph: Node, edge, state, router, checkpointer, tools.
• LangSmith: Trace, run, dataset, evaluator, project.
• LangFlow: Kanvas dengan komponen (loader, LLM, retriever, tool) dan koneksi.

Struktur alur kerja

• LangChain: Linear atau DAG, sebagian besar hanya maju.
• LangGraph: Graf penuh dengan siklus, percabangan, loop, jeda.
• LangSmith: Bukan kerangka eksekusi, ia membungkus run Anda untuk logging/evaluasi.
• LangFlow: Graf visual, yang biasanya diekspor ke kode LangChain.

Manajemen state

• LangChain: Sering implisit atau lokal per komponen.
• LangGraph: State sentral dan eksplisit yang dirangkai melalui node. Ini memungkinkan persistensi/checkpointing — artinya kita bisa menyimpan chat dalam memori.
• LangSmith: Menyimpan metadata run, input/output, metrik, dan umpan balik.
• LangFlow: Konfigurasi komponen disimpan dalam flow JSON.

Alur kontrol

• LangChain: Primtif percabangan/retry terbatas.
• LangGraph: Dukungan kelas satu untuk kondisional, retry, human‑in‑the‑loop.
• LangSmith: Tidak ada alur kontrol, hanya menawarkan evaluasi/peringatan.
• LangFlow: Percabangan visual; semantiknya bergantung pada backend ekspor.

Kemudahan penggunaan

• LangChain: API sederhana.
• LangGraph: Kurva belajar lebih terjal.
• LangSmith: Mudah diaktifkan via variabel lingkungan.
• LangFlow: Paling mudah untuk mulai secara visual dan bagus untuk tim/lokakarya terutama non‑koder.

Terbaik untuk

• LangChain: Prototipe, logika linear, aplikasi cepat.
• LangGraph: Aplikasi kompleks yang tangguh, berjalan lama/multi‑agen.
• LangSmith: Observabilitas, debugging, uji regresi, evaluasi A/B.
• LangFlow: Prototipe visual, ulasan pemangku kepentingan, ekspor kode.

Kapan menggunakan yang mana

• Mulai dengan LangChain jika alur kerja Anda linear/prototipe.
• Beralih ke LangGraph jika Anda butuh percabangan, retry, persistensi.
• Lapiskan LangSmith saat menguji/debug atau menuju produksi.
• Gunakan LangFlow untuk lokakarya, non‑koder, atau membuat sketsa arsitektur.

Tabel perbandingan

Pada tabel di bawah, Anda dapat menemukan perbandingan LangChain vs LangGraph vs LangSmith vs LangFlow:

Penutup

Kini kita telah membahas dan membandingkan keempat pustaka ini cukup mendalam, tetapi jelas masih banyak yang perlu dipelajari untuk menjadi AI Engineer tingkat lanjut dengan pustaka‑pustaka ini. Karena itu, saya sangat merekomendasikan kursus seperti RAG Systems with LangChain dan building Agentic Systems with LangChain.