What Is MCP (Model Context Protocol), Explained Simply

MCP gets written about as if it were something strictly for engineers: "open protocol," "standardized integration layer." The idea underneath is actually simple, and the payoff is pretty everyday — no jargon required.

MCP in plain terms

MCP (Model Context Protocol) is a common socket a model plugs into to reach external tools and data. The comparison people like to reach for: MCP is USB-C for AI. Before it, every tool needed its own adapter; now there's one port that everything fits.

Anthropic came up with the protocol and open-sourced it. In a year and a half it became the de-facto standard: a tool written once works with any agent that speaks MCP. No need to rewrite the integration for every model.

Why this matters at all

A model without tools can only reason and generate text. It can't look something up in a database on its own, check a calendar, or read your file — it has no hands.

MCP gives it hands. Each MCP server is a small program that hands the model a set of tools: "read tasks from the tracker," "find an email," "query the database." The agent sees these tools and calls them itself, whenever the task needs them.

What this looks like in practice

A couple of examples to make it concrete:

• GitHub. An official MCP server lets an agent read repositories, issues, and pull requests without pasting code into the chat.
• A knowledge base. Through an MCP server for Notion, an agent searches pages and puts together reports.
• A database. A PostgreSQL MCP server turns plain-language questions into SQL queries.
• The browser. A Playwright MCP server lets an agent open pages, click buttons, and check forms.
• Your own services. Have an internal API? Wrap it in an MCP server once, and the agent knows how to work with it.

The server ecosystem is already large: ready-made MCP servers exist for popular trackers, storage, messengers, and databases. Some run on your machine, some work as a remote service — check the specific server's documentation to know which.

How this works in Doka

Doka is a desktop agent, and MCP is built in. Management lives under the "MCP Servers" tab in the right panel (the server-rack icon). The mechanics:

1. You add an MCP server: a name, the launch command, arguments, and, if needed, environment variables (an access token, for example).
2. Every time a task starts, Doka spins up all enabled servers, collects their tools, and registers them under readable names.
3. The model calls them right alongside the built-in ones — Doka can already read files, browse the web, and edit code without MCP; MCP just extends that set to your own services.

One detail that matters: MCP servers in Doka run locally, as regular processes on your machine. Data moves directly between the agent and the tool, with no cloud in between. For sensitive access — tokens, internal databases — that's the whole point.

How to connect your own MCP server

Step by step, no code required:

1. Open the right panel → the "MCP Servers" tab → "+ Add server."
2. Fill in the form: a name (how it'll show up in the list), the launch command, and its arguments (one per line).
3. If the server needs a token or key, add it under environment variables as KEY=VALUE, one per line.
4. Flip the toggle and save. The settings survive an app restart.

That's it — the agent sees the new tools on the very next task.

What to take away

The point of MCP is simple: stop rewriting the integration for every service. A tool described once works with any agent. And when the agent lives on your own computer, access and data don't go anywhere.

The host doesn't have to be an agent, either — the same kind of server connects to model-runner apps too, not just agentic clients.

Easiest to just try it — download Doka and open the "MCP Servers" tab.