MCP and Anthropic Claude: How Claude Desktop, Claude Code, the Claude API, and the Agent SDK Use the Model Context Protocol

Anthropic didn’t just adopt MCP — they created it. The Model Context Protocol started as an internal Anthropic project, was open-sourced in November 2024, and grew into an industry standard — Anthropic reported over 97 million monthly SDK downloads across the Python and TypeScript SDKs as of December 2025; by the July 2026 spec revision, the protocol’s own maintainers put that figure at “close to half-a-billion downloads a month.” In December 2025, Anthropic donated MCP to the Agentic AI Foundation under the Linux Foundation, establishing open governance while remaining a platinum member and core maintainer.

Because MCP originated at Anthropic, Claude products have among the deepest MCP integrations of any AI platform. Claude Desktop shipped with local MCP server support on the day MCP itself launched, November 25, 2024 — making it the first consumer AI product to support MCP servers, since no other product could have supported the protocol before it existed. Claude Code treats MCP as a first-class extension mechanism. The Claude API now offers a native MCP Connector that handles server discovery and tool invocation without requiring developers to build their own MCP client. And Claude.ai’s web interface exposes MCP through the Connectors feature, bringing tool integration to the browser.

This guide covers every MCP integration surface across Anthropic’s products with configuration examples, SDK details, and architectural guidance. Our analysis draws on Anthropic’s official documentation, the MCP specification, SDK source code, community reports, and published research — we research and analyze rather than deploying these systems ourselves. Rob Nugen operates ChatForest; the site’s content is researched and written by AI.

Anthropic’s MCP Timeline

Understanding Anthropic’s MCP journey helps explain why their integration is the most mature in the industry:

• November 2024 — Anthropic open-sources the Model Context Protocol. Claude Desktop ships as the first consumer MCP client with stdio transport support.
• Early 2025 — The MCP ecosystem grows rapidly. Third-party MCP servers proliferate. Cursor, Windsurf, and other AI coding tools adopt MCP.
• March 2025 — OpenAI adopts MCP, validating it as an industry standard. Google and Microsoft follow shortly after.
• June 2025 — Anthropic launches Desktop Extensions (originally .dxt, later renamed .mcpb) for one-click MCP server installation in Claude Desktop.
• September 2025 — The official MCP Registry launches in preview. MCPB format replaces DXT (legacy files continue to work).
• November 2025 — The MCP specification’s third major revision lands, introducing Client ID Metadata Documents and mandatory PKCE S256 for OAuth 2.1.
• December 2025 — Anthropic donates MCP to the Agentic AI Foundation (AAIF) under the Linux Foundation. OpenAI and Block are co-founders.
• January 2026 — Anthropic launches Interactive Claude Apps, rendering live interfaces for Slack, Canva, Figma, Box, and Clay directly inside conversations, on top of the Integrations/Connectors feature (launched May 2025 with an initial 10 services).
• February 2026 — Claude API MCP Connector enters public beta (mcp-client-2025-11-20). Free and paid plan users get Connectors access. It remains in beta as of this writing.
• March 2026 — TypeScript SDK reaches v1.28.0. The 2026 MCP Roadmap is published, targeting stateless Streamable HTTP and enterprise auth work for the next spec cycle.
• June 2026 — Anthropic ships an Enterprise-Managed Authorization extension for zero-touch OAuth, and publishes beta SDKs for the next spec revision — going further than the March roadmap by removing the initialize handshake and protocol-level sessions entirely in favor of stateless, self-contained requests.
• July 28, 2026 — The MCP spec’s 2026-07-28 revision ships: the protocol is now stateless (no initialize handshake, no protocol-level session), Roots, Sampling, and Logging are deprecated (SEP-2577 — still functional for a one-year window, but signaled for eventual removal), and both official SDKs cut major versions — the Python SDK reaches mcp 2.0.0 and the TypeScript SDK splits into separate @modelcontextprotocol/client and @modelcontextprotocol/server packages at 2.0.0, alongside a final 1.30.0 release of the legacy @modelcontextprotocol/sdk package.

