Membuat LLM Anda Interaktif: Panduan Tool Calling (Function Calling) untuk Aplikasi Web

Pernahkah Anda berinterinteraksi dengan Large Language Model (LLM) seperti ChatGPT atau Gemini dan merasa takjub dengan kemampuannya memahami bahasa alami? LLM memang luar biasa dalam menghasilkan teks, menjawab pertanyaan, dan bahkan menulis kode. Namun, ada satu keterbatasan fundamental: LLM itu “terisolasi”. Ia hidup di dunia teks dan tidak bisa secara langsung berinterinteraksi dengan sistem eksternal, mengambil data real-time, atau melakukan tindakan nyata.

Bayangkan Anda ingin membangun asisten AI di aplikasi web yang bisa:

Mencari harga saham terkini.
Mengirim email atas nama pengguna.
Memesan tiket penerbangan.
Mengakses database produk internal.

LLM biasa tidak bisa melakukan ini. Ia tidak punya “tangan” untuk berinteraksi dengan dunia luar. Di sinilah Tool Calling (sering juga disebut Function Calling) masuk sebagai jembatan yang revolusioner.

Dalam artikel ini, kita akan menyelami konsep Tool Calling, mengapa ini penting untuk aplikasi web AI modern, dan bagaimana Anda bisa mengimplementasikannya untuk membuat LLM Anda lebih interaktif, relevan, dan actionable. Mari kita buka potensi penuh LLM Anda! 🚀

1. Pendahuluan: Mengapa LLM Butuh “Tangan”?

LLM adalah “otak” yang brilian. Ia bisa memproses informasi tekstual, memahami niat, dan menghasilkan respons yang koheren. Namun, ia tidak tahu apa yang terjadi di luar data pelatihannya. Ia tidak punya akses ke internet secara real-time, tidak bisa memanggil API eksternal, dan tidak bisa melakukan tindakan seperti menulis ke database atau mengirim notifikasi.

Ini menciptakan batasan serius bagi developer yang ingin membangun aplikasi AI yang benar-benar berguna. Kita tidak hanya ingin LLM menjawab pertanyaan, kita ingin ia melakukan sesuatu.

Tool Calling adalah solusi elegan untuk masalah ini. Ini adalah mekanisme di mana LLM, berdasarkan input pengguna, bisa merekomendasikan untuk memanggil fungsi atau “tool” eksternal yang telah kita definisikan. LLM akan mengidentifikasi tool yang relevan dan bahkan mengekstrak parameter yang diperlukan untuk memanggil tool tersebut. Aplikasi kita kemudian yang akan mengeksekusi tool tersebut dan mengirim hasilnya kembali ke LLM untuk diproses lebih lanjut dan disintesis menjadi jawaban akhir.

📌 Analogi: Bayangkan LLM Anda adalah seorang CEO yang sangat cerdas. Ia bisa memahami masalah dan merumuskan strategi. Tapi ia tidak akan pergi ke lapangan untuk mencari data atau melakukan pekerjaan operasional. Ia akan mendelegasikan tugas itu kepada “karyawan” (tools/API) yang spesifik. CEO (LLM) akan memberikan instruksi yang jelas (nama fungsi dan parameter), karyawan akan melakukan tugasnya, dan melaporkan hasilnya kembali ke CEO untuk membuat keputusan akhir atau merumuskan laporan.

Dengan Tool Calling, kita bisa mengubah LLM dari sekadar “pustakawan” menjadi “asisten pribadi” yang mampu berinteraksi dengan dunia nyata.

2. Apa Itu Tool Calling (Function Calling)?

Secara sederhana, Tool Calling adalah kemampuan LLM untuk secara cerdas menentukan kapan dan bagaimana memanggil fungsi yang Anda sediakan. Prosesnya biasanya melibatkan langkah-langkah berikut:

