Cara Membuat AI Agent dari Awal (Panduan Langkah demi Langkah)

Kemunculan model bahasa besar dan perangkat AI yang fleksibel telah membuat pembangunan agen AI kustom lebih mudah diakses dari sebelumnya. Baik Anda menginginkan agen untuk membantu mengotomatiskan tugas, membantu riset, mendukung interaksi pengguna, atau menggerakkan layanan baru — memulai dari awal dan mendesain sesuai kebutuhan Anda seringkali menghasilkan hasil yang paling fleksibel dan kuat. Dalam panduan ini, kami akan membahas proses sembilan langkah untuk membangun agen AI dari awal — mulai dari menentukan tujuan hingga membangun UI atau API di sekitarnya.

💡

Mencari alat Pengujian API hebat yang menghasilkan Dokumentasi API yang indah?

Mencari platform terintegrasi, All-in-One untuk Tim Developer Anda agar dapat bekerja sama dengan produktivitas maksimal?

Apidog memenuhi semua kebutuhan Anda, dan menggantikan Postman dengan harga yang jauh lebih terjangkau!

button

Langkah 1: Definisikan Tujuan dan Cakupan Agen Anda

Sebelum menulis satu baris kode atau *prompt* pun, Anda harus **jelas tentang apa yang seharusnya dilakukan agen Anda**. Ini berarti:

Menentukan **tugas persis** yang akan ditangani agen (misalnya, "mengidentifikasi prospek penjualan," "menyusun email pendekatan," "merangkum tiket dukungan," "merekomendasikan buku berdasarkan preferensi pengguna").
Mengidentifikasi **pengguna target** — apakah mereka anggota tim internal, pelanggan akhir, atau agen lain?
Mengklarifikasi **hasil yang diharapkan** — keluaran apa yang harus dihasilkan agen (misalnya, objek JSON, laporan terformat, draf pesan, keputusan, dll.).

Contoh: Misalkan Anda menginginkan agen "asisten penjualan". Anda mungkin mendefinisikan bahwa agen tersebut akan: mengambil data profil prospek sebagai masukan, meneliti informasi publik prospek, menilai kesesuaian prospek, dan menghasilkan draf email pendekatan. Dengan cakupan yang didefinisikan dengan jelas ini, segala hal lainnya — mulai dari *prompt* hingga aliran data — menjadi lebih mudah direncanakan.

Langkah 2: Tetapkan Skema Input / Output yang Jelas

Setelah tujuannya jelas, desain **skema masukan dan keluaran yang terstruktur** daripada membiarkan semuanya bebas. Ini memberikan agen Anda "kontrak" yang stabil, mirip dengan bagaimana API mendefinisikan struktur permintaan dan respons.

Gunakan alat seperti **Pydantic** (di Python), **JSON Schema**, atau **interface TypeScript** untuk mendefinisikan masukan dan keluaran secara formal (poin ini juga ditekankan oleh RDD).
Definisikan dengan tepat bidang apa yang diharapkan agen (dengan tipe, wajib vs opsional, batasan nilai, dll.).
Untuk keluaran, tentukan tidak hanya data (misalnya "email_subject", "email_body", "lead_score") tetapi juga metadata (misalnya timestamp, model_version, processing_time) jika bermanfaat — terutama berguna untuk *logging*, *debugging*, atau merangkai agen.

from pydantic import BaseModel, Field
from typing import Optional, List

class LeadProfile(BaseModel):
    name: str
    email: Optional[str]
    company: Optional[str]
    description: Optional[str]

class OutreachEmail(BaseModel):
    subject: str
    body: str
    lead_score: float = Field(..., ge=0, le=1)

# Example usage:
lead = LeadProfile(name="Alice Johnson", email="alice@example.com", company="Acme Corp")
print(lead.json())

Contoh Kode

Pendekatan berbasis skema ini memastikan konsistensi, mempermudah validasi keluaran, dan menyederhanakan integrasi dengan sistem atau UI lain.

Langkah 3: Tulis Instruksi Sistem

Dengan skema yang sudah ada, tulis **definisi peran dan instruksi sistem yang terperinci** untuk agen Anda. Pada dasarnya, Anda memberi tahu AI: “Anda adalah X. Berikut adalah tanggung jawab, batasan, gaya, nada, dan format keluaran Anda.”

