Belajar LangChain - Deep Agents & Multi-Agent Patterns

#Pendahuluan

Di episode 13 kalian membangun satu agen dengan create_agent, menyusun logikanya sebagai StateGraph, dan menjedanya dengan interrupt. Itu fondasi yang kokoh untuk satu agen. Tapi masalah produksi jarang selesai dengan satu agen: menulis artikel butuh riset lalu penulisan, membangun kode butuh perencanaan lalu implementasi, dan tugas besar lain sering lebih cepat diselesaikan beberapa "ahli" yang bekerja paralel daripada satu pekerja serba bisa yang antre.

Episode 14 memperkenalkan Deep Agents — paket dari ekosistem LangChain yang mengemas pola agent production (riset, implementasi, perencanaan) secara siap pakai. Kita akan membangun dengan create_deep_agent, memecah tugas ke subagent, menjalankannya secara asinkron (non-blocking), menangani input multi-modal (PDF, audio, video), lalu memilih backend dan Harness Profile yang tepat. Pada akhir episode, kalian punya orchestrator yang menugaskan pekerjaan ke subagent dan menggabungkan hasilnya.

#Apa Itu Deep Agents

Deep Agents adalah framework di atas LangGraph yang mengemas dua pola agent paling umum di produksi: research agent (meneliti, mengumpulkan fakta) dan implementation agent (mengeksekusi, menulis, mengubah). Ide besarnya: alih-alih menulis node, edge, dan conditional edges dari nol setiap proyek, kalian memakai constructor yang sudah tahu pola kerjanya, lalu menyesuaikan dengan model, tool, dan subagent.

Paketnya terpisah dari langchain inti, jadi instal dahulu:

pip install deepagents

Mengapa tidak langsung memakai create_agent saja? create_agent memberi kebebasan penuh tapi semua logika graph kalian yang urus. Deep Agents justru membalik arah: pola-pola yang sudah teruji (plan-execute, research-then-write, subagent delegation) sudah dibangun — kalian tinggal menyuntikkan model, tool, dan instruksi. Untuk aplikasi produksi, memulai dari pola siap pakai lalu mengubah yang benar-benar perlu hampir selalu lebih cepat daripada membangun dari nol.

#Membangun Agent dengan create_deep_agent

Constructor utamanya adalah create_deep_agent. Ia menerima model, daftar tool, dan opsional subagent serta backend:

create_deep_agent minimal

from deepagents import create_deep_agent
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
 
model = ChatOpenAI(model="gpt-5.2")
 
@tool
def cari_berita(kueri: str) -> str:
    "Mencari berita terbaru berdasarkan kueri."
    return "Artikel demo: inflasi turun di kuartal kedua"
 
agent = create_deep_agent(model=model, tools=[cari_berita])
 
result = await agent.ainvoke(
    {"messages": [("user", "Riset dan rangkum berita ekonomi pekan ini.")]}
)
print(result["messages"][-1].content)

Antarmukanya mirip create_agent: input berupa dict dengan key messages, dan output adalah daftar pesan yang pesan terakhirnya memuat jawaban. Bedanya, di dalamnya Deep Agents sudah menjalankan siklus plan-execute: merencanakan langkah, memilih tool, mengeksekusi, dan menulis jawaban. Model apa pun yang mendukung tool calling bisa dipakai — cukup ganti ChatOpenAI dengan integrasi provider lain.

#Subagents: Memecah Tugas Antar "Ahli"

Tugas kompleks sering butuh peran berbeda: seorang peneliti yang mencari fakta, lalu seorang penulis yang merangkai artikel. Subagent memungkinkan orkestrator menugaskan pekerjaan ke agen lain dengan instruksi khusus. Dengan create_sub_agent, tiap subagent punya system prompt dan tool sendiri; orkestrator memutuskan kapan menyerahkan tugas dan menyerap hasilnya.

Orkestrator dengan dua subagent

from deepagents import create_sub_agent
 
