<frendi />
Konsultasi gratis
← Kembali ke blog

Tutorial: Membangun AI Agent Self-Evolving dengan Skills, MCP, dan Lineage

Tutorial praktis membangun AI agent self-evolving dengan skill registry, MCP, SQLite persistence, lineage, regression test, human approval, dan rollback.

Tutorial••Frendi Triarista
#AI Automation#AI Agent#LLM Implementation#MCP#Data Automation#API Integration
Tutorial: Membangun AI Agent Self-Evolving dengan Skills, MCP, dan Lineage

Tutorial: Membangun AI Agent Self-Evolving dengan Skills, MCP, dan Lineage

AI agent yang hanya menerima prompt lalu menghasilkan jawaban cocok untuk eksperimen sederhana. Untuk workflow berulang, pola yang lebih berguna adalah agent yang dapat memakai ulang skill, memanggil tools melalui MCP, menyimpan state, dan melacak asal-usul setiap hasil.

Tutorial ini mengambil inspirasi dari tutorial MarkTechPost tentang OpenSpace, skill evolution, MCP, SQLite persistence, lineage, dan low-cost reuse. Contoh di bawah adalah pola implementasi yang dapat disesuaikan, bukan salinan benchmark atau klaim bahwa sistem sudah siap production.

Target tutorial

Di akhir tutorial, kita akan memiliki rancangan agent yang dapat:

  • menerima task terstruktur;
  • mencari skill yang sudah tersedia;
  • memanggil tool melalui lapisan MCP;
  • menyimpan versi skill dan riwayat eksekusi;
  • mengusulkan skill baru ketika workflow belum memiliki prosedur;
  • meminta review sebelum skill baru menjadi versi aktif;
  • melakukan rollback ke versi sebelumnya.

Contoh workflow yang digunakan adalah membuat ringkasan laporan penjualan. Pola yang sama dapat diterapkan pada rekonsiliasi data non-finansial, pemeriksaan dokumen, triase issue, analisis log, atau pembuatan laporan operasional.

1. Tentukan batas workflow

Jangan mulai dari agent yang boleh melakukan semua hal. Pilih satu workflow dengan input dan output yang jelas.

Contoh:

Input: file CSV penjualan
Output: ringkasan omzet per produk dan kanal
Tools: baca file, hitung agregasi, simpan draft laporan
Approval: wajib sebelum laporan dikirim ke pihak eksternal

Tentukan juga tindakan yang tidak boleh dilakukan agent:

  • mengubah data sumber;
  • mengirim email atau pesan eksternal;
  • mengakses database production tanpa izin;
  • menghapus file;
  • menambah permission sendiri;
  • mengaktifkan skill baru tanpa review.

Batas ini menjadi dasar permission, test case, dan audit log.

2. Siapkan environment eksperimen

Pisahkan eksperimen dari production. Gunakan virtual environment, data sintetis atau salinan terbatas, dan token API dengan scope minimum.

Contoh struktur project:

self-evolving-agent/
├── app/
│   ├── agent.py
│   ├── skills.py
│   ├── lineage.py
│   └── mcp_client.py
├── skills/
│   ├── sales_summary/
│   │   ├── skill.yaml
│   │   └── instructions.md
│   └── README.md
├── tests/
├── data/
│   └── sample_sales.csv
└── agent.db

Untuk prototype lokal, SQLite cukup untuk menyimpan registry dan riwayat. Jangan menyimpan secret API atau data pelanggan mentah di repository.

3. Buat schema skill registry

Skill bukan sekadar prompt panjang. Perlakukan skill sebagai artefak software yang memiliki identitas, versi, input, output, permission, dan test case.

Contoh schema SQLite:

CREATE TABLE skills (
    id TEXT PRIMARY KEY,
    name TEXT NOT NULL,
    version TEXT NOT NULL,
    status TEXT NOT NULL,
    instructions TEXT NOT NULL,
    input_schema TEXT NOT NULL,
    output_schema TEXT NOT NULL,
    permissions TEXT NOT NULL,
    parent_skill_id TEXT,
    created_at TEXT NOT NULL
);

CREATE TABLE runs (
    id TEXT PRIMARY KEY,
    task_name TEXT NOT NULL,
    skill_id TEXT,
    skill_version TEXT,
    input_hash TEXT NOT NULL,
    output_json TEXT,
    status TEXT NOT NULL,
    reviewer TEXT,
    created_at TEXT NOT NULL
);

