Standardising AI Access — Model Context Protocol (MCP)

Have you ever wished your AI assistant could do more?

Did you ever want to ask ChatGPT to handle your emails? Schedule meetings? Scan through pdfs and answer questions?

Information Silos

Currently, AI agents reside within information silos; they’re like geniuses that are stuck in a library with no access to the outside world.

Their knowledge only consists of whatever they have been given during the training process and nothing more. Giving it data will enable the agent to answer questions and take actions based on its now increased set of information.

Say you wanted your AI agent to schedule a meeting from an email in an empty slot in your calendar. The key factor in achieving this is to provide the Agent access to the email and calendar data, and the ability to schedule a meeting. This information will now allow the agent to schedule the meeting at the correct time with the right person.

So how do we give an agent like ChatGPT access to the data?

Let’s look at how developers typically handle this.

The “Old” Way

The following is some sample Python code to make the request to schedule a meeting from an email to the OpenAI API.

agent = OpenAI()

def get_emails():
  # Logic to fetch the contents of emails

def get_calendar_info():
  # Logic to fetch calendar info

def schedule_meeting():
  # A tool to enable the agent to schedule a meeting

prompt = "Please look at my latest email and schedule a meeting in an 
empty slot in my calendar."

response = agent.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": prompt},
    ],
    # Adding tools gives the agent the ability fetch the necessary info
    # And the ability to schedule meetings if needed
    tools=[
      { "type": "function", "function": { "name": "get_emails" } },
      { "type": "function", "function": { "name": "get_calendar_info" } },
      { "type": "function", "function": { "name": "schedule_meeting" } }
    ]
)

print(response.choices[0].message["content"])

In the snippet, we define 3 functions. Two functions to fetch information and one to provide the agent with the ability to take an action.

The problem with this method is the inability to use the tools we defined above in another implementation. Say we wanted to switch to using the Claude API instead, and we want to implement it in Typescript. Now we have to redo the entire implementation, including the 3 tools we defined earlier.

const client = ClaudeAI();

function get_emails() {
  // Reimplementation in typescript
}
  
function get_calendar_info() {
  // Reimplementation in typescript
}

function schedule_meeting() {
  // Reimplementation in typescript
}

const prompt = `Please look at my latest email and schedule a meeting in an 
empty slot in my calendar.`

const response = await client.messages.create({
  model: "claude-3-5-sonnet-20240620",
  messages: {role: "user", content: prompt}
  tools: [
    { name: "get_emails" },
    { name: "get_calendar_info" },
    { name: "schedule_meeting" }
  ]
)

console.log(response)

M X N Problem

This issue of having to implement each connection for every AI agent is referred to as the M x N problem. For every AI Agent, M, and every connection, N, a total of M multiplied by N connections need to be built.

2 Agents x 3 connections = 6 Custom Integrations

We can see that having to build each connection for every new agent we want to use can be quite onerous.

Model Context Protocol (MCP)

Model Context Protocol is a framework introduced by Anthropic that aims to solve this problem of having to create custom integrations. In this framework you only have to define the tools you want to make available to your agent once, and expose to them agent (client).

It’s easiest to dive into an example, we will first create an “MCP Server”.

from mcp.server.fastmcp import FastMCP

# Create MCP server instance
mcp = FastMCP("calendar_email_mcp")

# Register tools (capabilities)
@mcp.tool()
def get_emails_tool() -> dict:
    """Fetch emails and their contents."""
    return get_emails()

@mcp.tool()
def get_calendar_info_tool() -> dict:
    """Get the user's calendar information."""
    return get_calendar_info()

@mcp.tool()
def schedule_meeting_tool(time: str, with_person: str) -> dict:
    """Schedule a meeting with the given person at a specific time."""
    return schedule_meeting(time, with_person)

This MCP server defines the same three functions we saw in the previous examples. The advantage of this method lies in the “client” side or the agent utilisation of these tools.

Now, no matter which agent (ChatGPT, Claude) or which language you use these tools are made available for use through the server.

agent = OpenAI()
mcp_client = MCPClient("http://<location-of-mcp-server>:8000/mcp")

tools = mcp_client.list_tools() # This exposes the three tools we defined above

prompt = "Please look at my latest email and schedule a meeting in an 
empty slot in my calendar."

response = agent.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": prompt},
    ],
    tools=tools
)

print(response.choices[0].message["content"])

The real advantage of this implementation is realised when we take a look at the second javascript implementation with Claude.

const client = ClaudeAI();
const mcpClient = MCPClient();
const tools = mcpClient.listTools();

const prompt = `Please look at my latest email and schedule a meeting in an 
empty slot in my calendar.`

const response = await client.messages.create({
  model: "claude-3-5-sonnet-20240620",
  messages: {role: "user", content: prompt},
  tools: tools
)

console.log(response)

We can clearly see, not only the reduction in code, but also the ability to spin up any agent and quickly give it access to the data and functionality the it needs to achieve the required functionality.

This changes our M X N integration problem into a much more scalable M + N problem. For every agent, M, and every integration N only M plus N connections need to be created.

Need to add another Agent, Gemini in Ruby? Only one additional connection (Gemini — MCP Server) needs to be made, and the new agent will automatically have access to all the tools.

MCP Framework

This is just a small sample of what the Framework can achieve and you’ve only see one aspect of it in tool use. It supports many other features such as prompts, resources, streamable responses and more.

Stay tuned for the next article for a deep dive into the framework.

MCP Examples

It’s good to look at some examples of MCP servers to get an idea of what is possible.

Fetch tool — Gives agents access fetch content from any webpage
Git — Adds the ability to access git repositories. Make commits, branches and PRs with your AI Agent!
Slack — Enable your agent to message your slack channels
Google Maps — Let your agent pull data from the maps database to find your next dinner destination.