Claude Code के साथ MCP (Model Context Protocol) सर्वर सेट करने की व्यावहारिक गाइड, जिसमें इंस्टॉलेशन, कॉन्फ़िगरेशन, ट्रांसपोर्ट मोड, टूल डेफ़िनिशन और AI मॉडल को असली APIs और सेवाओं से कैसे जोड़ें, यह सब शामिल है। ऐसे काम करने वाले उदाहरण जिन्हें आप आज ही कॉपी करके चला सकते हैं।
अगर आपने Claude Code में काफ़ी समय बिताया है और सेटिंग्स में MCP सेक्शन देखा है, तो आपके मन में ज़रूर सवाल आया होगा कि यह असल में क्या करता है, इसे सेट करना कितना मुश्किल है और क्या यह मेहनत के लायक है। छोटा जवाब: हाँ, बहुत ज़्यादा लायक है। MCP (Model Context Protocol) वह तंत्र है जिससे Claude अपनी कॉन्टेक्स्ट विंडो के बाहर पहुँच सकता है, असली फ़ंक्शन कॉल कर सकता है, असली डेटाबेस क्वेरी कर सकता है और असली APIs के साथ इंटरैक्ट कर सकता है, और यह सब एक बातचीत के भीतर होता है।
यह गाइड MCP क्या है, यहाँ से शुरू करके आपका पहला कस्टम सर्वर Claude Code के साथ चलाने तक सब कुछ समझाती है, और इसमें असली कॉन्फ़िगरेशन उदाहरण भी हैं जिन्हें आप तुरंत कॉपी कर सकते हैं।
MCP एक ओपन प्रोटोकॉल है, जिसे Anthropic ने विकसित किया है। यह मानकीकरण करता है कि AI मॉडल बाहरी टूल्स और डेटा स्रोतों से कैसे बात करते हैं। इसे एक संरचित हैंडशेक की तरह समझें: आपका सर्वर बताता है कि वह कौन से टूल्स देता है, और Claude सही आर्गुमेंट्स के साथ उन्हें कॉल करता है और नतीजों को संभालता है।
MCP से पहले हर इंटीग्रेशन अलग से बनाना पड़ता था। आप खास सिस्टम प्रॉम्प्ट लिखते थे, फ़ंक्शन-कॉलिंग स्कीमा जोड़-तोड़ कर बनाते थे और उम्मीद करते थे कि मॉडल स्पेसिफ़िकेशन का पालन करेगा। MCP यह सब एक ही, अनुमानित परत में व्यवस्थित कर देता है।
प्रोटोकॉल तीन मूल प्रिमिटिव परिभाषित करता है:
| प्रिमिटिव | विवरण |
|---|---|
| Tools | वे फ़ंक्शन जिन्हें मॉडल कॉल कर सकता है (जैसे सर्च, फ़ेच, फ़ाइल लिखना) |
| Resources | वह डेटा जिसे मॉडल पढ़ सकता है (जैसे फ़ाइलें, डेटाबेस रिकॉर्ड) |
| Prompts | सर्वर द्वारा दिए गए दोबारा इस्तेमाल होने वाले प्रॉम्प्ट टेम्पलेट |
ये तीन प्रिमिटिव लगभग हर इंटीग्रेशन स्थिति को कवर करते हैं जिसका आपको सामना होगा। Tools एक्शन संभालते हैं, resources डेटा एक्सेस संभालते हैं, और prompts दोबारा इस्तेमाल होने वाले इंटरैक्शन पैटर्न संभालते हैं। यह प्रोटोकॉल ट्रांसपोर्ट-एग्नॉस्टिक है, यानी वही सर्वर कोड लोकल डेवलपमेंट के लिए stdio पर और प्रोडक्शन डिप्लॉयमेंट के लिए HTTP पर काम करता है।
MCP सर्वर दो ट्रांसपोर्ट मोड में से किसी एक में चलते हैं। इनका फ़र्क जान लेने से आपके घंटों की डिबगिंग बच जाएगी।
क्लाइंट (Claude Code) आपके सर्वर को एक सबप्रोसेस के रूप में शुरू करता है और stdin/stdout के ज़रिए बात करता है। लोकल टूल्स और निजी वर्कफ़्लो के लिए यह सबसे सरल सेटअप है। इसमें कोई पोर्ट, कोई नेटवर्किंग और कोई ऑथेंटिकेशन नहीं चाहिए।
{
"mcpServers": {
"my-tool": {
"command": "node",
"args": ["/absolute/path/to/server/dist/index.js"]
}
}
}
आपका सर्वर एक स्वतंत्र HTTP प्रोसेस के रूप में चलता है। Claude Code उससे नेटवर्क पर कनेक्ट होता है। साझा टीम सर्वर, क्लाउड डिप्लॉयमेंट या ऐसे किसी भी सर्वर के लिए यह सही विकल्प है जिसे सेशनों के बीच चालू रहना हो।
{
"mcpServers": {
"my-tool": {
"url": "http://localhost:3000/sse"
}
}
}
💡 stdio से शुरू करें। इसमें नेटवर्किंग सेटअप की ज़रूरत नहीं होती और डिबग करना कहीं आसान है। HTTP ट्रांसपोर्ट पर तभी जाएँ जब आपको साझा एक्सेस या लगातार चलने वाली सर्वर स्टेट चाहिए।
हर MCP सर्वर एक ही तरह शुरू होता है: आधिकारिक SDK इंस्टॉल करें और ESM के लिए TypeScript कॉन्फ़िगर करें।
mkdir my-mcp-server && cd my-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript tsx @types/node
TypeScript इनिशियलाइज़ करें:
npx tsc --init
tsconfig.json को ESM मॉड्यूल के लिए टारगेट करने हेतु अपडेट करें:
{
"compilerOptions": {
"target": "ES2022",
"module": "Node16",
"moduleResolution": "Node16",
"outDir": "./dist",
"strict": true
}
}
package.json में स्क्रिप्ट जोड़ें:
{
"type": "module",
"scripts": {
"build": "tsc",
"dev": "tsx src/index.ts"
}
}
"type": "module" फ़ील्ड ज़रूरी है। इसके बिना Node आपकी फ़ाइलों को CommonJS मानता है और हर ESM इंपोर्ट स्टार्टअप पर विफल हो जाता है।
src/index.ts बनाएँ और टाइप किए गए Zod स्कीमा के साथ अपना पहला टूल परिभाषित करें:
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-server",
version: "1.0.0",
});
server.tool(
"get_weather",
"Get current weather for a city",
{
city: z.string().describe("City name"),
units: z.enum(["celsius", "fahrenheit"]).optional().default("celsius"),
},
async ({ city, units }) => {
const temp = units === "celsius" ? "22°C" : "72°F";
return {
content: [
{
type: "text",
text: `Weather in ${city}: ${temp}, partly cloudy`,
},
],
};
}
);
const transport = new StdioServerTransport();
await server.connect(transport);
बिल्ड करें और जाँचें कि यह साफ़ तरीके से कम्पाइल होता है:
npx tsc
node dist/index.js
बस, यह एक काम करने वाला MCP सर्वर है। यह एक टूल देता है, जिसका टाइप्ड स्कीमा है। Claude उसे कॉल करने से पहले वैलिडेट करता है।
Claude Code सेटिंग्स खोलें और MCP सेक्शन में जाएँ। कम्पाइल्ड आउटपुट के एब्सोल्यूट पाथ का उपयोग करके अपनी सर्वर एंट्री जोड़ें:
{
"mcpServers": {
"my-first-server": {
"command": "node",
"args": ["/absolute/path/to/my-mcp-server/dist/index.js"]
}
}
}
Claude Code को रीस्टार्ट करें। नई बातचीत खोलें और पूछें: "पेरिस में मौसम कैसा है?"
अगर सब कुछ सही तरह जुड़ा है, तो Claude get_weather को city: "Paris" के साथ कॉल करेगा और नतीजा अपने जवाब में दिखाएगा। आपको बातचीत में टूल कॉल दिखेगी।
💡 अपनी MCP कॉन्फ़िग में हमेशा एब्सोल्यूट पाथ इस्तेमाल करें। रिलेटिव पाथ चुपचाप टूटते हैं, क्योंकि यह निर्भर करता है कि लॉन्च के समय Claude Code अपनी वर्किंग डायरेक्टरी कैसे तय करता है।
असली सर्वरों को स्कीमा परिभाषाओं, हैंडलरों और सर्विस लॉजिक के बीच साफ़ अलगाव चाहिए। यहाँ फ़ाइल संरचना दी गई है, जो बिना अनमेंटेनेबल हुए बढ़ती रहती है:
src/
index.ts # Entry point and server setup
tools/
definitions.ts # Zod schemas for each tool input
handlers.ts # Business logic per tool
services/
api.ts # External API calls
db.ts # Database access layer
definitions.ts में सभी Zod स्कीमा रहते हैं:
import { z } from "zod";
export const searchInputSchema = {
query: z.string().min(1).describe("Search query text"),
limit: z.number().int().min(1).max(50).optional().default(10),
};
handlers.ts में इम्प्लीमेंटेशन रहता है:
export async function handleSearch(
args: { query: string; limit?: number }
) {
const results = await searchApi(args.query, args.limit ?? 10);
return {
content: [{ type: "text" as const, text: JSON.stringify(results, null, 2) }],
};
}
index.ts हर टूल के लिए एक ही server.tool() कॉल में सबको आपस में जोड़ता है। इस अलगाव से आप बिना चालू सर्वर के हैंडलर टेस्ट कर सकते हैं और बिज़नेस लॉजिक को छुए बिना स्कीमा बदल सकते हैं।
ये वे गलतियाँ हैं जो अपना पहला MCP सर्वर बनाने वाले लगभग हर व्यक्ति को उलझाती हैं।
1. इंपोर्ट में .js फ़ाइल एक्सटेंशन गायब होना
Node16 मॉड्यूल रेज़ोल्यूशन को TypeScript सोर्स फ़ाइलों के भीतर भी स्पष्ट .js एक्सटेंशन चाहिए। इन्हें छोड़ने से रनटाइम इंपोर्ट विफल होते हैं, और TypeScript कम्पाइलर इन्हें नहीं पकड़ता, इसलिए ये उलझाने वाले होते हैं।
// This fails at runtime with ERR_MODULE_NOT_FOUND
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp";
// This works correctly
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
2. stdio सर्वरों में console.log() का इस्तेमाल
stdio मोड में stdout ही प्रोटोकॉल चैनल है। कोई भी console.log() कॉल उस चैनल में मनमाना टेक्स्ट लिख देती है और MCP स्ट्रीम को बिगाड़ देती है। सारे डिबग आउटपुट के लिए console.error() इस्तेमाल करें।
3. सर्वर कनेक्शन पर await का गायब होना
// Wrong: process may exit before connection completes
server.connect(transport);
// Correct: wait for connection handshake
await server.connect(transport);
4. Claude Code कॉन्फ़िग में रिलेटिव पाथ
Claude Code अलग-अलग वर्किंग डायरेक्टरी से लॉन्च होता है। हमेशा एब्सोल्यूट पाथ हार्डकोड करें या स्टार्टअप पर import.meta.url से उन्हें रिज़ॉल्व करें।
5. बहुत व्यापक टूल डिस्क्रिप्शन
Claude यह तय करने के लिए आपके टूल डिस्क्रिप्शन का इस्तेमाल करता है कि उसे कब कॉल करना है। "कुछ भी करता है" जैसे अस्पष्ट विवरण का नतीजा यह होता है कि टूल या तो बहुत बार कॉल होता है या कभी नहीं। साफ़-साफ़ बताएँ: "owner, repo और PR नंबर से GitHub pull request फ़ेच करें।"
जब आपका सर्वर टीम में साझा होना हो या क्लाउड वातावरण में चलना हो, तब HTTP with SSE सही ट्रांसपोर्ट है:
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
import express from "express";
const app = express();
const server = new McpServer({ name: "team-server", version: "1.0.0" });
const transports: Record<string, SSEServerTransport> = {};
app.get("/sse", async (req, res) => {
const transport = new SSEServerTransport("/messages", res);
transports[transport.sessionId] = transport;
await server.connect(transport);
});
app.post("/messages", express.json(), async (req, res) => {
const sessionId = req.query.sessionId as string;
const transport = transports[sessionId];
if (transport) await transport.handlePostMessage(req, res);
});
app.listen(3000, () => console.error("MCP server listening on :3000"));
हर Claude Code क्लाइंट अपना अलग सेशन ट्रांसपोर्ट रखता है, ताकि कई यूज़र एक साथ बिना एक-दूसरे में दखल दिए कनेक्ट हो सकें।
Resources Claude को बिना स्पष्ट टूल कॉल के संरचित डेटा पढ़ने देते हैं। कॉन्फ़िगरेशन, डॉक्यूमेंटेशन या कैश्ड स्टेट के लिए ये सही प्रिमिटिव हैं, जिनके बारे में Claude को जानकारी होनी चाहिए, बिना इसके कि आपको उसके लिए अलग फ़ेच टूल परिभाषित करना पड़े।
server.resource(
"config://app",
"Application configuration and feature flags",
async (uri) => ({
contents: [
{
uri: uri.toString(),
mimeType: "application/json",
text: JSON.stringify({
version: "2.1.0",
features: { darkMode: true, betaSearch: false },
limits: { maxResults: 50, timeoutMs: 5000 },
}),
},
],
})
);
Claude अपने कॉन्टेक्स्ट में config://app का संदर्भ दे सकता है और यह डेटा पहले से पढ़ सकता है, जिससे एक बातचीत में ज़रूरी टूल इन्वोकेशन की संख्या घटती है।
डेवलपमेंट के दौरान MCP Inspector ज़रूरी है। यह आपको एक विज़ुअल इंटरफ़ेस देता है, जिससे Claude Code के बिना सीधे अपने टूल कॉल कर सकते हैं:
npx @modelcontextprotocol/inspector node dist/index.js
http://localhost:5173 खोलें। वहाँ आपको सभी रजिस्टर्ड टूल, उनके स्कीमा और हर एक को मनमाने इनपुट के साथ सीधे कॉल करने का फ़ॉर्म दिखेगा। कच्चे रिक्वेस्ट और रिस्पॉन्स JSON दिखते हैं, इसलिए टाइप मिसमैच या गायब फ़ील्ड पहचानना बहुत आसान हो जाता है।
HTTP सर्वरों के लिए:
npx @modelcontextprotocol/inspector http://localhost:3000/sse
💡 स्कीमा मिसमैच पर ध्यान दें। अगर Claude Code कहता है कि टूल रजिस्टर्ड है पर वह उसे कभी कॉल नहीं करता, तो सबसे आम कारण वह Zod स्कीमा होता है जो मॉडल द्वारा दिए गए आर्गुमेंट्स को अस्वीकार कर देता है। Inspector से आप Claude को बीच में लाए बिना यही समस्या दोहरा सकते हैं।
सबसे ज़्यादा फ़ायदेमंद पैटर्न में से एक है ऐसे MCP सर्वर बनाना जो कई AI मॉडलों की कॉल्स को ऑर्केस्ट्रेट करें। आपका सर्वर मिडलवेयर परत बन जाता है, और Claude Code कोऑर्डिनेटर बन जाता है।
आप एक ऐसा टूल एक्सपोज़ कर सकते हैं जो गहरी रीज़निंग के लिए अनुरोध Deepseek R1 को, क्रिएटिव राइटिंग के लिए GPT 5 को, या तेज़ डॉक्यूमेंट प्रोसेसिंग के लिए Llama 4 Scout Instruct को भेजे। हाथ में मौजूद कार्य के आधार पर Claude तय करता है कि कौन सा टूल कॉल करना है।
server.tool(
"route_to_model",
"Route a task to the most suitable language model for the job",
{
task: z.enum(["reasoning", "creative", "summarize"]),
input: z.string().describe("The text input to process"),
},
async ({ task, input }) => {
const modelMap = {
reasoning: "deepseek-r1",
creative: "gpt-5",
summarize: "llama-4-scout",
};
const result = await callModelApi(modelMap[task], input);
return { content: [{ type: "text", text: result }] };
}
);
Claude Opus 4.7 को ऑर्केस्ट्रेटर और अपने MCP सर्वर को डिस्पैच लेयर बनाकर आपको एक मल्टी-मॉडल सिस्टम मिलता है, जो बिना जटिल इंफ़्रास्ट्रक्चर के बुद्धिमानी से रूट करता है।
Picasso IA Claude 4.5 Sonnet, Gemini 2.5 Flash और Claude 4 Sonnet सहित मॉडलों के लिए API एक्सेस देता है, जिससे हर प्रोवाइडर के लिए अलग API कीज़ और क्लाइंट लाइब्रेरी संभाले बिना मल्टी-मॉडल MCP टूल बनाना व्यावहारिक हो जाता है।
MCP टूल्स को कभी बिना हैंडल किए अपवाद नहीं फेंकने चाहिए। संरचित एरर कंटेंट लौटाएँ, ताकि Claude विफलताओं की साफ़ रिपोर्ट दे सके और तय कर सके कि आगे क्या करना है:
server.tool(
"safe_fetch",
"Fetch content from an external URL",
{ url: z.string().url() },
async ({ url }) => {
try {
const response = await fetch(url);
if (!response.ok) {
return {
content: [
{
type: "text",
text: `Request failed: HTTP ${response.status} from ${url}`,
},
],
isError: true,
};
}
return { content: [{ type: "text", text: await response.text() }] };
} catch (err) {
return {
content: [{ type: "text", text: `Network error: ${String(err)}` }],
isError: true,
};
}
}
);
isError: true फ़्लैग Claude को संकेत देता है कि कॉल विफल हुई है। इसके बाद Claude तय करता है कि दोबारा कोशिश करनी है, कोई फ़ॉलबैक इस्तेमाल करना है या यूज़र को एरर दिखाना है।
एक बार बुनियादी बातें काम करने लगें, तो व्यावहारिक संभावनाएँ खुल जाती हैं। आज टीमें MCP के साथ ये पैटर्न बना रही हैं:
| उपयोग का मामला | यह क्या करता है |
|---|---|
| Database tool | Claude सुरक्षित रूप से सीमित SQL क्वेरी लिखता और चलाता है |
| File system browser | चुनिंदा प्रोजेक्ट डायरेक्टरी में रीड/राइट एक्सेस |
| API wrapper | Jira, GitHub या Slack को कॉल योग्य टूल्स के रूप में एक्सपोज़ करता है |
| Image pipeline | Claude को टेक्स्ट-टू-इमेज जनरेशन APIs से जोड़ता है |
| Code sandbox | अलग कंटेनर में कोड स्निपेट चलाता और टेस्ट करता है |
| RAG retriever | वेक्टर डेटाबेस खोजकर प्रासंगिक चंक लौटाता है |
Image pipeline वाला उपयोग विशेष रूप से शक्तिशाली है। आप एक MCP सर्वर बनाते हैं जो Claude से टेक्स्ट प्रॉम्प्ट लेता है, टेक्स्ट-टू-इमेज मॉडल को कॉल करता है, नतीजा क्लाउड स्टोरेज पर अपलोड करता है और URL लौटाता है। यह सब एक ही टूल कॉल में होता है, और Claude उसे बिना किसी अतिरिक्त ऑर्केस्ट्रेशन कोड के बातचीत में स्वाभाविक रूप से चेन करता है।
जो टीमें इमेज जनरेशन वाले वर्कफ़्लो बना रही हैं, उनके लिए Picasso IA जैसे प्लेटफ़ॉर्म पर उपलब्ध 90+ मॉडलों को MCP टूल्स के रूप में जोड़ा जा सकता है। इससे Claude को बातचीत के भीतर से डिफ़्यूज़न मॉडल, अपस्केलर और एडिटिंग पाइपलाइन का सीधा एक्सेस मिल जाता है।
अपने MCP इंटीग्रेशन बनाने से पहले अगर आप देखना चाहते हैं कि AI मॉडलों से क्या संभव है, तो Picasso IA 90 से ज़्यादा टेक्स्ट-टू-इमेज मॉडल और दर्जनों लार्ज लैंग्वेज मॉडल सीधे आपके ब्राउज़र में उपलब्ध कराता है। बिना किसी सेटअप के Claude Opus 4.6, GPT 5, Deepseek R1 या Llama 4 Maverick Instruct चलाएँ।
किसी API इंटीग्रेशन को अपनाने से पहले मॉडल का आउटपुट जाँचने का यह सबसे तेज़ तरीका है। कोई मॉडल चुनें, प्रॉम्प्ट भेजें और देखें कि आपके MCP टूलचेन में असल में किसके साथ काम करना होगा। चाहे आप किसी प्रोजेक्ट के लिए इमेज बना रहे हों, प्रॉम्प्ट की संरचना परख रहे हों, या देख रहे हों कि अलग-अलग मॉडल एक ही इनपुट को कैसे संभालते हैं, यह प्लेटफ़ॉर्म इंफ़्रास्ट्रक्चर के झंझट के बिना तेज़ एक्सेस देता है।
खाता बनाएँ, एक मॉडल चुनें और आज ही इमेज या टेक्स्ट जनरेट करना शुरू करें, किसी कॉन्फ़िग फ़ाइल की ज़रूरत नहीं।
अपनी भाषा चुनें
