What is the Model Context Protocol and why it matters

The Model Context Protocol (MCP) is an open standard that allows large language models (LLMs) to connect to data sources and other external systems. It provides AI agents a consistent pathway to access third-party information, whether that includes pulling from real-time data sources or taking actions on external tools.

In this article, we’ll explore what the Model Context Protocol is in context, outlining its history and why it’s become central to the wider adoption and success of AI systems. Or, dive in to how the ElevenLabs Host MCP works with the video below.

Summary

• The Model Context Protocol connects LLMs to the outside world and provides resources beyond what’s available in their training data.
• MCP allows AI agents to discover connected server tools at runtime, as opposed to conventional APIs, which are hard-coded.
• MCP solves the MxN problem, in which constantly changing AI models each need unique connections to external systems. MCP acts as a universal translator for all these systems.
• AI platforms like ElevenLabs can operate as both an MCP server and client, either providing resources on demand or orchestrating the actions of other services.
• AI agents can chain together multiple MCP calls to perform complex workflows even mid-conversation with a user.

What is the Model Context Protocol (MCP)?

A protocol is like an agreed-upon language that different computer systems use to interact. MCP is a protocol that allows AI agents to retrieve information from external sources or execute actions using external tools and systems.

Large language models (LLMs) are powerful tools whose ability to interact in natural language has led to explosive growth in popularity in both the enterprise and consumer worlds. But as users worked with them more and more in real-world settings, two major limitations have become apparent:

• An LLM’s understanding of the world is frozen at the point in time its developers captured its training data.
• A model has no native way to interact with the outside world and other computer systems.

One of the hopes for LLMs was the ability to create artificial intelligence (AI) agents we could interact with in natural language. But an AI agent restricted to only a model’s training data, without those two dynamic capabilities, is of limited use.

Anthropic developed the Model Context Protocol to standardize communication between LLMs and external systems. They released it as an open standard in November 2024. Most major LLM developers quickly adopted it. Anthropic then donated the standard to the Agentic AI Foundation in 2025.

MCP gives large language models a way to connect to external data sources to supplement their training data and provide more accurate, contextual, and updated responses to queries. An LLM-powered AI agent can also access approved external tools to take autonomous action. 

For example, you could tell an agent to “Check my calendar for available time slots next Tuesday and then contact the contractor with a proposed meeting time.” The agent then checks the calendar server over MCP, ingests the results, and then accesses the email server over MCP to send the requested message.

How does the Model Context Protocol work?

The development of the Model Context Protocol built on earlier concepts, like tool calling and function calling, which allow an LLM to output a service request schema that external systems process through APIs. But these methods required custom connections between an LLM and each external system.

MCP creates a standardized, two-way communication model for sending and receiving data from external systems.

When an AI agent first starts up, it queries all connected MCP servers for a catalog of their available data sources and functions. It feeds that catalog back to the LLM’s context window, which is like short-term working memory for its current task.

Then, when you ask the agent to do something, the underlying LLM decides whether it can fulfill that request using only knowledge in its training data or if it needs external resources. If it does need external support, it checks its catalog and contacts the appropriate system over its MCP connection. 

The LLM reviews the external response and decides whether it can complete your request, or if it needs to take multi-step action, like in our calendar and email example.

MCP helps solve the MxN Problem

A universal communication standard, like MCP, was needed to solve what engineers called the MxN Problem. If you have M agents and want each to connect to N external tools, you have to maintain MxN point-to-point connections. When you only have a couple of AI agents and external sources, that’s not a problem, but as those numbers grow, it quickly becomes an unsustainable workload.

MCP allows LLMs to operate over M+N connections by standardizing all communication into a single protocol.

Core architecture: MCP servers vs. clients explained

An AI agent will use an MCP client to communicate with external systems. An external system, such as a calendar, email, or CRM, needs to be available via an MCP server for the agent to communicate with it.

ElevenLabs products are available as both clients and servers. It’s the same platform behind the scenes, but it can operate in either role.

Let’s use it as an example to understand MCP architecture.

MCP Server

An MCP server runs attached to an external system and presents a list of available resources and tools to connected MCP clients. Resources can be files, documents, databases, or pipelines. Tools allow the remote LLM to interact with assets on the external system.

The ElevenLabs-hosted MCP server provides Claude and other AI assistants access to management tools for their ElevenLabs agents. The server is available at: 

https://api.elevenlabs.io/v1/mcp

You create a secure connection from Claude, ChatGPT, or another assistant to the server using OAuth. That assistant is an MCP host and contains MCP clients, which manage the connection. You can then use the assistant to build and manage agents and audit their performance using simple, natural language prompts through your assistant.

Example prompts

• “Create a customer service agent for our e-commerce portal. It needs to maintain a professional but positive tone.”
• “Duplicate my customer support agent and change its default language to Spanish.”
• “Run a cost comparison per conversation for my Spanish-language agent in Gemini 3.5 Flash Lite and 3.8 Flash.”

MCP Client