Input Pengguna: Pengguna memberikan perintah atau pertanyaan ke aplikasi Anda (misal: “Berapa cuaca di Jakarta hari ini?”).
LLM Menganalisis: Aplikasi Anda mengirimkan input ini ke LLM, beserta daftar “tools” (fungsi) yang bisa dipanggil oleh LLM.
LLM Merekomendasikan Tool: Berdasarkan input pengguna dan deskripsi tools yang Anda berikan, LLM memutuskan apakah ada tool yang relevan. Jika ya, ia akan menghasilkan objek JSON yang berisi nama fungsi yang direkomendasikan dan argumen yang harus digunakan.
Aplikasi Mengeksekusi Tool: Aplikasi Anda menerima rekomendasi dari LLM. Ini bukan LLM yang menjalankan kode, melainkan aplikasi Anda yang membaca rekomendasi tersebut, kemudian menjalankan fungsi yang sesuai di backend Anda (misalnya, memanggil API cuaca eksternal).
Hasil Tool Kembali ke LLM: Hasil dari eksekusi tool (misal: “Cuaca di Jakarta: 28°C, cerah”) dikirimkan kembali ke LLM sebagai bagian dari konteks percakapan.
LLM Merespons Akhir: LLM kemudian menggunakan hasil ini untuk menghasilkan respons yang informatif dan relevan kepada pengguna (misal: “Cuaca di Jakarta hari ini 28°C dan cerah. Ada hal lain yang bisa saya bantu?”).

💡 Penting: LLM tidak memiliki kemampuan eksekusi kode. Ia hanya “memprediksi” fungsi mana yang paling relevan dan parameter apa yang harus digunakan, seperti halnya ia memprediksi kata berikutnya dalam sebuah kalimat. Keamanan dan eksekusi tetap ada di tangan aplikasi Anda.

3. Anatomi Sebuah “Tool” (Fungsi)

Agar LLM bisa “memahami” dan memilih tool yang tepat, kita perlu mendefinisikan setiap tool dengan jelas. Definisi ini biasanya mencakup:

name: Nama unik dari fungsi. Ini akan digunakan oleh LLM untuk mereferensikan fungsi dan oleh aplikasi Anda untuk memanggilnya.
description: Deskripsi singkat dan jelas tentang apa yang fungsi ini lakukan. Ini adalah sangat penting karena LLM akan menggunakan deskripsi ini untuk memutuskan kapan harus memanggil fungsi. Semakin baik deskripsinya, semakin cerdas LLM dalam memilih tool.
parameters: Skema (biasanya dalam format JSON Schema) yang menjelaskan argumen yang diterima oleh fungsi. Ini mencakup nama parameter, tipe data, deskripsi, dan apakah parameter tersebut wajib (required) atau opsional.

Berikut contoh definisi tool untuk mendapatkan informasi cuaca:

{
  "name": "get_current_weather",
  "description": "Mendapatkan informasi cuaca terkini untuk lokasi yang diberikan. Gunakan fungsi ini untuk menjawab pertanyaan tentang cuaca di suatu tempat.",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "Nama kota atau lokasi, e.g. 'Jakarta', 'New York'"
      },
      "unit": {
        "type": "string",
        "enum": ["celsius", "fahrenheit"],
        "description": "Satuan suhu yang diinginkan",
        "default": "celsius"
      }
    },
    "required": ["location"]
  }
}

Dari definisi di atas, LLM akan belajar bahwa jika pengguna bertanya tentang “cuaca di Jakarta”, ia harus merekomendasikan get_current_weather dengan location="Jakarta". Jika pengguna menambahkan “dalam Fahrenheit”, LLM juga akan mengisi parameter unit.

4. Implementasi Tool Calling di Backend (Studi Kasus Python dengan OpenAI API)

Mari kita lihat bagaimana Tool Calling bisa diimplementasikan dalam aplikasi web, khususnya di sisi backend. Kita akan menggunakan Python dan OpenAI API sebagai contoh, namun prinsipnya sama untuk LLM lain atau bahasa pemrograman lain.

