Tutorial Membuat AI Agent Sederhana dengan Python

Pendahuluan

Pernahkah kamu membayangkan punya asisten digital yang bisa berpikir sendiri, mengambil keputusan, dan menyelesaikan tugas tanpa perlu kamu perintah satu per satu? Itulah inti dari AI Agent.

Kalau kamu sudah membaca Apa itu Machine Learning? Penjelasan Lengkap untuk Pemula, kamu pasti tahu bahwa AI modern sudah jauh melampaui sekadar prediksi data. AI Agent adalah langkah lebih lanjut — sebuah program yang bisa bertindak secara mandiri berdasarkan informasi dari lingkungannya.

Di artikel ini, kita tidak akan hanya berteori. Kita akan langsung membangun AI Agent sederhana dari nol menggunakan Python — tanpa library besar, tanpa GPU mahal. Cukup logika dasar dan semangat belajar.

Memahami Konsep Dasar AI Agent

Sebelum menulis kode, bayangkan kamu punya robot pembersih ruangan. Robot ini:

1. Merasakan kondisi ruangan (kotor atau bersih?)
2. Berpikir apa yang harus dilakukan
3. Bertindak — menyapu jika kotor, berdiam jika bersih
4. Mengulang proses ini terus-menerus

Inilah siklus dasar sebuah AI Agent: Sense → Think → Act.

Dalam dunia pemrograman, siklus ini diterjemahkan menjadi:

Bayangkan jika ingin membangun aplikasi seperti Gojek — di balik layar ada banyak “agent” kecil yang terus-menerus memonitor posisi driver, permintaan penumpang, dan kondisi lalu lintas, lalu mengambil keputusan secara otomatis.

Persiapan Lingkungan Pengembangan Python

Kita akan menggunakan Python murni — tidak perlu install library eksternal untuk tutorial ini.

Pastikan Python 3.8+ sudah terinstall:

python --version
# Output: Python 3.10.x atau lebih baru

Buat folder proyek:

mkdir ai-agent-tutorial
cd ai-agent-tutorial
touch room_cleaner_agent.py

Kalau kamu belum familiar dengan Fungsi di Python: Definisi, Parameter, dan Return, sangat disarankan membaca artikel tersebut terlebih dahulu karena kita akan banyak menggunakan fungsi di sini.

Membangun AI Agent Pembersih Ruangan (Room Cleaner)

Kita akan membangun agent sederhana bernama RoomCleanerAgent. Agent ini bertugas membersihkan ruangan secara otomatis.

Langkah 1: Definisikan Lingkungan

import random

class Environment:
    """Lingkungan tempat agent beroperasi."""

    def __init__(self, rooms):
        # Inisialisasi status setiap ruangan secara acak
        self.rooms = {room: random.choice(["dirty", "clean"]) for room in rooms}
        self.current_room = rooms[0]

    def get_status(self):
        """Kembalikan status ruangan saat ini."""
        return self.rooms[self.current_room]

    def clean_room(self):
        """Bersihkan ruangan saat ini."""
        self.rooms[self.current_room] = "clean"

    def move_to(self, room):
        """Pindahkan posisi agent ke ruangan lain."""
        if room in self.rooms:
            self.current_room = room
            return True
        return False

    def display(self):
        """Tampilkan kondisi semua ruangan."""
        print("\n=== Status Ruangan ===")
        for room, status in self.rooms.items():
            icon = "🧹" if status == "dirty" else "✅"
            marker = " << (posisi agent)" if room == self.current_room else ""
            print(f"  {icon} {room}: {status}{marker}")
        print("=" * 22)

Langkah 2: Buat Otak Agent (Decision Logic)

