feat: Initial MCP server for GenAI plugin (#397)

Author: niallthomson

.pre-commit-config.yaml

@@ -26,5 +26,5 @@ repos:
       - id: lint
         language: node
         name: Run linting
-        entry: yarn lint-staged
+        entry: yarn lint-staged --no-stash
         stage: [commit]

plugins/genai/backend/package.json

@@ -45,6 +45,7 @@
     "@backstage/config": "^1.2.0",
     "@backstage/plugin-catalog-node": "^1.14.0",
     "@langchain/core": "0.3.57",
+    "@modelcontextprotocol/sdk": "^1.12.3",
     "@types/express": "*",
     "express": "^4.17.1",
     "express-promise-router": "^4.1.0",

plugins/genai/backend/src/plugin.ts

@@ -32,6 +32,7 @@ import {
   createBackstageTechDocsSearchTool,
 } from './tools';
 import { DatabaseSessionStore } from './database';
+import { McpService } from './service/McpService';
 
 export const awsGenAiPlugin = createBackendPlugin({
   pluginId: 'aws-genai',
@@ -94,10 +95,13 @@ export const awsGenAiPlugin = createBackendPlugin({
           sessionStore,
         });
 
+        const mcpService = await McpService.fromConfig(agentService);
+
         httpRouter.use(
           await createRouter({
             logger: winstonLogger,
             agentService,
+            mcpService,
             httpAuth,
             discovery,
             auth,

plugins/genai/backend/src/service/DefaultAgentService.ts

@@ -31,6 +31,7 @@ import {
   ChatEvent,
   ChatSession,
   GenerateResponse,
+  SyncResponse,
 } from '@aws/genai-plugin-for-backstage-common';
 import { SessionStore } from '../database';
 
@@ -111,6 +112,10 @@ export class DefaultAgentService implements AgentService {
     return service;
   }
 
+  getAgents(): Agent[] {
+    return Array.from(this.agents.values());
+  }
+
   async stream(
     userMessage: string,
     options: {
@@ -133,7 +138,7 @@ export class DefaultAgentService implements AgentService {
     const agent = this.getActualAgent(options.agentName);
 
     if (!sessionId) {
-      session = await this.createSession(agentName, principal, false);
+      session = await this.makeSession(agentName, principal, false);
 
       newSession = true;
     } else {
@@ -172,6 +177,19 @@ export class DefaultAgentService implements AgentService {
     return this.sessionStore.getSession(agentName, sessionId, principal);
   }
 
+  async createSession(options: {
+    agentName: string;
+    credentials: BackstageCredentials<
+      BackstageUserPrincipal | BackstageServicePrincipal
+    >;
+  }): Promise<ChatSession> {
+    const { agentName, credentials } = options;
+
+    const { principal } = await this.getUserEntityRef(credentials);
+
+    return this.makeSession(agentName, principal, false);
+  }
+
   async endSession(options: {
     agentName: string;
     sessionId: string;
@@ -186,6 +204,35 @@ export class DefaultAgentService implements AgentService {
     await this.sessionStore.endSession(agentName, sessionId, principal);
   }
 
+  async sync(
+    userMessage: string,
+    options: {
+      agentName: string;
+      sessionId?: string;
+      credentials: BackstageCredentials<
+        BackstageUserPrincipal | BackstageServicePrincipal
+      >;
+    },
+  ): Promise<SyncResponse> {
+    const { principal, userEntityRef } = await this.getUserEntityRef(
+      options.credentials,
+    );
+
+    const agent = this.getActualAgent(options.agentName);
+
+    const session = await this.makeSession(options.agentName, principal, true);
+
+    const output = agent.generate(userMessage, session.sessionId, {
+      userEntityRef,
+      credentials: options.credentials,
+    });
+
+    return {
+      output,
+      sessionId: session.sessionId,
+    };
+  }
+
   async generate(
     prompt: string,
     options: {
@@ -201,11 +248,7 @@ export class DefaultAgentService implements AgentService {
 
     const agent = this.getActualAgent(options.agentName);
 
-    const session = await this.createSession(
-      options.agentName,
-      principal,
-      true,
-    );
+    const session = await this.makeSession(options.agentName, principal, true);
 
     return agent.generate(prompt, session.sessionId, {
       userEntityRef,
@@ -227,7 +270,7 @@ export class DefaultAgentService implements AgentService {
     return this.agents.get(agent);
   }
 
-  private createSession(agent: string, principal: string, ended: boolean) {
+  private makeSession(agent: string, principal: string, ended: boolean) {
     const sessionId = uuidv4();
 
     this.logger.info(`Generated session ${sessionId}`);

plugins/genai/backend/src/service/McpService.ts

@@ -0,0 +1,100 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { BackstageCredentials } from '@backstage/backend-plugin-api';
+import { AgentService } from './types';
+import { Server as McpServer } from '@modelcontextprotocol/sdk/server/index.js';
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { version } from '@aws/genai-plugin-for-backstage-backend/package.json';
+
+export class McpService {
+  public constructor(private readonly agentService: AgentService) {}
+
+  static async fromConfig(agentService: AgentService) {
+    return new McpService(agentService);
+  }
+
+  getServer(options: { agentName: string; credentials: BackstageCredentials }) {
+    const { agentName, credentials } = options;
+
+    const agent = this.agentService.getAgent(agentName);
+
+    if (!agent) {
+      throw new Error(`Agent ${agentName} not found`);
+    }
+
+    const server = new McpServer(
+      {
+        name: `backstage-${agentName}`,
+        version,
+      },
+      { capabilities: { tools: {} } },
+    );
+
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [
+          {
+            inputSchema: {
+              type: 'object',
+              properties: {
+                query: {
+                  type: 'string',
+                  description: 'A natural language question for the agent.',
+                },
+              },
+              required: ['query'],
+            },
+
+            name: agent.getName(),
+            description: agent.getDescription(),
+            annotations: {
+              destructiveHint: true,
+              idempotentHint: false,
+              readOnlyHint: false,
+              openWorldHint: true,
+            },
+          },
+        ],
+      };
+    });
+
+    server.setRequestHandler(CallToolRequestSchema, async ({ params }) => {
+      if (params.arguments?.query) {
+        const result = await this.agentService.generate(
+          params.arguments.query as string,
+          {
+            agentName: params.name,
+            credentials,
+          },
+        );
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: result.output,
+            },
+          ],
+        };
+      }
+
+      throw new Error('No query provided');
+    });
+
+    return server;
+  }
+}

plugins/genai/backend/src/service/router.ts

@@ -30,10 +30,13 @@ import {
   ChatEvent,
   EndSessionRequest,
 } from '@aws/genai-plugin-for-backstage-common';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { McpService } from './McpService';
 
 export interface RouterOptions {
   logger: LoggerService;
   agentService: AgentService;
+  mcpService: McpService;
   discovery: DiscoveryService;
   auth?: AuthService;
   httpAuth?: HttpAuthService;
@@ -42,7 +45,7 @@ export interface RouterOptions {
 export async function createRouter(
   options: RouterOptions,
 ): Promise<express.Router> {
-  const { logger, agentService } = options;
+  const { logger, agentService, mcpService } = options;
 
   const router = Router();
   router.use(express.json());
@@ -139,6 +142,41 @@ export async function createRouter(
     response.status(200).send();
   });
 
+  router.post('/v1/mcp/:agent', async (request, response) => {
+    const { agent } = request.params;
+
+    const credentials = await httpAuth.credentials(request);
+
+    try {
+      const server = mcpService.getServer({
+        agentName: agent,
+        credentials,
+      });
+      const transport: StreamableHTTPServerTransport =
+        new StreamableHTTPServerTransport({
+          sessionIdGenerator: undefined,
+        });
+      response.on('close', () => {
+        transport.close();
+        server.close();
+      });
+      await server.connect(transport);
+      await transport.handleRequest(request, response, request.body);
+    } catch (error) {
+      logger.error('Error handling MCP request:', error as Error);
+      if (!response.headersSent) {
+        response.status(500).json({
+          jsonrpc: '2.0',
+          error: {
+            code: -32603,
+            message: 'Internal server error',
+          },
+          id: null,
+        });
+      }
+    }
+  });
+
   router.get('/health', (_, response) => {
     logger.info('PONG!');
     response.json({ status: 'ok' });

plugins/genai/backend/src/service/types.ts

@@ -15,10 +15,16 @@ import {
   ChatEvent,
   ChatSession,
   GenerateResponse,
+  SyncResponse,
 } from '@aws/genai-plugin-for-backstage-common';
 import { BackstageCredentials } from '@backstage/backend-plugin-api';
+import { Agent } from '../agent/Agent';
 
 export interface AgentService {
+  getAgents(): Agent[];
+
+  getAgent(agentName: string): Agent | undefined;
+
   stream(
     userMessage: string,
     options: {
@@ -28,6 +34,15 @@ export interface AgentService {
     },
   ): Promise<ReadableStream<ChatEvent>>;
 
+  sync(
+    userMessage: string,
+    options: {
+      agentName: string;
+      sessionId?: string;
+      credentials: BackstageCredentials;
+    },
+  ): Promise<SyncResponse>;
+
   generate(
     prompt: string,
     options: {
@@ -36,6 +51,11 @@ export interface AgentService {
     },
   ): Promise<GenerateResponse>;
 
+  createSession(options: {
+    agentName: string;
+    credentials: BackstageCredentials;
+  }): Promise<ChatSession>;
+
   endSession(options: {
     agentName: string;
     sessionId: string;

plugins/genai/common/src/types.ts

@@ -26,6 +26,11 @@ export interface AgentRequestOptions {
   token: string;
 }
 
+export interface SyncResponse {
+  sessionId: string;
+  output: any;
+}
+
 export interface GenerateResponse {
   output: any;
 }