Pertama, pastikan Anda sudah menginstal library OpenAI:

pip install openai

import openai
import json
import os

# Set your OpenAI API key
# Pastikan ini diambil dari environment variable, bukan hardcoded!
openai.api_key = os.environ.get("OPENAI_API_KEY")

# --- Langkah 1: Definisikan Tools Anda ---
# Ini adalah fungsi Python yang akan kita 'expose' ke LLM
def get_current_weather(location: str, unit: str = "celsius"):
    """
    Mendapatkan informasi cuaca terkini untuk lokasi yang diberikan.
    Fungsi dummy untuk tujuan demonstrasi.
    """
    if location.lower() == "jakarta":
        if unit == "celsius":
            return {"location": location, "temperature": "28", "unit": "celsius", "forecast": "Cerah"}
        else:
            return {"location": location, "temperature": "82.4", "unit": "fahrenheit", "forecast": "Cerah"}
    elif location.lower() == "bandung":
        return {"location": location, "temperature": "22", "unit": "celsius", "forecast": "Berawan"}
    else:
        return {"location": location, "temperature": "N/A", "unit": "unknown", "forecast": "Tidak dapat ditemukan"}

# Definisikan skema JSON untuk tool ini, sesuai dengan format yang diterima OpenAI
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "Mendapatkan informasi cuaca terkini untuk lokasi yang diberikan. Gunakan fungsi ini untuk menjawab pertanyaan tentang cuaca di suatu tempat.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Nama kota atau lokasi, e.g. 'Jakarta', 'New York'"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Satuan suhu yang diinginkan",
                        "default": "celsius"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

# --- Langkah 2 & 3: Panggil LLM dengan Tools dan Proses Respons ---
def run_conversation(user_message: str):
    messages = [{"role": "user", "content": user_message}]

    # Panggil LLM dengan daftar tools yang tersedia
    response = openai.chat.completions.create(
        model="gpt-3.5-turbo-0125", # Atau model lain yang mendukung tool calling
        messages=messages,
        tools=tools,
        tool_choice="auto" # Biarkan LLM memutuskan apakah akan memanggil tool
    )

    response_message = response.choices[0].message
    tool_calls = response_message.tool_calls

    # --- Langkah 4: Eksekusi Tool dan Kirim Hasil Balik ---
    if tool_calls:
        print("💡 LLM merekomendasikan pemanggilan tool.")
        # Tambahkan respons LLM ke pesan percakapan
        messages.append(response_message)
        
        # Iterasi setiap tool call yang direkomendasikan LLM
        for tool_call in tool_calls:
            function_name = tool_call.function.name
            function_args = json.loads(tool_call.function.arguments)
            
            # Panggil fungsi yang sesuai berdasarkan nama
            if function_name == "get_current_weather":
                print(f"   Memanggil fungsi: {function_name} dengan argumen: {function_args}")
                function_response = get_current_weather(
                    location=function_args.get("location"),
                    unit=function_args.get("unit")
                )
                print(f"   Hasil fungsi: {function_response}")
                
                # Tambahkan hasil eksekusi tool kembali ke pesan percakapan
                messages.append(
                    {
                        "tool_call_id": tool_call.id,
                        "role": "tool",
                        "name": function_name,
                        "content": json.dumps(function_response),
                    }
                )
            else:
                # Tangani kasus jika LLM merekomendasikan tool yang tidak dikenal
                messages.append(
                    {
                        "tool_call_id": tool_call.id,
                        "role": "tool",
                        "name": function_name,
                        "content": "Error: Tool tidak ditemukan.",
                    }
                )

        # Panggil LLM lagi dengan hasil eksekusi tool untuk sintesis jawaban akhir
        final_response = openai.chat.completions.create(
            model="gpt-3.5-turbo-0125",
            messages=messages,
        )
        return final_response.choices[0].message.content
    else:
        # Jika LLM tidak merekomendasikan tool, langsung berikan responsnya
        return response_message.content