CREATE TABLE lineage_events (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    run_id TEXT NOT NULL,
    event_type TEXT NOT NULL,
    source_id TEXT,
    detail_json TEXT NOT NULL,
    created_at TEXT NOT NULL
);

Status skill dapat dibuat sederhana:

  • experimental, baru dibuat atau sedang diuji;
  • reviewed, sudah diperiksa manusia;
  • stable, boleh dipakai pada workflow yang disetujui;
  • retired, tidak boleh dipakai untuk run baru.

4. Definisikan skill pertama

Contoh file skills/sales_summary/skill.yaml:

id: sales_summary
version: 1.0.0
status: experimental
input:
  required: [csv_path]
output:
  required: [total_sales, by_product, by_channel, caveats]
permissions:
  - filesystem.read:data/sample_sales.csv
  - compute.aggregate
side_effects: none

Instruksinya dapat berisi langkah deterministik:

1. Baca CSV tanpa mengubah file sumber.
2. Validasi kolom wajib dan laporkan baris yang tidak valid.
3. Hitung total penjualan per produk dan kanal.
4. Jangan mengisi data yang hilang dengan tebakan.
5. Kembalikan JSON sesuai output schema.
6. Sertakan caveats jika ada baris yang dilewati.

Semakin jelas input dan output schema, semakin mudah hasilnya divalidasi dan dipakai oleh workflow berikutnya.

5. Hubungkan tools melalui MCP

MCP dapat dipakai sebagai lapisan terstruktur untuk menghubungkan agent dengan tool dan resource eksternal. Dalam tutorial ini, MCP hanya mengekspos tool yang diperlukan:

read_sales_csv(path)
aggregate_sales(rows, group_by)
write_draft_report(report)

MCP bukan alasan untuk membuka semua sistem kepada agent. Setiap server dan tool harus memiliki:

  • identitas pemanggil;
  • scope permission;
  • validasi input;
  • timeout;
  • audit log;
  • batas ukuran data;
  • error handling;
  • mekanisme pencabutan akses.

Untuk tahap awal, write_draft_report sebaiknya hanya menulis ke folder draft. Pengiriman keluar tetap membutuhkan approval.

6. Buat loop agent yang dapat memakai ulang skill

Loop dasarnya dapat dirancang seperti berikut:

def run_task(task):
    skill = registry.find_matching_skill(task)

    if skill is None:
        plan = planner.create_plan(task)
        draft_skill = skill_builder.propose(plan)
        lineage.record("skill_proposed", draft_skill.id)
        return request_human_review(draft_skill)

    validate_permissions(skill, task)
    run_id = lineage.start_run(task, skill)

    result = executor.run(
        skill=skill,
        tools=mcp_tools_for(skill),
        input=task.input,
    )

    validate_output(result, skill.output_schema)
    lineage.finish_run(run_id, result)
    return result

Perhatikan bahwa agent tidak langsung mengaktifkan skill baru. Ketika skill belum ada, agent hanya membuat proposal dan meminta review.

7. Terapkan skill evolution dengan versi

Skill evolution sebaiknya berupa perubahan yang dapat dibandingkan, bukan overwrite tanpa sejarah.

Alur yang lebih aman:

  1. Agent gagal atau menerima feedback terhadap hasil.
  2. Sistem menyimpan input, output, error, dan feedback.
  3. Agent mengusulkan perubahan skill.
  4. Sistem membuat versi baru, misalnya 1.1.0.
  5. Test case lama dijalankan terhadap versi baru.
  6. Reviewer membandingkan output versi lama dan versi baru.
  7. Versi baru hanya menjadi stable setelah lolos approval.
  8. Jika kualitas menurun, registry tetap menggunakan versi lama.

Contoh evaluasi sederhana:

def evaluate_candidate(old_skill, new_skill, test_cases):
    old_score = run_regression(old_skill, test_cases)
    new_score = run_regression(new_skill, test_cases)

    return {
        "old_score": old_score,
        "new_score": new_score,
        "accepted": new_score >= old_score and new_score >= 0.95,
    }

Batas 0.95 hanya contoh. Threshold harus ditentukan berdasarkan risiko workflow, kualitas data, dan kebutuhan bisnis.

8. Simpan lineage untuk debugging dan audit

Lineage menjawab pertanyaan berikut:

  • Task apa yang dijalankan?
  • Skill dan versi berapa yang digunakan?
  • Tool MCP apa saja yang dipanggil?
  • Data apa yang menjadi sumber?
  • Output mana yang dihasilkan?
  • Siapa yang menyetujui perubahan?
  • Mengapa skill berevolusi?

