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

awslabs/elasticache_mcp_server/tools/rg/create.py

@@ -0,0 +1,318 @@
+# 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 replication group tool for ElastiCache MCP server."""
+
+from ...common.connection import ElastiCacheConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from ...context import Context
+from .processors import process_log_delivery_configurations, process_nodegroup_configuration
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, Dict, List, Optional, Union
+
+
+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")
+    model_config = ConfigDict(validate_by_name=True, arbitrary_types_allowed=True)
+
+
+class NodeGroupConfiguration(BaseModel):
+    """Node group configuration model."""
+
+    NodeGroupId: Optional[str] = Field(None, description='The identifier for the node group')
+    ReplicaCount: Optional[int] = Field(None, description='The number of replica nodes')
+    Slots: Optional[str] = Field(None, description='The keyspace for the node group')
+    PrimaryAvailabilityZone: Optional[str] = Field(
+        None, description='The Availability Zone where the primary node will be launched'
+    )
+    ReplicaAvailabilityZones: Optional[List[str]] = Field(
+        None, description='A list of Availability Zones where the replica nodes will be launched'
+    )
+    model_config = ConfigDict(validate_by_name=True, arbitrary_types_allowed=True)
+
+
+class LogDeliveryDestinationDetails(BaseModel):
+    """Log delivery destination details model."""
+
+    CloudWatchLogsDetails: Optional[Dict] = Field(
+        None, description='The configuration details of CloudWatch Logs destination'
+    )
+    KinesisFirehoseDetails: Optional[Dict] = Field(
+        None, description='The configuration details of Kinesis Data Firehose destination'
+    )
+    model_config = ConfigDict(validate_by_name=True, arbitrary_types_allowed=True)
+
+
+class LogDeliveryConfiguration(BaseModel):
+    """Log delivery configuration model."""
+
+    LogType: str = Field(..., description='The type of log to deliver')
+    DestinationType: str = Field(..., description='The type of destination to deliver to')
+    DestinationDetails: LogDeliveryDestinationDetails = Field(
+        ..., description='The configuration details of the destination'
+    )
+    LogFormat: str = Field(..., description='The format of the logs')
+    Enabled: bool = Field(..., description='Whether log delivery is enabled')
+    model_config = ConfigDict(validate_by_name=True, arbitrary_types_allowed=True)
+
+
+class CreateReplicationGroupRequest(BaseModel):
+    """Request model for creating an ElastiCache replication group."""
+
+    model_config = ConfigDict(validate_by_name=True, arbitrary_types_allowed=True)
+
+    replication_group_id: str = Field(..., description='The identifier of the replication group')
+    replication_group_description: str = Field(
+        ..., description='The description of the replication group'
+    )
+    cache_node_type: Optional[str] = Field(
+        None, description='The compute and memory capacity of nodes'
+    )
+    engine: Optional[str] = Field(None, description='The name of the cache engine')
+    engine_version: Optional[str] = Field(
+        None, description='The version number of the cache engine'
+    )
+    num_cache_clusters: Optional[int] = Field(None, description='The number of cache clusters')
+    preferred_cache_cluster_azs: Optional[List[str]] = Field(
+        None, description='List of Availability Zones'
+    )
+    num_node_groups: Optional[int] = Field(None, description='The number of node groups')
+    replicas_per_node_group: Optional[int] = Field(
+        None, description='The number of replica nodes in each node group'
+    )
+    node_group_configuration: Optional[Union[str, List[NodeGroupConfiguration]]] = Field(
+        None, description='Configuration for each node group'
+    )
+    cache_parameter_group_name: Optional[str] = Field(
+        None, description='The name of the parameter group to associate'
+    )
+    cache_subnet_group_name: Optional[str] = Field(
+        None, description='The name of the cache subnet group to use'
+    )
+    cache_security_group_names: Optional[List[str]] = Field(
+        None, description='List of cache security group names'
+    )
+    security_group_ids: Optional[List[str]] = Field(
+        None, description='List of Amazon VPC security group IDs'
+    )
+    tags: Optional[Union[str, List[Tag], Dict[str, Optional[str]]]] = Field(
+        None, description='Tags to apply to the replication group'
+    )
+    snapshot_arns: Optional[List[str]] = Field(
+        None, description='List of ARNs of snapshots to restore from'
+    )
+    snapshot_name: Optional[str] = Field(
+        None, description='The name of a snapshot to restore from'
+    )
+    preferred_maintenance_window: Optional[str] = Field(
+        None, description='The weekly time range for maintenance'
+    )
+    port: Optional[int] = Field(
+        None, description='The port number on which the cache accepts connections'
+    )
+    notification_topic_arn: Optional[str] = Field(
+        None, description='The ARN of an SNS topic for notifications'
+    )
+    auto_minor_version_upgrade: Optional[bool] = Field(
+        None, description='Enable/disable automatic minor version upgrades'
+    )
+    snapshot_retention_limit: Optional[int] = Field(
+        None, description='The number of days to retain backups'
+    )
+    snapshot_window: Optional[str] = Field(None, description='The daily time range for backups')
+    auth_token: Optional[str] = Field(
+        None, description='Password used to access a password protected server'
+    )
+    transit_encryption_enabled: Optional[bool] = Field(
+        None, description='Enable/disable encryption in transit'
+    )
+    at_rest_encryption_enabled: Optional[bool] = Field(
+        None, description='Enable/disable encryption at rest'
+    )
+    kms_key_id: Optional[str] = Field(
+        None, description='The ID of the KMS key used to encrypt the disk'
+    )
+    user_group_ids: Optional[List[str]] = Field(
+        None, description='List of user group IDs to associate'
+    )
+    log_delivery_configurations: Optional[Union[str, List[LogDeliveryConfiguration]]] = Field(
+        None, description='Log delivery configurations'
+    )
+
+
+def prepare_request_dict(request: CreateReplicationGroupRequest) -> Dict[str, Any]:
+    """Prepare the request dictionary for the AWS API.
+
+    Args:
+        request: The CreateReplicationGroupRequest object
+
+    Returns:
+        Dict containing the properly formatted request parameters
+    """
+    # Start with required parameters
+    create_request: Dict[str, Any] = {
+        'ReplicationGroupId': request.replication_group_id,
+        'ReplicationGroupDescription': request.replication_group_description,
+    }
+
+    # Optional string parameters
+    for param_name, value in [
+        ('CacheNodeType', request.cache_node_type),
+        ('Engine', request.engine),
+        ('EngineVersion', request.engine_version),
+        ('CacheParameterGroupName', request.cache_parameter_group_name),
+        ('CacheSubnetGroupName', request.cache_subnet_group_name),
+        ('SnapshotName', request.snapshot_name),
+        ('PreferredMaintenanceWindow', request.preferred_maintenance_window),
+        ('NotificationTopicArn', request.notification_topic_arn),
+        ('SnapshotWindow', request.snapshot_window),
+        ('AuthToken', request.auth_token),
+        ('KmsKeyId', request.kms_key_id),
+    ]:
+        if value:
+            create_request[param_name] = str(value)
+
+    # Optional numeric parameters
+    for param_name, value in [
+        ('NumCacheClusters', request.num_cache_clusters),
+        ('NumNodeGroups', request.num_node_groups),
+        ('ReplicasPerNodeGroup', request.replicas_per_node_group),
+        ('Port', request.port),
+        ('SnapshotRetentionLimit', request.snapshot_retention_limit),
+    ]:
+        if value is not None:
+            create_request[param_name] = value
+
+    # Optional boolean parameters
+    for param_name, value in [
+        ('AutoMinorVersionUpgrade', request.auto_minor_version_upgrade),
+        ('TransitEncryptionEnabled', request.transit_encryption_enabled),
+        ('AtRestEncryptionEnabled', request.at_rest_encryption_enabled),
+    ]:
+        if value is not None:
+            create_request[param_name] = value
+
+    # Optional list parameters
+    for param_name, value in [
+        ('PreferredCacheClusterAZs', request.preferred_cache_cluster_azs),
+        ('CacheSecurityGroupNames', request.cache_security_group_names),
+        ('SecurityGroupIds', request.security_group_ids),
+        ('SnapshotArns', request.snapshot_arns),
+        ('UserGroupIds', request.user_group_ids),
+    ]:
+        if value:
+            create_request[param_name] = list(value)
+
+    # Handle node group configuration
+    if request.node_group_configuration:
+        if isinstance(request.node_group_configuration, list):
+            configs = [
+                config.model_dump(exclude_none=True) for config in request.node_group_configuration
+            ]
+            create_request['NodeGroupConfiguration'] = configs
+        else:
+            processed_config = process_nodegroup_configuration(request.node_group_configuration)
+            if processed_config:
+                create_request['NodeGroupConfiguration'] = processed_config
+
+    # Handle tags
+    if request.tags:
+        if isinstance(request.tags, str):
+            # Parse shorthand syntax: Key=string,Value=string
+            tag_list = []
+            try:
+                pairs = [p.strip() for p in request.tags.split(',') if p.strip()]
+                for pair in pairs:
+                    if '=' not in pair:
+                        raise ValueError(
+                            'Invalid tag format. Each tag must be in Key=Value format'
+                        )
+                    key, value = pair.split('=', 1)
+                    key = key.strip()
+                    value = value.strip() if value.strip() else None
+                    if not key:
+                        raise ValueError('Tag key cannot be empty')
+                    tag_list.append({'Key': key, 'Value': value})
+                create_request['Tags'] = tag_list
+            except Exception as e:
+                raise ValueError(
+                    f'Invalid tag shorthand syntax. Expected format: Key=string,Value=string. Error: {str(e)}'
+                )
+        elif isinstance(request.tags, dict):
+            # Handle dictionary format
+            tag_list = []
+            for k, v in request.tags.items():
+                if not k:
+                    raise ValueError('Tag key cannot be empty')
+                tag_list.append({'Key': k, 'Value': v})
+            create_request['Tags'] = tag_list
+        elif isinstance(request.tags, list):
+            create_request['Tags'] = [tag.model_dump(exclude_none=True) for tag in request.tags]
+
+    # Handle log delivery configurations
+    if request.log_delivery_configurations:
+        if isinstance(request.log_delivery_configurations, list):
+            configs = [
+                config.model_dump(exclude_none=True)
+                for config in request.log_delivery_configurations
+            ]
+            create_request['LogDeliveryConfigurations'] = configs
+        else:
+            processed_configs = process_log_delivery_configurations(
+                request.log_delivery_configurations
+            )
+            if processed_configs:
+                create_request['LogDeliveryConfigurations'] = processed_configs
+
+    return create_request
+
+
+@mcp.tool(name='create-replication-group')
+@handle_exceptions
+async def create_replication_group(request: CreateReplicationGroupRequest) -> Dict:
+    """Create an Amazon ElastiCache replication group.
+
+    This tool creates a new replication group with specified configuration including:
+    - Basic replication group settings
+    - Cache node configuration
+    - Network and security settings
+    - Encryption settings
+    - Backup and maintenance settings
+    - Monitoring and logging settings
+
+    Args:
+        request: The CreateReplicationGroupRequest object containing all parameters
+
+    Returns:
+        Dict containing information about the created replication group.
+    """
+    # 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()
+
+    # Prepare request dictionary
+    create_request = prepare_request_dict(request)
+
+    # Create the replication group
+    response = elasticache_client.create_replication_group(**create_request)
+    return response

