Belajar LangChain - Tools & Function Calling

#Pendahuluan

Di episode 7 kalian memberi agent ingatan lewat chat history dan checkpoints. Ingatan itu masih pasif — agent hanya bicara. Sekarang saatnya agent bertindak. Dengan tools, agent bisa menghitung, memanggil API, membaca database, atau mengubah file. Inilah jembatan dari sekadar chatbot menjadi asisten yang sungguh menyelesaikan pekerjaan.

Episode ini membedah dua hal: definisi tool dengan dekorator @tool, skema parameter, dan docstring; lalu tool calling loop — bagaimana model memilih tool, bagaimana hasilnya dieksekusi dan dikembalikan ke model, plus fitur penanganan error seperti ProviderToolSearchMiddleware, apply_patch bawaan, dan strategi error handling.

#Membuat Tool dengan Dekorator @tool

Cara paling idiomatis mendefinisikan tool adalah dekorator @tool. Fungsi Python biasa yang diberi dekorator otomatis menjadi StructuredTool dengan skema yang diturunkan dari type hint dan docstring.

Tool pertama dengan @tool

from langchain_core.tools import tool
 
@tool
def hitung_umur(tahun_lahir: int, tahun_sekarang: int) -> int:
    """Hitung umur seseorang berdasarkan tahun lahirnya."""
    return tahun_sekarang - tahun_lahir

Cukup satu dekorator. LangChain membaca tipe parameter int, tipe pengembalian int, dan docstring sebagai deskripsi tool. Ketiganya menjadi kontrak yang diterjemahkan ke skema tool untuk model.

#Parameter Schema dan Docstring yang Baik

Kualitas skema tool menentukan kualitas pemilihan tool oleh model. Docstring bukan sekadar dokumentasi — ia adalah satu-satunya petunjuk model tentang kapan tool ini harus dipakai. Deskripsi yang samar menghasilkan pemilihan tool yang salah.

Tool dengan skema dan deskripsi rinci

from langchain_core.tools import tool
 
@tool
def cari_pengguna(nama: str, aktif_saja: bool = False) -> list[dict]:
    """Cari pengguna di database berdasarkan nama.
    Gunakan tool ini ketika user bertanya tentang pengguna.
    Parameter aktif_saja membatasi hasil ke akun yang masih aktif."""
    return [{"nama": nama, "aktif": True}]
 
print(cari_pengguna.name)
print(cari_pengguna.args_schema.schema())

cari_pengguna.args_schema.schema() memperlihatkan skema JSON yang dihasilkan — perhatikan bagaimana docstring dan tipe parameter diterjemahkan menjadi properti description, type, dan default. Semakin eksplisit kalian menulis, semakin akurat model memanggilnya.

#Mengikat Tools ke Model dengan bind_tools

Setelah tool terdefinisi, ikat ke model. bind_tools menambahkan definisi tool ke konteks model sehingga model bisa "meminta" pemanggilan tool dalam responsnya.

Mengikat tools ke model

from langchain_openai import ChatOpenAI
 
model = ChatOpenAI(model="gpt-4o-mini")
model_bertools = model.bind_tools([hitung_umur, cari_pengguna])
 
respons = model_bertools.invoke("Umur orang kelahiran 1990 berapa sekarang?")
print(respons.tool_calls)

respons.tool_calls berisi daftar pemanggilan yang diminta model — nama tool dan argumennya. Pada tahap ini model belum mengeksekusi apa pun; ia baru "mengajukan permintaan". Eksekusi adalah tanggung jawab loop di sisi kalian.

#Tool Calling Loop: Pemilihan, Eksekusi, Feedback

Satu panggilan invoke biasanya tidak cukup. Tool calling adalah loop: model meminta tool, aplikasi mengeksekusi, hasil dikembalikan sebagai pesan ToolMessage, lalu model menilai hasil itu untuk melanjutkan atau menyelesaikan respons. LangGraph mengotomatiskan seluruh siklus ini lewat create_agent.

Loop tool calling otomatis dengan create_agent

from langgraph.prebuilt import create_agent
 
