What is Sample Serverless Mcp Servers

sample-serverless-mcp-servers is a collection of sample implementations of MCP Servers designed to run on AWS Serverless compute, showcasing both stateful and stateless architectures.

Use cases

Use cases include building applications that require persistent connections for real-time updates, such as chat applications, live dashboards, and collaborative tools.

How to use

To use sample-serverless-mcp-servers, clone the repository and follow the instructions in the README to deploy the sample implementations on AWS Lambda or ECS, depending on your needs.

Key features

Key features include the ability to implement both stateless and stateful MCP servers, support for Streamable HTTP Transport, and examples of handling long-lived connections and session management.

Where to use

sample-serverless-mcp-servers can be used in various domains where real-time data streaming and communication are required, such as IoT applications, live data feeds, and interactive web applications.

Sample Serverless MCP Servers

This repo contains a collection of sample implementations of MCP Servers.

Stateful VS Stateless MCP Servers

When using Streamable HTTP Transport with MCP Servers/Clients, it’s important to understand the difference and trade-offs between stateful and stateless MCP server implementations. Each model has implications for scalability, connection handling, and session management.

Key Aspects

The Streamable HTTP Transport specification outlines two important capabilities. First, a client may initiate a long-lived HTTP GET request to establish a persistent SSE (Server-Sent Events) connection, allowing the server to push data even when the client hasn’t sent a POST request. Second, if the connection is interrupted, the client should be able to resume communication by reconnecting through another GET request. Both features imply that the server must be able to maintain a persistent session context and support long-lived connections. Read more about Streamable HTTP Transport session management here.

Stateful model challenges

In a stateful MCP server, this means maintaining session state in memory and keeping SSE connections alive over time. However, as of early May 2025, none of the official MCP SDKs support external session persistence (e.g. in Redis or DynamoDB). This limitation makes it difficult to scale stateful servers horizontally. For example, a client might establish a session with one server instance, but if subsequent requests are routed to a different instance, the session context will be lost and the connection will fail.

That said, it is still possible to scale stateful MCP servers if you’re willing to configure session affinity, also known as sticky sessions, at the load balancer level. For example, cookie-based sticky sessions can ensure that a client is routed to the same server instance for the duration of a session. However, the TypeScript MCP Client SDK currently relies on the fetch API, which doesn’t natively support cookies. To work around this limitation, you’ll need to implement manual cookie handling, as shown in the stateful-mcp-on-ecs example.

Stateless to the rescue

The MCP specification also allows for a stateless server mode. In this mode, the server doesn’t maintain session context between requests, and clients are not expected to resume dropped connections. Stateless mode enables seamless horizontal scaling and works well in environments where elasticity and load distribution are critical. This model is demonstrated in the stateless-mcp-on-lambda, stateless-mcp-on-ecs, and stateless-mcp-on-lambda-python samples included in this repository.

Refer to each folder separately for further instructions and deployment steps.

License

This library is licensed under the MIT-0 License. See the LICENSE file.