Supercharge Your Serverless MCP Server: Migrating from Serverless Framework to AWS CDK

Are you ready to elevate your serverless game? If you enjoyed building a serverless Model Context Protocol (MCP) server with AWS Lambda using the Serverless Framework, get ready for the next level. This guide walks you through rebuilding the same powerful serverless infrastructure using AWS CDK. Let’s dive into the world of Infrastructure as Code (IaC) with AWS CDK.

Why Choose AWS CDK for Your Serverless Deployment?

AWS CDK (Cloud Development Kit) offers a powerful approach to defining your infrastructure using familiar programming languages like TypeScript or Python. This can be a significant advantage over YAML or JSON, especially if you:

• Plan to integrate with other AWS services for more complex workflows.
• Need more programmatic control over your infrastructure deployment.
• Love writing code more than wrestling with configuration files.

CDK provides fine-grained control and scalability, making it perfect for complex serverless applications.

Serverless Framework vs. AWS SAM vs. AWS CDK: Which is Right for You?

Choosing the right IaC tool is crucial. Here’s a breakdown to help you decide:

Unpacking the AWS CDK Serverless MCP Repo

Our AWS CDK project creates:

• An AWS Lambda function, hosting your serverless MCP server.
• An Amazon API Gateway, providing a POST /mcp route for accessing your server.

The goal? A streamlined, deployable MCP server environment leveraging AWS CDK. You can find the complete code in this repo: 👉 cdk-serverless-mcp-server

Project Structure Unveiled

Here's how the project is organized:

cdk-serverless-mcp-server/
├── __tests__/                  # Jest tests
├── bin/                        # CDK entry point
│   └── cdk-serverless-mcp-server.ts  # CDK app
├── lib/                        # CDK stack
│   └── cdk-serverless-mcp-server-stack.ts  # CDK stack
├── src/                        # Source code
│   └── index.mjs               # MCP server handler
├── .gitignore                  # Git ignore file
├── cdk.json                    # CDK project config
├── package.json                # Project dependencies
├── package-lock.json           # Project lock file
└── README.md                   # Documentation file

Get Started with Serverless MCP on AWS CDK

Ready to deploy? Follow these steps:

1. Install Dependencies:

   npm install
   

   Copy

2. Install AWS CDK Globally: (Skip if already installed)

   npm install -g aws-cdk
   

   Copy

3. Run Local Tests: Give your code a quick check.

   npm run test
   

   Copy

Diving into the CDK Code

The cdk-serverless-mcp-server-stack.ts file holds the magic. Here's a snippet:

import { Stack, StackProps, Duration } from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as apigateway from 'aws-cdk-lib/aws-apigateway';
import { LayerVersion } from "aws-cdk-lib/aws-lambda";

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

    const runtime = lambda.Runtime.NODEJS_22_X;

    const dependenciesLayerName = 'dependencies-layer';
    const dependenciesLayerFolder = 'layer/dependencies';
    const dependenciesLayerDesc = 'Layer containing project dependencies';
    const dependenciesLayerProps = {
      code: lambda.Code.fromAsset(dependenciesLayerFolder),
      compatibleRuntimes: [ runtime ],
      description: dependenciesLayerDesc,
    };
    const dependenciesLayer = new LayerVersion(this, dependenciesLayerName, dependenciesLayerProps);

    const mcpLambda = new lambda.Function(this, 'McpHandler', {
      runtime: runtime,
      handler: 'index.handler',
      code: lambda.Code.fromAsset('src'),
      timeout: Duration.seconds(29),
      layers: [ dependenciesLayer ]
    });

    const api = new apigateway.RestApi(this, 'McpApi', {
      restApiName: 'MCP Service',
    });

    const mcpResource = api.root.addResource('mcp');
    mcpResource.addMethod('POST', new apigateway.LambdaIntegration(mcpLambda));
  }
}

Key components:

• Node.js 22 Support: CDK makes it simple to set the runtime.
• Custom Lambda Layer: Dependencies are packaged to improve reusability and reduce cold starts.
• API Gateway Integration: Expose your Lambda function using a POST method in just a few lines.

Deploying Your Serverless MCP Server to AWS

Follow these steps to launch your serverless MCP server:

1. Install Dependencies for the Layer:

   npm run layer-dependencies-install
   

   Copy

2. Bootstrap CDK: (One-time setup per AWS account)

   cdk bootstrap
   

   Copy

3. Deploy the Stack:

   cdk deploy
   

   Copy

After deployment, grab the API endpoint URL from the output.

Testing Your Deployed Serverless MCP

Let's use curl to test the API:

List Tools

Replace your-endpoint with your actual API endpoint.

curl --location 'https://your-endpoint/dev/mcp' \
--header 'content-type: application/json' \
--header 'accept: application/json' \
--header 'jsonrpc: 2.0' \
--data '{
"jsonrpc": "2.0",
"method": "tools/list",
"id": 1
}'

Add Tool

Again, replace your-endpoint with your API URL.

curl --location 'https://your-endpoint/dev/mcp' \
--header 'content-type: application/json' \
--header 'accept: application/json' \
--header 'jsonrpc: 2.0' \
--data '{
"jsonrpc": "2.0",
"id": 2,
"method": "tools/call",
"params": {
"name": "add",
"arguments": {
"a": 5,
"b": 3
}
}
}'

What's Next? Expanding Your Serverless Horizons

We've covered migrating to AWS CDK for your serverless MCP server. Stay tuned for more explorations with AWS SAM and beyond!