Deep Agents LangChain: Panduan dengan Proyek Demo

Apa Itu Deep Agents?

Deep Agents adalah arsitektur agen tingkat lanjut yang dirancang untuk menangani tugas kompleks dan bertahap yang memerlukan penalaran berkelanjutan, penggunaan tool, dan memori. Tidak seperti agen tradisional yang beroperasi dalam loop singkat atau melakukan panggilan tool sederhana, Deep Agents merencanakan aksinya, mengelola konteks yang terus berkembang, mendelegasikan sub-tugas ke sub-agen khusus, dan mempertahankan state sepanjang interaksi yang panjang. Arsitektur ini sudah mendukung aplikasi dunia nyata seperti Claude Code, Deep Research, dan Manus.

Sumber: LangChain

Berikut adalah karakteristik utama Deep Agents:

• Kemampuan perencanaan: Mampu memecah tugas besar menjadi sub-tugas yang dapat dikelola dan menyesuaikan rencana seiring berjalannya pekerjaan.
• Manajemen konteks: Menyimpan dan merujuk informasi penting sepanjang percakapan panjang dan beberapa langkah.
• Delegasi sub-agen: Deep Agents dapat meluncurkan sub-agen khusus untuk menangani bagian tugas yang terfokus.
• Integrasi sistem berkas: Menyimpan dan mengambil informasi sesuai kebutuhan, sehingga memungkinkan "memori" sesungguhnya melampaui satu giliran percakapan.
• Prompt sistem terperinci: Deep Agents mengikuti alur kerja eksplisit untuk konsistensi dan keandalan dengan instruksi serta contoh yang canggih.

Komponen Inti Deep Agents

Deep Agents mengatasi keterbatasan agen tradisional melalui empat komponen inti:

1. Prompt sistem terperinci

Tidak seperti prompt instruksi sederhana, Deep Agents menggunakan prompt sistem komprehensif sebagai berikut:

DEEP_AGENT_SYSTEM_PROMPT = """
You are an expert research assistant capable of conducting thorough, 
multi-step investigations. Your capabilities include:
PLANNING: Break complex tasks into subtasks using the todo_write tool
RESEARCH: Use internet_search extensively to gather comprehensive information
DELEGATION: Spawn sub-agents for specialized tasks using the call_subagent tool
DOCUMENTATION: Maintain detailed notes using the file system tools
When approaching a complex task:
1. First, create a plan using todo_write
2. Research systematically, saving important findings to files
3. Delegate specialized work to appropriate sub-agents
4. Synthesize findings into a comprehensive response
Examples:
[Detailed few-shot examples follow...]
"""

Prompt ini mengintegrasikan perencanaan, riset, dan delegasi dengan dokumentasi, menggunakan contoh few-shot untuk mengurai tugas kompleks.

2. Alat perencanaan

Alat perencanaan sering kali hanya "no-op" yang membantu agen menata pemikirannya:

@tool
def todo_write(tasks: List[str]) -> str:
    formatted_tasks = "\n".join([f"- {task}" for task in tasks])
    return f"Todo list created:\n{formatted_tasks}"

Alat sederhana ini memberikan rekayasa konteks penting, yang memaksa agen untuk merencanakan dengan semestinya dan menjaga rencana tersebut tetap terlihat sepanjang eksekusi.

3. Sub-agen

Deep Agents dapat memunculkan sub-agen khusus untuk tugas terfokus. Setiap sub-agen dirancang dengan prompt, deskripsi, dan seperangkat tool tersendiri, sehingga memungkinkan pemisahan tanggung jawab dan optimasi mendalam yang spesifik terhadap tugas. Berikut contoh cara Anda mendefinisikan sub-agen dalam alur kerja:

subagents = [
    {
        "name": "research-agent",
        "description": "Conducts deep research on specific topics",
        "prompt": "You are a research specialist. Focus intensively on the given topic...",
        "tools": ["internet_search", "read_file", "write_file"]
    },
    {
        "name": "analysis-agent", 
        "description": "Analyzes data and draws insights",
        "prompt": "You are a data analyst. Examine the provided information...",
        "tools": ["read_file", "write_file"]
    }
]

Pendekatan ini menyediakan karantina konteks, artinya setiap sub-agen mempertahankan konteksnya sendiri dan tidak mencemari memori agen utama. Dengan mengisolasi tugas khusus, Anda dapat memungkinkan:

