अपना पहला MCP सर्वर कैसे बनाएं: एक व्यावहारिक गाइड

विषय-सूची

जून 2026 के लिए अपडेट किया गया।

TL;DR: MCP (Model Context Protocol) Claude को बाहरी टूल्स और डेटा तक संरचित पहुंच देने का तरीका है — डेटाबेस, फाइलें, API — बिना कॉन्टेक्स्ट विंडो को ओवरलोड किए। सर्वर उतना सरल है जितना दिखता नहीं: SDK इंस्टॉल करें, अपने टूल्स को JSON schema के रूप में परिभाषित करें, हैंडलर लागू करें, stdio के माध्यम से कनेक्ट करें। आप 30 मिनट से कम में Claude को अपने कस्टम टूल्स कॉल करवा सकते हैं।

[ऑपरेटर का दृष्टिकोण] मैं नियमित रूप से अपने एजेंट्स में नए टूल्स जोड़ता हूं, और MCP अब इसे साफ तरीके से करने का मानक तरीका है। एक बार सर्वर बन जाने के बाद, हर MCP-compatible क्लाइंट — Claude Desktop, Claude Code, Anthropic SDK उपयोग करने वाला कोई भी ऐप — बिना कॉलिंग कोड में बदलाव किए इसका उपयोग कर सकता है। यही मूल्य है: एक बार बनाएं, हर जगह पुनः उपयोग करें।

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

Model Context Protocol एक ओपन प्रोटोकॉल है जो AI मॉडल को बाहरी कॉन्टेक्स्ट और टूल्स से कनेक्ट करने के तरीके को मानकीकृत करता है। इसे AI इंटीग्रेशन के लिए USB-C मानक की तरह सोचें: इससे पहले, हर ऐप जो Claude को डेटाबेस पढ़ने या API कॉल करने देना चाहता था, उसे अपनी व्यवस्था बनानी पड़ती थी। इसके बाद, आप एक MCP सर्वर बनाते हैं और कोई भी अनुपालक होस्ट इसका उपयोग कर सकता है।

MCP तीन चीजें परिभाषित करता है जो एक सर्वर ऑफर कर सकता है:

• टूल्स — वे फंक्शन जो Claude कॉल कर सकता है (फाइल पढ़ना, DB क्वेरी करना, Slack संदेश भेजना)
• रिसोर्सेज — वह डेटा जो Claude पढ़ सकता है (दस्तावेज, डेटाबेस रो, फाइल ट्री)
• प्रॉम्प्ट्स — पुन: उपयोग योग्य प्रॉम्प्ट टेम्पलेट जिन्हें होस्ट इंजेक्ट कर सकता है

अधिकांश ऑपरेटर उपयोग के मामलों के लिए, आप टूल सर्वर बना रहे हैं। रिसोर्सेज और प्रॉम्प्ट्स बाद में आते हैं जब बुनियादी बातें काम करने लगती हैं।

आर्किटेक्चर क्लाइंट-सर्वर है, जिसमें क्लाइंट (Claude Desktop, Claude Code, आपका कस्टम ऐप) सब कुछ नियंत्रित करता है। सर्वर निष्क्रिय है — यह केवल टूल कॉल अनुरोधों को सुनता है और परिणाम लौटाता है।

हर MCP सर्वर के तीन हिस्से

आप जो भी MCP सर्वर बनाते हैं उसकी संरचना एक जैसी होती है:

1. सर्वर ऑब्जेक्ट — आपके सर्वर का नाम, संस्करण, और क्षमताएं घोषित करता है (टूल्स, रिसोर्सेज, प्रॉम्प्ट्स)
2. टूल परिभाषाएं — नामों, विवरणों और उनके इनपुट के लिए JSON schema के साथ टूल्स की सूची
3. रिक्वेस्ट हैंडलर — वे फंक्शन जो Claude किसी टूल को कॉल करने पर चलते हैं

बस इतना ही। शुरू करने के लिए कोई डेटाबेस, HTTP स्टैक, या auth लेयर की जरूरत नहीं। न्यूनतम सर्वर 30 से कम TypeScript लाइनों का है।

