Tutorial Membangun Coding Agent Sendiri: Panduan Praktis

AI coding agent sedang menjadi topik hangat di komunitas developer. Berbeda dengan code completion biasa, coding agent bisa membaca konteks proyek, menjalankan perintah terminal, menulis file baru, dan bahkan melakukan debugging secara mandiri. Artikel ini akan membahas cara membangun coding agent sederhana yang bisa kamu modifikasi untuk kebutuhan pribadi atau tim.

Kita akan menggunakan pendekatan modular dengan Python, memanfaatkan LLM API untuk reasoning, dan memberikan kemampuan tool-use sehingga agent bisa berinteraksi dengan filesystem serta terminal. Hasil akhirnya adalah sebuah script Python yang bisa menerima instruksi dalam bahasa alami dan mengubahnya menjadi aksi konkret di komputer.

Memahami Arsitektur Coding Agent

Sebelum menulis kode, penting untuk memahami komponen utama sebuah coding agent. Setidaknya ada tiga bagian esensial: planning loop, tool executor, dan context manager. Planning loop bertugas merencanakan langkah-langkah untuk menyelesaikan tugas. Tool executor menjalankan perintah seperti membaca file, menulis file, atau menjalankan shell command. Context manager menyimpan riwayat percakapan dan state proyek agar agent memiliki memori jangka panjang.

Arsitektur ini mirip dengan pola ReAct (Reasoning and Acting) yang populer dalam pengembangan AI agent. Dengan memahami fondasi ini, kamu bisa mengembangkan agent yang lebih kompleks di masa depan. Pola ReAct memungkinkan agent untuk tidak hanya merespons, tapi juga berpikir secara struktural tentang langkah yang harus diambil.

Langkah 1: Setup Proyek dan Dependensi

Buat direktori proyek baru dan install dependensi yang dibutuhkan. Kita akan menggunakan OpenAI API atau OpenRouter sebagai provider LLM, serta library standar Python untuk manipulasi file.

# Buat direktori proyek
mkdir simple-coding-agent && cd simple-coding-agent
python3 -m venv venv
source venv/bin/activate

# Install dependensi
pip install openai python-dotenv

Buat file .env untuk menyimpan API key:

OPENAI_API_KEY=sk-your-key-here
# atau
OPENROUTER_API_KEY=sk-or-v1-your-key-here

Pastikan file .env masuk ke .gitignore agar kredensial tidak terexpos. Untuk pengembangan lokal, variabel lingkungan adalah cara paling aman menyimpan API key.

Langkah 2: Membuat Tool Executor

Tool executor adalah modul yang memungkinkan agent berinteraksi dengan sistem operasi. Kita akan membuat tiga tool dasar: read_file, write_file, dan run_shell.

import os
import subprocess

def read_file(path):
    with open(path, 'r', encoding='utf-8') as f:
        return f.read()

def write_file(path, content):
    os.makedirs(os.path.dirname(path), exist_ok=True)
    with open(path, 'w', encoding='utf-8') as f:
        f.write(content)
    return f"File {path} berhasil ditulis."

def run_shell(command):
    result = subprocess.run(
        command, shell=True, capture_output=True, text=True, timeout=30
    )
    return result.stdout + result.stderr

Fungsi run_shell memiliki timeout untuk mencegah perintah yang menggantung. Kamu bisa menambahkan validasi command untuk menghindari eksekusi kode berbahaya seperti rm -rf /. Dalam implementasi production, gunakan whitelist command atau sandboxing.

Langkah 3: Membangun Planning Loop dengan LLM

Planning loop adalah inti dari coding agent. Kita akan mengirimkan prompt ke LLM yang berisi deskripsi tugas, konteks file yang relevan, dan daftar tool yang tersedia. LLM akan merespons dengan langkah berupa JSON yang menentukan tool apa yang harus dijalankan.

import json
from openai import OpenAI

client = OpenAI()

