MCP (Model Context Protocol): Ang Kumpletong Gabay para sa mga Developer

Ang Model Context Protocol (MCP) ay isang bukas na pamantayan na ginawa ng Anthropic na tumutukoy kung paano nakikipag-usap ang mga AI model sa mga panlabas na tool, data source, at serbisyo. Isipin ito bilang "USB-C ng AI" - isang unibersal na connector na nagpapahintulot sa anumang AI agent na makipag-usap sa anumang tool sa pamamagitan ng isang standardized na interface.

Mula nang ilunsad, ang MCP ay lumampas sa 97 milyong buwanang SDK download at pinagtibay ng bawat pangunahing AI provider: Anthropic, OpenAI, Google, Microsoft, at Amazon. Sa gabay na ito, tutuklasin natin ang lahat ng kailangan mong malaman para gumawa gamit ang MCP.

Bakit Umiiral ang MCP

Bago ang MCP, bawat AI application ay kailangang gumawa ng custom na integration para sa bawat tool na gusto nitong gamitin. Gusto mo bang magbasa ng mga file ang iyong AI? Magsulat ng custom na code. Mag-query ng database? Higit pang custom na code. Mag-post sa Slack? Isa pang integration.

Lumikha ito ng problemang N×M: N na AI application na bawat isa ay nangangailangan ng M na custom integration, na humahantong sa doble na pagsisikap at pira-pirasong mga ecosystem.

Nilulutas ito ng MCP gamit ang iisang protokol na maaaring gamitin ng anumang AI client upang makipag-usap sa anumang MCP server:

Mga Pangunahing Konsepto

Ang MCP ay may tatlong pangunahing primitive:

1. Mga Tool

Ang mga tool ay mga function na maaaring tawagin ng AI. Kumakatawan ang mga ito sa mga aksyon tulad ng "gumawa ng file", "mag-query ng database", o "magpadala ng mensahe". Bawat tool ay may pangalan, paglalarawan, at JSON Schema para sa mga parameter nito.

{
  name: "create_issue",
  description: "Create a new GitHub issue",
  inputSchema: {
    type: "object",
    properties: {
      title: { type: "string", description: "Issue title" },
      body: { type: "string", description: "Issue body" },
      repo: { type: "string", description: "Repository name" }
    },
    required: ["title", "repo"]
  }
}

2. Mga Resource

Ang mga resource ay data na maaaring basahin ng AI. Kumakatawan ang mga ito sa mga file, database record, API response, o anumang iba pang data source. Ang mga resource ay kinikilala sa pamamagitan ng mga URI.

{
  uri: "file:///Users/dev/project/README.md",
  name: "Project README",
  mimeType: "text/markdown"
}

3. Mga Prompt

Ang mga prompt ay reusable na template na tumutulong sa pag-structure ng mga interaksyon. Maaari silang magsama ng mga dynamic na parameter at kapaki-pakinabang para sa pag-standardize ng mga karaniwang workflow.

{
  name: "code_review",
  description: "Review code changes for quality and security",
  arguments: [
    { name: "diff", description: "The code diff to review", required: true }
  ]
}

Arkitektura

Sumusunod ang MCP sa isang client-server na arkitektura:

• Host: Ang AI application (Claude Desktop, Cursor, ang iyong custom na app)
• Client: Nagpapanatili ng 1:1 na koneksyon sa isang MCP server
• Server: Nag-expose ng mga tool, resource, at prompt sa client
• Transport: Nangyayari ang komunikasyon sa pamamagitan ng JSON-RPC 2.0 sa stdio (lokal) o Server-Sent Events (remote)

Pagbuo ng MCP Server

Gumawa tayo ng praktikal na MCP server na nakikipag-ugnayan sa isang todo list na naka-store sa JSON file.

Setup

mkdir mcp-todo-server && cd mcp-todo-server
npm init -y
npm install @modelcontextprotocol/sdk zod

Server Implementation

// src/index.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import fs from "fs";

const TODO_FILE = "./todos.json";

function readTodos(): { id: number; text: string; done: boolean }[] {
  if (!fs.existsSync(TODO_FILE)) return [];
  return JSON.parse(fs.readFileSync(TODO_FILE, "utf-8"));
}

function writeTodos(todos: { id: number; text: string; done: boolean }[]) {
  fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2));
}

const server = new McpServer({
  name: "todo-server",
  version: "1.0.0",
});

// Tool: Add a todo
server.tool(
  "add_todo",
  "Add a new todo item",
  { text: z.string().describe("The todo text") },
  async ({ text }) => {
    const todos = readTodos();
    const newTodo = { id: Date.now(), text, done: false };
    todos.push(newTodo);
    writeTodos(todos);
    return { content: [{ type: "text", text: `Added: "${text}"` }] };
  }
);

