MCP Server Aurora Serverless v2 — ACU scaling, connection limits, session state

Aurora Serverless v2 vs v1 vs provisioned: choosing for MCP

ACU capacity and connection limits

Each Aurora Capacity Unit (ACU) provides approximately 2 GB of memory and 2 vCPUs. Aurora computes max_connections dynamically based on available memory using this formula for PostgreSQL:

max_connections ≈ LEAST(  floor(memory_in_bytes / 9531392), 5000  )
-- For Aurora PostgreSQL:
-- 0.5 ACU (1 GB RAM)  → ~90 connections
-- 1 ACU   (2 GB RAM)  → ~190 connections
-- 2 ACU   (4 GB RAM)  → ~390 connections
-- 4 ACU   (8 GB RAM)  → ~800 connections
-- 8 ACU  (16 GB RAM)  → ~1600 connections
-- 16 ACU (32 GB RAM)  → ~3200 connections

The connection limit cliff: if your cluster is at 0.5 ACU (idle) and a burst of 200 Lambda invocations all try to connect simultaneously, each trying to open one connection to Aurora, the 91st connection fails with FATAL: remaining connection slots are reserved for non-replication superuser connections. Aurora will scale up in ~1 second, but the connections that failed during that 1-second window are already gone. The Lambda invocations that got rejected must retry — and by the time they retry, Aurora has scaled up and can accept more connections.

This is why RDS Proxy is important even with Aurora Serverless v2: the proxy holds a stable pool of connections to Aurora, and Lambda invocations connect to the proxy. The proxy queues connection requests if Aurora hasn't scaled up yet, rather than immediately returning an error to Lambda.

CDK configuration for Aurora Serverless v2

import * as rds from "aws-cdk-lib/aws-rds";
import * as ec2 from "aws-cdk-lib/aws-ec2";

const cluster = new rds.DatabaseCluster(this, "McpSessionDb", {
  engine: rds.DatabaseClusterEngine.auroraPostgres({
    version: rds.AuroraPostgresEngineVersion.VER_15_4,
  }),
  serverlessV2MinCapacity: 0.5,   // ~90 connections at idle; minimum in most regions
  serverlessV2MaxCapacity: 16,    // ~3200 connections at peak; adjust based on load
  writer: rds.ClusterInstance.serverlessV2("writer", {
    // Scale-up target: Aurora scales when CPU exceeds 40% or connection count rises
    scaleWithWriter: true,
  }),
  readers: [
    // Optional: add a reader for read-heavy MCP tools
    rds.ClusterInstance.serverlessV2("reader", {
      scaleWithWriter: false, // Reader scales independently
    }),
  ],
  vpc,
  vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
  securityGroups: [dbSecurityGroup],
  defaultDatabaseName: "mcpdb",
  storageEncrypted: true,
  backup: { retention: Duration.days(7) },
  // Enable IAM authentication for passwordless Lambda connections
  iamAuthentication: true,
});

Schema for MCP session state

Aurora is well-suited for storing MCP session state when the state requires relational integrity, ACID transactions, or complex queries across sessions. A minimal schema for MCP session state:

-- Sessions table: one row per active MCP session
CREATE TABLE mcp_sessions (
  session_id   UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  client_id    TEXT NOT NULL,
  created_at   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
  last_ping_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
  metadata     JSONB,
  -- Index for cleanup queries (purge sessions older than X hours)
  CONSTRAINT check_last_ping CHECK (last_ping_at >= created_at)
);
CREATE INDEX idx_sessions_last_ping ON mcp_sessions (last_ping_at);

-- Tool call log: records each tool invocation for observability
CREATE TABLE mcp_tool_calls (
  id           BIGSERIAL PRIMARY KEY,
  session_id   UUID NOT NULL REFERENCES mcp_sessions(session_id) ON DELETE CASCADE,
  tool_name    TEXT NOT NULL,
  called_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
  duration_ms  INTEGER,
  result_ok    BOOLEAN NOT NULL,
  error_msg    TEXT
);
CREATE INDEX idx_tool_calls_session ON mcp_tool_calls (session_id, called_at DESC);

-- Automatic cleanup: delete sessions idle for more than 2 hours
-- Run via pg_cron or a scheduled Lambda
DELETE FROM mcp_sessions
WHERE last_ping_at < NOW() - INTERVAL '2 hours';

Monitoring Aurora Serverless v2 scaling

Key CloudWatch metrics to track for Aurora Serverless v2 in MCP workloads:

Common failure modes