मुख्य कंटेंट तक स्किप करें

MCP के साथ Claude को लोकल टूल्स और एजेंट्स से जोड़ें

मध्यम

आप चाहते हैं कि Claude दिमाग हो और आपकी मशीन हाथ मुहैया कराए — आपकी फाइलें पढ़े, आपका डेटाबेस क्वेरी करे, आपकी स्क्रिप्ट चलाए, यहाँ तक कि एक लोकल मॉडल या एक लोकल एजेंट को भी कॉल करे, और यह सब आपके डेटा को लैपटॉप से बाहर निकले बिना। इस तालमेल के लिए पहले से एक मानक मौजूद है: Model Context Protocol (MCP)। एक साँस में: MCP एक ओपन स्टैंडर्ड है जो किसी AI क्लाइंट को छोटे प्रोग्रामों के जरिए, जिन्हें MCP सर्वर कहते हैं, बाहरी टूल्स और डेटा को कॉल करने देता है — और ये सर्वर निजी तौर पर, लोकली, आपकी अपनी मशीन पर चल सकते हैं। यह पेज दिखाता है कि MCP क्या है, लोकल आर्किटेक्चर कैसे एक साथ जुड़ता है, Claude में एक लोकल सर्वर कैसे जोड़ें, और खुद का एक छोटा सा सर्वर कैसे बनाएं।

What you'll learn
  • MCP को एक वाक्य में समझाएं — एक ओपन स्टैंडर्ड ताकि कोई AI क्लाइंट MCP सर्वरों के जरिए बाहरी टूल्स और डेटा को कॉल कर सके
  • लोकल आर्किटेक्चर देखें: एक MCP क्लाइंट (Claude Code / Claude Desktop) जो stdio पर एक लोकल MCP सर्वर से बात कर रहा है
  • समझें कि क्यों यह वही Claude-दिमाग-के-रूप-में + लोकल-क्षमताओं का तालमेल है जो आप चाहते हैं
  • एक कमांड से Claude में एक लोकल MCP सर्वर जोड़ें
  • एक छोटा MCP सर्वर बनाएं जो एक टूल एक्सपोज़ करता हो
  • भरोसे की सीमा जानें — MCP सर्वर आपके ही विशेषाधिकारों के साथ काम करते हैं, इसलिए केवल वही इंस्टॉल करें जिस पर आप भरोसा करते हैं

MCP क्या है (एक साँस में)​

MCP एक ओपन स्टैंडर्ड है जो AI एप्लिकेशनों को बाहरी सिस्टमों से जोड़ता है। एक AI क्लाइंट (जैसे Claude) एक प्रोटोकॉल बोलता है; कोई भी MCP सर्वर जो उसे बोलता है, प्लग इन हो सकता है और क्लाइंट को नई क्षमताएं दे सकता है। आधिकारिक उपमा है AI के लिए एक USB-C पोर्ट: हर टूल के लिए एक अलग इंटीग्रेशन बनाने के बजाय, आप एक ही कनेक्टर के लिए बनाते हैं और वह हर जगह काम करता है।

Anthropic ने MCP को पेश किया और ओपन-सोर्स किया, और पहले ही दिन से यह लोकल MCP सर्वर सपोर्ट के साथ आया ताकि Claude आपकी अपनी मशीन पर चल रहे आंतरिक सिस्टमों और डेटासेट्स से जुड़ सके।

एक MCP सर्वर क्लाइंट को तीन तरह की चीजें एक्सपोज़ कर सकता है:

  • टूल्स — ऐसी क्रियाएं जिन्हें मॉडल कॉल कर सकता है (एक फाइल पढ़ना, एक क्वेरी चलाना, एक API हिट करना)। यह मॉडल के नेटिव टूल यूज़ के समान आकार का है: टाइप किए गए इनपुट के साथ एक नामित क्षमता।
  • रिसोर्सेज — डेटा जिसे क्लाइंट पढ़ सकता है (फाइलें, रिकॉर्ड, दस्तावेज़)।
  • प्रॉम्प्ट्स — पुनः उपयोग योग्य, पैरामीटराइज्ड प्रॉम्प्ट टेम्पलेट्स जो सर्वर पेश करता है।

इस पेज के लिए मुख्य बात है टूल्स: एक लोकल MCP सर्वर वह तरीका है जिससे आप Claude को एक नई, निजी क्षमता सौंपते हैं।

यह क्यों वही तालमेल है जो आप चाहते हैं​

लोग जब "Claude दिमाग के रूप में, मेरा कंप्यूटर शरीर के रूप में" कहते हैं, तो उनका मतलब बिल्कुल यही MCP क्लाइंट/सर्वर विभाजन होता है:

  • Claude ऑर्केस्ट्रेटर है। यह आपका लक्ष्य पढ़ता है, तय करता है कि कौन सा टूल कॉल करना है, उसे कॉल करता है, परिणाम पढ़ता है, और अगला कदम तय करता है।
  • लोकल MCP सर्वर क्षमताएं हैं। हर एक एक छोटा प्रोग्राम है जिसे आप अपनी मशीन पर चलाते हैं: एक फाइलसिस्टम सर्वर, एक डेटाबेस सर्वर, एक लोकल स्क्रिप्ट के इर्द-गिर्द एक रैपर, यहाँ तक कि एक सर्वर जो किसी लोकल मॉडल को कॉल करता है या काम किसी लोकल एजेंट को सौंप देता है।

