Building a Serverless remote MCP Server on AWS - Part 1

/
├── src/
│   ├── routes/                # Defines the three required MCP routes
│   ├── controllers/           # Implements the route handlers
│   ├── services/              # Contains the MCP protocol implementation
│   ├── middleware/            # Validates MCP headers and handles errors
│   ├── app.ts                 # Express application setup
│   └── lambda.ts              # AWS Lambda entry point
└── lib/
    └── lambda-mcp-server-stack.ts  # AWS CDK infrastructure

// src/lambda.ts
import serverless from 'serverless-http';
import { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
import app from './app';

const serverlessHandler = serverless(app);

export const handler = async (event: APIGatewayProxyEvent, context: Context): Promise<APIGatewayProxyResult> => {
  const result = await serverlessHandler(event, context);
  return result as APIGatewayProxyResult;
};

// src/app.ts
import express, { Express } from 'express';
import { errorHandler } from './middleware/error-handler';
import { validateMcpHeaders } from './middleware/mcp-headers';
import mcpRoutes from './routes/mcp';

export const createApp = (): Express => {
  const app = express();

  // Parse JSON request bodies
  app.use(express.json());
  
  // Validate MCP headers
  app.use(validateMcpHeaders);
  
  // Route all /mcp requests to our MCP routes
  app.use('/mcp', mcpRoutes);  
  
  // Global error handler for JSON-RPC errors
  app.use(errorHandler);

  return app;
};

export default createApp();

// src/services/mcp-service.ts
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { Request, Response } from "express";
import appConfig from "../config/app-config";
import { registerTools } from "./mcp-tools";

export class McpService {
  async handleRequest(req: Request, res: Response): Promise<void> {
    
    const server = new McpServer({
      name: appConfig.server.name,
      version: appConfig.server.version
    });
    
    // Register all tools from the dedicated tools file
    registerTools(server);
    
    const transport: StreamableHTTPServerTransport = new StreamableHTTPServerTransport({
      sessionIdGenerator: undefined,
      enableJsonResponse: true,
    });
    
    res.on('close', () => {
      transport.close();
      server.close();
    });
    
    await server.connect(transport);
    await transport.handleRequest(req, res, req.body);
  }
}

export default new McpService();

// src/services/mcp-tools.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { z } from "zod";

export function registerTools(server: McpServer): void {
  // BMI Calculator
  server.tool(
    "calculate-bmi",
    "Tool used to calculate the BMI of the user when requested to do so",
    {
      weightKg: z.number(),
      heightM: z.number()
    },
    async ({ weightKg, heightM }) => ({
      content: [{
        type: "text",
        text: String(weightKg / (heightM * heightM))
      }]
    })
  );
  
  // Additional fitness related tools
}

// routes/mcp/index.ts
// ...
router.post('/', handlePost);
router.get('/', handleGet);
router.delete('/', handleDelete);
// ...

// controller/mcp/index.ts
//...
export const handlePost = async (req: Request, res: Response): Promise<void> => {
  try {
    await mcpService.handleRequest(req, res);
  } catch (error) {
//...
}

export class LambdaMcpServerStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const mcpFunction = new nodejs.NodejsFunction(this, 'mcpFunction', {
      runtime: lambda.Runtime.NODEJS_22_X,
      memorySize: 1024,
      architecture: lambda.Architecture.ARM_64,
      entry: path.join(__dirname, '../src/lambda.ts'),
      handler: 'handler',
    })

    const mcpApi = new apigatewayv2.HttpApi(this, 'mcpApi', {
      corsPreflight: {
        allowOrigins: ['REPLACE_WITH_ORIGIN'],
        allowHeaders: ['Content-Type', 'X-Amz-Date', 'Authorization', 'X-Api-Key', 'X-Amz-Security-Token', 'X-Amz-User-Agent'],
        allowMethods: [apigatewayv2.CorsHttpMethod.GET, apigatewayv2.CorsHttpMethod.POST]
      }
    })

    // Create a Lambda integration for the mcpFunction
    const mcpIntegration = new integrations.HttpLambdaIntegration('mcpFunctionIntegration', mcpFunction)
    
    // Add a catch-all route that forwards any request to the mcpFunction
    mcpApi.addRoutes({
      path: '/{proxy+}',
      integration: mcpIntegration
    })

    new cdk.CfnOutput(this, 'mcpApiUrl', {
      value: mcpApi.apiEndpoint
    })
  }
}

# Install dependencies
$ npm install

# Deploy MCP server
$ cdk deploy