🔌 धडा 13 (बोनस) — MCP: AI tools साठी universal plug

📍 तुम्ही इथे आहात: बोनस धडा 13 · मागे: lesson-12-diffusion

📦 या ब्रँचमध्ये काय आहे

सगळे 12 मुख्य धडे, आणि agents बांधणाऱ्या प्रत्येकाला आठवडाभरात भेटणारा बोनस: MCP — Model Context Protocol — धडा 11 ची tools plug-and-play भाग बनवणारे standard.

🧒 5 वर्षांच्या मुलाला समजावल्यासारखे

शाळेच्या विज्ञान प्रयोगशाळेला एक अडचण आहे. 🔬 प्रत्येक उपकरण — सूक्ष्मदर्शक, तराजू, थर्मामीटर — स्वतःच्या विचित्र cable सह येते, आणि प्रत्येक वर्गात वेगवेगळे sockets आहेत. Room 3 मध्ये सूक्ष्मदर्शक हवा आहे? कोणीतरी हाताने Room-3-सूक्ष्मदर्शक adapter बनवतो. नवा तराजू? पाच खोल्या = पाच नवे adapters. N खोल्या आणि M उपकरणे असतील तर N×M adapters लागतात — शिपायाचा ड्रॉवर एकेक-वेळच्या cables चे दुःस्वप्न बनतो. 🍝

मग शाळा एकच standard भिंतीतला socket 🔌 स्वीकारते. प्रत्येक उपकरण standard plug सह येते; प्रत्येक खोलीत standard socket असतो. कोणतेही उपकरण, कोणतीही खोली, शून्य खास adapters: N×M ऐवजी N+M.

हेच MCP, AI साठी:

उपकरणे म्हणजे MCP servers — छोटे programs जे एखादी क्षमता (तुमच्या files, GitHub, database, Slack…) standard plug मागे गुंडाळतात.
खोल्या म्हणजे AI apps (hosts: Claude Desktop, IDEs, तुमचा स्वतःचा agent) — प्रत्येकात standard sockets असतात (MCP clients).
कोणताही server कोणत्याही host मध्ये plug करा. कोणीतरी लिहिलेला GitHub server MCP बोलणाऱ्या प्रत्येक app मध्ये चालतो, आज, न बदलता.

आणि प्रत्येक उपकरण plug केल्यावर ते काय देते ते जाहीर करते — manual नको: "नमस्कार! मी ही tools (तुम्ही करू शकता अशा गोष्टी), हे resources (तुम्ही वाचू शकता अशा गोष्टी), हे prompts (मी सुचवलेल्या कृती) देतो." model आधी शोधतो, मग वापरतो — धडा 11 चा loop, standard plugs सह.

🗺️ आकृती

flowchart LR
    subgraph before["🍝 before: N×M custom adapters"]
        x1["every app × every tool<br/>= a hand-built integration"]
    end
    subgraph hosts["🏫 hosts - the rooms"]
        h1["Claude Desktop 🔌"]
        h2["your IDE 🔌"]
        h3["your agent app 🔌"]
    end
    subgraph servers["🔬 MCP servers - the instruments"]
        s1["📁 filesystem<br/>tools · resources · prompts"]
        s2["🐙 GitHub"]
        s3["🗄️ your database"]
    end
    before -.->|"MCP standardizes<br/>the socket"| hosts
    h1 ---|"one protocol"| s1
    h2 --- s2
    h3 --- s3
    h1 --- s3

❓ काय (तपशील)

भूमिका: एक host (AI app) clients चालवतो (प्रत्येक connection साठी एक); प्रत्येक client एका server शी बोलतो. Servers तीन primitives उघड करतात:
- tools — model बोलावू शकतो अशी functions (धडा 11 चा calculator, standard केलेला),
- resources — वाचता येणारा context (files, records) जो host desk ला जोडू शकतो (धडा 08!),
- prompts — server सुचवतो असे पुन्हा वापरता येणारे prompt templates.
तारेवरचे संदेश (ते सुखद कंटाळवाणे आहेत): JSON-RPC. तीन चालींमध्ये एक session:

→ {"method":"initialize", "params":{"clientInfo":{"name":"my-agent"}}}
→ {"method":"tools/list"}
← {"result":{"tools":[{"name":"query_db",
     "description":"Run a read-only SQL query",
     "inputSchema":{"type":"object","properties":{"sql":{"type":"string"}}}}]}}
