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

awslabs/elasticache_mcp_server/tools/serverless/create.py

@@ -0,0 +1,174 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Create serverless cache operations."""
+
+from ...common.connection import ElastiCacheConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from ...context import Context
+from .models import CreateServerlessCacheRequest
+from typing import Dict
+
+
+@mcp.tool(name='create_serverless_cache')
+@handle_exceptions
+async def create_serverless_cache(request: CreateServerlessCacheRequest) -> Dict:
+    """Create a new Amazon ElastiCache serverless cache.
+
+    This tool creates a new serverless cache with specified configuration including:
+    - Serverless cache name and capacity
+    - Optional VPC and security settings
+    - Optional encryption settings
+    - Optional snapshot restoration and backup settings
+    - Optional usage limits and user groups
+    - Optional tags
+
+    Parameters:
+        serverless_cache_name (str): Name of the serverless cache.
+        engine (str): Cache engine type.
+        description (Optional[str]): Description for the cache.
+        kms_key_id (Optional[str]): KMS key ID for encryption.
+        major_engine_version (Optional[str]): Major engine version.
+        snapshot_arns_to_restore (Optional[List[str]]): List of snapshot ARNs to restore from.
+        subnet_ids (Optional[List[str]]): List of subnet IDs for VPC configuration.
+        tags (Optional[Union[str, List[Dict[str, Optional[str]]], Dict[str, Optional[str]]]]): Tags to apply to the cache.
+            Tag requirements:
+            - Key: (string) Required. The key for the tag. Must not be empty.
+            - Value: (string) Optional. The tag's value. May be null.
+
+            Supports three formats:
+            1. Shorthand syntax: "Key=value,Key2=value2" or "Key=,Key2=" for null values
+            2. Dictionary: {"key": "value", "key2": null}
+            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.
+        cache_usage_limits (Optional[CacheUsageLimits]): Usage limits for the cache. Structure:
+            {
+                "DataStorage": {
+                    "Maximum": int,  # Maximum storage in GB
+                    "Minimum": int,  # Minimum storage in GB
+                    "Unit": "GB"     # Storage unit (currently only GB is supported)
+                },
+                "ECPUPerSecond": {
+                    "Maximum": int,  # Maximum ECPU per second
+                    "Minimum": int   # Minimum ECPU per second
+                }
+            }
+        user_group_id (Optional[str]): ID of the user group to associate with the cache.
+        snapshot_retention_limit (Optional[int]): Number of days for which ElastiCache retains automatic snapshots.
+        daily_snapshot_time (Optional[str]): Time range (in UTC) when daily snapshots are taken (e.g., '04:00-05:00').
+
+    Returns:
+        Dict containing information about the created serverless cache.
+    """
+    """Create a new Amazon ElastiCache serverless cache.
+
+    This tool creates a new serverless cache with specified configuration including:
+    - Serverless cache name and capacity
+    - Optional VPC and security settings
+    - Optional encryption settings
+    - Optional snapshot restoration and backup settings
+    - Optional usage limits and user groups
+    - Optional tags
+
+    Args:
+        request: The CreateServerlessCacheRequest object containing all parameters
+
+    Returns:
+        Dict containing information about the created serverless cache.
+    """
+    # Check if readonly mode is enabled
+    if Context.readonly_mode():
+        raise ValueError(
+            'You have configured this tool in readonly mode. To make this change you will have to update your configuration.'
+        )
+
+    # Get ElastiCache client
+    elasticache_client = ElastiCacheConnectionManager.get_connection()
+
+    # Build AWS API request
+    create_request = {}
+
+    # Required parameters
+    create_request['ServerlessCacheName'] = request.serverless_cache_name
+    create_request['Engine'] = request.engine
+
+    # Optional string parameters
+    for param_name, value in [
+        ('Description', request.description),
+        ('KmsKeyId', request.kms_key_id),
+        ('MajorEngineVersion', request.major_engine_version),
+        ('UserGroupId', request.user_group_id),
+        ('DailySnapshotTime', request.daily_snapshot_time),
+    ]:
+        if value:
+            create_request[param_name] = str(value)
+
+    # Optional list parameters
+    for param_name, value in [
+        ('SnapshotArnsToRestore', request.snapshot_arns_to_restore),
+        ('SubnetIds', request.subnet_ids),
+        ('VpcSecurityGroupIds', request.vpc_security_group_ids),
+    ]:
+        if value:
+            create_request[param_name] = list(map(str, value))
+
+    # Optional numeric parameters
+    if request.snapshot_retention_limit is not None:
+        create_request['SnapshotRetentionLimit'] = str(request.snapshot_retention_limit)
+
+    # Cache usage limits
+    if request.cache_usage_limits:
+        limits_dict = request.cache_usage_limits.model_dump()
+        # Ensure numeric values are properly formatted
+        if 'DataStorage' in limits_dict:
+            limits_dict['DataStorage']['Maximum'] = int(limits_dict['DataStorage']['Maximum'])
+            limits_dict['DataStorage']['Minimum'] = int(limits_dict['DataStorage']['Minimum'])
+        if 'ECPUPerSecond' in limits_dict:
+            limits_dict['ECPUPerSecond']['Maximum'] = int(limits_dict['ECPUPerSecond']['Maximum'])
+            limits_dict['ECPUPerSecond']['Minimum'] = int(limits_dict['ECPUPerSecond']['Minimum'])
+        create_request['CacheUsageLimits'] = limits_dict
+
+    # Tags
+    if request.tags:
+        if isinstance(request.tags, str):
+            # Parse string format "key=value,key2=value2"
+            tags = []
+            for pair in request.tags.split(','):
+                key, value = pair.split('=')
+                tags.append(
+                    {
+                        'Key': str(key.strip()),
+                        'Value': str(value.strip()) if value.strip() else None,
+                    }
+                )
+            create_request['Tags'] = tags
+        elif isinstance(request.tags, dict):
+            # Convert dict format to list of Tag objects
+            create_request['Tags'] = [
+                {'Key': str(k), 'Value': str(v) if v is not None else None}
+                for k, v in request.tags.items()
+            ]
+        else:
+            # Convert Tag objects to dict format
+            create_request['Tags'] = [
+                {'Key': str(tag.Key), 'Value': str(tag.Value) if tag.Value is not None else None}
+                for tag in request.tags
+            ]
+
+    # Create the cache
+    response = elasticache_client.create_serverless_cache(**create_request)
+    return response

awslabs/elasticache_mcp_server/tools/serverless/delete.py

@@ -0,0 +1,49 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Delete serverless cache operations."""
+
+from ...common.connection import ElastiCacheConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from typing import Dict, Optional
+
+
+@mcp.tool(name='delete_serverless_cache')
+@handle_exceptions
+async def delete_serverless_cache(
+    serverless_cache_name: str,
+    final_snapshot_name: Optional[str] = None,
+) -> Dict:
+    """Delete an Amazon ElastiCache serverless cache.
+
+    This tool deletes a specified serverless cache from your AWS account.
+    The cache must exist and be in a deletable state.
+
+    Parameters:
+        serverless_cache_name (str): Name of the serverless cache to delete.
+        final_snapshot_name (Optional[str]): Name of the final snapshot to create before deletion.
+
+    Returns:
+        Dict containing the deletion response or error information.
+    """
+    # Get ElastiCache client
+    elasticache_client = ElastiCacheConnectionManager.get_connection()
+
+    delete_request = {'ServerlessCacheName': serverless_cache_name}
+    if final_snapshot_name:
+        delete_request['FinalSnapshotName'] = str(final_snapshot_name)
+
+    response = elasticache_client.delete_serverless_cache(**delete_request)
+    return response

