fastify-mcp-server MCP工具

Install dependencies

npm install

Installation

npm install fastify-mcp-server @modelcontextprotocol/sdk

Docker Compose Example

A docker-compose.yaml is provided for local development with Redis:

docker compose up -d
npm run dev:redis

Setup

```bash

Quick Start

import Fastify from 'fastify';
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import FastifyMcpServer, { getMcpDecorator } from 'fastify-mcp-server';

const app = Fastify({ logger: true });

// Create MCP server factory function
function createMcpServer () {
  const mcp = new McpServer({
    name: 'my-mcp-server',
    version: '1.0.0'
  });

  // Define MCP tools
  mcp.tool('hello-world', () => ({
    content: [{ type: 'text', text: 'Hello from MCP!' }]
  }));

  return mcp;
}

// Register the plugin
await app.register(FastifyMcpServer, {
  createMcpServer,
  endpoint: '/mcp' // optional, defaults to '/mcp'
});

// Get MCP decorator for advanced features
const mcpServer = getMcpDecorator(app);

// Start the server
await app.listen({ host: '127.0.0.1', port: 3000 });

Advanced Usage

Use Cases

• Custom Session IDs: Generate session IDs that match your existing ID format or include specific metadata
• Session Initialization Hooks: Perform custom logic when sessions are created (e.g., logging, metrics, notifications)
• Transport Configuration: Fine-tune transport behavior for specific deployment requirements

Example: Custom Session ID with Prefix

await app.register(FastifyMcpServer, {
  createMcpServer,
  transportOptions: {
    sessionIdGenerator: () => {
      return `mcp-prod-${randomUUID()}`;
    }
  }
});

Quick Demo

To quickly see the plugin in action, you can run the demo server:

```bash

Plugin Options

type FastifyMcpServerOptions = {
  createMcpServer: () => McpServer; // MCP Server factory function
  endpoint?: string; // Custom endpoint path (default: '/mcp')
  authorization?: {
    // Authorization configuration
    bearerMiddlewareOptions: {
      verifier: OAuthTokenVerifier; // Custom verifier for Bearer tokens
      requiredScopes?: string[]; // Optional scopes required for access
      resourceMetadataUrl?: string; // Optional URL for resource metadata
    };
    oauth2?: {
      // OAuth2 metadata configuration
      authorizationServerOAuthMetadata: OAuthMetadata; // OAuth metadata for authorization server
      protectedResourceOAuthMetadata: OAuthProtectedResourceMetadata; // OAuth metadata for protected resource
    };
  };
  sessionStore?: SessionStore; // Optional custom session store implementation
  transportOptions?: StreamableHTTPServerTransportOptions; // Optional transport configuration options
};

Custom Transport Options

You can customize the behavior of the underlying StreamableHTTPServerTransport by providing transportOptions when registering the plugin. This allows you to configure advanced transport features such as custom session ID generation and transport lifecycle callbacks.

Available Options

import type { StreamableHTTPServerTransportOptions } from '@modelcontextprotocol/sdk/server/streamableHttp.js';

await app.register(FastifyMcpServer, {
  createMcpServer,
  transportOptions: {
    // Custom session ID generator function
    sessionIdGenerator: () => {
      // Return your custom session ID
      return `custom-${Date.now()}-${Math.random()}`;
    },
    // Callback invoked when session is initialized
    onsessioninitialized: async (sessionId) => {
      console.log(`Session ${sessionId} initialized`);
    }
    // Additional StreamableHTTPServerTransport options...
  }
});

API Reference

Endpoints

• GET /.well-known/oauth-authorization-server — Returns the OAuth authorization server metadata.
• GET /.well-known/oauth-protected-resource — Returns the OAuth protected resource metadata.

These endpoints are registered only if the corresponding metadata options are provided.

Fastify MCP Server Plugin

A robust Fastify plugin that provides seamless integration with the Model Context Protocol (MCP) through streamable HTTP transport. This plugin enables your Fastify applications to act as MCP servers, allowing AI assistants and other clients to interact with your services using the standardized MCP protocol.

Comparison