# --- Contoh Penggunaan ---
print("--- Skenario 1: LLM memanggil tool ---")
print(run_conversation("Berapa cuaca di Jakarta hari ini?"))
# Expected: LLM merekomendasikan get_current_weather, aplikasi memanggil, LLM merespons.

print("\n--- Skenario 2: LLM memanggil tool dengan parameter unit ---")
print(run_conversation("Bagaimana cuaca di Bandung dalam Celsius?"))
# Expected: LLM merekomendasikan get_current_weather dengan unit="celsius".

print("\n--- Skenario 3: LLM tidak memanggil tool ---")
print(run_conversation("Apa ibu kota Indonesia?"))
# Expected: LLM merespons langsung tanpa tool.

Kode di atas menunjukkan alur lengkap Tool Calling:

Mendefinisikan fungsi Python (get_current_weather) dan skema JSON-nya.
Mengirimkan pesan pengguna bersama dengan definisi tools ke OpenAI API.
Menganalisis respons dari OpenAI. Jika ada tool_calls, kita mengekstraksi informasi fungsi dan argumen.
Mengeksekusi fungsi Python yang sesuai dengan argumen yang diberikan.
Mengirimkan hasil eksekusi fungsi kembali ke OpenAI API.
OpenAI API kemudian menghasilkan respons akhir kepada pengguna berdasarkan semua konteks percakapan, termasuk hasil dari tool.

5. Studi Kasus: Membangun Asisten Pemesanan Tiket Sederhana

Mari kita perluas contoh kita untuk asisten pemesanan tiket sederhana. Kita bisa memiliki dua tools: search_flights dan search_hotels.

# Tools definition example (simplified)
tools_booking = [
    {
        "type": "function",
        "function": {
            "name": "search_flights",
            "description": "Mencari penerbangan berdasarkan kota asal, kota tujuan, dan tanggal keberangkatan.",
            "parameters": {
                "type": "object",
                "properties": {
                    "origin": {"type": "string", "description": "Kota asal"},
                    "destination": {"type": "string", "description": "Kota tujuan"},
                    "departure_date": {"type": "string", "description": "Tanggal keberangkatan (YYYY-MM-DD)"}
                },
                "required": ["origin", "destination", "departure_date"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_hotels",
            "description": "Mencari hotel berdasarkan lokasi, tanggal check-in, dan tanggal check-out.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "Lokasi hotel"},
                    "check_in_date": {"type": "string", "description": "Tanggal check-in (YYYY-MM-DD)"},
                    "check_out_date": {"type": "string", "description": "Tanggal check-out (YYYY-MM-DD)"}
                },
                "required": ["location", "check_in_date", "check_out_date"]
            }
        }
    }
]

# Implementasi fungsi dummy
def search_flights(origin, destination, departure_date):
    print(f"Mencari penerbangan dari {origin} ke {destination} pada {departure_date}...")
    return {"flights": [{"flight_number": "GA123", "price": "IDR 1.500.000"}, {"flight_number": "JT456", "price": "IDR 1.200.000"}]}

def search_hotels(location, check_in_date, check_out_date):
    print(f"Mencari hotel di {location} dari {check_in_date} hingga {check_out_date}...")
    return {"hotels": [{"name": "Hotel A", "price_per_night": "IDR 800.000"}, {"name": "Hotel B", "price_per_night": "IDR 1.200.000"}]}

# Fungsi run_conversation akan dimodifikasi untuk memanggil tools_booking
# dan mengeksekusi search_flights/search_hotels
# (logika mirip dengan run_conversation di atas, hanya tools dan fungsi yang berbeda)

