🖼️ See the drawing + lab 🏠 Course home 🌿 Branch on GitHub ✏️ View source

🖼️ आकृती आणि labThe drawing + lab पूर्ण पानावर उघडा ↗Open full page ↗

🍝 धडा 01 — MCP का: adapter च्या ड्रॉवरची समस्या

📍 तुम्ही इथे आहात: 8 पैकी धडा 01 · पुढे: lesson-02-architecture

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

MCP ज्या समस्येला संपवण्यासाठी जन्माला आला ती समस्या — आणि protocol मधील प्रत्येक रचना-निर्णय समजावणारी एकच कल्पना (N×M → N+M).

🎒 सुरू करण्यापूर्वी: हा AI कोर्सच्या बोनस धडा 13 चा खोल साथीदार आहे, आणि Agents शाळेच्या आधी किंवा नंतर थांबण्यासाठी चांगला टप्पा. तुम्हाला फक्त Python 3 लागते. हे काय नाही: production-SDK tutorial — ही शाळा प्रत्येक byte दाखवून protocol (आवृत्ती 2026-07-28, सध्याची) शिकवते; खऱ्या servers साठी अधिकृत SDKs वापरा.

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

शाळेची विज्ञान प्रयोगशाळा 🔬: प्रत्येक उपकरण (microscope, तराजू, thermometer) स्वतःच्या विचित्र cable सोबत येते, आणि प्रत्येक वर्गात वेगवेगळे sockets असतात. खोली 3 मध्ये microscope? खोली-3-microscope साठी हाताने adapter बनवा. नवा तराजू? पाच खोल्या = आणखी पाच adapters.

N खोल्या × M उपकरणे = N×M adapters. सफाई कर्मचाऱ्याचा ड्रॉवर म्हणजे गुंतलेल्या spaghetti चा गुंता. 🍝 आणि हे काल्पनिक नाही — MCP पूर्वी AI tooling असेच होते: IDE साठी तुमचे GitHub integration, chatbot साठी आणखी एक, तुमच्या agent साठी तिसरे. तीच क्षमता, प्रत्येक app साठी पुन्हा बनवलेली, कायमची.

शाळा (आणि उद्योग) नेहमी याच उपायावर पोहोचतात: socket चे मानकीकरण करा 🔌. प्रत्येक उपकरण मानक plug सोबत येते; प्रत्येक खोलीत मानक भिंतीवरचे socket असते. कोणतेही उपकरण, कोणतीही खोली: N+M.

MCP म्हणजे AI साठी तेच socket: apps (hosts) ना sockets मिळतात, क्षमतांना (servers) plugs मिळतात, आणि या repo मध्ये एक खरी चालणारी जोडी आहे — server/school_server.py आणि client/mini_client.py — जी तुम्ही धडा 07 पर्यंत पूर्ण वाचाल. कोणतीही जादू उरणार नाही.

🗺️ आकृती

flowchart LR
    subgraph before["🍝 before: N×M"]
        a1["IDE ⨯ GitHub adapter"]
        a2["chatbot ⨯ GitHub adapter"]
        a3["agent ⨯ GitHub adapter"]
        a4["…every pair, hand-built"]
    end
    subgraph after["🔌 after: N+M"]
        h["hosts with standard sockets:<br/>IDE · chatbot · agent"]
        s["servers with standard plugs:<br/>GitHub · files · your DB"]
        h ---|"one protocol"| s
    end
    before -->|"standardize the socket"| after

❓ काय

MCP (Model Context Protocol): AI applications ना tools आणि data शी जोडण्यासाठीचे खुले standard (Anthropic, 2024 च्या शेवटी; संपूर्ण ecosystem ने स्वीकारलेले). AI साठी USB-C, शाळेच्या socket च्या पद्धतीने.
अर्थशास्त्र: integrations वाटून घेता येणारे भाग बनतात. तुमचा database server एकदाच लिहा → तो Claude Desktop, तुमचा IDE आणि तुमचा custom agent यांमध्ये, कोणताही बदल न करता चालतो.
इतर शाळांमधून तुम्हाला आधीच माहीत असलेली इतिहासाची पुनरावृत्ती: containers नी "software कसे पाठवायचे" याचे मानकीकरण केले (Docker कोर्स), Kubernetes ने "ते कसे चालवायचे" याचे — कंटाळवाणे, सामायिक interfaces हेच ecosystems घडवतात. MCP हे "AI गोष्टींपर्यंत कसा पोहोचतो" यासाठी करतो.

