⁠Run or install an MCP server for the tool or data source you care about. Anthropic has an open-source repo of pre-built servers for popular systems (Google Drive, Slack, Git, databases, etc.)​. You can install these and configure them (often just running a command with your credentials or keys).

Set up the MCP client in your AI app. If you’re using Claude’s app, you can add the server in the UI. If you’re coding your own agent, use the MCP SDK to connect to the server (providing the address/port).

Once you’ve enabled the MCP services in your client, the client will pick on the additional functionality provided: additional tools, resources and prompt templates.

Invoke and iterate. The model/agent can now call the MCP tool actions as needed. Make sure to monitor logs to see that it’s calling the servers correctly. You’ll see requests hitting the MCP server and responses coming back.

Custom API Integrations (One-off Connectors): The most common method has been writing custom code or using SDKs for each service. For example, if you wanted your AI agent to access Google Drive and a SQL database, you’d integrate Google’s API and a database driver separately, each with its own authentication, data format, and quirks. Pain in the neck! MCP, by contrast, gives a single “key” (protocol) that can unlock many doors, and new MCP servers can be added without changing the client​.

Language Model Plugins (OpenAI Plugins, etc.): Another approach introduced in 2023 was providing the model a standardized plugin specification (often an OpenAPI schema) so it could call external APIs in a controlled way (e.g. the ChatGPT Plugins system). While conceptually similar to MCP (standardizing tool access), these were proprietary and limited – each plugin still needed to be built and hosted individually, and only certain platforms (like ChatGPT or Bing Chat) could use them. Plugins also tended to focus on one-way data retrieval (the model calls an API and gets info) rather than maintaining an ongoing interactive session. MCP distinguishes itself by being open-source and universal (anyone can implement it, not tied to one AI provider) and by supporting rich two-way interactions. It’s like a dialogue between the AI and tools, whereas plugins were often stateless question-answer calls.

Tool Use via Frameworks (LangChain tools, Agents): Agent orchestration libraries like LangChain popularized the idea of giving models “tools” (functions) with descriptions. For example, you might have a search() tool or a calculate() tool, and the agent (via the LLM) decides when to invoke them. This is powerful, but each tool still required custom implementation under the hood – LangChain’s library grew to 500+ tools implemented in a consistent interface​, yet developers still had to wire up those tools or ensure they fit their needs. MCP can be seen as complementary here: it provides a standardized interface for the implementation of tools. In fact, you can think of MCP servers as a library of ready-made tools that any agent can use. The difference is where the standardization lies. LangChain created a developer-facing standard (its Tool class interface) to integrate tools into an agent’s code. MCP creates a model-facing standard – the running AI agent itself can discover and use any MCP-defined tool at runtime​. This means even if you don’t custom-build an agent’s code for a particular tool, the model can integrate it on the fly. In practice, these ideas are converging: for example, LangChain’s team (when noticed the surge of MCP) provided an adapter so that all those MCP servers (connectors) can be treated as LangChain tools easily​. So an agent built in LangChain or other frameworks can call MCP tools just like any other, benefiting from the growing MCP ecosystem.

Retrieval-Augmented Generation (RAG) and Vector Databases: A prevalent way to supply context to LLMs is to use a retriever that searches a knowledge base (documents, embeddings) and injects the top results into the prompt. This addresses the knowledge cutoff or limited memory of models. However, RAG usually deals with static text snippets and doesn’t inherently let the model perform actions or queries beyond what’s indexed. MCP can actually work alongside RAG – for instance, an MCP server could interface with a vector database or search engine, allowing the model to issue search queries as a tool rather than implicitly relying on retrieval every prompt. One could argue MCP is a more general mechanism: where RAG gives passive context, MCP lets the model actively fetch or act on context through defined channels. In scenarios where up-to-date or interactive data is needed (say, querying a live database or posting an update), MCP extends beyond just retrieving text – it can trigger operations.

One of the primary concerns is the added overhead of managing multiple tool servers. Running and maintaining connections to these local servers can be cumbersome, particularly in production environments where uptime, security, and scalability are paramount. MCP's initial implementation was designed for local and desktop use, which raises questions about how well it translates to cloud-based architectures and multi-user scenarios. Developers have proposed making MCP more stateless and adaptable to distributed environments, but this remains an ongoing challenge.

