MCP (Model Context Protocol): डेवलपर्स के लिए संपूर्ण गाइड

Model Context Protocol (MCP) Anthropic द्वारा बनाया गया एक ओपन स्टैंडर्ड है जो परिभाषित करता है कि AI मॉडल बाहरी टूल्स, डेटा स्रोतों और सेवाओं के साथ कैसे संवाद करते हैं। इसे "AI का USB-C" समझें - एक यूनिवर्सल कनेक्टर जो किसी भी AI एजेंट को एक मानकीकृत इंटरफ़ेस के माध्यम से किसी भी टूल से बात करने देता है।

अपने लॉन्च के बाद से, MCP ने 97 मिलियन मासिक SDK डाउनलोड पार कर लिए हैं और इसे हर प्रमुख AI प्रदाता ने अपनाया है: Anthropic, OpenAI, Google, Microsoft और Amazon। इस गाइड में, हम MCP के साथ बनाने के लिए आवश्यक सब कुछ जानेंगे।

MCP क्यों मौजूद है

MCP से पहले, हर AI एप्लिकेशन को हर उस टूल के लिए कस्टम इंटीग्रेशन बनाना पड़ता था जिसे वह उपयोग करना चाहता था। अपनी AI से फाइलें पढ़वाना चाहते हैं? कस्टम कोड लिखें। डेटाबेस क्वेरी करना? और कस्टम कोड। Slack पर पोस्ट करना? एक और इंटीग्रेशन।

इसने एक N×M समस्या पैदा की: N AI एप्लिकेशन्स में से प्रत्येक को M कस्टम इंटीग्रेशन की आवश्यकता थी, जिससे दोहरा प्रयास और खंडित इकोसिस्टम बने।

MCP इसे एक एकल प्रोटोकॉल से हल करता है जिसका उपयोग कोई भी AI क्लाइंट किसी भी MCP सर्वर के साथ संवाद करने के लिए कर सकता है:

मुख्य अवधारणाएँ

MCP में तीन मूलभूत प्रिमिटिव हैं:

1. टूल्स (Tools)

टूल्स ऐसे फंक्शन हैं जिन्हें AI कॉल कर सकती है। वे "फाइल बनाएं", "डेटाबेस क्वेरी करें", या "मैसेज भेजें" जैसी क्रियाओं का प्रतिनिधित्व करते हैं। हर टूल का एक नाम, विवरण और अपने पैरामीटर्स के लिए एक JSON Schema होता है।

{
  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. रिसोर्सेस (Resources)

रिसोर्सेस वह डेटा है जिसे AI पढ़ सकती है। ये फाइलें, डेटाबेस रिकॉर्ड्स, API रिस्पॉन्सेस या कोई भी अन्य डेटा स्रोत हो सकते हैं। रिसोर्सेस की पहचान URIs द्वारा होती है।

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

3. प्रॉम्प्ट्स (Prompts)

प्रॉम्प्ट्स पुन: प्रयोज्य टेम्पलेट हैं जो इंटरैक्शन को संरचित करने में मदद करते हैं। इनमें डायनामिक पैरामीटर शामिल हो सकते हैं और ये सामान्य वर्कफ़्लो को मानकीकृत करने के लिए उपयोगी हैं।

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

आर्किटेक्चर

MCP एक क्लाइंट-सर्वर आर्किटेक्चर का अनुसरण करता है:

• होस्ट: AI एप्लिकेशन (Claude Desktop, Cursor, आपका कस्टम ऐप)
• क्लाइंट: एक MCP सर्वर के साथ 1:1 कनेक्शन बनाए रखता है
• सर्वर: क्लाइंट को टूल्स, रिसोर्सेस और प्रॉम्प्ट्स उपलब्ध कराता है
• ट्रांसपोर्ट: संवाद stdio (लोकल) या Server-Sent Events (रिमोट) पर JSON-RPC 2.0 के माध्यम से होता है

MCP सर्वर बनाना

आइए एक प्रैक्टिकल MCP सर्वर बनाएं जो JSON फाइल में संग्रहीत एक कार्य सूची के साथ इंटरैक्ट करता है।

सेटअप

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

सर्वर कार्यान्वयन

// 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);

कॉन्फ़िगरेशन

इस सर्वर को Claude Desktop के साथ उपयोग करने के लिए, इसे अपने कॉन्फ़िग में जोड़ें:

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

MCP क्लाइंट बनाना

आप एक कस्टम क्लाइंट भी बना सकते हैं जो किसी भी MCP सर्वर से कनेक्ट होता है:

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);

लोकप्रिय MCP सर्वर

MCP इकोसिस्टम तेजी से बढ़ा है। यहाँ कुछ सबसे लोकप्रिय सर्वर हैं:

MCP vs A2A (Agent-to-Agent)

जबकि MCP एजेंट-टू-टूल संचार को संभालता है, Google का A2A (Agent-to-Agent) प्रोटोकॉल एजेंट-टू-एजेंट संचार को संभालता है। वे पूरक हैं:

• MCP: AI एजेंट टूल्स का उपयोग कैसे करता है (वर्टिकल इंटीग्रेशन)
• A2A: AI एजेंट्स एक-दूसरे के साथ कैसे सहयोग करते हैं (हॉरिज़ॉन्टल इंटीग्रेशन)

सर्वोत्तम प्रथाएँ

1. सर्वर को केंद्रित रखें: प्रत्येक डोमेन के लिए एक सर्वर (GitHub सर्वर, Slack सर्वर, आदि)। मोनोलिथिक सर्वर न बनाएं।
2. Zod से इनपुट वैलिडेट करें: हमेशा उचित स्कीमा के साथ टूल इनपुट को वैलिडेट करें।
3. एरर को सुचारू रूप से हैंडल करें: स्टैक ट्रेस नहीं, सार्थक एरर मैसेज लौटाएं।
4. रीड-ओनली डेटा के लिए रिसोर्सेस का उपयोग करें: यदि AI को केवल डेटा पढ़ना है, तो इसे टूल के बजाय रिसोर्स के रूप में एक्सपोज़ करें।
5. उचित विवरण जोड़ें: अच्छे टूल और पैरामीटर विवरण AI को समझने में मदद करते हैं कि प्रत्येक टूल का कब और कैसे उपयोग करना है।
6. MCP Inspector से टेस्ट करें: अपने सर्वर को इंटरैक्टिव रूप से टेस्ट करने के लिए npx @modelcontextprotocol/inspector का उपयोग करें।

शुरू करें

# 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

निष्कर्ष

MCP 2026 में AI टूल उपयोग के लिए वास्तविक मानक बन गया है। चाहे आप कस्टम AI एजेंट बना रहे हों, Claude Code का विस्तार कर रहे हों, या मौजूदा प्लेटफ़ॉर्म के लिए इंटीग्रेशन बना रहे हों, MCP को समझना आवश्यक है। यह प्रोटोकॉल एक दोपहर में सीखने के लिए पर्याप्त सरल है लेकिन प्रोडक्शन-ग्रेड AI वर्कफ़्लो बनाने के लिए पर्याप्त शक्तिशाली है।

अगले कदम:

• MCP स्पेसिफिकेशन एक्सप्लोर करें
• प्रेरणा के लिए मौजूदा MCP सर्वर ब्राउज़ करें
• TypeScript या Python SDK के साथ अपना पहला सर्वर बनाएं
• Claude Desktop या MCP Inspector से टेस्ट करें