🤔 हा कोर्स का (AI कोर्सच्या बोनस धड्याऐवजी)

AI कोर्सचा धडा 13 वरून दिसणारे दृश्य देतो. ही शाळा जमिनीवर उतरते: खरी architecture (L02), तीन primitives (L03), byte-by-byte wire (L04), प्रामाणिकपणे security (L05), मग तुम्ही खरा server आणि client वाचता (L06–07) आणि sequence आकृत्यांसह production सारखे पाच use cases अभ्यासता (L08).

🧪 करून पाहा (60 सेकंद — संपूर्ण protocol, live)

python3 client/mini_client.py

पाहा: ओळख 🪪 (server/discover), एक discovery 📋, तीन tool calls 🧰 — प्रत्येक JSON message छापलेला, प्रत्येक request वर त्याचा _meta badge (आवृत्ती 2026-07-28: handshake नाही). तो संवाद हाच या कोर्सचा संपूर्ण विषय आहे. तुम्हाला हे दिसायला हवे (छाटलेले):

═══ 1) introductions 🪪 — server/discover (optional since 2026-07-28) ═══
→ {"jsonrpc": "2.0", "id": 1, "method": "server/discover", "params": {"_meta": {"io.modelcontext …
← {"jsonrpc": "2.0", "id": 1, "result": {"resultType": "complete", "supportedVersions": ["2026-0 …
   🔬 school-server v2.0.0 speaks ['2026-07-28'] · stocks: tools
═══ 2) discovery 📋 — 'what do you offer?' ═════════════════
→ {"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {"_meta": {"io.modelcontextproto …
← {"jsonrpc": "2.0", "id": 2, "result": {"resultType": "complete", "tools": [{"name": "get_stude …
   🧰 get_student_count: How many students are in a class (3A or 3B)?
   🧰 lookup_grade: Look up one student's grade (read-only).
   🧰 add_homework: Add a homework item (WRITES state — hosts should confirm with the user!).
═══ 3) tool calls 🧰 — what an agent's loop would do ═══════
→ {"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "get_student_count", "a …
← {"jsonrpc": "2.0", "id": 3, "result": {"resultType": "complete", "content": [{"type": "text",  …
   📄 lands on the desk: Class 3A has 3 students: aishwarya, katrina, dipika.
→ {"jsonrpc": "2.0", "id": 4, "method": "tools/call", "params": {"name": "lookup_grade", "argume …
← {"jsonrpc": "2.0", "id": 4, "result": {"resultType": "complete", "content": [{"type": "text",  …
   📄 lands on the desk: Katrina (3A) has grade A+.
→ {"jsonrpc": "2.0", "id": 5, "method": "tools/call", "params": {"name": "add_homework", "argume …
← {"jsonrpc": "2.0", "id": 5, "result": {"resultType": "complete", "content": [{"type": "text",  …
   📄 lands on the desk: Added ✏️ — homework list is now: [{"title": "read MCP lesson 05", "due": "Friday"}]
═══ done — that was the ENTIRE protocol: three verbs and a badge 🪪 (no handshake since 2026-07-28) ═══

धडा 07 पर्यंत तुम्ही त्याच्या दोन्ही बाजू मनात लिहिलेल्या असतील.

✅ तपासा — तुम्हाला काय दिसायला हवे

python3 client/mini_client.py तीन विभाग छापतो — 🪪 ओळख (server/discover), 📋 discovery (तीन tools ची यादी), 🧰 तीन tool calls — प्रत्येकात एक → request ओळ आणि एक ← reply ओळ, आणि शेवट done — that was the ENTIRE protocol ने होतो. Exit code 0, stack trace नाही. छाटलेले अपेक्षित output करून-पाहा विभागात command खाली आहे.

🏁 तुम्ही आत्ताच काय सिद्ध केले

Python 3 शिवाय काहीही install न करता तुम्ही खरा MCP server आणि खरा MCP host चालवला — socket म्हणजे जादू नाही, त्या ~230 ओळी आहेत ज्या तुम्ही वाचणार आहात.

⚠️ नेहमीच्या चुका

client दुसऱ्या directory मधून चालवणे — तो repo root च्या सापेक्ष server/school_server.py सुरू करतो; तो repo root मधूनच चालवा
आधी SDK install करणे — इथे कशालाही त्याची गरज नाही; हाच तर मुद्दा आहे
जुने tutorials handshake दाखवतात म्हणून output मध्ये handshake अपेक्षित धरणे — आवृत्ती 2026-07-28 ने तो काढून टाकला (धडा 04)

🏭 प्रत्यक्ष वापरात हे का महत्त्वाचे: MCP चे मूल्य N+M अर्थशास्त्रात आहे: प्रत्येक क्षमतेसाठी एक server, जो प्रत्येक host पुन्हा वापरतो. जे teams तो नीट स्वीकारतात ते servers ना प्रत्येक app साठीचा चिकट गोंद न मानता सामायिक infrastructure मानतात — versioned, reviewed, least-privilege.

⏭️ पुढे

नक्की कोण कोणाशी बोलतो? Hosts, clients, servers — तीन भूमिका.

git checkout lesson-02-architecture

🍝 Lesson 01 — Why MCP: the adapter drawer problem

📍 You are here: Lesson 01 of 8 · Next: lesson-02-architecture

📦 What's in this branch

The problem MCP exists to kill — and the one idea (N×M → N+M) that explains every design choice in the protocol.

🎒 Before you start: this is the deep-dive companion to the AI course's bonus lesson 13, and a good stop before or after the Agents school. You need Python 3 only. What this is not: a production-SDK tutorial — this school teaches the protocol (revision 2026-07-28, the current one) by showing every byte; for real servers use the official SDKs.

🧒 Explain like I'm 5

The school science lab 🔬: every instrument (microscope, scale, thermometer) ships with its own weird cable, and every classroom has different sockets. Microscope in Room 3? Hand-build a Room-3-microscope adapter. New scale? Five rooms = five more adapters.

N rooms × M instruments = N×M adapters. The janitor's drawer is spaghetti. 🍝 And it's not hypothetical — that was AI tooling before MCP: your GitHub integration for the IDE, ANOTHER one for the chatbot, a THIRD for your agent. Same capability, rebuilt per app, forever.

The fix schools (and industries) always land on: standardize the socket 🔌. Every instrument ships the standard plug; every room has the standard wall socket. Any instrument, any room: N+M.

MCP is that socket for AI: apps (hosts) get sockets, capabilities (servers) get plugs, and this repo contains a REAL working pair — server/school_server.py and client/mini_client.py — that you'll read in full by lesson 07. No magic will remain.

🗺️ Diagram

flowchart LR
    subgraph before["🍝 before: N×M"]
        a1["IDE ⨯ GitHub adapter"]
        a2["chatbot ⨯ GitHub adapter"]
        a3["agent ⨯ GitHub adapter"]
        a4["…every pair, hand-built"]
    end
    subgraph after["🔌 after: N+M"]
        h["hosts with standard sockets:<br/>IDE · chatbot · agent"]
        s["servers with standard plugs:<br/>GitHub · files · your DB"]
        h ---|"one protocol"| s
    end
    before -->|"standardize the socket"| after

❓ What

MCP (Model Context Protocol): an open standard (Anthropic, late 2024; adopted ecosystem-wide) for connecting AI applications to tools and data. USB-C for AI, the school-socket way.
The economics: integrations become shareable parts. Write your database server once → it works in Claude Desktop, your IDE, and your custom agent, unchanged.
History rhyme you already know from the other schools: containers standardized "how software ships" (Docker course), Kubernetes standardized "how it runs" — boring shared interfaces are how ecosystems happen. MCP does it for "how AI reaches things".

🤔 Why this course (vs the AI course's bonus lesson)

The AI course's lesson 13 gives the aerial view. This school goes to the ground: the actual architecture (L02), the three primitives (L03), the wire byte-by-byte (L04), security honestly (L05), then you READ a real server and client (L06–07) and study five production-shaped use cases with sequence diagrams (L08).

🧪 Try it (60 seconds — the whole protocol, live)

python3 client/mini_client.py

Watch: introductions 🪪 (server/discover), a discovery 📋, three tool calls 🧰 — every JSON message printed, each request wearing its _meta badge (revision 2026-07-28: no handshake). That conversation is the entire subject of this course. You should see, trimmed:

═══ 1) introductions 🪪 — server/discover (optional since 2026-07-28) ═══
→ {"jsonrpc": "2.0", "id": 1, "method": "server/discover", "params": {"_meta": {"io.modelcontext …
← {"jsonrpc": "2.0", "id": 1, "result": {"resultType": "complete", "supportedVersions": ["2026-0 …
   🔬 school-server v2.0.0 speaks ['2026-07-28'] · stocks: tools
═══ 2) discovery 📋 — 'what do you offer?' ═════════════════
→ {"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {"_meta": {"io.modelcontextproto …
← {"jsonrpc": "2.0", "id": 2, "result": {"resultType": "complete", "tools": [{"name": "get_stude …
   🧰 get_student_count: How many students are in a class (3A or 3B)?
   🧰 lookup_grade: Look up one student's grade (read-only).
   🧰 add_homework: Add a homework item (WRITES state — hosts should confirm with the user!).
═══ 3) tool calls 🧰 — what an agent's loop would do ═══════
→ {"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "get_student_count", "a …
← {"jsonrpc": "2.0", "id": 3, "result": {"resultType": "complete", "content": [{"type": "text",  …
   📄 lands on the desk: Class 3A has 3 students: aishwarya, katrina, dipika.
→ {"jsonrpc": "2.0", "id": 4, "method": "tools/call", "params": {"name": "lookup_grade", "argume …
← {"jsonrpc": "2.0", "id": 4, "result": {"resultType": "complete", "content": [{"type": "text",  …
   📄 lands on the desk: Katrina (3A) has grade A+.
→ {"jsonrpc": "2.0", "id": 5, "method": "tools/call", "params": {"name": "add_homework", "argume …
← {"jsonrpc": "2.0", "id": 5, "result": {"resultType": "complete", "content": [{"type": "text",  …
   📄 lands on the desk: Added ✏️ — homework list is now: [{"title": "read MCP lesson 05", "due": "Friday"}]
═══ done — that was the ENTIRE protocol: three verbs and a badge 🪪 (no handshake since 2026-07-28) ═══

By lesson 07 you'll have written both sides of it in your head.

✅ Verify — what you should see

python3 client/mini_client.py prints three sections — 🪪 introductions (server/discover), 📋 discovery (three tools listed), 🧰 three tool calls — each with a → request line and a ← reply line, and ends with done — that was the ENTIRE protocol. Exit code 0, no stack trace. The trimmed expected output is under the command in the Try-it section.

🏁 What you just proved

You ran a real MCP server and a real MCP host with nothing installed beyond Python 3 — the socket is not magic, it is ~230 lines you will read.

⚠️ Common mistakes

running the client from another directory — it launches server/school_server.py relative to the repo root; run it from the repo root
installing an SDK first — nothing here needs one; that is the point
expecting a handshake in the output because older tutorials show one — revision 2026-07-28 removed it (lesson 04)

🏭 Why this matters in production: MCP's value is the N+M economics: one server per capability, reused by every host. Teams that adopt it well treat servers as shared infrastructure — versioned, reviewed, least-privilege — rather than per-app glue.

⏭️ Next

Who exactly talks to whom? Hosts, clients, servers — the three roles.

git checkout lesson-02-architecture

← Course homeall lessons Next →architecture

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