MCP — Study Notes

01

First — what even is a "protocol"?

The one-liner that unlocks everything

Must-know

◆ Intuition — the crust

"Protocol" just means: agreed rules for how two things talk to each other. That's it. Nothing more.

Before MCP, every AI framework (LangChain, LlamaIndex, CrewAI) had its own way of calling tools. Every tool had to write N custom integrations. MCP is just everyone agreeing on the same rulebook.

◆ Explanation

Real-world protocols — same idea, different domains

Protocol	Agreed rule
HTTP	How a browser talks to a web server
USB	How a device connects to a computer
Kafka	How producers and consumers exchange messages
MCP	How an AI agent talks to a tool server

02

What is MCP

USB-C for AI — universal plug, any device, any wall socket

Must-know

◆ Why — motivation

MCP = Model Context Protocol. An open standard for connecting LLMs to external tools, data, and services — created by Anthropic (Nov 2024), now governed by the Linux Foundation's Agentic AI Foundation (co-founded by Anthropic, OpenAI, Google, Microsoft, AWS, Block).

MCP is the interface layer between the LLM and tools + resources — it sits between the reasoning loop and the actual execution.

◆ Intuition — the crust

The problem it solves: same reason Kafka replaced point-to-point data pipelines — N×M → N+M. Without a standard, every framework needs a custom connector to every tool. MCP makes it N+M — write the tool once, any agent uses it.

03

The actual JSON rulebook

MCP defines exactly two things: how to discover tools, and how to call them

High priority

◆ Explanation

Live wire protocol — client ↔ server handshake

Client ↔ server handshake

MCP Client (your agent)

→ client sends

"method": "tools/list" // "what can you do?"

→ client sends

"method": "tools/call", "params": { "name": "create_issue", "arguments": { "repo": "myrepo", "title": "Bug fix" } } // LLM decided to call this

MCP Server (GitHub expert)

← server replies

"tools": [ { "name": "create_issue", "description": "Creates a GitHub issue", "inputSchema": { ... } }, ... ] // here are all my tools

← server replies

"content": [ { "type": "text", "text": "Issue #42 created" } ] // result, always same shape

The server never changes the shape. The client never guesses. That's the protocol — two message types, consistent structure, every server everywhere.

04

MCP server is built of 4 primitives

Most servers expose primarily Tools

Must-know

◆ Explanation

⚙️

Tools

Callable functions that do things — create_issue, run_query, send_message. Most commonly used primitive.

🗄️

Resources

Data, databases, files the agent can read — any form of structured or unstructured data.

📋

Prompts

Pre-crafted, tailored prompt templates for specific repeated tasks — bundled with the server.

🔁

Sampling

Server can ask the client to run an LLM completion — server-initiated AI calls back through the client.

Resources and Prompts are less common. Sampling is advanced — allows the server to trigger LLM calls, enabling recursive/agentic server behaviour.

05

Agent vs MCP — completely different layers

People confuse these because they're always used together — they're not the same thing

High priority

◆ Intuition — the crust

MCP

A power socket — standardized interface, doesn't care what's plugged in

≠

Agent

The device plugged in — reasoning loop, decides what to do with the power

MCP is the last mile. How the agent reaches a tool. Everything else is the agent's job.

◆ Explanation

Agent vs MCP — side by side

	Agent	MCP
What it is	Reasoning loop (think → act → observe)	Protocol / contract for tool exposure
Has intelligence?	Yes — LLM decides	No — just routes calls
Makes decisions?	Yes	No
Can exist alone?	Yes (with hardcoded tools)	No — needs a client
Examples	LangGraph, ReAct, Strands	GitHub MCP, Postgres MCP
Analogy	The chef	The kitchen equipment standard

Request flow — DB query example

User query ↓ Agent (LLM reasoning loop) ↓ "I need to query the DB" MCP Client (inside the agent) ↓ tools/call → Postgres MCP server MCP Server (Postgres expert) ↓ result returned Agent (observes, reasons again) ↓ Final answer

06

Two transport mechanisms

How the client and server physically communicate — stdio and SSE / streamable-http

Must-know

◆ Intuition — the crust

Transport 1

stdio

Client spawns the server as a local subprocess. They talk via stdin/stdout pipes. No port, no network.

best for: local scripts, dev tools

Transport 2 — local

streamable-http (local)

Server runs on your machine as an HTTP service. Client hits localhost:PORT/mcp.

best for: local microservices, docker

Transport 2 — remote

streamable-http (remote)

Server is hosted by a third party. Client hits their URL with an auth header. You don't run it.

best for: GitHub, Stripe, Slack MCP servers

SSE vs streamable-http: SSE (Server-Sent Events) was the original MCP transport for HTTP — the server pushes events to the client over a persistent connection. Streamable-http is the newer replacement (2025 spec update) — more flexible, supports both streaming and regular HTTP. Most modern servers use streamable-http; if you see sse in older code, the newer spec calls it streamable_http.