class RoomCleanerAgent:
    """AI Agent yang membersihkan ruangan secara otomatis."""

    def __init__(self, environment):
        self.env = environment
        self.steps = 0
        self.rooms_cleaned = 0

    def perceive(self):
        """Agent merasakan kondisi lingkungan saat ini."""
        return {
            "current_room": self.env.current_room,
            "status": self.env.get_status(),
            "all_rooms": list(self.env.rooms.keys())
        }

    def decide(self, perception):
        """
        Agent berpikir dan memutuskan tindakan.
        Aturan sederhana:
        - Jika ruangan kotor → bersihkan
        - Jika bersih → pindah ke ruangan berikutnya
        """
        if perception["status"] == "dirty":
            return "clean"
        
        rooms = perception["all_rooms"]
        current_index = rooms.index(perception["current_room"])
        
        # Cari ruangan kotor berikutnya
        for i in range(1, len(rooms)):
            next_index = (current_index + i) % len(rooms)
            next_room = rooms[next_index]
            if self.env.rooms[next_room] == "dirty":
                return f"move:{next_room}"
        
        return "done"  # Semua ruangan sudah bersih

    def act(self, action):
        """Agent mengeksekusi tindakan yang dipilih."""
        self.steps += 1
        
        if action == "clean":
            print(f"  🧹 Membersihkan {self.env.current_room}...")
            self.env.clean_room()
            self.rooms_cleaned += 1
        elif action.startswith("move:"):
            target = action.split(":")[1]
            print(f"  🚶 Pindah ke {target}...")
            self.env.move_to(target)
        elif action == "done":
            print("  ✅ Semua ruangan sudah bersih! Tugas selesai.")

    def run(self, max_steps=20):
        """Jalankan agent hingga semua ruangan bersih atau batas langkah tercapai."""
        print("🤖 RoomCleanerAgent mulai bekerja...\n")
        
        for step in range(max_steps):
            self.env.display()
            
            perception = self.perceive()
            action = self.decide(perception)
            
            print(f"Langkah {step + 1}: Aksi → '{action}'")
            self.act(action)
            
            if action == "done":
                break
        
        print(f"\n📊 Laporan:")
        print(f"   Total langkah: {self.steps}")
        print(f"   Ruangan dibersihkan: {self.rooms_cleaned}")

Langkah 3: Jalankan Agent

if __name__ == "__main__":
    # Definisikan ruangan yang ada
    rooms = ["Ruang Tamu", "Kamar Tidur", "Dapur", "Kamar Mandi"]
    
    # Buat lingkungan dan agent
    env = Environment(rooms)
    agent = RoomCleanerAgent(env)
    
    # Jalankan agent
    agent.run(max_steps=20)

Contoh output:

🤖 RoomCleanerAgent mulai bekerja...

=== Status Ruangan ===
  🧹 Ruang Tamu: dirty << (posisi agent)
  ✅ Kamar Tidur: clean
  🧹 Dapur: dirty
  ✅ Kamar Mandi: clean
======================
Langkah 1: Aksi → 'clean'
  🧹 Membersihkan Ruang Tamu...

...

✅ Semua ruangan sudah bersih! Tugas selesai.

📊 Laporan:
   Total langkah: 4
   Ruangan dibersihkan: 2

Contoh Kasus Nyata

Mari kita tingkatkan agent kita dengan menambahkan memori — kemampuan untuk mengingat ruangan mana yang sudah dikunjungi, sehingga tidak berputar-putar sia-sia.

class SmartRoomCleanerAgent(RoomCleanerAgent):
    """Versi lebih cerdas dengan memori kunjungan."""

    def __init__(self, environment):
        super().__init__(environment)
        self.visited = set()
        self.memory = []  # Log semua tindakan

    def decide(self, perception):
        """Keputusan lebih cerdas dengan mempertimbangkan riwayat."""
        current = perception["current_room"]
        self.visited.add(current)
        
        if perception["status"] == "dirty":
            self.memory.append(f"Membersihkan {current}")
            return "clean"

        rooms = perception["all_rooms"]
        
        # Prioritaskan ruangan yang belum dikunjungi
        for room in rooms:
            if room not in self.visited and self.env.rooms[room] == "dirty":
                return f"move:{room}"
        
        # Jika semua sudah dikunjungi, cek ulang
        for room in rooms:
            if self.env.rooms[room] == "dirty":
                return f"move:{room}"
        
        return "done"

    def show_memory(self):
        """Tampilkan log tindakan agent."""
        print("\n📝 Log Tindakan Agent:")
        for i, log in enumerate(self.memory, 1):
            print(f"   {i}. {log}")

Konsep memori pada agent ini mirip dengan bagaimana sistem rekomendasi — misalnya pada platform seperti Tokopedia atau Shopee — mengingat preferensi pengguna untuk memberikan saran yang lebih relevan dari waktu ke waktu.

Troubleshooting: Error yang Sering Muncul

AttributeError: ‘NoneType’ object has no attribute ‘current_room’

Penyebab: Objek Environment belum diinisialisasi dengan benar sebelum agent dijalankan, sehingga nilainya None.

Solusi:

# ❌ Salah — env belum diinisialisasi
agent = RoomCleanerAgent(None)
agent.run()

# ✅ Benar — selalu inisialisasi environment terlebih dahulu
rooms = ["Ruang Tamu", "Kamar Tidur"]
env = Environment(rooms)
agent = RoomCleanerAgent(env)
agent.run()

KeyError: Room tidak ditemukan di dictionary