→ {"method":"tools/call","params":{"name":"query_db","arguments":{"sql":"SELECT …"}}}
← {"result":{"content":[{"type":"text","text":"23 rows: …"}]}}

आधी शोधा, मग बोलवा — result desk वर येतो आणि धडा 11 चा loop पुढे चालू राहतो. एवढाच सगळा सोहळा.

Transports: stdio (host server ला local child process म्हणून सुरू करतो — files/dev tools साठी उत्तम) किंवा HTTP (remote/shared servers). दोन्हीकडे तेच messages.
उगम आणि स्वीकार: Anthropic ने (2024 च्या शेवटी) खुले standard म्हणून आणले, त्यानंतर संपूर्ण ecosystem मध्ये स्वीकारले गेले — ज्यावर सगळे सहमत झाले असा दुर्मीळ plug.
Security, गांभीर्याने 🚧: MCP server तुमच्या permissions ने चालतो — एखादा plug करणे म्हणजे software install करणे. आणि tool चे RESULTS desk वर येतात, म्हणून server ने आणलेले एखादे दुष्ट webpage/doc model कडे सूचना चोरून पोहोचवण्याचा प्रयत्न करू शकते (prompt injection). धडा 11 चे guardrails दुप्पट लागू होतात: फक्त विश्वासू servers, शक्य तिथे read-only, परिणामकारक कृतींसाठी human gates, logs नेहमी.

🤔 का

धडा 11 नंतर प्रत्येक team तीच tools प्रत्येक app मध्ये हाताने जोडत होती — N×M adapters चा ड्रॉवर. MCP तो एकत्र करतो: तुमचा database server एकदाच लिहा, आज Claude Desktop मधून, उद्या तुमच्या IDE मधून, पुढच्या आठवड्यात तुमच्या custom agent मधून वापरा. म्हणूनच "agent ecosystems" अचानक चालू लागतात: क्षमता खासगी जोडणीऐवजी वाटून घेता येणारे भाग बनल्या. (आणि हा सिनेमा तुम्ही पाहिला आहे: Kubernetes ने containers साठी आणि Terraform ने infrastructure साठी हेच standard plugs केले — कंटाळवाणे interfaces हेच ecosystems घडण्याचे कारण असतात. 🔌)

🧪 करून पाहा

कागदावरचा lab (5 मिनिटे): host तुम्ही व्हा. वरचे JSON session घ्या आणि तुमचे calendar गुंडाळणाऱ्या उपकरणासाठी tools/list response लिहा: कोणती tools (नावे + arguments)? कोणते resources? तुम्ही कशाला read-only आणि कशाला माणसाच्या मंजुरीमागे ठेवाल? अभिनंदन — तुम्ही आत्ताच एक MCP server design केला; SDK आवृत्ती म्हणजे बहुतेक फक्त typing.

खरा lab (15 मिनिटे, एक config बदल): reference filesystem server कोणत्याही MCP बोलणाऱ्या app मध्ये जोडा (उदा. Claude Desktop → claude_desktop_config.json, किंवा तुमच्या IDE ची MCP settings), modelcontextprotocol.io वरच्या quickstart प्रमाणे — मग assistant ला एका folder ची यादी करायला आणि एका file चा सारांश द्यायला सांगा. ते कोणती TOOLS बोलावते ते पाहा. तुम्ही आत्ता वाचलेला protocol प्रत्येक step खाली चालू आहे.

🎓 आता toolbox खरोखर पूर्ण झाला

AI कसे चालते आणि ते कसे वापरायचे याचे बारा धडे — आणि ते बाकी सगळ्याशी जोडणारा plug. जादू शून्य, sockets सह. 🔌🎓

git checkout main

🔌 Lesson 13 (bonus) — MCP: the universal plug for AI tools

📍 You are here: Bonus lesson 13 · Previous: lesson-12-diffusion

📦 What's in this branch

All 12 core lessons, plus the bonus everyone building agents meets within a week: MCP — the Model Context Protocol — the standard that turns lesson 11's tools into plug-and-play parts.

🧒 Explain like I'm 5

The school's science lab has a problem. 🔬 Every instrument — microscope, scale, thermometer — comes with its own weird cable, and every classroom has different sockets. Want the microscope in Room 3? Someone hand-builds a Room-3-microscope adapter. New scale? Five rooms = five new adapters. With N rooms and M instruments you need N×M adapters — the janitor's drawer is a nightmare of one-off cables. 🍝

Then the school adopts one standard wall socket 🔌. Every instrument ships with the standard plug; every room has the standard socket. Any instrument, any room, zero custom adapters: N+M instead of N×M.

