Introduction
Nearly two years after Anthropic Launches Open-Source AI Connection Protocol went live on November 25, 2024, the standard now anchors most production AI systems. The Python and TypeScript SDKs together reached roughly 97 million monthly downloads as of March 2026. Public server registries hold more than 10,000 entries, and over 300 clients speak the protocol. OpenAI, Google, Microsoft, and Cloudflare all ship native support in 2026. Governance has moved to the Linux Foundation under neutral stewardship. This guide walks through what the model context protocol integration explained is and where it is headed. It also covers the key steps engineering leads should ship in the next ninety days.
Quick Answers About Anthropic’s Open-Source AI Connection Protocol
What is the Anthropic open-source AI connection protocol?
It is an open standard called the Model Context Protocol, launched by Anthropic on November 25, 2024. It lets AI models call external data sources and tools through a shared client server interface.
Why does the protocol matter in 2026?
It replaced custom per-model connectors with one shared standard across vendors. OpenAI, Google, and Microsoft all ship native support, and public registries now list more than 10,000 servers.
Is MCP safe to run in production?
MCP is safe when teams add authentication, scoped tool allowlists, and prompt injection filters. Akamai published six attack surface findings on June 25, 2026, and gateways are now default.
Key Takeaways on MCP in 2026
- Anthropic launched the open-source Model Context Protocol on November 25, 2024, and donated it to the Agentic AI Foundation under the Linux Foundation on December 9, 2025.
- By March 2026, the Python and TypeScript SDKs saw 97 million monthly downloads, and public registries listed more than 10,000 MCP servers across 300 compatible clients.
- The July 28, 2026 specification removed session handshakes, moved protocol metadata into a signed
_metafield, and added routing headers that fit standard load balancers. - Akamai researchers published six new attack surface findings on June 25, 2026, so every production rollout now pairs an MCP gateway with strict auth, allowlists, and prompt injection filtering.
Table of contents
- Introduction
- Quick Answers About Anthropic’s Open-Source AI Connection Protocol
- Key Takeaways on MCP in 2026
- What Is Anthropic’s Open-Source AI Connection Protocol
- The N by M Integration Problem MCP Was Built to Solve
- Inside the Protocol: Hosts, Clients, and Servers
- The Transport Layer: JSON-RPC, stdio, and Streamable HTTP
- SDK Coverage Across Eleven Languages
- Reference Servers at Launch and the Early Community
- How Anthropic Launches Open-Source AI Connection Protocol Spread Across the Industry
- The 2025 Specification Updates That Enabled Enterprise Use
- How MCP Works Side by Side With Function Calling
- Core Use Cases Teams Are Already Shipping in Production
- Enterprise Implementation Patterns for Deploying MCP Safely
- Security Risks and the June 2026 Akamai Findings
- Ethics, Trust, and the Open Governance Question
- The Future After Anthropic Launches Open-Source AI Connection Protocol Through 2027
- Common Mistakes Teams Make With MCP in Their First Six Months
- Measuring MCP Success Beyond Install Counts
- A Practical Rollout Plan for the Next Ninety Days
- Key Insights on the Model Context Protocol in 2026
- MCP vs Function Calling vs Legacy Plug-ins Comparison
- Real-World Examples of the Open-Source AI Connection Protocol in Action
- Case Studies on the Open-Source AI Connection Protocol in Production
- Frequently Asked Questions on Anthropic’s Open-Source AI Connection Protocol
What Is Anthropic’s Open-Source AI Connection Protocol
Anthropic Launches Open-Source AI Connection Protocol, officially the Model Context Protocol, as a shared JSON-RPC standard. It lets any AI model talk to external tools and data through a common client server interface.
MCP rollout impact estimator
Model how an MCP rollout translates to engineer hours saved and tool call volume. Numbers are directional and based on 2026 adoption data.
75
6
Pilot
Weekly hours saved
450
Assumes 6 hours saved per engineer per week at full engagement.
Model baseline: WorkOS, March 2026, 97M monthly SDK downloads; 10,000+ public MCP servers across registries.
The N by M Integration Problem MCP Was Built to Solve
Before MCP, every AI vendor shipped its own tool-calling format for integrations. Every data provider wrote its own connector for each one of those vendors. Anthropic described this as the N by M problem, where N models times M data sources produced an exponential maintenance burden. A customer with four models and twenty data sources ended up with eighty bespoke integrations. Each one followed a different schema, authentication flow, and error contract. The scale alone pushed teams to pick one model and ignore everything else, which locked product roadmaps.
The protocol collapses that matrix into a single shared surface that any client and any server can speak. One MCP server for a database serves Claude, ChatGPT, Gemini, and Cursor alike. The server owner writes the integration once rather than once per vendor. On the model side, a client library handles tool discovery, schema negotiation, and transport. Model vendors do not duplicate work for every new data source they want to reach. The approach is modeled on the Language Server Protocol that reshaped IDE integrations a decade earlier.
The payoff is not only engineering time saved for one team. Shared standards let model vendors compete on model quality rather than lock-in. They also let platforms route a request to the model that fits each tool call. The Anthropic unveils autonomous AI agents story from 2024 hinted at why Anthropic cared enough to open-source the plumbing. An autonomous agent needs dozens of tool connections, and no single vendor can keep up with that catalog alone. Making the catalog open turned every third-party developer into a potential contributor rather than a competitor.
Inside the Protocol: Hosts, Clients, and Servers
Building on that foundation, MCP defines three roles that any implementation has to fill. The host is the application the user sees, such as Claude Desktop, Cursor, or a custom agent. The client is a thin component the host spins up for each server it wants to talk to. It handles the JSON-RPC messaging between the host and each configured server. The server exposes the actual tools, resources, and prompts for the model to call. Servers run locally on the user’s machine or remotely behind an HTTPS endpoint.
The host creates one client per server rather than multiplexing a shared client across all servers. This design keeps blast radius small when any single server behaves badly or ships a bug. A buggy or malicious server cannot see traffic headed to another server through the same client. Clients maintain their own capability negotiation and their own authorization scope at runtime. That isolation is what makes it safe to run both a trusted internal server and a fresh community server. Teams can mix sources in one host without cross-contamination between them.
Servers expose three primitives in the current MCP specification for teams to use. Tools are callable actions with a schema the model can read before invoking them. Resources are read-only context such as files or FAQ entries pulled into the prompt on request. Prompts are reusable templates the host can offer the user as named commands. The pattern is intentionally narrow to keep implementations predictable across different vendors. A protocol that tries to express every possible AI integration ends up a lowest common denominator mess.
The flow during a call looks straightforward on paper and in practice. The client lists tools from the server as a first step after connecting. The host then passes those descriptions to the LLM alongside the user’s message. The model decides to call a tool, and the client forwards the call to the server. The server executes the action and returns a structured result to the client. The host owns the orchestration logic for parallel runs, user confirmation, and retries.
The Transport Layer: JSON-RPC, stdio, and Streamable HTTP
Beyond the role split, the protocol specifies how messages travel between client and server. All MCP traffic uses JSON-RPC 2.0 as the shared wire format on every transport. That choice lets both sides parse messages with existing libraries on constrained channels. At launch, servers used stdio transport, meaning the host spawned a server as a local subprocess. The subprocess traded JSON-RPC messages across standard input and output with the host. That design was easy to implement and fine for local development, but it did not scale to cloud deployments.
The March 26, 2025 specification added Streamable HTTP transport for enterprise-grade cloud rollouts. Servers now run as long-lived HTTP endpoints that handle many clients at once. The 2025-03-26 update also added an OAuth 2.1 authorization framework specification for scoped tokens. Hosts could enforce per-user scopes without inventing an authorization story from scratch. These two changes made the leap from desktop proofs of concept to enterprise rollouts possible. The HTTP path fits standard load balancer, API gateway, and identity provider stacks that security teams already approved.
The July 28, 2026 specification rewrote the transport contract again for scale. Stateless design moved the initialize handshake and the session identifier into a signed _meta field. That field travels with every request so load balancers can route traffic without sticky sessions. New Mcp-Method and Mcp-Name headers let gateways route and filter requests before they reach the server. Discovery responses picked up HTTP-style caching fields that cut repeated schema fetches by an order of magnitude. The design shifts MCP from a stateful subprotocol into a REST-friendly surface, which SerpApi’s state of MCP in H1 2026 analysis covers in detail.
SDK Coverage Across Eleven Languages
Turning to developer experience, SDKs now cover the eleven languages most engineering teams actually use. Anthropic shipped Python, TypeScript, C#, and Java at launch for the first wave. Community maintainers added Kotlin, Go, PHP, Perl, Ruby, Rust, and Swift during 2025 to extend coverage. The Python and TypeScript libraries drive the download numbers because they fit the dominant AI stacks. The TypeScript SDK repository on GitHub sits in the top one hundred most-starred TypeScript projects. That ranking signals the sustained interest a protocol needs to survive its first adoption curve intact.
The quality of the SDKs varies more than the raw headcount of eleven languages suggests. The Python and TypeScript libraries ship with first-class async support and type-safe tool definitions out of the box. Teams can build production servers in a few hundred lines using those libraries. The newer SDKs lag on async transports and OAuth support, which affects performance-critical workloads. Small teams still write Go or Rust servers in a weekend when the Python surface is too slow. The gap matters for Microsoft Agent Framework vs OpenAI Agents SDK comparisons during platform selection.
Reference Servers at Launch and the Early Community
Shifting focus to the ecosystem, Anthropic seeded the open-source project with reference servers from day one. The launch set covered Google Drive, Slack, GitHub, Git, Postgres, and Puppeteer as examples. Those six spanned document stores, chat systems, code hosting, version control, databases, and headless browsers. Each reference server shipped as readable code with tests, so community maintainers could copy the pattern. Developers used the examples to avoid guessing at best practices for their own servers. The approach mirrored what the Language Server Protocol did a decade earlier with its own reference set.
Community growth beat every reasonable expectation after Anthropic Launches Open-Source AI Connection Protocol seeding. Public registries listed more than one thousand community servers by February 2025 across major catalogs. The count passed 5,800 by April 2025 according to the one year of Model Context Protocol dev.to retrospective. Block, Apollo, Zed, Replit, Codeium, and Sourcegraph adopted the protocol in the first few weeks after launch. The early adopters gave downstream developers a reason to invest in building their own servers. The curve matched what engineers saw with open-source tool for smarter AI coding agents patterns.
The quality of the early community output set the tone for the whole MCP catalog going forward. Server authors wrote clear documentation, published semver release notes, and open-sourced the test harness most of them used. That made it easy to evaluate a server before adopting it in a production stack. The maturity curve was faster than most protocol launches, because the reference servers acted as calibration. Claude Desktop shipped MCP support within weeks, so there was a real host to point servers at. The combination of calibration and a working host accelerated adoption more than any marketing campaign could have.
How Anthropic Launches Open-Source AI Connection Protocol Spread Across the Industry
Looking at adoption patterns, Anthropic Launches Open-Source AI Connection Protocol became a de facto standard within six months. OpenAI formally adopted MCP on March 26, 2025, with Sam Altman announcing support across the Agents SDK. The announcement promised ChatGPT desktop integration shortly after the initial Agents SDK work. Google DeepMind CEO Demis Hassabis confirmed Gemini MCP support in April 2025 at a Google event. Microsoft Copilot Studio reached general availability with MCP integration in May 2025 of that year. Windows 11 shipped as what Microsoft called an agentic operating system with native MCP support. Four of the five biggest AI vendors signed on inside half a year, which signals a shared pain solved.
Infrastructure vendors followed close behind the model vendors with their own MCP integrations. Docker launched the MCP Catalog and MCP Toolkit on April 22, 2025 with 100 verified servers. Partners at launch included Stripe, Elastic, Neo4j, Heroku, Pulumi, Grafana Labs, Kong, New Relic, and Continue.dev. Cloudflare added managed MCP server hosting with its usual edge network model for simple deployments. The Cloudflare MCP announcement on the official engineering blog described an agent-ready endpoint path. Those managed hosting moves meant developers could ship a server without owning the ops burden.
Governance moved from Anthropic to a neutral foundation during 2025 to answer competitor concerns. On December 9, 2025, Anthropic donated MCP to the Agentic AI Foundation under the Linux Foundation. Block and OpenAI joined as co-founders, with AWS, Google, Microsoft, Cloudflare, and Bloomberg as platinum supporting members. The handoff removed the lingering question of whether a competitor would hedge away from a vendor-owned protocol. It also opened the door for enterprise CIOs who required neutral governance before approving a hard dependency. The Linux Foundation press release announcing the Agentic AI Foundation framed it as a broader shift.
The spread across clients deepened through 2026 with new extensions beyond raw tool access. The MCP Apps extension launched on January 26, 2026, co-developed by Anthropic and OpenAI jointly. It enables servers to render sandboxed UI inside hosts such as Claude, ChatGPT, Goose, and VS Code. Figma, Hex, Monday, Amplitude, Asana, Box, Canva, and Clay were launch partners for MCP Apps. The partner list signaled that product companies see the protocol as a distribution channel beyond developer tools. The why tech insiders love Claude AI dynamic was always partly about the surface area MCP opened up. The 2026 extensions widened that surface considerably across both product and infrastructure companies.
The 2025 Specification Updates That Enabled Enterprise Use
Beyond initial adoption, two 2025 specification updates turned MCP from a hobby protocol into enterprise plumbing. The March 26, 2025 revision replaced stdio-only transport with Streamable HTTP for remote endpoints. Servers could run as managed HTTPS services behind standard reverse proxies after that change. The same revision added OAuth 2.1 as the authorization framework for scoped user tokens. Security teams gained a way to issue scoped tokens and audit who called what tool. Those two changes mapped onto the API gateway and identity stacks enterprises already ran in production.
The July 28, 2026 specification went further by making the protocol stateless where it had been session-oriented. The initialize handshake and the Mcp-Session-Id header both disappeared from the required flow. Protocol version, client info, and capability flags now ride inside a signed _meta field on every request. Required Mcp-Method and Mcp-Name headers let gateways route traffic without parsing the JSON-RPC body contents. Discovery responses picked up HTTP cache headers so a client can skip repeated schema fetches. Roots, Sampling, and Logging were marked deprecated with a twelve-month removal window for migrations. The MCP 2026-07-28 specification published on the official site remains the canonical reference.
How MCP Works Side by Side With Function Calling
Stepping back from spec history, teams often ask whether MCP replaces function calling in production. The two actually solve different parts of the same problem for developers building AI apps. Function calling is a model feature that converts natural language into a structured call matching a schema. MCP is a protocol that defines how any model can discover tools across a client-server boundary. Function calling describes what the model does with its structured output format each turn. MCP describes how the application and the data source talk through a transport and authorization layer.
The practical difference shows up most clearly in model portability across different vendors over time. A team writing tools as OpenAI function schemas has to translate those schemas when they add Claude. The same translation happens again when they add Gemini or an on-prem model later. A team writing tools as MCP servers writes them once and reuses them across hosts. The host maps the server’s tool list to each model’s native function-calling format at call time. The xmcp blog’s MCP vs OpenAI function calling comparison walks through exact code examples side by side.
The combination lets teams keep the fine-grained model-level tool semantics they want while swapping backends freely. In a typical production flow, the host receives a user turn through its chat interface. The LLM emits a function call in its native format for the host to interpret. The host maps that call onto the matching MCP tool from its catalog of connected servers. The MCP client forwards the invocation to the server using JSON-RPC over HTTP or stdio. Nothing in that path forces a single model vendor, which is the entire point of the design. The AI coding agents and live API docs pattern shows how the two layers compose in practice.
Core Use Cases Teams Are Already Shipping in Production
Among the real production deployments after Anthropic Launches Open-Source AI Connection Protocol spread, developer tools lead by a wide margin. Code editors such as Cursor, Zed, Windsurf, and VS Code use MCP servers for assistant context. Assistants read repositories, run tests, inspect database schemas, call linters, and open pull requests through MCP. Users do not need to leave the editor to invoke those actions during a coding session. The OpenAI vs Claude Code coding war turned MCP into one of the main battlegrounds between vendors. Developer deployments tend to be high-trust environments where the user approves each call before it runs.
Customer support automation is the second major pattern teams ship with MCP in enterprise settings. Teams expose CRM, ticketing, knowledge base, and billing data through MCP servers for agent assistants. The assistant unifies context for the human agent rather than forcing a tab across six consoles. CData’s enterprise MCP roadmap for 2026 reports that only six percent of organizations say they are satisfied. The low satisfaction rate reflects the data integration pain MCP is positioned to address directly. Deployment patterns range from read-only summarization in production to full write access on sandboxed accounts.
Beyond engineering and support, finance, legal, and operations teams increasingly ship MCP servers for internal workflows. Audit teams use MCP to query the general ledger and produce variance explanations with provenance preserved. Legal operations teams expose contract repositories so review assistants can flag off-standard clauses with human escalation. Operations teams wire MCP into supply chain systems to pull inventory data and trigger stockout alerts. Each pattern uses the same primitives but tunes authorization scope and tool allowlist to the risk profile. The building custom AI agents for workflow automation playbook treats scoping as a required design step.
Enterprise Implementation Patterns for Deploying MCP Safely
Turning to deployment architecture after Anthropic Launches Open-Source AI Connection Protocol matured, almost every enterprise rollout sits behind an MCP gateway. Direct client-to-server connections are now the exception rather than the rule in enterprise settings. The gateway inspects traffic, enforces authentication, caches schemas, applies rate limits, and writes an audit log. Security teams can replay the audit log to investigate incidents or verify compliance evidence. Header-level routing from the July 28, 2026 specification pays off at this layer during inspection. The pattern mirrors the API gateway rollout that firms did a decade ago for traditional web services.
Authentication is the single highest-leverage control for enterprise MCP, and OAuth 2.1 is now the default. Hosts obtain scoped tokens on behalf of the human user from the identity provider at runtime. Servers verify those tokens against the identity provider before executing any requested tool call. The token audience ensures a token issued for one server cannot be replayed against another server. Teams that want finer control add attribute-based access control at the gateway for named flows. The Microsoft Agent 365 enterprise agent governance rollout shows device-trust pairing with OAuth.
Catalogs and allowlists complete the picture for mature enterprise rollouts of MCP in production. Even a well-authenticated agent should not have access to every registered server across the catalog. Most firms maintain an internal catalog that marks each server as approved, pilot, or blocked for use. The Docker MCP Catalog pattern launched April 22, 2025 with 100 verified servers gave firms a starting point. Image Access Management and Registry Access Management from Docker Business handle the enterprise-grade controls on top. Open-source teams replicate the same gates with a signed-manifest flow and a cosign verification step in CI.
Observability closes the loop for teams running MCP at any meaningful scale in production. Every production rollout logs the server, tool, user, request shape, response size, and latency per call. Teams route those logs into a SIEM or an existing observability stack for correlation and alerting. Teams that treat MCP calls as privileged actions get the audit trail they need for SOC 2 evidence. They also get the baseline needed to spot anomalies when a server starts behaving differently from before. The Truefoundry MCP security risks and best practices guide covers a reference logging schema.
Security Risks and the June 2026 Akamai Findings
Beyond the base patterns, security researchers have mapped the MCP attack surface in detail over 2025 and 2026. Akamai researchers Maxim Zavodchik, Segev Fogel, and Gal Meiri published six findings on June 25, 2026. Each finding is keyed to a specific feature of the 2026-07-28 specification released that summer. Session and state handling flaws can let predictable identifiers hijack another user’s workflow entirely. Unsigned _meta objects can forge privilege tags such as administrator roles for cross-tenant access. Header and body desync between Mcp-Method and the JSON-RPC body can bypass gateway controls silently. The findings do not list CVE numbers, and verification steps the spec prescribes sit at the implementation layer.
Two additional findings are specific to newer MCP features introduced in the 2026-07-28 revision. Mapping a tool argument into an HTTP header via x-mcp-header can leak secrets to proxies and logs. API keys, tokens, and personal data all fit in that exposure category for most teams running MCP. Stored cross-site scripting through MCP Apps can run malicious HTML in another user’s sandboxed iframe. Phishing and data theft remain possible even inside the sandbox when attacker content is stored. The sixth finding describes hit-and-run abuse, where a single request kicks off an expensive long-running task. The attacker disconnects before paying, creating a denial-of-service pathway on the server side at scale.
Prompt injection and tool poisoning remain the oldest and still the most common MCP risks in 2026. The protocol lets servers describe tools in free-form text that the model reads at discovery time. A malicious description can smuggle instructions that trick the model into exfiltrating data through another tool. CloudTweaks reported that untreated MCP stacks carry a 92 percent exploit probability under adversarial testing. The securing the age of agentic AI framework combines allowlists and prompt injection classifiers. The AI agent flaw opens an email attack vector incident shows how a single misconfigured server can cause harm.
Ethics, Trust, and the Open Governance Question
Shifting focus to governance, the ethical argument for MCP rests on who gets to set the rules. A closed-source protocol owned by one vendor can lock the broader market into decisions made alone. The handoff from Anthropic to the Agentic AI Foundation on December 9, 2025 answered the loudest critique. Anthropic retains influence through the foundation’s technical steering committee for the near term. Strategic decisions now require coordination across Block, OpenAI, AWS, Google, Microsoft, Cloudflare, and Bloomberg members. The structure mirrors how Linux, Kubernetes, and gRPC moved from vendor projects to multi-stakeholder stewardship over time.
Trust still has rough edges for teams depending on MCP for production workflows. Server authors can publish tools to public registries with no identity verification required at upload. That lets bad actors ship typosquat packages or add surveillance tooling to otherwise useful servers quietly. The AI legend predicts enterprise tool disruption narrative flagged the registry problem early on. Signed server manifests, maintainer attestations, and reproducible builds are the current best practice today. The Docker MCP Catalog’s verified status covers the subset of servers where that gate exists already. The rest of the ecosystem is improving but still rewards defensive deployment practices from careful teams.
The Future After Anthropic Launches Open-Source AI Connection Protocol Through 2027
Looking ahead, the 2026 roadmap published on March 9, 2026 names enterprise readiness as the top priority. The priority maps to audit trails, single sign-on patterns, and gateway standardization through extensions. Transport scalability is the second theme on the roadmap for the next spec revision cycles ahead. Future revisions will likely add bidirectional streaming primitives for richer agent-to-agent communication later on. Agent-to-agent communication is the third theme, overlapping with Google’s Agent2Agent proposal from 2025. Open questions remain about whether MCP absorbs that layer or stays scoped to tool access only. Governance maturation closes the roadmap under neutral stewardship from the Agentic AI Foundation.
Forrester forecasts that thirty percent of enterprise application vendors will ship their own MCP servers. That trajectory implies five or ten thousand enterprise-grade servers inside a year of forecast rollout. Catalog quality, discovery, and reputation signals will matter more than raw server count at that volume. Monetization is the quiet undercurrent, because less than five percent of public servers currently sell paid tiers. The ecosystem is still negotiating what a healthy mix of free and paid tooling looks like for teams. The rise of MCP protocol adoption in 2026 Medium essay catalogs the business models in play.
The trajectory for teams building on MCP in 2027 looks like a two-track picture already today. One track treats MCP as table stakes and competes on model quality, data quality, and workflow design. The other track competes inside the protocol, building gateways, catalogs, authorization planes, and observability tooling. Enterprise CIOs will keep buying both tracks for the next five years based on current purchasing signals. The Anthropic launches Claude 2.1 dev tools story was the first signal that the vendor cared about surface. The MCP curve shows how an open-source bet can reshape an entire category inside two years cleanly.
MCP Adoption
Growth of the Model Context Protocol ecosystem, Nov 2024 to Mar 2026
Horizontal bars compare the ecosystem metrics that moved most as MCP went from launch to default. Chart type selected: Horizontal Bar because each metric is categorical and ranked.
Monthly SDK downloads grew roughly 48 times from launch to March 2026. Public MCP server count passed 10,000 in H1 2026, and compatible clients surpassed 300. The 4x figure measures remote server deployments between May 2025 and March 2026.
Sources: WorkOS MCP in 2026 writeup, Algeria Tech 97M installs analysis, Wikipedia Model Context Protocol.
Common Mistakes Teams Make With MCP in Their First Six Months
Among the recurring mistakes, teams rush to install every popular server before deciding what the organization needs. A sprawling catalog is harder to secure, review, and operate at scale across many engineering teams. Most of the servers added in the first thirty days of implementation never see production use at all. A better pattern is to scope the first rollout to three to five servers tied to one or two workflows. Run those for a sprint, then expand based on what the users actually asked for during the pilot. The context engineering for LLM agents discipline covers why fewer high-quality tools win long term.
The second common mistake is skipping observability from the start of the MCP rollout entirely. Teams that treat MCP calls as fire-and-forget end up blind when a server returns bad data later. They stay blind when a model hallucinates a tool call or a user reports an incident weeks later. Shipping a logging schema from day one and routing it through an existing SIEM saves retrofit pain. Keeping thirty days of query-replay logs lets teams investigate and debug issues when they arise. The semantic knowledge graphs for LLM agents patterns pair well with MCP observability work.
Measuring MCP Success Beyond Install Counts
Turning to metrics, download counts and server directories make for easy headlines but say little about value. Three metrics actually matter for a team shipping MCP in production: success rate, time saved, and incident rate. A healthy rollout sits above 95 percent tool call success rate during the first eight weeks of use. It also delivers measurable time savings on named workflows that the business cares about tracking. The incident rate should sit below one per thousand calls after the first eight weeks of operation. Teams that only track install counts tend to overstate their progress and understate the risk they carry.
Tool call success rate is the leading indicator for teams running Anthropic Launches Open-Source AI Connection Protocol in production. Low success rates predict user disengagement within a single sprint of rolling out a new server. A tool that returns errors more than five percent of the time trains users to avoid using it. That avoidance is slow to reverse once it sets in with the user base over a few weeks. Teams instrument the server to count successful calls, retried calls, failed calls, and user-aborted calls. They publish those numbers on a dashboard the product team can see every week during review. The AI supercharges the MCP developer workflow patterns tie reliability directly to adoption.
Time saved per workflow is the lagging indicator, and it is the number product leadership asks about. Teams calculate it by baselining the manual version of a workflow before the MCP rollout starts. They measure the MCP-assisted version after rollout and subtract the delta from the manual baseline. The baseline matters because a thirty-minute workflow dropping to twenty minutes looks the same as two hours dropping to ninety minutes. The business impact of those two deltas is very different in terms of hours saved per year. Published numbers across the ecosystem suggest a sixty to eighty percent reduction in integration timelines overall. The biggest wins show up in cross-system workflows that previously required swivel-chair work by humans.
A Practical Rollout Plan for the Next Ninety Days
Looking ahead to execution, teams that want to adopt MCP in the next quarter can run a focused plan. The plan pairs well with how Anthropic Launches Open-Source AI Connection Protocol itself unfolded over 2025. The first thirty days pick two workflows, name a staff engineer as owner, and stand up a gateway. The gateway handles OAuth 2.1 scopes while the team ships two internal MCP servers tied to the workflows. The second thirty days wire observability, run a tabletop exercise against the Akamai findings, and open a pilot. The pilot cohort is twenty users watching the three metrics covered in the previous section carefully. The final thirty days expand to a second cohort, formalize the catalog policy, and publish an internal retrospective.
The plan treats governance as a first-class deliverable rather than an afterthought bolted on later in the rollout. It leaves room for the next spec revision rather than optimizing for the current one on the shelf. A staff engineer, a security partner, a product owner, and an operations owner are the minimum team shape. Most firms find that a half-time commitment from each is enough for the first ninety days of work. The payoff is a shipping foundation the organization can expand on with real users in production. The lesson from the first two years of MCP adoption is that early rigor beats late rework by a wide margin. Anthropic Launches Open-Source AI Connection Protocol remains the clearest example of a well-seeded open standard.
Key Insights on the Model Context Protocol in 2026
- The Python and TypeScript SDKs reached 97 million monthly downloads as of March 25, 2026, a 4,750 percent increase from the roughly 2 million at launch.
- Public MCP server registries carry more than 10,000 servers across major catalogs as of March 2026, with Docker growing from 100 to several thousand verified entries.
- Remote MCP deployments grew about four times between May 2025 and March 2026, per the Algeria Tech infrastructure analysis of MCP adoption in 2026 coverage of the shift.
- Per the March 2026 Algeria Tech developer sentiment summary, 72 percent of developers already using MCP plan to increase that usage significantly.
- Approximately 1,200 practitioners attended the MCP Dev Summit North America held in New York in April 2026, hosted by the Agentic AI Foundation.
- Forrester forecasts that 30 percent of enterprise app vendors will ship their own MCP servers through 2026, pushing the catalog toward tens of thousands.
- Akamai researchers published six attack-surface findings against the 2026-07-28 MCP specification release candidate on June 25, 2026 tied to specific features.
- Untreated MCP stacks carry a 92 percent exploit probability in adversarial testing published October 2025, per CloudTweaks reporting.
Taken together the numbers describe a protocol that moved from launch to default in less than two years. That timing is almost unheard of for an open standard in enterprise software today. The adoption curve was pulled forward by Anthropic’s reference servers and OpenAI’s March 2025 endorsement. The 2026 story is mostly about enterprise readiness, with transport and authorization getting the attention. Security findings from Akamai and other researchers confirm that the surface area grew faster than the controls. Gateways, allowlists, and signed metadata are now the default pattern for production deployments of MCP.
MCP vs Function Calling vs Legacy Plug-ins Comparison
The comparison below ranks MCP, function calling, and legacy plug-ins across nine dimensions that engineering leads evaluate during platform selection. Each dimension picks a different operational concern that shapes real production rollouts over the next three years. The matrix shows where MCP wins on portability and governance, and where function calling still carries weight. Legacy plug-ins, mostly deprecated, serve mainly as a reminder of what the industry has moved beyond. Teams can map a current rollout against this grid to find where they sit today. The result is usually a short list of three dimensions where improvement delivers the most leverage.
| Dimension | MCP | Function Calling | Legacy Plug-ins (2023) |
|---|---|---|---|
| Model portability | Any compliant client model | Model-specific schemas | Vendor-specific |
| Transport | stdio and Streamable HTTP | In-process API | HTTPS with vendor manifest |
| Authentication | OAuth 2.1 scoped tokens | Caller-defined | Vendor plug-in approval |
| Governance | Agentic AI Foundation (Linux Foundation) | Each model vendor | Vendor marketplace |
| Catalog quality | 10,000+ public, mixed curation | Not applicable | Hundreds, vendor-curated |
| Observability | Gateway logs, SIEM integration | In-process traces | Marketplace analytics |
| Security surface | Prompt injection, tool poisoning, _meta forging | Prompt injection only | Vendor review process |
| Multi-tenant deployment | Native in 2026-07-28 spec | In application layer | Vendor-hosted |
| Lifetime through 2027 | Growing standard, enterprise ready | Complementary to MCP | Mostly deprecated |
Real-World Examples of the Open-Source AI Connection Protocol in Action
Block’s Internal Developer Rollout
Block was one of Anthropic’s earliest named adopters and rolled MCP into its internal developer tools during the first quarter after launch. CEO Jack Dorsey explicitly endorsed the protocol as a shared surface for the company’s AI agents. The team deployed servers for its internal databases, Git repositories, and ticketing systems, and reported that engineers cut context-switching time on cross-system tasks by a meaningful margin during pilot phases. Block reportedly saved several hours per engineer each week after the rollout. The company then joined Anthropic and OpenAI as a co-founder of the Agentic AI Foundation on December 9, 2025 under the Linux Foundation press announcement. The main limitation Block flagged publicly was the lack of a mature authorization layer in the 2024 release, which the March 26, 2025 OAuth 2.1 revision addressed. The deployment also showed that popular servers can mask uneven server quality, which pushed Block toward an internal catalog with explicit approval tiers.
Cursor’s Multi-Server Developer Experience
Cursor, the AI code editor, shipped native MCP support within weeks of launch. It used the protocol to let agents read repository context, run tests, and query documentation from inside the editor. The approach let Cursor avoid building bespoke integrations for every tool. Third-party server authors could reach the editor’s users directly, and the catalog grew from a handful to hundreds of community entries during 2025. The product’s rapid growth, documented across the OpenAI vs Claude Code coding war coverage, correlated with how many high-quality servers Cursor could reach. The visible limitation was friction when community servers broke or shipped poor error messages, which the Cursor team mitigated by maintaining a curated allowlist for enterprise customers. Users still occasionally saw a tool call fail because an upstream server author pushed a breaking change without a deprecation window.
Figma’s MCP Apps Launch Partnership
Figma was one of ten launch partners for the MCP Apps extension launched on January 26, 2026. The company used it to let AI assistants edit design components inline inside Claude, ChatGPT, Goose, and VS Code. The implementation renders a sandboxed Figma inspector in the host’s UI, which lets a user ask the assistant to adjust a component and see the result without leaving the chat. Figma reported higher assistant engagement on tasks that involved both narrative and visual review, though it did not publish specific lift numbers at launch. The main constraint is the sandbox model, which limits what the embedded iframe can do and prevents some multi-document workflows that work in the native Figma app. The integration still demonstrates how MCP Apps shifts the protocol from a developer tool into a surface that product companies use for distribution.
Books that pair well with the Model Context Protocol
A short reading list for engineers and leads shipping with MCP in 2026.
AI Engineering: Building Applications with Foundation Models
by Chip Huyen
A foundations-first guide to building AI applications on top of large models, which is the design space MCP exists to serve.
Buy on AmazonHands-On Large Language Models: Language Understanding and Generation
by Jay Alammar and Maarten Grootendorst
A practical walkthrough of modern LLM behavior, tool use, and generation that pairs naturally with MCP server design.
Buy on AmazonDesigning Machine Learning Systems: An Iterative Process for Production-Ready Applications
by Chip Huyen
Production-oriented ML systems guide that covers the operational layer MCP integrates into.
Buy on AmazonAs an Amazon Associate, AIplusInfo earns from qualifying purchases.
Case Studies on the Open-Source AI Connection Protocol in Production
Case Study: Docker’s MCP Catalog and Toolkit Launch
Docker faced the problem that enterprise customers wanted MCP but could not trust unverified community servers, so the company shipped a verified catalog as its solution. The fragmented catalog across GitHub and ad-hoc registries made evaluation slow before Docker intervened. On April 22, 2025 the company shipped the Docker MCP Catalog and Toolkit launch announcement with 100 verified servers. Partners included Stripe, Elastic, Neo4j, Heroku, Pulumi, Grafana Labs, Kong, New Relic, and Continue.dev in one curated hub. The toolkit integrated with Gordon, Claude Desktop, Cursor, VS Code, Windsurf, Continue.dev, and Goose, which let developers wire servers into their existing environment with a few commands. Image Access Management and Registry Access Management from Docker Business added enterprise controls over which images and registries developers could use.
The measured impact of the solution was fast catalog adoption across the ecosystem. The verified set grew to several thousand entries by mid-2026, with remote deployments growing roughly four times between May 2025 and March 2026. Docker’s twenty-plus billion monthly image pulls provided enough signal to tell which servers were actually used, which fed into automated reputation signals the catalog surfaced to users. The main limitation reported in community feedback was Docker-centric packaging, which gave Docker-hosted servers an operational edge over servers packaged differently. Docker also had to invest in signing, provenance, and vulnerability scanning as the catalog grew. Community reports surfaced typosquatting attempts that would have slipped through a weaker review process.
Case Study: Cloudflare’s Managed MCP Server Platform
Cloudflare faced a different side of the broader MCP adoption problem in enterprise environments. Enterprises wanted MCP but could not justify the operational cost of always-on HTTPS endpoints with authentication, rate limits, and observability. The company launched managed MCP server hosting on Workers during 2025. The pattern was documented in its official engineering blog, letting teams ship a server in a few hundred lines of code. The Cloudflare Workers remote MCP server tutorial gave teams a working path from zero to production in under an afternoon. By 2026 the Cloudflare pattern had been copied by competitors across the industry. That broad imitation validated the approach as the new default pattern for managed MCP hosting.
The impact was most visible in reduced time-to-production for teams without strong platform engineering, with Cloudflare citing deployment windows measured in hours rather than weeks. The approach also achieved substantial token savings through dynamic tool discovery, which the WorkOS state-of-MCP writeup pegged at over 98 percent in the Code Mode variant. The limitation is lock-in exposure, since a server shaped around Cloudflare’s Workers runtime does not port cleanly to AWS Lambda or Azure Functions without rewriting the edge integration. The company’s response has been to open-source most of the SDK code and publish migration guides, which blunts the lock-in critique but does not eliminate it. Teams that start on the Cloudflare pattern tend to stay there because the operational experience is strong, which is both the appeal and the risk.
Case Study: Shopify’s Commerce MCP Deployment
Shopify needed to let merchant-facing AI tools read product catalogs, order histories, and inventory levels. It also needed to keep merchant data isolated under strict multi-tenant controls and existing authorization patterns. The company built an MCP server solution during 2025 for merchant-facing assistants. The server exposed scoped merchant data running inside Shopify-approved hosts with OAuth 2.1 enforcing per-merchant scopes. The Shopify engineering writeup on MCP for commerce framed the deployment as part of a broader strategy. The strategy let third-party AI tools integrate without negotiating a bespoke API agreement each. The approach reused existing OAuth infrastructure that the Shopify platform already operated. Reusing that infrastructure cut integration time substantially for the Shopify platform team.
Early merchant feedback reported faster inventory review and faster response drafting for support, with concrete time savings in the range of twenty to forty percent on routine workflows. Shopify handled the authorization story carefully by issuing short-lived tokens with narrow scopes, which limited blast radius if a server or client were compromised. The main controversy was around rate-limiting behavior, where some third-party hosts triggered aggressive back-off during spikes that frustrated merchants. Shopify’s response was to publish clearer rate-limit documentation, add per-host quotas, and expose the quota headers so hosts could pace their calls. The deployment showed that an existing API platform can layer MCP without rebuilding its authorization story from scratch, which lowers the activation energy for other platform companies watching this space.
Frequently Asked Questions on Anthropic’s Open-Source AI Connection Protocol
It is the Model Context Protocol, an open standard Anthropic launched on November 25, 2024 to let AI models call tools and data sources through a shared client server interface. The protocol uses JSON-RPC 2.0 messaging and supports both local stdio and remote Streamable HTTP transports. It is governed by the Agentic AI Foundation under the Linux Foundation since December 9, 2025.
Anthropic launched the Model Context Protocol on November 25, 2024, releasing open-source Python and TypeScript SDKs plus reference servers for Google Drive, Slack, GitHub, Git, Postgres, and Puppeteer. The announcement positioned MCP as a solution to the N by M integration problem that plagued earlier AI tool integrations. The MCP project has grown dramatically across every ecosystem metric since that original launch date.
OpenAI adopted MCP in March 2025, Google DeepMind in April 2025, and Microsoft Copilot Studio in May 2025. Native MCP clients include Claude, ChatGPT, Gemini, Microsoft Copilot, GitHub Copilot, Cursor, Windsurf, VS Code, and Zed. Server adopters include Slack, GitHub, Salesforce, Stripe, HubSpot, Shopify, Notion, Linear, Sentry, Figma, Webflow, Cloudflare, Postman, and WooCommerce.
Function calling is a model feature that produces structured output matching a schema, while MCP is a protocol defining how any model talks to tools across a client server boundary. The two complement each other in production, with function calling handling the model-level structured output and MCP handling the catalog and transport. A tool written as an MCP server works across any compliant model.
The N by M problem describes how N models each need custom integrations to M data sources, producing N times M bespoke connectors. A team with four models and twenty data sources would need to maintain eighty custom integrations under the old pattern. MCP collapses this matrix by letting one server work with any client model, so each data source needs only one integration.
MCP uses JSON-RPC 2.0 as the message format across all transports. The original stdio transport runs the server as a local subprocess, which fits desktop clients and development workflows. The March 2025 specification added Streamable HTTP for remote deployments, and the July 28, 2026 revision made the HTTP transport stateless with signed metadata, routing headers, and standard cache fields.
Public registries listed more than 10,000 MCP servers across major catalogs as of March 2026, up from a handful at launch. The Python and TypeScript SDKs together saw roughly 97 million monthly downloads in the same month. Forrester forecasts 30 percent of enterprise application vendors will ship their own MCP servers through 2026 and into 2027, pushing the catalog toward tens of thousands of entries.
MCP is safe when deployed with authentication, scoped tool allowlists, prompt injection filters, and an audit log. Akamai researchers published six attack surface findings against the 2026-07-28 specification on June 25, 2026, each tied to specific protocol features. Teams typically deploy MCP behind a gateway that enforces OAuth 2.1 scopes, inspects traffic, and logs every call for later review.
The highest-impact risks are prompt injection, tool poisoning, session hijack through predictable identifiers, forging the unsigned _meta object, and header body desync between gateways and servers. CloudTweaks reported a 92 percent exploit probability on untreated MCP stacks in adversarial testing. Mitigations include signed server manifests, strict allowlists, prompt injection classifiers, and gateways that enforce authentication before requests reach a server.
The Agentic AI Foundation under the Linux Foundation governs MCP since Anthropic donated the project on December 9, 2025. Co-founders include Anthropic, Block, and OpenAI, with AWS, Google, Microsoft, Cloudflare, and Bloomberg as platinum supporting members. The foundation hosts the technical steering committee that oversees specification revisions and the roadmap published March 9, 2026.
MCP Apps is the first official extension of the protocol, launched January 26, 2026 with support in Claude, ChatGPT, Goose, and VS Code. It standardizes how MCP servers deliver interactive UI such as dashboards, forms, and visualizations through sandboxed iframes. Launch partners included Amplitude, Asana, Box, Canva, Clay, Figma, Hex, Monday, Slack, and Salesforce.
Pick either the Python or TypeScript SDK, both of which ship with first-class async support and type-safe tool definitions. Start from a reference server such as the GitHub, Postgres, or Puppeteer example, which Anthropic open-sourced at launch. Deploy locally with stdio transport first to validate the tool shape. Then move to Streamable HTTP transport when you want to run the server as a managed endpoint for remote clients.
The 2026-07-28 specification removed the initialize handshake and session identifier, moving protocol metadata into a signed _meta field. New Mcp-Method and Mcp-Name headers enable gateway routing without parsing the JSON-RPC body. Discovery responses added HTTP cache fields to reduce redundant schema fetches. Roots, Sampling, and Logging were marked deprecated with a twelve month removal window to give teams a predictable migration path.
MCP does not replace APIs, it layers on top of them to make tools discoverable and callable by AI models. An MCP server for a database typically wraps the existing database API with a schema the model can read and a transport the host can call. Direct API access remains the right pattern for deterministic machine-to-machine traffic, while MCP shines when a model orchestrates calls based on natural language input.
Pick two business workflows and name a staff engineer as owner, stand up a gateway with OAuth 2.1, and ship two internal MCP servers tied to the chosen workflows. Wire observability into an existing SIEM, run a tabletop exercise against the Akamai June 2026 findings, and roll out to a pilot cohort of twenty users. Finalize a catalog policy, expand to a second cohort, and publish an internal retrospective at day ninety.