1~
2**Model Context Protocol (MCP)** ialah standard terbuka yang dicipta oleh Anthropic yang mentakrifkan cara model AI berkomunikasi dengan alat luaran, sumber data dan perkhidmatan. Fikirkan ia sebagai "USB-C untuk AI"  -  penyambung sejagat yang membolehkan mana-mana ejen AI berkomunikasi dengan mana-mana alat melalui antara muka yang diseragamkan.
3~
4Sejak pelancaran, MCP telah melepasi **97 juta muat turun SDK bulanan** dan telah diterima pakai oleh semua pembekal AI utama: Anthropic, OpenAI, Google, Microsoft dan Amazon. Dalam panduan ini, kita akan meneroka semua yang anda perlu tahu untuk membina dengan MCP.
5~
6## Mengapa MCP Wujud
7~
8Sebelum MCP, setiap aplikasi AI perlu membina integrasi tersuai untuk setiap alat yang ingin digunakan. Mahu AI anda membaca fail? Tulis kod tersuai. Buat pertanyaan pangkalan data? Lagi kod tersuai. Pos ke Slack? Satu lagi integrasi.
9~
10Ini mewujudkan **masalah N×M**: N aplikasi AI setiap satu memerlukan M integrasi tersuai, menyebabkan usaha berganda dan ekosistem yang berpecah.
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 mana-mana klien AI boleh gunakan untuk berkomunikasi dengan mana-mana pelayan MCP:
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 Teras
38~
39MCP mempunyai tiga primitif asas:
40~
41### 1. Alat (Tools)
42Alat ialah fungsi yang AI boleh panggil. Ia mewakili tindakan seperti "cipta fail", "buat pertanyaan pangkalan data" atau "hantar mesej". Setiap alat mempunyai nama, penerangan 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. Sumber (Resources)
61Sumber ialah data yang AI boleh baca. Ia mewakili fail, rekod pangkalan data, respons API atau mana-mana sumber data lain. Sumber dikenal pasti 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. Prompt
72Prompt ialah templat yang boleh diguna semula yang membantu menstruktur interaksi. Ia boleh mengandungi parameter dinamik dan berguna untuk menyeragamkan aliran kerja biasa.
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## Seni Bina
85~
86MCP mengikuti seni bina klien-pelayan:
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- **Hos**: Aplikasi AI (Claude Desktop, Cursor, aplikasi tersuai anda)
105- **Klien**: Mengekalkan sambungan 1:1 dengan pelayan MCP
106- **Pelayan**: Mendedahkan alat, sumber dan prompt kepada klien
107- **Pengangkutan**: Komunikasi berlaku melalui JSON-RPC 2.0 menerusi stdio (tempatan) atau Server-Sent Events (jauh)
108~
109## Membina Pelayan MCP
110~
111Mari kita bina pelayan MCP praktikal yang berinteraksi dengan senarai tugas yang disimpan dalam fail JSON.
112~
113### Persediaan
114~
115```bash
116mkdir mcp-todo-server && cd mcp-todo-server
117npm init -y
118npm install @modelcontextprotocol/sdk zod
119```
120~
121### Pelaksanaan Pelayan
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 pelayan 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## Membina Klien MCP
223~
224Anda juga boleh membina klien tersuai yang menyambung ke mana-mana pelayan MCP:
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## Pelayan MCP Popular
251~
252Ekosistem MCP telah berkembang pesat. Berikut adalah beberapa pelayan paling popular:
253~
254| Pelayan | Penerangan | Kes Penggunaan |
255|---------|------------|---------------|
256| **GitHub** | Cipta issue, PR, urus repo | Aliran kerja pembangunan |
257| **Slack** | Hantar mesej, urus saluran | Komunikasi pasukan |
258| **PostgreSQL** | Pertanyaan dan urus pangkalan data | Akses data |
259| **Filesystem** | Baca, tulis dan cari fail | Pembangunan tempatan |
260| **Puppeteer** | Automasi pelayar dan scraping | Ujian web |
261| **Sentry** | Pemantauan ralat dan debugging | Sokongan pengeluaran |
262| **Supabase** | Pangkalan data, auth, storan | Operasi backend |
263~
264## MCP vs A2A (Agent-to-Agent)
265~
266Sementara MCP mengendalikan komunikasi **ejen-ke-alat**, protokol **A2A (Agent-to-Agent)** Google mengendalikan komunikasi **ejen-ke-ejen**. Mereka 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 ejen AI menggunakan alat (integrasi menegak)
276- **A2A**: Bagaimana ejen AI bekerjasama antara satu sama lain (integrasi mendatar)
277~
278## Amalan Terbaik
279~
2801. **Pastikan pelayan berfokus**: Satu pelayan untuk setiap domain (pelayan GitHub, pelayan Slack, dll.). Jangan bina pelayan monolitik.
2812. **Sahkan input dengan Zod**: Sentiasa sahkan input alat dengan skema yang sesuai.
2823. **Kendalikan ralat dengan baik**: Kembalikan mesej ralat yang bermakna, bukan stack trace.
2834. **Gunakan sumber untuk data baca sahaja**: Jika AI hanya perlu membaca data, dedahkan sebagai sumber berbanding alat.
2845. **Tambah penerangan yang sesuai**: Penerangan alat dan parameter yang baik membantu AI memahami bila dan bagaimana menggunakan setiap alat.
2856. **Uji dengan MCP Inspector**: Gunakan `npx @modelcontextprotocol/inspector` untuk menguji pelayan anda secara interaktif.
286~
287## Mula
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 standard de facto untuk penggunaan alat AI pada tahun 2026. Sama ada anda membina ejen AI tersuai, memperluaskan Claude Code, atau mencipta integrasi untuk platform sedia ada, memahami MCP adalah penting. Protokol ini cukup mudah untuk dipelajari dalam satu petang tetapi cukup berkuasa untuk membina aliran kerja AI peringkat pengeluaran.
300~
301**Langkah seterusnya:**
302- Terokai [Spesifikasi MCP](https://spec.modelcontextprotocol.io/)
303- Layari [pelayan MCP sedia ada](https://github.com/modelcontextprotocol/servers) untuk inspirasi
304- Bina pelayan pertama anda dengan TypeScript atau Python SDK
305- Uji dengan Claude Desktop atau MCP Inspector
306~