That's MCP, for AI:

The instruments are MCP servers — small programs that wrap a capability (your files, GitHub, a database, Slack…) behind the standard plug.
The rooms are AI apps (hosts: Claude Desktop, IDEs, your own agent) — each has standard sockets (MCP clients).
Plug any server into any host. The GitHub server someone wrote works in every MCP-speaking app, today, unchanged.

And each instrument announces what it offers when plugged in — no manual: "Hello! I offer these tools (things you may do), these resources (things you may read), these prompts (recipes I suggest)." The model discovers, then uses — lesson 11's loop, with standardized plugs.

🗺️ Diagram

flowchart LR
    subgraph before["🍝 before: N×M custom adapters"]
        x1["every app × every tool<br/>= a hand-built integration"]
    end
    subgraph hosts["🏫 hosts - the rooms"]
        h1["Claude Desktop 🔌"]
        h2["your IDE 🔌"]
        h3["your agent app 🔌"]
    end
    subgraph servers["🔬 MCP servers - the instruments"]
        s1["📁 filesystem<br/>tools · resources · prompts"]
        s2["🐙 GitHub"]
        s3["🗄️ your database"]
    end
    before -.->|"MCP standardizes<br/>the socket"| hosts
    h1 ---|"one protocol"| s1
    h2 --- s2
    h3 --- s3
    h1 --- s3

❓ What (the details)

Roles: a host (the AI app) runs clients (one per connection); each client speaks to one server. Servers expose three primitives:
- tools — functions the model may call (lesson 11's calculator, standardized),
- resources — readable context (files, records) the host can attach to the desk (lesson 08!),
- prompts — reusable prompt templates the server suggests.
The wire (it's refreshingly boring): JSON-RPC. A session in three moves:

→ {"method":"initialize", "params":{"clientInfo":{"name":"my-agent"}}}
→ {"method":"tools/list"}
← {"result":{"tools":[{"name":"query_db",
     "description":"Run a read-only SQL query",
     "inputSchema":{"type":"object","properties":{"sql":{"type":"string"}}}}]}}
→ {"method":"tools/call","params":{"name":"query_db","arguments":{"sql":"SELECT …"}}}
← {"result":{"content":[{"type":"text","text":"23 rows: …"}]}}

Discover, then call — the result lands on the desk and lesson 11's loop continues. That's the whole ceremony.

Transports: stdio (host launches the server as a local child process — great for files/dev tools) or HTTP (remote/shared servers). Same messages either way.
Origin & adoption: introduced by Anthropic (late 2024) as an open standard, since adopted across the ecosystem — the rare plug everyone agreed on.
Security, seriously 🚧: an MCP server runs with your permissions — plugging one in is installing software. And tool RESULTS land on the desk, so a malicious webpage/doc a server fetches can try to smuggle instructions to the model (prompt injection). Lesson 11's guardrails apply double: trusted servers only, read-only where possible, human gates for consequential actions, logs always.

🤔 Why

Lesson 11 left every team hand-wiring the same tools into every app — the N×M adapter drawer. MCP collapses it: write your database server ONCE, use it from Claude Desktop today, your IDE tomorrow, your custom agent next week. It's also why "agent ecosystems" suddenly work: capabilities became shareable parts instead of private wiring. (And you've seen this movie: standard plugs are what Kubernetes did for containers and Terraform did for infrastructure — boring interfaces are how ecosystems happen. 🔌)

🧪 Try it

Paper lab (5 min): you be the host. Take the JSON session above and write the tools/list response for an instrument wrapping your calendar: what tools (names + arguments)? what resources? what would you mark read-only vs gated-behind-a-human? Congratulations — you just designed an MCP server; the SDK version is mostly typing.

Real lab (15 min, one config edit): add the reference filesystem server to any MCP-speaking app (e.g. Claude Desktop → claude_desktop_config.json, or your IDE's MCP settings) following the quickstart at modelcontextprotocol.io — then ask the assistant to list a folder and summarize a file. Watch which TOOLS it calls. The protocol you just read is running under every step.

🎓 Now the toolbox is truly complete

Twelve lessons of how AI works and how to use it — plus the plug that connects it to everything else. Zero magic left, sockets included. 🔌🎓

git checkout main

← Previousdiffusion Finished! Take the quiz →check what stuck

This page is the lesson's README from the lesson-13-mcp branch, shown here so the whole School stays on one site. Code files open on GitHub at the same branch.