Skip to main content

Class 8: The MCP Ecosystem

Duration: ~20 minutes | Level: Beginner | Prerequisites: Class 7: Security and Trust

What the Previous Seven Classes Covered​

The protocol itself is now behind us:

  • Why MCP exists: write the integration once, not once per application (or per model)
  • The architecture: host, client, server, model
  • The three primitives: tools, resources, prompts
  • The protocol: JSON-RPC, message types, error handling
  • The transports: stdio for local, Streamable HTTP for remote (with HTTP+SSE as a deprecated legacy option)
  • Capability negotiation: per-request metadata now, the initialize handshake before 2026-07-28
  • Security: trust boundaries, least privilege, prompt injection

MCP Clients (Where You Connect Your Server)​

MCP clients are embedded in AI host applications. The following are confirmed MCP-compatible as of 2025-2026:

ClientTypeNotes
Claude DesktopDesktop AI assistantAnthropic's own; first-class MCP support
ChatGPTDesktop and web AI assistantNamed by the MCP documentation, alongside Claude, as an assistant that supports MCP
CursorAI code editorSupports both stdio and HTTP servers
ZedCode editorIntegrated MCP for context and tooling
GitHub CopilotAI coding assistantMicrosoft's integration
ContinueVS Code/JetBrains pluginOpen-source; broad MCP support
WindsurfAI code editorOriginally by Codeium; acquired by Cognition in July 2025
ClineVS Code agentOpen-source autonomous agent
LibreChatSelf-hosted chat UICommunity deployment

Notable MCP Servers​

The modelcontextprotocol/servers repository is the canonical home for reference implementations. Many early servers have moved to first-party maintainers (the vendors themselves) or been archived.

Currently maintained in modelcontextprotocol/servers​

  • Everything, a reference implementation that exercises every primitive (tools, resources, prompts, sampling)
  • Fetch, URL fetching and HTML-to-markdown conversion
  • Filesystem, safe, sandboxed local file access
  • Git, repository operations on local clones
  • Memory, persistent knowledge graph for AI memory
  • Sequential Thinking, structured reasoning helper
  • Time, time and timezone utilities

Maintained by their respective vendors (first-party)​

Community / third-party​

A long tail of community servers exists for Slack, Gmail, Google Calendar, Postgres, MongoDB, Docker, Kubernetes, Obsidian, Discord, Puppeteer, and many more domains. Only a few of these (Slack, Postgres, Puppeteer) began in the reference repository and have since been archived to servers-archived as read-only references.

When evaluating a community server, check: is it actively maintained, who runs the security review, and is the published version recent. Installing a server runs its code with your credentials, and the specification treats tool descriptions and annotations as untrusted unless the server is one you trust. Pin an exact version. The quickstart in the reference repository, npx -y @modelcontextprotocol/server-memory, installs whatever is newest that day, and its README calls those reference servers educational examples instead of production-ready solutions.

Official SDK Support​

The MCP project maintains official SDKs for the most common languages, all under the modelcontextprotocol GitHub organisation. In the table, GA marks a stable, general-availability release, and pre-1.0 an SDK whose API may still change. The tier is a maintenance promise: Tier 1 implements new protocol features before the revision ships, Tier 2 within six months, and Tier 3 without any timeline commitment.

LanguageArtifactTierSpec revisionStatus (September 2026)
TypeScript/Node.js@modelcontextprotocol/sdk12026-07-28GA
Pythonmcp (PyPI)12026-07-28GA
Javaio.modelcontextprotocol.sdk:mcp22025-11-25GA. Current 2.0.1, released 2026-08-19; the previous 1.1.x line is still patched (latest 1.1.4) and 1.0.x still receives fixes (latest 1.0.2). Maintained with Spring AI. Follows SemVer, and does not designate any release as long-term support.
C#/.NETModelContextProtocol NuGet12026-07-28GA, current v2.2.0. Maintained with Microsoft.
Gogithub.com/modelcontextprotocol/go-sdk12026-07-28GA, current v1.7.0. Maintained with Google.
Rustrmcp crate12026-07-28GA, current rmcp v3.2.0.
Kotlinio.modelcontextprotocol:kotlin-sdk32025-11-25Pre-1.0, current 0.15.0. Maintained with JetBrains.
Swiftmcp-swift-sdk3Pre-1.0, current 0.12.1.
Rubymcp gem2GA, current 1.5.0; the first stable release, 1.0.0, came on 2026-07-24.
PHPmcp/sdk (Packagist)3Pre-1.0, current 0.8.1. Maintained with The PHP Foundation.

