Your assistant can write code, but out of the box it cannot see your database, your tickets or your docs. Connecting it used to mean custom glue for every pair of AI app and tool. The Model Context Protocol, MCP, is an open standard for that connection. Anthropic started it in late 2024, and it is now supported across many AI tools and IDEs. The video above is the one minute version. This note is the rest.
The M × N problem
Five AI apps and ten tools means fifty integrations. Each one has its own auth, its own way to describe what it can do and its own way to break. Nobody builds all fifty, so most pairs never get connected.
MCP turns the multiplication into a sum. Each app implements the client side of the protocol once. Each tool ships one MCP server. Five plus ten is fifteen pieces, and any client can talk to any server.
The wire format is JSON-RPC 2.0. That is a deliberately boring choice: requests, responses and notifications, nothing you cannot read in a log.
What a server exposes
A server offers three kinds of things. The difference between them is not the data. It is who decides when they are used.
- Tools: the model decides. Actions with a name, a description and a JSON Schema for the input, like
create_ticket. The model reads the descriptions and chooses when to call one. - Resources: the app decides. Data addressed by a URI, like
tickets://open. The app chooses what to attach to the conversation, often because the user picked it. - Prompts: the user decides. Reusable templates the server suggests, usually surfaced as slash commands or menu items.
That split is the part most explanations skip, and it is the useful one. If the model should act on its own, it is a tool. If a person should pick the context, it is a resource or a prompt.
One request, end to end
You ask “which tickets are open?”. Here is what happens:
- Handshake. When the app starts the connection, client and server exchange versions and capabilities.
- Discovery. The client asks the server for its tools with
tools/listand hands their names, descriptions and schemas to the model as part of the context. - Choice. The model reads your question and the tool descriptions, and decides to call
list_open_tickets. - Call. The client sends
tools/callto the server with the arguments the model produced. - Answer. The server runs the query and returns the result. The client puts it back in the context, and the model writes the answer from it.
Step 4 on the wire:
{
"jsonrpc": "2.0",
"id": 2,
"method": "tools/call",
"params": {
"name": "list_open_tickets",
"arguments": { "limit": 5 }
}
}
Note what the model never does: it never talks to the server. It only produces a tool name and arguments. The client makes the call. That boundary is where you put confirmations, logging and limits.
A small server
With the official TypeScript SDK, a server with one tool is short:
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { z } from 'zod';
const server = new McpServer({ name: 'tickets', version: '1.0.0' });
server.registerTool(
'list_open_tickets',
{
description: 'Lists open support tickets, newest first.',
inputSchema: { limit: z.number().int().min(1).max(50).default(10) },
},
async ({ limit }) => {
const tickets = await db.openTickets(limit);
return { content: [{ type: 'text', text: JSON.stringify(tickets) }] };
},
);
await server.connect(new StdioServerTransport());
The description is not documentation for humans. It is the prompt the model uses to decide whether to call the tool. Write it like one: what the tool does, when to use it, what it returns.
Local or remote
There are two standard transports, and the choice changes the security model more than the code.
- stdio. The app starts the server as a local process and talks to it over standard input and output. Simple and fast, and the server runs with your user’s permissions on your machine.
- Streamable HTTP. The server runs somewhere else and the client connects over HTTP. This is how a team shares one server, and it brings real authorization into the picture: the spec builds on OAuth for that.
A local server you installed from a random repository is code running as you. Treat it like any other dependency you would review before running.
What MCP does not solve
MCP standardizes the connection. It does not decide what the model should be allowed to do with it.
- Permissions are yours. A server with a token that can delete records gives the model a way to delete records. Scope the credentials to what the tools actually need, and prefer read-only tools until a write is worth the risk.
- Tool results are untrusted input. A ticket body, a web page or a document can contain text written to look like instructions. The model reads it in the same context as everything else. The dangerous mix is private data, untrusted content and a tool that can send data out, all in one session.
- Writes deserve a human. Most clients can ask for confirmation before a tool runs. Keep that on for anything that changes state.
When I would not reach for it
MCP pays off when an integration is used by more than one client: your IDE, your chat app and your agent all reuse the same server. If you have one app calling one internal API, plain function calling in your own code is less machinery for the same result.
Tools also cost context. Every connected server puts its tool names, descriptions and schemas in front of the model on every request. Connect a dozen servers and the model has to choose among many tools, most of them irrelevant to the question. It is the same trade-off as in RAG vs CAG: more in the context is not free. Connect the servers a task needs, not every server you have.
Start with one server for the system you open most often, read-only, and watch what the model does with it. Then ask the question from the end of the video: what would you connect first?