The Integration Surfaces

Anthropic’s MCP support spans six distinct surfaces, each designed for different workflows:

The key architectural distinction: Claude Desktop and Claude Code can run MCP servers as local child processes (stdio transport), giving them access to your filesystem, databases, and local tools. Claude.ai web and the API MCP Connector only support remote servers — Anthropic’s infrastructure connects to your publicly-exposed MCP server on your behalf. This has significant implications for what’s possible and what security considerations apply.

Claude Desktop: The Original MCP Client

Claude Desktop was the first consumer product to support MCP, and it remains the most full-featured MCP client for interactive use.

Configuration

MCP servers are configured in claude_desktop_config.json:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Access this file via Claude menu → Settings → Developer tab → “Edit Config.”

A typical configuration:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/Documents"],
      "env": {}
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
      }
    },
    "remote-server": {
      "url": "https://mcp.example.com/sse",
      "headers": {
        "Authorization": "Bearer token123"
      }
    }
  }
}

Each server entry supports:

• command + args — for local stdio servers launched as child processes
• url — for remote Streamable HTTP or SSE servers
• env — environment variables passed to local server processes
• headers — HTTP headers for remote server authentication

Claude Desktop includes a built-in Node.js runtime, so Node-based MCP servers work without a separate Node.js installation.

Supported Transports

• stdio (primary for local servers) — servers run as child processes, communicating over stdin/stdout. This is the most common configuration.
• Streamable HTTP (for remote servers) — the recommended remote transport, supporting bidirectional communication.
• SSE (legacy remote) — supported but deprecated in favor of Streamable HTTP.

Approval Flows

All MCP tool actions require explicit user approval. When Claude wants to use a tool, you see an approval popup showing the tool name and parameters. Options include:

• Allow once — approve this specific invocation
• Always approve — permanently approve this tool (per server)

MCP permissions are granular — each tool must be approved individually; there are no wildcards.

MCPB Desktop Extensions

For users who don’t want to edit JSON config files, Anthropic introduced Desktop Extensions — originally as .dxt files (June 2025), later renamed to .mcpb (MCP Bundle) in September 2025. Legacy .dxt files continue to work.

Installation is one-click: download an .mcpb file from desktopextensions.com → double-click → click “Install.”

An .mcpb file is a ZIP archive containing a manifest.json that declares the server’s configuration:

{
  "mcpb_version": "1.0",
  "name": "my-mcp-server",
  "version": "1.0.0",
  "description": "Does useful things",
  "author": { "name": "Developer Name" },
  "type": "node",
  "entry_point": "dist/index.js",
  "mcp_config": {
    "transport": "stdio"
  },
  "user_config": {
    "api_key": {
      "type": "string",
      "description": "Your API key",
      "required": true,
      "sensitive": true
    }
  }
}

Key MCPB features:

• Credential security — fields marked "sensitive": true are stored in the OS keychain, not in plaintext config files
• Template literals — ${user_config.api_key} in environment variables are replaced at runtime from keychain values
• Packaging toolchain — npx @anthropic-ai/mcpb init generates the manifest interactively; npx @anthropic-ai/mcpb pack validates and creates the archive
• Enterprise support — Group Policy/MDM for pre-installation, publisher blocklists, and private extension directories
• Three runtime types — node, python, and binary

Server Management UI

The “+” button at the bottom of the chat input → “Connectors” shows connected MCP servers and their available tools. The Developer settings panel displays connection status, server logs, and error details for debugging.

On Team and Enterprise plans, workspace owners can manage which desktop extensions are available to team members.

Claude Code: CLI-Native MCP Integration

Claude Code is Anthropic’s command-line AI coding agent. It treats MCP as a first-class extension mechanism — MCP tools appear alongside Claude Code’s built-in tools (file editing, terminal access, web search) and can be used in the same agentic workflow.

