Protocols & Interop

MCP Reference ServersProtocols

The clearest way to understand the Model Context Protocol is to read servers that implement it correctly, and this is that collection. Useful both as working connectors and as the template to copy when writing your own.

Context7Protocols

Ask for a library by name and Context7 resolves it to an identifier like /vercel/next.js, then answers queries with version-specific snippets from a continuously re-indexed documentation corpus — so the model writes against the API that exists today rather than the one in its training data. Setup is one command or a URL pasted into any MCP client, and anyone can submit a public repository to the index. Know what you are adopting: the open-source part is a thin client, while the crawler, parser and index are Upstash's private hosted service — the free tier stops at 1,000 calls a month, and when the hosted endpoint went down for a stretch in August 2026, the tool had nothing to answer from.

chrome-devtools-mcpProtocols

It hands an agent a live Chrome plus the instruments of DevTools: it records a performance trace and reads out Core Web Vitals with named insights, lists network requests and source-mapped console errors, runs Lighthouse audits, and still clicks and fills forms from a text snapshot of the page the way browser MCPs do. It can attach to the Chrome you already have open, profile and all — which is also where care is needed. The trade against Playwright MCP is scope: this is Chrome-only, and what that buys is analysis no cross-browser server offers.

playwright-mcpComputer Use

Playwright MCP puts a real Chrome, Firefox, WebKit or Edge behind an MCP server and returns each page as an accessibility snapshot: a text outline of roles, names and reference ids that the agent clicks and types into, with no vision model and no coordinate guessing. Past plain navigation it can mock network requests, read and write cookies and web storage, record a trace or a video, and emit Playwright locators and assertions, which makes it a practical way to turn a session you drove by hand into a test you can check in. The cost is context: Microsoft's own README points coding agents at the Playwright CLI with skills instead, because the tool definitions and the snapshots compete for the same window as your codebase. It earns its keep in long-running loops, where holding one browser open across many turns is worth paying that.

github-mcp-serverProtocols

Point Claude, Copilot, Cursor or any other MCP client at it and the model can triage an issue, open and review a pull request, search code it has never downloaded, and read the logs of a failed Actions run — all through the GitHub API, so nothing is cloned. The remote server GitHub hosts needs no local setup or runtime at all; the same local server runs as a container or a single binary, and is the only route for GitHub Enterprise Server. The trade-off is breadth: more than eighty tools sit across twenty-odd toolsets, and only five toolsets are on by default for good reason — turning everything on gives most models more choices than they handle well.

composioTools & Integrations

Composio hands an agent a catalogue of ready-made actions spread across more than a thousand apps — create a GitHub issue, fetch Gmail threads — and keeps each of your users' account connections stored and refreshed, so you never write a sign-in flow yourself. A session is scoped to one user and by default gives the model only a handful of meta tools for finding, authenticating and running things at runtime, so hundreds of tool definitions never fill the context window; app events arrive as signed webhooks, and the agent gets a persistent Python sandbox to work in. The trade-off is that none of that machinery is yours: you gain a thousand integrations you did not have to build, and give up the ability to change any of them.

FastMCPTools & Integrations

A decorator over a typed Python function is a complete tool: the schema is derived from the type hints and docstring, and both the arguments coming in and the value going out are validated for you. Beyond that it covers the parts a second week of work runs into — a typed client, OAuth and remote identity providers, mounting several servers as one, proxying an existing server, and middleware. The confusion to be aware of is the name: an earlier version of this API was absorbed into the official MCP Python SDK, so FastMCP refers to two different things depending on which import you read.

A2AProtocols

A2A defines how separately built agents advertise their capabilities, exchange messages and track work that may outlive one connection. Version 1.0 separates a shared data model and operations from JSON-RPC, gRPC and HTTP/REST bindings, while official SDKs live in other repositories. Use it between autonomous services that need task state, streaming or asynchronous updates; a database query or other bounded tool call still belongs behind MCP, and adopting the specification does not supply an agent, a registry or authorization policy.

AG-UIProtocols

A request-and-response API cannot describe an agent that runs for minutes, streams partial work, changes its mind and occasionally needs a person. AG-UI defines that exchange as a stream of events over HTTP and WebSockets: tokens, tool calls and their results, shared state, attachments, and interrupts where the run stops to ask. Its usefulness scales with what already implements it — a first-party list that includes several frameworks in this catalogue — and drops sharply if neither your backend nor your frontend does.

