Understanding Anthropic's Model Context Protocol

A potentially revolutionary standard in it's very early days.

Anthropic announced the Model Context Protocol. The key thing about MCP is that it creates this standardized way for Large Language Models (LLM’s) to interact with your local tools and data, without needing to build custom integrations for every possible service. You just need to implement this protocol, and boom - Claude can talk to your stuff.

To get an understanding of what the model context protocol actually means, I've been putting in some work, getting it to work and experimenting with it. So far it seems like a much better, more powerful version of Function Calling.

It's a bit like a USB port: one of the first attempts at providing a protocol or standard to communicate between services and LLM's.

So to explain that, I'd like to bring up two different examples. One "at home" example, and one for a coroporate enviornment.

MCP controlling a Smart Home

Say you have a smart home server running that is plugged into your local network. You might not be able to manage things when you're not connected to your home network, but when you're connected to Wifi, you're free to change things around.

With model context protocol you can create a little server that acts as a bridge between your smart home and the Claude App. You can for example program in there that when it receives some information around lights, it can adjust them.

Let me continue with your smart home example to make it more concrete.

So you program your MCP server to expose a "tool" that Claude can use. This tool can tell claude it can control the lights by providing the name of a room, whether to turn the lights on or off, and perhaps a brightness level. In the server this would look something like this:

Now, when you're chatting with Claude in the Claude Desktop app, you could say something like "Hey, can you turn off the lights in my bedroom?" and Claude would understand that it has access to this tool through your MCP server. It would then make a call to your server with something like:

Your server would then translate this into whatever API calls your smart home system needs, maybe something like sending a command to your Phillips Hue bridge or your Home Assistant setup.

What's cool about this is that Claude doesn't need to know anything about your specific smart home setup - it just knows there's a tool available that can control lights, and it can use natural language to figure out when and how to use that tool.

MCP in a Work environment:

Imagine you're working at a large enterprise with various internal tools and databases. You have:

• A customer relationship management (CRM) system

• An internal knowledge base with product documentation

• A ticketing system for customer support

• Historical sales data in various databases

With traditional function calling, you might expose an API endpoint that Claude could call to get specific pieces of information. But MCP is more powerful because it provides a richer protocol for context-aware interactions. Here's how:

Let's say you build an MCP server that connects to these systems. You could expose:

1. Resources:

Now, you can provide the tool that tells the model what it needs to provide to grab information from the CRM. In this case, it could be: Customer ID, date range, and type of interaction (call, e-mail, message etc.)

2. Tools for active interactions:

Now, what makes this more powerful than simple function calling?

1. Bidirectional Communication: The MCP server can:

• Send progress updates while processing long-running queries

• Update resources in real-time as data changes

• Request additional LLM processing through the client session

2. Context Awareness: When a support representative asks Claude "What's going on with customer ABC Corp?", Claude can:

• Pull recent interaction history from the CRM resource

• Check relevant product documentation

• Search support tickets

• Combine all this information into a coherent response

3. Progressive Enhancement: Your server can expose additional capabilities over time:

4. Security and Access Control: Since it's a local server, you can:

• Keep sensitive data within your network

• Apply proper authentication and authorization

• Log and audit all interactions

• Control exactly what data Claude can access

So when someone asks Claude something like:

"What's our relationship with ABC Corp looking like? Are there any risks we should be aware of?"

Claude can:

1. Pull recent interactions from the CRM

2. Check support tickets for patterns

3. Review sales history

4. Look at product usage data

5. Use its own analytical capabilities to synthesize this information

6. Generate a comprehensive response that combines all these data sources

This is fundamentally different from function calling because it's not just about requesting specific pieces of data - it's about providing Claude with rich, contextual access to your business systems while maintaining security and control. The protocol handles all the complexity of this interaction, making it much more powerful than simple API calls.

---

What does this all mean for the future?

Think of MCP like a USB port - it's aiming to be a new standard that allows companies to create localized, secure connections between their systems and LLMs. This is particularly powerful because it opens up two interesting paths:

1. Companies can build their own MCP servers to connect their internal systems, data, and tools to LLMs in a standardized way. This means instead of building custom integrations for each LLM provider or tool, you build one MCP server that could potentially work with multiple LLM platforms.

2. Software providers could start shipping their products with built-in MCP support. Imagine:

   • Home Assistant (the open-source home automation platform) coming with a built-in MCP server, letting any compatible LLM instantly understand and control your smart home

   • Salesforce or HubSpot including an MCP server in their CRM, allowing seamless LLM integration with your customer data - Any company that picks to run their own LLM can now enable people to ask questions in natural language

   • Project management tools like Jira or Monday.com shipping with MCP support, enabling AI assistants to directly interact with your project data

   • Accounting software like QuickBooks integrating MCP, making your financial data and invoices instantly searchable and analyzable by LLMs

However, there are some important current limitations to consider:

Right now, MCP only works with Claude Desktop and Claude for Work apps. While it's a promising start, it needs broader adoption to truly become a universal standard.

The real game-changer would be if MCP could be implemented in other LLM environments. A great start would be tools like OpenWebUI, Ollama or LM Studio. Any of these tools would make it incredibly easy to combine MCP with ANY other model.

This wider compatibility would dramatically accelerate adoption and make MCP more valuable as a universal standard for LLM-system communication.

The big question is whether MCP will gain the widespread adoption it needs to become a true standard, or if it will remain limited to the Claude ecosystem. Anthropic has promised to share documentation on how others can implement MCP in their own LLM environments, which could be crucial for its broader adoption. Just like USB became universal through widespread support, MCP's success will depend on whether it can build a robust ecosystem of compatible tools, platforms, and LLMs.