20 मिनट में अपना पहला MCP सर्वर बनाएं

MCP वास्तव में क्या है

Model Context Protocol Anthropic का एक ओपन स्टैंडर्ड है जो AI असिस्टेंट्स को बाहरी टूल्स और डेटा तक संरचित तरीके से पहुंच देता है। इसे एक अच्छी तरह से टाइप किए गए API कॉन्ट्रैक्ट के रूप में सोचें — आपके मॉडल होस्ट (Claude Code, Cursor, आदि) और उस किसी भी क्षमता के बीच जिसे आप एक्सपोज़ करना चाहते हैं: एक डेटाबेस, एक वेब स्क्रेपर, एक फाइल वॉचर, एक Slack बॉट, एक CI ट्रिगर।

जब आप MCP सर्वर बनाते हैं, तो आप एक ब्रिज बना रहे होते हैं। मॉडल आपके टूल्स को नाम और संरचित आर्गुमेंट के साथ कॉल करता है; आपका सर्वर उन्हें एग्जीक्यूट करके संरचित रिजल्ट लौटाता है। अब "इस URL पर जाओ और बताओ क्या दिखता है" जैसी बात नहीं — सिर्फ टाइप्ड फंक्शन कॉल्स।

पूर्वशर्तें

• Node.js 22+
• Claude Code या Cursor का एक ऐसा सेटअप जो MCP सपोर्ट करता हो
• 20 मिनट

चरण 1: सर्वर का ढांचा तैयार करें

mkdir my-mcp-server && cd my-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node tsx

tsconfig.json बनाएं:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "outDir": "./dist",
    "strict": true
  }
}

चरण 2: अपना पहला टूल लिखें

src/index.ts बनाएं:

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

const server = new McpServer({
  name: "my-first-mcp",
  version: "0.1.0",
});

// Tool: fetch and summarize a URL's title
server.tool(
  "get_page_title",
  "Fetches the <title> tag from a given URL",
  { url: z.string().url().describe("The URL to fetch") },
  async ({ url }) => {
    try {
      const res = await fetch(url, { signal: AbortSignal.timeout(5000) });
      const html = await res.text();
      const match = html.match(/<title[^>]*>(.*?)<\/title>/is);
      const title = match?.[1]?.trim() ?? "No title found";
      return { content: [{ type: "text", text: title }] };
    } catch (err) {
      return {
        content: [{ type: "text", text: `Error: ${String(err)}` }],
        isError: true,
      };
    }
  }
);

// Tool: simple math evaluator
server.tool(
  "calculate",
  "Evaluates a safe arithmetic expression",
  { expression: z.string().describe("e.g. '2 + 2 * 10'") },
  async ({ expression }) => {
    // Only allow digits, operators, spaces, parens
    if (!/^[0-9+\-*/.() ]+$/.test(expression)) {
      return {
        content: [{ type: "text", text: "Invalid expression" }],
        isError: true,
      };
    }
    const result = Function(`"use strict"; return (${expression})`)();
    return { content: [{ type: "text", text: String(result) }] };
  }
);

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
}

main().catch(console.error);

चरण 3: Claude Code में वायर करें

अपने Claude Code MCP कॉन्फिग में यह जोड़ें (आमतौर पर ~/.claude/mcp.json या वर्कस्पेस का .mcp.json):

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

Claude Code को रिस्टार्ट करें। टूल पैलेट खोलें — आपके दोनों टूल दिखने चाहिए।

चरण 4: होस्ट के बिना टेस्ट करें

MCP इंस्पेक्टर का उपयोग करें:

npx @modelcontextprotocol/inspector tsx src/index.ts

यह एक लोकल UI खोलता है जहां आप अपने टूल्स को इनवोक कर सकते हैं, स्कीमा देख सकते हैं, और रॉ JSON-RPC मैसेज चेक कर सकते हैं। किसी असली होस्ट में वायर करने से पहले डीबगिंग के लिए यह जरूरी है।

आगे क्या बनाएं

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

• Persistent memory — एक लोकल JSON स्टोर में पढ़ें/लिखें ताकि आपका agent सेशन के बीच कॉन्टेक्स्ट याद रखे
• Project-aware search — embeddings के जरिए अपने कोडबेस पर सेमांटिक सर्च एक्सपोज़ करें
• Internal APIs — किसी भी कंपनी API को एक साफ टाइप्ड इंटरफेस के पीछे लपेटें जिसे मॉडल कॉल कर सके
• Browser control — संरचित वेब इंटरैक्शन के लिए Playwright को रैप करें
• CI hooks — अपने agent लूप के अंदर से बिल्ड ट्रिगर करें, टेस्ट रिजल्ट पढ़ें, PR खोलें

मुख्य बात

MCP आपके agent को एक चैट इंटरफेस से एक प्रोग्रामेबल रनटाइम में बदल देता है। मॉडल यह बताना बंद कर देता है कि वह क्या करेगा और आपके टाइप्ड, ऑडिटेबल, लॉग्ड फंक्शन कॉल्स के जरिए असल में करने लगता है। यही vibecoding से असली agentic सिस्टम बनाने की छलांग है।

20 मिनट में आपका पहला टूल। बाकी सब आपकी सोच पर निर्भर है।