◆ Explanation

Configuring all three transports

async with MultiServerMCPClient({ # stdio — spawns subprocess, no port "math": { "transport": "stdio", "command": "python", "args": ["servers/math_server.py"], }, # local http — server running on your machine "weather": { "transport": "streamable_http", "url": "http://localhost:8000/mcp", }, # remote http — third-party hosted, auth via header "github": { "transport": "streamable_http", "url": "https://api.githubcopilot.com/mcp/", "headers": { "Authorization": "Bearer ghp_token" }, }, }) as client: tools = await client.get_tools() # auto-discovers ALL tools

07

MCP server ecosystem

10,000+ public servers — three types to know

Good to have

◆ Intuition — the crust

Server types

Type	Who built it	Trust	Examples
Official	The platform itself	Highest	GitHub MCP, Stripe MCP, Supabase MCP
Reference	Anthropic (to demo the spec)	High	@modelcontextprotocol/server-github, server-postgres
Community	Anyone	Verify first	Check stars, last commit, maintenance

Registries: mcp.so · smithery.ai · mcpservers.org · github.com/wong2/awesome-mcp-servers

08

Minimal POC — LangGraph + FastMCP

Two files. One server, one agent. Enough to demo in any interview.

Good to have

◆ Explanation

install

pip install langchain-mcp-adapters langgraph langchain langchain-openai fastmcp

math_server.py — MCP server (stdio)

from fastmcp import FastMCP mcp = FastMCP("Math") # define tools with a simple decorator — that's it @mcp.tool() def add(a: int, b: int) -> int: """Add two numbers""" return a + b @mcp.tool() def multiply(a: int, b: int) -> int: """Multiply two numbers""" return a * b if __name__ == "__main__": mcp.run(transport="stdio")

agent.py — MCP client + LangGraph agent

import asyncio from langchain_mcp_adapters.client import MultiServerMCPClient from langgraph.prebuilt import create_react_agent from langchain_openai import ChatOpenAI async def main(): llm = ChatOpenAI(model="gpt-4o-mini") async with MultiServerMCPClient({ "math": { "transport": "stdio", "command": "python", "args": ["math_server.py"], } }) as client: tools = await client.get_tools() # auto-discovered agent = create_react_agent(llm, tools) result = await agent.ainvoke({ "messages": [{"role": "user", "content": "What is (3 + 5) * 12?"}] }) # agent calls add(3,5) → 8, then multiply(8,12) → 96 asyncio.run(main())

run

export OPENAI_API_KEY=sk-... python agent.py

The agent calls add(3, 5) → gets 8 → calls multiply(8, 12) → returns 96. Multi-step tool use, automatically, with zero manual orchestration.

09

Key concepts — interview cheatsheet

Plus a learning path for what's next

High priority

◆ Explanation

Cheatsheet

Concept	What to say
Why MCP?	Solves N×M tool fragmentation — write tool once, use across any MCP-compatible host
Transports	stdio for local subprocess; streamable-http (formerly SSE) for remote/deployed servers
MultiServerMCPClient	Stateless by default — each tool invocation creates a fresh ClientSession, executes, cleans up
Primitives	Tools (callable), Resources (data), Prompts (templates), Sampling (server-initiated LLM calls)
vs plain @tool	MCP tools are language/framework-agnostic — a Go server can expose tools a Python agent uses
Security	Permission boundaries, scoped access — server controls what the client can call
Interface layer	MCP sits between the LLM reasoning loop and the actual tool/resource execution

What's next — learning path

Add HTTP transport — run math_server with transport="streamable_http", connect via URL. Simulates a real deployed microservice.
Multi-server — add weather, DB servers to MultiServerMCPClient. Agent auto-routes to the right server per query.
Connect real MCP servers — GitHub, Postgres, Slack. No code to write — just point at their URL or npx command.
LangSmith tracing — MCP tool calls trace alongside agent reasoning steps. Aligns with existing LangSmith + OpenTelemetry setup.

10

Interview one-liners

The four questions that come up every time

Must-know

◆ Why — motivation

Interview Q & A

Q: Why MCP?

A: Same reason Kafka replaced point-to-point pipelines — N×M becomes N+M. Write the tool server once, every agent uses it.

Interview Q & A

Q: What is MCP technically?

A: An agreed JSON rulebook — client sends tools/list, server returns schemas, client sends tools/call with args, server returns result in a consistent shape. Every server, everywhere.

Interview Q & A

Q: Agent vs MCP?

A: MCP makes tools discoverable and standardized. Agents decide which tools to use and when. MCP is the socket. The agent is the device.

Interview Q & A

Q: Who created it?

A: Anthropic created it in Nov 2024, then donated governance to the Linux Foundation — co-governed now by Anthropic, OpenAI, Google, Microsoft, AWS, Block. Vendor-neutral infrastructure, like HTTP.