An MCP client is a dedicated connection to a specific MCP server. It lives inside an MCP host, and a host can have multiple MCP client-server connections. In our example above, Claude was the host.

Clients send requests for tools and resources to servers using structured JSON-RPC calls. Because requests are translated over the MCP protocol, the host doesn’t need to understand the underlying configuration details of the server’s attached tools.

ElevenLabs can also function as an MCP client. In this setup, you use your ElevenLabs workspace to connect an agent to an external MCP server, for example, Zapier MCP. That gives the option to connect your agent to hundreds of different tools and services.

Let’s say, for example, you’re building an ElevenLabs customer service agent. You want it to securely access your customers' account details in Salesforce so it can answer meaningful questions for them. Then when a customer asks it a question about a past order or the status of a return request, the agent will send a query over MCP to the Zapier server. 

It translates the query into a request Salesforce understands and returns the results, which your ElevenLabs agent speaks back to your customer.

MCP vs. traditional APIs: What’s the difference?

Traditional APIs perform a somewhat similar role in allowing client and server systems to communicate, but you need to hardcode most of the parameters in a basic request-response structure. That works fine when connecting conventional software systems, but it’s not practical for complex, AI-powered workflows, primarily due to the MxN Problem already discussed. 

Instead of creating hardcoded endpoints where systems can exchange requests, MCP works on top of APIs to provide an entirely machine-readable interface for LLMs. The connections aren’t prescribed. An AI can build its own sophisticated queries and develop appropriate contextual understanding.

Key benefits of using MCP for AI integrations

The release of the Model Context Protocol has opened up a wide range of new functionality and new capabilities for AI agents. 

It has provided several specific advantages:

• Standardization
• Tool discovery and querying flexibility
• Improved AI automation
• Sophisticated agentic behavior
• Greater accuracy in responses

Let’s break these down further.

Standardization

Before MCP, connecting LLMs to external systems was possible, but labor-intensive. You need to create customized connections between every single model and resource. Hence, the MxN Problem.

MCP provides a common language all LLMs can use to interact with virtually any connectable system. That makes developing new connections significantly easier and faster. Client and server configurations are also much more uniform across models. You don’t need to rewrite an MCP connection from the ground up every time a model updates.

Flexibility in tool discovery and querying

In the past, you needed to hard-code API endpoints for every external connection an AI agent needed to make. If a developer added a field to a database, you needed to rebuild the API for it to work.

MCP allows agents to discover external resources during runtime. In other words, the resources exist, and when an agent needs them, they can discover what’s available. You can add a tool to an MCP server, and the connected AI agents will discover it on the next run. You don’t need to write any code to update the connection.

Better AI automation

Out of the box, LLMs only know what’s in their training data set, and they have no way to interact with the outside world. MCP gives them the means to ingest up-to-date information and invoke tools from any connected system that has an MCP server.

Sophisticated agentic behavior

Making tool and function calls has been a capability LLMs have had for years. But those capabilities only offered limited access to external tools. Because it’s standardized, universal, and flexible, MCP allows AI models to string together multiple MCP calls into longer, sophisticated queries. For example, checking a CRM for updated client information, checking the calendar for available appointment times, and then emailing the client to suggest a follow-up call time slot.

Greater accuracy in responses

By their nature, large language models can sometimes hallucinate responses. They are prediction engines that output the most likely response based on the contextual information they’re given. If you ask an LLM a question whose answer relies on real-time information, you’re more likely to get a hallucinated answer if proper guardrails aren’t in place.

The MCP protocol allows LLMs to connect to real-world data repositories and tools that provide the live information they need to generate accurate responses.

MCP applications and real-world use cases

The Model Context Protocol is a standard bridge AI agents can use to talk to any number of external systems. 

Here is how you can use MCP across a number of real-world industries and workflows.

Configuring agents via chat

Testing and optimizing conversational bots usually requires switching between multiple dashboards and consoles. ElevenLabs’ hosted MCP server in Claude allows you to manage your voice infrastructure directly via a natural-language chat interface.

Context-aware coding assistants

Coding assistants work best when they have deep, contextual understanding of proprietary architecture designs and incident histories. That’s difficult to provide through conventional means.

MCP-connected development environments can pull from relevant repositories so your coding assistants understand the real-world context within which they’re building applications. Your human developers can troubleshoot issues faster because the assistant has already been able to map out dependencies across the entire codebase.

Voice agent mid-call workflows

Before large language models provided more natural language interaction, conventional voice bots needed to follow rigid flowchart scripts to interact with customers. They also couldn’t interact with customers using any form of real-time data.

Conversational bots can now use MCP to call backend systems for any necessary account information needed to process customer requests. They can do this in real-time, mid-conversation with a customer when needed. 

Get started with ElevenAgents for seamless MCP integration

ElevenAgents gives you powerful voice agent capabilities as both an MCP server and client. 

Connect your ElevenLabs agents to external MCP servers, or manage them from Claude via the hosted MCP. Get started with MCP-powered ElevenLabs agents today or learn more about ElevenAgents.

Frequently asked questions about the Model Context Protocol