MCP is the open standard Anthropic launched in November 2024 to connect AI to external tools and data. One port, everywhere. Here's where I pull together everything you need to know: the definition, the architecture, the popular servers in 2026, the real use cases, and how to build your first server.
MCP, short for Model Context Protocol, is an open standard released by Anthropic in November 2024 that lets any language model connect in a uniform way to external tools, databases and services. Instead of writing a custom integration between each AI and each tool, you write one MCP server once, and every compatible client can use it.
The analogy you'll see everywhere is USB-C. MCP is to AI what USB-C is to hardware: a universal, standard port. Before USB-C, every brand had its own proprietary cable — one for Apple, one for Samsung, one for Sony, not counting all those old round jacks. Today you plug a USB-C cable into any modern phone and it just works. MCP does the same thing for AI and its tools.
Before MCP, every AI maker had its own format for plugging in tools. OpenAI had its function calling, Anthropic had its Tools API, Google had its function declarations, Cohere its connectors. What that meant in practice: if you wanted an assistant to read your Postgres database and write to your Notion, you wrote the integration three times — once for ChatGPT, once for Claude, once for Gemini. Three codebases to maintain, three different formats, three learning curves.
Anthropic open-sourced the code and the spec in the modelcontextprotocol GitHub repo, under the MIT license. Anyone can write a server, publish it, use it, fork it. And the bet paid off: within a few months, Cursor, Claude Code, Continue, Cline, Windsurf and others had adopted the standard. In 2025, OpenAI announced that ChatGPT Desktop supports it too. MCP has become a de facto standard for AI agents.
MCP is not an AI model. It's not a competitor to Claude, GPT or Gemini. It's a layer on top, independent of the model. You can use MCP with Claude, GPT, Gemini, Mistral, or a local model through Ollama — as long as your client supports the protocol.
It's not an agent framework either. MCP doesn't plan actions, doesn't decide what to do next. It defines how an agent can discover and call tools. The orchestration logic stays with the model (or with the framework driving the model, like LangChain, LlamaIndex or Mastra).
To go deeper on the definition, I also wrote a short entry in the glossary: MCP, the simple definition. And the parent concept to understand is tool use / function calling, which describes a model's ability to call a tool instead of only replying with text.
MCP runs on a classic client-server architecture, carried over JSON-RPC. On the client side, you have the app that hosts the model (Claude Desktop, Claude Code, Cursor, and so on). On the server side, you have a standalone process that exposes capabilities to the client. The two talk to each other in JSON-RPC, either locally through stdio or remotely through HTTP.
┌────────────────────┐ JSON-RPC ┌────────────────────┐
│ MCP CLIENT │ ◄────────────────────► │ MCP SERVER │
│ (Claude Code, │ stdio OR HTTP │ (filesystem, │
│ Claude Desktop, │ │ GitHub, Postgres,│
│ Cursor, Cline) │ │ Notion, custom) │
└────────┬───────────┘ └─────────┬──────────┘
│ │
│ uses │ exposes
▼ ▼
┌────────────────────┐ ┌────────────────────┐
│ LLM MODEL │ │ 3 capabilities │
│ Claude · GPT │ │ • Resources │
│ Gemini · Local │ │ • Tools │
└────────────────────┘ │ • Prompts │
└────────────────────┘
An MCP server exposes three broad categories of capabilities — that is, three kinds of things it makes available to the client.
The protocol supports two transport modes depending on the context.
Stdio (standard input/output) is the local mode. The client launches the server as a sub-process and the two communicate through stdin/stdout. It's the default mode for servers running on your machine — filesystem, a local database, personal scripts. Upside: no network, maximum security, zero latency.
HTTP (with Server-Sent Events or WebSocket) is the remote mode. The server runs on another machine and the client connects over the network. It's what you use for services that need to stay centralized — an MCP shared across a team, a SaaS integration, a cloud connector.
When an MCP client connects to a server, it starts by asking for the list of its capabilities. The model then gets a structured description of every available tool, resource and prompt. No need to hard-code the tools into the system prompt — the AI discovers what it can do, dynamically, at each startup. That's what makes MCP genuinely portable.
The MCP ecosystem filled out fast. The modelcontextprotocol GitHub organization maintains around twenty official servers, and the community has published several hundred more. Here are the servers people use most day to day — the ones I see come up in every serious conversation about AI agents.
| Server | Language | Maintainer | Typical use | Complexity |
|---|---|---|---|---|
| Filesystem | TypeScript | Anthropic (official) | Read/write local files | Easy |
| GitHub | TypeScript | Anthropic (official) | Issues, PRs, repos | Easy |
| Notion | TypeScript | Notion + community | Knowledge base, notes | Medium (OAuth auth) |
| Slack | TypeScript | Anthropic (official) | Read / send messages | Medium (workspace auth) |
| PostgreSQL | TypeScript | Anthropic (official) | Read SQL queries | Easy |
| Puppeteer | TypeScript | Anthropic (official) | Browser control | Medium |
| Brave Search | TypeScript | Anthropic (official) | Web search | Easy (free API key) |
| Tavily / Exa | TypeScript / Python | Community + vendors | Web search for AI | Easy (paid API key) |
| Custom (your own) | Python or TS | You | Specific to your work | Varies |
Beyond the official servers, the community publishes MCP servers for just about everything. Linear, Jira, Trello on the project-management side. Stripe, PayPal on payments. HubSpot, Pipedrive on CRM. If a service has a public API, odds are good a community MCP server already exists. The reflex before coding one yourself: search the modelcontextprotocol/servers GitHub repo and community lists like awesome-mcp-servers.
And of course, you can always write your own. For my own workflows — agents that drive my site, that interact with my newsletter, that watch my builds — I've written a few minimalist MCP servers in TypeScript. We'll see how to do that a bit further down, in the dedicated section.
An MCP server is code that runs on your machine with access to whatever you hand it. A poorly written or malicious server can read your files, exfiltrate your secrets or post in your name. Golden rule: never install a server whose source you haven't checked. For Anthropic's official servers, it's safe. For community ones, look at the repo, the star count, who maintains it, and the last update.
When you first come across MCP, the first question that comes up is: how is this different from function calling? And it's a good question, because the three concepts look superficially alike. Here's how I tell them apart.
Function calling is a model's ability to choose to call a function instead of generating text. OpenAI popularized the concept in June 2023 with GPT-3.5 and then GPT-4. You describe your functions to the model in a JSON format specific to OpenAI, and the model can decide to call them with arguments.
The limit: the format is OpenAI's own. If you want to do the same thing with Claude or Gemini, you rewrite your integration.
Tools API is the function-calling equivalent on the Anthropic side, launched in early 2024. Same idea, slightly different format, supported natively by the Claude models. It's the same paradigm as function calling, but with its own spec.
Same limit: the format is Anthropic's own. Not portable to other models.
MCP is an open standard on top of all that. In concrete terms: your MCP server exposes tools (which look a lot like function calls), resources and prompts. The MCP client takes care of translating those tools into the specific format of the model it's using. If you switch models tomorrow, your server doesn't change.
So, concretely: function calling and Tools API are low-level features, specific to each model. MCP is a higher-level protocol that sits on top. The two coexist, they don't replace each other. Under the hood, an MCP client always uses function calling or Tools API to talk to its model.
| Criterion | Function Calling | Tools API | MCP |
|---|---|---|---|
| Maker | OpenAI | Anthropic | Anthropic (open standard) |
| Year | 2023 | 2024 | Nov 2024 |
| Portability | OpenAI only | Anthropic only | Any compatible client |
| Ecosystem | Vertically integrated | Vertically integrated | Open, community-driven |
| Level | Low (per model) | Low (per model) | High (on top) |
| Learning curve | Easy | Easy | Medium (server setup) |
| Pick it if… | You're coding a quick vertical OpenAI integration | You're coding a quick vertical Claude integration | You want portability + a shared ecosystem |
To dig into the tool-use layer, read the tool use / function calling entry. And to understand how MCP fits into a full agent, look at the definition of agentic workflow.
I'm not a developer or a coder. And yet I use several MCP servers every day. Here are the use cases that actually serve me, with a sample prompt for each and what I expect back.
Setup · official filesystem server, scope limited to ~/Projets.
Sample prompt · "Open my site's folder, find the articles that talk about MCP, and suggest a plan to improve the internal linking."
Expected result · Claude reads the real content of my files, doesn't rely on a copy-paste, and gives me an analysis grounded in the actual material. It's the most natural and most useful use.
Setup · community Notion server + Notion integration token.
Sample prompt · "Read my 'Article ideas' database in Notion, spot the topics I've already published on, and list the ideas worth digging into this week."
Expected result · the AI cross-references my Notion with my existing articles and gives me a prioritized to-do list. Handy for editorial curation.
Setup · community calendar server (iCloud or Google Calendar) + OAuth.
Sample prompt · "Look at my calendar this week, find the free slots longer than 2 hours, and suggest a schedule to finish the MCP pillar."
Expected result · the AI sees my real openings and gives me a realistic plan. No more copy-pasting my schedule.
Setup · official Brave Search server + free API key (2,000 requests/month).
Sample prompt · "Give me a state of the art of MCP as of May 2026. Look up the recent announcements, the benchmarks, and the serious comparisons."
Expected result · Claude fires off several searches in parallel, aggregates the results, and gives me a synthesis with sources. Ideal for not settling for the model's frozen knowledge.
All of these use cases run in Claude Code or Claude Desktop. The same logic works in Cursor or Cline for those who prefer an editor. To go further on the agentic workflows I build, read my article Superpowers · Claude Code skills — where I also talk about how skills + MCP complement each other.
I'm not going to give you the exhaustive tutorial here — the official docs at modelcontextprotocol.io do it very well, and the tech moves too fast for a static article to be reliable on the details. But here's the general outline to get started.
Anthropic maintains two official SDKs: Python and TypeScript. Both are at the same level of maturity.
You pick based on your stack. If you live in the Node/JavaScript ecosystem, go with TypeScript. If you do data science or AI in Python, go with Python. For a first server, both work just as well, and the code is of similar complexity.
The official SDK ships a starter template. In TypeScript, you can run npx @modelcontextprotocol/create-server my-server to generate a ready-made tree. In Python, you use the mcp package via uvx or pip.
You get a folder with the server skeleton, the dependencies installed, and a startup script ready to run.
You decide what your server exposes. The three categories: tools (actions), resources (data), prompts (templates). For a first server, start with one or two simple tools — for example, a tool that returns the weather for a city, or that lists the files in a folder.
For each capability, you declare a name, a description (the AI uses it to understand when to call it), and an argument schema in JSON.
Anthropic ships a debug tool called MCP Inspector that lets you launch your server and inspect it through a web interface. You see the list of capabilities, you can call your tools by hand, check the responses.
It's the highest-return step. Testing before plugging into a real client saves you a ton of time finding bugs.
You add an entry to your client's config. In Claude Code, it's a block in ~/.claude/settings.json. In Claude Desktop, it's in ~/Library/Application Support/Claude/claude_desktop_config.json on Mac. You specify the command that launches the server, the arguments and the environment variables.
You restart the client. If everything is set up right, your server shows up in the list of available tools and the AI can call it. You ask it, in plain language, to use your tool, and you see whether the magic happens.
The modelcontextprotocol/servers repo holds around twenty reference servers in TypeScript. The best way to learn is to read the code of the filesystem server or the GitHub server — they're simple, well commented, and you can fork them for your own server.
Yes, all the way. MCP is built for you. You write your own servers, you plug in the official ones, you build portable agents that can live in Claude Code, Cursor or Cline without rewriting your integration. It's the protocol's original target.
Yes, but not for coding servers. You use the existing MCP servers — filesystem, GitHub, Notion, Brave Search — to give your AI context. Combined with Claude Code skills, it turns your terminal into a universal assistant. That's my current use.
Not really yet. As of May 2026, Claude.ai (the consumer web app) doesn't yet support custom MCP servers. Claude Desktop and Claude Code get it first. One to watch — the feature will eventually land on Claude.ai, but we're not there.
Worth monitoring, not mature for 2026. If you're looking to wire your customer chatbot to your CRM or your product catalog through MCP, it's technically possible but the ecosystem isn't production-ready yet. The vertical solutions (Voiceflow, Botpress, specialized platforms) are still sturdier for now. MCP becomes relevant once you go beyond the consumer chatbot and build a custom agent.
My honest take after several months of use: MCP isn't a revolution for the general public, it's a revolution for builders. If you build agents, integrations, automations, it's a gift. If you only use AI in chat mode, you probably don't need to learn MCP — you benefit from it indirectly when the tools you use (Cursor, Claude Code) integrate it.
The 12 questions I asked myself when I was getting into MCP, and that people still ask me today. Short, straight answers, honest about what I don't know.
MCP, short for Model Context Protocol, is an open standard launched by Anthropic in November 2024 that lets any language model connect in a uniform way to external tools, databases and services. Think of it as USB-C for AI: one port to plug everything in.
MCP was designed and released by Anthropic, the company behind Claude. The protocol was announced in November 2024 and the code is published as open source in the modelcontextprotocol GitHub repo. Since then, other players (OpenAI, the Cursor community, IDE makers) have started adopting it, which makes it a de facto standard.
Because it's the first credible attempt to standardize the connections between AI and tools. Before MCP, every AI maker had its own tools format — OpenAI function calling, Anthropic Tools API, Google function declarations. The result: developers rewrote the same integrations three times. MCP unifies all of it, and the adoption by Cursor, Claude Code and Windsurf in 2025 accelerated the whole thing.
Yes. The spec, the official SDKs (Python and TypeScript) and most of the reference servers are published under the MIT license on GitHub, in the modelcontextprotocol organization. Anyone can write a server, publish it, fork it. Anthropic maintains the standard but doesn't have exclusive control over it.
Function calling is a feature specific to each model (OpenAI has its format, Anthropic its own, Google its own). MCP is an open protocol that sits on top. In practice: with function calling, you write one integration per LLM; with MCP, you write a server once and any compatible client can use it. MCP is the standard; function calling is the model's internal implementation.
You add an entry to your ~/.claude/settings.json config file, specifying the command that launches the server (often an npx or a python -m), the arguments and the environment variables. You restart Claude Code, and the server shows up in the list of available tools. For the official servers, install helpers exist that do this for you.
On the Anthropic side, Claude Desktop and Claude Code support MCP natively. Cursor supports it too. On the OpenAI side, ChatGPT desktop announced support in 2025. On the open-source side, Continue, Cline and Zed have integrated it. The list moves fast — most serious AI clients have switched or plan to.
The protocol itself is secure by design: each server runs in its own process, capabilities are explicitly declared, and the client can filter which tools are exposed. The real risk is what you install. A poorly written or malicious MCP server can read your files or expose your secrets. Golden rule: only install servers maintained by trusted sources, and read the code before plugging it in.
You pick your language (Python or TypeScript, the official SDKs cover both), you install the official template, you declare the capabilities (tools, resources, prompts) your server exposes, you implement their handlers, then you connect your client. The modelcontextprotocol.io docs have a full tutorial. For a simple first server, count on one to two hours.
LangChain Tools is an abstraction layer on the framework side (you use LangChain to orchestrate your agent and its tools). MCP is a communication protocol between client and server. The two can coexist: you can expose an MCP server that's then consumed by a LangChain agent, or the other way around. MCP is lower level and more universal; LangChain is higher level and tied to its own ecosystem.
Three limits I see in 2026: documentation is still uneven across servers (some are very well documented, others not at all), security rests on your own vigilance (no central marketplace that audits), and the install experience is still technical (manually editing a JSON file). Anthropic and the community are working to fix all three, but we're not there yet.
Three directions announced by Anthropic and the community: an official MCP server registry (an npm equivalent for MCP), better permission handling (a client can allow one tool but not another), and extending HTTP transport for remote servers (beyond local stdio). The public roadmap lives on the modelcontextprotocol GitHub.
To dig into MCP beyond what I cover here, these are the sources I check regularly. The spec and the ecosystem move fast, so I'd rather point to the reference sources than freeze everything into a static article.
Anthropic's official site dedicated to MCP. Full spec, tutorials, examples, getting-started guide. The source of truth, updated with every release.
GitHubThe official organization. You'll find the spec, the Python and TypeScript SDKs, the reference-servers repo and the clients repo. The best place to see the real code.
ServersAround twenty official MCP servers, ready to use or to fork. Filesystem, GitHub, Slack, PostgreSQL, Puppeteer, Brave Search. The code is readable and well commented.
CommunityAnthropic's official Discord hosts a channel dedicated to MCP. Announcements, support, conversations with the MCP team. Handy for following the news live.
Official videoMCP talks and tutorials by the Anthropic teams. Handy for watching a server get built live and understanding the philosophy behind the protocol.
Podcast (EN)One of the best AI podcasts in English. They've done several episodes dedicated to MCP, with interviews of Anthropic's founders and maintainers of popular MCP servers.
My guideMy complete guide to Claude Code, the MCP client that got me into all of this. Install, workflows, skills, and of course the section dedicated to MCP on the Claude Code side.
My articleThe article where I tell how I combine Claude Code skills and MCP servers to build my own agents. Concrete, with examples.
And if you want me to keep you posted on how MCP evolves — interesting new servers, spec releases, integrations that actually work — my AI Playbook newsletter drops every Friday morning at 9. Sign up in the footer below.
MCP moves fast. New servers, new clients adopting it, new versions of the spec. If you want to follow what actually deserves your attention — without reading 80 tech newsletters a week — mine, AI Playbook, drops Friday morning. I sum up my real tests, I give the commands that work, and I flag the dead ends.
See my newsletters →