peneliti = create_sub_agent(
    model=model,
    system_prompt="Kamu peneliti. Kumpulkan fakta dan angka selengkapnya.",
    tools=[cari_berita],
)
 
penulis = create_sub_agent(
    model=model,
    system_prompt="Kamu penulis. Susun artikel ringkas dari bahan yang diberikan.",
    tools=[],
)
 
orchestrator = create_deep_agent(
    model=model,
    tools=[],
    sub_agents=[peneliti, penulis],
)
 
result = orchestrator.invoke({
    "messages": [("user", "Tulis artikel ekonomi sepanjang 2 paragraf.")]
})

Alurnya: orkestrator menerima permintaan, menugaskan riset ke peneliti, menunggu hasil, lalu menugaskan penulisan ke penulis, dan mengembalikan artikel. Tiap subagent memakai model yang sama, tapi system prompt dan tool yang berbeda membuat mereka berperilaku sebagai spesialis. Jumlah subagent bebas — semakin banyak peran, semakin kompleks grafnya, jadi jaga agar tiap peran benar-benar punya tanggung jawab yang berbeda.

#Async Subagents: Menjalankan Tanpa Memblokir

Subagent yang dijalankan berurutan menunggu satu sama lain — peneliti selesai baru penulis mulai. Untuk tugas yang tidak bergantung, ini pemborosan. Deep Agents 0.5+ mendukung subagent asinkron: orkestrator meluncurkan beberapa subagent sekaligus dan menggabungkan hasilnya saat semuanya tiba. Contoh nyata: meneliti "inflasi", "suku bunga", dan "nilai tukar" bisa dijalankan bersamaan karena ketiganya independen.

Cukup pastikan pemanggilan memakai varian async, dan di dalamnya subagent yang independent dijadwalkan paralel:

Menjalankan subagent secara asinkron

async def riset_paralel():
    tasks = [
        peneliti.ainvoke({"messages": [("user", "riset inflasi")]}),
        peneliti.ainvoke({"messages": [("user", "riset suku bunga")]}),
        peneliti.ainvoke({"messages": [("user", "riset nilai tukar")]}),
    ]
    hasil = await asyncio.gather(*tasks)
    return [m["messages"][-1].content for m in hasil]
 
ringkasan = await riset_paralel()

Tiga riset independen berjalan bersamaan, dan total waktu mendekati waktu riset terlama, bukan penjumlahan ketiganya. Latensi turun tanpa mengubah logika — hanya memastikan subagent yang tidak saling bergantung dikirim sebagai tugas paralel. Ini pola kunci untuk throughput aplikasi multi-agent, dan kita akan membahasnya lebih dalam lagi di episode 18 soal performa.

#Tool Multi-Modal: PDF, Audio, dan Video

Agent tidak hanya membaca teks. Tool multi-modal menerima PDF, audio, atau video sebagai input. Dua pola umum: model yang punya kemampuan vision membaca langsung, atau tool khusus yang mengubah media menjadi teks untuk model non-multimodal.

Tool untuk memproses PDF

from langchain_core.tools import tool
 
@tool
def baca_pdf(jalur_file: str) -> str:
    "Mengekstrak teks dari file PDF."
    return ekstrak_teks_pdf(jalur_file)
 
@tool
def transkrip_audio(jalur_file: str) -> str:
    "Mengubah file audio menjadi teks transkripsi."
    return transkripsi_whisper(jalur_file)

baca_pdf memakai pustaka parsing PDF, transkrip_audio memakai model transkripsi seperti Whisper. Untuk video, pola yang umum adalah ekstraksi frame: ambil beberapa frame sebagai gambar lalu kirim ke model yang mendukung vision. Karena hasil semua tool adalah teks, agent bisa merangkum, mencari di dalamnya, atau menjadikannya konteks RAG — media apa pun pada akhirnya dikurangi menjadi teks yang bisa diproses pipeline biasa. Deep Agents memakai pola ini untuk menangani korpus berformat campuran.

#Backends: StateBackend, StoreBackend, dan ContextHubBackend

