MCP म्हणजे "AI अॅप्ससाठीचे USB-C": एकच खुले protocol जे कोणत्याही AI सहाय्यकाला कोणत्याही tool, database किंवा API शी, कस्टम जोडणी कोडशिवाय, जोडू देते. हे काय आहे, कसे चालते, का आणि कोणत्या दिशेने जात आहे, हे इथे आहे - sequence diagrams, संपूर्ण 0 ते 100 runtime प्रवाह आणि खऱ्या केस स्टडीजसह.
Model Context Protocol हा एक खुला मानक आहे (Anthropic ने 2024 च्या उत्तरार्धात सादर केला) जो AI अॅप्लिकेशन्सना बाह्य प्रणालींशी जोडण्याचा एक सर्वव्यापी मार्ग निश्चित करतो. MCP आधी, एका AI अॅप आणि एका tool मधील प्रत्येक एकत्रीकरण खास बनवावे लागत असे: M अॅप्स × N tools = M×N कस्टम connectors. MCP ते M+N मध्ये बदलते - एकदा server बनवा, आणि प्रत्येक MCP-सुसंगत client तो वापरू शकतो.
वापरकर्त्यासमोर असणारे AI अॅप - Claude Code, Claude Desktop, एखादे IDE, किंवा SDK वर बनवलेला तुमचा स्वतःचा agent. तो model चालवतो आणि सर्व काही व्यवस्थापित करतो.
host च्या आत राहणारा एक connector. प्रत्येक server साठी एक client, जो 1:1 stateful session राखतो आणि model च्या वतीने MCP बोलतो.
क्षमता उघड करणारा एक स्वतंत्र प्रोग्राम - एक filesystem, एक database, GitHub, Slack, एक खाजगी API. विचारल्यावर तो खरे काम करतो.
| Primitive | ते काय आहे | कोण नियंत्रित करते | उदाहरण |
|---|---|---|---|
| Tools | typed इनपुट/आउटपुटसह कॉल करता येणारी functions | model केव्हा कॉल करायचे ते ठरवतो | create_issue(), run_query() |
| Resources | URI ने संबोधित केलेला, वाचता येणारा data / context | अॅप / वापरकर्ता जोडतो | file:///report.pdf, db://users/42 |
| Prompts | पुन्हा वापरता येणारे, parameterized prompt templates | वापरकर्ता चालवतो (slash commands) | /summarize-pr, /plan-sprint |
LLMs शक्तिशाली आहेत पण वेगळे पडलेले असतात - त्यांच्या training cutoff मागे अडकलेले, तुमच्या live data पर्यंत पोहोच नसलेले आणि कृती करण्याची क्षमता नसलेले. प्रत्येक टीमने हे स्वतंत्रपणे सोडवल्याने ठिसूळ, एकावेळचे एकत्रीकरण तयार झाले. MCP जोडणी स्तर प्रमाणित करते.
एकदा server लिहा; प्रत्येक MCP host (Claude, Cursor, Windsurf, कस्टम agents) तो वापरू शकतो. प्रत्येक अॅपसाठी पुन्हा एकत्रीकरण नाही.
tools runtime ला शोधले जात असल्याने, तुम्ही host ला हात न लावता servers जोडू, काढू किंवा अपग्रेड करू शकता. Agents अनेक servers एकत्र करतात.
host प्रत्येक कॉलमध्ये मध्यस्थी करतो आणि वापरकर्त्याची मंजुरी मागू शकतो. Servers scoped परवानग्या आणि स्वतःच्या auth सह वेगळ्या प्रक्रिया म्हणून चालतात.
Python, TypeScript, Java, C#, Go आणि इतर भाषांमध्ये SDKs असलेला एक खुला spec. एका model किंवा एका कंपनीशी बांधलेला नाही.
प्रत्येक संदेश JSON-RPC 2.0 असतो. client आणि server एका transport वरून requests, responses आणि notifications ची देवाणघेवाण करतात. दोन transports प्रामुख्याने वापरले जातात:
server एक subprocess असतो; संदेश stdin/stdout वरून वाहतात. जलद, network नाही, लोकल tools साठी (filesystem, git) आदर्श. Auth अंतर्भूत आहे - तो तुमच्याच रूपात चालतो.
server एक web service आहे जो HTTP वरून पोहोचता येतो, streaming साठी Server-Sent Events सह. अनेक clients ना सेवा देतो आणि प्रमाणीकरणासाठी OAuth 2.1 वापरतो.
flowchart LR
subgraph Host["🖥️ Host (Claude Code / Desktop)"]
LLM["🧠 LLM"]
C1["🔌 Client A"]
C2["🔌 Client B"]
C3["🔌 Client C"]
LLM <--> C1
LLM <--> C2
LLM <--> C3
end
C1 <-->|stdio| S1["⚙️ Filesystem Server"]
C2 <-->|HTTP/SSE| S2["⚙️ GitHub Server"]
C3 <-->|HTTP/SSE| S3["⚙️ Postgres Server"]
S1 --> D1[("📁 Local files")]
S2 --> D2{{"🌐 GitHub API"}}
S3 --> D3[("🗄️ Database")]
{
"mcpServers": {
"postgres": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres",
"postgresql://localhost/mydb"]
},
"github": {
"url": "https://api.githubcopilot.com/mcp/",
"headers": { "Authorization": "Bearer ${GITHUB_TOKEN}" }
}
}
}पहिला एक लोकल stdio server आहे जो subprocess म्हणून चालवला जातो; दुसरा एक रिमोट HTTP server आहे. तेच protocol, वेगळे transport.
तीन दृश्ये: सुरुवातीचा handshake आणि discovery, runtime ला एक tool call, आणि रिमोट servers साठीचा OAuth प्रवाह.
sequenceDiagram
autonumber
participant U as 👤 User
participant H as 🖥️ Host
participant C as 🔌 Client
participant S as ⚙️ Server
U->>H: Launch app / add server
H->>C: Spin up a client for this server
C->>S: initialize (protocol version, capabilities)
S-->>C: initialize result (server capabilities, info)
C->>S: notifications/initialized
Note over C,S: Session is now live
C->>S: tools/list
S-->>C: [tools + JSON Schemas]
C->>S: resources/list
S-->>C: [resources]
C->>S: prompts/list
S-->>C: [prompt templates]
C-->>H: Register capabilities
H->>H: Inject tool defs into model context
sequenceDiagram
autonumber
participant U as 👤 User
participant LLM as 🧠 Model
participant H as 🖥️ Host
participant C as 🔌 Client
participant S as ⚙️ Server
participant Ext as 🌐 Data / API
U->>H: "How many signups last week?"
H->>LLM: prompt + available tools
LLM-->>H: tool_use: run_query(sql=...)
H->>U: Approve calling run_query? (optional)
U-->>H: ✔ Approve
H->>C: dispatch tool call
C->>S: tools/call { name, arguments }
S->>Ext: SELECT count(*) FROM signups ...
Ext-->>S: rows
S-->>C: tools/call result (structured content)
C-->>H: result
H->>LLM: tool result appended to context
LLM-->>H: "You had 1,284 signups last week."
H-->>U: Final answer
sequenceDiagram
autonumber
participant U as 👤 User
participant C as 🔌 Client
participant S as ⚙️ MCP Server
participant A as 🔑 Auth Server
C->>S: tools/call (no / expired token)
S-->>C: 401 Unauthorized + WWW-Authenticate
C->>A: Discover metadata, register client
C->>U: Open browser → consent screen
U->>A: Log in & grant scopes
A-->>C: Authorization code (redirect)
C->>A: Exchange code + PKCE for tokens
A-->>C: access_token (+ refresh_token)
C->>S: Retry tools/call (Bearer token)
S-->>C: 200 OK + result
cold start पासून पूर्ण झालेल्या, tool-सहाय्यित उत्तरापर्यंत घडणारे सर्व काही - संपूर्ण प्रवास क्रमाने.
कोणीतरी एक MCP server लिहितो (किंवा तुम्ही प्रकाशित केलेला install करता) जो एका प्रणालीला - एक DB, एक API, filesystem - गुंडाळतो आणि त्याची tools, resources आणि prompts जाहीर करतो.
ते config मध्ये जोडा: stdio साठी एक command, किंवा HTTP साठी एक url. आता host ला माहित आहे की server अस्तित्वात आहे.
सुरुवातीला host प्रत्येक server साठी एक client तयार करतो आणि transport उघडतो - एक subprocess pipe (stdio) किंवा एक HTTP जोडणी.
initialize देवाणघेवाणclient आणि server protocol version वर वाटाघाटी करतात आणि क्षमता जाहीर करतात, मग client notifications/initialized पाठवतो. session live झाली.
client tools/list, resources/list, prompts/list कॉल करतो. server नावे, वर्णने आणि JSON Schemas परत करतो.
शोधलेल्या tool व्याख्या स्वरूपित करून model च्या context मध्ये ठेवल्या जातात जेणेकरून त्याला कळेल की तो काय आणि कोणत्या arguments सह कॉल करू शकतो.
वापरकर्ता एक विनंती पाठवतो. model तिच्यावर आणि उपलब्ध tools वर तर्क करतो, आणि एखादे tool उपयुक्त ठरणार असल्यास एक संरचित tool_use विनंती तयार करतो.
host tool call पकडतो. संवेदनशील कृतींसाठी तो वापरकर्त्याला मंजुरीसाठी विचारतो. Auth तपासले जाते; रिमोट servers इथे OAuth प्रवाह सुरू करू शकतात.
client tools/call पाठवतो; server query चालवतो / API ला भेटतो / file वाचतो आणि संरचित निकाल परत करतो (आणि प्रगती stream करू शकतो).
host tool निकाल संभाषणाला जोडतो आणि model ला पुन्हा कॉल करतो. model आणखी tool calls साखळू शकतो - गरजेनुसार टप्पा 60 कडे परत जा.
context मध्ये ताज्या, वास्तविक जगातील data सह, model एक आधारभूत अंतिम उत्तर तयार करतो. पुढील फेरीसाठी session उघडी राहते.
production-सारख्या वापरात MCP दाखवणारे तीन प्रातिनिधिक नमुने.
एक developer त्याच्या सहाय्यकाला विचारतो की "CI अपयशी करणारी flaky test शोधा आणि एक fix PR उघडा." agent तीन MCP servers एकत्र करतो.
एक support engineer विचारतो: "या आठवड्यातील खुल्या P1 incidents चा सारांश द्या आणि #ops ला एक digest पोस्ट करा." कंपनी SSO मागे रिमोट MCP servers चालवते.
search_issues ला एक tool म्हणून आणि issues ना resources म्हणून उघड करतो - model live P1 tickets खेचतो.post_message उघड करतो; पोस्ट करण्यापूर्वी host स्पष्ट मंजुरी मागतो.एक front-end dev Figma मध्ये एक component निवडतो आणि agent ला विचारतो की "हे एक React component म्हणून बनवा." Figma एक MCP server पुरवते जो live design context उघड करतो.
MCP एका विक्रेत्याच्या spec पासून व्यापकपणे स्वीकारलेल्या मानकापर्यंत उल्लेखनीयरीत्या जलद पोहोचले. मार्गक्रमण अधिक समृद्ध, अधिक सुरक्षित, अधिक स्वायत्त agents कडे निर्देश करते.
discovery आणि एक-क्लिक install साठी सार्वजनिक server registries - agent क्षमतांसाठी एक "app store", signing आणि provenance सह.
स्वतःच agents असणारे servers, तसेच उदयोन्मुख agent-ते-agent protocols, जे एकमेकांना काम सोपवणाऱ्या विशेष agents ची नेटवर्क्स शक्य करतात.
MCP एंटरप्राइझमध्ये अधिक खोलवर जात असताना fine-grained scopes, प्रमाणित OAuth 2.1, tool-poisoning बचाव आणि लेखापरीक्षणक्षमता.
Servers कामाच्या मध्येच वापरकर्त्याकडून इनपुट मागू शकतात (elicitation) आणि host कडून model completions ची विनंती करू शकतात (sampling) - अधिक समृद्ध दुतर्फा संवाद.
OS-स्तरीय आणि IDE-स्तरीय MCP hosts, जेणेकरून कोणतेही अॅप खास जोडणीशिवाय एक agent पृष्ठभाग बनू शकते.
प्रगती streaming, रद्दीकरण आणि टिकाऊ दीर्घकाळ चालणाऱ्या कामांसाठी उत्तम समर्थन - खऱ्या स्वायत्त agents साठी अत्यावश्यक.