Apa Itu LangChain? Framework Open Source untuk AI Agent dan Aplikasi LLM

Apa Itu LangChain?

LangChain adalah framework open source, tersedia dalam Python dan JavaScript/TypeScript, yang memberi developer cara standar untuk menghubungkan model bahasa dengan alat, data, dan logika aplikasi. Abstraksi utamanya saat ini adalah agen, yaitu sebuah model yang berjalan dalam sebuah loop, memanggil alat dan menalar tentang hasilnya hingga suatu tugas selesai. Dokumentasi LangChain merangkum ide tersebut dalam formula singkat, "Agen = Model + Harness," di mana harness adalah segala sesuatu di sekitar loop model, termasuk prompt, alat, dan middleware apa pun yang membentuk perilaku. Di sekitar inti tersebut terdapat produk-produk terkait dari perusahaan yang sama, seperti: LangGraph untuk orkestrasi tingkat rendah dan eksekusi yang tahan lama, Deep Agents untuk agen yang lebih otonom dan berjalan lama, dan LangSmith untuk melacak, mengevaluasi, dan menyebarkan agen.

Asal Usul LangChain

Sebuah Proyek Akhir Pekan Sebelum ChatGPT
LangChain dimulai pada Oktober 2022 sebagai proyek Python open source oleh Harrison Chase, yang saat itu merupakan machine learning engineer di perusahaan keamanan AI Robust Intelligence. Proyek ini muncul hanya beberapa minggu sebelum OpenAI merilis ChatGPT, yang ternyata merupakan waktu yang tepat. Ketika dunia tiba-tiba ingin membangun aplikasi berbasis model bahasa, perangkat siap pakai untuk melakukannya sudah ada di GitHub, dan proyek ini menyebar dengan cepat.

Nama tersebut mencerminkan ide awalnya. Aplikasi model bahasa awal membutuhkan beberapa langkah untuk berfungsi, seperti: mengambil pertanyaan pengguna, mencari sesuatu, menggabungkan hasilnya menjadi sebuah perintah, memanggil model, dan memproses respons. LangChain menyediakan blok bangunan untuk menghubungkan langkah-langkah tersebut menjadi sebuah rantai. Ketika model menjadi mampu memutuskan langkah selanjutnya sendiri, proyek ini bergeser ke arah agen, dan abstraksi pun berubah seiring dengan itu.

Dari Proyek ke Perusahaan

Chase ikut mendirikan perusahaan LangChain Inc. bersama Ankush Gola. Pada Oktober 2025, perusahaan mengumumkan putaran pendanaan Seri B senilai $125 juta dengan valuasi $1,25 miliar, dipimpin oleh IVP, dengan partisipasi dari investor yang sudah ada termasuk Sequoia dan Benchmark serta investor baru termasuk CapitalG dan Sapphire Ventures. Pendanaan tersebut mengubah proyek open-source yang terkenal menjadi perusahaan dengan strategi komersial yang jelas, yaitu mempertahankan framework inti sebagai open source, dan membangun platform di sekitarnya untuk masalah yang lebih sulit dalam menjalankan agen di lingkungan produksi.

Tonggak Sejarah 1.0

Bersamaan dengan pendanaan tersebut, LangChain merilis versi utama pertamanya. Pada 22 Oktober 2025, tim merilis LangChain 1.0 dan LangGraph 1.0, yang mereka gambarkan sebagai komitmen terhadap stabilitas, tanpa perubahan yang merusak hingga versi 2.0. LangChain 1.0 menyederhanakan pustaka di sekitar tiga ide, yaitu: cara standar baru untuk membangun agen yang disebut create_agent, representasi standar konten pesan di seluruh penyedia model, dan namespace paket yang jauh lebih kecil. Fitur-fitur yang telah terakumulasi selama bertahun-tahun, seperti banyak implementasi rantai yang lebih lama, dipindahkan ke paket terpisah yang disebut langchain-classic agar paket utama dapat tetap fokus.

