Belajar Generative AI - Agents: Agent Loop & LangGraph

#Pendahuluan

Setelah di episode 9 kalian membangun tool loop yang bekerja, episode ini menjawab pertanyaan konseptual: kapan sekumpulan tool call menjadi sebuah "agent"? Jawaban singkatnya: ketika loop itu punya state (ingatan antar-langkah), kontrol (bisa memutuskan arah), dan tujuan (menyelesaikan task multi-langkah). Itulah yang membuat agent berbeda dari sekadar script.

Mengapa ini penting di 2026? Karena era ini didefinisikan oleh agentic AI — model yang bekerja, bukan hanya menjawab. Namun di balik kata-kata hype, agen adalah konsep engineering yang bisa dipecah: ReAct loop, state, dan orchestration. Memahami ketiganya membuat kalian bisa membangun agent yang andal, bukan sekadar memanggil framework.

#ReAct Loop: Reason + Act

ReAct adalah pola paling berpengaruh untuk agen: model bergantian berpikir (reason) dan bertindak (act), mengamati hasil, lalu berulang. Ditemukan di paper ReAct: Synergizing Reasoning and Acting in Language Models (2023).

Perbedaan dengan tool loop episode 9: di sini kita memaksa model untuk menuliskan pemikirannya sebelum bertindak — ini meningkatkan kualitas keputusan dan membuat alurnya bisa di-audit.

from openai import OpenAI
 
client = OpenAI()
 
react_prompt = """Kamu adalah agen. Untuk tiap langkah keluarkan:
Thought: <alasanmu>
Action: <nama tool dari daftar: search_docs, calculate>
Action Input: <argumen JSON>
Lanjutkan sampai kamu bisa memberi:
Final Answer: <jawaban>"""
 
def react(question):
    messages = [{"role": "system", "content": react_prompt},
                {"role": "user", "content": question}]
    for _ in range(8):
        r = client.chat.completions.create(
            model="gpt-4o-mini", messages=messages)
        out = r.choices[0].message.content
        print(">>>", out)
        if "Final Answer:" in out:
            return out.split("Final Answer:")[-1].strip()
        # parse Action & Action Input → eksekusi → append Observation
        messages.append({"role": "assistant", "content": out})
        messages.append({"role": "user",
                         "content": f"Observation: {call_tool(out)}"})

Perhatikan: ReAct bisa diimplementasikan bahkan tanpa function calling API — cukup sebagai format teks. Tapi di produksi, function calling native (episode 9) memberi jaminan JSON yang lebih kuat. Keduanya adalah dua pendekatan dari satu ide.

#State: Ingatan Agent

Agent berbeda dari sekadar loop karena ia memegang state — apa yang sudah dilakukan, hasil apa yang didapat, keputusan apa yang diambil. Di sinilah framework seperti LangGraph masuk: agent digambarkan sebagai state machine dengan node (langkah) dan edges (kondisi transisi).

from langgraph.graph import StateGraph
from typing import TypedDict, Annotated
import operator
 
class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    remaining_steps: int
 
def decide(state: AgentState) -> str:
    # kondisi transisi: cukup tool call? → "final"
    return "final" if state["remaining_steps"] <= 0 else "tools"
 
graph = StateGraph(AgentState)
graph.add_node("tools", run_tool_node)
graph.add_node("final", final_node)
graph.set_entry_point("tools")
graph.add_conditional_edges("tools", decide, {"final": "final", "tools": "tools"})
graph.add_edge("final", "__end__")

Keuntungan memodelkan agent sebagai state machine:

• Bercabang: node berbeda untuk alat berbeda; transisi kondisional ("kalau gagal, coba lagi; kalau butuh input, tanya user").
• Auditable: setiap node bisa di-log, di-inspect, di-pause.
• Testable: state machine bisa diuji per-transisi, bukan hanya end-to-end.

#Multi-Agent Orchestration

Satu agent dengan banyak tool sering cukup — tapi untuk task besar (research berbulan-bulan data, atau workflow yang butuh keahlian berbeda), pecah menjadi beberapa agent dengan peran dan sebuah orchestrator yang mengarahkan. Peran umumnya: planner (menyusun rencana), executor (mengeksekusi langkah), verifier (memeriksa hasil).

Kapan memakai multi-agent? Aturan praktis: mulai dengan satu agent; tambah agent kedua hanya ketika ada batas kejelasan peran atau paralelisme yang nyata. Multi-agent menambah latency, biaya, dan titik kegagalan — ia bukan solusi ajaib. Kita perdalam arsitekturnya di episode 20.

#Framework: LangChain, LangGraph, LlamaIndex, MCP

Empat nama yang wajib kalian petakan:

Peran MCP cukup penting untuk dibahas terpisah — di episode 11 kita bangun MCP server sendiri. Untuk episode ini, intinya: LangGraph adalah pilihan utama untuk membangun agent produksi karena model state machine-nya; LlamaIndex lebih kuat di sisi retrieval/data (sering dipakai berpasangan dengan RAG di episode 7-8).

#Common Pitfalls

• Agent tanpa batas langkah & budget: biaya token membengkak tak terkendali — selalu set max iterations & max token.
• State tidak dipersistensikan: crash di tengah loop = mulai dari nol; simpan state (misal per checkpoint).
• Menanyakan ulang hal yang sama: agent lupa sudah menghitung → arsitektur state harus menyimpan hasil antara.
• Multi-agent yang tidak perlu: menambah agent menambah biaya & kegagalan — mulai dari satu.

#Penutup

Inti yang harus dibawa pulang:

• ReAct loop: thought → action → observation, diulang sampai jawaban final.
• State membedakan agent dari script; LangGraph memodelkannya sebagai state machine.
• Multi-agent = planner/executor/verifier + orchestrator; mulai dari satu agent dulu.
• Framework (LangChain/LangGraph/LlamaIndex/MCP) mempermudah, prinsip di atas yang berlaku universal.

Di episode 11 selanjutnya kita akan membangun MCP (Model Context Protocol) — arsitektur server/client/tools/resources, cara menghubungkan agent ke data & services, lalu praktik membangun MCP server sederhana dan mengintegrasikannya dengan agent. Sampai jumpa di episode 11!