If you have been around AI chatbots for any length of time in 2026, you have heard the acronym MCP. It shows up in Claude Desktop settings, in ChatGPT connector menus, in the OpenClaw Easy plugin picker, in half the GitHub READMEs of every new AI tool. So what is it, actually? And why has the entire industry quietly standardized on it in less than two years?
This guide explains MCP in plain language: what it is, what problem it solves, what an MCP server actually does, who built it, and how you can use it on real channels like WhatsApp and Telegram today. No prior protocol knowledge required.
MCP in one sentence
The Model Context Protocol (MCP) is an open standard for connecting AI chatbots to external tools — databases, APIs, files, services — without each AI vendor inventing its own format. One protocol, one server implementation, every compliant client can use it.
If you have ever written a "function-calling" integration for ChatGPT and then had to rewrite the same logic for Claude, then again for Gemini, then again for the next model that launched — MCP is the thing that ends that. The MCP server you write once works for every MCP-compliant client.
The problem MCP solves
Before MCP, every AI provider shipped its own way to let the model call external tools:
- OpenAI had function calling, with a JSON-schema definition of each function and a particular message shape for tool results.
- Anthropic had tool use, with its own slightly different JSON-schema shape and result envelope.
- Google Gemini had its own function calling, again with subtle differences.
- Local models via Ollama, llama.cpp, vLLM all needed their own glue.
The functions were doing the same job — "look up this customer in our CRM," "search this repository," "read this file." But the integration code had to be written four times, tested four times, and maintained forever. Worse: the moment a new model came out (every six weeks, lately), you had a fifth flavor.
MCP normalizes all of that. You write the integration once, as an MCP server. Any AI client that speaks MCP can use it. The vendor lock-in around tool integrations effectively goes away.
How MCP works — client and server
MCP follows a simple client/server model. The AI chat application — Claude Desktop, ChatGPT Desktop, Cursor, Zed, OpenClaw Easy — acts as the MCP client. The tool provider — a filesystem connector, a GitHub connector, a Slack connector, a Postgres connector — runs as an MCP server.
The client launches or connects to the server when the user opens a chat session. The server tells the client what tools, resources, and prompts it offers. The client passes that menu to the language model. When the model decides to call a tool, the client forwards the call to the server, the server runs it, and the result flows back to the model.
Communication is JSON-RPC over either stdio (the server is a child process of the client) or HTTP/SSE (the server is remote). That is the entire wire format. Anyone can implement either side in any language; SDKs exist for TypeScript, Python, Rust, Go, Java, C#, and more.
What an MCP server exposes
Every MCP server can expose three kinds of things to the AI client. You will see these three concepts everywhere in the protocol docs:
Tools
Tools are function-like actions the model can call. Each tool has a name, a description, and a JSON schema for its arguments. Examples: read_file, execute_sql, create_github_issue, send_slack_message. The model decides when to call a tool based on the user's request and the tool's description.
Resources
Resources are read-only data the model can pull into context. Each resource has a URI (e.g. file:///docs/api.md or postgres://customers/12345). The client lists available resources to the model or the user, and the model can ask for the contents of any resource it wants to read.
Prompts
Prompts are reusable templates the server provides for users to pick from a menu. A GitHub MCP server might offer a "Review this PR" prompt with the PR number as an argument. The user clicks it, the prompt gets filled in, and the conversation starts from there.
Together those three primitives — tools, resources, prompts — cover essentially every real-world integration. A typical MCP server provides a handful of each.
Who created it
Anthropic open-sourced MCP in late 2024, alongside the launch of Claude Desktop's first MCP support. The protocol spec, the reference SDKs, and a starter set of MCP servers (filesystem, GitHub, Postgres, Slack, Puppeteer) all shipped under permissive open-source licenses.
What happened next surprised most observers: instead of staying a Claude-only thing, the rest of the industry adopted it within twelve months. Microsoft added MCP support to Copilot Studio and Windows. OpenAI shipped first-party MCP connector support in ChatGPT. Google wired MCP into the Gemini agent stack. By mid-2026, dozens of developer-tool companies (Cursor, Zed, Continue, Aider) and most major SaaS vendors had either built an MCP server or wired their product into one.
It is rare for an open standard from one vendor to be adopted this fast by direct competitors. The fact that MCP cleared that bar is itself useful information: it means the "tool integration is duplicated four ways" problem was painful enough that everyone wanted out of it.
Concrete examples
Reading about a protocol is abstract. Looking at a few real MCP servers makes it concrete.
Filesystem MCP server
The filesystem server lets the AI read and write files on your machine. You point it at a directory (say, ~/Documents/work) when you launch it, and from then on the model can ask: "what files are in this folder," "read me report.md," "write a new file called summary.md with this content." Useful when you want the AI to actually edit things, not just give you snippets to paste.
GitHub MCP server
The GitHub server gives the AI read/write access to your repositories via the GitHub API. The model can search code, list issues, read a specific PR, leave a review comment, file a new issue. You authenticate it once with a GitHub token (scoped to whatever you trust the AI with), and from then on conversations like "summarize what changed in PR #1842" or "open a tracking issue about this bug" work as one turn.
Slack MCP server
The Slack server lets the AI read recent channel messages and post into channels. Useful for "what did the team discuss in #engineering yesterday" or "post a summary of this thread to #standup." Like GitHub, it auths with a Slack bot token; you scope it to the workspaces and channels you care about.
Postgres MCP server
The Postgres server connects the AI to a SQL database. The model can introspect the schema, run read-only queries, and (if you let it) write data. This is the canonical "stop hand-copying SQL between your terminal and the chat window" use case — you ask in English, the model writes the query, the server runs it, the result comes back.
That is four of dozens. Official and community servers exist for Notion, Linear, Jira, Google Drive, Sentry, Stripe, Cloudflare, AWS, Kubernetes, Puppeteer (browser automation), shell execution, and many more.
MCP vs OpenAI function calling vs Claude tool use
If you are wondering how MCP relates to the older per-vendor tool-calling APIs, here is the short comparison:
| MCP | OpenAI function calling | Claude tool use | |
|---|---|---|---|
| Vendor-neutral | Yes — works with any client | OpenAI-only API shape | Anthropic-only API shape |
| Where it runs | Local process or remote server, your choice | Tool code runs in your app; OpenAI calls it | Tool code runs in your app; Claude calls it |
| Discovery | Server advertises tools, resources, prompts dynamically | You pre-declare functions per request | You pre-declare tools per request |
| Reusability | Same server works for every MCP-capable model | Tied to OpenAI API request shape | Tied to Anthropic API request shape |
| Under the hood | Often uses function calling / tool use to ask the model what to do | The model-side primitive MCP often sits on top of | The model-side primitive MCP often sits on top of |
The cleanest way to think about it: function calling and tool use are model-level APIs. MCP is a transport-level standard that lives one layer up. An MCP client typically uses each model's native function-calling under the hood to ask the model which tool to invoke, then routes that decision out to whatever MCP server provides the tool. The MCP server doesn't care which model is on the other side.
MCP and privacy
One of the most common misconceptions about MCP is that it sends your data somewhere new. It doesn't, on its own. MCP servers run wherever you put them.
If you run a local filesystem MCP server, your files stay on your machine — only the snippets the model decides to read end up in the model's context. If you run a local Postgres server pointed at localhost:5432, the database connection never leaves your box; only the query results the model sees flow into the conversation.
A remote MCP server — for example, a hosted GitHub MCP server provided by a third party — is only as private as that operator. You are trusting that operator with whatever scopes you grant. Treat installing a remote MCP server the same way you would treat installing a browser extension or a CI runner: read who runs it, check what data it sees, prefer first-party servers (from the vendor whose data it touches) when one exists.
Practical rule: for personal or business data you want to keep local, prefer local MCP servers (filesystem, Postgres-on-localhost, local file caches) plus a model that can also run locally — for example, an Ollama model via OpenClaw Easy. End-to-end, no data leaves your machine.
How OpenClaw Easy uses MCP
OpenClaw Easy is an MCP client. That means you can attach any MCP server to your AI bot and give it real tool access — not just chat. The interesting part is that OpenClaw Easy also handles the channel, so the same MCP-equipped bot is reachable from WhatsApp, Telegram, Slack, Discord, Feishu, or Line without writing any glue code.
The flow looks like this:
- You pick an AI model in OpenClaw Easy — Claude, GPT, Gemini, DeepSeek, a local Ollama model, anything.
- You attach one or more MCP servers in the MCP panel of the Control UI (Settings › MCP) — filesystem, GitHub, Postgres, whatever you trust this bot with.
- You connect a channel — scan the WhatsApp QR, drop in a Telegram bot token, etc.
- You message the bot from your phone. The model has the MCP tools available the same way it would in a desktop chat client.
The MCP server runs on your desktop machine alongside OpenClaw Easy. WhatsApp or Telegram just carries the conversation — they never see the MCP server, and the MCP server never has to be exposed to the internet. This is, for a lot of people, the cleanest possible "AI agent on WhatsApp" setup.
If you are weighing this kind of design against a hosted chatbot platform, our companion writeups on AI agents vs chatbots and the best AI agents in 2026 go deeper on the architectural trade-offs.
Where to find MCP servers
There is no single app store, but a few canonical places are worth knowing:
- modelcontextprotocol.io — the official site, with the spec, SDK docs, and a curated directory of servers.
- GitHub — the modelcontextprotocol organization hosts the reference servers (filesystem, GitHub, Postgres, Slack, Puppeteer, fetch, memory, time). Most "official" servers live there.
- npm and PyPI — community-built MCP servers are typically published as @modelcontextprotocol/server-* on npm or mcp-server-* on PyPI. You install them like any other package.
- Vendor docs — many SaaS companies (Notion, Linear, Sentry, Cloudflare, etc.) now ship their own first-party MCP servers; check their developer docs.
If you are picking your first three, the official filesystem, fetch, and either GitHub or Postgres servers are a great starter set. They cover "read my files," "read a URL," and "talk to my work data," which is most of what people want from a useful agent on day one.
If you are pairing an MCP-equipped bot with an open-weights model to keep everything local, our guide to Ollama in 2026 walks through model picks, and the post on running OpenClaw Easy with free models shows the end-to-end setup. If WhatsApp is your endpoint, the best AI models for a WhatsApp bot in 2026 guide compares quality and latency.
How to add an MCP server in OpenClaw
There are three ways to add an MCP server in OpenClaw (and so in OpenClaw Easy). They all write to the same place — the mcp.servers section of your OpenClaw config — so pick whichever fits how you work.
| Method | How | Best for |
|---|---|---|
| Control UI (no code) | Web Dashboard › Settings › MCP (/settings/mcp) |
Most people — a form, not JSON |
openclaw mcp add |
Flags: --command, --arg, --url |
Scripting and quick one-liners |
openclaw mcp set |
One JSON object on the command line | Pasting a server's ready-made config |
Option A: add a server with no code
If you use the OpenClaw Easy desktop app, you never have to touch a config file. The app manages the local gateway and opens the Control UI — a browser dashboard with a dedicated MCP panel.
- Open the desktop app and click Open Web Dashboard (the app starts the gateway for you if it isn't running).
- Go to Settings › MCP (the
/settings/mcppage, also reachable at the/mcpalias). - Click Add server, give it a name, and fill in either a command (for a local stdio server) or a URL (for a remote HTTP server).
- Save. The panel shows the server's status, the tools it exposes, and any OAuth or filter settings.
That's it — no JSON, no restart. The panel writes the same mcp.servers entry the CLI does, and the change applies on the server's next use.
Prefer the desktop app? OpenClaw Easy is a free installer for macOS (Apple-notarized) and Windows (not code-signed yet) that runs everything locally — the gateway, the Control UI, and your MCP servers. Download OpenClaw Easy and skip the terminal entirely.
Option B: add a server from the command line
The openclaw mcp command manages your saved MCP servers. The two you'll use most are add (build a server from flags) and set (paste a full JSON object).
Add a local (stdio) server.
A stdio server is a program OpenClaw launches on your machine and talks to over standard input/output. Most community MCP servers ship this way and run via npx (Node) or uvx (Python). For example, to add the official filesystem server scoped to your Documents folder:
$ openclaw mcp add filesystem \
--command npx \
--arg -y \
--arg @modelcontextprotocol/server-filesystem \
--arg ~/Documents
Or paste a ready-made config with set — this adds Context7, a live documentation-lookup server:
$ openclaw mcp set context7 '{"command":"uvx","args":["context7-mcp"]}'
The stdio fields are command, args, env (environment variables), and cwd (working directory). OpenClaw launches the process when the assistant needs it and tears the whole process tree down cleanly on shutdown.
Add a remote (HTTP) server.
An HTTP server is a hosted endpoint you connect to by URL — good for managed services. Use transport: "streamable-http" and, where the service supports it, OAuth instead of a pasted token:
$ openclaw mcp add acme \
--url https://mcp.example.com/ \
--transport streamable-http \
--auth oauth
$ openclaw mcp login acme # opens an authorization URL; approve, then re-run with --code
HTTP servers also support static headers, TLS verification control, and mTLS client certificates for locked-down environments.
Good first servers
Don't add ten servers on day one. Pick the one that automates a task you already do by hand, confirm it works, then grow. These are solid, widely used starting points:
| MCP server | What it adds | Transport |
|---|---|---|
| Filesystem | Read and write files in a folder you choose | stdio (npx) |
| Context7 | Up-to-date library and API documentation on demand | stdio (uvx) |
| GitHub | Issues, pull requests, code and repo search | stdio or HTTP |
| Postgres / database | Run read-only queries against your own data | stdio |
| Brave Search | Live web search results (needs a free API key) | stdio |
| Playwright | Open a real browser — navigate, click, extract | stdio |
Each server publishes its exact launch command in its README. Drop that command into openclaw mcp add (or the Control UI's command field) exactly as shown. For a browsable, larger catalog of reusable AI capabilities that pair well with these tools, see the OpenClaw Skills hub.
Check that the server works
After you add a server, confirm it actually connects before you rely on it. Three commands, from cheapest to most thorough:
| Command | What it does |
|---|---|
openclaw mcp status --verbose |
Shows transport, auth, timeouts and filters — without connecting |
openclaw mcp doctor <name> --probe |
Static checks (missing command, bad path, literal secrets) plus a live connect |
openclaw mcp probe <name> |
Connects and reports the tool count, resources/prompts support and diagnostics |
Use openclaw mcp list to see every saved server and openclaw mcp tools <name> --include <csv> to expose only specific tools. Once a server connects, its tools show up in your assistant's coding and messaging tool profiles automatically — message the bot on any connected channel and it will call them when your request needs one.
Tools not showing up? MCP tools are hidden in the minimal profile and disabled when tools.deny lists "bundle-mcp". Idle stdio servers are also reaped after mcp.sessionIdleTtlMs (default 10 minutes) and reconnect on next use — so a "gone" server is often just asleep.
Security: check this before you add a server
An MCP server runs with the access you grant it, so treat adding one like installing software. A few habits keep you safe:
- Only add servers you trust. Prefer official servers and well-known projects; read what tools a server exposes before enabling it.
- Scope filesystem access. Point the filesystem server at a specific project folder, never your whole home directory.
- Prefer OAuth over pasted tokens. For HTTP servers, use
--auth oauthandopenclaw mcp logininstead of long-lived keys in config. - Trim the tool surface. Use per-server include/exclude filters so the assistant only sees the tools you actually want.
- Run the doctor.
openclaw mcp doctorflags literal secrets in headers or env, disabled servers and broken setups before you connect.
Because OpenClaw runs locally on your own machine, your files and credentials stay on your device — the MCP servers you add talk to your assistant on your computer, not through a third-party cloud. More on that model in privacy-first AI chatbots.
Frequently asked questions
Is MCP only for Claude?
No. Anthropic open-sourced MCP and any AI client can implement it. Claude Desktop was the first big client, but ChatGPT (via OpenAI's connector layer), Microsoft Copilot Studio, Google's Gemini stack, Cursor, Zed, and open-source clients like OpenClaw Easy all speak MCP. The protocol is vendor-neutral by design.
What can MCP servers do?
An MCP server can expose three things to the AI client: tools (function-like actions the model can call, such as "search GitHub issues" or "run SQL query"), resources (read-only data the model can pull in, such as a file or a wiki page), and prompts (reusable templates the user can pick from a menu). Together that covers almost every real integration: filesystems, databases, APIs, ticketing systems, dev tools.
Is MCP secure?
MCP itself is just a protocol — security depends on which server you trust and where you run it. A local MCP server (filesystem, Postgres on localhost) never sends data over the network. A remote MCP server is only as safe as the operator. Treat installing an MCP server like installing any other software: read the source, prefer official servers, and don't grant write access you don't need.
How do I use MCP with WhatsApp or Telegram?
Use an MCP-capable client like OpenClaw Easy. Connect WhatsApp or Telegram as the channel, pick your AI model (Claude, GPT, Gemini, Llama, etc.), then attach one or more MCP servers — filesystem, GitHub, Postgres, Slack. When you message the bot, the model can call those tools to answer. The MCP server runs on your machine; WhatsApp just carries the conversation.
How do I add an MCP server to my AI assistant?
In OpenClaw, either add it in the Control UI under Settings › MCP (no code), or run openclaw mcp add <name> with stdio flags like --command npx --arg -y --arg <package>, or paste a config with openclaw mcp set <name> '{...}'. Then run openclaw mcp probe <name> to confirm it connects.
What's the difference between stdio and HTTP MCP servers?
A stdio server is a local program OpenClaw launches and talks to over standard input/output (configured with a command and args). An HTTP server is a remote endpoint you reach by URL with optional OAuth. Use stdio for local tools like filesystem access; use HTTP for hosted services.
Does adding MCP servers require the terminal?
No. The OpenClaw Easy desktop app gives you a graphical MCP panel in the Control UI, so you can add, verify, and remove servers without ever opening a terminal. The openclaw mcp CLI is there when you want scripting or one-liners.
The takeaway
MCP is doing for AI tool integration what USB did for peripherals: replacing N vendor-specific cables with one standard plug. You write the integration once, every compliant client can use it, and you stop being locked into a single model vendor's tool format.
For end users, the practical payoff is that you can mix and match — pick the model you like, pick the tools you need, pick the channel you want to talk on — and they all just work together. That is a meaningfully better world than 2024, when every new AI feature was a separate one-off integration project.
If you want to try MCP on your own messaging channels today, the fastest path is downloading OpenClaw Easy, attaching an MCP server (filesystem is the gentlest first step), and pointing a WhatsApp or Telegram bot at it. Fifteen minutes from "what is MCP" to "I have an MCP-powered bot in my pocket."