Pembersihan ini penting bagi siapa pun yang membaca tutorial lama. Sebagian besar konten LangChain di internet menggambarkan dunia pra-1.0, dengan impor yang berbeda dan pola yang direkomendasikan berbeda. Jika kode yang kita temukan online tidak sesuai dengan dokumentasi saat ini, biasanya itulah alasannya.

Masalah yang Dipecahkan LangChain

Penting untuk menjelaskan secara konkret mengapa framework seperti ini bermanfaat, karena nilainya mudah terlewatkan jika kita hanya membangun prototipe sederhana.

Masalah pertama adalah perbedaan penyedia. Setiap penyedia model memiliki bentuk API, format pesan, dan cara penanganan alat serta output terstruktur yang berbeda. LangChain menawarkan antarmuka model standar sehingga kita dapat beralih model dengan perubahan kode minimal dan menjaga aplikasi kita tetap portabel seiring perkembangan kebutuhan. Di bidang di mana model terbaik untuk pekerjaan tertentu berubah setiap beberapa bulan, portabilitas tersebut merupakan bentuk jaminan.

Masalah kedua adalah penggunaan alat. Agar model dapat bertindak, ia membutuhkan cara untuk memanggil fungsi, menerima hasilnya, dan memutuskan apa yang harus dilakukan selanjutnya. LangChain menyediakan konvensi untuk mendefinisikan alat dan loop siap pakai yang menangani proses bolak-balik, sehingga kita tidak perlu menuliskannya secara manual setiap saat.

Masalah ketiga adalah menghubungkan model dengan data kita sendiri. Retrieval-augmented generation memerlukan pemuatan dokumen, pemisahan, penyematan, penyimpanan vektor, dan pengambilan bagian yang relevan pada saat pertanyaan diajukan. LangChain menyediakan komponen untuk setiap tahap dan integrasi dengan banyak penyimpanan vektor, sehingga kita dapat merakit alur kerja dari bagian-bagian yang telah diuji.

Yang keempat adalah mekanisme produksi yang kurang menarik, seperti: menjaga status antar tahapan, berhenti sejenak untuk persetujuan manusia, memulihkan diri dari kegagalan, mengalirkan hasil parsial ke antarmuka pengguna, menegakkan batasan, dan melihat apa yang terjadi ketika terjadi kesalahan. Hal-hal inilah yang menjadi fokus prototipe sederhana menjadi sistem nyata, dan di sinilah sebagian besar produk baru LangChain berfokus.

Ekosistem LangChain: Bagaimana Bagian-bagiannya Saling Terhubung

LangChain: Framework

LangChain sendiri adalah framework agen. Ia menyediakan abstraksi yang memudahkan untuk memulai dengan agen, seperti: antarmuka standar untuk model, alat, pesan, dan perulangan agen, ditambah middleware untuk menyesuaikan perilaku. Titik masuk utamanya adalah fungsi yang disebut create_agent, yang dalam dokumentasi digambarkan sebagai framework minimal yang sangat dapat dikonfigurasi. Kita menyediakan model, beberapa alat, dan perintah, dan kita dapat menambahkan kemampuan secara bertahap melalui middleware. Ini adalah lapisan yang paling banyak digunakan oleh pendatang baru.

LangGraph: Runtime

LangGraph adalah framework orkestrasi tingkat rendah dan runtime untuk membangun agen yang berjalan lama dan memiliki status. Jika LangChain memberi kita abstraksi yang nyaman, LangGraph memberi kita kontrol yang lebih detail dan infrastruktur produksi: eksekusi yang tahan lama yang mampu bertahan dari kegagalan, streaming, dukungan interaksi manusia, dan persistensi. Agen LangChain dibangun di atas LangGraph, itulah sebabnya mereka mewarisi properti tersebut, tetapi dokumentasinya secara eksplisit menyatakan bahwa kita tidak perlu mengetahui LangGraph untuk menggunakan LangChain, dan kita tidak perlu LangChain untuk menggunakan LangGraph.

Deep Agents: Perangkat Lengkap yang Siap Digunakan

