Anthropic's Official MCP Tutorial: From Protocol Principles to Production Deployment

What is MCP? Anthropic's Open-Source AI Context Protocol

MCP (Model Context Protocol) is an open protocol released by Anthropic in November 2024, designed to standardize how AI applications access external context. In simple terms, it defines how AI applications obtain the context information they need through tool calls and data resources.

To understand MCP's emergence, we need to place it within the broader context of AI Agent development. 2024 is widely considered the inaugural year of AI Agents, with major players (OpenAI, Google, Microsoft, etc.) all pushing AI to evolve from pure conversational models into intelligent agents capable of executing complex tasks. However, for Agents to truly be effective, they must be able to access external data and invoke external tools — this is the so-called "context problem." Before MCP, the industry already had Function Calling mechanisms, but they lacked cross-platform standardization, with each AI platform implementing them differently. MCP essentially establishes a standardized communication protocol layer on top of Function Calling, similar to how the USB protocol unified computer peripheral connections.

According to Ali Shopeik, Anthropic's Head of Technical Education, MCP was born from an internal project — the team discovered while expanding Claude Desktop that they needed AI to interact with local file systems and other external systems. After internally validating the protocol's versatility, they decided to publicly release the specification and open up development to the open-source community.

Key characteristics of MCP include:

• Model-agnostic: Not tied to any specific AI model; any LLM can use it
• Open standard: The specification is public, and the community can freely develop MCP services
• Client-server architecture: Clearly defines communication methods and responsibility separation

MCP Architecture Design: How Client and Server Collaborate

Basic Architecture Principles

MCP is based on a client-server architecture, where:

• MCP Client: Embedded within the AI application, responsible for communicating with MCP servers
• MCP Server: Provides three core capabilities — Tools, Resources, and Prompts

MCP's client-server architecture draws from the design philosophy of LSP (Language Server Protocol). LSP is a protocol developed by Microsoft for VS Code that decouples programming language intelligence features (such as code completion and go-to-definition) from the editor, allowing a single language server to serve multiple editors. MCP's communication layer is based on the JSON-RPC 2.0 protocol and supports two transport methods: stdio (standard input/output, suitable for local inter-process communication) and HTTP+SSE (Server-Sent Events, suitable for remote communication). This design allows MCP servers to run either as local processes or be deployed as remote services.

The advantage of this architecture lies in decoupling. AI applications don't need to directly integrate various external service APIs — they only need to communicate with servers through the unified MCP protocol. MCP servers handle the specific tool execution logic, encapsulating the complex integration work.

Three Core Capabilities Explained

The three types of capabilities provided by MCP servers each serve different design purposes:

• Tools: Functions that models can actively invoke, similar to function definitions in Function Calling, but managed and executed uniformly on the server side. For example, a GitHub MCP server might provide tools like "Create Issue" and "Submit PR."
• Resources: Similar to GET endpoints in REST APIs, providing structured or unstructured data for models to read, such as file contents, database records, etc. Resources are identified by URIs, and clients can request them on demand.
• Prompts: Predefined interaction templates that help users interact with domain-specific tools in optimal ways. For example, a code review MCP server might provide a "Review PR" prompt template that guides the model through a specific code review workflow.

The combination of these three makes it possible for MCP servers to fully encapsulate all AI interaction capabilities of an external service.

Practical Use Cases

Take building a research assistant Agent as an example. Suppose you want this Agent to:

1. Interact with GitHub repositories
2. Read notes from Google Drive
3. Generate summaries and save them to the local file system

Before MCP, developers needed to write custom API calls and tool definitions for each service. With MCP, you simply connect your Agent to the corresponding MCP servers (GitHub server, Google Drive server, file system server), and these servers provide standardized tool definitions and handle tool execution.

What AI Integration Pain Points Does MCP Solve?

In the past, connecting AI applications to external resources faced numerous challenges:

• Each service has different API specifications and authentication methods
• Tool definitions lack unified standards, making reuse difficult
• Developers need to write extensive glue code for each integration
• Integrations cannot be shared across different AI applications

Before MCP, developers primarily connected AI to external services through: direct API calls (requiring adapter code for each model), Tool abstractions from frameworks like LangChain/LlamaIndex (framework-bound, incompatible across frameworks), and OpenAI's Plugin/GPTs system (platform lock-in). MCP's key innovation is that it's a "protocol-level" standard, not bound to any specific framework or platform. This means an MCP server written in Go can be called by a Python client, and an MCP server developed for Cursor can equally be used in Claude Desktop, achieving true "develop once, use everywhere."

MCP solves these pain points through a standardized protocol. Once an MCP server is developed, it can be reused by any MCP-compatible AI application — whether it's Claude Desktop, a custom chatbot, or other third-party applications.

Since its release, the MCP ecosystem has grown rapidly, driven jointly by the open-source community and Anthropic's MCP team, with a large number of available MCP services emerging. As of mid-2025, officially maintained reference servers cover common services including file systems, GitHub, Google Drive, PostgreSQL, Slack, and more. Community-contributed servers cover even broader domains, including Notion, Linear, Jira, AWS, and others. On the client support side, beyond Claude Desktop, AI code editors like Cursor, Windsurf, and Zed, as well as development tools like Continue and Cline, all support MCP. Notably, OpenAI also announced MCP support in its Agents SDK in March 2025, signaling that MCP is evolving from Anthropic's unilateral initiative into an industry consensus.

Tutorial Learning Path: From Beginner to Remote Deployment

This course, co-developed by Anthropic and DeepLearning.AI, covers a complete path from beginner to advanced:

1. Understanding Protocol Details: Deep dive into the communication mechanisms of MCP's client-server architecture
2. Developing a Chatbot: Build an MCP-enabled chatbot application
3. Building MCP Servers: Develop and test your own MCP servers that provide tools, prompt templates, and resources
4. Connecting Third-Party Services: Extend functionality through trusted third-party MCP servers
5. Cross-Application Reuse: Connect MCP servers to other MCP applications like Claude Desktop
6. Remote Deployment: Learn how to deploy MCP servers remotely so more developers can use them

Why Developers Should Learn MCP Now

MCP represents an important trend in AI application integration — moving from fragmented custom integrations toward standardized, protocol-driven approaches. As AI Agents increasingly need to interact with the external world, a unified context acquisition standard becomes crucial.

For developers, mastering MCP means:

• Quickly integrating rich external capabilities into AI applications
• Developing servers that can be reused across the entire ecosystem
• Reducing the cost of maintaining multiple custom integrations

As an open standard led by Anthropic, MCP is gaining increasing community support and tool ecosystem growth — now is the perfect time to get involved.

Key Takeaways

• MCP is an open protocol released by Anthropic in November 2024 to standardize how AI applications access external context
• Based on a client-server architecture, MCP servers provide three core capabilities: tools, resources, and prompts
• MCP's communication layer is based on JSON-RPC 2.0, supporting both stdio and HTTP+SSE transport methods
• MCP is model-agnostic; a single MCP server can be reused by any AI application that supports the protocol
• The tutorial covers a complete learning path from protocol understanding, server development, and third-party connections to remote deployment
• The MCP ecosystem is jointly driven by the open-source community and Anthropic's team, has gained support from multiple parties including OpenAI, and is developing rapidly