Definisikan aturan perilaku (misalnya, “selalu kembalikan JSON yang sesuai dengan skema,” “jika data hilang, respons dengan objek error,” “bersikap sopan, ringkas, dan profesional”).
Gunakan *template prompt* / instruksi yang konsisten untuk mengurangi variasi dalam respons. Banyak agen mendapatkan manfaat dari struktur yang stabil berupa “*system prompt* + *user prompt* + penegakan skema”."
Coba gaya instruksi yang berbeda — beberapa agen merespons lebih baik terhadap instruksi yang sangat eksplisit, yang lain lebih baik terhadap instruksi yang lebih fleksibel atau bersifat percakapan.

Anda dapat menggunakan LLM apa pun yang mendukung gaya ini — misalnya GPT-4, Claude, atau model lainnya. Banyak pengembang menyematkan instruksi sistem langsung dalam inisialisasi agen mereka.

Langkah 4: Aktifkan Penalaran & Tindakan Eksternal

Agen menjadi jauh lebih kuat ketika ia dapat **bernalar secara logis dan berinteraksi dengan sistem eksternal** — basis data, API, alat, pencarian web, eksekusi kode, dll.

Gunakan kerangka kerja seperti **ReAct** (Reasoning + Action) atau pola serupa: agen bernalar, lalu memilih tindakan (seperti memanggil API), kemudian mengamati hasilnya, lalu bernalar lagi, dan seterusnya.
Berikan agen **fungsi/antarmuka alat** yang dapat dipanggilnya, dengan masukan dan keluaran yang didefinisikan dengan jelas (sesuai skema), seperti “search_web(query)” → mengembalikan hasil; “send_email(payload)”; “query_database(params)”; dll.
Untuk tugas-tugas seperti pengambilan data, perhitungan, operasi basis data, *web scraping*, pemrosesan dokumen — menghubungkan tindakan eksternal ini membuat agen mampu melakukan lebih dari sekadar menghasilkan teks.

Langkah ini mengubah agen Anda dari “generator teks pintar” menjadi “agen” sungguhan yang dapat *bertindak*, bukan hanya “membalas.”

import openai, os, json

openai.api_key = os.getenv("OPENAI_API_KEY")

SYSTEM_PROMPT = """
You are a helpful assistant. Use the available tools when needed.
Return output in JSON with keys: {action, action_input} or {final_answer}.
"""

TOOLS = {
    "search": lambda query: f"[search results for: {query}]",
    # add more tools as needed
}

def call_llm(messages):
    resp = openai.chat.completions.create(
        model="gpt-4o",
        messages=messages
    )
    return resp.choices[0].message["content"]

def agent_loop(user_input):
    messages = [{"role":"system","content":SYSTEM_PROMPT},
                {"role":"user","content":user_input}]
    while True:
        reply = call_llm(messages)
        data = json.loads(reply)
        if "action" in data:
            result = TOOLS[data["action"]](data["action_input"])
            messages.append({"role":"assistant","content":reply})
            messages.append({"role":"tool","content":result})
        elif "final_answer" in data:
            return data["final_answer"]

if __name__ == "__main__":
    answer = agent_loop("Find the population of France and compute 10% of it.")
    print(answer)

Contoh Kode

Langkah 5: Mengorkestrasi Banyak Agen (Jika Diperlukan)

Untuk alur kerja yang kompleks — misalnya, *sales funnel* multi-langkah, *pipeline* analisis data + pelaporan, atau alur kerja multi-departemen — Anda mungkin ingin **banyak agen bekerja sama**, masing-masing dengan peran yang ditentukan.

Misalnya: agen **Perencana** menentukan langkah-langkah, agen **Pekerja** menjalankan tugas (misalnya, mengambil data, perhitungan), dan agen **Pemeriksa** meninjau hasil untuk kualitas.
Bangun **logika koordinasi** (orkestrator) yang menugaskan tugas ke agen, mengurutkan tindakan, menangani dependensi, dan mengumpulkan hasil.
Gunakan kerangka kerja atau pustaka orkestrasi, atau tulis logika kustom. Seringkali berguna untuk memperlakukan orkestrasi ini seperti lapisan “pengontrol” dalam sebuah aplikasi — meneruskan tugas, hasil, status, dan mengoordinasikan agen.

Ini membuat sistem Anda modular, mudah dipelihara, dan mampu menangani tugas yang kompleks atau berskala besar.

Langkah 6: Tambahkan Memori dan Konteks

Banyak agen yang berguna — asisten obrolan, bot dukungan, agen riset, asisten pribadi — perlu **mengingat interaksi sebelumnya atau pengetahuan yang persisten seiring waktu**. Tanpa memori, setiap interaksi bersifat *stateless* dan tanpa konteks.

