All chapters
  1. Start hereA protocol standardizes the call. It does not grant the permission
  2. Foundations · 1The primitive: a function, its arguments, its result, its side effects
  3. Foundations · 2Function calling: the model asks, your application executes
  4. Foundations · 3Client and server: process boundaries, JSON-RPC, errors and trust
  5. Foundations · 4What MCP is: host, client, server and what the protocol promises
  6. Protocol · 5Three surfaces: tools act, resources inform, prompts guide
  7. Protocol · 6A first MCP server: typed input, deterministic data, the raw exchange
  8. Protocol · 7Java and the SDKs: typed DTOs, validation and interoperability
  9. Protocol · 8Local or remote: stdio, HTTP, stateless requests and availability
  10. Platform · 9The database decision: direct SQL, a service boundary or an MCP adapter
  11. Platform · 10Sharing across teams: ownership, catalogs, contracts and versions
  12. Platform · 11Who gets access: users, agents, delegation and least privilege
  13. Platform · 12Enterprise authorization: tokens, audiences, gateways and no passthrough
  14. Platform · 13The threat model: injection, poisoned tools, confused deputies and egress
  15. Platform · 14Governance: who may publish, who approves, who answers the page
  16. Operations · 15Observability and audit: what was called, by whom, and why it was allowed
  17. Operations · 16Resilience: timeouts, retries, idempotency and overload at a shared server
  18. Operations · 17Testing and evaluation: contracts, authorization matrices and injection
  19. Reference · 18Advanced MCP: long tasks, large catalogs, tenants and evolving versions
  20. Reference · 19The ecosystem: SDKs, registries, gateways, identity and telemetry
  21. Reference · 20Enterprise reference architecture: one assessment platform, four teams
  22. Reference · 21Decision playbooks: function, API or MCP, and the records that explain why
  23. ReferenceGlossary
  24. AboutAbout this site and its sources
Reference · 19

The ecosystem: SDKs, registries, gateways, identity and telemetry

Official SDKs, the registry, gateways, identity integrations, provider clients and OpenTelemetry, each read on its own documentation and labelled as standard, vendor feature or community extension.

You will be able to label
Every piece of an MCP platform as a standard, a community extension or a vendor feature, and say what that label lets you rely on.
You will know
What the official SDKs, the registry, gateways, identity integrations, hosts and OpenTelemetry each solve, and where each one stops.
You will be able to decide
When a product earns its place and when plain code around the assessment service is the better choice.

The architecture review for uw-assessment goes well until the last slide. The platform team has drawn the server, the gateway, the identity provider, the catalog and the tracing pipeline. A reviewer from identity and security governance asks one question per box: "Which of these is the standard, which is a product, and which is something we wrote? And what happens to us if it changes next quarter?"

Nobody can answer cleanly. The MCP specification is dated and normative. The OAuth version it cites is still a draft. The claims team's SDK follows the specification on its own schedule. The registry is in preview. The tracing names are marked "Development". The identity setup follows a vendor page that links an older protocol revision. Each fact is easy to find; together they decide how much of the design will stay still.

This reference chapter answers that review, one section per named item, each read on its own documentation on 2026-11-18. It deepens Sharing, Enterprise authorization and Observability. It names no product it did not read, ranks nothing and quotes no prices.

How to read the labels on this page#

A standard is a specification published by a standards body or by the MCP project as normative text, with MUST and SHOULD requirements, changed by dated revision or new document number. A tiny example: MCP revision 2026-07-28, or RFC 8707.

A community extension is an optional addition maintained by an open project outside the normative core; it promises only what its maintainers state. A tiny example: the official MCP Python SDK. Official MCP projects (SDKs, the Registry, extensions) carry this label because they are optional and versioned apart from the specification, not because they are unofficial.

A vendor feature is a capability of one company's product, documented and changed by that company. A tiny example: Microsoft Entra's documented way of protecting an MCP server.

The labels are this site's convention, not a ranking: they say what you can rely on and whom to ask when it changes. Claims inside each section also carry the lead-ins Normative, Ecosystem pattern and This site's recommendation.

Before AI. A Java team already does this for every dependency. The Servlet specification is a standard; Spring is an open-source project with its own release train; a cloud vendor's managed gateway is a vendor feature. Nobody confuses "Spring changed a default" with "the Servlet specification changed".