क्योंकि सर्वर लोकली चलता है और Claude आपकी अपनी मशीन के स्टैंडर्ड इनपुट/आउटपुट पर उससे बात करता है, आपका डेटा और क्रियाएं आपके हार्डवेयर पर ही रहती हैं — मॉडल ऑर्केस्ट्रेट करता है, लेकिन फाइल पढ़ना, SQL, स्क्रिप्ट निष्पादन लोकली होते हैं। यह एजेंटिक काम का गोपनीयता-संरक्षित संस्करण है: दिमाग क्लाउड में (या लोकल भी), हाथ सख्ती से आपके बॉक्स पर।

और क्योंकि MCP एक ओपन स्टैंडर्ड है जिसे कई क्लाइंट्स में अपनाया गया है, आपके द्वारा बनाया गया सर्वर किसी एक ऐप तक सीमित नहीं है। वही लोकल सर्वर जिसे आप Claude Code में जोड़ते हैं, अन्य MCP-बोलने वाले क्लाइंट्स द्वारा भी इस्तेमाल किया जा सकता है — एक बार बनाएं, हर जगह पुनः उपयोग करें।

लोकल आर्किटेक्चर​

सबसे छोटी उपयोगी तस्वीर में दो हिस्से और एक चैनल होता है:

  • MCP क्लाइंट (होस्ट)। AI ऐप — उदाहरण के लिए Claude Code या Claude Desktop। यह मॉडल को रखता है और तय करता है कि कौन से टूल कॉल करने हैं।
  • MCP सर्वर। एक अलग प्रोसेस जो टूल्स/रिसोर्सेज/प्रॉम्प्ट्स का विज्ञापन करता है और पूछे जाने पर उन्हें निष्पादित करता है।
  • ट्रांसपोर्ट। लोकल सर्वरों के लिए क्लाइंट सर्वर को एक सबप्रोसेस के रूप में लॉन्च करता है और वे JSON-RPC संदेशों का उपयोग करते हुए stdio (स्टैंडर्ड इनपुट/आउटपुट) पर बात करते हैं। न कोई नेटवर्क, न कोई पोर्ट — बस आपकी मशीन पर दो प्रोसेसों के बीच एक लोकल पाइप। (रिमोट सर्वर भी मौजूद हैं, HTTP पर; यह पेज लोकल, stdio वाले मामले के बारे में है।)
┌─────────────────────────┐         stdio (JSON-RPC)        ┌──────────────────────────┐
│  MCP CLIENT / HOST       │ ──── launches as subprocess ──▶ │  LOCAL MCP SERVER         │
│  Claude Code / Desktop   │ ◀── tools/resources/prompts ─── │  filesystem · db · script │
│  (the model = the brain) │                                 │  · local model / agent    │
└─────────────────────────┘                                  └──────────────────────────┘
                                                              runs on YOUR machine, YOUR data

मॉडल आपकी डिस्क को सीधे कभी नहीं छूता — यह लोकल सर्वर से पूछता है, और सर्वर (आपकी अनुमतियों के साथ चलते हुए) काम करता है और एक परिणाम लौटाता है।

Claude में एक लोकल MCP सर्वर जोड़ें​

सबसे तेज रास्ता Claude Code का claude mcp add कमांड है, जो एक सर्वर रजिस्टर करता है जिसे क्लाइंट stdio पर लॉन्च करेगा। सामान्य आकार एक नाम है, फिर वह कमांड जो सर्वर को शुरू करता है।

Guided walkthrough1 of 4
  1. एक आधिकारिक रेफरेंस सर्वर (जैसे फाइलसिस्टम सर्वर) से शुरू करें ताकि व्यवहार ज्ञात हो। Anthropic रेफरेंस MCP सर्वरों का एक संग्रह बनाए रखता है जिन्हें आप लोकली चला सकते हैं — filesystem, git, memory, fetch, और अधिक।

एक लोकल फाइलसिस्टम सर्वर के लिए एक न्यूनतम claude mcp add (-- के बाद सब कुछ लॉन्च कमांड है):

Add a local filesystem MCP server to Claude Code

claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/dir

अगर आप सीधे कॉन्फिग एडिट करना पसंद करते हैं, तो एक stdio सर्वर उस कमांड से घोषित किया जाता है जो उसे लॉन्च करता है। आकार इस तरह दिखता है:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"]
    }
  }
}

एक छोटा MCP सर्वर बनाएं​

