Feature Request: Middleware support for McpServer

[ahammednibras8]

Is your feature request related to a problem? Please describe.
I've been
working on a secure MCP server (a "Zero Trust" database bridge) and found myself
needing to apply the same logic across multiple tools—such as logging every
request, checking permissions, or validating schemas.

Currently, I have to manually wrap every single tool handler function to add
this logic. This leads to repetitive code and makes it easy to accidentally miss
a tool. For example, if I want to log every tool call, I have to copy-paste the
logging code into every server.tool(...) definition.

Describe the solution you'd like
would love to see a server.use() method
added to McpServer, similar to how Express or Koa handle middleware. This
would allow developers to define logic once and have it automatically run for
every tool or resource request.

Ideally, it could look something like this:

const server = new McpServer({ name: "my-server", version: "1.0.0" });

// Global logging middleware
server.use(async (ctx, next) => {
    console.log(`Calling tool: ${ctx.request.method}`);
    await next();
});

This would make the code much cleaner and ensure that important checks (like
auth) are never skipped.

Describe alternatives you've considered
A clear and concise description of any alternative solutions or features you've considered.

Additional context
I am new to contributing to this project, but I would be
very happy to try implementing this feature if the team thinks it's a good idea!
I'm open to any guidance on how best to fit this into the existing architecture.

[eddienubes]

Another use-case for middlewares we've discovered is event/activity tracking server-side.
E.g. we'd like to intercept the first tools/list and the tools return by that call as a single event.

Currently, we do it by serializing the RPC request (body) ourselves, checking .method === tools/list and saving it together with tools we just registered in the same request lifecycle.

I feel like extra serialization is unnecessary here and the SDK could provide hooks/middleware for easy access to RPC request/response objects.

[ahammednibras8]

That’s a great point — intercepting the full request lifecycle (request +
response) is exactly the kind of cross-cutting concern that’s hard to handle
cleanly today.

I’m working on a minimal request-level hook that runs once per RPC call (before
tool dispatch) so things like logging, auth, and event aggregation can be
handled centrally without re-serializing requests or wrapping individual tools.

I’ll keep the scope tight and share a PR once there’s something concrete to
review.

[felixweinberger]

We closed #1345 in favor of handler composition (see the close comment there for the pattern). Is there a specific use case where withAuth(withLogging(handler)) style composition falls short? Happy to discuss if there's something that genuinely needs framework-level machinery rather than function wrapping.

[eddienubes]

@felixweinberger Hm.. I see, that looks like a viable approach, I don't have any objections.
Wdyt @ahammednibras8?

[ahammednibras8]

Composition works, but the developer needs to remember to apply it. if they forget, it becomes a security hole. With middleware it's non-skippable, which is why middleware is the safer guarantee. Both work, but composition puts the responsibility on the developer every time.
With AI-assisted coding this may become less of a concern, but if we can guarantee it at the SDK level, that's a stronger foundation regardless of how the code is written.

@felixweinberger

[kamranayub]

FWIW, the C# SDK implements this using Filters which I find a little more intuitive. It guarantees your filters will be called and you can even differentiate between Incoming and Outgoing filters, making it easy to do things like "filter the tools being returned".

In FastMCP, it's just middleware.

The main issue with leaving this up to a framework is that the frameworks are all HTTP-based, which leaves a gap for STDIO servers. Exposing a native way to do this under the transport layer might make sense. Using this workaround, you could make your own pipeline but the ergonomics are not great.

One workaround/approach that seems to be the easiest is to capture the original setRequestHandler and overwrite it. I'm doing this in a TS project and it's working:

// Capture the original handler, making sure to bind it to the server object
const originalSetRequestHandler = server.server.setRequestHandler.bind(server.server);

// Replace the method altogether so you can inject a wrapped handler
server.server.setRequestHandler = (schema, handler) => {
  return originalSetRequestHandler(schema, async (request, extra) => {
      console.error(`Received request for method: ${request.method}`);
    return handler(request, extra);
  });
};

[kamranayub]

Here is a more complete middleware example if you just want to roll it yourself.

middleware.ts

import type {
  JSONRPCRequest,
  Result,
} from "@modelcontextprotocol/sdk/types.js";
import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
import {
  type ServerNotification,
  type ServerRequest,
} from "@modelcontextprotocol/sdk/types.js";
import type {
  McpServer,
  RegisteredTool,
} from "@modelcontextprotocol/sdk/server/mcp.js";

// Middleware system with chaining support
type MiddlewareHandler = (
  request: JSONRPCRequest,
  extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
  next: () => Promise<Result>,
) => Promise<Result>;

export function withMiddleware(server: McpServer) {
  const middlewares: MiddlewareHandler[] = [];
  const originalSetRequestHandler = server.server.setRequestHandler.bind(
    server.server,
  );

  // Override setRequestHandler to inject middleware chain
  server.server.setRequestHandler = (schema, handler) => {
    return originalSetRequestHandler(schema, async (request, extra) => {
      // Build middleware chain from the end
      let index = 0;

      const next = async (): Promise<Result> => {
        if (index < middlewares.length) {
          const middleware = middlewares[index++];
          return middleware(request, extra, next);
        }
        // End of chain - call the actual handler
        return handler(request, extra);
      };

      return next();
    });
  };

  return {
    use(middleware: MiddlewareHandler) {
      middlewares.push(middleware);
      return this; // Allow chaining
    },
  };
}

// Logging middleware
export function logging(): MiddlewareHandler {
  return async (request, extra, next) => {
    const startTime = Date.now();
    console.error(
      `[Middleware:Logging] → ${request.method} (request_id: ${extra.requestId})`,
    );

    const result = await next();

    const duration = Date.now() - startTime;
    console.error(
      `[Middleware:Logging] ← ${request.method} completed in ${duration}ms`,
    );

    return result;
  };
}

// Caching middleware (simulated)
export function caching(): MiddlewareHandler {
  const cache = new Map<string, { value: any; expires: number }>();

  return async (request, extra, next) => {
    // Only cache tool calls (check if it looks like a tool-related request)
    if (request.method === "tools/call") {
      const params = request.params ?? {};
      delete params._meta; // Remove non-essential params from cache key
      const cacheKey = JSON.stringify({ method: request.method, params });
      const cached = cache.get(cacheKey);

      if (cached && Date.now() < cached.expires) {
        console.error(
          `[Middleware:Caching] 🎯 Cache HIT for ${request.method}`,
        );
        return cached.value;
      }

      console.error(`[Middleware:Caching] ❌ Cache MISS for ${request.method}`);
      const result = await next();

      // Cache for 5 seconds
      cache.set(cacheKey, { value: result, expires: Date.now() + 5000 });

      return result;
    }

    return next();
  };
}

server.ts

import { caching, logging, withMiddleware } from "./middleware.ts";

const server = new McpServer({
  name: "Middleware Demo",
  version: "1.0.0",
});

// Initialize middleware chain
withMiddleware(server)
  .use(logging())
  .use(caching());

Inspector