def plan_step(task, context, tools_description):
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "Kamu adalah coding agent. Respon dengan JSON {"action": "tool_name", "args": {}}."},
            {"role": "user", "content": f"Tugas: {task}\nKonteks: {context}\nTools: {tools_description}"}
        ],
        response_format={"type": "json_object"}
    )
    return json.loads(response.choices[0].message.content)

Pastikan model yang dipilih mendukung JSON mode untuk hasil yang lebih konsisten. Jika menggunakan OpenRouter, sesuaikan parameter model sesuai provider. Beberapa model lokal seperti Qwen 2.5 Coder juga bisa digunakan melalui Ollama untuk mengurangi biaya API.

Langkah 4: Menghubungkan Loop dengan Executor

Sekarang kita gabungkan planning loop dan tool executor dalam satu orchestrator. Orchestrator akan berjalan iteratif sampai agent menentukan bahwa tugas selesai.

tools = {
    "read_file": read_file,
    "write_file": write_file,
    "run_shell": run_shell
}

def run_agent(task, max_steps=10):
    context = ""
    for i in range(max_steps):
        plan = plan_step(task, context, list(tools.keys()))
        action = plan.get("action")
        args = plan.get("args", {})

        if action == "done":
            return "Tugas selesai."

        if action in tools:
            result = tools[action](**args)
            context += f"\nStep {i+1}: {action}({args}) => {result}"
        else:
            context += f"\nStep {i+1}: Action {action} tidak dikenal."
    return "Mencapai batas step maksimal."

Orchestrator ini sangat sederhana namun sudah cukup untuk tugas seperti membuat file HTML, menjalankan test, atau refactor kode kecil. Untuk produksi, tambahkan error handling dan retry logic. Kamu juga bisa menambahkan logging ke file agar bisa dianalisis jika terjadi kesalahan.

Langkah 5: Testing dengan Tugas Nyata

Mari uji agent dengan tugas sederhana: membuat file Python yang menghitung fibonacci.

task = "Buat file fib.py yang berisi fungsi fibonacci(n) dan print fibonacci(10)"
print(run_agent(task))

Jika agent berjalan dengan benar, kamu akan melihat log setiap step dan file fib.py akan muncul di direktori proyek. Iterasi dan perbaiki prompt sistem jika hasil belum sesuai ekspektasi. Cobalah juga tugas lain seperti membuat file HTML sederhana atau menjalankan perintah git.

Menambahkan Context Manager untuk Proyek Besar

Untuk proyek yang lebih besar, context manager menjadi krusial. Kamu perlu membatasi konteks yang dikirim ke LLM agar tidak melebihi batas token. Salah satu tekniknya adalah menggunakan directory tree dan hanya mengirimkan file yang relevan.

import os

def get_project_tree(root='.', max_depth=2):
    tree = []
    for dirpath, dirnames, filenames in os.walk(root):
        depth = dirpath.count(os.sep)
        if depth > max_depth:
            del dirnames[:]
            continue
        tree.append(f"{dirpath}/: {', '.join(filenames)}")
    return '\n'.join(tree)

Dengan tree ini, LLM bisa memutuskan file mana yang perlu dibaca tanpa harus menerima seluruh isi repository.

Ide Pengembangan Selanjutnya

Dari fondasi ini, kamu bisa mengembangkan fitur tambahan seperti integrasi dengan Git untuk commit otomatis, analisis codebase besar dengan chunking, atau bahkan menambahkan web search untuk riset library terbaru. Beberapa proyek open source seperti Tutorial Codebase Knowledge menunjukkan bagaimana AI bisa memahami repository GitHub secara menyeluruh.

Referensi arsitektur coding agent juga bisa dipelajari dari tulisan Geoffrey Huntley yang membahas pola desain agent modern. Pola tersebut mencakup observability, self-correction, dan hierarchical planning.

Kesimpulan

Membangun coding agent sendiri tidak sesulit yang dibayangkan. Dengan Python, LLM API, dan pola ReAct, kamu sudah bisa membuat agent yang mampu membaca file, menulis kode, dan menjalankan perintah terminal. Mulai dari fondasi sederhana ini, eksplorasi kemungkinan untuk mengotomatisasi workflow development harianmu.