ReAct vs. Chain of Thought: Perbedaan dan Kapan Menggunakannya

Pendahuluan

Ketika bekerja dengan Large Language Model (LLM) atau membangun AI Agent, dua teknik prompting yang paling sering disebut adalah ReAct dan Chain of Thought (CoT). Keduanya dirancang untuk membuat model berpikir lebih terstruktur, tapi cara kerja dan use case-nya sangat berbeda.

Bayangkan kamu sedang membangun asisten AI untuk platform seperti Tokopedia — asisten yang bisa mencari produk, mengecek stok, lalu memberikan rekomendasi. Di sinilah pilihan antara ReAct dan CoT menjadi krusial. Salah pilih, dan agentmu bisa boros token, lambat, atau bahkan memberikan jawaban yang tidak akurat.

Di artikel ini, kita akan bedah keduanya secara mendalam: cara kerja, contoh implementasi nyata, serta panduan kapan harus menggunakan masing-masing. Kalau kamu belum familiar dengan konsep dasar AI Agent, ada baiknya baca dulu Apa itu Deep Learning? Penjelasan Lengkap untuk Pemula sebagai fondasi.

Konsep Dasar

Chain of Thought (CoT): Berpikir Langkah demi Langkah

Chain of Thought adalah teknik di mana kamu meminta LLM untuk menuliskan proses berpikirnya sebelum memberikan jawaban akhir. Alih-alih langsung menjawab, model akan “menjelaskan” langkah-langkah penalaran yang ia lakukan.

CoT cocok untuk masalah yang bisa diselesaikan hanya dengan pengetahuan internal model — tanpa perlu akses ke dunia luar. Contohnya: soal matematika, analisis logika, penjelasan konsep, atau reasoning berbasis teks.

Pola dasar CoT:

Input: [Pertanyaan]
Think: Langkah 1... Langkah 2... Langkah 3...
Answer: [Jawaban akhir]

ReAct: Reasoning + Acting

ReAct (singkatan dari Reasoning + Acting) adalah framework yang menggabungkan kemampuan berpikir (reasoning) dengan kemampuan bertindak (acting). Model tidak hanya berpikir — ia juga bisa memanggil tools eksternal seperti search engine, API, database, atau kalkulator, lalu menggunakan hasil dari tools tersebut untuk melanjutkan penalarannya.

Siklus ReAct:

Thought → Action → Observation → Thought → Action → Observation → ... → Answer

Inilah yang membuat ReAct sangat powerful untuk AI Agent yang perlu berinteraksi dengan dunia nyata.

Perbandingan Langsung

Contoh Kode

Implementasi Chain of Thought

Contoh di bawah ini menggunakan Python dengan Anthropic Claude API untuk CoT sederhana:

import anthropic

client = anthropic.Anthropic()

def chain_of_thought(question: str) -> str:
    prompt = f"""Jawab pertanyaan berikut dengan menuliskan langkah-langkah berpikirmu terlebih dahulu.

Pertanyaan: {question}

Format jawaban:
Langkah 1: [penjelasan]
Langkah 2: [penjelasan]
...
Kesimpulan: [jawaban akhir]"""

    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        messages=[
            {"role": "user", "content": prompt}
        ]
    )
    return response.content[0].text

# Contoh penggunaan
result = chain_of_thought(
    "Jika sebuah toko menjual 120 produk per hari dengan margin 15%, "
    "berapa total keuntungan dalam sebulan (30 hari) jika harga rata-rata produk Rp 50.000?"
)
print(result)

Output yang diharapkan:

Langkah 1: Hitung pendapatan per hari
  120 produk × Rp 50.000 = Rp 6.000.000/hari

Langkah 2: Hitung keuntungan per hari
  Rp 6.000.000 × 15% = Rp 900.000/hari

Langkah 3: Hitung keuntungan per bulan
  Rp 900.000 × 30 = Rp 27.000.000

Kesimpulan: Total keuntungan dalam sebulan adalah Rp 27.000.000

Implementasi ReAct dengan Tools

Berikut implementasi ReAct yang lebih realistis — agent yang bisa menggunakan tools:

import anthropic
import json
from typing import Any

client = anthropic.Anthropic()

# Definisi tools yang tersedia untuk agent
tools = [
    {
        "name": "search_product",
        "description": "Cari produk berdasarkan keyword dan kembalikan daftar produk beserta harga",
        "input_schema": {
            "type": "object",
            "properties": {
                "keyword": {
                    "type": "string",
                    "description": "Kata kunci pencarian produk"
                }
            },
            "required": ["keyword"]
        }
    },
    {
        "name": "check_stock",
        "description": "Cek ketersediaan stok produk berdasarkan ID produk",
        "input_schema": {
            "type": "object",
            "properties": {
                "product_id": {
                    "type": "string",
                    "description": "ID unik produk"
                }
            },
            "required": ["product_id"]
        }
    },
    {
        "name": "calculate_discount",
        "description": "Hitung harga setelah diskon",
        "input_schema": {
            "type": "object",
            "properties": {
                "original_price": {"type": "number"},
                "discount_percent": {"type": "number"}
            },
            "required": ["original_price", "discount_percent"]
        }
    }
]

