Bab 15: Build AI Agent¶

Chatbot menjawab. Agent menyelesaikan. Bedanya: agent bisa pakai tools, ambil decision, dan loop sampai task tercapai.

Bab terakhir. Kita gabung semua yang sudah dipelajari untuk build AI yang bisa beraksi mandiri.

Setelah Bab 15, kamu akan bisa:

Memahami komponen agent
Build agent simple dengan tools
Tahu kapan agent worth dibangun vs simple LLM call cukup

15.1. Apa itu Agent?¶

Agent = LLM + memory + tools + loop control.

flowchart TB
    User[User Goal]
    Plan[Planner:<br/>'Apa langkah-langkahnya?']
    Memory[(Memory:<br/>chat history,<br/>scratchpad)]
    Loop{Loop:<br/>masih ada<br/>step?}
    Tool[Pakai Tool:<br/>search, calc,<br/>email, dll]
    Result[Tool Result]
    Decide{Goal<br/>tercapai?}
    Final[Final Answer]

    User --> Plan
    Plan --> Memory
    Memory --> Loop
    Loop -- Ya --> Tool
    Tool --> Result
    Result --> Memory
    Result --> Decide
    Decide -- Belum --> Loop
    Decide -- Tercapai --> Final

    style User fill:#1a1a1a,stroke:#6366f1,color:#fafafa
    style Plan fill:#1a1a1a,stroke:#f59e0b,color:#fafafa
    style Memory fill:#1a1a1a,stroke:#06b6d4,color:#fafafa
    style Loop fill:#1a1a1a,stroke:#f59e0b,color:#fafafa
    style Tool fill:#1a1a1a,stroke:#ec4899,color:#fafafa
    style Result fill:#1a1a1a,stroke:#10b981,color:#fafafa
    style Decide fill:#1a1a1a,stroke:#f59e0b,color:#fafafa
    style Final fill:#1a1a1a,stroke:#10b981,color:#fafafa

Cara baca diagram

Diagram ini menunjukkan arsitektur agent yang sebenarnya cuma kombinasi konsep yang sudah kita pelajari:

Planner = CoT atau ToT (Bab 6, 8)
Memory = scratchpad konteks
Tools = ReAct pattern (Bab 9)
Loop control = decision logic (kapan stop)

Cara kerja:

User kasih goal (bukan task spesifik)
Planner pecah jadi steps
Loop mulai: tiap iterasi pilih next action
Tool call dengan params yang dibutuhkan
Result masuk memory sebagai konteks
Decide: cukup info untuk jawab goal? Kalau belum, loop lagi. Kalau cukup, kasih final answer

Contoh konkret:

Goal: "Booking flight Jakarta-Bali untuk weekend depan,
       budget Rp 2jt PP, prefer pagi"

Iterasi 1:
  Plan: cek tanggal weekend depan
  Tool: get_date("weekend depan") → "Sabtu 23 Mei, Minggu 24 Mei"

Iterasi 2:
  Plan: search flight Sabtu pagi
  Tool: search_flight(origin=CGK, dest=DPS, date="2026-05-23",
                      time_pref="morning")
  Result: 5 options

Iterasi 3:
  Plan: filter budget Rp 2jt PP
  Tool: filter(price < 1000000)  # 1jt one-way
  Result: 2 options

Iterasi 4:
  Plan: kasih user pilihan, biar dia konfirmasi
  Output: "Saya temukan 2 options: X dan Y. Mau saya book yang mana?"

Agent tidak hardcode flow ini. Dia rencanakan sendiri berdasarkan goal.

Power: kamu kasih high-level goal, agent yang figure out steps.

Trade-off: kompleks untuk debug. Kalau salah, susah trace di step mana.

15.2. Komponen Agent¶

Komponen 1: System Prompt (Persona + Rules)¶

Kamu adalah travel booking assistant.

Goal kamu: bantu user book travel sesuai kebutuhan mereka.

Tools yang tersedia:
- search_flight(origin, dest, date, time_pref)
- search_hotel(city, checkin, checkout, budget)
- check_weather(city, date)
- get_user_preference(key)
- book(item_id)