# Contoh interaksi:
# Pengguna: "Saya ingin mencari penerbangan dari Surabaya ke Bali tanggal 25 Desember 2024."
# LLM: Merekomenasikan search_flights(origin="Surabaya", destination="Bali", departure_date="2024-12-25")
# Aplikasi: Mengeksekusi search_flights, mendapatkan hasil.
# LLM: "Saya menemukan beberapa penerbangan. Penerbangan GA123 seharga IDR 1.500.000 dan JT456 seharga IDR 1.200.000. Apakah Anda ingin mencari hotel juga?"

# Pengguna: "Ya, di Bali dari tanggal 25 sampai 28."
# LLM: Merekomenasikan search_hotels(location="Bali", check_in_date="2024-12-25", check_out_date="2024-12-28")
# Aplikasi: Mengeksekusi search_hotels, mendapatkan hasil.
# LLM: "Saya menemukan Hotel A seharga IDR 800.000 per malam dan Hotel B seharga IDR 1.200.000 per malam. Apakah ada lagi yang bisa saya bantu?"

Skenario ini menunjukkan bagaimana Tool Calling memungkinkan LLM untuk berinteraksi dalam percakapan multi-turn, mengumpulkan informasi yang hilang, dan memanggil beberapa tool secara berurutan untuk memenuhi kebutuhan pengguna yang kompleks.

6. Tips dan Best Practices untuk Tool Calling

Membangun aplikasi dengan Tool Calling bisa sangat powerful, tetapi ada beberapa hal yang perlu diperhatikan:

Deskripsi Tool yang Jelas dan Detail: ✅ Ini adalah kunci utama agar LLM bisa memilih tool dengan benar. Jangan pelit dalam memberikan deskripsi. Jelaskan kapan tool harus digunakan, apa yang dilakukannya, dan apa saja parameternya.
Validasi Argumen dari LLM: ⚠️ LLM bisa saja “berhalusinasi” atau memberikan argumen yang tidak valid. Selalu validasi argumen yang diterima dari LLM sebelum mengeksekusi fungsi Anda. Gunakan skema JSON atau validasi manual.
Penanganan Error yang Robust: ❌ Apa yang terjadi jika tool Anda gagal dieksekusi (misalnya, API eksternal down)? Pastikan Anda menangani error ini, mencatatnya, dan menginformasikan kembali ke LLM agar LLM bisa memberikan respons yang sesuai kepada pengguna (misal: “Maaf, saya tidak bisa mendapatkan informasi cuaca saat ini.”).
Manajemen State Percakapan: 🎯 Untuk percakapan multi-turn yang kompleks, Anda perlu mengelola riwayat pesan dan hasil tool. Setiap respons LLM dan hasil tool harus ditambahkan ke messages agar LLM memiliki konteks penuh saat membuat keputusan berikutnya.
Keamanan adalah Prioritas: 🔒 Ingat, LLM hanya merekomendasikan panggilan fungsi. Aplikasi Anda yang memiliki kendali penuh atas eksekusi. Jangan pernah membiarkan LLM mengeksekusi kode secara langsung atau memanggil fungsi yang tidak Anda izinkan. Selalu ada lapisan validasi dan otorisasi di aplikasi Anda.
Pertimbangkan Latensi dan Biaya: 💰 Setiap panggilan ke API LLM dan setiap eksekusi tool akan menambah latensi dan potensi biaya. Optimalkan jumlah panggilan dan pastikan tool Anda berjalan efisien.
Gunakan tool_choice secara Bijak: tool_choice="auto" membiarkan LLM memutuskan. Anda bisa memaksa LLM untuk selalu memanggil tool tertentu (tool_choice={"type": "function", "function": {"name": "my_tool"}}) atau tidak pernah memanggil tool (tool_choice="none") jika diperlukan untuk kasus penggunaan spesifik.

Kesimpulan

Tool Calling (Function Calling) adalah salah satu fitur paling transformatif dalam pengembangan aplikasi berbasis LLM. Ini memberdayakan LLM untuk melampaui batasan tekstualnya dan berinteraksi dengan dunia nyata, memungkinkan