• Spesialisasi prompt: Setiap agen dapat dioptimalkan untuk fungsinya dengan instruksi dan contoh terarah.
• Manajemen konteks lebih bersih: Konteks agen utama tetap fokus dan tidak terbebani detail yang tidak relevan, sementara sub-agen beroperasi dalam batasannya masing-masing.
• Penalaran modular: Tugas dapat didelegasikan, diparalelkan, atau disempurnakan secara iteratif, memudahkan penskalaan sistem agen ke domain baru.

4. Integrasi sistem berkas

Deep Agents mempertahankan dan berbagi state menggunakan sistem berkas virtual. Alih-alih hanya mengandalkan riwayat percakapan, tool bawaan ini memungkinkan agen mengatur informasi sepanjang alur kerja:

tools = [
    "ls",           # List files
    "read_file",    # Read file contents  
    "write_file",   # Write to file
    "edit_file"     # Edit existing file
]

Sistem berkas virtual ini menawarkan beberapa keunggulan:

• Memori persisten: Agen dapat menyimpan temuan kunci, catatan, atau hasil antara dalam berkas, membuat informasi ini dapat diakses di banyak langkah, bahkan oleh sub-agen.
• Ruang kerja bersama: Beberapa agen (atau sub-agen) dapat berkolaborasi dengan membaca dan menulis ke berkas yang sama, memungkinkan kerja tim dalam satu alur kerja.
• Pengorganisasian informasi: Tugas kompleks dan bertahap menjadi lebih mudah dikelola karena agen dapat membuat, mengategorikan, dan merujuk dokumen atau artefak sesuai kebutuhan.

Demo: Membangun Asisten Lamaran Kerja dengan deepagents LangChain

Saya akan memandu Anda melalui contoh praktis membangun asisten lamaran kerja yang secara otomatis menemukan lowongan relevan dan menghasilkan surat lamaran yang disesuaikan untuk pengguna.

Asisten kita akan:

• Mencari lowongan kerja terkini berdasarkan kriteria yang ditentukan pengguna
• Menyaring dan memberi peringkat pekerjaan menurut kecocokan keterampilan
• Menghasilkan surat lamaran personal untuk setiap peran
• Mengemas semua hasil dalam format yang dapat diunduh untuk pengguna

Langkah 1: Penyiapan awal dan dependensi

Mari mulai dengan instalasi dan penyiapan dasar:

pip install deepagents
pip install tavily-python  
pip install streamlit      
pip install langchain-openai

Setelah terpasang, kita menyiapkan variabel lingkungan:

export OPENAI_API_KEY=sk-projxxxxxxxxxxxxxxxxxxx
export TAVILY_API_KEY=tvly-devxxxxxxxxxxxxxxxxxxx

Untuk demo ini, Anda memerlukan kunci API OpenAI (untuk model GPT-4o mini) dan kunci API Tavily (untuk fungsi pencarian web). Tavily menyediakan lowongan kerja terkini langsung dari web, sementara model OpenAI menangani pemahaman bahasa, penalaran, perencanaan, dan pembuatan konten.

Catatan: Pengguna baru Tavily menerima 1.000 kredit API gratis. Untuk mendapatkan kunci Anda, cukup daftar di https://app.tavily.com.

Terakhir, kita impor pustaka yang diperlukan dan menyiapkan antarmuka Streamlit:

import os
import io
import json
import re
from typing import Literal, Dict, Any, List
import streamlit as st
import pandas as pd
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from tavily import TavilyClient
from deepagents import create_deep_agent

Langkah ini mengimpor semua dependensi yang dibutuhkan untuk aplikasi deep agent kita. Kita menggunakan streamlit untuk antarmuka web, pandas untuk penanganan data, langchain_openai untuk integrasi LLM, dan deepagents untuk kerangka agen.

Langkah 2: Manajemen state sesi

Berikutnya, kita inisialisasi session state Streamlit untuk mempertahankan data antar interaksi pengguna. Ini memastikan aplikasi mengingat berkas yang diunggah, hasil, dan status error saat pengguna berinteraksi dengan antarmuka:

if "jobs_df" not in st.session_state:
    st.session_state.jobs_df = None
if "cover_doc" not in st.session_state:
    st.session_state.cover_doc = None
