Skip to main content

Module 8: The MCP Ecosystem

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

Congratulations, You Know MCP​

You've now covered the complete theoretical foundation:

  • 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

In this final module, we step back and look at where MCP sits in the real world: who's using it, what's been built, and where it's going.

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
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

The list is growing. If a product markets itself as an "AI assistant" or "agentic tool," it likely either supports MCP already or will soon.

Notable MCP Servers​

The modelcontextprotocol/servers repository is the canonical home for reference implementations. As the ecosystem has matured, many early servers have been migrated to first-party maintainers (the vendors themselves) or archived. The list below reflects the current state.

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) started life in the reference repository and have since been archived to servers-archived as read-only references; the rest grew up as independent community projects from the start.

When evaluating a community server, check: is it actively maintained, who runs the security review, and is the published version recent.

Official SDK Support​

The MCP project maintains official SDKs for the most common languages. All are under the modelcontextprotocol GitHub organisation:

LanguageArtifactStatus (as of July 2026)
TypeScript/Node.js@modelcontextprotocol/sdkGA
Pythonmcp (PyPI)GA
Javaio.modelcontextprotocol.sdk:mcpGA. Current 2.0.0 (released 2026-06-11, tracks the 2025-11-25 spec); the previous 1.1.x line is still patched (latest 1.1.3) and 1.0.x still receives fixes (latest 1.0.2). Maintained with Spring AI. Follows SemVer with no formal LTS designation.
C#/.NETModelContextProtocol NuGetGA, current v2.0.0 (implements 2026-07-28). Maintained with Microsoft.
Gogithub.com/modelcontextprotocol/go-sdkGA, current v1.7.0 (implements 2026-07-28). Maintained with Google.
Rustrmcp crateGA, current rmcp v3.0.1 (implements 2026-07-28).
Kotlinio.modelcontextprotocol:kotlin-sdkPre-1.0 (current 0.15.0, still 2025-11-25). Maintained with JetBrains.
Swiftmcp-swift-sdkPre-1.0 (current 0.12.1).
Rubymcp gemGA, current 1.0.0 (first stable release, 2026-07-24).
PHPmcp/sdk (Packagist)Pre-1.0 (current 0.7.0). Maintained with The PHP Foundation.

Our Java SDK course uses the official Java SDK. It integrates cleanly with Spring Boot and provides all the building blocks for production-quality servers.

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. Most SDKs moved immediately: Python, C#, Go and Kotlin all shipped releases on ratification day, and Rust the day after. Java is the outlier. The Java SDK's latest release, 2.0.0 from 11 June 2026, predates ratification and still implements 2025-11-25 (the "first anniversary" release), which is what the code in these courses targets. That lag is not an accident, it is the tiering system at work: Java is a Tier 2 SDK, and the tiers exist precisely to set expectations about how quickly a given SDK tracks the specification. 2025-06-18 and 2025-03-26 also remain widely supported. Landmarks already shipped:

Streamable HTTP transport (introduced in the 2025-03-26 revision): the current standard HTTP transport. A single endpoint serves both POST requests and optional SSE streaming on the same path; session state moves to an MCP-Session-Id header. The older HTTP+SSE two-channel design is deprecated but still encountered in legacy deployments. (The MCP-Session-Id header was removed entirely in 2026-07-28, see below.)

OAuth authentication for HTTP servers (introduced in 2025-03-26, refined in 2025-06-18 and 2025-11-25): a standardised way to authenticate clients 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 support, OAuth 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, enabling interactive workflows.

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

Tasks (async operations) (introduced experimentally in 2025-11-25): specific request types (currently tools/call on the server side, plus sampling and elicitation requests in the client direction) can return a task handle when the receiving side declares the tasks capability, letting the requestor check status and fetch results later. Tasks move through states like working, input_required, completed, failed, and cancelled. (In 2026-07-28 tasks moved out of the core protocol into an official extension, io.modelcontextprotocol/tasks, and were redesigned around polling.)

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 schema definitions.

Linux Foundation governance (announced 9 December 2025): MCP became a founding project of the newly-formed Agentic AI Foundation (AAIF), a directed fund under the Linux Foundation. The AAIF was co-founded by Anthropic, Block, and OpenAI, with backing from Google, Microsoft, AWS, Cloudflare, and Bloomberg. MCP joined Block's goose agent and OpenAI's AGENTS.md as the AAIF's founding projects, and the 2025-11-25 spec formalised Working Groups and an SDK tiering system.

The 2026-07-28 revision (ratified 28 July 2026): the largest change since MCP launched, and worth reading in full before you plan any migration. Protocol-level sessions are gone: the Mcp-Session-Id header and the initialize / notifications/initialized handshake are both removed, and every request now carries its protocol version and client capabilities in _meta instead (SEP-2567, SEP-2575). A new server/discover RPC, which servers MUST implement, advertises supported versions, capabilities and identity. Server-initiated requests (roots/list, sampling/createMessage, elicitation/create) give way to the Multi Round-Trip Requests pattern: the server returns a result with resultType: "input_required", and the client retries the original request carrying the answers (SEP-2322). resources/subscribe and the HTTP GET stream are replaced by a single subscriptions/listen stream, and ping plus logging/setLevel are removed outright. 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).

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 unreliable: roughly four in ten public projects that use the official Java SDK directly are themselves Spring Boot applications, which had the Spring AI starter available and did not take it. The criterion that actually separates the four is what you are building.

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, directlyMakes no assumption about how your tools are declared
Working in Quarkus, or targeting a native imageQuarkus MCP ServerCDI annotations, 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​

You've completed the MCP Fundamentals course. You understand the protocol better than most people building with it.

The next step depends on your goal:

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
  • Spring AI is the recommended framework for Java-based MCP client applications
  • The ecosystem is growing fast; MCP is becoming the default integration standard for AI tooling