Configuration Methods

Claude Code offers three ways to configure MCP servers:

1. CLI commands (quickest):

# Add a local stdio server
claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /home/user/docs

# Add a remote HTTP server
claude mcp add --transport http my-api https://mcp.example.com/api

# List configured servers
claude mcp list

# Remove a server
claude mcp remove filesystem

2. Direct file editing (more control): Edit configuration files directly for complex setups with environment variables and headers.

3. Project .mcp.json (team sharing): Place an .mcp.json file in the project root. This is checked into version control so the whole team gets the same MCP servers:

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-server-postgres", "postgresql://localhost/mydb"]
    },
    "jira": {
      "type": "http",
      "url": "https://mcp.atlassian.com/jira",
      "headers": {
        "Authorization": "Bearer ${JIRA_TOKEN}"
      }
    }
  }
}

Configuration Scopes

Claude Code supports three configuration scopes with clear precedence:

Local scope takes precedence over project scope, which takes precedence over user scope. If a server is configured both locally and via a Claude.ai connector, the local config wins.

Environment Variable Expansion

.mcp.json supports environment variable expansion with ${VAR} and ${VAR:-default} syntax in command, args, env, url, and headers fields. This keeps secrets out of version control while allowing team-shared configurations.

Supported Transports

• stdio — for local server processes: claude mcp add --transport stdio <name> -- <command> [args...]
• Streamable HTTP (recommended for remote): claude mcp add --transport http <name> <url>
• SSE (deprecated): claude mcp add --transport sse <name> <url>

How MCP Tools Work in Claude Code

During a coding session, MCP tools integrate seamlessly with Claude Code’s built-in capabilities:

• Tool discovery — Claude Code discovers available tools from connected MCP servers at session start. It supports list_changed notifications for live capability refresh when servers add or remove tools.
• Unified tool use — MCP tools appear alongside built-in tools. Claude Code can use an MCP tool to query a database, then use its built-in file editor to update code based on the results.
• Permission controls — Allow, Ask, and Deny rules control which MCP tools Claude Code can use without manual approval. Configurable in settings files.
• Push messages — Servers declaring claude/channel capability can push messages into sessions (CI results, alerts, deployment status).
• Output limits — MCP tool output has a warning threshold at 10,000 tokens, configurable via MAX_MCP_OUTPUT_TOKENS.
• Timeouts — Startup timeout is configurable via MCP_TIMEOUT environment variable.
• OAuth — Remote servers requiring authentication are handled via the /mcp slash command.
• Status — The /mcp command within a session shows server connection status.

CLAUDE.md as Complementary Context

CLAUDE.md files provide project-specific instructions and context to Claude Code. They complement MCP by giving Claude knowledge about the project (coding conventions, architecture decisions, deployment procedures) while MCP provides tool access (database queries, API calls, file operations). Together, they let you configure a coding agent that knows your project and can act on it.

Claude API: The MCP Connector

The Claude API MCP Connector lets developers connect to remote MCP servers directly from the Messages API without implementing a separate MCP client. It entered public beta in February 2026 and remains in beta as of this writing.

How It Works

The API request includes two MCP-specific components:

1. mcp_servers — an array of server connection details (URL, name, authentication)
2. tools — includes mcp_toolset entries that configure which tools to enable from each server

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-opus-5",
    max_tokens=1024,
    mcp_servers=[
        {
            "type": "url",
            "url": "https://mcp.example.com/api",
            "name": "my-server",
            "authorization_token": "token123"
        }
    ],
    tools=[
        {
            "type": "mcp_toolset",
            "mcp_server_name": "my-server"
        }
    ],
    messages=[
        {"role": "user", "content": "List all open issues"}
    ],
    betas=["mcp-client-2025-11-20"]
)

