Lesson 01 What Is MCP and Why It Matters
Theme:
Lesson 01 · Slide 1

Lesson 01 — What Is MCP and Why It Matters

The Model Context Protocol, in one lesson.

MCP Servers Module 1

Lesson 01 · Slide 2

The problem MCP solves

The M × N problem

You have M LLM apps (Claude Desktop, Cursor, your internal tools…) and N capabilities you want to expose (search Slack, query a DB, read your filesystem…). Without a protocol you build M × N integrations.

Every new client needs to know every tool. Every new tool needs to be re-glued into every client. The work multiplies.

3 clients × 4 tools = 12 shims

            Slack    DB     FS    Web
Claude Desk  [#]    [#]    [#]    [#]
Cursor       [#]    [#]    [#]    [#]
Your App     [#]    [#]    [#]    [#]

  every [#] is a custom integration
  you have to write and maintain.
Lesson 01 · Slide 3

One protocol, both sides plug in.

MCP standardises the wire between an LLM app (the client) and a capability provider (the server). Write your server once; every MCP-aware client can talk to it. Add a new client; it inherits every existing server.

MCP Client Claude Desktop Cursor · Windsurf your IDE / app MCP Protocol JSON-RPC over stdio / HTTP MCP Server your code tools · resources prompts
Lesson 01 · Slide 4

Three primitives.

An MCP server exposes capabilities in exactly three shapes. Everything you'll build in this course is one of these three.

PrimitiveWhat it isExample
ToolFunction the LLM can callpkb.search(query)
ResourceRead-only data the LLM can fetchfile:///notes/2026-05-21.md
PromptReusable prompt template provided by the server/welcome
Lesson 01 · Slide 5

Real example.

The official filesystem MCP server is the canonical "hello world". Once configured in Claude Desktop, here is what the user actually sees:

Notes: The user never touches JSON. The protocol is invisible to them — that is the whole point.
Lesson 01 · Slide 6

MCP vs raw function-calling

Why MCP wins for cross-app tooling

  • Reusable across clients — one server, many apps.
  • Sampling back to the LLM — the server can ask the client to run an LLM completion on its behalf.
  • User-permissioned tools — the client mediates approval per call.
  • Transport flexibility — same server runs over stdio or HTTP without code changes.

When you don't need MCP

A single-binary app calling a single LLM with private tools doesn't gain anything from MCP — the protocol overhead buys you nothing if there is only ever one client and one server.

Use raw function-calling there. Reach for MCP when the tools need to be shared.

Lesson 01 · Slide 7

The 2026 landscape

Lesson 01 · Slide 8

Transports at a glance

MCP messages are JSON-RPC 2.0. The protocol is the same; the pipe changes.

Next lesson: deep dive on the wire format and lifecycle.
Lesson 01 · Slide 9

The PKB server.

You'll build a Personal Knowledge Base MCP server, one capability per lesson:

  1. L05 — search — full-text search across your notes. The first tool; the spine of the server.
  2. L06 — fetch — read the full content of a specific note by ID. Pairs with search to give Claude both discovery and retrieval.
  3. L07 — summarize — collapse a note (or a set of notes) into a short brief. Introduces server-side prompts.
  4. L08 — write — create or append to notes from inside a conversation. Adds permissioning — this is the first destructive tool.
  5. L09 — export — pack a selection of notes into a downloadable bundle. Demonstrates resources and binary payloads.
Lesson 01 · Slide 10

Prereqs & setup check

Open a terminal and run:

python --version          # 3.10+
pip install 'mcp[cli]'      # the official SDK
mcp dev --help              # should print the dev CLI

Already done claude/lesson13-building-mcp-server?

If you've already done claude/lesson13-building-mcp-server, skim slides 1–9 and jump straight to Lesson 04.

Lesson 01 · Slide 11

A word on terminology

Four pairs that trip up everyone on day one:

PairOne-sentence disambiguation
server vs clientThe server exposes capabilities; the client is the LLM app that consumes them — same as web, opposite intuition for some.
tool vs resourceTools are callable actions (verbs); resources are addressable data the model reads (nouns).
sampling vs elicitationSampling is the server asking the client for an LLM completion; elicitation is the server asking the user (via the client) for input.
stdio vs HTTP transportstdio = subprocess pipes for local servers; HTTP = networked servers, possibly multi-tenant.
Lesson 01 · Slide 12

Recap & what's next

Coming up: Lesson 02 — JSON-RPC, transports, and the connection lifecycle.
1 / ?