The table lists every item in section order; it takes the place of a lab, because the ecosystem changes too fast for a recorded interaction to stay true.

ItemLabelVersion or status read on 2026-11-18
MCP specificationstandardrevision 2026-07-28 (current)
JSON-RPC 2.0standardlast updated 2013-01-04
OAuth 2.1 draft and cited RFCsstandard (one draft)MCP cites draft -13; latest -17, not an RFC
OpenTelemetry GenAI and MCP conventionsstandard, in developmentstatus Development, no release
MCP Python, TypeScript, Java SDKscommunity extensionTier 1, Tier 1, Tier 2
Official MCP Registrycommunity extensionpreview
Organization catalogs and subregistriesyour system; interface is a community extensionpattern
MCP gatewaysecosystem pattern; products are vendor featuresno product read
Enterprise-managed authorizationcommunity extensionStable, keyed to 2026-07-28
Microsoft Entra for MCP serversvendor featurepage dated 2026-11-05
A host that consumes MCP serversvendor featureClaude Code documentation

Diagram: Where each item acts in one call · from the claims host to uw-assessment

Read left to right along one call. The host and its SDK build the request. Identity gives it a token. A gateway may pre-check it. The server, built on an SDK, authorizes and calls the domain service. The registry and the catalog sit before the call: they decide what the host knows about. OpenTelemetry names the spans at every hop. Click a box for its label and its limit.

  1. Before the call · finding servers
    1. Official MCP Registry: Metadata for publicly accessible servers under verified namespaces. No private servers; scanning left to others.
    2. Organization catalog: The insurer's source of truth. A private subregistry, if any, is generated from it.
  2. The caller's side
    1. Host (provider client): The application the person or agent works in. Decides how servers are configured, approved and authenticated.
    2. Identity provider: Issues the token whose audience is the MCP server. With enterprise-managed authorization, policy is set once at the identity provider.
  3. Platform edge
    1. Gateway (pattern): Rejects what any server would reject and counts calls per client. Never forwards the caller's token; never owns domain rules.
  4. Server side
    1. MCP server on an SDK: Python, TypeScript or Java SDK handles the protocol; the server authorizes every call and calls the domain service.
    2. OpenTelemetry spans: Span and attribute names shared across SDKs and gateways; trace context travels in _meta.

The map places each item where it acts in one call from the claims host to uw-assessment. Carry one point through the sections: the standards fix the wire and the token; everything else is a choice someone made and must keep current.

Standards · The MCP specification#

The normative text that defines how an AI application discovers and calls capabilities other programs offer. It solves the problem every page here starts from: without a shared contract, each host and server would invent its own call format.

TemplateAs documented on 2026-11-18
Protocol or data modelJSON-RPC 2.0; stateless, with version and client capabilities in every request's _meta; mandatory server/discover; resultType on every result; stdio and Streamable HTTP
Strengthsone vocabulary of methods and errors; a dated revision to pin; deprecated features kept at least twelve months (ninety days expedited)
Limitationssays it "cannot enforce these security principles at the protocol level"; no tool versions, catalogs or gateways; 2025-11-25 tutorials no longer apply
Integration and securityHTTP authorization per its authorization pages; no token passthrough; W3C trace context in reserved _meta keys
When plain code is betterone application owning data and agent: a typed function call (Start here)
Labelstandard (normative)
Version and date verified2026-07-28 current, 2025-11-25 previous; 2026-11-18
Primary sourcesspecification, versioning, changelog

Minimum example (documented shape; the example's server answers this request shape):

{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "get_roof_assessment", "arguments": {"submission_id": "SUB-1004"}, "_meta": {"io.modelcontextprotocol/protocolVersion": "2026-07-28", "io.modelcontextprotocol/clientCapabilities": {}}}}

Standards · JSON-RPC 2.0#

A small specification for remote procedure calls in JSON: a request names a method, a response carries a result or an error, an id ties them together. It solves framing, so MCP does not define its own.