Another issue lies in tool usability. Just because MCP expands an AI model’s toolset does not necessarily mean the model will use those tools effectively. Previous agent-based frameworks have demonstrated that AI models can struggle with tool selection and execution. MCP attempts to mitigate this by providing structured tool descriptions and specifications, but success still hinges on the quality of these descriptions and the AI’s ability to interpret them correctly. The community-driven approach, as highlighted by LangChain’s founder Harrison Chase, suggests that well-documented tools can enhance usability, but this is still an area of ongoing refinement.

Beyond implementation hurdles, MCP’s maturity is also a consideration. As a relatively new technology, it is subject to rapid changes and evolving standards. This can lead to breaking changes, requiring frequent updates to servers and clients. While the core concept of MCP appears stable, developers should anticipate and prepare for version upgrades and evolving best practices.

Compatibility is another limiting factor. Currently, MCP has first-class support within Anthropic’s ecosystem (e.g., Claude), but broader adoption remains uncertain. Other AI providers may not natively support MCP, requiring additional adapters or custom integrations. Until MCP gains wider acceptance across AI platforms, its utility will be somewhat constrained.

For simpler applications, MCP may even be overkill. If an AI model only needs to access one or two straightforward APIs, direct API calls might be a more efficient solution than implementing MCP. The learning curve associated with MCP’s messaging system and server setup means that its benefits need to be weighed against its complexity.

Security and monitoring also present ongoing challenges. Since MCP acts as an intermediary, it necessitates robust authentication and permission controls to prevent unauthorized access. Open-source initiatives like MCP Guardian have emerged to address these concerns by logging requests and enforcing policies, but securing MCP in enterprise environments remains a work in progress.

Multi-Step, Cross-System Workflows Agentic systems often need to coordinate across platforms. Say an AI plans an event: it checks your calendar, books a venue, emails guests, arranges travel, and updates a budget sheet. Right now, this requires stitching APIs together manually. With MCP, all these actions happen through a single interface. The agent calls a series of MCP tools (one for each task), keeping shared context across them—no lost threads, no custom integrations.

Agents That Understand Their Environment (including Robotics) Beyond tool access, MCP can enable AI agents embedded in smart environments – whether in a smart home or an operating system. An AI assistant could interact with sensors, IoT devices, or OS functions via standardized MCP servers. Instead of operating in isolation, the AI gains real-time awareness, enabling more natural and proactive assistance.

Collaborating Agents (Agent Societies) – I’m very excited about this one – MCP could also serve as a shared workspace for multi-agent systems. Specialized AI agents – one for research, one for planning, another for execution – could use MCP to exchange information and coordinate tasks dynamically. With MCP, each agent doesn’t need direct integrations; they simply access a common toolset.

Personal AI Assistants with Deep Integration MCP could let users configure their own AI to interact with personal data and apps securely. A local MCP server could grant an AI access to emails, notes, and smart devices without exposing sensitive data to third parties. This could create an ultra-personalized AI assistant without relying on cloud-based services.

Enterprise Governance and Security For businesses, MCP standardizes AI access to internal tools, reducing integration overhead. It also enables governance: AI interactions can be logged, monitored, and controlled via an oversight layer, preventing unintended actions while maintaining efficiency.

Remote Servers & OAuth

Official MCP Registry

Well-Known Endpoints

Further Enhancements

Introducing the Model Context Protocol by Anthropic

Model Context Protocol documentation and quickstart guide

MCP docs

Model Context Protocol on GitHub

Collection of Servers for MCP on GitHub

Building Agents with Model Context Protocol (and especially the part: What’s next for MCP) by Mahesh Murag from Anthropic

Why MCP Won by swyx from Latent Space

GitHub Star History (charts)

MCP: Flash in the Pan or Future Standard? by LangChain

MCP Guardian on Github

Exposing Services with MCP

Initial reaction to MCP on reddit

🦸🏻#5: Building Blocks of Agentic Systems

🦸🏻#9: Does AI Remember? The Role of Memory in Agentic Workflows

🦸🏻#10: Does Present-Day GenAI Actually Reason?

🦸🏻#11: How Do Agents Plan and Reason?

🦸🏻#12: How Do Agents Learn from Their Own Mistakes? The Role of Reflection in AI

🦸🏻#13: Action! How AI Agents Execute Tasks with UI and API Tools