# Simulasi fungsi tools (di production, ini terhubung ke API nyata)
def execute_tool(tool_name: str, tool_input: dict) -> Any:
    if tool_name == "search_product":
        # Simulasi pencarian produk
        return {
            "results": [
                {"id": "P001", "nama": "Laptop ASUS VivoBook", "harga": 8500000},
                {"id": "P002", "nama": "Laptop Lenovo IdeaPad", "harga": 7200000}
            ]
        }
    elif tool_name == "check_stock":
        return {"product_id": tool_input["product_id"], "stok": 5, "tersedia": True}
    elif tool_name == "calculate_discount":
        harga = tool_input["original_price"]
        diskon = tool_input["discount_percent"]
        return {"harga_asli": harga, "harga_diskon": harga * (1 - diskon / 100)}

def react_agent(user_query: str) -> str:
    """Agent ReAct yang melakukan reasoning dan menggunakan tools secara iteratif."""
    
    messages = [{"role": "user", "content": user_query}]
    
    system_prompt = """Kamu adalah asisten belanja yang membantu pengguna menemukan produk terbaik.
Gunakan tools yang tersedia untuk mencari produk, cek stok, dan hitung diskon.
Selalu lakukan reasoning sebelum memilih tool yang akan digunakan."""

    max_iterations = 5
    iteration = 0

    while iteration < max_iterations:
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=2048,
            system=system_prompt,
            tools=tools,
            messages=messages
        )

        # Tambahkan respons assistant ke history
        messages.append({"role": "assistant", "content": response.content})

        # Jika model selesai (tidak ada tool call), kembalikan jawaban
        if response.stop_reason == "end_turn":
            for block in response.content:
                if hasattr(block, "text"):
                    return block.text

        # Proses tool calls jika ada
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                print(f"[ReAct] Thought: Menggunakan tool '{block.name}'")
                print(f"[ReAct] Action: {json.dumps(block.input, ensure_ascii=False)}")
                
                result = execute_tool(block.name, block.input)
                print(f"[ReAct] Observation: {json.dumps(result, ensure_ascii=False)}\n")
                
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": json.dumps(result, ensure_ascii=False)
                })

        if tool_results:
            messages.append({"role": "user", "content": tool_results})

        iteration += 1

    return "Maaf, tidak dapat menyelesaikan permintaan dalam batas iterasi."

# Contoh penggunaan
query = "Carikan laptop dengan harga terjangkau, cek stoknya, dan hitung harga setelah diskon 10%"
print("Query:", query)
print("\n--- Proses ReAct ---")
jawaban = react_agent(query)
print("\n--- Jawaban Akhir ---")
print(jawaban)

Kapan Gunakan CoT vs ReAct?

def pilih_strategi(task_type: str) -> str:
    """
    Panduan memilih strategi berdasarkan jenis task.
    """
    strategi = {
        # Gunakan CoT untuk:
        "analisis_logika": "chain_of_thought",
        "soal_matematika": "chain_of_thought",
        "klasifikasi_teks": "chain_of_thought",
        "summarization": "chain_of_thought",
        "code_review": "chain_of_thought",
        
        # Gunakan ReAct untuk:
        "pencarian_web": "react",
        "akses_database": "react",
        "integrasi_api": "react",
        "multi_step_workflow": "react",
        "real_time_data": "react",
    }
    
    return strategi.get(task_type, "chain_of_thought")  # default: CoT

# Contoh
tasks = ["soal_matematika", "pencarian_web", "akses_database", "analisis_logika"]
for task in tasks:
    print(f"Task '{task}' → Gunakan: {pilih_strategi(task)}")

Teknik ini sangat berguna saat membangun sistem yang mirip dengan implementasi antrian pada aplikasi berskala besar — kamu perlu memilih pendekatan yang tepat agar sistem tetap efisien.

Troubleshooting: Error yang Sering Muncul

Tool Not Called Despite Clear Instructions

Penyebab: Model tidak memanggil tool karena prompt sistem tidak cukup jelas memerintahkan penggunaan tool, atau tool description kurang deskriptif.

Solusi:

# Sebelum (kurang jelas)
system_prompt = "Kamu adalah asisten yang membantu."

# Sesudah (lebih eksplisit)
system_prompt = """Kamu adalah asisten yang WAJIB menggunakan tools yang tersedia.
Jangan pernah menjawab langsung tanpa menggunakan tool terlebih dahulu.
Selalu mulai dengan search_product sebelum memberikan rekomendasi."""

# Pastikan juga tool_choice diset jika perlu
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=system_prompt,
    tools=tools,
    tool_choice={"type": "auto"},  # atau {"type": "any"} untuk paksa pakai tool
    messages=messages
)

Infinite Loop pada ReAct Agent