These version numbers move: the official SDK page has the current tier for each SDK, and Maven Central the current Java version.

Our Java SDK course uses the official Java SDK, which integrates cleanly with Spring Boot.

The Protocol's Evolution​

The current stable specification is 2026-07-28, ratified on 28 July 2026, and it is the largest revision since MCP launched. Four SDKs spoke it on ratification day: TypeScript, Python, Go and C#, with the Rust SDK supporting it in beta the same day. The Java SDK is behind: its latest release, 2.0.1 from 19 August 2026, still implements 2025-11-25 (the "first anniversary" release), which is what the code in these courses targets. That lag is the tiering system at work, because a Tier 2 SDK has six months to implement a revision. 2025-06-18 and 2025-03-26 also remain widely supported.

Every revision so far, and what each one added:

RevisionDateWhat landed
2024-11-05November 2024The first revision: stdio and the HTTP+SSE transport
2025-03-26March 2025Streamable HTTP; OAuth 2.1 authorization for HTTP servers
2025-06-18June 2025Elicitation; structured tool output; RFC 8707 Resource Indicators required; the MCP-Protocol-Version header
2025-11-25November 2025Tasks (experimental); icons; JSON Schema 2020-12 as the default dialect; OpenID Connect Discovery; Client ID Metadata Documents; Working Groups and SDK tiering
2026-07-28July 2026Per-request _meta in place of sessions; server/discover; Multi Round-Trip Requests; subscriptions/listen; required resultType; required request headers; ttlMs and cacheScope

The versioning rules call 2025-11-25 and earlier legacy, and 2026-07-28 and later modern. A client that speaks only modern fails against a server that speaks only legacy, so a server built on the Java SDK today needs clients that speak both eras. A dual-era client finds out which era it is talking to by probing:

The body of that 400 Bad Request decides it: a modern server answers a bad modern request with a recognised modern error, so any other body marks the server as legacy.

Streamable HTTP transport (introduced in the 2025-03-26 revision): the current standard HTTP transport, replacing the two-channel HTTP+SSE design, which is deprecated but still encountered in legacy deployments. Session state moved to an Mcp-Session-Id header, which 2026-07-28 removed along with sessions themselves.

HTTP+SSE (2024-11-05, deprecated)Streamable HTTP (as of 2026-07-28)
Endpointsa GET endpoint that opens an SSE stream, plus a separate POST endpointa single MCP endpoint that accepts POST
How the client learns the POST URLfrom an endpoint event, the first event on the SSE streamit is the URL the user configured
Where server messages arriveon the one long-lived SSE streamper request: a JSON body, or an SSE stream scoped to that request

OAuth authentication for HTTP servers (introduced in 2025-03-26, refined in 2025-06-18 and 2025-11-25): how clients authenticate to HTTP-based MCP servers, built on OAuth 2.1, RFC 9728 Protected Resource Metadata, and RFC 8707 Resource Indicators. The 2025-11-25 revision adds OpenID Connect Discovery, Client ID Metadata Documents for client registration, and mandates PKCE verification. Covered in the Remote MCP Servers course.

Server-initiated elicitation (introduced in 2025-06-18): servers can ask the user (through the client) for additional information mid-tool-call using JSON-Schema-validated forms.

Structured tool output (introduced in 2025-06-18): strongly typed tool return values via the optional structuredContent field on CallToolResult, alongside the existing content array:

{
  "jsonrpc": "2.0",
  "id": 5,
  "result": {
    "content": [
      { "type": "text", "text": "{\"temperature\": 22.5, \"conditions\": \"Partly cloudy\"}" }
    ],
    "structuredContent": { "temperature": 22.5, "conditions": "Partly cloudy" }
  }
}

The text block repeats the same data as a string, so a client that reads only content still works.

Tasks (async operations) (introduced experimentally in 2025-11-25): tools/call on the server side, plus sampling and elicitation in the client direction, can return a task handle when the receiving side declares the tasks capability. (In 2026-07-28 tasks moved out of the core protocol into an official extension, io.modelcontextprotocol/tasks, and were redesigned around polling.) The handle lets the requestor check status and fetch results later, and the task moves through five states:

input_required is the only state that leads back to working.

Icons and metadata (introduced in 2025-11-25): servers can attach icons to tools, resources, resource templates, and prompts; is now the default dialect for MCP schemas.

Linux Foundation governance (announced 9 December 2025): MCP became a founding project of the Agentic AI Foundation (AAIF), a directed fund under the Linux Foundation, co-founded by Anthropic, Block and OpenAI with backing from Google, Microsoft, AWS, Cloudflare and Bloomberg. It joined Block's goose and OpenAI's AGENTS.md as the AAIF's founding projects.

The 2026-07-28 revision (ratified 28 July 2026) removes protocol-level sessions (SEP-2567, SEP-2575). The changelog lists what was replaced:

Up to 2025-11-25From 2026-07-28
initialize and notifications/initializedprotocol version and client capabilities in every request's _meta
capabilities learned from the initialize resultserver/discover, which servers MUST implement, advertising supported versions, capabilities and identity
the Mcp-Session-Id headerremoved with protocol-level sessions
resources/subscribe, resources/unsubscribe and the HTTP GET streamone subscriptions/listen stream
roots/list, sampling/createMessage and elicitation/create sent by the serverMulti Round-Trip Requests: the server answers resultType: "input_required" and the client retries
pingremoved
logging/setLevelio.modelcontextprotocol/logLevel in _meta, set per request
notifications/roots/list_changedremoved
Last-Event-ID stream resumptionthe client re-issues the request under a new id

The Multi Round-Trip Requests row changes how a server is written (SEP-2322). A server can no longer send a request of its own, so it answers with a result that asks for input and waits for the client to come back:

The second tools/call carries the same parameters plus the answers, under a new JSON-RPC id: the specification treats the retry as an independent request.

Four smaller changes in the same revision will affect your code. Every result gains a required resultType field, complete or input_required, and a result from an older server that omits it MUST be read as complete. Error codes were renumbered, and one range is now reserved for the specification itself:

CodeMeaningStatus in 2026-07-28
-32000 to -32019implementation-definedleft to the SDKs, existing usage grandfathered
-32020 to -32099reservedallocated to the MCP specification
-32602invalid paramsnow also carries resource-not-found, which was -32002 up to 2025-11-25

Streamable HTTP also requires routing headers on every POST, so a gateway can route a call without reading the body:

HeaderSource fieldRequired for
Mcp-Methodmethodevery request
Mcp-Nameparams.name or params.uritools/call, resources/read, prompts/get
Mcp-Param-{name}a tool parameter annotated x-mcp-headerwhen the tool definition declares it

ttlMs and cacheScope become required on the results of tools/list, prompts/list, resources/list, resources/templates/list and resources/read, giving clients a freshness hint instead of a reason to poll.

Finally, Roots, Sampling and Logging are deprecated (SEP-2577) under a new feature-lifecycle policy that guarantees a minimum twelve-month window before anything is removed (SEP-2596), and Dynamic Client Registration is deprecated in favour of OAuth Client ID Metadata Documents.

Building on Top of MCP​

Several frameworks are emerging that use MCP as a foundation rather than implementing it directly:

LangChain / LangGraph: the popular Python agent framework has MCP tool integrations, allowing MCP servers to be used as LangChain tools.

LangChain4j: the Java counterpart to LangChain, and the main alternative to Spring AI for JVM developers who aren't already in the Spring ecosystem. Its dev.langchain4j:langchain4j-mcp module is an MCP client, supporting stdio and Streamable HTTP; server-side support lives separately in LangChain4j Community.

Spring AI: Spring's official AI framework has first-class MCP support, including auto-discovery and registration of MCP tools as Spring AI tools.

AI SDK (Vercel): TypeScript SDK with MCP client support for Next.js and Node.js applications.

Choosing a Java Path​

This course is technology-agnostic, but the JVM has four distinct MCP implementations, and choosing between them is a common source of confusion.

The intuitive criterion, use whichever framework you already use, turns out to be a weak one. Being a Spring Boot application does not settle the question, because plenty of Spring Boot projects reach for the official Java SDK directly. What decides it is how your tools are declared: fixed at compile time, or assembled while the application is running. The questions, in the order worth asking them:

The first question does the most work: tools assembled while the application is running rule out Spring AI and Quarkus MCP Server, which both declare tools with annotations at compile time.

If you areUseWhy
Building a new service, tools known at compile timeSpring AIAnnotate a bean; the starter wires transport, discovery and registration
Adding MCP to an application or runtime you do not control, or generating tools at runtimeThe official Java SDK, directlyDoes not assume anything about how your tools are declared
Working in Quarkus, or targeting a native image (an ahead-of-time compiled binary)Quarkus MCP ServerCDI annotations (Jakarta Contexts and Dependency Injection), and an implementation independent of the SDK
Already building with LangChain4jlangchain4j-mcpA capable client; its server-side support is limited

Where to Find MCP Servers​

What's Next​

That is the end of the MCP Fundamentals course. You have the protocol, its primitives, its transports and its trust boundaries, which the implementation courses assume you are bringing with you.

If you want to build MCP servers in Java → Building MCP Servers in Java →

If you want to build agents that consume MCP servers → Spring AI + MCP Integration →

If you want to design larger systems → MCP Architecture Patterns (coming soon)

If you want to ship to production → Remote MCP Servers and Securing Production MCP (both coming soon)

If you want to test what you build → Testing & Observability (coming soon)

If you want to understand more protocol nuance → Read the official MCP specification

If you want context before building → Check the Blog for practical insights and real-world patterns

Key Takeaways​

  • MCP has broad client adoption: Claude Desktop, Cursor, GitHub Copilot, Zed, and more
  • Thousands of community servers cover most common integration scenarios; check before building
  • Official GA SDKs exist for TypeScript, Python, Java, C#/.NET, Go, Rust, and Ruby, with Kotlin, Swift, and PHP still pre-1.0
  • The protocol is now governed under the Linux Foundation as a vendor-neutral standard
  • On the JVM, pick between Spring AI, the Java SDK, Quarkus and LangChain4j by what you are building, and not by the framework the surrounding application already uses
  • The current revision is 2026-07-28; most SDKs track it, and the Java SDK 2.0.1 still implements 2025-11-25

Further Reading​

  • Key Changes (specification 2026-07-28): the normative list of every change this class summarises, with the SEP number behind each one.
  • Versioning and Compatibility: the legacy and modern eras, and the matrix of which client and server combinations work.
  • Multi Round-Trip Requests: the full rules for the pattern that replaced server-initiated sampling, elicitation and roots requests.
  • Streamable HTTP: the transport as it stands now, including the required headers and the probe for older servers.
  • SDKs: the official list of the ten SDKs and the current tier of each, which is where to check whether the table above has gone stale.
  • Feature Lifecycle and Deprecation Policy: the Active, Deprecated and Removed states, and the twelve-month minimum window that now governs Roots, Sampling and Logging.
  • The New MCP Roadmap: the workstreams the maintainers named for the next revision.

Sources​