Summary of Today’s Gen AI MCP Session: Pipes and Protocols – MCP Architecture and Your Dev Environment (26 Oct 2026)

Saturday we used an MCP server. Today we went under the hood and got the machine ready to build one.

1. The Architecture, Restated

Three parts, in this order:

Part	Role
Host	The AI application — Claude Desktop, an IDE, your own agent
Client	Lives inside the host. One client per server connection
Server	Hosts the tool and does the actual work

The flow, end to end:

Model → MCP client → MCP server → work happens → result → client → model

The Swiggy example from Saturday, mapped: Claude is the host, its MCP client makes the call, the Swiggy MCP server books the table, the result comes back, and the model turns it into a sentence.

In a custom agent, your agent is the client. Each tool you want it to reach is a server. That’s how you scale from one tool to twenty — you add servers, you don’t rewrite the agent.

2. Transports: How Client and Server Talk

stdio — same machine
The client launches the server as a child process and talks over its standard input and output. Think of two pipes: the client writes to one, the server reads it, and replies on the other.

It’s local-only for a simple reason: pipes don’t cross machines. That’s what makes it perfect for development and for tools that act on your own computer.

Streamable HTTP — different machines
When the server lives elsewhere, communication goes over HTTP. This is how the Swiggy connector works.

On SSE: the original HTTP+SSE transport has been deprecated in favour of Streamable HTTP. Server-Sent Events didn’t disappear — Streamable HTTP still uses SSE internally to stream responses back. So “SSE was replaced” is true of the transport, not the technology.

3. What an MCP SDK Gives You

Server side — what you expose:

• Tools — actions the model can take
• Resources — data it can read
• Prompts — reusable templates

Client side — what the host provides:

• Sampling — the server can ask the client’s model for a completion
• Roots and elicitation — scope and user input

Worth keeping straight: sampling is a client capability, not something your server exposes.

4. Python Environment

uv python install 3.12          # if you don't have it
mkdir learning-mcp && cd learning-mcp
uv init --python 3.12           # note the double dash
uv add "mcp[cli]"               # SDK + the CLI you'll need
uv add --dev ipykernel
code .

• Python 3.12 or above. 3.11 may work; don’t fight it.
• The quotes around "mcp[cli]" matter — without them your shell may mangle the brackets. And plain uv add mcp leaves you without the mcp command the inspector workflow uses.
• Select the interpreter in VS Code: command palette (Ctrl+Shift+P, Cmd+Shift+P on Mac) → Python: Select Interpreter → the one inside this project’s .venv.

5. Node.js — For the Inspector

The MCP Inspector runs on Node, so you need it even though we’re writing Python.

Install through a version manager, not a one-off installer:

OS	How
Windows	nvm-windows — a separate project from the Unix one, so use its own installer
Mac	Homebrew → nvm
Linux	The official nvm install script

Then:

nvm install --lts      # picks the current LTS for you
node --version
npm --version
npx --version

All three must respond. If npx is missing, the inspector won’t start.

6. Also Install

• Claude Desktop — our client for trying out the servers we build. The free capabilities are enough for this.
• PowerShell (Windows) is easier to read than the embedded VS Code terminal during demos.
• A local LLM is optional. Only worth it if your machine has the headroom.

7. Schedule Change

The format moves to two online and two offline sessions per week.

✅ Before the Next Session

This is a hard prerequisite — next session we write a real local MCP server, and there won’t be time to fix setups.

1. Python 3.12+ installed, with the learning-mcp project initialised through uv.
2. mcp[cli] and ipykernel installed, interpreter selected in VS Code.
3. Node LTS via nvm, with node, npm and npx all answering.
4. Claude Desktop installed.

Setup help is available between sessions — use it rather than arriving blocked.

⏭️ Next up: writing your first local MCP server.