Deep Agents adalah lapisan yang lebih terarah untuk agen yang menangani tugas-tugas kompleks, multi-langkah, dan berjalan lama. Ia dibangun di atas agen LangChain dan menambahkan kemampuan seperti perencanaan dengan daftar tugas, sistem file virtual untuk mengelola konteks, kemampuan untuk membuat subagen, dan kompresi otomatis riwayat percakapan yang panjang. Ia ditawarkan sebagai SDK open source yang dapat kita host sendiri, dan sebagai opsi terkelola yang menjalankan perangkat yang sama di lingkungan produksi tanpa mengharuskan kita mengelola infrastruktur. Kebijakan rilis dalam dokumentasi LangChain menjelaskan bahwa Deep Agents masih dalam tahap pematangan menuju rilis versi 1.0, jadi harapkan antarmuka-antarmuka yang dimilikinya akan lebih banyak berubah dibandingkan dengan pustaka versi 1.0.

LangSmith: Platform

LangSmith adalah platform perusahaan untuk sisi operasional agen. Platform ini melacak permintaan sehingga kita dapat memeriksa panggilan alat, transisi status, dan latensi; mendukung evaluasi output; menyediakan infrastruktur penyebaran untuk agen yang berjalan lama dan memiliki status; dan fitur-fitur yang lebih baru termasuk LangSmith Engine, yang memantau jejak, mendeteksi masalah, dan mengusulkan perbaikan, serta LangSmith Fleet untuk membangun agen tanpa kode. LangSmith dirancang untuk bekerja dengan agen yang dibangun dengan framework apa pun di atas, dan dokumentasi mencatat bahwa platform ini dapat digunakan terlepas dari pilihan kita. Mengaktifkan pelacakan hanya membutuhkan pengaturan variabel lingkungan dan kunci API.

Cara Memahami Stack

Model mental yang bermanfaat berasal dari perbandingan runtime, framework, dan harness dalam dokumentasi itu sendiri. Runtime, seperti LangGraph, menyediakan mesin untuk menjalankan agen secara andal. Framework, seperti LangChain, menyediakan abstraksi dan integrasi yang memudahkan pembangunan agen. Sistem pendukung, seperti Deep Agents, menyediakan alat dan petunjuk yang terarah untuk pekerjaan yang lebih otonom. Setiap sistem memiliki tingkat abstraksi yang berbeda, dan tingkat yang lebih tinggi dibangun di atas tingkat yang lebih rendah. Kita memilih tingkat yang sesuai dengan seberapa banyak kendali atau kemudahan yang kita butuhkan, dan kita dapat menurunkan tingkatnya jika tingkat yang lebih tinggi menghambat pekerjaan kita.

Blok Bangunan Inti LangChain

Model

Antarmuka model adalah fondasinya. LangChain mendukung model obrolan, model penyematan, dan jenis model lainnya dari banyak penyedia, termasuk OpenAI, Anthropic, Google, dan lainnya, ditambah opsi yang dihosting dan lokal seperti AWS Bedrock, Azure OpenAI, Hugging Face, dan Ollama. Model dapat ditentukan dengan string sederhana yang menyebutkan penyedia dan model, dan integrasi khusus penyedia diinstal sebagai paket terpisah. Karena setiap model berada di balik antarmuka yang sama, mengganti satu dengan yang lain biasanya hanya perubahan satu baris.

Pesan dan Blok Konten

Percakapan direpresentasikan sebagai pesan dengan peran seperti pengguna, asisten, dan alat. LangChain 1.0 menambahkan properti content_blocks standar yang memberikan akses terpadu dan bertipe ke fitur model modern di seluruh penyedia. Penyedia yang berbeda mengembalikan hal-hal seperti jejak penalaran, kutipan, dan panggilan alat dalam bentuk yang berbeda, dan blok konten menormalkan perbedaan tersebut sehingga kode aplikasi kita tidak perlu bercabang berdasarkan penyedia. Bidang konten yang lebih lama tetap ada untuk kompatibilitas mundur.

Alat

