What is Claude MCP | Full Feature List and 5-Step Connection Guide

What is MCP — The USB-C for AI, an Open Standard Protocol Connecting AI to External Systems

MCP (Model Context Protocol) is "a new open standard designed by Anthropic for connecting AI assistants to the systems where data lives" Source.

The official documentation defines it as follows:

"MCP is an open-source standard for connecting AI applications to external systems."

Source

MCP is often compared to a "USB-C port for AI." Just as USB-C standardized physical connections between devices, MCP standardizes how AI applications connect to external systems Source. With MCP, you can do things like:

• Let agents access Google Calendar or Notion to become more personalized assistants
• Have Claude Code generate entire web apps based on Figma designs
• Connect enterprise chatbots to multiple internal databases for chat-driven data analysis

Since its release on November 25, 2024, a wide range of clients beyond Claude — including ChatGPT, Visual Studio Code, and Cursor — have adopted it, making it the de facto ecosystem standard Source.

MCP is now an open-source project hosted by The Linux Foundation. The GitHub Organization is modelcontextprotocol (github.com/modelcontextprotocol), with contributors including not just Anthropic but also Google (Go SDK), Microsoft (C# SDK), and Spring (Java SDK) Source.

The 3 Components of MCP — Host / Client / Server

Based on the official documentation, the MCP architecture consists of three participants Source.

Component 1: MCP Host — The AI App Itself (Claude Desktop / Code / VS Code, etc.)

The AI application itself. It manages and coordinates one or more MCP clients. Claude Desktop, Claude Code, and Visual Studio Code are typical examples of hosts. The host creates one MCP client per MCP server it connects to.

Component 2: MCP Client — In-Host Component Supporting stdio + Streamable HTTP

A component within the host. It maintains the connection to MCP servers and retrieves context (tools, resources, prompts) to pass back to the host. It supports both stdio connections to local servers and Streamable HTTP connections to remote servers.

Component 3: MCP Server — Exposed Locally (Same Machine) or Remotely (External Infrastructure)

A program that provides context to MCP clients. There are "local MCP servers" that run on the same machine, and "remote MCP servers" that run on external infrastructure. Remote servers can handle multiple MCP clients simultaneously.

┌────────────────────────────────────────────────┐
│           MCP Host (AI Application)            │
│                                                │
│  ┌─────────────┐   ┌─────────────┐             │
│  │ MCP Client 1│   │ MCP Client 2│  ...        │
│  └──────┬──────┘   └──────┬──────┘             │
└─────────┼────────────────┼────────────────────┘
          │ Dedicated       │ Dedicated
          ▼                 ▼
   ┌────────────┐    ┌──────────────┐
   │ MCP Server │    │  MCP Server  │
   │  (Local)   │    │  (Remote)    │
   │ e.g. Git   │    │ e.g. Slack   │
   └────────────┘    └──────────────┘

Source: Diagram based on modelcontextprotocol.io — Architecture overview

The 2-Layer Protocol Structure — Data Layer (JSON-RPC 2.0) + Transport Layer (stdio / HTTP)

The MCP protocol is structured in two layers: a "data layer" and a "transport layer."

Source

The 3 Primitives Provided by Servers — Tools / Resources / Prompts

The capabilities an MCP server can provide to an MCP client are defined as three types of primitives Source.

Full Feature List — MCP Support Across All 6 Products: Claude.ai / Desktop / Mobile / Code / Cowork / SDK

The following reflects support status as of 2026-04-23, based on official documentation Source.

Key MCP Connectors — First-Party Integrations in the Claude.ai Official Directory

The following connectors are listed on Anthropic's official announcement page and repositories. For connectors not listed here, please refer to the official documentation of each service.

Claude.ai Connector Directory — First-Party Integrations Including Google Drive / GitHub / Notion

The Claude.ai official connector directory offers "first-party integrations" with the following services Source.

• Google Drive / Gmail / Google Calendar
• GitHub
• Slack
• Microsoft 365

Pre-Built Connectors at Launch — Initial Lineup When MCP Was Open-Sourced in 2024-11

The reference servers provided in the official repository at the time of MCP's announcement were as follows Source.

• Google Drive — Access to documents and files
• Slack — Read and write channels and messages
• GitHub — Repository operations and code review support
• Git — Operations on local Git repositories
• PostgreSQL — Database queries
• Puppeteer — Web browser automation

Current Official Reference Servers — modelcontextprotocol/servers Repository

As of April 2026, the following 7 reference servers are actively maintained in the official repository Source. Note that servers such as GitHub, Google Drive, and PostgreSQL have been moved to the archived repository (servers-archived).

At the time of writing, specific connectors such as QuickBooks and Zoom have not been confirmed in Anthropic's official documentation. Third parties may have published MCP servers for these services, but since they cannot be confirmed as official information, we recommend checking claude.com/docs/connectors/directory directly.

5 Connection Steps — Setting Up MCP Connectors in Claude.ai (Web)

Setup Steps for Claude.ai (Web) — 5 Steps: Settings → URL → OAuth → Add

The setup steps based on official documentation are as follows Source.

5 Steps for Free / Pro / Max Plans

1. Open Settings > Connectors (or Customize > Connectors)
2. Click Add custom connector or the + button
3. Enter the URL of the remote MCP server
4. Configure OAuth credentials as needed
5. Click Add to complete

Team / Enterprise Plans — Added for Organizations via Admin Settings by an Administrator

Administrators add organization-wide connectors in Admin settings > Connectors, and members connect individually via Settings > Connectors.

Enabling in Chat — Toggle ON/OFF Per Conversation via the + Button

Select Connectors from the + button in the chat input area to enable or disable connectors on a per-conversation basis Source.

Connection Limits by Plan — Free Allows 1, Pro and Above Allow Multiple

Source

How to Build a Custom MCP Server — Build Your Own in 4 Steps Using the Python / TypeScript SDK

MCP servers can be implemented using the official Python SDK or TypeScript SDK Source.

The official tutorial uses a two-tool server that returns weather information as an example, following these steps:

1. Install the SDK — Requires Python 3.10 or later and MCP SDK 1.2.0 or later
2. Define tools — Register functions as tools using the @mcp.tool() decorator
3. Start the server — Expose it via stdio or HTTP
4. Register with the client — Add the URL in Claude Desktop's config file or via Claude.ai's Settings > Connectors

Logging Caveat — Never Use print() with stdio; Always Write to stderr / logging

When using stdio transport, writing to stdout with print() will corrupt JSON-RPC messages. Output logs via standard error (sys.stderr) or a logging library instead Source.

# Correct logging for STDIO servers
import sys
import logging

# Bad: do not write to stdout
# print("Processing request")

# Good: write to stderr
print("Processing request", file=sys.stderr)

# Good: use the logging library
logging.info("Processing request")

Source: modelcontextprotocol.io — Build an MCP server

For a complete implementation example, refer to the official tutorial: modelcontextprotocol.io/docs/develop/build-server

Security & Privacy — OAuth Recommended, Declaration Required, ZDR Needs Verification

The following security-related information is documented in official sources.

Authentication — OAuth Recommended, Dynamic Client Registration (DCR) Supported

OAuth authentication is recommended for connecting to remote MCP servers. The following are available in Claude.ai Source.

• OAuth callback mechanism (Auth callback URL: https://claude.ai/api/mcp/auth_callback)
• Token refresh and revocation management
• Dynamic Client Registration (DCR)

Server-Side Declaration Requirements — Use readOnlyHint / destructiveHint to Help Claude Assess Risk

MCP servers are required to declare readOnlyHint (read-only flag) and destructiveHint (destructive operation flag) on their tools, allowing Claude to properly assess the risk of each tool call Source.

Connection Best Practices — Trusted Organizations Only, Verify Scopes, Monitor Behavior

Key points for this section:

• Only connect to servers from organizations you trust
• Always review the permission scopes requested before connecting
• Monitor for unexpected behavioral changes after connecting

Source

Zero Data Retention (ZDR) — Not Confirmed in Official Docs; Check Before Enterprise Use

Official Anthropic documentation confirming Zero Data Retention (ZDR) support for MCP connector usage has not been found at the time of writing. For data handling policies under the Enterprise plan, please refer to Anthropic's privacy policy.

MCP vs. Claude Plugins vs. Agent Skills — Protocol / App / Knowledge: 3 Distinct Layers

Here is a breakdown of how these relate to each other.

Think of MCP as "the USB-C standard itself," Claude Plugins as "official peripherals built using that standard," and Agent Skills as "user-configured shortcuts and macros." None of these replaces the others — they are designed to complement each other at their respective layers.

Sources (Primary Information)

The following primary sources were directly referenced in the creation of this article. Always check each link for the latest accurate information.

• Anthropic: Announcing Model Context Protocol
• modelcontextprotocol.io — Introduction
• modelcontextprotocol.io — Architecture overview
• modelcontextprotocol.io — Build an MCP server
• GitHub: modelcontextprotocol Organization
• GitHub: modelcontextprotocol/servers — Official Reference Servers
• Claude Docs — Connectors overview
• Claude Support — What are connectors?
• Claude Docs — Custom remote MCP
• Claude Docs — Building an MCP server for Claude