// Tool: List todos
server.tool(
  "list_todos",
  "List all todo items",
  {},
  async () => {
    const todos = readTodos();
    const list = todos
      .map((t) => `${t.done ? "✅" : "⬜"} [${t.id}] ${t.text}`)
      .join("\n");
    return { content: [{ type: "text", text: list || "No todos yet." }] };
  }
);

// Tool: Complete a todo
server.tool(
  "complete_todo",
  "Mark a todo as completed",
  { id: z.number().describe("The todo ID to complete") },
  async ({ id }) => {
    const todos = readTodos();
    const todo = todos.find((t) => t.id === id);
    if (!todo) return { content: [{ type: "text", text: "Todo not found." }] };
    todo.done = true;
    writeTodos(todos);
    return { content: [{ type: "text", text: `Completed: "${todo.text}"` }] };
  }
);

// Resource: Current todos as a readable resource
server.resource(
  "todos://list",
  "Current todo list",
  async () => ({
    contents: [{
      uri: "todos://list",
      mimeType: "application/json",
      text: JSON.stringify(readTodos(), null, 2),
    }],
  })
);

// Start the server
const transport = new StdioServerTransport();
await server.connect(transport);

Configuration

Para magamit ang server na ito sa Claude Desktop, idagdag ito sa iyong config:

{
  "mcpServers": {
    "todo": {
      "command": "npx",
      "args": ["tsx", "/path/to/mcp-todo-server/src/index.ts"]
    }
  }
}

Pagbuo ng MCP Client

Maaari ka ring gumawa ng custom na client na kumokonekta sa anumang MCP server:

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
  command: "npx",
  args: ["tsx", "./src/index.ts"],
});

const client = new Client({ name: "my-client", version: "1.0.0" });
await client.connect(transport);

// List available tools
const { tools } = await client.listTools();
console.log("Available tools:", tools.map((t) => t.name));

// Call a tool
const result = await client.callTool({
  name: "add_todo",
  arguments: { text: "Write MCP blog post" },
});
console.log(result);

Mga Sikat na MCP Server

Mabilis na lumago ang MCP ecosystem. Narito ang ilan sa mga pinakasikat na server:

MCP vs A2A (Agent-to-Agent)

Habang ang MCP ang namamahala sa komunikasyong agent-to-tool, ang A2A (Agent-to-Agent) protocol ng Google ang namamahala sa komunikasyong agent-to-agent. Magkakatuwang sila:

• MCP: Paano gumagamit ng tool ang AI agent (vertical integration)
• A2A: Paano nagtutulungan ang mga AI agent (horizontal integration)

Mga Pinakamahusay na Gawi

1. Panatilihing focused ang mga server: Isang server bawat domain (GitHub server, Slack server, atbp.). Huwag gumawa ng monolithic na server.
2. I-validate ang input gamit ang Zod: Laging i-validate ang tool input gamit ang tamang schema.
3. Hawakan ang mga error nang maayos: Magbalik ng makabuluhang error message, hindi stack trace.
4. Gumamit ng resource para sa read-only na data: Kung kailangan lang ng AI na magbasa ng data, i-expose ito bilang resource sa halip na tool.
5. Magdagdag ng wastong paglalarawan: Ang magandang paglalarawan ng tool at parameter ay tumutulong sa AI na maunawaan kung kailan at paano gamitin ang bawat tool.
6. Mag-test gamit ang MCP Inspector: Gamitin ang npx @modelcontextprotocol/inspector para i-test ang iyong server nang interactive.

Magsimula

# Create a new MCP server from template
npx @modelcontextprotocol/create-server my-server

# Test with the MCP Inspector
npx @modelcontextprotocol/inspector npx tsx ./src/index.ts

Konklusyon

Ang MCP ay naging de facto na pamantayan para sa paggamit ng AI tool noong 2026. Gumagawa ka man ng custom na AI agent, pinapalawak ang Claude Code, o gumagawa ng integration para sa mga umiiral na platform, ang pag-unawa sa MCP ay mahalaga. Ang protokol ay sapat na simple para matutunan sa isang hapon ngunit sapat na malakas para bumuo ng production-grade na AI workflow.

Mga susunod na hakbang:

• Tuklasin ang MCP Specification
• I-browse ang mga umiiral na MCP server para sa inspirasyon
• Buuin ang iyong unang server gamit ang TypeScript o Python SDK
• I-test ito gamit ang Claude Desktop o MCP Inspector