TemplateAs documented on 2026-11-18
Protocol or data modeljsonrpc "2.0", method, optional params, id; a request without id is a notification and gets no reply; exactly one of result or error; codes -32700, -32600 to -32603, -32000 to -32099
Strengthstiny, stable, transport-neutral
Limitationsno authentication, no parameter schema; MCP narrows it (no null ids) and reserves -32020 to -32099
Integration and securityapplication codes outside -32768 to -32000 (the example's -31403)
When plain code is betterinside one process there is nothing to frame
Labelstandard (a published specification, not an IETF RFC)
Version and date verified2.0, last updated 2013-01-04; 2026-11-18
Primary sourcesJSON-RPC 2.0

Minimum example (documented shape): request, shortened response, notification.

{"jsonrpc": "2.0", "id": 1, "method": "server/discover", "params": {"_meta": {"io.modelcontextprotocol/protocolVersion": "2026-07-28", "io.modelcontextprotocol/clientCapabilities": {}}}}
{"jsonrpc": "2.0", "id": 1, "result": {"resultType": "complete", "supportedVersions": ["2026-07-28"]}}
{"jsonrpc": "2.0", "method": "notifications/tools/list_changed", "params": {}}

Client and server teaches JSON-RPC from zero.

Standards · OAuth 2.1 draft and the RFCs MCP cites#

The family of specifications by which a client obtains an access token for a protected resource. It solves "who is calling, for which resource, with which permissions" without the server handling passwords. Normative (MCP specification 2026-07-28): servers must publish RFC 9728 protected resource metadata, clients must send the RFC 8707 resource parameter, and servers must validate that a token was issued for them.

TemplateAs documented on 2026-11-18
Protocol or data modelRFC 9728 resource metadata; RFC 8414 server metadata; RFC 8707 resource (the token's audience); RFC 8693 token exchange; also RFC 6750, RFC 9207
Strengthsmature identity providers; audience binding stops a CRM token working at the MCP server (UW-M04)
LimitationsOAuth 2.1 is an Internet-Draft: MCP cites -13 (28 May 2025), the latest is -17 (31 October 2026); Dynamic Client Registration is deprecated in MCP
Integration and securitybearer header only; PKCE with S256; issuer comparison; no passthrough
When plain code is betterstdio servers take credentials from the environment, as the specification says
Labelstandard (RFCs are Proposed Standards; OAuth 2.1 is a draft)
Version and date verifiedRFC 8707 (2020), 9728 (2025), 8414 (2018), 8693 (2020); 2026-11-18
Primary sourcesMCP authorization, RFC 9728, RFC 8707, OAuth 2.1 drafts

Minimum example (documented shape, values from this site's example):

{"resource": "https://mcp.uw.insurer.example", "authorization_servers": ["https://idp.insurer.example"], "scopes_supported": ["uw.read"], "bearer_methods_supported": ["header"]}

Standards · OpenTelemetry GenAI and MCP semantic conventions#

OpenTelemetry is an open standard and toolset for traces, metrics and logs; its semantic conventions are agreed span and attribute names. They solve readability across hops: a trace through a Python host, a gateway and a Java server is only useful if all three name things alike.

TemplateAs documented on 2026-11-18
Protocol or data modelspan name {mcp.method.name} {target}; kinds CLIENT and SERVER; mcp.method.name required; trace context in params._meta as traceparent, tracestate, baggage
Strengthsone naming scheme across SDKs; propagation matches MCP's reserved _meta keys
Limitationsmoved to a separate repository with no release; status "Development"; still lists initialize and mcp.session.id, no 2026-07-28 in the parts read
Integration and securitytool arguments in spans are opt-in because they may be sensitive
When plain code is bettera single-process agent with application logs
Labelstandard, in development
Version and date verifiedDevelopment, no release; 2026-11-18 (end of the GitHub page not read)
Primary sourcesmoved notice, semantic-conventions-genai

Minimum example (documented shape; illustrative values):

{"name": "tools/call get_roof_assessment", "kind": "SERVER", "attributes": {"mcp.method.name": "tools/call", "gen_ai.tool.name": "get_roof_assessment", "jsonrpc.request.id": "3"}}

Observability maps these to the example's audit events; tracing as a discipline is at https://observe.sammuthu.com.

Official SDKs · MCP Python SDK#

An official SDK is a library in the MCP project's own organization that implements the protocol for one language. Ecosystem pattern: the SDK page lists Tier 1 TypeScript, Python, C#, Go, Rust, Ruby; Tier 2 Java; Tier 3 Swift, PHP, Kotlin. Tier 1 means a 100% conformance pass rate and new features before a specification release; Tier 2, 80% and within six months; no tier requires extensions such as Tasks; "SDKs adopt new protocol revisions on their own schedules." The Python SDK solves hand-writing transports and schemas in Python.

TemplateAs documented on 2026-11-18
Protocol or data modelclass MCPServer (from mcp.server import MCPServer); decorators declare tools; schemas from type hints
StrengthsTier 1; v2 implements 2026-07-28 and "serves both revisions at once"
LimitationsFastMCP renamed MCPServer, old import removed; WebSocket and experimental Tasks API removed; Tasks extension not implemented yet; no version number on the pages read
Integration and securityauthorization stays in your code; two revisions served means two behaviors to test
When plain code is betteran agent calling its own service in-process
Labelcommunity extension (official MCP project)
Version and date verifiedv2, "the current stable release line"; 2026-11-18
Primary sourcesdocs, what's new, SDK tiers

Minimum example (documented shape; not run here; service is the assessment service, and the authorization checks a real server needs are left out):

# Documented shape of the MCP Python SDK v2; not run here.
from mcp.server import MCPServer

mcp = MCPServer("uw-assessment")


@mcp.tool()
def get_roof_assessment(submission_id: str) -> dict:
    """Return the PropertyAssessment of one submission's property. Read only."""
    return service.get_roof_assessment(submission_id)

Official SDKs · MCP TypeScript SDK#

The TypeScript SDK implements MCP for Node.js and similar runtimes, where many host applications are written.

TemplateAs documented on 2026-11-18
Protocol or data modelpackages @modelcontextprotocol/server, @modelcontextprotocol/client; class McpServer; registerTool with a Zod v4 schema
StrengthsTier 1; targets 2026-07-28; v1 gets fixes for at least six months after v2
Limitationsthe README does not say whether v2 serves 2025-11-25 clients; v1 users change package names
Integration and securitythe schema is generated from code, so a test must pin it (Java and SDKs)
When plain code is bettera Node service whose callers are other services keeps its HTTP contract
Labelcommunity extension (official MCP project)
Version and date verifiedv2 released 2026-07-27; 2026-11-18
Primary sourcestypescript-sdk

Minimum example (adapted from the README to the roof lookup; service is the assessment service; not run, not compiled):

import { McpServer } from '@modelcontextprotocol/server';
import { StdioServerTransport } from '@modelcontextprotocol/server/stdio';
import * as z from 'zod/v4';

const server = new McpServer({ name: 'uw-assessment', version: '2.0.0' });
server.registerTool('get_roof_assessment',
  { description: 'Return the PropertyAssessment of one submission.', inputSchema: z.object({ submission_id: z.string() }) },
  async ({ submission_id }) => ({ content: [{ type: 'text', text: JSON.stringify(await service.get(submission_id)) }] }));
await server.connect(new StdioServerTransport());

Official SDKs · MCP Java SDK#

The Java SDK implements MCP for the JVM, maintained with Spring AI; it serves enterprise teams like the claims team.

TemplateAs documented on 2026-11-18
Protocol or data modelMaven io.modelcontextprotocol.sdk:mcp; sync and async APIs; stdio and Streamable HTTP (JDK HttpClient, Servlet API)
Strengthsmodern 2026-07-28 and legacy 2025-11-25 and earlier in one module; Java 17+
LimitationsTier 2; Spring transports come from Spring AI (2.1+ for the modern revision), not the SDK
Integration and securityauthentication and authorization in servlet filters in front of the transport
When plain code is bettera Spring service with only service callers keeps its REST controller
Labelcommunity extension (official MCP project)
Version and date verifiedmcp-core 2.2.0 in the API reference; 2026-11-18
Primary sourcesJava SDK docs

Minimum example (documented coordinates; not run here):

<dependency>
  <groupId>io.modelcontextprotocol.sdk</groupId>
  <artifactId>mcp</artifactId>
  <version>2.2.0</version>
</dependency>

Java and SDKs compares the three SDKs' schema sources and validation; this page does not repeat it.

Registries · The official MCP Registry#

In its own words, "the official centralized metadata repository for publicly accessible MCP servers". It solves public discovery: one place where a server's name, location and launch instructions sit under a verified namespace.

TemplateAs documented on 2026-11-18
Protocol or data modela server.json per server version; read-only REST API under /v0.1/servers, cursor-paginated; metadata immutable except status
Strengthsnamespace proof by GitHub, DNS or HTTP challenge; an OpenAPI interface other registries can implement
Limitations"currently in preview"; no private servers; not for hosts to consume directly; does not verify control of a remote URL
Integration and securityscanning delegated to package registries and aggregators: listed is not vetted
When plain code is betterfor private servers it is not an option; the catalog is the source
Labelcommunity extension (official MCP project, preview)
Version and date verifiedpreview; 2026-11-18
Primary sourcesabout, aggregators

Minimum example (documented read API; not run here):

curl -s "https://registry.modelcontextprotocol.io/v0.1/servers?limit=10"

Sharing shows a server.json for uw-assessment and why the public registry would refuse it.

Registries · Organization catalogs and subregistries#

The catalog is the organization's record of approved capabilities (Sharing is its home). A subregistry is "an aggregator that also implements the OpenAPI spec defined by the MCP Registry". Together they solve private discovery while ownership stays in the catalog.

TemplateAs documented on 2026-11-18
Protocol or data modelthe registry's OpenAPI interface; own data under _meta with the subregistry's key
Strengthsregistry-aware hosts work unchanged; the organization adds its own fields
Limitationsthe official codebase "is not designed for self-hosting"; entries describe servers, not tools
Integration and securitydiscovery is not authorization: a token with the right audience and scopes is still required
When plain code is bettera few servers and hosts: one reviewed configuration file per host
Labelthe catalog is your system; the interface is a community extension
Version and date verifiedpattern from the registry documentation; 2026-11-18
Primary sourcesaggregators

Minimum example (the _meta key pattern is documented; this key and its fields are this site's illustration):

{"_meta": {"example.insurer/catalog": {"owner_team": "property-risk-data", "risk_tier": "medium", "approved_scopes": ["uw.read"], "state": "monitored"}}}

This site's recommendation: generate the private registry from the catalog, never the reverse.

Gateways · MCP gateways as a pattern#

An MCP gateway is a proxy in front of MCP servers that applies shared policy (Enterprise authorization is the term's home). It descends from the API gateway: a reverse proxy that applies cross-cutting policy such as authentication, routing, rate limits and logging to HTTP APIs before requests reach the services. It solves applying one policy to many servers and teams.

TemplateAs documented on 2026-11-18
Protocol or data modelno protocol role; Normative (MCP specification 2026-07-28): Mcp-Method and Mcp-Name headers mirror the body so infrastructure can route without parsing it
Strengthsone place for token pre-checks, per-client limits, routing, per-consumer views (Advanced MCP)
Limitationscannot decide what needs domain data (SUB-2001 belongs to commercial-east); must respect cacheScope private; one more hop
Integration and securitybound by the no-passthrough rule; never the home of domain rules
When plain code is betterone server, few hosts: checks and limits in the server
Labelecosystem pattern; each product a vendor feature
Version and date verifiedno product documentation read, so none named; 2026-11-18
Primary sourcesStreamable HTTP, security best practices

Minimum example (illustrative policy, not any product's format):

# Illustrative gateway policy for uw-assessment; not a real product's configuration format.
route: https://mcp.uw.insurer.example
reject_before_server: [missing_token, wrong_audience, expired_token]
rate_limit_per_client:
  claims-assistant: {bucket: 3, refill_per_s: 1}
  analytics-jobs: {bucket: 2, refill_per_s: 1}
leave_to_server: [scope_per_call, principal_type, tenant]
forward_caller_token: false

Identity · Enterprise-managed authorization#

An official MCP extension, io.modelcontextprotocol/enterprise-managed-authorization, that "enables organizations to control MCP server access centrally through their existing identity provider (IdP)". It solves per-user, per-server consent and one-by-one offboarding.

TemplateAs documented on 2026-11-18
Protocol or data modelthe client exchanges the SSO assertion (RFC 8693) for an ID-JAG, presents it with the jwt-bearer grant, receives an audience-restricted token
Strengthscentral policy; no consent page per server; revocation at the identity provider "immediately across all MCP clients"
LimitationsID-JAG is an Internet-Draft (-06); "implementations track different draft revisions"; issued tokens live until expiry
Integration and securityopt-in per request; the server's own checks do not move; vendor table "not comprehensive"
When plain code is betterfew users, one server: standard MCP authorization
Labelcommunity extension (official extension, Stable)
Version and date verifiedStable, keyed to 2026-07-28; 2026-11-18
Primary sourcesextension docs, ID-JAG draft

Minimum example (documented shape): the client's declaration.

{"_meta": {"io.modelcontextprotocol/clientCapabilities": {"extensions": {"io.modelcontextprotocol/enterprise-managed-authorization": {}}}}}

Enterprise authorization walks the flow step by step.

Identity · Microsoft Entra, as documented#

Vendor feature (as documented on 2026-11-18): an Entra Agent ID page opens "An MCP server is an OAuth 2.0 protected resource. Register the server as an API in Microsoft Entra ID, publish protected-resource metadata, and validate each access token before processing an MCP request." It solves integration for workforces already in Entra.

TemplateAs documented on 2026-11-18
Protocol or data modelapp registration, Application ID URI, delegated scopes; metadata resource must match the expected aud; server https://login.microsoftonline.com/<tenant>/oauth21/2026-08
Strengthsmaps onto the MCP steps; 401 for a missing or invalid token, 403 without scope or role
Limitationsv2.0 access tokens only; links MCP revision 2025-06-18; CIMD support in public preview; authorized-party claim and downstream flow not described
Integration and securityvalidate signature, issuer, audience, lifetime, tenant, client, permissions; downstream, a token "issued for this downstream API"
When plain code is betternot that choice: the server validates Entra tokens either way
Labelvendor feature
Version and date verifiedms.date 2026-11-05; 2026-11-18
Primary sourcesSecure an MCP server with Microsoft Entra ID

Minimum example (the page's metadata shape, this site's host name):

{"resource": "https://mcp.uw.insurer.example", "authorization_servers": ["https://login.microsoftonline.com/<tenant-id>/oauth21/2026-08"], "scopes_supported": ["mcp.access"], "bearer_methods_supported": ["header"]}

Enterprise authorization maps Entra's steps row by row.

Provider clients · A host that consumes MCP servers#

A provider client here is a host from a model provider or tool vendor that connects to MCP servers for a user: the MCP host of What MCP is. Every host decides, outside the protocol, how servers are configured, approved and authenticated. One host's documentation was read, Claude Code's, as an instance of the role, not a recommendation.

TemplateAs documented on 2026-11-18 (Claude Code)
Protocol or data modelHTTP (recommended), SSE (deprecated), stdio; also a WebSocket configuration, outside the specification's two standard bindings
Strengthsscopes local, project (shared .mcp.json), user; OAuth 2.0 for remote HTTP servers; managed configuration with allowlists and denylists
Limitationsmanaged-configuration details on a page not read; behavior changes with vendor releases
Integration and security"Verify you trust each server before connecting it."; approval prompt before project-scoped servers
When plain code is betteran unattended pipeline calling one service
Labelvendor feature
Version and date verified2026-11-18 (end of the page not read)
Primary sourcesClaude Code: MCP

Minimum example (documented command form; not run here):

claude mcp add --transport http uw-assessment https://mcp.uw.insurer.example/mcp

For any host, ask: can the organization restrict which servers users add, does it send the resource parameter, and does it show the user a write before it happens?

In a coding agent. A coding agent is a provider client too, and its configuration scopes are this page's labels in miniature: a server in a repository's shared .mcp.json is the team's decision and needs approval before first use; a user's own server is personal; a managed list is policy. A repository server with read_file is low risk; one that can open_pull_request belongs only in the managed list. Harness Engineering covers the runtime that holds these connections.

Diagram: Three labels across four layers · what you can rely on, and who you ask when it changes

Rows are the layers of an MCP platform. Columns are the three labels this page uses. Read across a row to see which part of that layer is a standard, which is an optional community extension and which is one vendor's feature. The standards column is the shortest: most of a platform is choices that someone must keep current.

  1. Wire
    1. MCP 2026-07-28 + JSON-RPC 2.0: The dated specification and the framing it builds on. Changes by revision, with a deprecation policy.
    2. Official SDKs, Tasks: Optional libraries and extensions maintained by the MCP project, versioned apart from the specification.
    3. Host transport options: What a given host supports and how it is configured is the host vendor's choice.
  2. Identity
    1. OAuth RFCs + 2.1 draft: RFC 9728, 8707, 8414, 8693 are Proposed Standards; OAuth 2.1 is an Internet-Draft.
    2. Enterprise-managed authorization: Central policy at the identity provider, resting on the ID-JAG Internet-Draft.
    3. Microsoft Entra setup: One vendor's documented steps for protecting an MCP server; links an older MCP revision.
  3. Discovery
    1. server/discover: The only discovery the specification defines: what one server supports. Finding servers is outside it.
    2. Official MCP Registry: Public metadata repository with an OpenAPI interface that subregistries may implement.
    3. Marketplaces, managed lists: Aggregators and hosts add curation and allowlists on top; each is that vendor's feature.
  4. Telemetry
    1. W3C trace context in _meta: traceparent, tracestate and baggage are reserved _meta keys in the MCP specification.
    2. OpenTelemetry MCP conventions: Agreed span and attribute names, in a separate repository with no release yet.
    3. Tracing backends: Where traces are stored and queried is a product choice; no product is named on this page.

What goes wrong when the labels are missing#

MistakeWhat happens
A draft treated as finalcode pinned to OAuth 2.1 draft 13, or an ID-JAG library on another revision
A preview treated as infrastructurethe registry resets data and an onboarding script breaks
An SDK treated as the protocola Tier 2 gap shows up in production
A vendor page treated as the specificationa 2025-06-18 setup is copied into a 2026-07-28 server
A gateway treated as the authorizationthe server stops checking the tenant, and SUB-2001 leaks

Security and governance notes#

Security note. Every item here moves trust somewhere: an SDK's parser, a registry's namespace check, a gateway's token check, an identity provider's policy, a host's approval prompt. None replaces the server's per-call authorization. A protocol standardizes the call. It does not grant the permission.
Governance note. Keep a dependency record per item: label, version or draft revision, date verified, owner, and the trigger for re-review (a new MCP revision, a draft update, the registry leaving preview, a vendor page change). That record is what the reviewer in the opening asked for.
What this is not. Not a product directory or a ranking, and not a tutorial for any item. Tool schemas and the tool loop are at Tools Engineering; tracing as a discipline at https://observe.sammuthu.com; SDK schema behavior at Java and SDKs.

Checklist for Monday#

CheckPass when
Labelsevery component is labelled standard, community extension or vendor feature, with an owner
Revisions and draftseach server's MCP revision and each draft dependency's revision are recorded
Previewnothing in production needs the public registry to be up or stable
Gatewaythe gateway-versus-server split of checks is written down; the server authorizes every call
Identity and hostsidentity setup checked against current MCP pages; hosts limited to approved servers

Exercises#

  1. The claims team wants a gateway product because "it does MCP authorization". Which checks may it take over, and which stay in uw-assessment?
  2. Your identity provider's guide links MCP revision 2025-06-18. What do you check before following it for a 2026-07-28 server?
  3. A developer proposes replacing the catalog with the public registry plus an "approved" tag in a fork. What is wrong?
AnswersOne line each
  1. It may reject what any server would reject (no token, wrong audience, expired, over the rate limit); scope per call, principal type and tenant need domain data and stay in the server.
  2. Compare each step with the current authorization pages: protected resource metadata, the resource parameter, audience validation, client registration (DCR is deprecated in 2026-07-28) and no passthrough downstream.
  3. The public registry accepts no private servers, its codebase is not designed for self-hosting, and it describes servers, not tools, so owners, scopes and risk tiers per tool would be lost; keep the catalog and generate any registry from it.
Why this site's example is not built on an SDK, and when yours should beA teaching subset shows the wire; a production server needs conformance

The example's server and client are a teaching subset of revision 2026-07-28, written from the specification with the standard library. That choice serves one purpose: every message is visible, and no SDK abstraction hides a check. It has a price the example states plainly: it is not conformance tested, and it leaves out SSE streams, subscriptions, pagination, multi round-trip requests, the Tasks extension and the real OAuth flow.

A production server should start from an SDK for the same reason a production HTTP service starts from a framework: framing, transports, header validation and error shapes are where subtle incompatibilities hide, and the SDK tiers measure exactly that against a shared conformance suite. The tier page's numbers are the useful ones: Tier 1 at a 100% pass rate, Tier 2 at 80%.

Writing your own protocol layer is defensible in three cases: a language with no official SDK at the tier you need, an environment where the SDK's dependencies are not allowed, or a very small surface (one tool, stdio only) where the protocol code is shorter than the SDK integration. In each case, run the official conformance suite against your server and record the result in the catalog entry, as you would for an SDK. Whatever you choose, the domain rules stay in the domain service; neither an SDK nor a hand-written layer should own them.

Questions to ask any gateway productA vendor-neutral checklist, derived from the specification's rules

No gateway product was read for this page, so none is named. These questions come from the rules the specification and this site rely on, and any product's own documentation should answer them before adoption.

Does it speak revision 2026-07-28: per-request _meta, no protocol sessions, server/discover, and the Mcp-Method and Mcp-Name headers? A gateway built for 2025-11-25 may depend on Mcp-Session-Id, which the current revision removed.

What does it do with the caller's token? It may validate it; it must not forward it to a service that would accept it as its own. If it obtains downstream tokens, by which grant, with which audience, and is the original principal recorded?

How does it cache lists? A tool list filtered by authorization is cacheScope private; a gateway that caches it across tokens shows one team's tools to another.

Can it hold back tools that are new or changed since a consumer's approval, using fingerprints, or only filter by scope? The second is not enough on a dynamic catalog (Advanced MCP).

What does it record? An audit event per call with principal, decision, sanitized arguments and correlation id, in a store the platform owns (Observability), and trace context propagated through _meta.

How does it fail? If the gateway is down, can the platform bypass it safely, or does every team stop? Who is on call for it?

And what stays in the server? Write down, per check, whether the gateway, the server or both perform it. The server must keep scope, principal type and tenant checks regardless.

Building on drafts, previews and Development conventionsFive moving parts under one platform, and how to keep them from moving you

As read on 2026-11-18, five things under the insurer's platform are not finished standards. The OAuth 2.1 document is at draft revision 17 while MCP cites revision 13. The ID-JAG format behind enterprise-managed authorization is at draft revision 06, and the extension's docs say vendors track different revisions. The OpenTelemetry MCP conventions have status Development, no release and still describe the 2025 protocol model. The public registry is in preview. And the Tasks extension is Beta on the extensions overview.

That is normal for a young ecosystem, and it does not mean waiting. It means isolating each moving part behind a seam you own. Put token validation behind one module whose tests pin the draft behavior you rely on. Pin attribute names in a small mapping layer, so a renamed OpenTelemetry attribute is one change. Treat the registry as a source to copy from on a schedule, never as a runtime dependency. Gate any Beta extension behind a catalog flag per server.

Then give each part a re-review trigger in the dependency record: a new draft revision, a convention release, the registry's general availability, a stage change. The MCP specification itself has the clearest rule of the set: deprecated features stay at least twelve months, or ninety days under the expedited exception. Nothing else on this page publishes a window like that, which is a reason to watch the others more closely, not less.

Registry entries and the server supply chainWhat a namespace proves, what it does not, and what to check before connecting

The registry's namespace check proves one thing: the publisher controls the GitHub account or domain in the server's name. For a package, the registry also checks a back-reference (an mcpName in package.json for npm, an mcp-name: line in the README for PyPI). For a remote server, the quickstart says the registry "does not verify that you control the remote URL". Security scanning is left to package registries and aggregators.

So a public entry is a pointer with a verified name, not a reviewed server. Before any host in the organization connects to one, treat it as a third-party dependency: pin the package version or the remote URL in the catalog, fingerprint the tool definitions at approval (Threat model), give it the narrowest scopes and no access to sensitive data, route it through egress control, and assign an owner who watches its releases. Registry metadata is immutable except its status, which helps: a version you approved will not be rewritten in place, but a new version needs a new review.

In one breath#

An MCP platform stands on a few standards (the MCP specification 2026-07-28, JSON-RPC 2.0, the OAuth RFCs) and on many things that are not finished or not standard: an OAuth 2.1 draft newer than the one MCP cites, Development-status tracing conventions, official SDKs with tiers and their own schedules, a registry in preview, a Stable extension resting on a draft grant, vendor pages that link older revisions. Label each one, record its version and date, and give it an owner and a re-review trigger. Then use products where they remove work, and keep the per-call authorization in the server, where the domain data is.

The insurer now has the protocol, the controls, the advanced patterns and a labelled map of what it can build them from. What it does not yet have is one picture that puts all of it together: the assessment service, the MCP adapter, the gateway, identity, the catalog, audit and the underwriter's decision path, with four teams on it and an owner for every box. That is Reference architecture.