awslabs/elasticache_mcp_server/tools/serverless/describe.py

@@ -0,0 +1,69 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Describe serverless cache operations."""
+
+from ...common.connection import ElastiCacheConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from typing import Dict, Optional
+
+
+@mcp.tool(name='describe-serverless-caches')
+@handle_exceptions
+async def describe_serverless_caches(
+    serverless_cache_name: Optional[str] = None,
+    max_items: Optional[int] = None,
+    starting_token: Optional[str] = None,
+    page_size: Optional[int] = None,
+) -> Dict:
+    """Describe Amazon ElastiCache serverless caches in your AWS account.
+
+    This tool retrieves detailed information about serverless caches including:
+    - Cache configuration
+    - Cache endpoints
+    - Cache status
+    - Cache size
+    - Cache connections
+
+    Parameters:
+        serverless_cache_name (Optional[str]): Name of the serverless cache to describe. If not provided, describes all caches.
+        max_items (Optional[int]): Maximum number of results to return.
+        starting_token (Optional[str]): Token to start the list from a specific page.
+        page_size (Optional[int]): Number of records to include in each page.
+
+    Returns:
+        Dict containing information about the serverless cache(s).
+    """
+    # Get ElastiCache client
+    elasticache_client = ElastiCacheConnectionManager.get_connection()
+
+    if serverless_cache_name:
+        # Get specific cache details
+        response = elasticache_client.describe_serverless_caches(
+            ServerlessCacheName=serverless_cache_name
+        )
+        return response
+    else:
+        # List all caches with optional pagination
+        kwargs = {}
+        if max_items:
+            kwargs['MaxItems'] = max_items
+        if starting_token:
+            kwargs['StartingToken'] = starting_token
+        if page_size:
+            kwargs['PageSize'] = page_size
+
+        response = elasticache_client.describe_serverless_caches(**kwargs)
+        return response

awslabs/elasticache_mcp_server/tools/serverless/models.py

@@ -0,0 +1,160 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Models for serverless cache operations."""
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from typing import Dict, List, Optional, Union
+
+
+class DataStorageLimits(BaseModel):
+    """Limits for data storage capacity in serverless configuration."""
+
+    Maximum: int = Field(..., description='Maximum storage in GB', gt=0)
+    Minimum: int = Field(..., description='Minimum storage in GB', gt=0)
+    Unit: str = Field(..., description='Storage unit (currently only GB is supported)')
+
+    @field_validator('Unit')
+    def validate_unit(cls, v):
+        """Validate that Unit is 'GB'."""
+        if v != 'GB':
+            raise ValueError("Unit must be 'GB'")
+        return v
+
+    @field_validator('Minimum')
+    def minimum_less_than_maximum(cls, v, values):
+        """Validate that Minimum is less than or equal to Maximum."""
+        if hasattr(values, 'data') and 'Maximum' in values.data and v > values.data['Maximum']:
+            raise ValueError('Minimum must be less than or equal to Maximum')
+        return v
+
+
+class ECPULimits(BaseModel):
+    """Limits for ECPU (ElastiCache Processing Units) in serverless configuration."""
+
+    Maximum: int = Field(..., description='Maximum ECPU per second', gt=0)
+    Minimum: int = Field(..., description='Minimum ECPU per second', gt=0)
+
+    @field_validator('Minimum')
+    def minimum_less_than_maximum(cls, v, values):
+        """Validate that Minimum is less than or equal to Maximum."""
+        if hasattr(values, 'data') and 'Maximum' in values.data and v > values.data['Maximum']:
+            raise ValueError('Minimum must be less than or equal to Maximum')
+        return v
+
+
+class CacheUsageLimits(BaseModel):
+    """Combined limits for data storage and ECPU in serverless configuration."""
+
+    DataStorage: DataStorageLimits = Field(..., description='Data storage limits configuration')
+    ECPUPerSecond: ECPULimits = Field(..., description='ECPU limits configuration')
+
+
+class Tag(BaseModel):
+    """Tag model for ElastiCache resources."""
+
+    Key: str = Field(..., description='The key for the tag')
+    Value: Optional[str] = Field(None, description="The tag's value")
+
+
+class CreateServerlessCacheRequest(BaseModel):
+    """Request model for creating an ElastiCache serverless cache."""
+
+    serverless_cache_name: str = Field(..., description='The identifier of the serverless cache')
+    engine: str = Field(..., description='The name of the cache engine')
+    description: Optional[str] = Field(None, description='Description for the cache')
+    kms_key_id: Optional[str] = Field(None, description='KMS key ID for encryption')
+    major_engine_version: Optional[str] = Field(None, description='Major engine version')
+    snapshot_arns_to_restore: Optional[List[str]] = Field(
+        None, description='List of snapshot ARNs to restore from'
+    )
+    subnet_ids: Optional[List[str]] = Field(
+        None, description='List of subnet IDs for VPC configuration'
+    )
+    tags: Optional[Union[str, List[Tag], Dict[str, Optional[str]]]] = Field(
+        None,
+        description=(
+            'Tags to apply. Can be a string in Key=value format, '
+            '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'
+    )
+    cache_usage_limits: Optional[CacheUsageLimits] = Field(
+        None, description='Usage limits for the cache'
+    )
+    user_group_id: Optional[str] = Field(
+        None, description='ID of the user group to associate with the cache'
+    )
+    snapshot_retention_limit: Optional[int] = Field(
+        None, description='Number of days to retain automatic snapshots', ge=0
+    )
+    daily_snapshot_time: Optional[str] = Field(
+        None,
+        description="Time range (in UTC) when daily snapshots are taken (e.g., '04:00-05:00')",
+    )
+
+    @field_validator('daily_snapshot_time')
+    def validate_snapshot_time(cls, v):
+        """Validate snapshot time format."""
+        if v is not None:
+            import re
+
+            if not re.match(r'^([0-1][0-9]|2[0-3]):[0-5][0-9]-([0-1][0-9]|2[0-3]):[0-5][0-9]$', v):
+                raise ValueError('Invalid time range format. Must be in format HH:MM-HH:MM')
+        return v
+
+    model_config = ConfigDict(validate_by_name=True, arbitrary_types_allowed=True)
+
+
+class ModifyServerlessCacheRequest(BaseModel):
+    """Request model for modifying an ElastiCache serverless cache."""
+
+    serverless_cache_name: str = Field(
+        ..., description='The name of the serverless cache to modify'
+    )
+    description: Optional[str] = Field(None, description='New description for the cache')
+    major_engine_version: Optional[str] = Field(None, description='New major engine version')
+    snapshot_retention_limit: Optional[int] = Field(
+        None, description='Number of days to retain automatic snapshots', ge=0
+    )
+    daily_snapshot_time: Optional[str] = Field(
+        None,
+        description="Time range (in UTC) when daily snapshots are taken (e.g., '04:00-05:00')",
+    )
+    cache_usage_limits: Optional[CacheUsageLimits] = Field(
+        None, description='New usage limits for the cache'
+    )
+    remove_user_group: Optional[bool] = Field(
+        None, description='Whether to remove the user group association'
+    )
+    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'
+    )
+
+    @field_validator('daily_snapshot_time')
+    def validate_snapshot_time(cls, v):
+        """Validate snapshot time format."""
+        if v is not None:
+            import re
+
+            if not re.match(r'^([0-1][0-9]|2[0-3]):[0-5][0-9]-([0-1][0-9]|2[0-3]):[0-5][0-9]$', v):
+                raise ValueError('Invalid time range format. Must be in format HH:MM-HH:MM')
+        return v
+
+    model_config = ConfigDict(validate_by_name=True, arbitrary_types_allowed=True)