एक सर्वर बस एक प्रोग्राम है जो एक MCP SDK का उपयोग करता है, एक टूल घोषित करता है, और एक stdio ट्रांसपोर्ट शुरू करता है। पूरा विचार यहाँ TypeScript में है — एक टूल जो दो संख्याओं को जोड़ता है (बॉडी को "मेरी स्क्रिप्ट चलाओ", "मेरा DB क्वेरी करो", "मेरे लोकल मॉडल को कॉल करो" से बदल दें):

npm install @modelcontextprotocol/sdk 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-local-tools", version: "0.1.0" });

// Declare ONE tool. Inputs are typed; the body runs locally with your privileges.
server.registerTool(
  "add",
  {
    description: "Add two numbers",
    inputSchema: { a: z.number(), b: z.number() },
  },
  async ({ a, b }) => ({
    content: [{ type: "text", text: String(a + b) }],
  }),
);

// Talk to the client over stdio — this is what makes it a LOCAL server.
await server.connect(new StdioServerTransport());

इसे किसी भी अन्य stdio सर्वर की तरह ही Claude के साथ रजिस्टर करें — लॉन्च कमांड को अपनी फाइल की ओर इंगित करें:

Add your own local server to Claude Code

claude mcp add my-local-tools -- node /abs/path/to/server.js

यही पूरा लूप है: Claude (दिमाग) एक नया टूल देखता है, प्रासंगिक होने पर उसे कॉल करता है, और आपका कोड (हाथ) लोकली चलता है और परिणाम लौटाता है। क्योंकि यह वही ओपन प्रोटोकॉल बोलता है, यह सर्वर बिना किसी बदलाव के अन्य MCP क्लाइंट्स में भी काम करता है।

Watch out
  • MCP सर्वर आपके विशेषाधिकारों के साथ चलते हैं और वास्तविक क्रियाएं कर सकते हैं — केवल वही सर्वर इंस्टॉल करें जिन पर आप भरोसा करते हैं, और टूल परिणामों के जरिए आने वाले प्रॉम्प्ट-इंजेक्शन से सावधान रहें।

खुद को परखें​

खुद को परखें

0/4
  1. एक वाक्य में, MCP क्या है?
  2. एक लोकल MCP सर्वर के लिए, क्लाइंट आमतौर पर उससे कैसे बात करता है?
  3. एक MCP सर्वर बनाना टूल्स के आर-पार क्यों फायदेमंद रहता है?
  4. किसी सर्वर को इंस्टॉल करने से पहले उसकी जांच करने का मुख्य कारण क्या है?
कार्ड पलटने के लिए Enter या Space दबाएँ। कार्ड बदलने के लिए बाएँ और दाएँ तीर कुंजियों का उपयोग करें।शब्द दिखाया गया।
1 / 8
Key takeaways
  • MCP एक ओपन स्टैंडर्ड है ताकि एक AI क्लाइंट MCP सर्वरों के जरिए बाहरी टूल्स और डेटा को कॉल कर सके — Anthropic ने इसे शुरू से ही लोकल सर्वर सपोर्ट के साथ पेश किया।
  • लोकल आर्किटेक्चर सरल है: एक MCP क्लाइंट (Claude Code / Desktop) एक लोकल MCP सर्वर को एक सबप्रोसेस के रूप में लॉन्च करता है और stdio पर उससे बात करता है — आपका डेटा आपकी मशीन पर रहता है।
  • यह Claude-दिमाग-के-रूप-में + लोकल-क्षमताओं का तालमेल है: Claude ऑर्केस्ट्रेट करता है; लोकल सर्वर (फाइलसिस्टम, DB, एक स्क्रिप्ट, यहाँ तक कि एक लोकल मॉडल या एजेंट) हाथ मुहैया कराते हैं।
  • एक कमांड से एक सर्वर जोड़ें (claude mcp add ... -- <लॉन्च कमांड>); एक टूल रजिस्टर करके और एक stdio ट्रांसपोर्ट कनेक्ट करके एक MCP SDK से एक बनाएं।
  • MCP को व्यापक रूप से अपनाया गया है, इसलिए आपके द्वारा बनाया गया एक लोकल सर्वर कई क्लाइंट्स में काम करता है — एक बार बनाएं, हर जगह पुनः उपयोग करें।
  • सर्वर आपके विशेषाधिकारों के साथ काम करते हैं: केवल वही इंस्टॉल करें जिस पर आप भरोसा करते हैं और टूल परिणामों को एक संभावित प्रॉम्प्ट-इंजेक्शन वेक्टर मानें।

आगे​

  • रोजमर्रा टर्मिनल से MCP का उपयोग करें → Claude Code: MCP
  • ऑर्केस्ट्रेटर क्या है → Claude Code क्या है
  • MCP टूल्स जिस टूल-कॉलिंग आकार का पालन करते हैं → टूल यूज़
  • वह लोकल मॉडल या एजेंट चलाएं जिसे एक सर्वर रैप कर सकता है → लोकल AI एजेंट्स

स्रोत और आगे पढ़ने के लिए​