पूर्व-आवश्यकताएं (2 मिनट)

• Node.js 18+ — node --version से जांचें
• TypeScript 5+ (नीचे dev dependency के रूप में शामिल)
• टेस्ट करने के लिए MCP क्लाइंट — Claude Desktop मुफ्त है और आपके सर्वर को काम करते देखने का सबसे आसान तरीका है

MCP सर्वर चलाने के लिए Anthropic API की कुंजी की जरूरत नहीं है। API की कुंजी क्लाइंट में होती है, सर्वर में नहीं।

चरण 1: प्रोजेक्ट सेट करें (3 मिनट)

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

package.json में जोड़ें:

{
  "type": "module",
  "scripts": {
    "build": "tsc",
    "dev": "tsx src/index.ts"
  }
}

tsconfig.json बनाएं:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./build",
    "strict": true
  },
  "include": ["src/**/*"]
}

चरण 2: न्यूनतम सर्वर लिखें (5 मिनट)

src/index.ts बनाएं:

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";

const server = new Server(
  { name: "my-mcp-server", version: "1.0.0" },
  { capabilities: { tools: {} } }
);

// घोषित करें कि यह सर्वर कौन से टूल्स ऑफर करता है
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "get_word_count",
      description: "टेक्स्ट के एक ब्लॉक में शब्दों की गिनती करता है।",
      inputSchema: {
        type: "object",
        properties: {
          text: {
            type: "string",
            description: "वह टेक्स्ट जिसमें शब्द गिने जाने हैं",
          },
        },
        required: ["text"],
      },
    },
  ],
}));

// क्लाइंट से टूल कॉल हैंडल करें
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  if (name === "get_word_count") {
    const { text } = args as { text: string };
    const count = text.trim().split(/\s+/).filter(Boolean).length;
    return {
      content: [{ type: "text", text: `शब्द गिनती: ${count}` }],
    };
  }

  throw new Error(`अज्ञात टूल: ${name}`);
});

// stdio के माध्यम से कनेक्ट करें — इस तरह Claude Desktop सर्वर से बात करता है
const transport = new StdioServerTransport();
await server.connect(transport);

यह पूरा सर्वर है। यह एक टूल (get_word_count) रजिस्टर करता है और उसे लागू करता है। संरचना ही मायने रखती है।

चरण 3: बिल्ड करें और Claude Desktop में रजिस्टर करें (5 मिनट)

TypeScript बिल्ड करें:

npm run build

अब Claude Desktop के कॉन्फिग फाइल में रजिस्टर करें।

macOS पर: ~/Library/Application Support/Claude/claude_desktop_config.json Windows पर: %APPDATA%\Claude\claude_desktop_config.json

अगर फाइल नहीं है, बनाएं:

{
  "mcpServers": {
    "my-mcp-server": {
      "command": "node",
      "args": ["/absolute/path/to/my-mcp-server/build/index.js"]
    }
  }
}

Absolute path उपयोग करें। सहेजने के बाद Claude Desktop रीस्टार्ट करें। मैसेज इनपुट में हथौड़े का आइकन (🔨) दिखेगा — इसका मतलब है Claude ने आपके टूल्स खोज लिए हैं।

चरण 4: एक उपयोगी टूल बनाएं

शब्द गिनना उदाहरण के लिए है। यहां एक अधिक उपयोगी टूल है: प्रोजेक्ट डायरेक्टरी से फाइलें पढ़ना, जिसका उपयोग मैं कॉन्टेक्स्ट इंजेक्शन एजेंट्स के लिए करता हूं जो कोडबेस, changelogs, या कॉन्फिग फाइलें सारांशित करते हैं।

import { readFileSync, readdirSync } from "fs";
import { join, extname } from "path";

const ALLOWED_EXTENSIONS = [".md", ".txt", ".ts", ".json", ".yaml"];
const PROJECT_DIR = process.env.PROJECT_DIR ?? process.cwd();