(Field names verified against Anthropic’s current MCP Connector docs as of August 2026 — note the toolset field is mcp_server_name, not server_label, and the older tool_configuration object is deprecated in favor of default_config/configs on the toolset.)

Key Capabilities

• Multiple servers — connect to several MCP servers in a single API request
• Flexible tool filtering — enable all tools, allowlist specific tools, or denylist unwanted tools per server
• Deferred loading — defer_loading option for use with Tool Search, so tool descriptions aren’t sent to the model upfront
• OAuth authentication — Bearer token support for authenticated servers
• Cache control — cache control headers supported on toolsets for performance

Response Types

The MCP Connector introduces two new content block types in API responses:

• mcp_tool_use — when the model calls an MCP tool
• mcp_tool_result — the result returned by the MCP server

Limitations

• Tools only — MCP resources, prompts, and sampling are not supported through the Connector
• Remote servers only — must be publicly exposed via HTTPS (Streamable HTTP or SSE). Local stdio servers cannot connect directly
• Not available on Bedrock/Vertex — only supported on the direct Anthropic API
• Not eligible for Zero Data Retention (ZDR)
• Validation — every server in mcp_servers must be referenced by exactly one toolset, and each server can only be referenced by one toolset

SDK MCP Helpers

For developers managing their own MCP client connections instead of using the hosted Connector, the SDKs provide helper functions:

TypeScript SDK (requires both @anthropic-ai/sdk and @modelcontextprotocol/sdk):

import { mcpTools, mcpMessages, mcpResourceToContent } from "@anthropic-ai/sdk/helpers/beta/mcp";

// Convert MCP tools to Claude API tools
const tools = mcpTools(mcpToolList, mcpClient);

// Convert MCP prompt messages to API format
const messages = mcpMessages(mcpPromptMessages);

// Convert MCP resource to content block
const content = mcpResourceToContent(resource);

Python SDK (pip install "anthropic[mcp]", requires Python 3.10+):

from anthropic.lib.tools.mcp import async_mcp_tool, mcp_message

# Convert an MCP Tool + ClientSession into a Claude API tool
tool = await async_mcp_tool(mcp_tool_definition, mcp_session)

# Convert MCP prompt messages to API format
messages = mcp_message(prompt_message)

These helpers bridge any MCP server to the Claude API without the hosted Connector, giving developers full control over the MCP client lifecycle.

Claude.ai Web: Connectors

MCP is available in Claude’s web interface through the Connectors feature, bringing tool integration to the browser.

Availability

• Free plan — one custom connector
• Pro, Max, Team, Enterprise — unlimited connectors
• Feature remains in beta

Pre-Built Connectors

The Connectors Directory launched in May 2025 with an initial 10 services and has grown substantially since — we could not confirm an exact current count from Anthropic’s own materials, so treat any specific number you see elsewhere as a snapshot, not a stable fact. Since January 2026, some connectors support interactive apps — rendering live interfaces for Slack, Canva, Figma, Box, and Clay directly inside Claude conversations, with Salesforce support announced as coming soon.

Custom Connectors

Paid plan users can add custom connectors:

1. Go to Settings → Connectors → “Add custom connector”
2. Enter a name and MCP server URL
3. Configure OAuth credentials in Advanced settings if needed

Team and Enterprise

Workspace owners add connectors at the organization level via Organization settings → Connectors. Individual team members then authenticate through their personal Settings → Connectors page.

Per-Conversation Activation

Connectors are enabled per-conversation using the “+” button in the chat interface → “Connectors” to toggle specific integrations on or off. This gives you control over which tools are available in each conversation.

Security

Custom connectors connect to arbitrary, unverified services. Anthropic warns users to only connect to trusted servers. Pre-built connectors in the directory undergo Anthropic’s review process.

The Official MCP SDKs

Anthropic maintains the two official MCP SDKs that implement the full specification. These are the foundation on which MCP servers and clients are built.

TypeScript SDK

As of the 2026-07-28 spec revision, the TypeScript SDK is split into separate client and server packages, both at v2.0.0:

• Install: npm install @modelcontextprotocol/client and/or @modelcontextprotocol/server
• GitHub: modelcontextprotocol/typescript-sdk
• The pre-split single package, @modelcontextprotocol/sdk, received a final 1.x release (v1.30.0) on July 27, 2026 and remains installable for existing projects, but new development should target the v2 packages.

Key features:

• Full MCP specification implementation
• Server and client classes
• All transports (stdio, Streamable HTTP)
• Zod schema integration for type-safe tool definitions
• OAuth authentication support
• Conformance testing suite

Python SDK (mcp package)

• Latest version: 2.0.0 (July 28, 2026) — described by the maintainers as “a major rework of the SDK” to support the 2026-07-28 spec
• Install: pip install mcp or uv add "mcp[cli]"
• GitHub: modelcontextprotocol/python-sdk

Key features:

• Full MCP specification implementation
• FastMCP high-level API built into the SDK
• All transports (stdio, Streamable HTTP)
• Async-first design

FastMCP

FastMCP is a high-level Python framework for building MCP servers quickly. The core FastMCP API is built into the official Python SDK, while the standalone FastMCP package (maintained by Prefect/Jlowin) extends it further:

• FastMCP 3.0 (January 2026) added component versioning, granular authorization, OpenTelemetry instrumentation, multiple provider types (FileSystem, Skills, OpenAPI), hot reload, and custom providers
• Currently at version 3.4.7 (August 2026); a 4.0 beta is in progress
• FastMCP’s own README claims “some version of FastMCP powers 70% of MCP servers across all languages” and cites roughly a million downloads a day — this is FastMCP’s self-reported figure, not independently verified

Combined SDK Downloads

Anthropic reported over 97 million monthly SDK downloads across the Python and TypeScript SDKs as of December 2025. By the 2026-07-28 spec announcement, the protocol’s own maintainers described monthly SDK downloads as “close to half-a-billion” — roughly a 5x increase in seven months. (We could not independently verify a specific growth percentage for the earlier period; a “4,750% growth since launch” figure in an earlier version of this page had no traceable source and has been removed.)

Claude Agent SDK

The Claude Agent SDK gives developers programmatic access to the same tools, agent loop, and context management that power Claude Code. It’s available in both Python and TypeScript.

• Python: claude-agent-sdk (v0.2.136 on PyPI as of this writing)
• TypeScript: @anthropic-ai/claude-agent-sdk (v0.3.228 on npm as of this writing; developed in the claude-agent-sdk-typescript repo)

Both SDKs ship frequent releases — check the linked package pages for the current version before pinning a dependency.

Native MCP Integration

The Agent SDK supports MCP natively:

• In-process MCP servers — run an MCP server within the same process as your agent
• External MCP servers — connect to remote or local MCP servers using any supported transport
• Full MCP capabilities — tools, resources, and prompts are all accessible

This means you can build autonomous agents that leverage the full MCP ecosystem — connecting to databases, APIs, file systems, and any other MCP-enabled service — with the same agentic capabilities that Claude Code uses internally.

Anthropic’s Role in MCP Governance

The Agentic AI Foundation

On December 9, 2025, Anthropic donated MCP to the Agentic AI Foundation (AAIF) under the Linux Foundation. This was a deliberate move toward open governance — ensuring that no single company controls the protocol.

Co-founders: Anthropic, Block, and OpenAI

Platinum members: Amazon Web Services, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI

45 member organizations at launch per the Linux Foundation’s formation announcement: 8 Platinum, 17 Gold (including Adyen, Cisco, Datadog, Docker, IBM, JetBrains, Oracle, SAP, and Snowflake), and 20 Silver (including Hugging Face, Uber, and Elastic). (An earlier version of this page cited “100+ total members” from Anthropic’s own announcement — that figure does not appear in either Anthropic’s or the Linux Foundation’s launch materials and has been corrected.)