agent = create_agent(model=model, tools=[hitung_umur, cari_pengguna])
respons = agent.invoke({
    "messages": [("human", "Umur orang kelahiran 1990, dan cari user bernama Arman")]
})
for pesan in respons["messages"]:
    print(pesan.type, "->", pesan.content[:60] if pesan.content else pesan.tool_calls)

Jejak respons["messages"] menunjukkan siklus lengkap: HumanMessage masuk, AIMessage berisi dua tool call, dua ToolMessage berisi hasil eksekusi, dan AIMessage final yang merangkum jawaban untuk user. Inilah inti agentic behavior: model tidak hanya bicara, tapi bertindak dan menilai hasil tindakannya.

#Menangani Error Tool

Tool bisa gagal — API down, argumen invalid, atau hasil kosong. Strategi dasarnya: jangan biarkan exception menghancurkan loop. Kembalikan error sebagai hasil tool sehingga model bisa memperbaikinya, misalnya meminta input yang benar.

Tool dengan fallback error

from langchain_core.tools import tool
 
@tool
def bagi(a: float, b: float) -> float:
    """Bagikan a dengan b."""
    try:
        return a / b
    except ZeroDivisionError:
        return float("inf")

Dengan mengembalikan nilai alih-alih melempar exception, model menerima hasil dan bisa memberi tahu user dengan bahasa manusiawi, misalnya "tidak bisa membagi dengan nol". Alternatif lain: beri tool sendiri kemampuan validasi. Untuk error tak terduga, LangGraph meneruskan exception sebagai ToolMessage error sehingga loop bisa menyampaikan konteks kegagalan kepada model.

#ProviderToolSearchMiddleware dan apply_patch

Dua fitur modern di ekosistem 2026 yang wajib kalian kenali. ProviderToolSearchMiddleware membuat tool dicari dan dipanggil melalui provider tool search, berguna saat daftar tool sangat banyak sehingga tidak semua definisi tool perlu dikirim ke model dalam satu request. Sementara apply_patch adalah tool bawaan yang memungkinkan agent mengedit file menggunakan format diff yang ringkas dan terarah, ideal untuk tugas pemrograman.

Memuat apply_patch dan middleware pencarian tool

from langchain_core.tools import apply_patch  # contoh impor, nama bervariasi per rilis
from langgraph.prebuilt import create_agent
 
agent = create_agent(
    model=model,
    tools=[cari_pengguna, apply_patch],
    middleware=[ProviderToolSearchMiddleware(provider="..." )] if False else [],
)

Catatan penting: apply_patch mengurangi konsumsi token dibanding mengirim seluruh file, tapi patch yang tidak valid harus ditangani — model perlu mendapat feedback untuk memperbaiki diff-nya. Detail tata letak kelas persisnya mengikuti versi langchain-core di rilis kalian; verifikasi lewat dokumentasi resmi sebelum dipakai di produksi.

#Penutup

Episode ini mengubah agent kalian dari pembicara menjadi pekerja. Dengan @tool kalian mendefinisikan kemampuan; dengan bind_tools kalian memberitahu model apa yang bisa dipakai; dan dengan create_agent LangGraph menjalankan loop pemilihan-eksekusi-feedback secara otomatis. Error handling, ProviderToolSearchMiddleware, dan apply_patch melengkapi toolkit untuk agent yang andal.

Inti yang harus dibawa pulang:

• @tool mengubah fungsi Python menjadi tool dengan skema otomatis dari type hint dan docstring.
• Docstring berkualitas menentukan akurasi model memilih tool.
• bind_tools menambahkan definisi tool ke model; tool_calls adalah permintaan, bukan eksekusi.
• create_agent menjalankan loop tool calling penuh: pilih, eksekusi, feedback, selesaikan.
• Error tool harus dikembalikan sebagai hasil yang bisa dibaca model, bukan exception yang memutus loop.
• ProviderToolSearchMiddleware dan apply_patch adalah fitur modern untuk tool yang banyak dan editing file yang efisien.

Di episode 9 kita mulai menyentuh data: Document Loaders & Text Splitters — membaca PDF, web, CSV, dan JSON menjadi objek Document, lalu memotongnya menjadi chunks yang siap dipakai untuk RAG. Sampai jumpa!