What problem does MCP solve? (the N×M problem)
Welcome: why does MCP exist?
Level: from scratch — you don't need any previous experience. If you've never heard "MCP", you're in the right place. Watch the video above and follow this guide at your own pace.
In this first lesson you'll understand what problem the Model Context Protocol (MCP) solves and why it became a standard. We're not going to write code yet: first the "what for". Once the "what for" is clear, everything else is much easier to learn.
What you'll learn
- The concrete problem MCP solves (the N×M problem).
- How MCP fits next to things you may already know (APIs, and if you code, your editor's LSP).
- The minimum vocabulary for the rest of the course: host, client, server.
The problem, in one sentence
AI models are only as good as the context you give them. For an assistant to be truly useful, it needs to connect to your data and tools: your GitHub, your database, your calendar, your documents. The problem: every connection used to be built by hand.
Imagine M AI applications (Claude, your app, an IDE) and N tools (GitHub, Slack, your database). Without a standard, you have to build M × N different integrations — one for every pair. It's expensive, it breaks often, and nobody reuses it.
MCP flattens that problem to M + N. Each application speaks MCP just once; each tool exposes an "MCP server" just once; and everything connects with everything. It's the same idea that made other standards successful:
- APIs standardized how the front-end talks to the back-end.
- LSP (Language Server Protocol) standardized how your editor understands any language.
- MCP standardizes how an AI talks to external tools and data.
The three roles (vocabulary you'll use all course long)
- Host: the AI application where you work (for example Claude Desktop, an IDE).
- Client: a connector that lives inside the host; there is one per server.
- Server: the program that exposes capabilities (tools, data) via MCP. This course teaches you to build these servers.
Key idea: "client" and "server" are logical roles, not different computers. A single app can be client of one server and server of another. We'll see this in Module 1.
Key moments in the video
- 1 — Why models are "only as good as their context".
- 4 — The leap to a standardized world: MCP clients and servers.
- 6 — The N×M problem explained with the microservices example.
Quick glossary
- MCP: Model Context Protocol — an open protocol to connect AI with tools/data.
- N×M: the explosion of hand-built integrations that MCP avoids.
- Host / Client / Server: the protocol's three roles (see above).
- Tool / Resource / Prompt: the three "primitives" a server exposes (Module 1).
Downloads
- 📄 Cheat sheet — What is MCP? (1-page PDF with everything essential from this lesson).
- 📄 Course glossary (PDF, expanded in each module).
Before moving on
There's nothing to memorize yet. If you keep one idea, let it be this: MCP exists so you build an integration once and it works everywhere. In the next lesson we set up your computer (Python, Node, and editor) step by step.