if "last_error" not in st.session_state:
    st.session_state.last_error = ""
if "raw_final" not in st.session_state:
    st.session_state.raw_final = ""

Penyiapan ini penting untuk pengalaman pengguna yang mulus, memungkinkan kita menyimpan hasil pekerjaan, surat lamaran yang dihasilkan, dan pesan error sepanjang sesi.

Langkah 3: Penyiapan antarmuka pengguna

Kita menggunakan kolom Streamlit untuk menata field input dalam UI untuk unggah resume, jabatan, lokasi, dan keterampilan opsional:

st.set_page_config(page_title="Job Application Assistant", page_icon=" ", layout="wide")
st.title("💼 Job Application Assistant")
c0, c1, c2 = st.columns([2, 1, 1])
with c0:
    uploaded = st.file_uploader("Upload your resume (PDF/DOCX/TXT)", type=["pdf", "docx", "txt"])
with c1:
    target_title = st.text_input("Target title", "Senior Machine Learning Engineer")
with c2:
    target_location = st.text_input("Target location(s)", "Bangalore OR Remote")
skills_hint = st.text_area(
    "Add/override skills (optional)",
    "",
    placeholder="Python, PyTorch, LLMs, RAG, Azure, vLLM, FastAPI",
)

UI ditata dalam kolom untuk tata letak yang lebih baik. Pengguna dapat mengunggah resume dalam berbagai format, menentukan jabatan dan lokasi target, serta menyorot keterampilan tertentu yang ingin ditekankan dalam lamaran.

Langkah 4: Fungsi pembantu pemrosesan berkas

Berikutnya, kita menerapkan pemrosesan berkas yang andal untuk menangani berbagai format resume dan mengekstrak teks darinya.

 import pypdf
 import docx
def extract_text(file) -> str:
    if not file:
        return ""
    name = file.name.lower()
    if name.endswith(".txt"):
        return file.read().decode("utf-8", errors="ignore")
    if name.endswith(".pdf"):
        pdf = pypdf.PdfReader(io.BytesIO(file.read()))
        return "\n".join((p.extract_text() or "") for p in pdf.pages)
    if name.endswith(".docx"):
        d = docx.Document(io.BytesIO(file.read()))
        return "\n".join(p.text for p in d.paragraphs)
    return ""
def md_to_docx(md_text: str) -> bytes:
    doc = docx.Document()
    for raw in md_text.splitlines():
        line = raw.rstrip()
        if not line:
            doc.add_paragraph("")
            continue
        if line.startswith("#"):
            level = min(len(line) - len(line.lstrip("#")), 3)
            doc.add_heading(line.lstrip("#").strip(), level=level)
        elif line.startswith(("- ", "* ")):
            doc.add_paragraph(line[2:].strip(), style="List Bullet")
        else:
            doc.add_paragraph(line)
    bio = io.BytesIO()
    doc.save(bio)
    bio.seek(0)
    return bio.read()

Fungsi pembantu ini menangani kompleksitas ekstraksi teks dari berbagai format berkas (PDF, DOCX, TXT) dan mengonversi keluaran markdown kembali ke format DOCX untuk diunduh. Begini cara kerja masing-masing fungsi:

• Fungsi extract_text() secara otomatis mendeteksi tipe berkas yang diunggah (TXT, PDF, atau DOCX) dan mengekstrak konten menggunakan pustaka yang sesuai, sehingga pengguna tidak perlu mengkhawatirkan format berkas.
• Fungsi md_to_docx() mengambil teks berformat markdown (seperti surat lamaran yang dihasilkan agen) dan mengonversinya menjadi dokumen Word yang rapi dan terstruktur, siap diunduh.

Ini memastikan aplikasi dapat menangani input resume yang beragam secara fleksibel dan menyajikan keluaran profesional apa pun format berkas aslinya.

Langkah 5: Pemrosesan dan ekstraksi data

Berikutnya, kita menerapkan parsing yang andal untuk mengekstrak data pekerjaan dari respons agen.

