From Serverless Framework to AWS CDK: Deploy Your MCP Server with Ease

Are you looking for more control over your serverless infrastructure? Do you want to define your cloud resources using familiar programming languages like TypeScript or Python? This article will guide you through rebuilding a minimal Model Context Protocol (MCP) server using AWS CDK (Cloud Development Kit), offering a powerful alternative to the Serverless Framework.

Why Choose AWS CDK for Serverless Deployment?

AWS CDK provides developers with fine-grained control over their cloud infrastructure. This is great for projects that need to scale or integrate with other AWS services. Here's why you might choose AWS CDK:

• Full Programmatic Control: Define infrastructure using TypeScript, Python, Java, C#, or Go.
• Seamless AWS Integration: Effortlessly connect your serverless app with other AWS services.
• Infrastructure as Code (IAC): Manage and version your infrastructure just like your application code.

Serverless Framework vs. AWS CDK: A Quick Comparison

Choosing the right infrastructure-as-code tool is crucial. Here's a table that compares the Serverless Framework, AWS SAM, and AWS CDK:

Project Goals: Deploying a Serverless MCP Server with AWS CDK

This project creates a basic setup for deploying an MCP server in a serverless environment using AWS CDK instead of the Serverless Framework. The goal is to create:

• An AWS Lambda function hosting the serverless MCP server
• An Amazon API Gateway with a POST /mcp route to access the server.

Deconstructing the Project Structure

The project is organized as follows:

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           # This documentation file

Fast Start: Setting Up Your AWS CDK Environment

Follow these simple steps to get your environment ready:

1. Install Dependencies:

   npm install
   

   Copy

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

   npm install -g aws-cdk
   

   Copy

3. Test Locally with Jest:

   npm run test
   

   Copy

AWS CDK Code Breakdown: Defining Your Infrastructure

The cdk-serverless-mcp-server-stack.ts file contains the core infrastructure definition. Here's a snippet of the code with explanations of key elements:

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); // Initialize the stack

    // Define runtime
    const runtime = lambda.Runtime.NODEJS_22_X

    // Create dependencies lambda layer
    const dependenciesLayerName = ' dependencies-layer '; // Name of the layer
    const dependenciesLayerFolder = ' layer/dependencies '; // Folder containing the layer code
    const dependenciesLayerDesc = ' Layer containing project dependencies '; // Description of the layer
    const dependenciesLayerProps = {
     code: lambda.Code.fromAsset(dependenciesLayerFolder), // Path to the layer code
     compatibleRuntimes: [runtime], // Specify the compatible runtimes
     description: dependenciesLayerDesc, // Description of the layer
    };
    const dependenciesLayer = new LayerVersion(this, dependenciesLayerName, dependenciesLayerProps);

    // Create lambda function
    const mcpLambda = new lambda.Function(this, 'McpHandler', {
      runtime: runtime, // The runtime environment for the Lambda function
      handler: 'index.handler', // The name of the exported function in our code
      code: lambda.Code.fromAsset('src'), // Path to our lambda function code
      timeout: Duration.seconds(29), // Set timeout to 29 seconds
      layers: [dependenciesLayer] // Add the layer to the lambda function
    });

    // Create API Gateway
    const api = new apigateway.RestApi(this, 'McpApi', {
      restApiName: ' MCP Service ', // The name of the API
    });

    // Add a resource and method to the API Gateway
    const mcpResource = api.root.addResource(' mcp '); // Create a resource named 'mcp'
    mcpResource.addMethod(' POST ', new apigateway.LambdaIntegration(mcpLambda)); // Add a POST method to the resource
  }
}

This code does the following:

• Sets up Node.js 22 support: Uses the NODEJS_22_X runtime for Lambda.
• Creates a custom Lambda Layer: Packages dependencies in a layer (layer/dependencies) to reduce function size and improve cold starts.
• Deploys a Lambda Function: Contains the MCP server code.
• Integrates with API Gateway: Creates a POST endpoint at /mcp to access the Lambda function.

Deploy Your Serverless MCP Server to AWS

Follow these steps to deploy your serverless application:

1. Install Dependencies for the Layer:

   npm run layer-dependencies-install
   

   Copy

2. Bootstrap the CDK: (Run this only once per AWS account)

   cdk bootstrap
   

   Copy

3. Deploy the Stack:

   cdk deploy
   

   Copy

After running cdk deploy, the CLI will output the URL of your live MCP server. Be sure to copy this endpoint!

Validate Deployment: Running Test Requests

After deployment, verify your server is working. In these examples, replace your-endpoint with the URL provided by the cdk deploy command.

Obtain Tools List

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
}'

Engage the Add Tool

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
    }
  }
}'

Conclusion

Congratulations! You've successfully deployed a serverless MCP server using AWS CDK. This approach offers greater control and flexibility compared to the Serverless Framework, particularly when integrating with other AWS services or managing complex infrastructure.