Aturan:
1. Selalu konfirmasi ke user sebelum panggil book()
2. Kalau budget tidak disebut, tanya
3. Kalau ada multiple option, kasih top 3 dengan alasan
4. Bahasa: Indonesia

Komponen 2: Tools¶

Setiap tool punya: - Nama (function name) - Parameters (apa input) - Return type (apa output) - Description (kapan dipakai)

def search_flight(origin: str, dest: str, date: str, time_pref: str) -> list:
    """
    Search penerbangan.

    Args:
        origin: airport code 3 huruf (e.g. CGK)
        dest: airport code 3 huruf (e.g. DPS)
        date: ISO date (YYYY-MM-DD)
        time_pref: 'morning', 'afternoon', 'evening', 'any'

    Returns:
        List of flight options dengan price, time, airline.
    """

Komponen 3: Memory¶

Agent perlu ingat: - Conversation history - Tool call results - User preferences yang sudah disebut

Implementasi: pass context di tiap LLM call (semua history di prompt) atau pakai memory store.

Komponen 4: Loop Control¶

Kapan stop? - Goal achieved - Max iterations tercapai (safety) - User intervention needed (butuh konfirmasi) - Error yang tidak bisa di-handle

15.3. Build dengan LangChain¶

from langchain.agents import AgentExecutor, create_react_agent
from langchain_openai import ChatOpenAI
from langchain.tools import Tool

# Define tools
tools = [
    Tool(
        name="SearchFlight",
        func=search_flight,
        description="Search flights. Args: origin, dest, date, time_pref"
    ),
    Tool(
        name="SearchHotel",
        func=search_hotel,
        description="Search hotels. Args: city, checkin, checkout, budget"
    ),
]

# Create agent
llm = ChatOpenAI(model="gpt-4", temperature=0)
agent = create_react_agent(llm, tools, prompt_template)

# Execute
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
result = executor.invoke({
    "input": "Booking flight Jakarta-Bali weekend depan, budget 2jt"
})

LangChain handle loop control + tool calling untuk kamu.

15.4. Build dengan OpenAI Assistants API¶

client = OpenAI()

# Create assistant
assistant = client.beta.assistants.create(
    name="Travel Bot",
    instructions="...",
    model="gpt-4",
    tools=[
        {"type": "function", "function": {...}},
        {"type": "function", "function": {...}},
    ],
)

# Create thread (memory)
thread = client.beta.threads.create()

# Run
run = client.beta.threads.runs.create(
    thread_id=thread.id,
    assistant_id=assistant.id,
    instructions="User: Booking flight ke Bali..."
)

OpenAI handle memory + tool calling.

15.5. Anthropic Tool Use (Claude)¶

Claude punya tool use API native:

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-3-opus-20240229",
    max_tokens=1024,
    tools=[
        {
            "name": "search_flight",
            "description": "Search penerbangan",
            "input_schema": {
                "type": "object",
                "properties": {
                    "origin": {"type": "string"},
                    "dest": {"type": "string"},
                    "date": {"type": "string"},
                },
                "required": ["origin", "dest", "date"]
            }
        }
    ],
    messages=[{"role": "user", "content": "Booking ke Bali"}]
)

Claude akan return tool calls — kamu execute, kasih hasil balik, loop sampai final answer.

15.6. Kapan Build Agent vs Simple Call¶

✓ Pakai Agent¶

Task butuh multi-step planning dynamic
Butuh tool calls real-time
Goal high-level, steps tidak fixed
Workflow yang bervariasi tiap user

✗ Simple LLM Call Cukup¶

Task single-shot (translate, summarize, classify)
Workflow fixed (selalu sama steps)
Cost-sensitive (agent = banyak LLM calls)
Latency-critical (agent slow karena multi-step)

Rule of thumb: kalau workflow bisa kamu describe dengan flowchart sederhana, chain prompts (Bab 10) cukup. Kalau butuh dynamic decision tiap step, baru pakai agent.