awslabs/elasticache_mcp_server/tools/serverless/modify.py

@@ -0,0 +1,95 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Modify serverless cache operations."""
+
+from ...common.connection import ElastiCacheConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from .models import ModifyServerlessCacheRequest
+from typing import Dict
+
+
+@mcp.tool(name='modify_serverless_cache')
+@handle_exceptions
+async def modify_serverless_cache(request: ModifyServerlessCacheRequest) -> Dict:
+    """Modify an Amazon ElastiCache serverless cache.
+
+    This tool modifies the configuration of an existing serverless cache including:
+    - Cache description
+    - Engine version
+    - Snapshot settings
+    - Usage limits
+    - Security groups
+    - User groups
+
+    Parameters:
+        serverless_cache_name (str): Name of the serverless cache to modify.
+        apply_immediately (Optional[bool]): Whether to apply changes immediately or during maintenance window.
+        description (Optional[str]): New description for the cache.
+        major_engine_version (Optional[str]): New major engine version.
+        snapshot_retention_limit (Optional[int]): Number of days for which ElastiCache retains automatic snapshots.
+        daily_snapshot_time (Optional[str]): Time range (in UTC) when daily snapshots are taken (e.g., '04:00-05:00').
+        cache_usage_limits (Optional[CacheUsageLimits]): New usage limits for the cache. Structure:
+            {
+                "DataStorage": {
+                    "Maximum": int,  # Maximum storage in GB
+                    "Minimum": int,  # Minimum storage in GB
+                    "Unit": "GB"     # Storage unit (currently only GB is supported)
+                },
+                "ECPUPerSecond": {
+                    "Maximum": int,  # Maximum ECPU per second
+                    "Minimum": int   # Minimum ECPU per second
+                }
+            }
+        security_group_ids (Optional[List[str]]): List of VPC security group IDs.
+        user_group_id (Optional[str]): ID of the user group to associate with the cache.
+
+    Returns:
+        Dict containing information about the modified serverless cache.
+    """
+    """Modify an Amazon ElastiCache serverless cache.
+
+    This tool modifies the configuration of an existing serverless cache including:
+    - Cache description
+    - Engine version
+    - Snapshot settings
+    - Usage limits
+    - Security groups
+    - User groups
+
+    Args:
+        request: ModifyServerlessCacheRequest object containing modification parameters
+
+    Returns:
+        Dict containing information about the modified serverless cache.
+    """
+    # Get ElastiCache client
+    elasticache_client = ElastiCacheConnectionManager.get_connection()
+
+    # Convert request to dict and remove None values
+    modify_request = {k: v for k, v in request.model_dump().items() if v is not None}
+
+    # Convert snake_case to PascalCase for AWS API
+    aws_request = {}
+    for key, value in modify_request.items():
+        # Special handling for boolean values
+        if isinstance(value, bool):
+            aws_request[key.title().replace('_', '')] = str(value).lower()
+        else:
+            aws_request[key.title().replace('_', '')] = value
+
+    # Modify the cache
+    response = elasticache_client.modify_serverless_cache(**aws_request)
+    return response