Penyebab: Nama ruangan yang digunakan pada move_to() tidak cocok dengan nama yang didaftarkan di self.rooms — biasanya karena perbedaan huruf kapital atau spasi.

Solusi:

# ❌ Salah — nama tidak cocok
env.move_to("ruang tamu")  # huruf kecil semua

# ✅ Benar — nama harus persis sama seperti saat inisialisasi
rooms = ["Ruang Tamu", "Dapur"]
env = Environment(rooms)
env.move_to("Ruang Tamu")  # cocok persis

# Tips: normalisasi nama ruangan
def normalize_room_name(name):
    return name.strip().title()

RecursionError: maximum recursion depth exceeded

Penyebab: Agent terjebak dalam loop tak terbatas karena kondisi "done" tidak pernah terpenuhi — biasanya karena logika decide() selalu mengembalikan aksi selain "done".

Solusi:

# Selalu batasi jumlah langkah maksimum saat memanggil run()
agent.run(max_steps=50)  # Tambahkan batas yang realistis

# Atau tambahkan safeguard di dalam decide()
def decide(self, perception):
    if all(status == "clean" for status in self.env.rooms.values()):
        return "done"  # Paksa selesai jika semua bersih
    # ... logika lainnya

Pertanyaan yang Sering Diajukan (FAQ)

Apa perbedaan AI Agent dengan program biasa?

Program biasa mengikuti instruksi yang sudah ditentukan secara kaku — jika kondisi A maka lakukan B. AI Agent jauh lebih fleksibel: ia merasakan lingkungannya, memutuskan tindakan terbaik berdasarkan kondisi saat itu, dan bahkan bisa belajar dari pengalaman. Singkatnya, AI Agent bisa “beradaptasi”, sedangkan program biasa tidak.

Apakah saya perlu memahami Machine Learning untuk membuat AI Agent?

Tidak harus! AI Agent sederhana seperti yang kita buat di artikel ini murni berbasis logika aturan (rule-based). Machine Learning dibutuhkan saat kamu ingin agent belajar dari data dan meningkatkan kemampuannya sendiri. Untuk pemula, memulai dari rule-based agent adalah langkah yang tepat sebelum masuk ke Mastering Prompt Engineering: Kunci Utama Optimasi LLM atau teknik ML lanjutan.

Bagaimana cara membuat AI Agent yang bisa belajar sendiri (Reinforcement Learning)?

Kamu perlu menambahkan komponen reward dan Q-table atau neural network. Alurnya: agent melakukan aksi → mendapat reward positif/negatif → memperbarui strategi. Ini adalah bidang yang disebut Reinforcement Learning. Untuk itu, kamu bisa mempelajari library seperti gymnasium (dulu gym) sebagai langkah berikutnya setelah memahami konsep dasar di artikel ini.

Berapa banyak “ruangan” yang bisa ditangani agent ini?

Secara teknis tidak ada batas keras, namun performa akan menurun jika terlalu banyak karena agent mencari ruangan kotor secara linear O(n). Untuk skala besar, kamu bisa menggunakan struktur data yang lebih efisien seperti priority queue agar agent selalu menuju ruangan kotor terdekat terlebih dahulu.

Bisakah AI Agent ini diintegrasikan ke aplikasi web atau chatbot?

Bisa! Kamu bisa membungkus logika agent ini dalam API menggunakan Flask atau FastAPI, lalu memanggil endpoint-nya dari frontend React atau antarmuka chatbot. Konsep agentnya tetap sama — yang berubah hanya cara input dan outputnya dikirimkan.

Kesimpulan

Selamat! Kamu baru saja membangun AI Agent pertamamu dari nol menggunakan Python. Kita telah belajar:

• Konsep inti AI Agent: Sense → Think → Act
• Cara mendefinisikan Environment sebagai dunia agent
• Cara membangun logika keputusan (decision logic) yang sederhana namun efektif
• Cara menambahkan memori agar agent bertindak lebih cerdas
• Cara men-debug error umum yang sering muncul

Ini baru permulaan. Dari fondasi ini, kamu bisa mengembangkan agent yang lebih canggih — agent yang bisa mengakses internet, berinteraksi dengan API, atau bahkan berkolaborasi dengan agent lain dalam sebuah sistem multi-agent.

Selamat belajar dan terus bereksperimen! Jangan takut untuk memodifikasi kode di atas dan mencoba skenario yang berbeda — itulah cara terbaik untuk benar-benar memahami cara kerja AI Agent. Kalau ada yang ingin didiskusikan lebih lanjut, jelajahi artikel-artikel lainnya di KamusNgoding dan terus tumbuh sebagai developer Indonesia yang hebat!