Terapkan **memori jangka pendek** (riwayat percakapan, konteks sesi), untuk tugas yang melibatkan interaksi multi-giliran.
Terapkan **memori jangka panjang/basis pengetahuan** — simpan fakta, preferensi pengguna, keputusan masa lalu, data eksternal — seringkali menggunakan *vector database* atau solusi penyimpanan lainnya.
Untuk pengambilan memori dan *grounding*, pertimbangkan untuk menggunakan *retrieval-augmented generation* (RAG): ketika agen membutuhkan konteks, ambil data atau dokumen relevan yang lalu, sematkan dengan *prompt* saat ini, lalu hasilkan.

Dengan menambahkan memori, agen Anda dapat memberikan kesinambungan, personalisasi, dan perilaku yang semakin berguna.

class ConversationMemory:
    def __init__(self):
        self.history = []

    def add(self, message: str):
        self.history.append(message)
        # Optional: trim if too long

    def get_context(self) -> str:
        return "\n".join(self.history)

mem = ConversationMemory()

def run_conversation(input_text):
    mem.add(f"User: {input_text}")
    # pass context to agent
    # agent generates response...
    response = "..."  # from LLM
    mem.add(f"Agent: {response}")
    return response

# Example usage
run_conversation("Hello, who are you?")
run_conversation("Remember my name is Alice.")

Contoh Kode

Langkah 7: Integrasikan Kemampuan Multimedia

Tergantung pada tujuan agen, Anda mungkin ingin atau tidak ingin menambahkan dukungan untuk gambar, suara, video, atau pemrosesan file/dokumen (tergantung pada Agen AI yang Anda coba buat, langkah ini bisa opsional bagi sebagian orang, tetapi bagi sebagian besar, ini cukup penting).

**Untuk suara atau audio:** integrasikan alat *speech-to-text* / *text-to-speech* (misalnya Whisper, sistem ASR/TTS lainnya).
**Untuk gambar / visual:** aktifkan pembuatan gambar atau model yang mampu melihat (jika diperlukan), sehingga agen dapat menganalisis gambar atau menghasilkan visual.
**Untuk pemrosesan dokumen:** *parse* PDF, dokumen Word, atau format data lainnya, dan biarkan agen membaca atau menghasilkan keluaran terstruktur.

Dukungan multimedia memperluas jangkauan tugas yang dapat ditangani agen Anda — mulai dari rangkuman dokumen hingga analisis berbasis gambar atau tugas UI interaktif.

Langkah 8: Format dan Sampaikan Keluaran

Keluaran agen Anda harus **terstruktur dengan baik, bersih, dan dapat digunakan** — baik untuk manusia maupun untuk program atau sistem lain.

Gunakan format keluaran terstruktur (JSON, XML, skema berjenis) ketika keluaran dikonsumsi secara terprogram.
Jika agen menghasilkan laporan, *log*, atau ringkasan yang dapat dibaca manusia — formatlah dengan jelas (Markdown, HTML, PDF, dll.).
Untuk *debugging* atau introspeksi — sertakan metadata (timestamp, *log* panggilan alat, penggunaan *token*) sebagai bagian dari keluaran.

Ini memastikan keluaran dapat diandalkan, dapat diuraikan, dan lebih mudah diintegrasikan ke dalam UI, *pipeline*, atau sistem hilir.

Langkah 9: Bangun Antarmuka Pengguna atau Lapisan API

Akhirnya, bungkus agen AI Anda dalam **antarmuka atau API yang menghadap pengguna** agar dapat digunakan oleh orang lain — baik pengguna internal, pelanggan, atau sistem lain.

Pilihannya antara lain:

REST API (uji semua *endpoint* API Anda dengan Apidog) atau *endpoint* HTTP (misalnya, menggunakan *framework* seperti FastAPI) sehingga aplikasi eksternal dapat memanggil agen secara terprogram. (lebih banyak contoh kode di Real Python)

Menguji Endpoint API dengan Apidog — Menguji Endpoint API di Apidog

UI obrolan sederhana (web atau desktop), atau antarmuka baris perintah agar pengguna dapat berinteraksi.
Penyematan dalam aplikasi yang sudah ada, bot Slack, dasbor, atau *front-end* kustom.

Langkah terakhir ini mengubah agen Anda dari “proyek” menjadi alat yang dapat digunakan — secara efektif, sebuah produk yang memberikan nilai.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class AgentRequest(BaseModel):
    prompt: str