Penyebab: Agent terus memanggil tool secara berulang tanpa mencapai kondisi berhenti, biasanya karena stop condition tidak terdefinisi dengan baik.

Solusi:

def react_agent_safe(user_query: str, max_iterations: int = 5) -> str:
    messages = [{"role": "user", "content": user_query}]
    iteration = 0
    
    while iteration < max_iterations:
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=2048,
            tools=tools,
            messages=messages
        )
        
        # Deteksi loop: jika tool yang sama dipanggil 2x berturut-turut
        if iteration > 0:
            last_tool = getattr(messages[-1].get("content", [{}])[-1], "name", None)
            current_tool = next(
                (b.name for b in response.content if b.type == "tool_use"), None
            )
            if last_tool == current_tool:
                return "Terdeteksi loop — menghentikan eksekusi."
        
        if response.stop_reason == "end_turn":
            return response.content[0].text
            
        # ... proses tool calls
        iteration += 1
    
    return f"Batas iterasi ({max_iterations}) tercapai."

Token Limit Exceeded pada CoT Panjang

Penyebab: Chain of Thought pada masalah kompleks bisa menghasilkan reasoning yang sangat panjang dan melebihi batas token output.

Solusi:

def chain_of_thought_limited(question: str, max_steps: int = 5) -> str:
    prompt = f"""Jawab pertanyaan berikut dengan maksimal {max_steps} langkah penalaran.
Setiap langkah maksimal 2 kalimat. Langsung ke poin utama.

Pertanyaan: {question}

Format:
Langkah 1: [penjelasan singkat]
...
Kesimpulan: [jawaban]"""

    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=512,  # Batasi output
        messages=[{"role": "user", "content": prompt}]
    )
    return response.content[0].text

Pertanyaan yang Sering Diajukan (FAQ)

Apa perbedaan utama antara ReAct dan Chain of Thought?

Chain of Thought hanya melibatkan proses berpikir internal model tanpa interaksi dengan sistem eksternal, cocok untuk reasoning dan kalkulasi. ReAct menambahkan kemampuan bertindak — model bisa memanggil tools seperti API atau database dan menggunakan hasilnya untuk melanjutkan reasoning, cocok untuk task yang membutuhkan data real-time.

Apakah saya bisa menggabungkan CoT dan ReAct dalam satu sistem?

Ya, dan ini adalah praktik yang umum! Kamu bisa menggunakan CoT di dalam setiap langkah Thought pada siklus ReAct. Artinya, sebelum model memutuskan action apa yang akan diambil, ia melakukan chain of thought terlebih dahulu untuk reasoning yang lebih dalam. Ini disebut ReAct + CoT hybrid.

Kapan ReAct lebih buruk dari CoT?

ReAct lebih buruk dari CoT ketika task bisa diselesaikan hanya dengan pengetahuan internal model. Pada kasus seperti analisis teks, soal logika, atau summarization, ReAct hanya menambah overhead — lebih banyak token terpakai, lebih lambat, dan lebih mahal — tanpa manfaat nyata. Gunakan ReAct hanya saat tools benar-benar dibutuhkan.

Bagaimana cara mengukur performa ReAct vs CoT untuk use case saya?

Ukur tiga metrik utama: (1) Akurasi jawaban — apakah jawaban benar?, (2) Jumlah token yang dikonsumsi per query, dan (3) Latensi — berapa lama waktu yang dibutuhkan. Jalankan keduanya pada 20–50 sample soal dari domain kamu, lalu bandingkan hasilnya secara kuantitatif sebelum memutuskan.

Apakah ReAct aman digunakan di production?

ReAct aman jika diimplementasikan dengan benar. Pastikan selalu ada: (1) batas iterasi maksimum untuk mencegah infinite loop, (2) validasi input sebelum tools dieksekusi, dan (3) timeout pada setiap tool call. Jangan pernah memberikan akses tools yang destruktif (seperti delete database) tanpa konfirmasi eksplisit dari pengguna.

Kesimpulan

ReAct dan Chain of Thought adalah dua senjata berbeda dalam arsenal developer AI — keduanya powerful, tapi untuk situasi yang berbeda. Gunakan CoT ketika kamu hanya butuh reasoning internal yang terstruktur: matematika, logika, analisis teks. Gunakan ReAct ketika agentmu perlu berinteraksi dengan dunia luar: API, database, search engine, atau sistem eksternal lainnya.

Kunci keberhasilan adalah tidak memaksakan satu teknik untuk semua situasi. Evaluasi use case kamu terlebih dahulu, pertimbangkan trade-off antara akurasi, kecepatan, dan biaya, lalu pilih yang paling sesuai — atau kombinasikan keduanya jika diperlukan.

Selamat mencoba dan terus bereksperimen! Dunia AI Agent berkembang sangat cepat, dan dengan memahami fondasi seperti ReAct dan CoT, kamu sudah satu langkah lebih maju. Jika ada pertanyaan atau kamu ingin eksplorasi lebih jauh, jangan ragu untuk menjelajahi artikel-artikel lainnya di KamusNgoding.