15.7. Pitfalls¶

Pitfall 1: Infinite Loop¶

Agent stuck di loop yang sama. Selalu set max iterations (5-10 default).

Pitfall 2: Tool Hallucination¶

Agent panggil tool dengan params salah. Selalu validate input di kode tool, return error kalau invalid.

Pitfall 3: Cost Explosion¶

Tiap iterasi = LLM call. Goal kompleks bisa 20 iterasi = 20 calls. Monitor cost.

Pitfall 4: Tidak Reproducible¶

Agent flow non-deterministic — sama input bisa output berbeda. Untuk production, log semua intermediate steps untuk debugging.

Pitfall 5: Over-Engineering¶

Banyak yang build agent untuk task yang single LLM call cukup. Mulai dari simple, naik ke agent kalau benar-benar perlu.

15.8. Latihan¶

15.1 — Identify Agent Use Case¶

List 5 task di kerjaan kamu. Tandai mana yang butuh agent vs mana yang simple call cukup.

15.2 — Build Tool Inventory¶

Untuk satu use case agent, design 5 tools yang dia butuhkan. Tulis spec lengkap (params, return, description).

15.3 — Tantangan: Production Agent¶

Build agent simple dengan 3 tools real (e.g. search web, calculator, send Slack message). Deploy di Slack bot.

Komponen Agent¶

System prompt (persona + rules)
Tools (function definitions)
Memory (conversation history)
Loop control (kapan stop)

Frameworks¶

Framework	Best For
LangChain	Multi-provider, banyak integration
LlamaIndex	RAG-focused agents
OpenAI Assistants	Native OpenAI integration
Anthropic Tool Use	Native Claude integration

Kapan Pakai Agent¶

✓ Multi-step dinamis ✓ Butuh tools real-time ✓ Goal high-level ✓ Workflow bervariasi

Kapan Skip¶

✗ Single-shot task ✗ Workflow fixed ✗ Cost-sensitive ✗ Latency-critical

Pitfalls¶

Infinite loop → set max_iterations
Tool hallucination → validate inputs
Cost explosion → monitor token usage
Non-reproducible → log intermediate steps
Over-engineering → start simple

Pattern Tool Definition¶

{
    "name": "search_flight",
    "description": "kapan dipakai",
    "parameters": {
        "origin": "string, airport code",
        "dest": "string, airport code",
        "date": "string, ISO date"
    }
}

🎉 Selamat — Buku Selesai!¶

Kamu menyelesaikan 15 bab prompt engineering. Itu pencapaian nyata.

Yang sekarang kamu bisa¶

✅ Tulis prompt yang konsisten produktif
✅ Pakai role, format, few-shot untuk tune output
✅ Apply CoT, ToT untuk reasoning task
✅ Build pipeline dengan prompt chaining
✅ Implement RAG untuk Q&A di atas data kamu
✅ Design AI agent yang menyelesaikan task multi-step

Apa selanjutnya¶

Practice. Pakai semua teknik di atas di kerjaan harian. 30 hari konsisten = transformasi nyata.
Build prompt library. Catat prompt yang bekerja untuk use case spesifik. Library kamu jadi asset karir.
Stay updated. AI berkembang cepat — model baru, technique baru. Follow blog OpenAI, Anthropic, Learn Prompting.
Eksperimen. Tidak ada substitute untuk run prompt sendiri dan compare hasil. Theory tanpa praktik = tidak menempel.

Kontribusi Balik¶

Kalau buku ini berguna untukmu:

Berkontribusi ke Learn Prompting asli
Bagikan ke teman yang butuh
Berkontribusi ke project terjemahan ini

"Prompt yang baik adalah investasi yang return-nya majemuk. Tulis sekali, pakai ratusan kali, hasilnya konsisten."

Selamat ngeprompt. Selamat bangun yang kamu impikan dengan AI.

← Bab 14 🏠 Beranda

Diadaptasi dari modul "AI Agents" dari Learn Prompting. Dilisensikan Apache 2.0.