Membangun Aplikasi LLM Cerdas dengan Agentic Workflow: Mengintegrasikan Model, Tool, dan Otomasi

1. Pendahuluan

Sejak kemunculan model bahasa besar (Large Language Models - LLM) seperti GPT-3.5, GPT-4, atau Llama, kita telah melihat kemampuan luar biasa mereka dalam memahami dan menghasilkan teks. Banyak aplikasi web modern kini mulai mengintegrasikan LLM untuk tugas-tugas seperti ringkasan, pembuatan konten, atau chatbot sederhana.

Namun, LLM “tradisional” memiliki keterbatasan: mereka hanya bisa merespons berdasarkan pengetahuan yang ada di data latih mereka. Mereka tidak bisa bertindak di dunia nyata, mencari informasi terkini di internet, atau berinteraksi dengan sistem eksternal seperti database atau API. Di sinilah konsep Agentic Workflow masuk.

Agentic Workflow adalah paradigma baru dalam membangun aplikasi AI, di mana LLM tidak hanya merespons, tetapi juga bertindak sebagai “agen” cerdas yang dapat merencanakan, menggunakan tool eksternal, dan beradaptasi untuk mencapai tujuan yang lebih kompleks. Bayangkan sebuah LLM yang bisa mencari jadwal penerbangan terbaru, memesan tiket, atau bahkan mengelola kalender Anda — itu adalah kekuatan agentic workflow.

Artikel ini akan membawa Anda menyelami dunia agentic workflow, menjelaskan komponen-komponennya, dan menunjukkan bagaimana Anda bisa mulai membangun aplikasi LLM yang lebih otonom dan fungsional untuk web Anda.

2. Memahami Konsep Agentic Workflow

Untuk memahami agentic workflow, mari kita gunakan analogi sederhana: seorang manusia dengan kotak peralatan.

Ketika Anda meminta seorang teman (LLM) untuk “mencari tahu cuaca di Jakarta besok”, jika teman Anda hanya memiliki pengetahuan internal, dia mungkin akan memberi tahu cuaca berdasarkan ingatan terakhirnya atau data umum. Tapi, jika teman Anda memiliki “tool” berupa aplikasi cuaca atau kemampuan mencari di internet, dia bisa bertindak: membuka aplikasi, memasukkan “cuaca Jakarta besok”, dan memberi tahu Anda informasi terkini.

Di dunia AI, agentic workflow bekerja dengan cara serupa:

Agent (Agen): Ini adalah “otak” utama, biasanya sebuah LLM, yang bertanggung jawab untuk memahami tujuan, merencanakan langkah-langkah yang diperlukan, dan memutuskan tool mana yang harus digunakan.
Tools (Alat): Ini adalah fungsi atau API eksternal yang dapat diakses oleh agen. Contohnya bisa berupa fungsi untuk mencari di Google, mengambil data dari database, memanggil API cuaca, mengirim email, atau bahkan berinteraksi dengan microservice lain di backend Anda.
Prompting/Planning (Perencanaan): Agen menggunakan prompt khusus yang memandu mereka untuk berpikir langkah demi langkah. Ini melibatkan identifikasi tujuan, memecahnya menjadi sub-tugas, memilih tool yang relevan, dan merencanakan urutan eksekusi.
Observation/Reflection (Observasi & Refleksi): Setelah menggunakan sebuah tool, agen akan “mengamati” hasilnya. Berdasarkan hasil ini, agen dapat merefleksikan apakah langkah yang diambil sudah benar, apakah perlu ada penyesuaian, atau apakah tujuan sudah tercapai. Proses ini memungkinkan agen untuk belajar dan memperbaiki strateginya secara iteratif.

📌 Intinya: Agentic workflow mengubah LLM dari sekadar “penjawab pertanyaan” menjadi “pemecah masalah” yang aktif dan adaptif.

3. Komponen Utama Agentic Workflow

Untuk membangun agentic workflow, kita membutuhkan beberapa komponen kunci yang bekerja sama:

Large Language Model (LLM) sebagai Otak:
- Ini adalah inti dari agen. LLM akan menerima instruksi, menganalisis situasi, dan membuat keputusan tentang tindakan selanjutnya. Pilih LLM yang kuat dalam reasoning (penalaran) dan function calling atau tool use.
- Contoh: OpenAI GPT (GPT-4, GPT-3.5-turbo), Anthropic Claude, atau model open-source seperti Llama 3 yang di-host secara lokal atau di cloud.
Memory (Memori):
- Agen membutuhkan memori untuk mengingat percakapan sebelumnya (short-term memory/context) dan informasi jangka panjang yang relevan (long-term memory).
- Short-term memory: Biasanya dikelola melalui konteks dalam prompt LLM.
- Long-term memory: Seringkali diimplementasikan menggunakan Vector Database yang menyimpan embeddings dari dokumen atau interaksi sebelumnya. Ini penting untuk Retrieval Augmented Generation (RAG) dan memungkinkan agen memiliki pengetahuan di luar data latihnya.
Tools/Functions (Alat/Fungsi):
- Ini adalah jembatan agen ke dunia nyata. Tools adalah fungsi yang dapat dipanggil oleh LLM untuk melakukan tindakan tertentu atau mendapatkan informasi.
- Setiap tool harus memiliki deskripsi yang jelas agar LLM tahu kapan dan bagaimana menggunakannya.
- Contoh:
  - search_web(query: str): Untuk mencari informasi di internet.
  - get_current_weather(city: str): Untuk mendapatkan cuaca terkini.
  - query_database(sql_query: str): Untuk mengambil data dari database internal.
  - send_email(recipient: str, subject: str, body: str): Untuk mengirim email.
  - book_flight(origin: str, destination: str, date: str): Untuk berinteraksi dengan API pemesanan penerbangan.
