Last week, Anthropic released Model Context Protocol (MCP), an open source standard proposal for enabling communication between LLM-powered apps and services that can take actions and provide context. After a week of exploring the protocol, writing a server, and most importantly, using Claude with a variety of MCP tools, I’m very excited.

First, MCP Itself

MCP is an evolution of the function calling/tool use pattern that OpenAI started last year, though it’s, more complex. The main value is that it enables types of interactions between the model (“client” in MCP terminology) and the service (“server”).

Function calling/tool use is straight forward:

  1. Declare a set of tools that the model can use. Each tool has name, description, and an expected schema.
  2. During the conversation or interaction, the model makes a call on when to reach for tools (learned as part of its pre-training or system prompt).

That’s it. It’s extremely general so you can use it for pretty much whatever you want. Actions like “send a slack message” or “run SQL query” are obvious.

MCP adds more types of communication, including bi-directionally:

  • Tools - The synchronous call and response pattern of function calling
  • Resources - Content available on the server that the client can request. A tool’s actions might generate new content, and content can become asynchronously too.
  • Prompts - Pre-baked prompts that can start a client down a specific workflow that MCP server supports
  • Sampling - Lets the server ask the client to run completions on its behalf
  • Notifications - Server can alert client to changes proactively.
  • And more (details about the session including token context, ability to update progress, share error logging, etc)

This enables a much richer set of interactions between a client and the services it works with.

“Agentic Workflows”: Claude Does a Great Job

Agentic Workflow is a buzzword for using AI to power Zapier-style if-this-then-that automations. The reason it’s buzzy is that a model should be able to make autonomous decisions on when and how to use tools, rather than having all of those decisions made up front.

Though Claude itself doesn’t implement all of the MCP capabilities yet, it uses Tools and Resources very smoothly. Here’s a demo of the pre-built sqlite server doing analysis. Even when it runs into SQL errors, it can iterate based on the response.

It feels fluid and natural, if a bit slow at times. And being able to mix tools and artifacts is delightful. Yes, there’s some usability issues getting MCP servers set up right now, but it mostly works once you’re there.

The Value of Structure and the Death of Forms

If you watch closely on the sqlite demo, you can see one very interesting interaction that isn’t explicitly querying a database. Did you catch it? Claude saves an insight.

The sqlite server implementation is a little more advanced than others. In addition to the set of tools you’d expect for interacting with a db, it also has a tool to capture an insight and create an insights memo resource. The memo is trivial–an array of strings–but simply including that affordance of an append-insight tool is all that’s need to encourage Claude to start tracking them. Claude infers that an insight is an important concept to track in this context and that’s very useful for workflow designer.

Let’s say you wanted to use Claude as your personal trainer. Claude actually does pretty well at this, at least for a novice like myself. It can come up with a workout that gives me enough to look relatively focused at my local gym. But, outside a conversation, it doesn’t have any memory.

With the right set of affordances in an MCP server, this looks dramatically more valuable.

  • Use a Prompt to capture the process of doing an initial intake (ask me age/weight, my current goals. This is the exact intake a gym does now, with annoying paper/app forms.
  • Generate an initial workout based on the parameters, and then remember it.
  • Allow me to report my progress during my workout: What did I actually do. This is also what any number of workout tracker apps do, and they’re universally tedious to update. Instead an MCP tool lets Claude to log my progress.
    • Based on what I actually accomplish, Claude can identify where I’m weak and add that to its goals on my behalf.
  • Then each workout it could use the set of goals and log of history to generate a newer targeted one.

The Personal Trainer MCP provides a simple structure, Claude fills in the rest, and I spend zero time trying to type in weight vs reps into a tiny screen with sweaty fingers. What that append-insight tool makes obvious is that it only takes a light hint on “what to pay attention to” in order to get a model to work the flow. It already has an intuitive sense of the details to care about, that otherwise would be annoying fields in a form.

It’s hard not to come to the conclusion that every annoying form you interact with on the web today can go away, and with it, all the human time spent managing them. This isn’t a specific feature of the protocol, it just makes it a lot more obvious.

What’s Next

There’s a lot more to think about here over the coming weeks.

  • Mobile/cross-device - All of the above is hypothetical as Claude only supports desktop today.
  • Cross-model - There’s no reason the service context should be limited to a single model either. Of course your database will be shared. Sharing my gym history between Claude and Gemini so the latter can watch a video of my squats and give me feedback could be very interesting.
  • MCP & Anthropic - Ultimately it’s not obvious the open standard will drastically change the number of integrations as its alternative tool use is very simple. More than anything though, this seems like a play by Anthropic to win developer mindshare over OpenAI. So far it seems successful.