Lesson 9 showed a model asking for one tool. Real use needs dozens, from services that have never heard of each other. This lesson shows the shared standard that makes that possible — and the actual name behind three letters you'll see everywhere: MCP.
Lesson 9's weather tool was one call, hand-built for one service. Now imagine an app that needs fifty tools — a calendar, a database, a dozen SaaS products, a company's own internal systems. Wire each one by hand, in its own bespoke way, and the wiring itself becomes the whole project.
That's the real problem this lesson solves. Not a smarter model, not a new trick for the model to learn — a shared shape for the wiring itself, so it only has to be built once per tool, not once per app that wants to use it.
MCP stands for Model Context Protocol — a shared, published shape for two things: here is the list of tools I offer, and here is exactly how to call each one. Any app that speaks it can use any tool that speaks it, with no custom wiring in between. It was introduced in 2024 and adopted industry-wide within about a year.
This is the same tool_use shape from Lesson 9 — a request instead of prose, an answer poured back into the backpack — just standardized, so it isn't reinvented per integration. The model still does exactly what it always does: read what's in front of it, and lean toward the likeliest next token. MCP only changes what's available to reach for.
The program on the other end of MCP is called a server — not because it's a website, but because it serves up a menu. Point an app at one, and it hands back its whole toolbox at once, the same shape every time.
{"tools": [
{"name": "get_weather", "description": "Current conditions for a location"},
{"name": "search_calendar", "description": "Find events in a date range"},
{"name": "run_query", "description": "Query the company database"}
]}That's the practical payoff: connect to one MCP server and inherit everything it offers — a dozen tools, fifty, however many — instead of wiring each one by hand. Add a new tool to the server, and every app already connected picks it up automatically, with nothing rebuilt on their end.
What MCP is not: it isn't a smarter model, a new kind of prediction, or a way around anything from Lesson 7. It's plumbing — a standard for connecting tools, sitting entirely outside the model itself.
Everything you already know still applies underneath: the model reads what's in front of it and leans toward the likeliest next token, whether that token asks for a tool the old bespoke way or the standardized MCP way. MCP just means the businesses building on top don't each have to invent their own wiring from scratch.
Curious how a platform packages tools like these together with the instructions and credentials needed to actually use them? See how orqo does it.
Every door this course has opened — the chat window, the API, tool calls, now a whole standardized shelf of them — eventually comes down to one question: what happens to what you type?
The last lesson answers it, so the worry that likely brought you to this course in the first place can actually go.
Everything from the lessons before this one, plus what this lesson added.
| The board | The word for it |
|---|---|
| The board and its pegs | The structure — the model |
| A single peg | A neuron |
| A single step from one peg to the next | A connection |
| How red or blue a patch of floor is | A weight — a parameter |
| The whole painted floor | The trained model |
| Boards stacked, one on the next | Layers — "deep" |
| Smearing the floor in, coin by coin | Training |
| Dropping one coin through a finished board | Using it — inference |
| Which slot you pour into | Your input — your prompt |
| The bins, relabelled with tokens | The vocabulary — every token it could pick |
| The tallest pile among the bins | The prediction — the likeliest next token |
| Feeding the growing line back in and running again | The loop — how one guess becomes a sentence |
| One bin's label, precisely | A token — not always a whole word |
| How many bins there are, in total | Vocabulary size — tens of thousands |
| The size of the mountain of text it was shown | Training data — measured in tokens |
| A bin's own address, plotted in space | An embedding — meaning turned into a list of numbers |
| How close two addresses sit | Similarity — how related two things are |
| The measurement's real name, out in the wild | Cosine similarity — same idea as similarity, different name |
| About meaning, not exact spelling | Semantic |
| A neighbourhood of addresses that share a topic | A domain — a cluster of related meaning |
| Scanning every address for whichever one sits closest to a new point | Nearest neighbor — the closest real match to a computed point |
| A small, separate machine that only plots words as points — it never writes a sentence | An embedding model — not the same as a language model |
| The total number of coloured patches, across every board | Parameters — the number people quote |
| How many tokens the funnel can hold in one pour | Input tokens — the context window |
| How many tokens come back out | Output tokens — what it writes back |
| Everything you've met so far, built at real-world size | A Large Language Model — an LLM |
| A shorter pile winning, extended forward with full confidence | A hallucination |
| The point where the training reading stopped | The knowledge cutoff |
| How sharp or blended the colour stays before a coin is poured | Temperature — the dial on how often a stray pick wins |
| Pouring the same slot twice, not always the same pile | Non-deterministic — same input, no guaranteed identical output |
| Background, examples, or a role, added right into the pour | Context |
| Asking for many small steps instead of one big leap | Chain-of-thought prompting |
| A friendly chat window built around the board | A product — like ChatGPT or Claude.ai |
| A door that lets software pour in and read out directly | An API |
| What each million tokens costs to send in or get back | API pricing — pricier for bigger models, and for output |
| Recalling the start of the line instead of re-pouring it | Cached tokens — priced far cheaper than fresh input |
| The board asking the app to go do something real before it answers | Tool use — or function calling |
| + New in this lesson | |
| One shared shape for listing tools and calling them | MCP — Model Context Protocol |
| A program that speaks that shape and hands back its whole toolbox | An MCP server |
39 rows now. It keeps growing as the course goes on.