MCP हर जगह है। 2026 की शुरुआत में हर AI tool announcement में इसका नाम आता है। हर "modern AI stack" वाले article में listed है। लेकिन जब लोगों से पूछो MCP actually क्या है, तो या तो PhD thesis मिलती है या marketing pitch।
एक line में बात: MCP AI agents के लिए USB port है।
बस। पूरी explanation यही है। ठीक है, बाकी भी सुन लो। 😼
Standard से पहले की दुनिया
2024 के अंत का scene imagine करो। तुम एक AI agent बना रहे हो — एक program जो LLM (large language model — ChatGPT, Claude, Gemini के पीछे का दिमाग) use करके खुद decisions लेता है और actions perform करता है। तुम्हारे agent को PostgreSQL database query करना है, web search करना है, GitHub issues manage करने हैं, और local files read करनी हैं।
हर एक tool के लिए custom integration का jugaad code लिखो:
# हर tool का अपना jugaad code
from custom_postgres import query_db
from custom_github import create_issue
from custom_search import web_search
from custom_files import read_file
# हर integration में अलग:
# - Authentication methods
# - Response formats
# - Error handling
# - Connection management
हर AI vendor ने अपना integration system बनाया। Claude के पास "tool use" था। OpenAI के पास "function calling"। LangChain के पास "tools"। सब same काम करते थे, incompatible तरीके से। एक के लिए integration बनाओ तो दूसरे के लिए फिर से बनाओ।
ये AI tooling का Nokia-charger वाला दौर था। याद है ना? USB से पहले हर phone का अपना charger — Nokia का अलग, Samsung का अलग, Sony Ericsson का अलग। Pure chaos। 😹
वो gap जो भरना ज़रूरी था
Problem ये नहीं था कि integrations मुश्किल थे। Problem ये था कि हर बार मुश्किल थे। नया tool आया — 200 lines का custom integration लिखो। अब इसे market के हर AI client से multiply करो। Math बेरहम है।
किसी को एक universal plug define करना था।
MCP आया
Anthropic ने 2024 के अंत में MCP (Model Context Protocol) introduce किया — एक open standard — AI tools के लिए universal plug, जैसे USB लेकिन data के लिए। March 2026 तक, ये AI agents के बाहरी दुनिया से connect करने का default तरीका बन चुका है।
चार tools को MCP से connect करना ऐसा दिखता है:
{
"mcpServers": {
"postgres": { "command": "npx", "args": ["-y", "@mcp/server-postgres", "..."] },
"github": { "command": "npx", "args": ["-y", "@mcp/server-github"] },
"search": { "command": "npx", "args": ["-y", "@mcp/server-brave-search"] },
"files": { "command": "npx", "args": ["-y", "@mcp/server-filesystem", "/home"] }
}
}
चार tools। चार lines config। Zero custom code। हर server same protocol बोलता है — programs कैसे communicate करें, इसके rules का set — और हर client समझता है।
Architecture: तीन actors, zero जादू
MCP में बस तीन moving parts हैं:
┌──────────────────┐
│ HOST │ (Claude Code, Cursor, तुम्हारा app)
│ │
│ ┌────────────┐ │
│ │ CLIENT │──── MCP Protocol ──── SERVER (Postgres, GitHub)
│ └────────────┘ │
│ │
│ ┌────────────┐ │
│ │ CLIENT │──── MCP Protocol ──── SERVER (Search, Files)
│ └────────────┘ │
└──────────────────┘
Host — वो AI application जिससे तुम interact करते हो। Claude Code, Claude Desktop, Cursor, Windsurf, या तुम्हारा खुद का custom app।
Client — host के अंदर रहता है। एक server से connection manage करता है। एक host कई clients चला सकता है, कई servers से connected।
Server — tools और data provide करता है। एक अलग process के रूप में चलता है — standalone program — तुम्हारी machine पर या किसी remote server पर।
कोई orchestration layer नहीं। कोई message queue नहीं। कोई service mesh नहीं। बस एक client, एक server, standard protocol पर बात कर रहे हैं। बस इतना ही। 😸
Pipe में क्या flow होता है
MCP servers तीन type की चीज़ें provide कर सकते हैं:
1. Tools — actions जो AI ले सकता है
Tools functions हैं — self-contained operations — जो AI call कर सकता है। जैसे "SQL query run करो" या "GitHub issue create करो।"
{
"name": "query",
"description": "Run a read-only SQL query against the database",
"inputSchema": {
"type": "object",
"properties": {
"sql": { "type": "string", "description": "The SQL query to execute" }
},
"required": ["sql"]
}
}
जब server start होता है, वो client को बताता है: "ये रहे मेरे tools, हर एक क्या करता है, parameters क्या हैं।" AI model ये descriptions पढ़ता है और decide करता है कब कौन सा use करना है — बिल्कुल वैसे जैसे तुम decide करते हो phone में कौन सी app खोलनी है।
2. Resources — data जो AI पढ़ सकता है
Resources वो data pieces हैं जो server expose करता है। किसी file का content, database schema (तुम्हारी tables की structure), कोई configuration।
Difference important है: tools काम करते हैं, resources context देते हैं। AI resources पढ़ता है environment समझने के लिए, action लेने से पहले। ऐसे समझो — restaurant में order करने से पहले menu पढ़ना।
3. Prompts — starter templates
Pre-written templates जो server offer करता है, जैसे "इस table को analyze करो" या "इस pull request को review करो।" ये convenience shortcuts हैं जिन्हें पता है server के tools effectively कैसे use करने हैं।
ज़्यादातर लोग prompts ignore करते हैं और AI से normally बात करते हैं। बिल्कुल सही है। ये optional हैं।
एक real request trace करते हैं
चलो follow करते हैं क्या होता है जब तुम Claude Code में type करते हो "Show me all users who signed up today" और Postgres MCP server connected है:
1. तुम TYPE करते हो: "Show me all users who signed up today"
2. CLAUDE देखता है Postgres MCP tools available हैं
(query, list_tables, describe_table)
3. CLAUDE पहले 'describe_table' call करता है
users table की structure समझने के लिए
4. CLIENT भेजता है SERVER को:
{ "method": "tools/call",
"params": { "name": "describe_table",
"arguments": { "table": "users" } } }
5. SERVER PostgreSQL query करता है, schema return करता है
6. CLAUDE schema के based पर SQL query लिखता है:
SELECT * FROM users WHERE created_at >= CURRENT_DATE
7. CLIENT query भेजता है SERVER को, SERVER run करता है
8. CLAUDE results format करता है और तुम्हें दिखाता है
पूरा process 1-2 seconds लेता है। तुमने English में पूछा, AI ने SQL figure out किया, MCP server ने run किया, और results मिल गए। कोई manual query writing नहीं। ज़्यादातर लोगों के लिए ये "aha" moment होता है। 😻
Transport layer — bits कैसे travel करते हैं
MCP दो transport methods पर काम करता है:
STDIO (local servers) — server तुम्हारी machine पर child process के रूप में चलता है। Communication stdin/stdout पर होती है — वही text pipes जो तुम्हारा terminal use करता है। ये सबसे common setup है:
{
"mcpServers": {
"my-server": {
"command": "node",
"args": ["server.js"],
"env": { "DB_URL": "..." }
}
}
}
Simple, fast, कोई network involvement नहीं।
Streamable HTTP (remote servers) — जब servers दूसरी machines पर हों। Cloud-hosted, team में shared, या third-party services:
{
"mcpServers": {
"remote-server": {
"url": "https://mcp.example.com/sse",
"headers": { "Authorization": "Bearer your-token" }
}
}
}
Requests regular HTTP POST जाती हैं। Responses real time में stream back होती हैं। Enterprise deployments ऐसे ही काम करते हैं — centralized servers जिनसे multiple developers connect करते हैं।
20 lines में अपना खुद का बनाओ
ये रहा सबसे simple working MCP server जो तुम official TypeScript SDK से लिख सकते हो:
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
const server = new McpServer({
name: "my-tool",
version: "1.0.0"
});
server.tool(
"hello",
"Says hello to someone",
{ name: { type: "string", description: "Person to greet" } },
async ({ name }) => ({
content: [{ type: "text", text: `Hello, ${name}!` }]
})
);
const transport = new StdioServerTransport();
await server.connect(transport);
SDK install करो (npm install @modelcontextprotocol/sdk), tools define करो, transport connect करो। SDK protocol negotiation handle करता है — वो handshake जहाँ client और server agree करते हैं कि दोनों क्या support करते हैं — message parsing, और error handling।
एक practical example — weather API
server.tool(
"get_weather",
"Get current weather for a city",
{
city: { type: "string", description: "City name" },
units: { type: "string", description: "celsius or fahrenheit", default: "celsius" }
},
async ({ city, units }) => {
const response = await fetch(
`https://wttr.in/${encodeURIComponent(city)}?format=j1`
);
const data = await response.json();
const current = data.current_condition[0];
const temp = units === "fahrenheit"
? current.temp_F + "°F"
: current.temp_C + "°C";
return {
content: [{ type: "text", text: `${city}: ${temp}, ${current.weatherDesc[0].value}` }]
};
}
);
अब तुम्हारा AI agent weather check कर सकता है। लेकिन ज़्यादा important बात — pattern देखो: किसी भी API (application programming interface — programs एक दूसरे से कैसे बात करते हैं) से data fetch करो, MCP tool में wrap करो, और दुनिया का हर MCP-compatible client इसे use कर सकता है।
Capability handshake
जब client पहली बार server से connect होता है, negotiate करते हैं:
Client: "मैं tools, resources, और prompts support करता हूँ। तुम्हारे पास क्या है?"
Server: "मेरे पास 3 tools और 2 resources हैं। ये रहे।"
Client: "समझ गया। Ready."
इसका मतलब clients को पहले से जानने की ज़रूरत नहीं कि server क्या provide करता है। Servers features add या remove कर सकते हैं बिना कुछ तोड़े। Different clients same server को अलग तरीके से use कर सकते हैं। Graceful evolution, brittle coupling नहीं।
क्या perfect नहीं है
ऐसा मत समझो कि ये flawless है। March 2026 तक:
Security अभी भी तुम्हारी ज़िम्मेदारी है। एक MCP server वो सब कर सकता है जो तुम उसे permission दो। एक malicious server tool calls के through data चुरा सकता है। कोई built-in sandboxing नहीं — system के बाकी हिस्से से automatic isolation नहीं। तुम हर server पर उसी तरह trust करते हो जैसे कोई random npm package install करते समय करते हो। एक second सोचो इस पर।
Discovery अभी भी messy है। अपने use case के लिए सही MCP server ढूँढने का मतलब है mcpservers.org या glama.ai/mcp/servers जैसी registries browse करना। कोई centralized, verified marketplace अभी तक नहीं है। Quality में ज़मीन-आसमान का फ़र्क है।
Debugging rough है। जब कोई tool call fail होता है, error messages कई layers से गुज़रते हैं — client, protocol, server, underlying API — और दूसरी तरफ़ पहुँचते-पहुँचते कचरा बन जाते हैं। Improve हो रहा है, लेकिन अभी भी painful है।
Performance overhead है। हर tool call एक JSON-RPC round trip है — JSON format में request-response message। Local STDIO servers के लिए ये negligible है। Remote servers के लिए HTTP पर, जब AI multiple calls chain करता है तो latency बढ़ती जाती है।
तुम्हारे लिए इसका क्या मतलब है
अगर तुम AI coding tools use करते हो जैसे Claude Code या Cursor: MCP का मतलब है तुम्हारा AI बिना software updates के नई abilities सीखता रहता है। Jira के लिए नया MCP server आया? Install करो, और AI तुम्हारे tickets manage करता है। AWS का नया server? AI तुम्हारा infrastructure manage करता है। Tool vendor का integration बनने का wait नहीं — community बनाती है।
अगर तुम tools या APIs build करते हो: MCP का मतलब है एक integration लिखो और ये Claude, Cursor, Windsurf, Cline, और हर future MCP-compatible client के साथ काम करता है। एक server, दर्जनों clients। USB वाला math।
अगर तुम founder हो: अपने product के लिए MCP server बनाना अब उतना ही ज़रूरी हो गया है जितना 10 साल पहले REST API बनाना था। अगर तुम्हारे developer tool का MCP server नहीं है, तो users पूछेंगे क्यों।
March 2026 का ecosystem
- Official servers Anthropic से: PostgreSQL, GitHub, Filesystem, Brave Search, Puppeteer, Google Maps, Slack, और बहुत कुछ — MCP servers repository देखो
- Enterprise servers AWS, Cloudflare, Sentry से
- Community servers Docker, Kubernetes, Notion, Linear, Figma, Stripe के लिए — सैकड़ों और गिनती जारी है
- 2026 roadmap agent-to-agent communication, horizontal scaling, और
.well-knowndiscovery mechanism पर focus करता है ताकि servers automatically खुद को advertise कर सकें
USB ने proprietary charger को ख़त्म किया। MCP custom integrations को ख़त्म करेगा।
MCP AI tooling में सबसे important चीज़ है जब से context windows — AI की working memory — इतनी बड़ी हुईं कि एक real codebase fit हो सके। ये sexy नहीं है। ये stdio पर JSON-RPC protocol है। लेकिन USB भी sexy नहीं था, और उसने अपने रास्ते में आने वाले हर proprietary connector को ख़त्म कर दिया।
अभी सबसे smart काम जो तुम कर सकते हो: specification documents पढ़ना बंद करो। एक Postgres MCP server install करो, Claude Code से connect करो, और अपने database के बारे में पूछो। 30 seconds में MCP समझ आ जाएगा।
Specification उन लोगों के लिए है जो protocol बना रहे हैं। तुम इसे use कर रहे हो। 😹
