awslabs.elasticache-mcp-server 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

awslabs/elasticache_mcp_server/tools/cc/connect.py

@@ -19,7 +19,7 @@ from ...common.decorators import handle_exceptions
 from ...common.server import mcp
 from ...context import Context
 from botocore.exceptions import ClientError
-from typing import Any, Dict, Tuple, Union
+from typing import Any, Dict, Optional, Tuple, Union
 
 
 async def _configure_security_groups(
@@ -252,18 +252,20 @@ async def get_ssh_tunnel_command_cc(
 @handle_exceptions
 async def create_jump_host_cc(
     cache_cluster_id: str,
-    subnet_id: str,
-    security_group_id: str,
     key_name: str,
+    subnet_id: Optional[str] = None,
+    security_group_id: Optional[str] = None,
     instance_type: str = 't3.small',
 ) -> Dict[str, Any]:
     """Creates an EC2 jump host instance to access an ElastiCache cluster via SSH tunnel.
 
     Args:
         cache_cluster_id (str): ID of the ElastiCache cluster to connect to
-        subnet_id (str): ID of the subnet to launch the EC2 instance in (must be public)
-        security_group_id (str): ID of the security group to assign to the EC2 instance
         key_name (str): Name of the EC2 key pair to use for SSH access
+        subnet_id (str, optional): ID of the subnet to launch the EC2 instance in (must be public).
+            If not provided and cache uses default VPC, will auto-select a default subnet.
+        security_group_id (str, optional): ID of the security group to assign to the EC2 instance.
+            If not provided and cache uses default VPC, will use the default security group.
         instance_type (str, optional): EC2 instance type. Defaults to "t3.small"
 
     Returns:
@@ -306,6 +308,59 @@ async def create_jump_host_cc(
         )['CacheSubnetGroups'][0]
         cache_vpc_id = cache_subnet_group['VpcId']
 
+        # Check if cache is in default VPC
+        vpcs = ec2_client.describe_vpcs(VpcIds=[cache_vpc_id])['Vpcs']
+        cache_vpc = vpcs[0] if vpcs else None
+        is_default_vpc = cache_vpc and cache_vpc.get('IsDefault', False)
+
+        # Auto-select subnet if not provided and cache is in default VPC
+        if not subnet_id and is_default_vpc:
+            # Get default subnets in the default VPC
+            subnets = ec2_client.describe_subnets(
+                Filters=[
+                    {'Name': 'vpc-id', 'Values': [cache_vpc_id]},
+                    {'Name': 'default-for-az', 'Values': ['true']},
+                ]
+            )['Subnets']
+
+            if subnets:
+                # Pick the first available default subnet
+                subnet_id = subnets[0]['SubnetId']
+            else:
+                # Fallback to any public subnet in the VPC
+                all_subnets = ec2_client.describe_subnets(
+                    Filters=[{'Name': 'vpc-id', 'Values': [cache_vpc_id]}]
+                )['Subnets']
+
+                for subnet in all_subnets:
+                    if subnet.get('MapPublicIpOnLaunch', False):
+                        subnet_id = subnet['SubnetId']
+                        break
+
+        # Auto-select security group if not provided and cache is in default VPC
+        if not security_group_id and is_default_vpc:
+            # Get the default security group for the VPC
+            security_groups = ec2_client.describe_security_groups(
+                Filters=[
+                    {'Name': 'vpc-id', 'Values': [cache_vpc_id]},
+                    {'Name': 'group-name', 'Values': ['default']},
+                ]
+            )['SecurityGroups']
+
+            if security_groups:
+                security_group_id = security_groups[0]['GroupId']
+
+        # Validate required parameters after auto-selection
+        if not subnet_id:
+            raise ValueError(
+                'subnet_id is required. Either provide a subnet_id or ensure the cache cluster is in the default VPC with default subnets available.'
+            )
+
+        if not security_group_id:
+            raise ValueError(
+                'security_group_id is required. Either provide a security_group_id or ensure the cache cluster is in the default VPC.'
+            )
+
         # Get subnet details and verify it's public
         subnet_response = ec2_client.describe_subnets(SubnetIds=[subnet_id])
         subnet = subnet_response['Subnets'][0]
@@ -318,6 +373,7 @@ async def create_jump_host_cc(
             )
 
         # Check if subnet is public by looking for route to internet gateway
+        # or if it's a default subnet in the default VPC (which are automatically public)
         route_tables = ec2_client.describe_route_tables(
             Filters=[{'Name': 'association.subnet-id', 'Values': [subnet_id]}]
         )['RouteTables']
@@ -331,9 +387,38 @@ async def create_jump_host_cc(
             if is_public:
                 break
 
+        # If no explicit route table association, check the main route table for the VPC
+        if not is_public and not route_tables:
+            main_route_tables = ec2_client.describe_route_tables(
+                Filters=[
+                    {'Name': 'vpc-id', 'Values': [subnet_vpc_id]},
+                    {'Name': 'association.main', 'Values': ['true']},
+                ]
+            )['RouteTables']
+
+            for rt in main_route_tables:
+                for route in rt.get('Routes', []):
+                    if route.get('GatewayId', '').startswith('igw-'):
+                        is_public = True
+                        break
+                if is_public:
+                    break
+
+        # If not found via route table, check if it's a default subnet in default VPC
+        if not is_public:
+            # Check if this is the default VPC
+            vpcs = ec2_client.describe_vpcs(VpcIds=[subnet_vpc_id])['Vpcs']
+            vpc = vpcs[0] if vpcs else None
+
+            if vpc and vpc.get('IsDefault', False):
+                # In default VPC, check if this is a default subnet
+                # Default subnets have MapPublicIpOnLaunch set to True
+                if subnet.get('DefaultForAz', False) or subnet.get('MapPublicIpOnLaunch', False):
+                    is_public = True
+
         if not is_public:
             raise ValueError(
-                f'Subnet {subnet_id} is not public (no route to internet gateway found). '
+                f'Subnet {subnet_id} is not public (no route to internet gateway found and not a default subnet in default VPC). '
                 'The subnet must be public to allow SSH access to the jump host.'
             )
 

awslabs/elasticache_mcp_server/tools/cw/get_metric_statistics.py

@@ -65,7 +65,17 @@ async def get_metric_statistics(
 
     # Add optional parameters
     if dimensions:
-        params['Dimensions'] = [{'Name': k, 'Value': v} for d in dimensions for k, v in d.items()]
+        # Ensure dimensions are properly formatted as [{'Name': name, 'Value': value}, ...]
+        formatted_dimensions = []
+        for d in dimensions:
+            # Check if the dimension is already in the correct format
+            if 'Name' in d and 'Value' in d:
+                formatted_dimensions.append(d)
+            else:
+                # Convert from {key: value} format to {'Name': key, 'Value': value}
+                for k, v in d.items():
+                    formatted_dimensions.append({'Name': k, 'Value': v})
+        params['Dimensions'] = formatted_dimensions
     if statistics:
         params['Statistics'] = statistics
     if extended_statistics:

awslabs/elasticache_mcp_server/tools/rg/connect.py

@@ -19,7 +19,7 @@ from ...common.decorators import handle_exceptions
 from ...common.server import mcp
 from ...context import Context
 from botocore.exceptions import ClientError
-from typing import Any, Dict, List, Tuple, Union
+from typing import Any, Dict, Optional, Tuple, Union
 
 
 async def _configure_security_groups(
@@ -52,28 +52,21 @@ async def _configure_security_groups(
         ReplicationGroupId=replication_group_id
     )['ReplicationGroups'][0]
 
-    # Get primary cluster details
-    primary_cluster_id = None
-    for member in replication_group['MemberClusters']:
-        cluster = elasticache_client.describe_cache_clusters(
-            CacheClusterId=member, ShowCacheNodeInfo=True
-        )['CacheClusters'][0]
-        if cluster['CacheClusterRole'].lower() == 'primary':
-            primary_cluster_id = member
-            break
+    # Get first cluster details (MemberClusters doesn't have notion of primary cluster)
+    if not replication_group['MemberClusters']:
+        raise ValueError(f'No clusters found in replication group {replication_group_id}')
 
-    if not primary_cluster_id:
-        raise ValueError(f'No primary cluster found in replication group {replication_group_id}')
+    first_cluster_id = replication_group['MemberClusters'][0]
 
-    # Get cache cluster VPC ID from primary cluster
-    primary_cluster = elasticache_client.describe_cache_clusters(
-        CacheClusterId=primary_cluster_id, ShowCacheNodeInfo=True
+    # Get cache cluster VPC ID from first cluster
+    first_cluster = elasticache_client.describe_cache_clusters(
+        CacheClusterId=first_cluster_id, ShowCacheNodeInfo=True
     )['CacheClusters'][0]
 
-    # Get subnet group name from cluster
-    subnet_group_name = primary_cluster.get('CacheSubnetGroupName')
+    # Get subnet group name from first cluster
+    subnet_group_name = first_cluster.get('CacheSubnetGroupName')
     if not subnet_group_name:
-        raise ValueError(f'No cache subnet group found for cluster {primary_cluster_id}')
+        raise ValueError(f'No cache subnet group found for cluster {first_cluster_id}')
 
     # Get VPC ID from subnet group
     try:
@@ -98,8 +91,8 @@ async def _configure_security_groups(
             f'EC2 instance VPC ({instance_vpc_id}) does not match replication group VPC ({cache_vpc_id})'
         )
 
-    # Get cache cluster port from primary node
-    cache_port = primary_cluster['CacheNodes'][0]['Endpoint']['Port']
+    # Get cache cluster port from first node
+    cache_port = first_cluster['CacheNodes'][0]['Endpoint']['Port']
 
     # Get cache cluster security groups from all member clusters
     cache_security_groups = set()
@@ -209,15 +202,15 @@ async def connect_jump_host_rg(replication_group_id: str, instance_id: str) -> D
 @handle_exceptions
 async def get_ssh_tunnel_command_rg(
     replication_group_id: str, instance_id: str
-) -> Dict[str, Union[str, int, List[Dict[str, Any]], None]]:
-    """Generates SSH tunnel commands to connect to an ElastiCache replication group through an EC2 jump host.
+) -> Dict[str, Union[str, int]]:
+    """Generates an SSH tunnel command to connect to an ElastiCache replication group through an EC2 jump host.
 
     Args:
         replication_group_id (str): ID of the ElastiCache replication group to connect to
         instance_id (str): ID of the EC2 instance to use as jump host
 
     Returns:
-        Dict[str, Union[str, int, List[Dict[str, Any]]]]: Dictionary containing SSH tunnel commands and related details
+        Dict[str, Union[str, int]]: Dictionary containing the SSH tunnel command and related details
 
     Raises:
         ValueError: If required resources not found or information cannot be retrieved
@@ -256,52 +249,28 @@ async def get_ssh_tunnel_command_rg(
             ReplicationGroupId=replication_group_id
         )['ReplicationGroups'][0]
 
-        # Get node details for all clusters
-        node_commands = []
-        base_port = None
-
-        for member in replication_group['MemberClusters']:
-            cluster = elasticache_client.describe_cache_clusters(
-                CacheClusterId=member, ShowCacheNodeInfo=True
-            )['CacheClusters'][0]
-
-            if not cluster.get('CacheNodes'):
-                continue
-
-            node = cluster['CacheNodes'][0]
-            endpoint = node['Endpoint']['Address']
-            port = node['Endpoint']['Port']
-
-            if base_port is None:
-                base_port = port
-
-            # For replicas, use different local ports to avoid conflicts
-            local_port = port
-            if cluster['CacheClusterRole'].lower() != 'primary':
-                local_port = port + 1000  # Use a different port range for replicas
-
-            ssh_command = (
-                f'ssh -i "{key_name}.pem" -fN -l {user} '
-                f'-L {local_port}:{endpoint}:{port} {public_dns} -v'
+        # Use the ConfigurationEndpoint for the SSH tunnel
+        if 'ConfigurationEndpoint' not in replication_group:
+            raise ValueError(
+                f'No ConfigurationEndpoint found for replication group {replication_group_id}'
             )
 
-            node_commands.append(
-                {
-                    'role': cluster['CacheClusterRole'],
-                    'clusterId': member,
-                    'command': ssh_command,
-                    'localPort': local_port,
-                    'remoteEndpoint': endpoint,
-                    'remotePort': port,
-                }
-            )
+        endpoint = replication_group['ConfigurationEndpoint']['Address']
+        port = replication_group['ConfigurationEndpoint']['Port']
+
+        # Generate a single SSH tunnel command
+        ssh_command = (
+            f'ssh -i "{key_name}.pem" -fN -l {user} -L {port}:{endpoint}:{port} {public_dns} -v'
+        )
 
         return {
+            'command': ssh_command,
             'keyName': key_name,
             'user': user,
             'jumpHostDns': public_dns,
-            'nodes': node_commands,
-            'basePort': base_port,
+            'localPort': port,
+            'remoteEndpoint': endpoint,
+            'remotePort': port,
         }
 
     except Exception as e:
@@ -312,18 +281,20 @@ async def get_ssh_tunnel_command_rg(
 @handle_exceptions
 async def create_jump_host_rg(
     replication_group_id: str,
-    subnet_id: str,
-    security_group_id: str,
     key_name: str,
+    subnet_id: Optional[str] = None,
+    security_group_id: Optional[str] = None,
     instance_type: str = 't3.small',
 ) -> Dict[str, Any]:
     """Creates an EC2 jump host instance to access an ElastiCache replication group via SSH tunnel.
 
     Args:
         replication_group_id (str): ID of the ElastiCache replication group to connect to
-        subnet_id (str): ID of the subnet to launch the EC2 instance in (must be public)
-        security_group_id (str): ID of the security group to assign to the EC2 instance
         key_name (str): Name of the EC2 key pair to use for SSH access
+        subnet_id (str, optional): ID of the subnet to launch the EC2 instance in (must be public).
+            If not provided and replication group uses default VPC, will auto-select a default subnet.
+        security_group_id (str, optional): ID of the security group to assign to the EC2 instance.
+            If not provided and replication group uses default VPC, will use the default security group.
         instance_type (str, optional): EC2 instance type. Defaults to "t3.small"
 
     Returns:
@@ -361,31 +332,75 @@ async def create_jump_host_rg(
             ReplicationGroupId=replication_group_id
         )['ReplicationGroups'][0]
 
-        # Get primary cluster details
-        primary_cluster_id = None
-        for member in replication_group['MemberClusters']:
-            cluster = elasticache_client.describe_cache_clusters(
-                CacheClusterId=member, ShowCacheNodeInfo=True
-            )['CacheClusters'][0]
-            if cluster['CacheClusterRole'].lower() == 'primary':
-                primary_cluster_id = member
-                break
+        # Get first cluster details (MemberClusters doesn't have notion of primary cluster)
+        if not replication_group['MemberClusters']:
+            raise ValueError(f'No clusters found in replication group {replication_group_id}')
 
-        if not primary_cluster_id:
-            raise ValueError(
-                f'No primary cluster found in replication group {replication_group_id}'
-            )
+        first_cluster_id = replication_group['MemberClusters'][0]
 
-        # Get VPC details from primary cluster
-        primary_cluster = elasticache_client.describe_cache_clusters(
-            CacheClusterId=primary_cluster_id, ShowCacheNodeInfo=True
+        # Get VPC details from first cluster
+        first_cluster = elasticache_client.describe_cache_clusters(
+            CacheClusterId=first_cluster_id, ShowCacheNodeInfo=True
         )['CacheClusters'][0]
 
         cache_subnet_group = elasticache_client.describe_cache_subnet_groups(
-            CacheSubnetGroupName=primary_cluster['CacheSubnetGroupName']
+            CacheSubnetGroupName=first_cluster['CacheSubnetGroupName']
         )['CacheSubnetGroups'][0]
         cache_vpc_id = cache_subnet_group['VpcId']
 
+        # Check if replication group is in default VPC
+        vpcs = ec2_client.describe_vpcs(VpcIds=[cache_vpc_id])['Vpcs']
+        cache_vpc = vpcs[0] if vpcs else None
+        is_default_vpc = cache_vpc and cache_vpc.get('IsDefault', False)
+
+        # Auto-select subnet if not provided and replication group is in default VPC
+        if not subnet_id and is_default_vpc:
+            # Get default subnets in the default VPC
+            subnets = ec2_client.describe_subnets(
+                Filters=[
+                    {'Name': 'vpc-id', 'Values': [cache_vpc_id]},
+                    {'Name': 'default-for-az', 'Values': ['true']},
+                ]
+            )['Subnets']
+
+            if subnets:
+                # Pick the first available default subnet
+                subnet_id = subnets[0]['SubnetId']
+            else:
+                # Fallback to any public subnet in the VPC
+                all_subnets = ec2_client.describe_subnets(
+                    Filters=[{'Name': 'vpc-id', 'Values': [cache_vpc_id]}]
+                )['Subnets']
+
+                for subnet in all_subnets:
+                    if subnet.get('MapPublicIpOnLaunch', False):
+                        subnet_id = subnet['SubnetId']
+                        break
+
+        # Auto-select security group if not provided and replication group is in default VPC
+        if not security_group_id and is_default_vpc:
+            # Get the default security group for the VPC
+            security_groups = ec2_client.describe_security_groups(
+                Filters=[
+                    {'Name': 'vpc-id', 'Values': [cache_vpc_id]},
+                    {'Name': 'group-name', 'Values': ['default']},
+                ]
+            )['SecurityGroups']
+
+            if security_groups:
+                security_group_id = security_groups[0]['GroupId']
+
+        # Validate required parameters after auto-selection
+        if not subnet_id:
+            raise ValueError(
+                'subnet_id is required. Either provide a subnet_id or ensure the replication group is in the default VPC with default subnets available.'
+            )
+
+        if not security_group_id:
+            raise ValueError(
+                'security_group_id is required. Either provide a security_group_id or ensure the replication group is in the default VPC.'
+            )
+
         # Get subnet details and verify it's public
         subnet_response = ec2_client.describe_subnets(SubnetIds=[subnet_id])
         subnet = subnet_response['Subnets'][0]
@@ -398,20 +413,11 @@ async def create_jump_host_rg(
             )
 
         # Check if subnet is public by looking for route to internet gateway
+        # or if it's a default subnet in the default VPC (which are automatically public)
         route_tables = ec2_client.describe_route_tables(
             Filters=[{'Name': 'association.subnet-id', 'Values': [subnet_id]}]
         )['RouteTables']
 
-        # If no explicit route table association, check main route table
-        if not route_tables:
-            route_tables = ec2_client.describe_route_tables(
-                Filters=[
-                    {'Name': 'vpc-id', 'Values': [subnet_vpc_id]},
-                    {'Name': 'association.main', 'Values': ['true']},
-                ]
-            )['RouteTables']
-
-        # Check for route to internet gateway
         is_public = False
         for rt in route_tables:
             for route in rt.get('Routes', []):
@@ -421,10 +427,38 @@ async def create_jump_host_rg(
             if is_public:
                 break
 
-        # Raise error if no route to internet gateway found
+        # If no explicit route table association, check the main route table for the VPC
+        if not is_public and not route_tables:
+            main_route_tables = ec2_client.describe_route_tables(
+                Filters=[
+                    {'Name': 'vpc-id', 'Values': [subnet_vpc_id]},
+                    {'Name': 'association.main', 'Values': ['true']},
+                ]
+            )['RouteTables']
+
+            for rt in main_route_tables:
+                for route in rt.get('Routes', []):
+                    if route.get('GatewayId', '').startswith('igw-'):
+                        is_public = True
+                        break
+                if is_public:
+                    break
+
+        # If not found via route table, check if it's a default subnet in default VPC
+        if not is_public:
+            # Check if this is the default VPC
+            vpcs = ec2_client.describe_vpcs(VpcIds=[subnet_vpc_id])['Vpcs']
+            vpc = vpcs[0] if vpcs else None
+
+            if vpc and vpc.get('IsDefault', False):
+                # In default VPC, check if this is a default subnet
+                # Default subnets have MapPublicIpOnLaunch set to True
+                if subnet.get('DefaultForAz', False) or subnet.get('MapPublicIpOnLaunch', False):
+                    is_public = True
+
         if not is_public:
             raise ValueError(
-                f'Subnet {subnet_id} is not public (no route to internet gateway found). '
+                f'Subnet {subnet_id} is not public (no route to internet gateway found and not a default subnet in default VPC). '
                 'The subnet must be public to allow SSH access to the jump host.'
             )
 

awslabs/elasticache_mcp_server/tools/serverless/connect.py

@@ -19,7 +19,7 @@ from ...common.decorators import handle_exceptions
 from ...common.server import mcp
 from ...context import Context
 from botocore.exceptions import ClientError
-from typing import Any, Dict, Tuple, Union
+from typing import Any, Dict, Optional, Tuple, Union
 
 
 async def _configure_security_groups(
@@ -53,15 +53,28 @@ async def _configure_security_groups(
     )['ServerlessCaches'][0]
 
     # Get cache security groups
-    cache_security_groups = serverless_cache['VpcSecurityGroups']
+    cache_security_groups = serverless_cache['SecurityGroupIds']
     if not cache_security_groups:
         raise ValueError(f'No security groups found for serverless cache {serverless_cache_name}')
 
-    # Get cache VPC ID
-    cache_vpc_id = cache_security_groups[0]['VpcId']
+    # Get cache VPC ID from subnet IDs
+    if not serverless_cache.get('SubnetIds'):
+        raise ValueError(f'No subnet IDs found for serverless cache {serverless_cache_name}')
 
-    # Get cache port (default is 6379 for Redis)
-    cache_port = 6379
+    # Get subnet details to find VPC ID
+    subnet_response = ec2_client.describe_subnets(SubnetIds=[serverless_cache['SubnetIds'][0]])
+    cache_vpc_id = subnet_response['Subnets'][0]['VpcId']
+
+    # Get cache port dynamically from endpoint if available
+    # Set default port based on engine type
+    engine = serverless_cache.get('Engine', '').lower()
+    if engine == 'memcached':
+        cache_port = 11211  # Default port for Memcached
+    else:
+        cache_port = 6379  # Default port for Redis/Valkey
+
+    if serverless_cache.get('Endpoint') and serverless_cache['Endpoint'].get('Port'):
+        cache_port = serverless_cache['Endpoint']['Port']
 
     # Get EC2 instance details
     instance_info = ec2_client.describe_instances(InstanceIds=[instance_id])
@@ -83,8 +96,7 @@ async def _configure_security_groups(
         raise ValueError(f'No security groups found for EC2 instance {instance_id}')
 
     # For each cache security group, ensure it allows inbound access from EC2 security groups
-    for cache_sg in cache_security_groups:
-        cache_sg_id = cache_sg['SecurityGroupId']
+    for cache_sg_id in cache_security_groups:
         cache_sg_info = ec2_client.describe_security_groups(GroupIds=[cache_sg_id])[
             'SecurityGroups'
         ][0]
@@ -223,9 +235,19 @@ async def get_ssh_tunnel_command_serverless(
             ServerlessCacheName=serverless_cache_name
         )['ServerlessCaches'][0]
 
-        # Get cache endpoint and port (default port is 6379 for Redis)
+        # Get cache endpoint and port
         cache_endpoint = serverless_cache['Endpoint']['Address']
-        cache_port = 6379
+
+        # Get cache port dynamically from endpoint if available
+        # Set default port based on engine type
+        engine = serverless_cache.get('Engine', '').lower()
+        if engine == 'memcached':
+            cache_port = 11211  # Default port for Memcached
+        else:
+            cache_port = 6379  # Default port for Redis/Valkey
+
+        if serverless_cache.get('Endpoint') and serverless_cache['Endpoint'].get('Port'):
+            cache_port = serverless_cache['Endpoint']['Port']
 
         # Generate SSH tunnel command
         ssh_command = (
@@ -251,18 +273,20 @@ async def get_ssh_tunnel_command_serverless(
 @handle_exceptions
 async def create_jump_host_serverless(
     serverless_cache_name: str,
-    subnet_id: str,
-    security_group_id: str,
     key_name: str,
+    subnet_id: Optional[str] = None,
+    security_group_id: Optional[str] = None,
     instance_type: str = 't3.small',
 ) -> Dict[str, Any]:
     """Creates an EC2 jump host instance to access an ElastiCache serverless cache via SSH tunnel.
 
     Args:
         serverless_cache_name (str): Name of the ElastiCache serverless cache to connect to
-        subnet_id (str): ID of the subnet to launch the EC2 instance in (must be public)
-        security_group_id (str): ID of the security group to assign to the EC2 instance
         key_name (str): Name of the EC2 key pair to use for SSH access
+        subnet_id (str, optional): ID of the subnet to launch the EC2 instance in (must be public).
+            If not provided and serverless cache uses default VPC, will auto-select a default subnet.
+        security_group_id (str, optional): ID of the security group to assign to the EC2 instance.
+            If not provided and serverless cache uses default VPC, will use the default security group.
         instance_type (str, optional): EC2 instance type. Defaults to "t3.small"
 
     Returns:
@@ -301,14 +325,72 @@ async def create_jump_host_serverless(
         )['ServerlessCaches'][0]
 
         # Get cache security groups
-        cache_security_groups = serverless_cache['VpcSecurityGroups']
+        cache_security_groups = serverless_cache['SecurityGroupIds']
         if not cache_security_groups:
             raise ValueError(
                 f'No security groups found for serverless cache {serverless_cache_name}'
             )
 
-        # Get cache VPC ID
-        cache_vpc_id = cache_security_groups[0]['VpcId']
+        # Get cache VPC ID from subnet IDs
+        if not serverless_cache.get('SubnetIds'):
+            raise ValueError(f'No subnet IDs found for serverless cache {serverless_cache_name}')
+
+        # Get subnet details to find VPC ID
+        subnet_response = ec2_client.describe_subnets(SubnetIds=[serverless_cache['SubnetIds'][0]])
+        cache_vpc_id = subnet_response['Subnets'][0]['VpcId']
+
+        # Check if serverless cache is in default VPC
+        vpcs = ec2_client.describe_vpcs(VpcIds=[cache_vpc_id])['Vpcs']
+        cache_vpc = vpcs[0] if vpcs else None
+        is_default_vpc = cache_vpc and cache_vpc.get('IsDefault', False)
+
+        # Auto-select subnet if not provided and serverless cache is in default VPC
+        if not subnet_id and is_default_vpc:
+            # Get default subnets in the default VPC
+            subnets = ec2_client.describe_subnets(
+                Filters=[
+                    {'Name': 'vpc-id', 'Values': [cache_vpc_id]},
+                    {'Name': 'default-for-az', 'Values': ['true']},
+                ]
+            )['Subnets']
+
+            if subnets:
+                # Pick the first available default subnet
+                subnet_id = subnets[0]['SubnetId']
+            else:
+                # Fallback to any public subnet in the VPC
+                all_subnets = ec2_client.describe_subnets(
+                    Filters=[{'Name': 'vpc-id', 'Values': [cache_vpc_id]}]
+                )['Subnets']
+
+                for subnet in all_subnets:
+                    if subnet.get('MapPublicIpOnLaunch', False):
+                        subnet_id = subnet['SubnetId']
+                        break
+
+        # Auto-select security group if not provided and serverless cache is in default VPC
+        if not security_group_id and is_default_vpc:
+            # Get the default security group for the VPC
+            security_groups = ec2_client.describe_security_groups(
+                Filters=[
+                    {'Name': 'vpc-id', 'Values': [cache_vpc_id]},
+                    {'Name': 'group-name', 'Values': ['default']},
+                ]
+            )['SecurityGroups']
+
+            if security_groups:
+                security_group_id = security_groups[0]['GroupId']
+
+        # Validate required parameters after auto-selection
+        if not subnet_id:
+            raise ValueError(
+                'subnet_id is required. Either provide a subnet_id or ensure the serverless cache is in the default VPC with default subnets available.'
+            )
+
+        if not security_group_id:
+            raise ValueError(
+                'security_group_id is required. Either provide a security_group_id or ensure the serverless cache is in the default VPC.'
+            )
 
         # Get subnet details and verify it's public
         subnet_response = ec2_client.describe_subnets(SubnetIds=[subnet_id])
@@ -322,6 +404,7 @@ async def create_jump_host_serverless(
             )
 
         # Check if subnet is public by looking for route to internet gateway
+        # or if it's a default subnet in the default VPC (which are automatically public)
         route_tables = ec2_client.describe_route_tables(
             Filters=[{'Name': 'association.subnet-id', 'Values': [subnet_id]}]
         )['RouteTables']
@@ -335,10 +418,38 @@ async def create_jump_host_serverless(
             if is_public:
                 break
 
-        # Raise error if no route to internet gateway found
+        # If no explicit route table association, check the main route table for the VPC
+        if not is_public and not route_tables:
+            main_route_tables = ec2_client.describe_route_tables(
+                Filters=[
+                    {'Name': 'vpc-id', 'Values': [subnet_vpc_id]},
+                    {'Name': 'association.main', 'Values': ['true']},
+                ]
+            )['RouteTables']
+
+            for rt in main_route_tables:
+                for route in rt.get('Routes', []):
+                    if route.get('GatewayId', '').startswith('igw-'):
+                        is_public = True
+                        break
+                if is_public:
+                    break
+
+        # If not found via route table, check if it's a default subnet in default VPC
+        if not is_public:
+            # Check if this is the default VPC
+            vpcs = ec2_client.describe_vpcs(VpcIds=[subnet_vpc_id])['Vpcs']
+            vpc = vpcs[0] if vpcs else None
+
+            if vpc and vpc.get('IsDefault', False):
+                # In default VPC, check if this is a default subnet
+                # Default subnets have MapPublicIpOnLaunch set to True
+                if subnet.get('DefaultForAz', False) or subnet.get('MapPublicIpOnLaunch', False):
+                    is_public = True
+
         if not is_public:
             raise ValueError(
-                f'Subnet {subnet_id} is not public (no route to internet gateway found). '
+                f'Subnet {subnet_id} is not public (no route to internet gateway found and not a default subnet in default VPC). '
                 'The subnet must be public to allow SSH access to the jump host.'
             )
 

awslabs/elasticache_mcp_server/tools/serverless/create.py

@@ -22,7 +22,7 @@ from .models import CreateServerlessCacheRequest
 from typing import Dict
 
 
-@mcp.tool(name='create_serverless_cache')
+@mcp.tool(name='create-serverless-cache')
 @handle_exceptions
 async def create_serverless_cache(request: CreateServerlessCacheRequest) -> Dict:
     """Create a new Amazon ElastiCache serverless cache.
@@ -54,7 +54,7 @@ async def create_serverless_cache(request: CreateServerlessCacheRequest) -> Dict
             3. JSON array: [{"Key": "string", "Value": "string"}, {"Key": "string2", "Value": null}]
 
             Can be None if no tags are needed.
-        vpc_security_group_ids (Optional[List[str]]): List of VPC security group IDs.
+        security_group_ids (Optional[List[str]]): List of security group IDs.
         cache_usage_limits (Optional[CacheUsageLimits]): Usage limits for the cache. Structure:
             {
                 "DataStorage": {
@@ -121,7 +121,7 @@ async def create_serverless_cache(request: CreateServerlessCacheRequest) -> Dict
     for param_name, value in [
         ('SnapshotArnsToRestore', request.snapshot_arns_to_restore),
         ('SubnetIds', request.subnet_ids),
-        ('VpcSecurityGroupIds', request.vpc_security_group_ids),
+        ('SecurityGroupIds', request.security_group_ids),
     ]:
         if value:
             create_request[param_name] = list(map(str, value))

awslabs/elasticache_mcp_server/tools/serverless/delete.py

@@ -20,7 +20,7 @@ from ...common.server import mcp
 from typing import Dict, Optional
 
 
-@mcp.tool(name='delete_serverless_cache')
+@mcp.tool(name='delete-serverless-cache')
 @handle_exceptions
 async def delete_serverless_cache(
     serverless_cache_name: str,

awslabs/elasticache_mcp_server/tools/serverless/models.py

@@ -89,9 +89,7 @@ class CreateServerlessCacheRequest(BaseModel):
             'a list of Tag objects, or a dict of key-value pairs'
         ),
     )
-    vpc_security_group_ids: Optional[List[str]] = Field(
-        None, description='List of VPC security group IDs'
-    )
+    security_group_ids: Optional[List[str]] = Field(None, description='List of security group IDs')
     cache_usage_limits: Optional[CacheUsageLimits] = Field(
         None, description='Usage limits for the cache'
     )
@@ -143,9 +141,7 @@ class ModifyServerlessCacheRequest(BaseModel):
     user_group_id: Optional[str] = Field(
         None, description='ID of the user group to associate with the cache'
     )
-    vpc_security_group_ids: Optional[List[str]] = Field(
-        None, description='List of VPC security group IDs'
-    )
+    security_group_ids: Optional[List[str]] = Field(None, description='List of security group IDs')
 
     @field_validator('daily_snapshot_time')
     def validate_snapshot_time(cls, v):

awslabs/elasticache_mcp_server/tools/serverless/modify.py

@@ -21,7 +21,7 @@ from .models import ModifyServerlessCacheRequest
 from typing import Dict
 
 
-@mcp.tool(name='modify_serverless_cache')
+@mcp.tool(name='modify-serverless-cache')
 @handle_exceptions
 async def modify_serverless_cache(request: ModifyServerlessCacheRequest) -> Dict:
     """Modify an Amazon ElastiCache serverless cache.
@@ -53,7 +53,7 @@ async def modify_serverless_cache(request: ModifyServerlessCacheRequest) -> Dict
                     "Minimum": int   # Minimum ECPU per second
                 }
             }
-        security_group_ids (Optional[List[str]]): List of VPC security group IDs.
+        security_group_ids (Optional[List[str]]): List of security group IDs.
         user_group_id (Optional[str]): ID of the user group to associate with the cache.
 
     Returns:

{awslabs_elasticache_mcp_server-0.1.1.dist-info → awslabs_elasticache_mcp_server-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: awslabs.elasticache-mcp-server
-Version: 0.1.1
+Version: 0.1.3
 Summary: An AWS Labs Model Context Protocol (MCP) server for Amazon ElastiCache
 Project-URL: homepage, https://awslabs.github.io/mcp/
 Project-URL: docs, https://awslabs.github.io/mcp/servers/elasticache-mcp-server/
@@ -38,10 +38,19 @@ Description-Content-Type: text/markdown
 
 # AWS ElastiCache MCP Server
 
-The official MCP Server for interacting with AWS ElastiCache
+The official MCP Server for interacting with AWS ElastiCache control plane. In order to interact with your data in ElastiCache Serverless caches and self-designed clusters use the [Valkey MCP Server](https://github.com/awslabs/mcp/blob/main/src/valkey-mcp-server) or the [Memcached MCP Server](https://github.com/awslabs/mcp/blob/main/src/memcached-mcp-server).
 
 ## Available MCP Tools
 
+### Serverless Cache Operations
+- `create-serverless-cache` - Create a new ElastiCache serverless cache
+- `delete-serverless-cache` - Delete a serverless cache
+- `describe-serverless-caches` - Get information about serverless caches
+- `modify-serverless-cache` - Modify settings of a serverless cache
+- `connect-jump-host-serverless-cache` - Configure an EC2 instance as a jump host for serverless cache access
+- `create-jump-host-serverless-cache` - Create an EC2 jump host to access a serverless cache via SSH tunnel
+- `get-ssh-tunnel-command-serverless-cache` - Generate SSH tunnel command for serverless cache access
+
 ### Replication Group Operations
 - `create-replication-group` - Create an Amazon ElastiCache replication group with specified configuration
 - `delete-replication-group` - Delete an ElastiCache replication group with optional final snapshot
@@ -64,15 +73,6 @@ The official MCP Server for interacting with AWS ElastiCache
 - `create-jump-host-cache-cluster` - Create an EC2 jump host to access a cluster via SSH tunnel
 - `get-ssh-tunnel-command-cache-cluster` - Generate SSH tunnel command for cluster access
 
-### Serverless Cache Operations
-- `create-serverless-cache` - Create a new ElastiCache serverless cache
-- `delete-serverless-cache` - Delete a serverless cache
-- `describe-serverless-caches` - Get information about serverless caches
-- `modify-serverless-cache` - Modify settings of a serverless cache
-- `connect-jump-host-serverless-cache` - Configure an EC2 instance as a jump host for serverless cache access
-- `create-jump-host-serverless-cache` - Create an EC2 jump host to access a serverless cache via SSH tunnel
-- `get-ssh-tunnel-command-serverless-cache` - Generate SSH tunnel command for serverless cache access
-
 ### CloudWatch Operations
 - `get-metric-statistics` - Get CloudWatch metric statistics for ElastiCache resources with customizable time periods and dimensions
 
@@ -114,7 +114,9 @@ All tools support an optional `region_name` parameter to specify which AWS regio
 
 ## Installation
 
-Add the MCP to your favorite agentic tools. e.g. for Amazon Q Developer CLI MCP, `~/.aws/amazonq/mcp.json`):
+[![Install MCP Server](https://cursor.com/deeplink/mcp-install-light.svg)](https://cursor.com/install-mcp?name=awslabs.elasticache-mcp-server&config=eyJjb21tYW5kIjoidXZ4IGF3c2xhYnMuZWxhc3RpY2FjaGUtbWNwLXNlcnZlckBsYXRlc3QiLCJlbnYiOnsiQVdTX1BST0ZJTEUiOiJkZWZhdWx0IiwiQVdTX1JFR0lPTiI6InVzLXdlc3QtMiIsIkZBU1RNQ1BfTE9HX0xFVkVMIjoiRVJST1IifSwiZGlzYWJsZWQiOmZhbHNlLCJhdXRvQXBwcm92ZSI6W119)
+
+Add the MCP to your favorite agentic tools. (e.g. for Amazon Q Developer CLI MCP, `~/.aws/amazonq/mcp.json`):
 
 ```json
 {

{awslabs_elasticache_mcp_server-0.1.1.dist-info → awslabs_elasticache_mcp_server-0.1.3.dist-info}/RECORD

@@ -8,7 +8,7 @@ awslabs/elasticache_mcp_server/common/decorators.py,sha256=jIQQH3N9Ko604eb65ZwKn
 awslabs/elasticache_mcp_server/common/server.py,sha256=5W1gSo7_BWqbSiWRWZq2NkFy35rv8LhkPorjj0_7w9k,1131
 awslabs/elasticache_mcp_server/tools/__init__.py,sha256=KSEbmf3L19fZWgATz6RIuYcnZaoGwjhAFAlu_eeb_78,664
 awslabs/elasticache_mcp_server/tools/cc/__init__.py,sha256=5PAZpzh_4AU5EUf1xR8_Y3M4toKbhzOIaKJ57l8x-nA,1148
-awslabs/elasticache_mcp_server/tools/cc/connect.py,sha256=cDHsvCdvfnGXRnCqKLFBHqqwF43BnB5Ct6BMoVHfSy4,17097
+awslabs/elasticache_mcp_server/tools/cc/connect.py,sha256=POaioP5ExNkCNEETAVe7Hha8aTf5--RW1khdOeLm6es,21077
 awslabs/elasticache_mcp_server/tools/cc/create.py,sha256=cZzqA1MyUvtrv11kqAzscNlqsuOeaUmqmbZlIdqyfW4,9943
 awslabs/elasticache_mcp_server/tools/cc/delete.py,sha256=i6jecaSHJicrI8H3a4bFZtLJYIfeWWs6IkypCXKZLzg,2435
 awslabs/elasticache_mcp_server/tools/cc/describe.py,sha256=3glRiRc5ebGeDKPlyMf7PTP1YnaOBMuGhwWkfscbJRA,3642
@@ -18,7 +18,7 @@ awslabs/elasticache_mcp_server/tools/cc/processors.py,sha256=mJ0MTtxRgMcpLD2KGuF
 awslabs/elasticache_mcp_server/tools/ce/__init__.py,sha256=nY1ui4V0U_cHm4qLsyBeDCRGQnhE36PEVon-n30meV0,806
 awslabs/elasticache_mcp_server/tools/ce/get_cost_and_usage.py,sha256=2mEXSRFIYfZ6PpEbhmyN2qMVrH-epJfY6NeYeT4JkDQ,2923
 awslabs/elasticache_mcp_server/tools/cw/__init__.py,sha256=WMqauaWifQk1YoSmaV1SpZqOyb30RT7mWvZMshYC97U,735
-awslabs/elasticache_mcp_server/tools/cw/get_metric_statistics.py,sha256=XBnal3dTcdLcJZ8YR3LADj4yOj6VYTgwAie8I8MkrJk,2885
+awslabs/elasticache_mcp_server/tools/cw/get_metric_statistics.py,sha256=vyta4rQ_VcGysxcl4jI1gBbQ8zwNMblgoXhE8hP4DqM,3369
 awslabs/elasticache_mcp_server/tools/cwlogs/__init__.py,sha256=5pcisxzfTCCbs6JWK7bmy1w9YD-oxHHTfIxVIKcCUFY,1034
 awslabs/elasticache_mcp_server/tools/cwlogs/create_log_group.py,sha256=6LYK7K86vPyKBNy54WiPCiDKOxM38nWiEUtkMu-snWE,2407
 awslabs/elasticache_mcp_server/tools/cwlogs/describe_log_groups.py,sha256=FMfMsIhzdD9As86TC7h5nBRfQ3GEFZVMaHts-icLDPU,4652
@@ -36,7 +36,7 @@ awslabs/elasticache_mcp_server/tools/misc/describe_events.py,sha256=OFm8S0-Hnk-c
 awslabs/elasticache_mcp_server/tools/misc/describe_service_updates.py,sha256=ppnPpSbChI7KOqk-M1PTQvoDRu4maIGmS7reNnJt9R4,2990
 awslabs/elasticache_mcp_server/tools/rg/__init__.py,sha256=RyGA5z-CeuOjw8X3GeFwpW33WzzThoErmuJ0ddu-gC0,1983
 awslabs/elasticache_mcp_server/tools/rg/complete_migration.py,sha256=yU1qSI5WRdKvrFp1rSPrtwd1fIrAJmfgoOodZixBzl8,3732
-awslabs/elasticache_mcp_server/tools/rg/connect.py,sha256=ObxevDUOY95jsyVoLH_H2gx4PIZXzmg2w81wJ7hAfTA,20800
+awslabs/elasticache_mcp_server/tools/rg/connect.py,sha256=f8pxLQxur8HW12GnsR1GyyzuVsog6A55bRx0kTfNIdw,23052
 awslabs/elasticache_mcp_server/tools/rg/create.py,sha256=SUe8_vyvQ3emeCru1g9yp9ZxfHmk-ASNpu36DaBoSXU,13495
 awslabs/elasticache_mcp_server/tools/rg/delete.py,sha256=PA-D8YK2ePs1aa6BRc7OYsrHNSbjGazwN9UP1fDnBDA,2747
 awslabs/elasticache_mcp_server/tools/rg/describe.py,sha256=wt7tdYKe3VPkxgDj7MdcmNtXwxjRKprKxkwQPx9C1Fg,2984
@@ -46,15 +46,15 @@ awslabs/elasticache_mcp_server/tools/rg/processors.py,sha256=2DEsrF7ucCg7vKhXfoO
 awslabs/elasticache_mcp_server/tools/rg/start_migration.py,sha256=bReeWPZbCoU7gKlmR8Nfy8VrweVThTrvp4KibK_fmp4,6042
 awslabs/elasticache_mcp_server/tools/rg/test_migration.py,sha256=Ye05Lxf84tQShOOokm-agL9GDPFSZTrL31A1A7368EE,5597
 awslabs/elasticache_mcp_server/tools/serverless/__init__.py,sha256=q_te85wY15COM7iFszg1SrY4ianS_BmQrvTEMYpxm3A,1306
-awslabs/elasticache_mcp_server/tools/serverless/connect.py,sha256=PETjBHn2vhWIggyL2cvHhrbHFF5Z54tfd_4U0Cl0If8,17185
-awslabs/elasticache_mcp_server/tools/serverless/create.py,sha256=zpihqFZWweifjSKpAr39CDn2Hp8mPK6l3pJr7WvXEl0,7513
-awslabs/elasticache_mcp_server/tools/serverless/delete.py,sha256=Rc1JXZgDlkpArW217TSxdpZkyOZEW053iaWulp_ZWUk,1858
+awslabs/elasticache_mcp_server/tools/serverless/connect.py,sha256=T_d2gOe-1GGdVjRClvDXvCPlaTUR0VROzfBqmaMRYlU,22558
+awslabs/elasticache_mcp_server/tools/serverless/create.py,sha256=0L4Tji3aSrPmsLYvib-s4D_fuEMaWk541ix9mti_rKE,7498
+awslabs/elasticache_mcp_server/tools/serverless/delete.py,sha256=SByDCgcfNj23zL7ijO0ze_1QL0iTWBO4PVsBxvu1BGc,1858
 awslabs/elasticache_mcp_server/tools/serverless/describe.py,sha256=GwHuHfi4vltAxOv7hLvvsKiq7GoGF7LUcrt0uCi4mAM,2567
-awslabs/elasticache_mcp_server/tools/serverless/models.py,sha256=hex1WG0HwDBbMFNbi7lpbAs0XaGJRzpIerHjpdG53MY,6678
-awslabs/elasticache_mcp_server/tools/serverless/modify.py,sha256=OU6x5kNsNvKM1ylETPviBN_dv05LMPWW02zubo47mVE,3872
-awslabs_elasticache_mcp_server-0.1.1.dist-info/METADATA,sha256=5M4kdQ43eDpFWk8rLrb2tUdtbUC_w4gqJhFfQILkVO8,10824
-awslabs_elasticache_mcp_server-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-awslabs_elasticache_mcp_server-0.1.1.dist-info/entry_points.txt,sha256=058QYfdxCKFALC9V2L5AQz36-jBT8fV8HVLOuIVngAA,92
-awslabs_elasticache_mcp_server-0.1.1.dist-info/licenses/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-awslabs_elasticache_mcp_server-0.1.1.dist-info/licenses/NOTICE,sha256=89EDSSt20vYGgAdEzUiW5Y_VMpZ5CDd2RvXs8BDdhKk,98
-awslabs_elasticache_mcp_server-0.1.1.dist-info/RECORD,,
+awslabs/elasticache_mcp_server/tools/serverless/models.py,sha256=0QTnp8ygVJ4j49JznT4IRlFzdyKYiMXopoJNifO93ok,6634
+awslabs/elasticache_mcp_server/tools/serverless/modify.py,sha256=zBYYhwWF6p8c4WGCZl5tpocXR00pNAHpdqJAF8KRJyI,3868
+awslabs_elasticache_mcp_server-0.1.3.dist-info/METADATA,sha256=z2Jfebuhogj_Dab_a8ZciBeFqrjNsFdMG-UKEcW7TIM,11510
+awslabs_elasticache_mcp_server-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+awslabs_elasticache_mcp_server-0.1.3.dist-info/entry_points.txt,sha256=058QYfdxCKFALC9V2L5AQz36-jBT8fV8HVLOuIVngAA,92
+awslabs_elasticache_mcp_server-0.1.3.dist-info/licenses/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+awslabs_elasticache_mcp_server-0.1.3.dist-info/licenses/NOTICE,sha256=89EDSSt20vYGgAdEzUiW5Y_VMpZ5CDd2RvXs8BDdhKk,98
+awslabs_elasticache_mcp_server-0.1.3.dist-info/RECORD,,