Serverless Scaling: Deploying Strands + MCP on AWS

This content originally appeared on DEV Community and was authored by Om Shree

In this Article, we’ll explore how to deploy a Strands Agent connected to an MCP server using serverless AWS services. We’ll cover three deployment models—Lambda (native & web adapter) and Fargate—and compare their pros, limitations, and recommended scenarios.

1. Introduction

Strands Agents SDK provides a convenient model-driven loop, while MCP enables dynamic tool invocation. Deploying them on AWS serverless platforms allows you to build scalable, maintainable agents without managing servers¹.

2. Deployment Options Overview

3. Native AWS Lambda (Stateless MCP)

Approach: Package your MCP server as a Lambda function using FastMCP with HTTP transport³.

# lambda_mcp.py
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("lambda-mcp", stateless_http=True)

@mcp.tool()
def echo(message: str) -> str:
    return message

def lambda_handler(event, context):
    return mcp.handle_lambda_event(event, context)

How to Deploy:

zip function.zip lambda_mcp.py

aws lambda create-function \
  --function-name lambdaMcp \
  --runtime python3.9 \
  --handler lambda_mcp.lambda_handler \
  --zip-file fileb://function.zip \
  --role <LAMBDA_IAM_ROLE_ARN> \
  --timeout 900

Optionally, expose it via API Gateway:

aws apigateway create-rest-api --name mcpAPI
# Configure /mcp POST integration with the Lambda function

Benefits:

• Fast cold starts
• Simplified deployment for stateless tools
• Integrated with AWS native monitoring

Limitations:

• No streaming support
• 15-minute execution timeout
• No persistent state between invocations

4. Lambda + Web Adapter (Containerized MCP)

Approach: Package MCP within a web framework (FastAPI, Flask, or Express) inside a Lambda Web Adapter container. This enables web-like behavior within Lambda.

Dockerfile:

FROM public.ecr.aws/lambda/python:3.9
COPY app.py requirements.txt ./
RUN pip install -r requirements.txt
CMD ["app.lambda_handler"]

app.py Example:

from fastmcp import FastMCP
from aws_lambda_adapter import api_gateway_handler

mcp = FastMCP("web-mcp", stateless_http=True)
app = mcp.app

def lambda_handler(event, context):
    return api_gateway_handler(app, event, context)

Deploy via AWS CDK Example:

from aws_cdk import (
    aws_lambda as _lambda,
    aws_apigateway as apigw,
    Stack
)
from constructs import Construct

class WebAdapterStack(Stack):
    def __init__(self, scope, id, **kwargs):
        super().__init__(scope, id, **kwargs)

        fn = _lambda.DockerImageFunction(self, "WebMCPFn",
            code=_lambda.DockerImageCode.from_image_asset("path/to/dockerfile")
        )

        apigw.LambdaRestApi(self, "ApiGateway", handler=fn)

Benefits:

• Allows existing web frameworks
• Flexible HTTP routing via API Gateway
• Serverless, pay-per-use

Limitations:

• Added container and adapter complexity
• Cold start delays (1–3 seconds)
• Still no native streaming support

5. AWS Fargate (Containerized MCP)

Approach: Fully containerize the MCP server and deploy on AWS Fargate via ECS or EKS. Suitable for agents requiring persistent sessions and streaming².

Dockerfile:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt ./
RUN pip install -r requirements.txt
COPY mcp_server.py ./
CMD ["python", "mcp_server.py"]

mcp_server.py Example:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("fargate-mcp", stateless_http=True, port=8080)

@mcp.tool()
def echo(message: str) -> str:
    return message

if __name__ == "__main__":
    mcp.run(transport="streamable-http")

CDK Deployment Example:

from aws_cdk import (
    aws_ecs as ecs,
    aws_ecs_patterns as patterns,
    aws_ecr_assets as assets,
    Stack
)
from constructs import Construct

class FargateStack(Stack):
    def __init__(self, scope, id, **kwargs):
        super().__init__(scope, id, **kwargs)

        docker_image = assets.DockerImageAsset(self, "McpImage",
            directory="path/to/dockerfile"
        )

        patterns.ApplicationLoadBalancedFargateService(
            self, "FargateMCPService",
            task_image_options={
                "image": ecs.ContainerImage.from_docker_image_asset(docker_image)
            },
            desired_count=2,
            public_load_balancer=True
        )

Benefits:

• Full streaming and persistent workloads supported
• Scalability with ECS or EKS
• Suitable for production-grade deployments

Limitations:

• More costly than Lambda for low-usage patterns
• Slightly longer deploy cycles
• Requires container orchestration setup

6. Choosing the Right Model

• Use Native Lambda for testing, short-lived tasks, low traffic.
• Add Web Adapter when integrating with web apps or frameworks.
• Choose Fargate for streaming, persistent workloads, or higher performance needs⁴³.

7. Key Considerations

• Security & Observability: Lambda and Fargate integrate with X-Ray, CloudWatch, IAM, and OpenTelemetry²³.
• Cost & Scaling: Lambda is cost-effective for burst workloads; Fargate favors steady or stream-heavy usage⁴.
• Developer Experience: Native Lambda offers fastest dev loop; Fargate supports production parity and long-lived workflows³.

8. Next Steps

1. Start with a proof-of-concept using native Lambda + FastMCP.
2. Expand to include frameworks via Web Adapter for structured web API support.
3. Move to a containerized MCP + agent deployment on Fargate via Strands’ sample projects¹.

References

1. AWS “Open Protocols for Agent Interoperability Part 3: Strands Agents & MCP” 

2. Heeki Park, “Building an MCP server as an API developer”  

3. Ran Isenberg, “Serverless MCP on AWS: Lambda vs. Fargate for Agentic AI Workloads” 

4. Vivek V, “Implementing Nova Act MCP Server on ECS Fargate” 

This content originally appeared on DEV Community and was authored by Om Shree