Módulo de servidor MCP de NestJS

Un módulo NestJS para exponer sin esfuerzo herramientas, recursos y avisos para IA, desde sus aplicaciones NestJS utilizando el Protocolo de contexto de modelo (MCP) .

@rekog/mcp-nest gestiona la complejidad de configurar servidores MCP. Define herramientas, recursos y solicitudes de la forma habitual en NestJS y aprovecha al máximo la inyección de dependencias para utilizar tus servicios existentes.

Características

🚀 HTTP+SSE y transporte HTTP transmisible
🔍 tool automática, resource y descubrimiento y registro prompt
💯 Validación de solicitudes basada en Zod
📊 Notificaciones de progreso
Autenticación basada en guardia
⏱️ Ping SSE automático para mantener conexiones largas

Instalación

npm install @rekog/mcp-nest @modelcontextprotocol/sdk zod

Inicio rápido

1. Módulo de importación

// app.module.ts
import { Module } from '@nestjs/common';
import { McpModule } from '@rekog/mcp-nest';
import { GreetingTool } from './greeting.tool';

@Module({
  imports: [
    McpModule.forRoot({
      name: 'my-mcp-server',
      version: '1.0.0',
    }),
  ],
  providers: [GreetingTool],
})
export class AppModule {}

2. Definir herramientas y recursos

// greeting.tool.ts
import { Injectable } from '@nestjs/common';
import { Tool, Resource, Context } from '@rekog/mcp-nest';
import { z } from 'zod';
import { Progress } from '@modelcontextprotocol/sdk/types';

@Injectable()
export class GreetingTool {
  constructor() {}

  @Tool({
    name: 'hello-world',
    description:
      'Returns a greeting and simulates a long operation with progress updates',
    parameters: z.object({
      name: z.string().default('World'),
    }),
  })
  async sayHello({ name }, context: Context) {
    const greeting = `Hello, ${name}!`;

    const totalSteps = 5;
    for (let i = 0; i < totalSteps; i++) {
      await new Promise((resolve) => setTimeout(resolve, 500));

      // Send a progress update.
      await context.reportProgress({
        progress: (i + 1) * 20,
        total: 100,
      } as Progress);
    }

    return {
      content: [{ type: 'text', text: greeting }],
    };
  }

  @Resource({
    uri: 'mcp://hello-world/{userName}',
    name: 'Hello World',
    description: 'A simple greeting resource',
    mimeType: 'text/plain',
  })
  // Different from the SDK, we put the parameters and URI in the same object.
  async getCurrentSchema({ uri, userName }) {
    return {
      content: [
        {
          uri,
          text: `User is ${userName}`,
          mimeType: 'text/plain',
        },
      ],
    };
  }
}

¡Ya estás listo!

Puntos finales de API

GET /sse : punto final de conexión SSE (protegido por protectores si está configurado)
POST /messages : Punto final de ejecución de la herramienta (protegido por guardias si está configurado)

Consejos

Es posible utilizar el módulo con prefijo global, pero la forma recomendada es excluir esos puntos finales con:

app.setGlobalPrefix('/api', { exclude: ['sse', 'messages'] });

Autenticación

Puede proteger sus puntos finales de MCP utilizando NestJS Guards estándar.

1. Crea un guardia

Implementar la interfaz CanActivate . El guardián debe gestionar la validación de solicitudes (p. ej., comprobar JWT y claves API) y, opcionalmente, adjuntar información del usuario al objeto de solicitud.

Nada especial, consulte la documentación de NestJS para obtener más detalles.

2. Aplicar la protección

Transfiera sus protecciones a la configuración de McpModule.forRoot . Estas se aplicarán a los puntos finales /sse y /messages .

// app.module.ts
import { Module } from '@nestjs/common';
import { McpModule } from '@rekog/mcp-nest';
import { GreetingTool } from './greeting.tool';
import { AuthGuard } from './auth.guard';

@Module({
  imports: [
    McpModule.forRoot({
      name: 'my-mcp-server',
      version: '1.0.0',
      guards: [AuthGuard], // Apply the guard here
    }),
  ],
  providers: [GreetingTool, AuthGuard], // Ensure the Guard is also provided
})
export class AppModule {}

¡Listo! El resto es igual que con NestJS Guards.

Servicio de ping SSE

El módulo incluye un servicio de ping SSE que ayuda a mantener conexiones SSE de larga duración al evitar tiempos de espera del navegador/cliente. Esto es especialmente útil para clientes como IDE que utilizan el servidor MCP de forma remota.

Configuración

Puede configurar el comportamiento del ping SSE al importar el módulo:

// app.module.ts
import { Module } from '@nestjs/common';
import { McpModule } from '@rekog/mcp-nest';

@Module({
  imports: [
    McpModule.forRoot({
      name: 'my-mcp-server',
      version: '1.0.0',
      sse: {
        pingEnabled: true,        // Default is true
        pingIntervalMs: 30000,    // Default is 30 seconds (30000ms)
      },
    }),
  ],
})
export class AppModule {}

NestJS MCP Server Module

Integrations