Orchestrator/Frameworks (Orkestrator/Kerangka Kerja):
- Membangun agentic workflow dari nol bisa jadi rumit. Untungnya, ada banyak kerangka kerja yang membantu mengelola alur kerja ini.
- Contoh populer: LangChain (Python/JavaScript), Semantic Kernel (C#/Python), CrewAI.
- Kerangka kerja ini menyediakan abstraksi untuk mendefinisikan agen, tool, memori, dan mengelola loop eksekusi agentic.

4. Merancang Tools untuk Agen Anda

Merancang tool adalah langkah krusial. Deskripsi tool yang baik akan sangat memengaruhi kemampuan LLM dalam memilih dan menggunakannya secara efektif.

💡 Tips: Deskripsikan tool seolah-olah Anda menjelaskan kepada seorang junior developer yang perlu tahu kapan dan bagaimana memanggil fungsi tersebut, termasuk parameter yang dibutuhkan.

Mari kita buat contoh tool sederhana menggunakan Python. Kita akan membuat tool untuk mencari cuaca.

# weather_tools.py
import requests
import json

def get_current_weather(city: str) -> str:
    """
    Mengambil informasi cuaca terkini untuk kota yang ditentukan.
    Gunakan tool ini ketika pengguna bertanya tentang cuaca di suatu lokasi.

    Args:
        city (str): Nama kota, misalnya 'Jakarta' atau 'London'.

    Returns:
        str: String JSON yang berisi data cuaca seperti suhu, kondisi, dan kelembaban.
             Mengembalikan pesan error jika kota tidak ditemukan atau terjadi masalah API.
    """
    api_key = "YOUR_OPENWEATHERMAP_API_KEY" # Ganti dengan API Key Anda
    base_url = "http://api.openweathermap.org/data/2.5/weather"
    params = {
        "q": city,
        "appid": api_key,
        "units": "metric" # Untuk suhu dalam Celsius
    }
    try:
        response = requests.get(base_url, params=params)
        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
        data = response.json()

        if data.get("cod") == "404":
            return json.dumps({"error": f"Kota '{city}' tidak ditemukan."})

        main = data.get("main", {})
        weather_description = data.get("weather", [{}])[0].get("description", "tidak diketahui")
        temperature = main.get("temp")
        feels_like = main.get("feels_like")
        humidity = main.get("humidity")

        result = {
            "city": city,
            "temperature": f"{temperature}°C",
            "feels_like": f"{feels_like}°C",
            "condition": weather_description,
            "humidity": f"{humidity}%"
        }
        return json.dumps(result, indent=2)
    except requests.exceptions.RequestException as e:
        return json.dumps({"error": f"Gagal mengambil data cuaca: {e}"})
    except Exception as e:
        return json.dumps({"error": f"Terjadi kesalahan internal: {e}"})

# Contoh penggunaan (untuk testing tool secara manual)
if __name__ == "__main__":
    print(get_current_weather("Jakarta"))
    print(get_current_weather("InvalidCityName123"))

⚠️ Penting: Pastikan untuk mengganti "YOUR_OPENWEATHERMAP_API_KEY" dengan API key OpenWeatherMap Anda yang sebenarnya. Anda perlu mendaftar di OpenWeatherMap untuk mendapatkannya.

Tool ini sangat spesifik. Anda bisa membuat tool lain untuk mencari informasi umum (misalnya, menggunakan Google Search API), berinteraksi dengan database, atau memanggil API internal aplikasi web Anda. Kunci adalah setiap tool harus melakukan satu tugas dengan baik dan memiliki deskripsi yang jelas.

5. Membangun Agen Sederhana dengan LangChain

Sekarang kita akan mengintegrasikan tool get_current_weather ke dalam agen menggunakan LangChain, salah satu framework agentic workflow paling populer.

Pertama, pastikan Anda sudah menginstal LangChain dan OpenAI library:

pip install langchain openai requests

Kemudian, buat file Python untuk agen Anda:

# simple_agent.py
import os
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.tools import tool
from langchain_core.prompts import ChatPromptTemplate
from weather_tools import get_current_weather # Import tool yang sudah dibuat

# Konfigurasi API Key OpenAI Anda
# os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"
# Atau set di environment variable sistem Anda

# 1. Definisikan Tools untuk Agen Anda
# Kita akan membungkus fungsi get_current_weather ke dalam LangChain tool
@tool
def current_weather(city: str) -> str:
    """
    Mengambil informasi cuaca terkini untuk kota yang ditentukan.
    Gunakan tool ini ketika pengguna bertanya tentang cuaca di suatu lokasi.

    Args:
        city (str): Nama kota, misalnya 'Jakarta' atau 'London'.

    Returns:
        str: String JSON yang berisi data cuaca seperti suhu, kondisi, dan kelembaban.
             Mengembalikan pesan error jika kota tidak ditemukan atau terjadi masalah API.
    """
    return get_current_weather(city)

# Kita juga bisa menambahkan tool lain, misalnya untuk mencari di web
@tool
def web_search(query: str) -> str:
    """
    Mencari informasi di internet menggunakan mesin pencari.
    Gunakan tool ini untuk pertanyaan tentang informasi umum, berita, atau data terkini yang tidak ada di pengetahuan LLM.

    Args:
        query (str): Query pencarian.

    Returns:
        str: Hasil pencarian dalam bentuk teks.
    """
    # Placeholder: Dalam aplikasi nyata, Anda akan mengintegrasikan dengan Google Search API, Brave Search API, dll.
    print(f"DEBUG: Melakukan pencarian web untuk '{query}'...")
    if "pemilu 2024" in query.lower():
        return "Hasil pencarian untuk pemilu 2024: Pemilu presiden dan legislatif Indonesia diadakan pada 14 Februari 2024."
    return f"Maaf, fungsi pencarian web saat ini hanya placeholder. Tidak dapat mencari '{query}'."

tools = [current_weather, web_search]

# 2. Inisialisasi LLM
# Gunakan model yang mendukung function calling, seperti gpt-3.5-turbo atau gpt-4
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

# 3. Buat Prompt untuk Agen
# Prompt ini akan memandu LLM untuk bertindak sebagai agen
prompt = ChatPromptTemplate.from_messages([
    ("system", "Anda adalah asisten AI yang cerdas dan berguna. Anda memiliki akses ke berbagai tool untuk membantu pengguna. Gunakan tool yang tepat untuk menjawab pertanyaan atau menyelesaikan tugas."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"), # Ini untuk menyimpan pemikiran dan tindakan agen
])

# 4. Buat Agen
agent = create_tool_calling_agent(llm, tools, prompt)

# 5. Buat Agent Executor untuk menjalankan agen
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 6. Jalankan Agen
if __name__ == "__main__":
    print("Selamat datang! Saya adalah asisten AI Anda. Anda bisa bertanya tentang cuaca atau informasi umum.")
    while True:
        user_input = input("\nAnda: ")
        if user_input.lower() in ["exit", "keluar"]:
            print("Sampai jumpa!")
            break
        try:
            response = agent_executor.invoke({"input": user_input})
            print(f"AI: {response['output']}")
        except Exception as e:
            print(f"AI: Maaf, terjadi kesalahan: {e}")

✅ Cara Kerja Kode di Atas:

Definisi Tool: Fungsi get_current_weather dari weather_tools.py dibungkus dengan decorator @tool dari LangChain. Ini memberitahu LangChain bahwa fungsi ini adalah tool yang bisa digunakan LLM. Kita juga menambahkan tool web_search sebagai placeholder.
Inisialisasi LLM: ChatOpenAI diinisialisasi sebagai otak agen. Pastikan OPENAI_API_KEY Anda sudah diatur.
Prompt: Kami membuat ChatPromptTemplate yang memberikan instruksi sistem kepada LLM dan menyediakan tempat untuk input pengguna ({input}) serta “scratchpad” agen ({agent_scratchpad}) di mana LLM akan mencatat pemikiran dan tindakannya.
Pembuatan Agen: Fungsi create_tool_calling_agent menggabungkan LLM, tools, dan prompt untuk membentuk agen yang bisa memanggil tool.
Agent Executor: AgentExecutor adalah mesin yang menjalankan agen. Ia akan berulang kali memanggil LLM, memeriksa apakah LLM ingin menggunakan tool, menjalankan tool tersebut, dan memberikan hasilnya kembali ke LLM. Parameter verbose=True sangat berguna untuk melihat “pemikiran” agen.

Ketika Anda menjalankan kode ini dan bertanya “berapa cuaca di Surabaya sekarang?”, Anda akan melihat agen memutuskan untuk menggunakan tool current_weather, memanggilnya dengan parameter “Surabaya”, dan kemudian merespons berdasarkan hasil dari tool tersebut. Jika Anda bertanya tentang “siapa presiden Indonesia”, agen mungkin akan mencoba web_search (meskipun saat ini hanya placeholder).

6. Studi Kasus: Asisten Pemesanan Tiket Cerdas

Mari kita bayangkan skenario yang lebih kompleks: membangun asisten pemesanan tiket cerdas untuk aplikasi web Anda. Pengguna ingin memesan tiket, tetapi prosesnya melibatkan beberapa langkah dan interaksi dengan API eksternal.

Tujuan Agen: Membantu pengguna memesan tiket penerbangan dari awal hingga konfirmasi.

Potensi Tools yang Dibutuhkan:

get_flight_schedule(origin: str, destination: str, date: str) -> str: Mengambil daftar penerbangan yang tersedia.
check_price(flight_id: str) -> str: Memeriksa harga untuk penerbangan tertentu.
book_flight(flight_id: str, passenger_name: str, email: str) -> str: Melakukan pemesanan tiket.
send_confirmation_email(email: str, booking_details: str) -> str: Mengirim email konfirmasi.

Bagaimana Agen Akan Bekerja (Alur Berpikir):

Pengguna: “Saya ingin terbang dari Jakarta ke Bali besok.”
Agen (LLM):
- Analisis: Pengguna ingin memesan penerbangan. Saya perlu jadwal.
- Tindakan: Panggil get_flight_schedule(origin='Jakarta', destination='Bali', date='besok').
Tool get_flight_schedule: Mengembalikan daftar penerbangan (misal: “Flight ID: FL101, Jam: 08:00, Maskapai: Garuda; Flight ID: FL102, Jam: 14:00, Maskapai: Lion Air”).
Agen (LLM):
- Observasi: Saya punya jadwal.
- Tindakan: Tanyakan kepada pengguna penerbangan mana yang dipilih. “Saya menemukan penerbangan ini: FL101 (08:00 Garuda), FL102 (14:00 Lion Air). Mana yang Anda inginkan?”
Pengguna: “Saya pilih FL101.”
Agen (LLM):
- Analisis: Pengguna memilih penerbangan. Saya perlu harga.
- Tindakan: Panggil check_price(flight_id='FL101').
Tool check_price: Mengembalikan harga (misal: “Harga untuk FL101 adalah Rp 1.500.000”).
Agen (LLM):
- Observasi: Saya punya harga.
- Tindakan: Tanyakan konfirmasi dan detail penumpang. “Harga FL101 adalah Rp 1.500.000. Apakah Anda ingin melanjutkan pemesanan? Jika ya, mohon berikan nama lengkap dan email Anda.”
Pengguna: “Ya, nama saya Budi, email budi@example.com.”
Agen (LLM):
- Analisis: Pengguna mengkonfirmasi dan memberikan detail. Saya bisa memesan.
- Tindakan: Panggil book_flight(flight_id='FL101', passenger_name='Budi', email='budi@example.com').
Tool book_flight: Melakukan pemesanan, mengembalikan konfirmasi booking (misal: “Pemesanan berhasil, Booking ID: ABC123”).
Agen (LLM):
- Observasi: Pemesanan berhasil.
- Tindakan: Informasikan pengguna dan kirim email konfirmasi. “Pemesanan Anda berhasil dengan Booking ID ABC123. Saya akan mengirimkan detail ke budi@example.com.” Lalu panggil send_confirmation_email(email='budi@example.com', booking_details='...').
Pengguna: “Terima kasih!”

❌ Kesalahan Umum: Tanpa agentic workflow, untuk skenario di atas, Anda harus menulis banyak logika if/else dan state machine di backend untuk mengelola setiap langkah interaksi. LLM biasa hanya akan merespons “Maaf, saya tidak bisa memesan tiket.”

✅ Manfaat Agentic Workflow: LLM secara dinamis menentukan langkah-langkah, memilih tool, dan beradaptasi dengan input pengguna, membuat alur kerja kompleks menjadi lebih fleksibel dan intuitif. Ini secara signifikan mengurangi kompleksitas logika yang harus Anda tulis sebagai developer.

Kesimpulan

Agentic Workflow membuka dimensi baru dalam pengembangan aplikasi AI. Dengan memungkinkan LLM untuk berinteraksi dengan tool eksternal dan membuat keputusan otonom, kita dapat membangun aplikasi web yang jauh lebih cerdas, responsif, dan mampu menyelesaikan tugas-tugas di dunia nyata.

Sebagai developer, ini berarti Anda bisa fokus pada mendefinisikan “tool” yang kuat (API dan fungsi backend Anda) dan memberikan tujuan yang jelas kepada agen. Biarkan LLM yang mengurus perencanaan, eksekusi, dan adaptasi. Ini adalah langkah besar menuju otomasi cerdas dan pengalaman pengguna yang lebih mulus.

Meskipun masih ada tantangan dalam hal keandalan dan kontrol, potensi agentic workflow sangat besar. Mulailah bereksperimen dengan framework seperti LangChain atau Semantic Kernel, rancang tool Anda sendiri, dan saksikan bagaimana aplikasi web Anda bertransformasi menjadi entitas yang lebih cerdas dan proaktif.