AWS Builder Center
What Is MCP (Model Context Protocol)?

What Is MCP (Model Context Protocol)?

If you've spent any time around AI assistants recently, you've probably run into the term "MCP." It shows up in product docs, developer changelogs, and increasingly, in casual conversation among people building AI tools. But what is it, actually — and why does it matter?

The problem MCP was built to solve

AI models have gotten remarkably good at reasoning and generating text. But there's a catch: a model is only as useful as the information it can access. By default, a large language model knows nothing about your calendar, your company's internal wiki, your codebase, or the ticket you filed in Jira this morning. It's cut off from the live data that actually matters for most real work.
Before MCP, connecting an AI assistant to any of these systems meant building a custom, one-off integration. Want Claude to read from Google Drive? Build a connector. Want it to also read from Slack? Build another one. Every new data source meant more bespoke plumbing, and none of it was reusable across different AI tools. This made truly connected AI systems slow and expensive to build at scale.

Enter the Model Context Protocol

Anthropic introduced the Model Context Protocol as an open standard for exactly this problem: connecting AI assistants to the systems where data actually lives, including content repositories, business tools, and development environments. Instead of a thicket of custom integrations, MCP offers one universal protocol that any AI application can speak.
The architecture is straightforward and has two sides:
  • MCP servers expose a data source or tool — think Google Drive, Slack, GitHub, or a Postgres database — in a standard way.
  • MCP clients are the AI applications (like Claude) that connect to those servers to pull in context or take actions.
Because both sides speak the same protocol, a developer only needs to build a connector once, and it can then work with any MCP-compatible AI application, not just one specific product.

How it works in practice

When MCP launched, it shipped as three main pieces: an open specification and SDKs for developers to build against, local MCP server support baked into the Claude Desktop app, and an open-source repository of ready-made servers for common systems. Pre-built servers were made available for tools people already rely on daily, including Google Drive, Slack, GitHub, Git, Postgres, and browser automation via Puppeteer.
The connection is designed to be two-way: an AI assistant isn't just pulling read-only data, it can also be given the ability to take actions within connected systems, subject to whatever permissions the developer configures.

Real-world use cases

A few patterns emerged quickly among early adopters:
Enterprise knowledge access. Companies like Block integrated MCP so their internal AI systems could pull from real company data sources rather than working from a blank slate. Block's leadership framed open protocols like MCP as the connective tissue that lets AI move from novelty to genuinely useful infrastructure for agentic systems.
Software development. Coding-focused tools including Zed, Replit, Codeium, and Sourcegraph began working with MCP so AI coding agents could retrieve the relevant context around a task — the right files, the right repo history — and produce working code in fewer attempts. This is one of the clearest use cases: an AI that can see your actual codebase writes far more relevant code than one guessing from a prompt alone.
General-purpose assistants. For everyday users, MCP support in Claude Desktop meant being able to connect personal or work tools directly to a conversation — asking an assistant to check a Google Drive folder or search a Slack channel, without switching apps or copy-pasting content back and forth.

The architecture, piece by piece

Under the hood, MCP follows a client-server model with four distinct parts:
  • MCP host — the AI application itself, such as Claude Desktop or Claude Code. It coordinates everything and decides how retrieved context gets used.
  • MCP client — lives inside the host, one per server it connects to. Each client keeps a dedicated, one-to-one connection with a single server and handles the low-level protocol messaging.
  • MCP server — an external service that exposes capabilities to the AI application. Each server usually focuses on one integration point (a GitHub server for repository access, a Postgres server for database queries) and can expose three kinds of things: tools (actions the model can decide to call, like "delete a pod" or "search a database"), resources (data the app can read, like files or API responses), and prompts (reusable, templated interactions the user selects).
  • Transport layer — how the client and server actually communicate. MCP supports two main transports: stdio, which is fast and local, typically serving a single client per server on the same machine; and Streamable HTTP, which lets one remote server serve many clients at once, so it can be hosted anywhere and updated for everyone simultaneously. Underneath either transport, messages are exchanged using the JSON-RPC 2.0 format.
A single host can run multiple clients in parallel, each wired to a different server. That's what makes it possible to connect one AI assistant to GitHub, Slack, and a database at the same time, with each connection kept cleanly isolated from the others.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article