Contoh event:

{
  "run_id": "run-2026-07-27-001",
  "event": "tool_call",
  "tool": "read_sales_csv",
  "skill": "[email protected]",
  "input_hash": "sha256:...",
  "result": "success"
}

Jangan menyimpan secret dalam lineage. Untuk data sensitif, simpan hash, identifier, atau ringkasan yang cukup untuk audit tanpa menyalin seluruh isi data.

9. Tambahkan regression test

Skill yang berkembang sendiri membutuhkan test yang stabil. Gunakan fixture kecil dengan hasil yang sudah diketahui.

Contoh test case:

{
  "name": "sales_by_product_basic",
  "input": "tests/fixtures/sales-basic.csv",
  "expected": {
    "total_sales": 1500000,
    "products": 3
  }
}

Test minimal yang perlu ada:

  • input normal;
  • kolom wajib hilang;
  • nilai nominal tidak valid;
  • data kosong;
  • duplikasi baris;
  • format tanggal berbeda;
  • hasil yang harus ditolak karena permission;
  • output yang melanggar schema.

Jalankan test setiap kali skill berubah. Jangan menjadikan satu contoh sukses sebagai bukti bahwa skill sudah aman.

10. Buat human approval dan rollback

Gunakan tiga tingkat tindakan:

Tingkat Contoh Perlakuan
Read Membaca dan merangkum data Dapat otomatis dengan logging
Draft Membuat laporan atau tiket Review manusia
Write/External Mengubah data atau mengirim pesan Approval eksplisit

Rollback harus sederhana. Simpan setiap versi skill sebagai artefak immutable dan ubah pointer versi aktif di registry. Jika versi 1.2.0 bermasalah, kembalikan pointer ke 1.1.0 tanpa menghapus lineage.

11. Ukur apakah reuse benar-benar bermanfaat

Low-cost reuse tidak boleh hanya menjadi asumsi. Ukur baseline sebelum agent memakai skill registry:

  • durasi proses;
  • jumlah tool call;
  • biaya model;
  • biaya infrastruktur;
  • error rate;
  • koreksi manual;
  • jumlah retry;
  • waktu reviewer.

Bandingkan metrik tersebut setelah skill dipakai ulang. Jika reuse membuat output lebih murah tetapi koreksi manual meningkat, sistem belum benar-benar efisien.

12. Contoh penerapan untuk bisnis Indonesia

Pola ini dapat dimulai dari workflow yang tidak mengubah data penting secara langsung:

  • membuat laporan penjualan mingguan;
  • membaca invoice dan membuat draft rekap;
  • menggabungkan data spreadsheet dan CRM;
  • mengelompokkan tiket customer support;
  • memeriksa kelengkapan dokumen;
  • membuat ringkasan operasional;
  • menyiapkan draft notifikasi internal.

Untuk UMKM, SQLite dan folder lokal dapat cukup untuk prototype. Untuk production, tambahkan database yang sesuai, secret manager, observability, backup, permission terpusat, dan pemisahan environment.

Checklist sebelum production

  • Skill memiliki input dan output schema.
  • Versi skill tercatat dan tidak di-overwrite.
  • MCP tools memiliki permission minimum.
  • Semua tool call masuk audit log.
  • Data sensitif tidak disimpan mentah tanpa kebijakan.
  • Regression test berjalan setiap ada perubahan.
  • Skill baru melewati approval manusia.
  • Workflow memiliki fallback manual.
  • Rollback ke versi stabil sudah diuji.
  • Biaya, latency, error, dan intervensi manusia dipantau.

Penutup

Self-evolving AI agent bukan berarti agent bebas mengubah dirinya sendiri di production. Pola yang lebih aman adalah agent dapat mengusulkan skill, membuat versi baru di sandbox, menjalankan test, menyimpan lineage, dan menunggu approval sebelum digunakan.

MCP menyediakan jalur integrasi tools, SQLite dapat menjadi persistence ringan untuk prototype, dan skill registry membuat kemampuan agent lebih mudah dipakai ulang. Nilai bisnisnya baru terlihat setelah dibandingkan dengan baseline: waktu, biaya, error, dan pekerjaan koreksi manual.

Mulai dari satu workflow berisiko rendah. Bangun registry, test, audit, dan rollback terlebih dahulu. Setelah fondasinya stabil, barulah perluas agent ke proses yang memiliki dampak lebih besar.

Referensi