Alat adalah fungsi yang dapat dipanggil oleh model. Dalam Python, kita dapat mengubah fungsi biasa dengan docstring yang jelas dan petunjuk tipe menjadi alat, dan framework menjelaskannya kepada model sehingga model dapat memutuskan kapan harus menggunakannya. Sebuah alat dapat mencari di web, menanyakan database, mengirim email, atau memanggil API internal. Kualitas nama, deskripsi, dan pesan kesalahan suatu alat sangat memengaruhi seberapa baik agen menggunakannya, poin yang berlaku untuk setiap framework agen.

Agen dan create_agent

Agen adalah kombinasi dari model, alat, prompt, dan middleware opsional, yang dijalankan dalam sebuah loop. Dokumentasi LangChain menunjukkan betapa singkatnya contoh kerja yang dapat dibuat:

from langchain.agents import create_agent
def get_weather(city: str) -> str:
     ""Mendapatkan informasi cuaca untuk kota tertentu."""
     return f"Di {city} selalu cerah!"
agent = create_agent(
     model="claude-sonnet-4-6",
     tools=[get_weather],
     system_prompt="Anda adalah asisten yang membantu",
)
result = agent.invoke(
     {"messages": [{"role": "user", "content": "Bagaimana cuaca di San Francisco?"}]}
)

String model dan paket provider akan berbeda tergantung pada provider yang kita gunakan, dan nama model sering berubah, jadi anggap pengidentifikasi di atas sebagai contoh, bukan rekomendasi. Yang penting adalah bentuknya: definisikan sebuah tool, berikan ke create_agent dengan model dan prompt, dan panggil agent dengan daftar pesan. Di balik antarmuka kecil itu, agen memutuskan apakah akan memanggil alat tersebut, menerima hasilnya, dan melanjutkan hingga dapat menjawab.

Middleware

Middleware dijelaskan dalam catatan rilis sebagai fitur utama dari create_agent. Fitur ini memungkinkan kita untuk menyisipkan diri ke dalam loop agen untuk membentuk perilaku tanpa perlu menulis ulang loop itu sendiri. Dokumentasi mencantumkan middleware bawaan untuk kebutuhan umum, termasuk menyunting informasi identitas pribadi, meringkas percakapan panjang untuk mengelola konteks, dan memerlukan persetujuan manusia sebelum tindakan tertentu, bersama dengan pola seperti percobaan ulang, perutean, pengaman, dan kebijakan alat khusus. Middleware adalah tempat sebagian besar penguatan produksi agen terjadi, dan menjaga logika tersebut tetap modular dan dapat digunakan kembali.

Memori dan Status

Agen membutuhkan memori pada dua skala waktu. Memori jangka pendek menyimpan status percakapan atau tugas saat ini. Memori jangka panjang bertahan di seluruh sesi, sehingga agen dapat mengingat preferensi atau fakta dari interaksi sebelumnya. LangChain dan LangGraph menyediakan mekanisme untuk keduanya. Karena agen LangChain berjalan di LangGraph, mereka juga dapat menyimpan status, yang memungkinkan percakapan atau tugas panjang untuk dilanjutkan setelah gangguan.

Retrieval

Komponen retrieval adalah salah satu komponen tertua dan paling banyak digunakan di LangChain. Pemuat dokumen mengambil konten dari sumber seperti file dan halaman web. Pemisah teks memecah dokumen panjang menjadi beberapa bagian. Model penyematan mengubah bagian-bagian tersebut menjadi vektor. Penyimpanan vektor, seperti Chroma, Pinecone, dan FAISS, menyimpan vektor-vektor tersebut untuk pencarian kesamaan, dan pengambil data mengambil bagian yang paling relevan pada saat kueri. Dokumentasi LangChain menyajikan retrieval-augmented generation sebagai salah satu pola umumnya, bersama dengan agen dengan alat dan sistem multi-agen. Kita dapat menjalankan RAG sebagai pipeline tetap, atau mengekspos pengambilan data sebagai alat yang dipanggil agen ketika memutuskan membutuhkan informasi.

Output Terstruktur dan Streaming

Banyak aplikasi membutuhkan jawaban model dalam struktur yang dapat diprediksi, seperti objek JSON dengan bidang-bidang tertentu, sehingga kode hilir dapat menggunakannya. LangChain mendukung pembuatan output terstruktur, dan rilis 1.0 telah memperbaikinya. Streaming memungkinkan aplikasi untuk menampilkan hasil parsial saat tiba, yang sangat penting untuk antarmuka pengguna yang responsif, dan didukung di seluruh framework dan runtime-nya.

Pola Multi-Agen

Untuk tugas-tugas kompleks, dokumentasi LangChain menjelaskan pola di mana agen utama mendelegasikan tugas kepada subagen atau memanfaatkan keahlian, masing-masing berfokus pada pekerjaan yang lebih sempit dan dengan konteksnya sendiri. Ini membuat agen individual lebih sederhana dan konteksnya lebih bersih. Seperti dalam desain multi-agen apa pun, manfaatnya harus ditimbang terhadap biaya koordinasi tambahan, dan memulai dengan satu agen biasanya lebih bijaksana.

Bagaimana Agen yang Dibangun dengan LangChain Berjalan

Kita memasukkan daftar pesan. Agen mengirimkan percakapan, bersama dengan deskripsi alat yang tersedia, ke model. Model merespons dengan jawaban akhir atau dengan satu atau lebih panggilan alat. Jika ada panggilan alat, framework mengeksekusinya, menambahkan hasilnya ke percakapan sebagai pesan alat, dan mengirimkan percakapan yang diperbarui kembali ke model. Ini berulang hingga model menghasilkan jawaban akhir, dengan middleware yang dapat campur tangan pada titik-titik yang ditentukan, misalnya untuk meringkas riwayat yang terlalu panjang, menyunting data sensitif, atau berhenti sejenak untuk persetujuan manusia.

Karena seluruh siklus berjalan di LangGraph, eksekusi bukanlah panggilan fungsi dalam memori yang rapuh. Status dapat dipertahankan, eksekusi dapat dialirkan, dan manusia dapat memeriksa dan memodifikasi status agen pada titik interupsi sebelum berlanjut. Inilah perbedaan praktis antara skrip prototipe dan agen yang dapat kita jalankan untuk pelanggan.

LangGraph Lebih Mendalam

LangGraph memodelkan aplikasi sebagai grafik. Node adalah langkah-langkah, yang dapat berupa fungsi Python biasa atau panggilan ke model; edge mendefinisikan bagaimana aliran kontrol di antara mereka; dan objek status bersama membawa informasi di sepanjangnya. Contoh minimal dari dokumentasi menunjukkan strukturnya:

from langgraph.graph import StateGraph, MessagesState, START, END
def mock_llm(state: MessagesState):
return {"messages": [{"role": "ai", "content": "hello world"}]}

graph = StateGraph(MessagesState)
graph.add_node(mock_llm)
graph.add_edge(START, "mock_llm")
graph.add_edge("mock_llm", END)
graph = graph.compile()

graph.invoke({"messages": [{"role": "user", "content": "hi!"}]})

Sesederhana apa pun contohnya, contoh ini menunjukkan modelnya: kita mendefinisikan node, menghubungkannya, mengkompilasi graf, dan menjalankannya.

Kekuatan utama LangGraph, menurut dokumentasinya, adalah kemampuannya untuk menggabungkan langkah-langkah deterministik yang dikodekan secara manual dengan langkah-langkah berbasis agen yang digerakkan oleh LLM dalam satu grafik. Hal ini penting karena banyak sistem nyata tidak seharusnya sepenuhnya otonom. Kita mungkin menginginkan urutan tetap yang dapat diaudit untuk langkah-langkah yang sensitif terhadap kepatuhan, langkah berbasis agen untuk tugas penelitian yang fleksibel, dan langkah persetujuan manusia sebelum melakukan sesuatu yang tidak dapat dibatalkan, semuanya dalam satu alur kerja. LangGraph dirancang untuk perpaduan tersebut.

Kemampuan utamanya yang lain adalah yang dibutuhkan sistem produksi. Persistensi memungkinkan agen untuk bertahan dari kegagalan dan melanjutkan dari tempat mereka berhenti. Dukungan interaksi manusia memungkinkan seseorang untuk memeriksa dan memodifikasi status kapan saja. Memori mencakup memori kerja jangka pendek dan memori jangka panjang di seluruh sesi. Streaming memberikan hasil parsial. Integrasi dengan LangSmith memberikan visibilitas ke jalur eksekusi dan transisi status. Desainnya mengambil ide dari Pregel Google dan Apache Beam, dan antarmuka publiknya terinspirasi dari NetworkX.

Dokumentasi tersebut secara jujur ​​menjelaskan komprominya, yaitu LangGraph sangat tingkat rendah dan sepenuhnya berfokus pada orkestrasi, dan tidak mengabstraksi perintah atau arsitektur. Jika kita baru memulai atau menginginkan abstraksi tingkat yang lebih tinggi, disarankan untuk memulai dengan agen LangChain.

Deep Agents: Ketika Tugas Menjadi Panjang dan Rumit

Beberapa tugas tidak cocok dengan siklus pemanggilan alat yang singkat. Meneliti suatu topik di puluhan sumber, mengerjakan codebase yang besar, atau menghasilkan laporan multi-bagian dapat berjalan lama, menghasilkan lebih banyak materi perantara daripada yang muat dalam context window model, dan membutuhkan perencanaan dan delegasi.

Deep Agents mengatasi hal ini dengan serangkaian kemampuan bawaan. Alat perencanaan memungkinkan agen untuk melacak beberapa tugas dengan daftar tugas. Subagen memungkinkan agen untuk mendelegasikan pekerjaan dan menjaga konteks utamanya tetap bersih. Sistem file virtual, pada backend penyimpanan yang dapat dipasang, memberikan tempat untuk menyimpan hasil yang besar alih-alih memasukkannya ke dalam percakapan. Fitur manajemen token meringkas riwayat dan secara otomatis mengeluarkan hasil alat yang besar. Idenya adalah bahwa framework menangani rekayasa konteks atas nama agen, yang merupakan salah satu bagian tersulit dalam membangun agen yang berjalan lama.

Dokumentasi memposisikan Deep Agents untuk agen yang lebih otonom yang menghadapi tugas-tugas kompleks dan non-deterministik, dan menawarkan SDK yang dihosting sendiri dan layanan terkelola. Karena Deep Agents lebih baru daripada pustaka versi 1.0, diperlukan kehati-hatian lebih jika kita membutuhkan stabilitas antarmuka jangka panjang.

LangSmith: Melihat dan Meningkatkan Kinerja Agen Kita

Membangun agen adalah bagian yang mudah. ​​Memahami mengapa agen berperilaku seperti itu, mengukur apakah agen tersebut baik, dan meningkatkannya dari waktu ke waktu adalah bagian yang sulit, dan inilah masalah yang ditargetkan oleh LangSmith.

Karena model bahasa tidak deterministik, input yang sama dapat menghasilkan jalur yang berbeda. Ketika agen gagal, kita perlu melihat jejaknya: panggilan model mana yang terjadi, alat mana yang dipanggil dengan argumen mana, apa yang dikembalikan, berapa lama setiap langkah berlangsung, dan di mana logika salah. LangSmith menangkap jejak ini sehingga kita dapat memeriksa panggilan alat, transisi status, dan latensi di satu tempat, menemukan mode kegagalan, dan mengevaluasi kualitas menggunakan data eksekusi nyata.

Evaluasi adalah pilar lainnya. Kita membangun kumpulan data tugas realistis, menjalankan agen kita terhadapnya, dan memberi skor pada hasilnya, sehingga perubahan pada perintah, alat, atau model dapat dibandingkan secara objektif daripada dinilai berdasarkan firasat. LangSmith juga menyediakan infrastruktur deployment untuk agen yang berjalan lama dan memiliki status, dan fitur Engine yang lebih baru memantau jejak untuk masalah dan dapat mengusulkan perbaikan, termasuk membuka permintaan pull untuk perubahan yang diusulkan.

LangSmith adalah platform komersial perusahaan, sedangkan LangChain, LangGraph, dan Deep Agents SDK adalah library open source. Perbedaan itu penting ketika kita memutuskan apa yang akan diadopsi. Kita dapat membangun di atas library open source tanpa LangSmith, dan kita dapat menggunakan LangSmith dengan agen yang sama sekali tidak dibangun di atas LangChain. Periksa harga dan ketentuan saat ini sebelum bergantung pada layanan yang dihosting, sesuai dengan prinsip umum bahwa apa pun yang kita sewa dapat berubah.

Apa yang Orang Bangun dengan LangChain

Dokumentasi LangChain menyebutkan perusahaan-perusahaan seperti Klarna, Uber, dan J.P. Morgan di antara mereka yang menggunakan LangGraph, dan pengumuman perusahaan tentang rilis 1.0 menyebutkan adopsi oleh Uber, LinkedIn, dan Klarna. Di luar perusahaan-perusahaan tertentu, beberapa kategori aplikasi umum digunakan.

Asisten retrieval-augmented adalah penggunaan klasik, yaitu chatbot dan pengalaman pencarian yang menjawab pertanyaan dari dokumentasi internal, kebijakan, tiket, atau basis pengetahuan, dengan sumber yang dikutip. Agen dukungan pelanggan menggabungkan pencarian dengan alat yang mencari pesanan, memeriksa status akun, dan meneruskan ke manusia. Agen riset dan analisis mencari di web, membaca sumber, membuat catatan, dan mensintesis laporan. Agen data dan operasi melakukan kueri database, menjalankan analisis, dan memicu alur kerja. Agen coding dan produktivitas developer membaca repositori, mengusulkan perubahan, dan menjalankan pengujian. Dan alur kerja bisnis multi-langkah menggabungkan tahapan deterministik dengan tahapan agen, seperti memproses dokumen, mengekstrak data, memvalidasinya, dan mengarahkan pengecualian ke manusia.

Kesamaan dari semua ini adalah kebutuhan untuk menghubungkan model ke data pribadi dan sistem eksternal, dalam sebuah siklus, dengan status dan pengawasan. Itulah ranah yang menjadi fokus LangChain.

Perbandingan LangChain dengan Alternatifnya

LangChain beroperasi di bidang yang ramai, dan dokumentasi resminya sendiri mencantumkan beberapa alternatif. Di antara framework agen, disebutkan Vercel AI SDK, CrewAI, OpenAI Agents SDK, Google Agent Development Kit, dan LlamaIndex. Di antara runtime, disebutkan Temporal dan Inngest bersama LangGraph. Di antara harness, disebutkan Claude Agent SDK dan Manus bersama Deep Agents SDK.

LlamaIndex paling dekat dalam semangat untuk pekerjaan yang banyak melibatkan pengambilan data dan secara historis berfokus pada menghubungkan model ke data kita, dengan alat yang kuat untuk penyerapan, pengindeksan, dan kueri. CrewAI menekankan tim multi-agen berbasis peran. OpenAI Agents SDK, Google ADK, dan Claude Agent SDK berasal dari penyedia model dan terintegrasi paling erat dengan model mereka sendiri, meskipun seringkali dapat digunakan secara lebih luas. Vercel AI SDK populer di aplikasi web TypeScript. Temporal dan Inngest adalah mesin eksekusi tahan lama umum yang dapat berfungsi sebagai runtime untuk agen.

Tidak ada pemenang universal. Jika kita menginginkan rangkaian integrasi terluas dan jalur menuju tumpukan produksi lengkap, LangChain adalah kandidat yang kuat. Jika masalah kita sebagian besar adalah pemasukan dan pengambilan dokumen, library yang berfokus pada pengambilan mungkin lebih cocok. Jika kita berkomitmen pada satu penyedia model dan menginginkan integrasi yang paling ketat, SDK penyedia tersebut layak dipertimbangkan. Dan untuk permintaan sekali pakai, kita mungkin tidak memerlukan framework sama sekali.

Kapan Menggunakan LangChain, dan Kapan Tidak

LangChain cocok digunakan saat kita membangun agen atau aplikasi berbasis pengambilan data yang membutuhkan beberapa hal berikut, seperti: penggunaan alat, koneksi ke data kita sendiri, dukungan untuk beberapa penyedia model, persistensi dan pengawasan manusia, serta kemampuan observasi. LangChain juga cocok digunakan saat tim menginginkan serangkaian konvensi bersama tentang cara membangun agen, karena standardisasi memiliki nilai tersendiri.

LangChain kurang cocok digunakan saat aplikasi kita cukup sederhana sehingga panggilan API langsung sudah cukup, saat kita membutuhkan transparansi dan kontrol penuh atas setiap permintaan dan bersedia menulis sendiri infrastruktur pendukungnya, atau saat kendala kita, seperti jejak deployment yang sangat kecil, tidak sesuai dengan pohon dependensi yang besar. kita juga perlu berhati-hati jika kita kekurangan kapasitas untuk mengikuti perkembangan ekosistem yang cepat, meskipun kebijakan stabilitas 1.0 mengurangi kekhawatiran tersebut.

Pendekatan yang bijaksana untuk proyek baru adalah memulai dari yang kecil. Buat prototipe dengan create_agent, lengkapi dengan pelacakan sejak hari pertama, tulis beberapa kasus evaluasi, dan hanya gunakan LangGraph atau Deep Agents ketika kita menemukan kebutuhan konkret yang tidak dapat dipenuhi oleh lapisan yang lebih sederhana.

Memulai

Memulainya cukup mudah. ​​Instal library dengan pengelola paket Python kita, bersama dengan paket integrasi untuk penyedia model yang akan kita gunakan, dan atur kunci API penyedia tersebut sebagai variabel lingkungan. Panduan memulai cepat dalam dokumentasi menunjukkan polanya, misalnya menginstal langchain bersama dengan tambahan penyedia seperti untuk Anthropic atau OpenAI. Kemudian tulis alat, berikan ke create_agent dengan model dan prompt sistem, dan panggil agen dengan pesan. Developer JavaScript dan TypeScript memiliki fungsi createAgent yang setara dalam paket langchain.

Dari sana, perkembangan alaminya terlihat seperti ini. Pertama, aktifkan pelacakan sehingga kita dapat melihat persis apa yang dilakukan agen. Kedua, tambahkan pengambilan dengan memuat dan membagi dokumen kita, menyematkannya ke dalam penyimpanan vektor, dan memberikan agen alat pengambilan. Ketiga, tambahkan middleware untuk perilaku yang dibutuhkan kasus penggunaan kita, seperti meringkas percakapan panjang atau memerlukan persetujuan sebelum tindakan sensitif. Keempat, tulis kasus evaluasi dari contoh nyata sehingga kita dapat mengubah prompt dan model dengan percaya diri. Kelima, jika alur kerja kita melampaui loop agen bawaan, pindahkan bagian-bagian yang relevan ke LangGraph untuk kontrol eksplisit.

Dua kiat praktis akan menghemat waktu. Tetapkan versi dependensi kita dan baca catatan rilis sebelum melakukan peningkatan, bahkan dengan janji stabilitas 1.0. Dan ketika kita menemukan tutorial, periksa tanggal dan impornya: jika mereka menggunakan "create_react_agent" dari "langgraph.prebuilt" atau mengimpor rantai lama dari paket "langchain" utama, mereka mendahului versi 1.0, dan padanan saat ini adalah "create_agent" dan paket "langchain-classic" untuk fungsionalitas lama.

Jika kita memigrasikan proyek lama, LangChain menyediakan panduan migrasi untuk pindah ke versi 1.0. Pola "config["configurable"]" lama masih berfungsi untuk kompatibilitas mundur, meskipun parameter konteks yang lebih baru direkomendasikan untuk aplikasi baru.


Jadi, LangChain paling baik dipahami sebagai perangkat untuk rekayasa seputar model bahasa. Ia memberi kita antarmuka model standar, yaitu cara cepat untuk membangun agen yang menggunakan alat, komponen untuk menghubungkan model ke data kita, middleware untuk membentuk perilaku, runtime di LangGraph untuk pekerjaan jangka panjang yang andal, framework di Deep Agents untuk tugas yang lebih otonom, dan platform di LangSmith untuk melihat dan meningkatkan apa yang dilakukan sistem kita.