Three projects were contributed at launch:

1. Model Context Protocol (MCP) — by Anthropic
2. Goose — by Block (open-source AI agent)
3. AGENTS.md — by OpenAI

Governance Model

The AAIF Governing Board handles strategic decisions, budget, and member recruitment. Individual projects like MCP maintain full technical autonomy — maintainers continue to control the specification, review contributions, and make technical decisions independently. This is the standard Linux Foundation model (similar to how Kubernetes operates under the CNCF).

MCP Dev Summit

The first MCP Dev Summit North America took place April 2–3, 2026 in New York City, featuring 95+ sessions from Anthropic, OpenAI, Microsoft, Docker, Bloomberg, and major enterprise adopters. Key topics included SDK V2 roadmap, authentication standardization, and cross-platform interoperability.

The 2026 MCP Roadmap

Anthropic published the 2026 MCP Roadmap on March 9, 2026, outlining four priority areas. Update, August 2026: the roadmap’s transport-scalability goal shipped, but went further than originally planned — the 2026-07-28 spec revision didn’t just make Streamable HTTP support stateless scaling, it removed the initialize handshake and protocol-level sessions from the protocol entirely, replacing them with stateless, self-contained requests and a new Multi Round-Trip Requests (MRTR) mechanism. The roadmap items below are preserved as a historical snapshot of what Anthropic was planning as of March 2026:

1. Transport Evolution and Scalability

• Evolving Streamable HTTP for stateless horizontal scaling (no sticky sessions or distributed stores)
• Session creation, resumption, and migration for transparent server restarts and scale-out
• A cookie-like mechanism being explored to decouple session state from transport
• Server Cards — a .well-known metadata format for capability discovery without connecting
• No new official transports this cycle

2. Agent Communication

• Refining the Tasks primitive (SEP-1686) for managing long-running operations
• Retry semantics for transient failures
• Expiry policies for result retention

3. Governance Maturation

• Documented contributor ladder
• Delegation model allowing Working Groups to accept domain-specific SEPs
• Reducing Core Maintainer bottlenecks

4. Enterprise Readiness

• Audit trails, SSO-integrated authentication, gateway behavior, configuration portability
• Prioritizing extensions over core spec changes
• Security SEPs: DPoP (SEP-1932) and Workload Identity Federation (SEP-1933)

Timeline (as originally stated in March 2026): the goal was to finalize SEPs in Q1 2026 for inclusion in the next spec release, tentatively slated for June 2026. In practice, beta SDKs for the next revision shipped June 29, 2026 and the finished 2026-07-28 spec landed about a month after the original target — see the Anthropic MCP Timeline above and the current spec for what actually shipped.

Choosing the Right Integration Point

For Individual Developers

Start with Claude Desktop if you want to try MCP servers interactively. Install servers from desktopextensions.com with one click, or configure custom servers in claude_desktop_config.json. This is the lowest-friction way to experience MCP.

Use Claude Code if you’re a developer who works in the terminal. Claude Code’s MCP integration lets you extend your AI coding agent with project-specific tools — database access, API clients, deployment tools — through a simple .mcp.json file that the whole team can share.

For Application Developers

Use the Claude API MCP Connector if you want the simplest path to connecting Claude to remote MCP servers in production. Anthropic manages the MCP client connection — you just provide the server URL and authentication. The trade-off: tools only (no resources or prompts), and remote servers must be publicly accessible.

Use the SDK MCP helpers if you need full control over the MCP client lifecycle, want to connect to local stdio servers, or need MCP capabilities beyond tools (resources, prompts). You manage the MCP connection yourself and bridge it to the Claude API through the helper functions.

Use the Claude Agent SDK if you’re building autonomous agents that need the same capabilities as Claude Code — agentic loops, tool use, context management — with native MCP support. This is the right choice for production agent systems.

For MCP Server Builders