तर्क समान है: सटीक JSON schema के साथ टूल्स परिभाषित करें, हैंडलर लागू करें, path traversal रोकने के लिए इनपुट validate करें, और क्लाइंट को टेक्स्ट लौटाएं।

मैंने जो गलतियां कीं (ताकि आप न करें)

Path absolute होनी चाहिए। Claude Desktop कॉन्फिग में Relative paths उस तरह resolve नहीं होती जैसी उम्मीद है। हमेशा पूरा path /home/user/... उपयोग करें।

Stdio का मतलब है अपने सर्वर में console.log नहीं। Claude Desktop आपके सर्वर से stdin/stdout के माध्यम से communicate करता है। Debug console.log JSON-RPC stream को corrupt करता है। stderr पर log करें:

process.stderr.write(`Debug: ${message}\n`);

हर कॉन्फिग बदलाव के बाद Claude Desktop रीस्टार्ट करें। MCP सर्वर startup पर लोड होते हैं। एक edited कॉन्फिग फाइल तब तक कुछ नहीं करती जब तक आप ऐप बंद करके दोबारा न खोलें।

टूल विवरण ही उत्पाद है। Claude तय करता है कि आपका टूल call करना है या नहीं description फील्ड के आधार पर। अस्पष्ट विवरण का मतलब है Claude नहीं जानेगा कब इसे उपयोग करना है। सटीक विवरण का मतलब है Claude इसे सही समय पर उपयोग करता है। विवरण पर implementation से ज्यादा समय लगाएं।

मैं production में MCP सर्वर कैसे उपयोग करता हूं

Stdio pattern Claude Desktop और Claude Code (local) के लिए बढ़िया काम करता है। Production एजेंट्स के लिए — 30+ जो मैं Cloudflare Workers पर चलाता हूं — मैं Anthropic SDK की tool-use API सीधे उपयोग करता हूं, क्योंकि मुझे प्रति चरण Haiku vs Sonnet को route करने की लचीलापन चाहिए।

वे patterns जो मैं वास्तव में उपयोग करता हूं:

1. Local dev tooling — Claude Code के लिए MCP सर्वर जो project-specific टूल्स expose करते हैं
2. Context injection — MCP सर्वर जो manually copy किए बिना relevant docs preload करते हैं
3. Prototype-to-API bridge — मैं पहले MCP बनाता हूं (iterate करना तेज), फिर production के लिए logic को SDK tool-use में port करता हूं

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

एक बार सर्वर structure समझ आ जाए, उपयोगी टूल्स वे हैं जो Claude के external context तक पहुंचते हैं:

• Database reader — read-only SQL query चलाएं और परिणाम JSON में लौटाएं
• Slack reader — किसी channel से अंतिम N संदेश प्राप्त करें
• GitHub reader — open PRs list करें, specific commit पर फाइल पढ़ें
• Internal API wrapper — auth headers baked in के साथ अपनी REST API call करें

अक्सर पूछे जाने वाले प्रश्न

क्या MCP सर्वर बनाने के लिए Anthropic API key चाहिए?

नहीं। आपका MCP सर्वर Anthropic API call नहीं करता। यह केवल client से tool call requests का जवाब देता है। API key client में होती है, सर्वर में नहीं।

क्या मेरा MCP सर्वर external APIs call कर सकता है?

हां — handler बस async TypeScript code है। Weather API fetch करें, database query करें, file में लिखें। सर्वर को परवाह नहीं कि handler अंदरूनी रूप से क्या करता है।

stdio और HTTP transport में क्या अंतर है?

Stdio local सर्वर के लिए है — Claude Desktop या Claude Code के समान machine पर। HTTP with SSE remote सर्वर के लिए है जिसे web service के रूप में deploy किया जा सकता है। stdio से शुरू करें; debug करना आसान है।

Claude कैसे जानता है कि मेरा टूल कब call करना है?

Claude टूल के description field और बातचीत के context के आधार पर तय करता है। अगर Claude आपके टूल को ignore करता रहता है, विवरण को और सटीक बनाएं।