awslabs/elasticache_mcp_server/tools/rg/delete.py

@@ -0,0 +1,68 @@
+# 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 replication group tool for ElastiCache MCP server."""
+
+from ...common.connection import ElastiCacheConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from ...context import Context
+from typing import Dict, Optional
+
+
+@mcp.tool(name='delete-replication-group')
+@handle_exceptions
+async def delete_replication_group(
+    replication_group_id: str,
+    retain_primary_cluster: Optional[bool] = None,
+    final_snapshot_name: Optional[str] = None,
+) -> Dict:
+    """Delete an Amazon ElastiCache replication group.
+
+    This tool deletes an existing replication group. You can optionally retain the primary cluster
+    as a standalone cache cluster or create a final snapshot before deletion.
+
+    Parameters:
+        replication_group_id (str): The identifier of the replication group to delete.
+        retain_primary_cluster (Optional[bool]): If True, retains the primary cluster as a standalone
+            cache cluster. If False, deletes all clusters in the replication group.
+        final_snapshot_name (Optional[str]): The name of a final cache cluster snapshot to create
+            before deleting the replication group.
+
+    Returns:
+        Dict containing information about the deleted replication group.
+    """
+    # 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 delete request
+    delete_request = {
+        'ReplicationGroupId': replication_group_id,
+    }
+
+    # Add optional parameters if provided
+    if retain_primary_cluster is not None:
+        delete_request['RetainPrimaryCluster'] = str(retain_primary_cluster).lower()
+    if final_snapshot_name:
+        delete_request['FinalSnapshotIdentifier'] = final_snapshot_name
+
+    # Delete the replication group
+    response = elasticache_client.delete_replication_group(**delete_request)
+    return response