Use the TypeScript SDK (@modelcontextprotocol/sdk) or Python SDK (mcp) to build MCP servers. For Python, the built-in FastMCP API provides a high-level decorator-based interface for rapid development:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-server")

@mcp.tool()
def search_docs(query: str) -> str:
    """Search documentation for relevant information."""
    # Your implementation here
    return results

For distribution, consider MCPB packaging for Claude Desktop users, npm/PyPI for developers, or Docker for enterprise deployments.

Comparison: Anthropic vs. OpenAI MCP Integration

For developers choosing between platforms or building cross-platform MCP servers, here’s how Anthropic’s MCP support compares to OpenAI’s:

Both platforms now offer comprehensive MCP support. Anthropic’s advantage is depth and maturity — they’ve been iterating on MCP integration since November 2024. OpenAI’s advantage is breadth — their Agents SDK and Responses API reached general availability faster.

Security Considerations

MCP integration across Claude products raises several security considerations:

Local Servers (Desktop + Code)

• Process isolation — stdio servers run as child processes with the same permissions as the parent application. A compromised server has access to everything the user does.
• Config file security — claude_desktop_config.json and .mcp.json may contain API keys and tokens. MCPB’s keychain integration addresses this for Desktop Extensions, but manual configurations still risk plaintext secrets.
• Supply chain — installing MCP servers via npm/pip carries the same supply chain risks as any package installation. Prefer servers from verified publishers and the official registry.

Remote Servers (API Connector + Web Connectors)

• Data exposure — remote MCP servers receive the context of your conversation. Only connect to servers you trust.
• Authentication — use OAuth 2.1 or Bearer tokens for remote server authentication. See our MCP Authentication & OAuth 2.1 guide for details.
• Network security — remote servers must be exposed over HTTPS. Ensure TLS is properly configured.

Team Environments

• Project .mcp.json — servers in project config files are shared with the team. Claude Code prompts for approval before using project-scoped servers, preventing supply chain attacks through version control.
• Enterprise controls — Team and Enterprise plans support managed connector policies, publisher blocklists, and private extension directories.

For a deeper dive into MCP security, see our guides on MCP server security and MCP attack vectors and defense.

What’s Next

MCP is Anthropic’s bet on an open standard for AI tool integration, and they’re backing it with deep integration across every product. The June 2026 spec release — with stateless HTTP, Server Cards, and enhanced agent communication — will shape the next phase. The Agentic AI Foundation’s governance ensures that MCP’s evolution reflects the needs of the broader ecosystem, not just one company.

For developers building on Claude, MCP is already the primary extension mechanism. Whether you’re connecting Claude Desktop to a local database, giving Claude Code access to your deployment pipeline, or building production agents with the Claude API, MCP provides the standard interface. The question isn’t whether to adopt MCP — it’s which integration point fits your workflow.

Related guides:

• What Is MCP? — Protocol fundamentals
• MCP and OpenAI — OpenAI’s MCP integration for comparison
• Writing Effective CLAUDE.md Files — Complementary context for Claude Code
• MCP Server Packaging & Distribution — Publishing servers for Claude users
• MCP Authentication & OAuth 2.1 — Security for remote MCP servers
• MCP Server Security — Hardening MCP deployments
• MCP Clients Comparison — How Claude compares to other MCP clients
• Building MCP Clients — Building your own MCP client
• MCP Server Frameworks & SDKs — Choosing the right SDK
• Bluesky Attie — Claude powers Bluesky’s AI app for vibe-coding custom social feeds
• Claude Code Overtakes GitHub Copilot — How Claude Code hit 41% market share and $2.5B revenue in under a year
• Claude Cowork — Enterprise AI Agent Platform — Cowork extends Claude’s MCP integration to non-technical workers via plugin marketplaces and 12 new connectors
• Claude Platform on AWS vs Bedrock — Anthropic’s native API through your AWS account: day-one feature parity, IAM auth, and the key compliance trade-offs vs Bedrock (GA May 2026)