MCP InspectorProtocols

Connects to an MCP server you are developing and lets you call its tools, read its resources and render its prompts one at a time, checking each response as it comes back. It starts from npx with nothing installed, as a web UI, a scriptable CLI for CI, or a terminal TUI — all from the same command. It is a development-time check, not production monitoring or evals.

mcp-useProtocols

Most MCP servers return text and leave the client to render it. mcp-use is built around the opposite idea: a tool can carry a React view, so what the user sees inside ChatGPT or Claude is an interface rather than a paragraph. Tool inputs and outputs are declared with Zod schemas and those types flow through to the view's props, so a change in one place shows up as a type error in the other. A scaffolded project comes with an inspector at a local URL for calling tools and looking at views while you work, and a tunnel for testing against a real client. Version 2 is a rewrite around this server-and-view model; the earlier Python client library is no longer where the project's attention is.

AWS MCP ServersProtocols

Point Claude, Cursor, Kiro or any other MCP client at one of these servers and the model can search current AWS documentation, write CloudFormation and CDK against AWS's own guidance, query DynamoDB or PostgreSQL, read CloudWatch logs and estimate costs — each capability is its own small server, started with one uvx command and your AWS credentials. Two need no setup at all: the hosted Knowledge server answers documentation questions without an AWS account, and the preview AWS MCP Server reaches the AWS APIs under IAM permissions with CloudTrail logging. The open question is longevity: AWS announced the Agent Toolkit for AWS in May 2026 as this suite's successor, recommends it for production agent work, and says the most useful servers here will move into it over time.

Model Context ProtocolProtocols

The document every MCP client and server is measured against: a TypeScript schema published alongside a JSON Schema, plus the prose defining what a conforming implementation must do. Anthropic donated it to the Linux Foundation's Agentic AI Foundation in December 2025, and the licence is mid-transition — new code and specification text under Apache-2.0, documentation under CC-BY-4.0, and contributions whose authors have not consented to relicensing still MIT. Read it when an SDK's behaviour surprises you, but it is a document rather than a dependency: shipping anything still means picking one of the language SDKs.

mcp-agentFrameworks

mcp-agent makes a narrow bet: if every tool an agent needs arrives over MCP, the framework can be small. It handles the tedious half of that — opening, holding and closing connections to MCP servers — and then supplies the well-known compositions from Anthropic's "Building Effective Agents" as pieces you can nest: a router that picks a specialist, an orchestrator that plans and delegates, an evaluator that sends work back for another pass. The same agent can be published as an MCP server itself. For runs that must survive a crash it can execute on Temporal, which brings pause and resume at the cost of a service to operate.

OpenLLMetryObservability

Every other option in this category is a product with its own backend, which means adopting one adds a system to run and a place where half your telemetry lives apart from the rest. This is the instrumentation layer instead: it emits standard OpenTelemetry spans for model and vector-database calls, and those go to Datadog, Grafana, New Relic, Splunk, Honeycomb or wherever your existing traces go. The trade is that a general-purpose backend shows spans and latencies, not the prompt-versioning and evaluation views a dedicated platform is built around.

agentgatewayGuardrails

A Rust data plane that sits between agents and everything they call — model providers, MCP servers, other agents — so authentication, RBAC, rate limits and OpenTelemetry export are configured once instead of reimplemented in every agent. Solo.io donated it to the Linux Foundation in August 2025 and it moved under the Agentic AI Foundation in June 2026, alongside MCP and goose. It is young for something that sits in the request path: per-user identity onto downstream MCP servers is still an open issue, so confirm the authentication model you need before putting it in front of production traffic.

ContextForgeProtocols

The MCP problem an organisation hits is not writing a server, it is that after a year there are forty of them, nobody has a list, and each client is configured by hand. ContextForge is the registry and proxy for that situation: servers are registered once and discovered from one place, existing REST and gRPC services can be exposed as MCP without being rewritten, A2A agents are routed the same way, and authentication, rate limits and tracing are applied centrally instead of per server. It is itself a compliant MCP server, so clients see one endpoint. The weight is the obvious cost — this is infrastructure with a database, a cache and a Kubernetes story, which is a lot to run if you have three servers rather than forty.