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

awslabs/elasticache_mcp_server/tools/cwlogs/__init__.py

@@ -0,0 +1,29 @@
+# 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.
+
+"""CloudWatch Logs tools."""
+
+from .get_log_events import get_log_events
+from .create_log_group import create_log_group
+from .describe_log_groups import describe_log_groups
+from .describe_log_streams import describe_log_streams
+from .filter_log_events import filter_log_events
+
+__all__ = [
+    'get_log_events',
+    'create_log_group',
+    'describe_log_groups',
+    'describe_log_streams',
+    'filter_log_events',
+]

awslabs/elasticache_mcp_server/tools/cwlogs/create_log_group.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.
+
+"""Tool for creating a CloudWatch Logs log group."""
+
+from ...common.connection import CloudWatchLogsConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from ...context import Context
+from typing import Any, Dict, Optional
+
+
+@mcp.tool(name='create-log-group')
+@handle_exceptions
+async def create_log_group(
+    log_group_name: str,
+    kms_key_id: Optional[str] = None,
+    tags: Optional[Dict[str, str]] = None,
+    log_group_class: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Create a new CloudWatch Logs log group.
+
+    Args:
+        log_group_name: The name of the log group to create
+        kms_key_id: The Amazon Resource Name (ARN) of the KMS key to use for encryption
+        tags: The key-value pairs to use for the tags
+        log_group_class: Specify one of the following classes:
+            STANDARD - Standard log events (default)
+            INFREQUENT_ACCESS - Infrequent Access log events
+
+    Returns:
+        Dict containing success message or error details
+    """
+    # 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.'
+        )
+
+    client = CloudWatchLogsConnectionManager.get_connection()
+
+    # Build request parameters
+    params: Dict[str, Any] = {
+        'logGroupName': log_group_name,
+    }
+
+    # Add optional parameters
+    if kms_key_id:
+        params['kmsKeyId'] = kms_key_id
+    if tags:
+        params['tags'] = tags
+    if log_group_class:
+        params['logGroupClass'] = log_group_class
+
+    # Make API call
+    client.create_log_group(**params)
+    return {'message': f'Successfully created log group: {log_group_name}'}

awslabs/elasticache_mcp_server/tools/cwlogs/describe_log_groups.py

@@ -0,0 +1,123 @@
+# 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.
+
+"""Tool for describing CloudWatch Logs log groups."""
+
+from ...common.connection import CloudWatchLogsConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from typing import Any, Dict, List, Optional
+
+
+@mcp.tool(name='describe-log-groups')
+@handle_exceptions
+async def describe_log_groups(
+    account_identifiers: Optional[List[str]] = None,
+    log_group_name_prefix: Optional[str] = None,
+    log_group_name_pattern: Optional[str] = None,
+    include_linked_accounts: Optional[bool] = None,
+    log_group_class: Optional[str] = None,
+    log_group_identifiers: Optional[List[str]] = None,
+    starting_token: Optional[str] = None,
+    page_size: Optional[int] = None,
+    max_items: Optional[int] = None,
+) -> Dict[str, Any]:
+    """Describe CloudWatch Logs log groups.
+
+    Args:
+        account_identifiers: List of account IDs to filter log groups
+        log_group_name_prefix: Prefix to filter log groups by name
+        log_group_name_pattern: Pattern to match log group names
+        include_linked_accounts: Whether to include log groups from linked accounts
+        log_group_class: Filter by log group class (STANDARD or INFREQUENT_ACCESS)
+        log_group_identifiers: List of log group identifiers to describe
+        starting_token: Token for starting the list from a specific page
+        page_size: Number of records to include in each page
+        max_items: Maximum number of records to return in total
+
+    Returns:
+        Dict containing log groups information or error details
+    """
+    client = CloudWatchLogsConnectionManager.get_connection()
+
+    # Build request parameters
+    params: Dict[str, Any] = {}
+
+    # Add optional parameters
+    if account_identifiers:
+        params['accountIdentifiers'] = account_identifiers
+    if log_group_name_prefix:
+        params['logGroupNamePrefix'] = log_group_name_prefix
+    if log_group_name_pattern:
+        params['logGroupNamePattern'] = log_group_name_pattern
+    if include_linked_accounts is not None:
+        params['includeLinkedAccounts'] = include_linked_accounts
+    if log_group_class:
+        params['logGroupClass'] = log_group_class
+    if log_group_identifiers:
+        params['logGroupIdentifiers'] = log_group_identifiers
+    if starting_token:
+        params['nextToken'] = starting_token
+    if page_size:
+        params['limit'] = page_size
+
+    # If max_items is set, we need to handle pagination manually
+    if max_items is not None:
+        log_groups = []
+        items_remaining = max_items
+
+        while True:
+            # Adjust limit if we're close to max_items
+            if page_size and items_remaining < page_size:
+                params['limit'] = items_remaining
+
+            # Make API call
+            response = client.describe_log_groups(**params)
+            current_groups = response.get('logGroups', [])
+
+            # Add groups up to max_items
+            if len(current_groups) > items_remaining:
+                log_groups.extend(current_groups[:items_remaining])
+                next_token = response.get('nextToken')  # Save for result
+                break
+            else:
+                log_groups.extend(current_groups)
+                items_remaining -= len(current_groups)
+
+            # Check if we need to continue
+            if 'nextToken' not in response or items_remaining <= 0:
+                next_token = response.get('nextToken')
+                break
+
+            # Update token for next iteration
+            params['nextToken'] = response['nextToken']
+
+        result = {'logGroups': log_groups}
+        if next_token:
+            result['nextToken'] = next_token
+        return result
+
+    # If max_items is not set, make a single API call
+    response = client.describe_log_groups(**params)
+
+    # Extract relevant information
+    log_groups = response.get('logGroups', [])
+    next_token = response.get('nextToken')
+
+    result = {'logGroups': log_groups}
+
+    if next_token:
+        result['nextToken'] = next_token
+
+    return result

awslabs/elasticache_mcp_server/tools/cwlogs/describe_log_streams.py

@@ -0,0 +1,120 @@
+# 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.
+
+"""Tool for describing CloudWatch Logs log streams."""
+
+from ...common.connection import CloudWatchLogsConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from typing import Any, Dict, Optional
+
+
+@mcp.tool(name='describe-log-streams')
+@handle_exceptions
+async def describe_log_streams(
+    log_group_name: Optional[str] = None,
+    log_group_identifier: Optional[str] = None,
+    log_stream_name_prefix: Optional[str] = None,
+    order_by: Optional[str] = None,
+    descending: Optional[bool] = None,
+    starting_token: Optional[str] = None,
+    page_size: Optional[int] = None,
+    max_items: Optional[int] = None,
+) -> Dict[str, Any]:
+    """Describe CloudWatch Logs log streams.
+
+    Args:
+        log_group_name: The name of the log group containing the log streams to describe.
+        log_group_identifier: The unique identifier of the log group.
+        log_stream_name_prefix: The prefix to match when describing log streams.
+        order_by: The parameter to sort by (LogStreamName or LastEventTime).
+        descending: If true, results are returned in descending order.
+        starting_token: Token for starting the list from a specific page.
+        page_size: Number of records to include in each page.
+        max_items: Maximum number of records to return in total.
+
+    Returns:
+        Dict containing information about the log streams or error details.
+    """
+    client = CloudWatchLogsConnectionManager.get_connection()
+
+    # Build request parameters
+    params: Dict[str, Any] = {}
+
+    # Add optional parameters
+    if log_group_name:
+        params['logGroupName'] = log_group_name
+    if log_group_identifier:
+        params['logGroupIdentifier'] = log_group_identifier
+    if log_stream_name_prefix:
+        params['logStreamNamePrefix'] = log_stream_name_prefix
+    if order_by:
+        params['orderBy'] = order_by
+    if descending is not None:
+        params['descending'] = descending
+    if starting_token:
+        params['nextToken'] = starting_token
+    if page_size:
+        params['limit'] = page_size
+
+    # If max_items is set, we need to handle pagination manually
+    if max_items is not None:
+        log_streams = []
+        items_remaining = max_items
+
+        while True:
+            # Adjust limit if we're close to max_items
+            if page_size and items_remaining < page_size:
+                params['limit'] = items_remaining
+
+            # Make API call
+            response = client.describe_log_streams(**params)
+            current_streams = response.get('logStreams', [])
+
+            # Add streams up to max_items
+            if len(current_streams) > items_remaining:
+                log_streams.extend(current_streams[:items_remaining])
+                next_token = response.get('nextToken')  # Save for result
+                break
+            else:
+                log_streams.extend(current_streams)
+                items_remaining -= len(current_streams)
+
+            # Check if we need to continue
+            if 'nextToken' not in response or items_remaining <= 0:
+                next_token = response.get('nextToken')
+                break
+
+            # Update token for next iteration
+            params['nextToken'] = response['nextToken']
+
+        result = {'logStreams': log_streams}
+        if next_token:
+            result['nextToken'] = next_token
+        return result
+
+    # If max_items is not set, make a single API call
+    # Make API call
+    response = client.describe_log_streams(**params)
+
+    # Extract relevant information
+    log_streams = response.get('logStreams', [])
+    next_token = response.get('nextToken')
+
+    result = {'logStreams': log_streams}
+
+    if next_token:
+        result['nextToken'] = next_token
+
+    return result

awslabs/elasticache_mcp_server/tools/cwlogs/filter_log_events.py

@@ -0,0 +1,122 @@
+# 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.
+
+"""Tool for filtering log events from CloudWatch Logs."""
+
+from ...common.connection import CloudWatchLogsConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+
+@mcp.tool(name='filter-log-events')
+@handle_exceptions
+async def filter_log_events(
+    log_group_name: Optional[str] = None,
+    log_group_identifier: Optional[str] = None,
+    log_stream_names: Optional[List[str]] = None,
+    log_stream_name_prefix: Optional[str] = None,
+    start_time: Optional[datetime] = None,
+    end_time: Optional[datetime] = None,
+    filter_pattern: Optional[str] = None,
+    interleaved: Optional[bool] = None,
+    unmask: Optional[bool] = None,
+    starting_token: Optional[str] = None,
+    page_size: Optional[int] = None,
+    max_items: Optional[int] = None,
+) -> Dict[str, Any]:
+    """Filter log events from CloudWatch Logs.
+
+    Args:
+        log_group_name: The name of the log group
+        log_group_identifier: The unique identifier of the log group
+        log_stream_names: Optional list of log stream names to search
+        log_stream_name_prefix: Optional prefix to match log stream names
+        start_time: The start of the time range, inclusive
+        end_time: The end of the time range, inclusive
+        filter_pattern: The filter pattern to use
+        interleaved: If true, multiple log streams are interleaved
+        unmask: If true, unmask sensitive log data
+        starting_token: Token for getting the next set of events
+        page_size: Number of events to return per page
+        max_items: Maximum number of events to return in total
+
+    Returns:
+        Dict containing:
+        - events: List of filtered log events
+        - searchedLogStreams: List of log streams that were searched
+        - nextToken: Token for getting the next set of events
+    """
+    client = CloudWatchLogsConnectionManager.get_connection()
+
+    # Build request parameters
+    params: Dict[str, Any] = {}
+
+    # Add required parameters
+    if log_group_name:
+        params['logGroupName'] = log_group_name
+    if log_group_identifier:
+        params['logGroupIdentifier'] = log_group_identifier
+
+    # Add optional parameters
+    if log_stream_names:
+        params['logStreamNames'] = log_stream_names
+    if log_stream_name_prefix:
+        params['logStreamNamePrefix'] = log_stream_name_prefix
+    if start_time:
+        params['startTime'] = int(start_time.timestamp() * 1000)
+    if end_time:
+        params['endTime'] = int(end_time.timestamp() * 1000)
+    if filter_pattern:
+        params['filterPattern'] = filter_pattern
+    if interleaved is not None:
+        params['interleaved'] = interleaved
+    if unmask is not None:
+        params['unmask'] = unmask
+    if starting_token:
+        params['nextToken'] = starting_token
+    if page_size:
+        params['limit'] = page_size
+
+    # Make API call
+    response = client.filter_log_events(**params)
+
+    # Format response
+    events = []
+    for event in response.get('events', []):
+        events.append(
+            {
+                'timestamp': event['timestamp'],
+                'message': event['message'],
+                'ingestionTime': event.get('ingestionTime'),
+                'eventId': event.get('eventId'),
+                'logStreamName': event.get('logStreamName'),
+            }
+        )
+
+    searched_streams = []
+    for stream in response.get('searchedLogStreams', []):
+        searched_streams.append(
+            {
+                'logStreamName': stream.get('logStreamName'),
+                'searchedCompletely': stream.get('searchedCompletely', False),
+            }
+        )
+
+    return {
+        'events': events,
+        'searchedLogStreams': searched_streams,
+        'nextToken': response.get('nextToken'),
+    }

awslabs/elasticache_mcp_server/tools/cwlogs/get_log_events.py

@@ -0,0 +1,99 @@
+# 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.
+
+"""Tool for retrieving log events from CloudWatch Logs."""
+
+from ...common.connection import CloudWatchLogsConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+@mcp.tool(name='get-log-events')
+@handle_exceptions
+async def get_log_events(
+    log_stream_name: str,
+    log_group_name: Optional[str] = None,
+    log_group_identifier: Optional[str] = None,
+    start_time: Optional[datetime] = None,
+    end_time: Optional[datetime] = None,
+    next_token: Optional[str] = None,
+    limit: Optional[int] = None,
+    start_from_head: Optional[bool] = None,
+    unmask: Optional[bool] = None,
+) -> Dict[str, Any]:
+    """Get log events from CloudWatch Logs.
+
+    Args:
+        log_group_name: The name of the log group
+        log_group_identifier: The unique identifier of the log group
+        log_stream_name: The name of the log stream
+        start_time: The start of the time range, inclusive
+        end_time: The end of the time range, inclusive
+        next_token: The token for the next set of items to return
+        limit: The maximum number of log events to return
+        start_from_head: If true, read from oldest to newest
+        unmask: If true, unmask sensitive log data
+
+    Returns:
+        Dict containing:
+        - events: List of log events
+        - nextForwardToken: Token for getting the next set of events
+        - nextBackwardToken: Token for getting the previous set of events
+    """
+    client = CloudWatchLogsConnectionManager.get_connection()
+
+    # Build request parameters
+    params: Dict[str, Any] = {
+        'logStreamName': log_stream_name,
+    }
+
+    # Add optional parameters
+    if log_group_name:
+        params['logGroupName'] = log_group_name
+    if log_group_identifier:
+        params['logGroupIdentifier'] = log_group_identifier
+    if start_time:
+        params['startTime'] = int(start_time.timestamp() * 1000)
+    if end_time:
+        params['endTime'] = int(end_time.timestamp() * 1000)
+    if next_token:
+        params['nextToken'] = next_token
+    if limit:
+        params['limit'] = limit
+    if start_from_head is not None:
+        params['startFromHead'] = start_from_head
+    if unmask is not None:
+        params['unmask'] = unmask
+
+    # Make API call
+    response = client.get_log_events(**params)
+
+    # Format response
+    events = []
+    for event in response.get('events', []):
+        events.append(
+            {
+                'timestamp': event['timestamp'],
+                'message': event['message'],
+                'ingestionTime': event.get('ingestionTime'),
+            }
+        )
+
+    return {
+        'events': events,
+        'nextForwardToken': response.get('nextForwardToken'),
+        'nextBackwardToken': response.get('nextBackwardToken'),
+    }

awslabs/elasticache_mcp_server/tools/firehose/__init__.py

@@ -0,0 +1,19 @@
+# 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.
+
+"""Tools for working with Amazon Kinesis Data Firehose."""
+
+from .list_delivery_streams import list_delivery_streams
+
+__all__ = ['list_delivery_streams']

awslabs/elasticache_mcp_server/tools/firehose/list_delivery_streams.py

@@ -0,0 +1,63 @@
+# 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.
+
+"""Tool for listing Kinesis Firehose delivery streams."""
+
+from __future__ import annotations
+
+from ...common.connection import FirehoseConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from typing import Any, Dict
+
+
+@mcp.tool(name='list-delivery-streams')
+@handle_exceptions
+async def list_delivery_streams(
+    limit: Any = None,
+    delivery_stream_type: Any = None,
+    exclusive_start_delivery_stream_name: Any = None,
+) -> Dict[str, Any]:
+    """List your delivery streams.
+
+    Args:
+        limit: The maximum number of delivery streams to list
+        delivery_stream_type: The delivery stream type. This can be one of the following values:
+            DirectPut - Provider data is sent directly to the Firehose stream
+            KinesisStreamAsSource - Data is sourced from an existing Kinesis stream
+        exclusive_start_delivery_stream_name: The name of the delivery stream to start the list after
+
+    Returns:
+        Dict containing the list of delivery streams and whether there are more streams available
+    """
+    client = FirehoseConnectionManager.get_connection()
+
+    # Build request parameters
+    params: Dict[str, Any] = {}
+    if limit is not None:
+        params['Limit'] = limit
+    if delivery_stream_type is not None:
+        params['DeliveryStreamType'] = delivery_stream_type
+    if exclusive_start_delivery_stream_name is not None:
+        params['ExclusiveStartDeliveryStreamName'] = exclusive_start_delivery_stream_name
+
+    # Make API call
+    try:
+        response = client.list_delivery_streams(**params)
+        return {
+            'DeliveryStreamNames': response.get('DeliveryStreamNames', []),
+            'HasMoreDeliveryStreams': response.get('HasMoreDeliveryStreams', False),
+        }
+    except Exception as e:
+        return {'error': str(e)}

awslabs/elasticache_mcp_server/tools/misc/__init__.py

@@ -0,0 +1,31 @@
+# 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.
+
+"""Miscellaneous ElastiCache tools."""
+
+from .batch_apply_update_action import batch_apply_update_action
+from .batch_stop_update_action import batch_stop_update_action
+from .describe_cache_engine_versions import describe_cache_engine_versions
+from .describe_engine_default_parameters import describe_engine_default_parameters
+from .describe_events import describe_events
+from .describe_service_updates import describe_service_updates
+
+__all__ = [
+    'batch_apply_update_action',
+    'batch_stop_update_action',
+    'describe_cache_engine_versions',
+    'describe_engine_default_parameters',
+    'describe_events',
+    'describe_service_updates',
+]