class AgentResponse(BaseModel):
    result: str

@app.post("/api/agent", response_model=AgentResponse)
def call_agent(req: AgentRequest):
    response = agent_loop(req.prompt)  # assume agent_loop is defined
    return {"result": response}

Contoh Kode

Pertanyaan yang Sering Diajukan

Q1. Mengapa mendefinisikan skema input/output terstruktur daripada menggunakan teks bebas?
Skema terstruktur (melalui Pydantic, JSON Schema, dll.) memberikan jaminan — memastikan agen menerima bidang yang diharapkan dan mengembalikan keluaran yang dapat diprediksi serta dapat dibaca mesin. Ini mengurangi kemungkinan data yang salah format, menyederhanakan validasi, dan membuat integrasi dengan sistem lain jauh lebih kuat.

Q2. Apa itu ReAct dan mengapa itu berguna?
ReAct adalah singkatan dari “Reasoning + Action” (Penalaran + Tindakan). Ini adalah pola desain di mana agen bergantian antara berpikir (bernalar) dan melakukan (memanggil alat atau melakukan tindakan), kemudian mengamati hasilnya dan melanjutkan penalaran sesuai kebutuhan. Ini memungkinkan agen untuk melakukan logika multi-langkah, memanggil alat atau API eksternal, dan mendasarkan langkah-langkah selanjutnya pada hasil — menjadikannya jauh lebih kuat daripada bot *prompt-and-respond* sekali jalan yang sederhana.

Q3. Kapan saya harus menggunakan banyak agen daripada satu agen?
Gunakan banyak agen ketika tugasnya kompleks dan melibatkan sub-tugas berbeda yang mendapat manfaat dari spesialisasi — misalnya perencanaan, eksekusi, validasi, atau domain yang berbeda seperti pengambilan data, penalaran, dan pelaporan. Pengaturan multi-agen meningkatkan modularitas, kejelasan, dan ketahanan. (panduan praktis di Empathy First Media)

Q4. Bagaimana memori meningkatkan agen — dan jenis memori apa yang terbaik?
Memori memungkinkan kesinambungan — memungkinkan agen untuk mengingat interaksi sebelumnya, preferensi pengguna, keputusan masa lalu, atau pengetahuan yang terkumpul. Memori jangka pendek (konteks sesi) membantu percakapan multi-giliran; memori jangka panjang (*vector database*, penyimpanan dokumen) mendukung pengambilan pengetahuan, personalisasi, dan penalaran seiring waktu. Untuk banyak aplikasi, kombinasi adalah yang ideal.

Q5. Bagaimana cara aman menerapkan agen AI — dan menghindari *loop* yang tak terkendali atau perilaku tidak aman?
Sebelum penerapan, tambahkan keamanan dan pemantauan: batasi jumlah *loop* penalaran atau panggilan alat per permintaan; terapkan *logging*, penanganan kesalahan, dan *checkpoint human-in-the-loop* untuk tindakan sensitif; pantau penggunaan, biaya, dan kinerja; serta uji kasus-kasus ekstrem secara menyeluruh.

Kesimpulan

Membangun agen AI dari awal adalah upaya yang memuaskan — dan semakin mudah diakses. Dengan mengikuti proses terstruktur — mendefinisikan tujuan, merancang skema yang jelas, menulis instruksi yang solid, memungkinkan penalaran dan penggunaan alat, secara opsional mengorkestrasi banyak agen, menambahkan memori dan konteks, memformat keluaran dengan benar, dan mengekspos antarmuka yang dapat digunakan — Anda dapat membuat agen yang kuat, andal, dan disesuaikan dengan kebutuhan spesifik Anda.

Tidak peduli apa yang Anda bangun (asisten penjualan, alat riset, *chatbot*, atau mesin otomatisasi), panduan langkah demi langkah ini memberikan Anda cetak birunya. Dengan desain yang matang dan arsitektur yang baik, agen AI Anda dapat berkembang dari prototipe menjadi alat yang berguna, mudah dipelihara, dan dapat diskalakan.

Jika Anda siap untuk membangun agen pertama Anda — pilih tujuan sederhana, tulis skemanya, dan cobalah. Setelah dasar-dasarnya berfungsi, Anda dapat menambahkan memori, alat, dan antarmuka, dan saksikan kreasi Anda berkembang menjadi sesuatu yang benar-benar kuat.

💡

button