def normalize_jobs(items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
    normed = []
    for it in items:
        if not isinstance(it, dict):
            continue
        # case-insensitive keys
        lower_map = {str(k).strip().lower(): it[k] for k in it.keys()}
        company = str(lower_map.get("company", "") or "").strip()
        title = str(lower_map.get("title", "") or "").strip()
        location = str(lower_map.get("location", "") or "").strip()
        link = str(lower_map.get("link", "") or "").strip()
        why_fit = str(lower_map.get("why_fit", lower_map.get("good match", "")) or "").strip()
        if not link:
            continue
        normed.append({
            "company": company or "—",
            "title": title or "—",
            "location": location or "—",
            "link": link,
            "Good Match": "Yes" if why_fit else "—",
        })
    return normed[:5]
def extract_jobs_from_text(text: str) -> List[Dict[str, Any]]:
    if not text:
        return []
    pattern = r"<JOBS>\s*(?:```[\w-]*\s*)?(\[.*?\])\s*(?:```)?\s*</JOBS>"
    m = re.search(pattern, text, flags=re.S | re.I)
    if not m:
        return []
    raw = m.group(1).strip().strip("`").strip()
    try:
        obj = json.loads(raw)
        return obj if isinstance(obj, list) else []
    except Exception:
        try:
            salvaged = re.sub(r"(?<!\\)'", '"', raw)
            obj = json.loads(salvaged)
            return obj if isinstance(obj, list) else []
        except Exception:
            st.session_state.last_error = f"JSON parse failed: {raw[:1200]}"
            return []

Mari pahami secara singkat fungsi-fungsi di atas:

• Fungsi extract_jobs_from_text() menggunakan ekspresi reguler untuk mengekstrak array JSON pekerjaan dari keluaran terstruktur agen (di dalam tag <JOBS>...</JOBS>). Parsing cadangan juga disertakan untuk menangani kesalahan kecil model, seperti mengembalikan tanda petik tunggal alih-alih tanda petik ganda pada JSON.
• Kemudian fungsi normalize_jobs() menstandarkan dan membersihkan setiap kamus pekerjaan, seperti kunci tidak peka huruf besar-kecil, field wajib, dan pembersihan spasi, serta membatasi keluaran ke 5 entri teratas.

Langkah 6: Integrasi alat

Inti dari kemampuan riset didukung oleh Tavily. Karena itu, kita mendefinisikan tool pencarian web yang akan digunakan deep agent untuk menemukan daftar pekerjaan terbaru:

TAVILY_KEY = os.environ.get("TAVILY_API_KEY", "")
@tool
def internet_search(
    query: str,
    max_results: int = 5,
    topic: Literal["general", "news", "finance"] = "general",
    include_raw_content: bool = False,
) -> List[Dict[str, Any]]:
    if not TAVILY_KEY:
        raise RuntimeError("TAVILY_API_KEY is not set in the environment.")
    client = TavilyClient(api_key=TAVILY_KEY)
    return client.search(
        query=query,
        max_results=max_results,
        include_raw_content=include_raw_content,
        topic=topic,
    )

Fungsi internet_search() diberi dekorator @tool, sehingga dapat diakses oleh agen dan sub-agen. Fungsi ini kemudian memanggil API Tavily, yang mengembalikan hasil pencarian yang relevan dan terbaru, ideal untuk kueri pekerjaan dinamis dan riset.

Catatan: Anda dapat menambahkan lebih banyak tool dengan cara ini (seperti peringkasan dokumen, eksekusi kode, atau pengayaan data) untuk memperluas kemampuan deep agent Anda.

Langkah 7: Konfigurasi deep agent

Sekarang, kita menyatukan semuanya dengan mengonfigurasi agen utama dan sub-agennya, masing-masing dengan instruksi terarah sebagai berikut:

INSTRUCTIONS = (
    "You are a job application assistant. Do two things:\n"
    "1) Use the web search tool to find exactly 5 CURRENT job postings (matching the user's target title, locations, and skills). "
    "Return them ONLY as JSON in this exact wrapper:\n"
    "<JOBS>\n"
    "[{\"company\":\"...\",\"title\":\"...\",\"location\":\"...\",\"link\":\"https://...\",\"Good Match\":\"one sentence\"}, ... five total]\n"
    "</JOBS>\n"
    "Rules: The list must be valid JSON (no comments), real links to the job page or application page, no duplicates.\n"
    "2) Produce a concise cover letter (≤150 words) for EACH job, with a subject line, appended to cover_letters.md under a heading per job.\n"
    "Do not invent jobs. Prefer reputable sources (company career pages, LinkedIn, Lever, Greenhouse)."
)
JOB_SEARCH_PROMPT = (
    "Search and select 5 real postings that match the user's title, locations, and skills. "
    "Output ONLY this block format (no extra text before/after the wrapper):\n"
    "<JOBS>\n"
    "[{\"company\":\"...\",\"title\":\"...\",\"location\":\"...\",\"link\":\"https://...\",\"Good Match\":\"one sentence\"},"
    " {\"company\":\"...\",\"title\":\"...\",\"location\":\"...\",\"link\":\"https://...\",\"Good Match\":\"one sentence\"},"
    " {\"company\":\"...\",\"title\":\"...\",\"location\":\"...\",\"link\":\"https://...\",\"Good Match\":\"one sentence\"},"
    " {\"company\":\"...\",\"title\":\"...\",\"location\":\"...\",\"link\":\"https://...\",\"Good Match\":\"one sentence\"},"
    " {\"company\":\"...\",\"title\":\"...\",\"location\":\"...\",\"link\":\"https://...\",\"Good Match\":\"one sentence\"}]"
    "\n</JOBS>"
)
COVER_LETTER_PROMPT = (
    "For each job in the found list, write a subject line and a concise cover letter (≤150 words) that ties the user's skills/resume to the role. "
    "Append to cover_letters.md under a heading per job. Keep writing tight and specific."
)
def build_agent():
    api_key = os.environ.get("OPENAI_API_KEY")
    if not api_key:
        st.error("Please set OPENAI_API_KEY in your environment.")
        st.stop()
    llm = ChatOpenAI(model=os.environ.get("OPENAI_MODEL", "gpt-4o-mini"), temperature=0.2)
    tools = [internet_search]
    subagents = [
        {"name": "job-search-agent", "description": "Finds relevant jobs", "prompt": JOB_SEARCH_PROMPT},
        {"name": "cover-letter-writer-agent", "description": "Writes cover letters", "prompt": COVER_LETTER_PROMPT},
    ]
    return create_deep_agent(tools, INSTRUCTIONS, subagents=subagents, model=llm)
def make_task_prompt(resume_text: str, skills_hint: str, title: str, location: str) -> str:
    skills = skills_hint.strip()
    skill_line = f" Prioritize these skills: {skills}." if skills else ""
    return (
        f"Target title: {title}\n"
        f"Target location(s): {location}\n"
        f"{skill_line}\n\n"
        f"RESUME RAW TEXT:\n{resume_text[:8000]}"
    )

Langkah ini menunjukkan kekuatan Deep Agents melalui sub-agen khusus. Instruksi utama memberikan panduan keseluruhan, sementara setiap sub-agen memiliki prompt terfokus untuk tugas spesifik:

• INSTRUCTIONS, JOB_SEARCH_PROMPT, dan COVER_LETTER_PROMPT mendefinisikan prompt sistem utama dan instruksi khusus untuk setiap sub-agen. Ini memastikan agen selalu menghasilkan hasil pekerjaan yang terstruktur baik dan surat lamaran yang disesuaikan dalam format yang diperlukan.
• Fungsi build_agent() memeriksa kunci API OpenAI, menyiapkan model bahasa, dan membuat deep agent dengan sub-agen pencarian pekerjaan dan penulis surat lamaran. Penyiapan modular ini memungkinkan setiap sub-agen fokus pada bagiannya dalam alur kerja.
• Kemudian fungsi make_task_prompt() menghasilkan satu prompt yang menggabungkan resume, keterampilan, jabatan, dan lokasi pengguna. Ini memberi agen semua konteks yang dibutuhkan untuk memulai pencarian dan proses penulisan draf.

Bersama-sama, fungsi-fungsi ini menambah struktur dan spesialisasi dalam alur kerja.

Langkah 8: Logika aplikasi utama

Langkah ini adalah logika inti aplikasi yang menangani input pengguna dan mengorkestrasi deep agent:

resume_text = extract_text(uploaded) if uploaded else ""
run_clicked = st.button("Run", type="primary", disabled=not uploaded)
if run_clicked:
    st.session_state.last_error = ""
    st.session_state.raw_final = ""
    try:
        if not os.environ.get("OPENAI_API_KEY"):
            st.error("OPENAI_API_KEY not set.")
            st.stop()
        if not TAVILY_KEY:
            st.error("TAVILY_API_KEY not set.")
            st.stop()
        agent = build_agent()
       task = make_task_prompt(resume_text, skills_hint, target_title, target_location)
        state = {
            "messages": [{"role": "user", "content": task}],
            "files": {"cover_letters.md": ""},
        }
        with st.spinner("Finding jobs and drafting cover letters..."):
            result = agent.invoke(state)
        final_msgs = result.get("messages", [])
        final_text = (final_msgs[-1].content if final_msgs else "") or ""
        st.session_state.raw_final = final_text
        files = result.get("files", {}) or {}
        cover_md = (files.get("cover_letters.md") or "").strip()
        st.session_state.cover_doc = md_to_docx(cover_md) if cover_md else None
        raw_jobs = extract_jobs_from_text(final_text)
        jobs_list = normalize_jobs(raw_jobs)
        st.session_state.jobs_df = pd.DataFrame(jobs_list) if jobs_list else None
        st.success("Done. Results generated and saved.")
    except Exception as e:
        st.session_state.last_error = str(e)
        st.error(f"Error: {e}")

Kode di atas menangani aksi pengguna, meluncurkan deep agent, dan menampilkan hasil sebagai berikut:

• Saat pengguna mengeklik Run, aplikasi memeriksa ketersediaan kunci API yang diperlukan.
• Aplikasi mengekstrak resume, mengumpulkan input (keterampilan, jabatan, lokasi), dan menyusun prompt tugas.
• Agen dipanggil, dengan memasukkan kueri pengguna dan placeholder berkas untuk surat lamaran.
• Saat agen menyelesaikan alur kerjanya, aplikasi:
• Mengekstrak dan menyimpan surat lamaran yang dihasilkan (dikoversi ke DOCX untuk diunduh)
• Mem-parse, menormalkan, dan menampilkan kecocokan pekerjaan sebagai DataFrame interaktif

Langkah 9: Tampilan hasil dan unduhan

Terakhir, kita sajikan hasil dalam format yang ramah pengguna:

st.header("Jobs")
if st.session_state.jobs_df is None or st.session_state.jobs_df.empty:
    st.write("No jobs to show yet.")
else:
    df = st.session_state.jobs_df.copy()
    def as_link(u: str) -> str:
        u = u if isinstance(u, str) else ""
        return f'<a href="{u}" target="_blank">Apply</a>' if u else "—"
    if "link" in df.columns:
        df["link"] = df["link"].apply(as_link)
    cols = [c for c in ["company", "title", "location", "link", "Good Match"] if c in df.columns]
    df = df[cols]
    st.write(df.to_html(escape=False, index=False), unsafe_allow_html=True)
st.header("Download")
if st.session_state.cover_doc:
    st.download_button(
        "Download cover_letters.docx",
        data=st.session_state.cover_doc,
        file_name="cover_letters.docx",
      mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
        key="dl_cover_letters",
    )
else:
    st.caption("Cover letters not produced yet.")

Setelah agen selesai, kita sajikan hasil dalam tata letak yang rapi, yaitu:

• Aplikasi menampilkan kecocokan pekerjaan dalam tabel, dengan tautan Apply yang dapat diklik untuk setiap posisi.
• Jika surat lamaran tersedia, tombol unduh memungkinkan pengguna menyimpannya sebagai dokumen Word.

Ini mengubah alur kerja AI bertahap menjadi pengalaman sekali klik yang sederhana.

Untuk meluncurkan aplikasi, cukup jalankan:

streamlit app.py

Kesimpulan

Deep Agents merepresentasikan evolusi signifikan dalam arsitektur agen, melampaui sekadar pemanggilan tool menuju sistem canggih yang mampu merencanakan, mendelegasikan, dan mengeksekusi tugas kompleks secara berkelanjutan. Paket deepagents membuat arsitektur ini dapat diakses, memungkinkan pengembang membangun agen siap produksi untuk riset, pengodean, analisis, dan domain khusus.

Seiring agen AI menjadi esensial dalam bisnis dan riset, arsitektur deep agent menyediakan struktur dan fleksibilitas yang dibutuhkan untuk dampak nyata. Saya juga merekomendasikan untuk melihat tutorial LangSmith Agent Builder jika Anda mencari solusi tanpa kode.