awslabs/elasticache_mcp_server/tools/rg/describe.py

@@ -0,0 +1,68 @@
+# 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 replication groups tool for ElastiCache MCP server."""
+
+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-replication-groups')
+@handle_exceptions
+async def describe_replication_groups(
+    replication_group_id: Optional[str] = None,
+    max_records: Optional[int] = None,
+    marker: Optional[str] = None,
+) -> Dict:
+    """Describe one or more ElastiCache replication groups.
+
+    This tool returns information about provisioned replication groups. If a replication group ID
+    is specified, information about only that replication group is returned. Otherwise, information
+    about up to MaxRecords replication groups is returned.
+
+    Parameters:
+        replication_group_id (Optional[str]): The identifier for the replication group to describe.
+            If not provided, information about all replication groups is returned.
+        max_records (Optional[int]): The maximum number of records to include in the response.
+            If more records exist than the specified MaxRecords value, a marker is included
+            in the response so that the remaining results can be retrieved.
+        marker (Optional[str]): An optional marker returned from a previous request. Use this marker
+            for pagination of results from this operation. If this parameter is specified,
+            the response includes only records beyond the marker, up to the value specified
+            by MaxRecords.
+
+    Returns:
+        Dict containing information about the replication group(s), including:
+        - ReplicationGroups: List of replication groups
+        - Marker: Pagination marker for next set of results
+    """
+    # Get ElastiCache client
+    elasticache_client = ElastiCacheConnectionManager.get_connection()
+
+    # Build describe request
+    describe_request = {}
+
+    # Add optional parameters if provided
+    if replication_group_id:
+        describe_request['ReplicationGroupId'] = replication_group_id
+    if max_records:
+        describe_request['MaxRecords'] = max_records
+    if marker:
+        describe_request['Marker'] = marker
+
+    # Describe the replication group(s)
+    response = elasticache_client.describe_replication_groups(**describe_request)
+    return response