Deep Agents memisahkan penyimpanan menjadi tiga lapis lewat backend:

• StateBackend — menyimpan state graph per thread (riwayat percakapan dalam satu sesi). Analog dengan checkpointer LangGraph dari episode 7 dan 13.
• StoreBackend — menyimpan memori lintas thread: fakta yang ingin diingat antar percakapan, cache, atau data bersama. Berguna untuk knowledge yang dipakai banyak sesi.
• ContextHubBackend — menyimpan prompt dan konteks sebagai file, dengan pengalaman berbasis LangSmith Hub: prompt dipusatkan di satu tempat sehingga bisa diubah tanpa men-deploy ulang kode.

Mengonfigurasi backend Deep Agents

from deepagents.backends import StateBackend, StoreBackend, ContextHubBackend
 
agent = create_deep_agent(
    model=model,
    tools=[cari_berita],
    state_backend=StateBackend(),
    store_backend=StoreBackend(),
    context_hub_backend=ContextHubBackend(root_dir="./context"),
)

StateBackend dan StoreBackend bawaan memakai penyimpanan in-memory — cukup untuk pengembangan. Di produksi, ganti dengan implementasi persisten: StoreBackend berbasis database untuk memori lintas thread, dan ContextHubBackend menunjuk direktori berisi file prompt. Kunci pemisahannya: state itu per-sesi dan volatile, store itu global dan tahan lama, context hub itu aset prompt yang dikelola sebagai file.

#Harness Profile per Provider

Model dari tiap provider punya parameter default yang berbeda — satu model butuh temperature tertentu, model lain butuh max token berbeda. Harness Profile adalah kumpulan pengaturan model yang sudah di-tuning per provider dan varian model, sehingga kalian tidak perlu mengingat parameter yang tepat:

Memakai Harness Profile untuk model baru

from langchain import profiles
from langchain_anthropic import ChatAnthropic
 
profile = profiles.get_harness_profile("anthropic.claude-opus-5")
model = ChatAnthropic(**profile)
 
agent = create_deep_agent(model=model, tools=[cari_berita])

get_harness_profile menerima nama profil (formatnya nama provider titik nama model, misalnya openai.gpt-5.2) dan mengembalikan kumpulan parameter yang bisa disebarkan langsung ke constructor model dengan operator unpacking. Manfaatnya besar ketika tim memakai banyak model: cukup ganti satu string nama profil, pengaturan yang tepat ikut terpasang. Ini juga cara yang rapi untuk menguji model baru tanpa mengutak-atik parameter satu per satu.

#Penutup

Episode ini menaikkan arsitektur agent dari satu entitas menjadi tim: Deep Agents mengemas pola research dan implementation agent; create_deep_agent merakit orkestrator; subagent memecah tugas ke peran spesialis; subagent asinkron mempercepat tugas independen; tool multi-modal menangani PDF, audio, dan video; backend memisahkan state, store, dan context hub; serta Harness Profile menyatukan konfigurasi antar provider. Kalian sekarang punya peralatan untuk orkestrasi yang serius — lengkap dengan cara menggabungkan hasil banyak agen.

Inti yang harus dibawa pulang:

• Deep Agents mengemas pola agent produksi: research agent, implementation agent, dan delegasi subagent.
• create_sub_agent membentuk peran spesialis; orkestrator menyerahkan tugas dan menyerap hasilnya.
• Subagent asinkron (non-blocking) memangkas latensi tugas independen secara signifikan.
• Tool multi-modal mengubah PDF, audio, dan video menjadi teks agar bisa diproses pipeline biasa.
• StateBackend, StoreBackend, dan ContextHubBackend memisahkan state, memori, dan prompt; Harness Profile menyederhanakan konfigurasi model.

Semakin banyak agen yang kalian koordinasikan, semakin besar pula permukaan serangannya. Di episode 15 kita mengamankannya: Security Best Practices — threat model untuk prompt injection, SSRF melalui tool, eksfiltrasi data, dan tool over-privilege, beserta mitigasinya. Sampai jumpa di sana!