1~
2**Model Context Protocol (MCP)** adalah standar terbuka yang dibuat oleh Anthropic yang mendefinisikan bagaimana model AI berkomunikasi dengan tools eksternal, sumber data, dan layanan. Anggap saja ini sebagai "USB-C untuk AI"  -  konektor universal yang memungkinkan agen AI mana pun berkomunikasi dengan tools apa pun melalui antarmuka yang terstandarisasi.
3~
4Sejak peluncurannya, MCP telah melampaui **97 juta unduhan SDK bulanan** dan telah diadopsi oleh setiap penyedia AI utama: Anthropic, OpenAI, Google, Microsoft, dan Amazon. Dalam panduan ini, kita akan menjelajahi semua yang perlu Anda ketahui untuk membangun dengan MCP.
5~
6## Mengapa MCP Ada
7~
8Sebelum MCP, setiap aplikasi AI harus membangun integrasi khusus untuk setiap tools yang ingin digunakan. Ingin AI Anda membaca file? Tulis kode khusus. Kueri database? Lebih banyak kode khusus. Posting ke Slack? Integrasi lain lagi.
9~
10Ini menciptakan **masalah N×M**: N aplikasi AI masing-masing membutuhkan M integrasi khusus, yang mengakibatkan duplikasi usaha dan ekosistem yang terfragmentasi.
11~
12```mermaid
13graph TD
14    subgraph "Before MCP (N×M)"
15        A1[AI App 1] --> T1[GitHub Integration]
16        A1 --> T2[Slack Integration]
17        A1 --> T3[DB Integration]
18        A2[AI App 2] --> T4[GitHub Integration]
19        A2 --> T5[Slack Integration]
20        A2 --> T6[DB Integration]
21    end
22```
23~
24MCP menyelesaikan ini dengan **satu protokol** yang dapat digunakan klien AI mana pun untuk berkomunikasi dengan server MCP mana pun:
25~
26```mermaid
27graph TD
28    subgraph "With MCP (N+M)"
29        A1[AI App 1] --> MCP[MCP Protocol]
30        A2[AI App 2] --> MCP
31        MCP --> S1[GitHub Server]
32        MCP --> S2[Slack Server]
33        MCP --> S3[DB Server]
34    end
35```
36~
37## Konsep Inti
38~
39MCP memiliki tiga primitif fundamental:
40~
41### 1. Tools
42Tools adalah fungsi yang dapat dipanggil AI. Mereka merepresentasikan aksi seperti "buat file", "kueri database", atau "kirim pesan". Setiap tool memiliki nama, deskripsi, dan JSON Schema untuk parameternya.
43~
44```typescript
45{
46  name: "create_issue",
47  description: "Create a new GitHub issue",
48  inputSchema: {
49    type: "object",
50    properties: {
51      title: { type: "string", description: "Issue title" },
52      body: { type: "string", description: "Issue body" },
53      repo: { type: "string", description: "Repository name" }
54    },
55    required: ["title", "repo"]
56  }
57}
58```
59~
60### 2. Resources
61Resources adalah data yang dapat dibaca AI. Mereka merepresentasikan file, catatan database, respons API, atau sumber data lainnya. Resources diidentifikasi melalui URI.
62~
63```typescript
64{
65  uri: "file:///Users/dev/project/README.md",
66  name: "Project README",
67  mimeType: "text/markdown"
68}
69```
70~
71### 3. Prompts
72Prompts adalah template yang dapat digunakan kembali yang membantu menyusun interaksi. Mereka dapat menyertakan parameter dinamis dan berguna untuk menstandarisasi alur kerja umum.
73~
74```typescript
75{
76  name: "code_review",
77  description: "Review code changes for quality and security",
78  arguments: [
79    { name: "diff", description: "The code diff to review", required: true }
80  ]
81}
82```
83~
84## Arsitektur
85~
86MCP mengikuti arsitektur klien-server:
87~
88```mermaid
89graph LR
90    subgraph "Host Application"
91        Client[MCP Client]
92    end
93~
94    subgraph "MCP Server"
95        Server[Server Process]
96        Server --> Tools[Tools]
97        Server --> Resources[Resources]
98        Server --> Prompts[Prompts]
99    end
100~
101    Client -- "JSON-RPC 2.0\n(stdio or SSE)" --> Server
102```
103~
104- **Host**: Aplikasi AI (Claude Desktop, Cursor, aplikasi kustom Anda)
105- **Client**: Mempertahankan koneksi 1:1 dengan server MCP
106- **Server**: Mengekspos tools, resources, dan prompts ke klien
107- **Transport**: Komunikasi terjadi melalui JSON-RPC 2.0 via stdio (lokal) atau Server-Sent Events (remote)
108~
109## Membangun Server MCP
110~
111Mari kita bangun server MCP praktis yang berinteraksi dengan daftar tugas yang disimpan dalam file JSON.
112~
113### Setup
114~
115```bash
116mkdir mcp-todo-server && cd mcp-todo-server
117npm init -y
118npm install @modelcontextprotocol/sdk zod
119```
120~
121### Implementasi Server
122~
123```typescript
124// src/index.ts
125import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
126import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
127import { z } from "zod";
128import fs from "fs";
129~
130const TODO_FILE = "./todos.json";
131~
132function readTodos(): { id: number; text: string; done: boolean }[] {
133  if (!fs.existsSync(TODO_FILE)) return [];
134  return JSON.parse(fs.readFileSync(TODO_FILE, "utf-8"));
135}
136~
137function writeTodos(todos: { id: number; text: string; done: boolean }[]) {
138  fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2));
139}
140~
141const server = new McpServer({
142  name: "todo-server",
143  version: "1.0.0",
144});
145~
146// Tool: Add a todo
147server.tool(
148  "add_todo",
149  "Add a new todo item",
150  { text: z.string().describe("The todo text") },
151  async ({ text }) => {
152    const todos = readTodos();
153    const newTodo = { id: Date.now(), text, done: false };
154    todos.push(newTodo);
155    writeTodos(todos);
156    return { content: [{ type: "text", text: `Added: "${text}"` }] };
157  }
158);
159~
160// Tool: List todos
161server.tool(
162  "list_todos",
163  "List all todo items",
164  {},
165  async () => {
166    const todos = readTodos();
167    const list = todos
168      .map((t) => `${t.done ? "✅" : "⬜"} [${t.id}] ${t.text}`)
169      .join("\n");
170    return { content: [{ type: "text", text: list || "No todos yet." }] };
171  }
172);
173~
174// Tool: Complete a todo
175server.tool(
176  "complete_todo",
177  "Mark a todo as completed",
178  { id: z.number().describe("The todo ID to complete") },
179  async ({ id }) => {
180    const todos = readTodos();
181    const todo = todos.find((t) => t.id === id);
182    if (!todo) return { content: [{ type: "text", text: "Todo not found." }] };
183    todo.done = true;
184    writeTodos(todos);
185    return { content: [{ type: "text", text: `Completed: "${todo.text}"` }] };
186  }
187);
188~
189// Resource: Current todos as a readable resource
190server.resource(
191  "todos://list",
192  "Current todo list",
193  async () => ({
194    contents: [{
195      uri: "todos://list",
196      mimeType: "application/json",
197      text: JSON.stringify(readTodos(), null, 2),
198    }],
199  })
200);
201~
202// Start the server
203const transport = new StdioServerTransport();
204await server.connect(transport);
205```
206~
207### Konfigurasi
208~
209Untuk menggunakan server ini dengan Claude Desktop, tambahkan ke konfigurasi Anda:
210~
211```json
212{
213  "mcpServers": {
214    "todo": {
215      "command": "npx",
216      "args": ["tsx", "/path/to/mcp-todo-server/src/index.ts"]
217    }
218  }
219}
220```
221~
222## Membangun Klien MCP
223~
224Anda juga dapat membangun klien kustom yang terhubung ke server MCP mana pun:
225~
226```typescript
227import { Client } from "@modelcontextprotocol/sdk/client/index.js";
228import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
229~
230const transport = new StdioClientTransport({
231  command: "npx",
232  args: ["tsx", "./src/index.ts"],
233});
234~
235const client = new Client({ name: "my-client", version: "1.0.0" });
236await client.connect(transport);
237~
238// List available tools
239const { tools } = await client.listTools();
240console.log("Available tools:", tools.map((t) => t.name));
241~
242// Call a tool
243const result = await client.callTool({
244  name: "add_todo",
245  arguments: { text: "Write MCP blog post" },
246});
247console.log(result);
248```
249~
250## Server MCP Populer
251~
252Ekosistem MCP telah berkembang pesat. Berikut beberapa server paling populer:
253~
254| Server | Deskripsi | Kasus Penggunaan |
255|--------|-----------|-----------------|
256| **GitHub** | Buat issue, PR, kelola repo | Alur kerja pengembangan |
257| **Slack** | Kirim pesan, kelola channel | Komunikasi tim |
258| **PostgreSQL** | Kueri dan kelola database | Akses data |
259| **Filesystem** | Baca, tulis, dan cari file | Pengembangan lokal |
260| **Puppeteer** | Otomasi browser dan scraping | Pengujian web |
261| **Sentry** | Pemantauan error dan debugging | Dukungan produksi |
262| **Supabase** | Database, auth, penyimpanan | Operasi backend |
263~
264## MCP vs A2A (Agent-to-Agent)
265~
266Sementara MCP menangani komunikasi **agen-ke-tools**, protokol **A2A (Agent-to-Agent)** dari Google menangani komunikasi **agen-ke-agen**. Keduanya saling melengkapi:
267~
268```mermaid
269graph TD
270    Agent1[Agent 1] -- "A2A Protocol" --> Agent2[Agent 2]
271    Agent1 -- "MCP Protocol" --> Tool1[GitHub MCP Server]
272    Agent2 -- "MCP Protocol" --> Tool2[Database MCP Server]
273```
274~
275- **MCP**: Bagaimana agen AI menggunakan tools (integrasi vertikal)
276- **A2A**: Bagaimana agen AI berkolaborasi satu sama lain (integrasi horizontal)
277~
278## Praktik Terbaik
279~
2801. **Jaga server tetap fokus**: Satu server per domain (server GitHub, server Slack, dll.). Jangan bangun server monolitik.
2812. **Validasi input dengan Zod**: Selalu validasi input tools dengan schema yang tepat.
2823. **Tangani error dengan baik**: Kembalikan pesan error yang bermakna, bukan stack trace.
2834. **Gunakan resources untuk data read-only**: Jika AI hanya perlu membaca data, ekspos sebagai resource bukan tool.
2845. **Tambahkan deskripsi yang tepat**: Deskripsi tools dan parameter yang baik membantu AI memahami kapan dan bagaimana menggunakan setiap tool.
2856. **Uji dengan MCP Inspector**: Gunakan `npx @modelcontextprotocol/inspector` untuk menguji server Anda secara interaktif.
286~
287## Memulai
288~
289```bash
290# Create a new MCP server from template
291npx @modelcontextprotocol/create-server my-server
292~
293# Test with the MCP Inspector
294npx @modelcontextprotocol/inspector npx tsx ./src/index.ts
295```
296~
297## Kesimpulan
298~
299MCP telah menjadi standar de facto untuk penggunaan tools AI pada tahun 2026. Baik Anda membangun agen AI kustom, memperluas Claude Code, atau membuat integrasi untuk platform yang sudah ada, memahami MCP sangat penting. Protokol ini cukup sederhana untuk dipelajari dalam satu sore tetapi cukup kuat untuk membangun alur kerja AI tingkat produksi.
300~
301**Langkah selanjutnya:**
302- Jelajahi [Spesifikasi MCP](https://spec.modelcontextprotocol.io/)
303- Telusuri [server MCP yang ada](https://github.com/modelcontextprotocol/servers) untuk inspirasi
304- Bangun server pertama Anda dengan TypeScript atau Python SDK
305- Uji dengan Claude Desktop atau MCP Inspector
306~