What is the Model Context Protocol (MCP)?

Large language models are powerful at reasoning over text, but on their own they are sealed off from the live world: they can't read your calendar, query a database, or call an API. The Model Context Protocol (MCP) solves the plumbing problem behind that limitation. It is an open specification that standardises how an AI application discovers, describes and invokes external capabilities, so the same tool integration works across many different models and apps.

What is the Model Context Protocol, in plain terms?

MCP is a protocol — a set of rules and message formats — that sits between an AI model and the outside world. It was published by Anthropic as an open standard in November 2024 and has since been adopted by a range of AI tools and vendors. The protocol defines two roles: an MCP client (the AI app, such as a chat assistant or coding agent) and an MCP server (a small program that exposes a specific capability, like access to a file system, a Git repository, a Slack workspace or a Postgres database).

The standard organises what a server can offer into three categories: tools (functions the model can call, such as 'send_email' or 'search_issues'), resources (data the model can read, such as files or records), and prompts (reusable templates a user can trigger). Because every server speaks the same language, an AI client that supports MCP can plug into any of them without bespoke code.

How does MCP work?

At runtime, the AI client and a server establish a connection and exchange structured messages. The protocol uses JSON-RPC 2.0 as its message format and supports transports such as local standard input/output (for a server running on the same machine) or HTTP-based streaming (for remote servers). A typical exchange looks like this:

1. Discover — the client asks the server what it offers; the server returns a list of its tools, resources and prompts, each with a name, a description and a schema for its inputs.
2. Decide — the model reasons over the user's request and the available tool descriptions and chooses whether to call a tool, and with what arguments.
3. Invoke — the client sends a structured tool-call request to the server, which executes the action (querying a database, hitting an API, reading a file).
4. Return — the server sends results back; the model incorporates them into its answer, optionally calling more tools before responding to the user.

Crucially, the model never holds the integration's credentials or business logic itself. The server owns the connection to the underlying system, which keeps secrets and permissions on the server side rather than baked into the prompt.

// An MCP server advertising a tool the model can call
{
  "name": "search_documents",
  "description": "Full-text search across the user's files",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": { "type": "string" },
      "limit": { "type": "integer", "default": 5 }
    },
    "required": ["query"]
  }
}

Why does MCP matter for interoperability?

Before MCP, every AI product invented its own way to wire up tools. Connecting five models to five services meant building twenty-five separate integrations — the classic M×N problem. A shared protocol collapses that to M+N: build one MCP server for a service, and every MCP-capable client can use it; build one MCP client, and it can reach every existing server. That is the same network effect that made the web and email durable.

• Reusability — a server written once works across many AI apps and model providers.
• Portability — switching the underlying model doesn't break your tool integrations.
• An ecosystem — a growing library of community and vendor servers means common integrations are often already built.
• Clear boundaries — separating the model (reasoning) from servers (capabilities and credentials) makes systems easier to secure and reason about.

How does MCP relate to AI agents and tool use?

An AI agent is a system that takes a goal, decides which actions to take, and uses tools to carry them out — searching the web, sending a message, editing a file. 'Tool use' is the mechanism; MCP is one standardised way to expose those tools. You can build agents without MCP (with hard-coded function calls), but MCP gives agents a plug-and-play tool layer, so adding a new capability is often as simple as connecting another server rather than rewriting the agent.

It helps to keep two ideas distinct: function calling is a model feature that lets an LLM emit a structured request to run a named function; MCP is a transport-and-discovery standard for where those functions live, how they describe themselves, and how a client connects to them. They work together — the model decides to call a tool, and MCP is one way that tool is delivered.

How does this relate to MiyoMind?

MiyoMind is a personal AI assistant you talk to inside WhatsApp, Telegram, Discord, or the web dashboard at miyomind.com. Under the hood it runs the open-source OpenClaw agent runtime plus a model router called Hermes and our own orchestration, memory, billing and safety code, drawing on frontier models from OpenAI, Anthropic, Google, xAI and Alibaba. So the agentic concepts MCP standardises — discovering tools, deciding when to call them, and invoking them safely — are exactly the patterns MiyoMind uses to do real work in one conversation.

In practice, you don't manage MCP servers yourself. MiyoMind handles tool use and integrations for you: it can run live web search with citations, draft email, set one-off and recurring reminders that fire across your chat apps, generate images, transcribe voice notes, read documents and PDFs, and connect to tools you already use — Gmail, Google Calendar, Drive, Outlook, Notion, Slack, GitHub, Linear and roughly 30 connectors in total — through secure OAuth. Each paid user gets a dedicated, sandboxed container with no public internet egress and zero stored external keys, while the free tier runs on a shared direct-agent path; integrations and memories are encrypted at rest. MCP is the broader industry standard for this kind of connectivity; MiyoMind is a finished assistant that puts the same agentic capabilities to work without you wiring anything up.