Ekosistem Artificial Intelligence telah berevolusi melampaui hanya sekedar chatbot dengan single prompt. Kita kini telah memasuki masa Sistem Multi-Agen (Multi-Agent Systems) dimana sekumpulan "agen" cerdas yang otonom dapat berdiskusi, membagi tugas, berdebat, dan menyelesaikan rekayasa perangkat lunak tanpa intervensi manusia secara langsung.
Namun, perkembangan inovasi ini melahirkan masalah baru yaitu Fragmentasi Arsitektur. Bagaimana caranya agen yang dibangun menggunakan framework LangChain bisa berkomunikasi dengan agen yang dibangun di atas ekosistem CrewAI? Bagaimana agen bisa membaca database lokal perusahaan tanpa membocorkan kredensial ke server OpenAI atau Anthropic?. Disinilah standarisasi protokol komunikasi sangat diperlukan dan dalam artikel ini, kita akan eksplorasi secara sederhana tiga terminologi yang paling sering dibahas di dunia AI Engineering yaitu MCP, A2A, dan ACP.
1. Model Context Protocol (MCP)
Digagas secara open-source oleh Anthropic (perusahaan pencipta Claude), Model Context Protocol (MCP) adalah protokol yang memecahkan masalah isolasi model AI. Singkatnya, MCP adalah semacam adapter bahasa universal yang memungkinkan model AI (Host) "berbicara" dengan tools. Secara tradisional, agar sebuah LLM (seperti Claude atau GPT-4) bisa membaca tabel di database PostgreSQL lokal Anda maka Anda harus menulis custom middleware (API) yang mengambil data tersebut dan menyuntikkannya ke dalam prompt. Hal ini sangat merepotkan, tidak scalable, dan rawan celah keamanan. Maka MCP mengubah paradigma ini dengan menciptakan koneksi standar bertipe Client-Server.
Arsitektur MCP: Klien (aplikasi chat atau IDE) menjembatani Model AI untuk "berbicara" langsung dengan Server MCP lokal. Server MCP ini yang memiliki kunci (akses) ke sumber data sungguhan, memastikan Model AI tidak pernah memegang kredensial database Anda.
Anatomi MCP:
- MCP Host: Model AI itu sendiri (Claude, ChatGPT, dsb).
- MCP Client: Aplikasi yang Anda gunakan (seperti Claude Desktop, Cursor IDE, atau aplikasi Node.js kustom Anda) yang menjaga konektivitas.
- MCP Server: Microservice ringan (berjalan di mesin lokal/jaringan tertutup) yang mengekspos spesifikasi tools (seperti
baca_database,tulis_file_lokal). Server ini tidak memiliki kecerdasan, hanya mengeksekusi perintah.
Ketiga komponen anatomi di atas tidak sekadar beroperasi, melainkan didesain secara khusus untuk memecahkan tiga masalah arsitektural fundamental dalam adopsi AI di perusahaan:
1. Zero-Trust AI dan Isolasi Kredensial
Dengan memisahkan antara Host (model AI) dan Server (penyedia tools), MCP secara default mengadopsi prinsip keamanan Zero-Trust. Kredensial sensitif seperti password database atau API Key internal tetap terkunci aman dan hanya diakses oleh MCP Server lokal Anda. Model AI hanya bertugas memberikan instruksi pemanggilan (intent) dan menerima hasil akhir berupa teks, tanpa pernah memegang otorisasi sumber data.
2. Siklus Hidup Eksekusi (The Execution Lifecycle)
Secara operasional, komunikasi ketiga anatomi tersebut berjalan dalam orkestrasi 4 fase yaitu:
- Discovery: MCP Client terhubung dan bertanya kepada MCP Server, "Tools apa saja yang berhak saya gunakan?"
- Negotiation: MCP Client meneruskan daftar tools tersebut ke Model AI. Model AI kemudian merangkai payload JSON berisi nama-nama fungsi dan argumen yang tepat.
- Invocation: MCP Client mencegat JSON tersebut agar tidak tereksekusi di cloud, melainkan memicunya secara lokal di MCP Server.
- Return: Hasil eksekusi database dikembalikan ke Model AI untuk dirangkai menjadi narasi bahasa manusia.
3. Fleksibilitas Jaringan & Konsep "Buat Sekali, Pakai dimana Saja"
MCP dirancang sangat fleksibel dalam hal jalur komunikasi. Ia bisa beroperasi secara langsung melalui terminal komputer (Stdio) jika agen AI dan tools berada di mesin fisik yang sama. Namun, jika tools Anda berada di cloud server terpisah, MCP juga bisa terhubung melalui jalur internet biasa (HTTP SSE).
Berkat standarisasi ini, terwujudlah kebebasan berekosistem (Write Once, Run Everywhere). Anda cukup membuat satu program MCP Server (contoh: program untuk membaca database). Nantinya, program tunggal tersebut bisa langsung dihubungkan ke berbagai aplikasi AI yang berbeda, seperti Claude Desktop, Cursor IDE, atau sistem LangChain buatan Anda sendiri tanpa perlu repot menulis kode integrasi yang berbeda-beda untuk tiap aplikasi.
Membuat Server MCP dengan TypeScript
Mari kita lihat contoh nyata bagaimana membangun sebuah MCP Server menggunakan TypeScript. Server ini akan mengekspos satu tool: membaca informasi cuaca lokal dari terminal.
// mcp-weather-server.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
CallToolRequestSchema,
ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
// 1. Inisialisasi Server MCP
const server = new Server(
{
name: "weather-mcp-server",
version: "1.0.0",
},
{
capabilities: {
tools: {},
},
}
);
// 2. Daftarkan Tools yang bisa "dilihat" oleh AI
server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: [
{
name: "get_weather",
description: "Mendapatkan informasi cuaca berdasarkan nama kota",
inputSchema: {
type: "object",
properties: {
city: {
type: "string",
description: "Nama kota (contoh: Jakarta, London)",
},
},
required: ["city"],
},
},
],
};
});
// 3. Tangani eksekusi Tool saat AI memanggilnya
server.setRequestHandler(CallToolRequestSchema, async (request) => {
if (request.params.name === "get_weather") {
const { city } = request.params.arguments as { city: string };
// (Dalam kasus nyata, di sini Anda melakukan fetch ke API eksternal lokal/BMKG)
const mockWeather = city.toLowerCase() === "jakarta" ? "Cerah Berawan, 32°C" : "Hujan, 18°C";
return {
content: [
{
type: "text",
text: `Cuaca saat ini di ${city} adalah: ${mockWeather}`,
},
],
};
}
throw new Error("Tool tidak ditemukan");
});
// 4. Jalankan server melalui Standard Input/Output (stdio)
// Ini membuat server sangat aman karena tidak membuka port jaringan TCP (Anti-DDoS).
const transport = new StdioServerTransport();
await server.connect(transport);
console.log("Weather MCP Server berjalan dengan aman melalui stdio...");
Dengan mengeksekusi skrip di atas, Claude Desktop (atau client lain) bisa langsung mengetahui bahwa ada fitur "get_weather" yang tersedia di komputer Anda, tanpa harus Anda latih atau berikan prompt sistem yang panjang.
2. Paradigma Agent-to-Agent (A2A)
Jika MCP adalah protokol untuk menghubungkan AI ke data atau tools, maka Agent-to-Agent (A2A) adalah paradigma yang membahas bagaimana satu agen cerdas berbicara dengan agen cerdas lainnya. Sama seperti struktur perusahaan, sekumpulan agen otonom bisa dibagi menjadi berbagai departemen.
Alur Komunikasi A2A (Hierarchical Orchestrator): Orchestrator bertindak sebagai Manajer Proyek. Ia mendelegasikan tugas ke Agen Coder. Ketika Coder selesai, kode dilempar ke Agen QA untuk di-review. Jika gagal, QA akan memberikan teguran dan mengirimkannya kembali ke Coder secara otomatis (Feedback Loop).
Arsitektur A2A Swarm dan Orchestrator
Dalam merancang komunikasi Agent-to-Agent untuk level produksi, para Software Engineer biasanya menghadapi dua pilihan arsitektur utama. Pemilihan di antara keduanya merupakan kompromi (trade-off) yang krusial antara kebebasan berpikir (otonomi) dan kepastian hasil (kendali). Dua pilihan arsitektur tersebut adalah:
1. Decentralized Swarm (Pendekatan Koreografi)
Pada pola ini, agen-agen dilepas ke dalam sebuah lingkungan komunal untuk saling berkomunikasi secara setara (peer-to-peer). Tidak ada sosok manajer pusat. Agen Riset bisa langsung menyapa Agen Penulis, dan Agen Penulis bisa berdiskusi langsung dengan Agen Editor layaknya kerumunan manusia (Swarm).
- Keunggulan: Sistem ini sangat organik, dinamis, dan terukur. Pola yang tepat untuk tugas-tugas open-ended seperti pemecahan masalah (brainstorming) karena agen-agen tersebut bisa menemukan rute penyelesaian yang mungkin tidak terpikirkan oleh developer manusia.
- Kelemahan: Sifatnya yang liar dan Non-Deterministik. Jika tanpa pengawasan, arsitektur Swarm sangat rentan terhadap jebakan Infinite Loop atau "Debat Halusinasi", yaitu kondisi dimana dua agen saling melempar argumen atau revisi secara terus-menerus tanpa titik temu, menguras tagihan token API atau tagihan listrik Anda dalam hitungan menit. Selain itu, melacak sumber masalah (debugging) pada pesan yang menyilang secara acak adalah hal yang sulit dilakukan.
2. Hierarchical Orchestrator (Pendekatan State Graph)
Berkebalikan dengan Swarm, pola ini adalah standar industri (termasuk yang kami terapkan) untuk lingkungan Enterprise. Pola ini mendirikan satu Agen Sentral (atau mesin status / State Machine) yang bertindak sebagai "Konduktor". Para agen bawahan sama sekali tidak diizinkan untuk berbicara satu sama lain; seluruh pesan dan hasil kerja harus dilempar kembali ke Konduktor untuk diarahkan.
- Keunggulan: Alur eksekusi menjadi sangat Deterministik. Anda memiliki kendali penuh atas rute percakapan dan bisa dengan mudah menyelipkan pengawasan manusia (Human-in-the-Loop) di titik-titik krusial sebelum Konduktor meneruskan tugas ke agen berikutnya.
- Implementasi Nyata: Framework seperti LangGraph (dari LangChain) memakai pola ini. Mereka merepresentasikan para agen AI ke dalam simpul-simpul graf berarah (Directed Graph). Jika komunikasi gagal atau membingungkan, sistem secara matematis tahu persis di node mana kegagalan tersebut terjadi.
Contoh Kasus Nyata A2A
Bayangkan sebuah startup yang seluruh departemen QA-nya dijalankan oleh mesin.
- User memberikan PR (Pull Request) Github.
- Agen Coder (GPT-4o) membaca PR tersebut dan menulis unit test-nya.
- Sebelum langsung dimerge, kode dikirim ke Agen Security (Claude 3.5 Sonnet).
- Agen Security mendeteksi celah SQL Injection. Ia "menolak" hasil kerja Coder, dan mengirimkan pesan balik: "Tolong gunakan Prepared Statements pada baris 42".
- Agen Coder memperbaiki kode dan mengirimkannya kembali ke Security. Siklus (loop) ini terjadi di belakang layar dalam 30 detik tanpa manusia menyadarinya.
Implementasi Koding Orchestrator A2A dengan LangGraph
Untuk mewujudkan kasus di atas secara terstruktur tanpa terjebak infinite loop, kita wajib menggunakan pendekatan State Graph. Berikut adalah abstraksi kode bagaimana seorang Orchestrator mengatur rute komunikasi menggunakan LangGraph (TypeScript):
import { StateGraph, END } from "@langchain/langgraph";
// 1. Mendefinisikan State (Konteks memori yang mengalir antar agen)
interface SistemState {
kode_sumber: string;
catatan_revisi: string;
status_keamanan: "pending" | "approved" | "rejected";
}
// 2. Inisialisasi Graf Berarah (Directed Graph)
const orkestrator = new StateGraph<SistemState>({ /* definisi state */ });
// 3. Mendefinisikan Simpul (Node) Para Agen
orkestrator.addNode("AgenCoder", async (state) => {
const kodeBaru = await panggilLlmCoder(state.catatan_revisi);
return { kode_sumber: kodeBaru, status_keamanan: "pending" };
});
orkestrator.addNode("AgenSecurity", async (state) => {
const hasilReview = await panggilLlmSecurity(state.kode_sumber);
return {
catatan_revisi: hasilReview.catatan,
status_keamanan: hasilReview.keputusan // "approved" atau "rejected"
};
});
// 4. Membangun Aturan Jalur Komunikasi (Edges)
orkestrator.setEntryPoint("AgenCoder"); // Pekerjaan selalu dimulai dari Coder
// Coder tidak berhak merilis, ia WAJIB menyerahkan kodenya ke Security
orkestrator.addEdge("AgenCoder", "AgenSecurity");
// Logika Percabangan (Conditional Routing) dari Agen Security
orkestrator.addConditionalEdges("AgenSecurity", (state) => {
if (state.status_keamanan === "rejected") {
// Feedback Loop: Tolak dan lemparkan kembali ke Agen Coder
return "AgenCoder";
}
// Jika "approved", alur komputasi diizinkan untuk selesai
return END;
});
// 5. Kompilasi Graph menjadi sistem A2A yang siap dieksekusi
const sistemA2A = orkestrator.compile();
Blok kode di atas adalah contoh implementasi dari Hierarchical Orchestrator. Karena aturan komunikasi didefinisikan secara matematis sebagai Graf, kita bisa mengunci kepastian sistem; Agen Coder tidak akan pernah bisa menyentuh garis akhir (END) jika belum mendapat status approved dari Agen Security. Dengan pola ini, developer dapat dengan mudah melakukan debugging pada sistem AI yang kompleks. Inilah kontrol yang dibutuhkan oleh perusahaan-perusahaan dalam mengoperasikan agen-agen AI
3. Agent Communication Protocol (ACP)
Sejauh ini, kita telah membahas mengenai cara agen berkomunikasi jika mereka berada di dalam satu ekosistem yang sama (misalnya sesama pengguna LangChain). Namun, realita infrastruktur Enterprise sering kali jauh lebih terfragmentasi. Mari kita perluas skenario sebelumnya: Bagaimana jika Agen Coder di perusahaan Anda dibangun oleh tim internal menggunakan LangChain, tetapi untuk urusan audit keamanan, manajemen memutuskan untuk menyewa Agen Security pihak ketiga yang berjalan di atas mesin CrewAI yang tertutup (proprietary)?
Karena kedua agen cerdas ini lahir dari dua framework yang berbeda, mereka ibarat dua manusia yang tidak memiliki bahasa yang sama; struktur memori mereka berbeda, cara mereka mengurai pesan pun berbeda. Mereka tidak bisa saling berdiskusi. Untuk menjembatani jurang komunikasi beda-ekosistem inilah, standarisasi Agent Communication Protocol (ACP) dirumuskan. Sama seperti REST API yang memungkinkan sistem Java berbicara dengan Node.js, ACP menjadi semacam Jembatan Bahasa Universal agar agen dari berbagai ekosistem dapat saling mengerti intent, struktur pesan, dan pembagian tugas.
ACP (atau standarisasi sejenis seperti FIPA-ACL) berusaha membuat spesifikasi JSON abstrak. Ketika sebuah agen mengirim pesan, pesan tersebut bukan sekadar teks bebas ("Hei, tolong periksa kode ini"), melainkan memiliki standar struktur (meta-data) seperti ini:
{
"protocol": "ACP_v1",
"sender_id": "agent_coder_01",
"receiver_id": "agent_security_02",
"performative": "REQUEST",
"payload": {
"task": "security_audit",
"context": "github_pr_104",
"content": "function login(user, pass) { ... }"
},
"deadline": "2026-08-27T10:00:00Z"
}
Dengan struktur seperti ini, kerangka kerja apa pun yang membungkus agen penerima dapat mem-parsing (menguraikan) pesan, memasukkannya ke dalam memori vektor mereka, dan membalasnya dengan format yang sama. Ini membebaskan developer dari jebakan integrasi khusus (vendor lock-in).
Implementasi Membangun ACP Bridge Sederhana
Dalam praktiknya, implementasi ACP sering kali berbentuk API Gateway atau layanan Webhook yang berdiri di depan agen AI tersebut. Gateway ini bertugas menerima JSON berstandar ACP, dan menerjemahkannya ke dalam aksi internal framework (contoh LangChain). Berikut adalah abstraksi kode TypeScript menggunakan Express.js untuk mendemonstrasikan bagaimana agen Anda sebagai penerima memproses pesan ACP dari agen eksternal:
import express, { Request, Response } from 'express';
const app = express();
app.use(express.json());
// 1. Definisi Kontrak Bahasa Universal (ACP)
interface AcpMessage {
protocol: string;
sender_id: string;
receiver_id: string;
performative: "REQUEST" | "INFORM" | "FAILURE";
payload: {
task: string;
context: string;
content: string;
};
}
// 2. Membuka gate komunikasi untuk agen eksternal
app.post('/acp-bridge', async (req: Request, res: Response) => {
const pesanMasuk: AcpMessage = req.body;
// Pastikan agen pengirim menggunakan bahasa protokol yang sama
if (pesanMasuk.protocol !== "ACP_v1") {
return res.status(400).send("Protokol tidak dikenali.");
}
// 3. Menangkap Intent Agen Eksternal
if (pesanMasuk.performative === "REQUEST") {
console.log(`[ACP] Menerima tugas: ${pesanMasuk.payload.task} dari ${pesanMasuk.sender_id}`);
// 4. Menerjemahkan pesan ke dalam sistem lokal (Misal: LangGraph kita)
// Asumsi 'sistemA2A' adalah orkestrator yang sudah kita buat di bab sebelumnya
const eksekusiLokal = await sistemA2A.invoke({
kode_sumber: pesanMasuk.payload.content,
catatan_revisi: pesanMasuk.payload.context
});
// 5. Membungkus hasil kerja lokal ke dalam format ACP lagi
const balasanACP: AcpMessage = {
protocol: "ACP_v1",
sender_id: pesanMasuk.receiver_id, // ID Agen kita bertukar posisi
receiver_id: pesanMasuk.sender_id, // Dikembalikan ke pengirim awal
performative: "INFORM",
payload: {
task: "security_audit_completed",
context: "audit_passed",
content: eksekusiLokal.catatan_revisi
}
};
return res.json(balasanACP);
}
});
app.listen(3000, () => console.log('ACP Bridge Agent Security berjalan di port 3000'));
Melalui kehadiran ACP Bridge Gateway seperti kode di atas, agen LangChain Anda kini memiliki sebuah URL yang bisa dipanggil. Agen CrewAI milik vendor eksternal cukup memanggil HTTP POST dengan payload JSON ACP standar ke URL tersebut.
Kerumitan perbedaan framework, perbedaan prompt engineering, dan perbedaan bahasa pemrograman / framework tidak menjadi masalah dan digantikan oleh handshake antar API yang terstruktur dan mudah dipahami antar sistem.
4. Desain Agent Control Center
Melihat sekumpulan agen AI berdebat lewat teks terminal sungguh tidak nyaman bagi para eksekutif atau Product Manager. Membangun sistem multi-agen modern juga berarti membangun antarmuka (UI) untuk memantau sistem tersebut.
UI System Design: Sebuah Agent Control Center. Terdapat visualisasi topologi (agen mana yang sedang aktif dan berbicara dengan siapa), berdampingan dengan log terminal (pesan JSON aktual yang sedang mengalir melalui protokol ACP/MCP).
Antarmuka ini sangat penting di perusahaan agar manajer manusia tetap bisa memantau lalu-lintas keputusan agen AI. Jika Agen A dan Agen B terjebak dalam infinite loop, manusia dapat segera mengintervensi dengan menekan tombol Kill-Switch atau melakukan injeksi pesan manual (Human-in-the-loop).
Batas antara perangkat lunak dan pekerja otonom perlahan menghilang.
- Gunakan MCP (Model Context Protocol) jika agen AI Anda perlu membaca database MySQL secara aman, mengontrol browser, atau membaca file PDF di hard drive lokal Anda tanpa merusak standar keamanan IT korporat.
- Pahami paradigma A2A (Agent-to-Agent) untuk merancang orkestrasi internal aplikasi Anda. Bagilah LLM raksasa Anda menjadi peran-peran sempit spesialis (Arsitek, QA, Penulis) agar output-nya jauh lebih presisi dan halusinasi ditekan ke angka nol.
- Pahami dan awasi perkembangan standar ACP (Agent Communication Protocol) agar aplikasi yang Anda kembangkan hari ini bisa berkomunikasi dengan miliaran agen lainnya di internet di masa depan.
Kita bukan lagi sekadar menulis code; kita sedang menyusun arsitektur untuk masyarakat silikon (sistem agen AI) agar mereka dapat saling berbicara, berdagang informasi, dan berinovasi di atas cloud.
Tetap semangat belajar, bereksplorasi, dan jangan pernah berhenti membangun hal-hal yang luar biasa!