Anthropic's Model Context Protocol (MCP): The Complete Guide
Published on
Anthropic, one of the leading AI companies in the world, released an article about MCP in November 2024 without making much noise. It describes an open standard that lets developers connect AI assistants to all kinds of data sources.
Back then, we talked about the launch on the “IA Sob Controle” podcast. But lately the name has been coming back up in the AI community because more and more people, companies and development platforms are adopting it.
Today I’m going to explain what MCP is and how it works, plus share some really cool use cases we’re seeing in the community. Shall we?
What MCP is
The Model Context Protocol (MCP) is an open protocol created by Anthropic to standardize how AI models connect to external data sources and tools. Instead of every integration being custom-built, MCP defines a universal standard for that communication. In practice, it works like a universal “USB-C port” for AI applications, giving you a single way to connect language models to all kinds of content repositories, databases, services and apps, no matter who built them.
MCP has a simple but powerful goal: to break the isolation of AI models and give them controlled, secure access to real-world data. In practice, that means even the most advanced models (which today are limited to whatever they learned in training) will be able to generate much more contextualized answers, because they’ll have access to the information you already have in other tools. It’s as if we were giving AIs a standardized way to “see the world” beyond the knowledge bubble where they were trained, and in a structured way.
Just like HTTP revolutionized communication on the web (letting any browser access any site) and LSP made it easier to plug many programming languages into IDEs, MCP promises to establish a “lingua franca” for AI integrations.
In practice, that means any MCP-compatible client will be able to talk to any MCP server, creating a truly interoperable ecosystem. No more fragmented integrations or proprietary protocols, just one consistent, universal way to connect models to the real world.
As Block’s CTO pointed out, open technologies like MCP serve as a “bridge that connects AI to real-world applications”, making innovation more accessible, transparent and collaborative, and making it possible to build agent systems that take the burden of mechanical tasks off people and free them up for creative work.
The technical part: how it works and what it’s compatible with
Below, we see a simplified diagram of the MCP architecture. An MCP client (for example, a desktop app with AI) talks to an MCP server through the standardized protocol. The MCP server acts as an adapter between the AI model and different data sources, each with its own specific API (GitHub, Slack, the local file system, etc.), but all accessed in a unified way via MCP.
Architecture
Technically, MCP follows a client-server model. On one side we have a host (the application that embeds the AI model, like Claude Desktop, an IDE or some other app) and on the other side one or several MCP servers that expose data or functionality. Inside the host, an MCP client component manages 1-to-1 connections with each available MCP server. Each MCP server is basically a little program that “translates” a specific data source or service into the protocol’s standards.
The server can run locally or remotely. For example, it can be a local process accessing files on your computer, or a web service accessing an external API like Slack or GitHub. The communication between MCP client and server is standardized: everything happens through JSON messages following the JSON-RPC 2.0 standard. These messages can travel over different channels (transports): MCP supports both STDIO communication (ideal when the server runs locally, using standard input/output) and HTTP with SSE (Server-Sent Events) for networked scenarios.
Regardless of the transport, the message format and conventions stay the same, which guarantees interoperability. During the connection’s initialization phase, the client and the server exchange protocol version information and supported capabilities, and only then start exchanging messages in a secure, structured way.
Resources and Tools
MCP defines two main types of capabilities that every Dev should know: Resources and Tools:
- Resources are basically all the “knowledge” the model can access, but read-only. Think files, database records, API results or even images. Each of these resources is identified by a unique URI (like file:// for local files or postgres:// for databases). The interesting part is how it works: the client can simply list the available resources via the resources/list endpoint and then access any of them with resources/read. The server returns everything in a standardized format: UTF-8 text, or binary in base64 for images and other files.
- Tools are where the magic happens. They represent executable actions or functions that the AI model can invoke through the server. Each tool has a unique name, a description and a specification of the parameters it expects (defined in JSON Schema). The client can discover the available tools (tools/list) and call one of them via tools/call, sending the requested parameters. The server then executes the action (for example, creating a new file, sending a message, running a search) and returns the results or a standardized error.
The detail that caught my attention the most (and that I believe is essential for enterprise adoption) is the built-in security control. Since tools can change state or interact with external systems, the protocol provides for human confirmation on critical actions. Imagine the model trying to delete a file: the application can (and should) ask for your authorization before doing it.
That control layer is what will let companies adopt more autonomous AI agents without the constant fear of “what if it does something it shouldn’t?”. It’s the famous human-in-the-loop, applied in a standardized way.
Development
When it comes to development, Anthropic is already providing official SDKs in several languages (like Python, TypeScript, Java, Kotlin, etc.) and an open specification so developers can easily create their own MCP servers and clients.
What caught my attention the most is how much this simplifies a developer’s life. Basically, you build an MCP server by defining which resources and tools you want to expose, you implement the handlers for the standardized endpoints (resources/list, resources/read, tools/call), and that’s it, the SDK takes care of all that boring transport and protocol work. You only worry about the logic of your data source.
And the best part: since it’s an open protocol, the flexibility is huge. People are already plugging MCP clients into LangChain and even running servers on Cloudflare Workers! The community doesn’t waste any time, as usual.
Maybe the most strategic point of this protocol is that it’s model- and vendor-agnostic. Even though it was proposed by Anthropic, MCP doesn’t depend exclusively on Claude. You can implement an MCP client on top of any LLM (GPT, Gemini, your pick). Anthropic itself highlighted this as “flexibility to switch between LLM providers”, which is crucial in a market that evolves this fast.
What does that mean in practice? We finally have a standardized, modular integration layer between AIs and any source of information or tool. And the most interesting part: unlike mechanisms such as OpenAI’s function calls or LangChain’s tools (where everything has to be defined beforehand), an application with MCP support can connect new servers practically in real time, like installing a browser extension.
Below are Anthropic’s beginner tutorials for anyone who wants to start playing around:
Practical applications and use cases
Since the launch in late 2024, MCP has been gaining popularity in all sorts of contexts. Several tech companies and startups have more recently started embracing the protocol as a way to make their AI systems more connected and useful.
What fascinates me is how fast big companies are adopting it. Block (Square), led by Jack Dorsey, was one of the pioneers, incorporating MCP to automate complex operational tasks. Apollo followed a similar path, letting its virtual assistants query databases and internal tools directly via MCP. In practice, that means you can ask something like “how are the metrics for our latest launch looking?” and the agent goes off, fetches the data and brings back a complete report, all without you having to open 15 different tabs.
In the developer world, adoption has been even faster. Replit, Zed, Sourcegraph and Codeium have already integrated MCP into their coding environments. Imagine having an assistant that not only understands your code, but can also run it, debug it and even deploy changes, all from natural language instructions.
Even Cloudflare jumped on the bandwagon and launched an official MCP server. Now an AI agent can manage resources on their platform (Workers, DNS, etc.) through conversational commands. “Hey Claude, update the DNS record for that domain to point to the new server” and boom, done.
Maybe the most interesting part is what’s happening in the open-source community. Since MCP is an open protocol, independent developers created hundreds of MCP servers in just a few months. I’ve seen use cases ranging from organizing files on your computer to controlling IoT devices at home, all from natural language commands. Below are some of the most impressive ones:
MCP that lets Claude talk directly to Blender and create 3D scenes from prompts:
MCP for Perplexity’s Sonar model, giving AI assistants real-time research and web search capabilities:
MCP integrating Claude with the PubMed academic database:
MCP that lets Claude talk directly to Unity to create games from prompts:
What we’re witnessing is the transition of AIs from “isolated question-answering tools” to “agents capable of doing things in the real world”, and that has huge implications. The companies that adopt this approach first will probably have significant advantages in productivity and innovation.
Market impact and the future
Just like earlier universal standards (USB, HTTP, SQL, etc.) transformed their domains, MCP has the potential to become the de facto standard for connecting language models to data and services. Before MCP, there kind of wasn’t a single way to do this. Each company and AI provider handled integrations their own way. It was as if every device needed a different cable, with no standardization.
On top of that, releasing MCP as open source encouraged a real community to grow around the protocol. This creates a positive chain effect: as more MCP servers get built for different tools, more developers and companies are drawn to using the protocol, since they’ll already have a rich catalog to work with. It’s a similar effect to why companies use Python for AI projects.
From the companies’ point of view, MCP can solve one of the bottlenecks for wide adoption of AI assistants: secure integration with existing systems. Many organizations have valuable data sitting in silos (CRM, ERP, internal databases) that could drastically improve an AI assistant’s answers, but there are always concerns about security, privacy and the cost of building custom integrations. With MCP, companies can keep the data in their own environment (on-premise or private cloud) and expose it to an AI model through a local MCP server, under their control.
Finally, the word of 2025 in the AI world: agents. MCP reinforces this trend toward “agentic” systems, where AI models don’t just passively respond to a prompt, but take initiative, carry out tasks and coordinate tools to reach goals. With a standardized protocol like MCP, building these applications in a modular, scalable way becomes much more feasible, and so does building these agents.
Developers can combine multiple MCP servers to give an agent a variety of skills (reading documents, sending e-mails, doing calculations, querying APIs), and the agent itself (the AI model) can plan which tools to use to solve a complex user request.
Conclusion
Anthropic’s Model Context Protocol arrives as a direct answer to a practical problem in AI adoption: the need to give language models context and real capabilities in a simple, secure and standardized way.
In the short term, it makes life easier for AI developers and enables more advanced use cases (like agents that really execute tasks). But it’s in the medium and long term that things get really interesting. If the industry starts converging around MCP (and there are good signs that it will), it could become as fundamental to enterprise AI infrastructure as the HTTP protocol is to the internet today.
The most fascinating thing is realizing how the AI ecosystem is moving toward a more integrated and collaborative model. Instead of isolated islands of technology, we’re building bridges, and MCP has the potential to be the main one.