awslabs/elasticache_mcp_server/tools/rg/modify.py

@@ -0,0 +1,236 @@
+# 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 replication group tool for ElastiCache MCP server."""
+
+import json
+from ...common.connection import ElastiCacheConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from ...context import Context
+from .processors import process_log_delivery_configurations, process_resharding_configuration
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, Dict, List, Optional, Union
+
+
+@mcp.tool(name='modify-replication-group-shard-configuration')
+@handle_exceptions
+async def modify_replication_group_shard_configuration(
+    replication_group_id: str,
+    node_group_count: int,
+    apply_immediately: Optional[bool] = None,
+    resharding_configuration: Optional[Union[str, List[Dict]]] = None,
+) -> Dict:
+    """Modify the shard configuration of an existing Amazon ElastiCache replication group.
+
+    This tool modifies the shard configuration of an existing replication group by:
+    - Modifying the number of replicas in a shard
+    - Specifying preferred availability zones for replicas
+
+    Parameters:
+        replication_group_id (str): The identifier of the replication group to modify.
+        node_group_count (int): The number of node groups (shards) in the replication group.
+        apply_immediately (Optional[bool]): Whether to apply changes immediately or during maintenance window.
+        resharding_configuration (Optional[Union[str, List[Dict]]]): Resharding configuration in either shorthand string format or list of dictionaries format.
+            Shorthand format: "NodeGroupId=string,NewShardConfiguration={NewReplicaCount=integer,PreferredAvailabilityZones=string1,string2}"
+            Multiple configurations can be separated by spaces.
+            JSON format: List of dictionaries with required fields:
+            - NodeGroupId: string
+            - NewShardConfiguration:
+                - NewReplicaCount: integer
+                - PreferredAvailabilityZones: list of strings (optional)
+
+    Returns:
+        Dict containing information about the modified replication group.
+    """
+    # 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 modify request
+    modify_request = {
+        'ReplicationGroupId': replication_group_id,
+        'NodeGroupCount': node_group_count,
+    }
+
+    # Add optional parameters if provided
+    if apply_immediately is not None:
+        modify_request['ApplyImmediately'] = str(apply_immediately).lower()
+
+    if resharding_configuration:
+        try:
+            processed_configs = process_resharding_configuration(resharding_configuration)
+            modify_request['ReshardingConfiguration'] = json.dumps(processed_configs)
+        except ValueError as e:
+            return {'error': str(e)}
+
+    # Modify the replication group shard configuration
+    response = elasticache_client.modify_replication_group_shard_configuration(**modify_request)
+    return response
+
+
+class ModifyReplicationGroupRequest(BaseModel):
+    """Request model for modifying an ElastiCache replication group."""
+
+    model_config = ConfigDict(extra='allow')  # Allow extra fields to support future API additions
+
+    replication_group_id: str = Field(..., description='The identifier of the replication group')
+    apply_immediately: Optional[bool] = None
+    auto_minor_version_upgrade: Optional[bool] = None
+    automatic_failover_enabled: Optional[bool] = None
+    cache_node_type: Optional[str] = None
+    cache_parameter_group_name: Optional[str] = None
+    cache_security_group_names: Optional[List[str]] = None
+    engine_version: Optional[str] = None
+    log_delivery_configurations: Optional[Union[str, List[Dict]]] = None
+    maintenance_window: Optional[str] = None
+    multi_az_enabled: Optional[bool] = None
+    notification_topic_arn: Optional[str] = None
+    notification_topic_status: Optional[str] = None
+    num_node_groups: Optional[int] = None
+    preferred_node_groups_to_remove: Optional[List[int]] = None
+    primary_cluster_id: Optional[str] = None
+    replicas_per_node_group: Optional[int] = None
+    replication_group_description: Optional[str] = None
+    security_group_ids: Optional[List[str]] = None
+    snapshot_retention_limit: Optional[int] = None
+    snapshot_window: Optional[str] = None
+    user_group_ids_to_add: Optional[List[str]] = None
+    user_group_ids_to_remove: Optional[List[str]] = None
+    node_group_id: Optional[str] = None
+    remove_user_groups: Optional[bool] = None
+    auth_token: Optional[str] = None
+    auth_token_update_strategy: Optional[str] = None
+
+
+def prepare_modify_request_dict(request: ModifyReplicationGroupRequest) -> Dict[str, Any]:
+    """Prepare the request dictionary for the AWS API.
+
+    Args:
+        request: The ModifyReplicationGroupRequest object
+
+    Returns:
+        Dict containing the properly formatted request parameters
+    """
+    # Start with required parameters
+    modify_request: Dict[str, Any] = {
+        'ReplicationGroupId': request.replication_group_id,
+    }
+
+    # Optional string parameters
+    for param_name, value in [
+        ('CacheNodeType', request.cache_node_type),
+        ('CacheParameterGroupName', request.cache_parameter_group_name),
+        ('EngineVersion', request.engine_version),
+        ('PreferredMaintenanceWindow', request.maintenance_window),
+        ('NotificationTopicArn', request.notification_topic_arn),
+        ('NotificationTopicStatus', request.notification_topic_status),
+        ('PrimaryClusterId', request.primary_cluster_id),
+        ('ReplicationGroupDescription', request.replication_group_description),
+        ('SnapshotWindow', request.snapshot_window),
+        ('NodeGroupId', request.node_group_id),
+        ('AuthToken', request.auth_token),
+        ('AuthTokenUpdateStrategy', request.auth_token_update_strategy),
+    ]:
+        if value:
+            modify_request[param_name] = str(value)
+
+    # Optional numeric parameters
+    for param_name, value in [
+        ('NodeGroupCount', request.num_node_groups),
+        ('ReplicasPerNodeGroup', request.replicas_per_node_group),
+        ('SnapshotRetentionLimit', request.snapshot_retention_limit),
+    ]:
+        if value is not None:
+            modify_request[param_name] = value
+
+    # Optional boolean parameters
+    for param_name, value in [
+        ('ApplyImmediately', request.apply_immediately),
+        ('AutoMinorVersionUpgrade', request.auto_minor_version_upgrade),
+        ('AutomaticFailoverEnabled', request.automatic_failover_enabled),
+        ('MultiAZEnabled', request.multi_az_enabled),
+        ('RemoveUserGroups', request.remove_user_groups),
+    ]:
+        if value is not None:
+            modify_request[param_name] = value
+
+    # Optional list parameters
+    for param_name, value in [
+        ('CacheSecurityGroupNames', request.cache_security_group_names),
+        ('SecurityGroupIds', request.security_group_ids),
+        ('UserGroupIdsToAdd', request.user_group_ids_to_add),
+        ('UserGroupIdsToRemove', request.user_group_ids_to_remove),
+    ]:
+        if value:
+            modify_request[param_name] = list(value)
+
+    # Handle node groups to remove
+    if request.preferred_node_groups_to_remove:
+        modify_request['NodeGroupsToRemove'] = request.preferred_node_groups_to_remove
+
+    # Handle log delivery configurations
+    if request.log_delivery_configurations:
+        try:
+            processed_configs = process_log_delivery_configurations(
+                request.log_delivery_configurations
+            )
+            if processed_configs:
+                modify_request['LogDeliveryConfigurations'] = processed_configs
+        except ValueError as e:
+            return {'error': str(e)}
+
+    return modify_request
+
+
+@mcp.tool(name='modify-replication-group')
+@handle_exceptions
+async def modify_replication_group(request: ModifyReplicationGroupRequest) -> Dict:
+    """Modify an existing Amazon ElastiCache replication group.
+
+    This tool modifies the settings of an existing replication group including:
+    - Node configuration
+    - Security settings
+    - Maintenance settings
+    - Backup settings
+    - Engine settings
+    - Monitoring settings
+    - User group settings
+
+    Args:
+        request: The ModifyReplicationGroupRequest object containing all parameters
+
+    Returns:
+        Dict containing information about the modified replication group.
+    """
+    # 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()
+
+    # Prepare request dictionary
+    modify_request = prepare_modify_request_dict(request)
+
+    # Modify the replication group
+    response = elasticache_client.modify_replication_group(**modify_request)
+    return response