awslabs.dynamodb-mcp-server 2.0.1__py3-none-any.whl → 2.0.2__py3-none-any.whl

awslabs/__init__.py

@@ -14,3 +14,23 @@
 
 # This file is part of the awslabs namespace.
 # It is intentionally minimal to support PEP 420 namespace packages.
+
+# Namespace Package Configuration
+#
+# This line resolves namespace conflicts when multiple packages share the 'awslabs' namespace prefix.
+# Without this configuration, test suites fail and build issues occur because Python cannot properly
+# resolve which package owns the 'awslabs' namespace when both 'awslabs.dynamodb-mcp-server' and
+# 'awslabs.mysql-mcp-server' are installed in the same environment.
+#
+# The extend_path() function implements PEP 420 namespace packages, allowing multiple distributions
+# to contribute modules to the same namespace. This ensures that:
+# 1. Both DynamoDB and MySQL MCP servers can coexist in the same Python environment
+# 2. Import statements like 'from awslabs.dynamodb_mcp_server import ...' work correctly
+# 3. Test discovery and execution functions properly across both packages
+# 4. Build processes complete successfully without namespace collision errors
+#
+# This is the standard solution for namespace packages in Python and is required for proper
+# multi-package namespace support in the awslabs ecosystem.
+
+# Extend namespace to include installed packages
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)

awslabs/dynamodb_mcp_server/__init__.py

@@ -14,4 +14,4 @@
 
 """awslabs.dynamodb-mcp-server"""
 
-__version__ = '2.0.1'
+__version__ = '2.0.2'

awslabs/dynamodb_mcp_server/database_analysis_queries.py

@@ -0,0 +1,210 @@
+# 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.
+
+"""Source Database Analysis SQL Query Resources for DynamoDB Data Modeling."""
+
+from typing import Any, Dict
+
+
+# SQL Query Templates for MySQL
+mysql_analysis_queries = {
+    'performance_schema_check': {
+        'name': 'Performance Schema Status Check',
+        'description': 'Returns the status of the performance_schema system variable (ON/OFF)',
+        'sql': 'SELECT @@performance_schema;',
+        'parameters': [],
+    },
+    'query_pattern_analysis': {
+        'name': 'Query Pattern Analysis',
+        'description': 'Returns query patterns from Performance Schema with execution counts, calculated RPS, average execution time, average rows examined per execution, scan counts, execution timeframes, and SQL complexity classification',
+        'sql': """SELECT
+  -- Basic pattern information
+  DIGEST_TEXT as query_pattern,
+  COUNT_STAR as frequency,
+  -- Timing information
+  FIRST_SEEN as first_seen,
+  LAST_SEEN as last_seen
+FROM performance_schema.events_statements_summary_by_digest
+WHERE SCHEMA_NAME = '{target_database}'
+AND COUNT_STAR > 0
+AND LAST_SEEN >= DATE_SUB(NOW(), INTERVAL {pattern_analysis_days} DAY)
+-- Exclude system and administrative queries
+AND DIGEST_TEXT NOT LIKE 'SET%'
+AND DIGEST_TEXT NOT LIKE 'USE %'
+AND DIGEST_TEXT NOT LIKE 'SHOW%'
+AND DIGEST_TEXT NOT LIKE '/* RDS Data API */%'
+AND DIGEST_TEXT NOT LIKE '%information_schema%'
+AND DIGEST_TEXT NOT LIKE '%performance_schema%'
+AND DIGEST_TEXT NOT LIKE '%mysql.%'
+AND DIGEST_TEXT NOT LIKE 'SELECT @@%'
+AND DIGEST_TEXT NOT LIKE '%sys.%'
+AND DIGEST_TEXT NOT LIKE 'select ?'
+AND DIGEST_TEXT NOT LIKE '%mysql.general_log%'
+AND DIGEST_TEXT NOT LIKE 'DESCRIBE %'
+AND DIGEST_TEXT NOT LIKE 'EXPLAIN %'
+AND DIGEST_TEXT NOT LIKE '%configured_database%'
+AND DIGEST_TEXT NOT LIKE 'FLUSH %'
+AND DIGEST_TEXT NOT LIKE 'RESET %'
+AND DIGEST_TEXT NOT LIKE 'OPTIMIZE %'
+AND DIGEST_TEXT NOT LIKE 'ANALYZE %'
+AND DIGEST_TEXT NOT LIKE 'CHECK %'
+AND DIGEST_TEXT NOT LIKE 'REPAIR %'
+AND DIGEST_TEXT NOT LIKE '%@@default_storage_engine%'
+AND DIGEST_TEXT NOT LIKE '%@%:=%'
+AND DIGEST_TEXT NOT LIKE '%MD5%'
+AND DIGEST_TEXT NOT LIKE '%SHA%'
+AND DIGEST_TEXT NOT LIKE '%CONCAT_WS%'
+ORDER BY frequency DESC;""",
+        'parameters': ['target_database', 'pattern_analysis_days'],
+    },
+    'table_analysis': {
+        'name': 'Table Structure Analysis',
+        'description': 'Returns table statistics including row counts, data size in MB, index size in MB, column counts, foreign key counts, and creation/modification timestamps',
+        'sql': """SELECT
+  TABLE_NAME,
+  TABLE_ROWS,
+  -- Storage sizes in MB
+  ROUND(DATA_LENGTH/1024/1024, 2) as datamb,
+  ROUND(INDEX_LENGTH/1024/1024, 2) as indexmb,
+  -- Count columns in this table
+  (SELECT COUNT(*) FROM information_schema.COLUMNS c
+   WHERE c.TABLE_SCHEMA = t.TABLE_SCHEMA AND c.TABLE_NAME = t.TABLE_NAME) as columncount,
+  -- Count foreign keys in this table
+  (SELECT COUNT(*) FROM information_schema.KEY_COLUMN_USAGE k
+   WHERE k.TABLE_SCHEMA = t.TABLE_SCHEMA AND k.TABLE_NAME = t.TABLE_NAME
+   AND k.REFERENCED_TABLE_NAME IS NOT NULL) as fkcount,
+  CREATE_TIME,
+  UPDATE_TIME
+FROM information_schema.TABLES t
+WHERE TABLE_SCHEMA = '{target_database}'
+ORDER BY TABLE_ROWS DESC;""",
+        'parameters': ['target_database'],
+    },
+    'column_analysis': {
+        'name': 'Column Information Analysis',
+        'description': 'Returns all column definitions including table name, column name, data type, nullability, key type, default value, and extra attributes',
+        'sql': """SELECT
+  TABLE_NAME,
+  COLUMN_NAME,
+  COLUMN_TYPE,
+  IS_NULLABLE,
+  COLUMN_KEY,
+  COLUMN_DEFAULT,
+  EXTRA
+FROM information_schema.COLUMNS
+WHERE TABLE_SCHEMA = '{target_database}'
+ORDER BY TABLE_NAME, ORDINAL_POSITION;""",
+        'parameters': ['target_database'],
+    },
+    'index_analysis': {
+        'name': 'Index Statistics Analysis',
+        'description': 'Returns index structure details including table name, index name, column name, uniqueness flag, and column position within each index',
+        'sql': """SELECT
+  TABLE_NAME,
+  INDEX_NAME,
+  COLUMN_NAME,
+  NON_UNIQUE,
+  SEQ_IN_INDEX
+FROM information_schema.STATISTICS
+WHERE TABLE_SCHEMA = '{target_database}'
+ORDER BY TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX;""",
+        'parameters': ['target_database'],
+    },
+    'foreign_key_analysis': {
+        'name': 'Foreign Key Relationship Analysis',
+        'description': 'Returns foreign key relationships including constraint names, child/parent table and column mappings, referential action rules, and estimated relationship cardinality',
+        'sql': """SELECT
+  kcu.CONSTRAINT_NAME,
+  kcu.TABLE_NAME as child_table,
+  kcu.COLUMN_NAME as child_column,
+  kcu.REFERENCED_TABLE_NAME as parent_table,
+  kcu.REFERENCED_COLUMN_NAME as parent_column,
+  rc.UPDATE_RULE,
+  rc.DELETE_RULE,
+  -- Estimate relationship cardinality based on unique constraints
+  CASE
+    WHEN EXISTS (
+      SELECT 1 FROM information_schema.STATISTICS s
+      WHERE s.TABLE_SCHEMA = '{target_database}'
+      AND s.TABLE_NAME = kcu.TABLE_NAME
+      AND s.COLUMN_NAME = kcu.COLUMN_NAME
+      AND s.NON_UNIQUE = 0  -- Unique constraint exists
+      AND (SELECT COUNT(*) FROM information_schema.KEY_COLUMN_USAGE kcu2
+           WHERE kcu2.CONSTRAINT_NAME = s.INDEX_NAME
+           AND kcu2.TABLE_SCHEMA = s.TABLE_SCHEMA) = 1  -- Single column constraint
+    ) THEN '1:1 or 1:0..1'
+    ELSE '1:Many'
+  END as estimated_cardinality
+FROM information_schema.KEY_COLUMN_USAGE kcu
+LEFT JOIN information_schema.REFERENTIAL_CONSTRAINTS rc
+  ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+  AND kcu.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
+WHERE kcu.TABLE_SCHEMA = '{target_database}'
+  AND kcu.REFERENCED_TABLE_NAME IS NOT NULL  -- Only foreign key constraints
+ORDER BY kcu.TABLE_NAME, kcu.COLUMN_NAME;""",
+        'parameters': ['target_database'],
+    },
+    'database_objects': {
+        'name': 'Database Objects Summary',
+        'description': 'Returns object counts and concatenated names grouped by object type: tables, triggers, stored procedures, and functions',
+        'sql': """SELECT
+  'Tables' as object_type,
+  COUNT(*) as count,
+  GROUP_CONCAT(TABLE_NAME) as names
+FROM information_schema.TABLES
+WHERE TABLE_SCHEMA = '{target_database}'
+UNION ALL
+SELECT
+  'Triggers' as object_type,
+  COUNT(*) as count,
+  COALESCE(GROUP_CONCAT(TRIGGER_NAME), 'None') as names
+FROM information_schema.TRIGGERS
+WHERE TRIGGER_SCHEMA = '{target_database}'
+UNION ALL
+SELECT
+  'Stored Procedures' as object_type,
+  COUNT(*) as count,
+  COALESCE(GROUP_CONCAT(ROUTINE_NAME), 'None') as names
+FROM information_schema.ROUTINES
+WHERE ROUTINE_SCHEMA = '{target_database}'
+AND ROUTINE_TYPE = 'PROCEDURE'
+UNION ALL
+SELECT
+  'Functions' as object_type,
+  COUNT(*) as count,
+  COALESCE(GROUP_CONCAT(ROUTINE_NAME), 'None') as names
+FROM information_schema.ROUTINES
+WHERE ROUTINE_SCHEMA = '{target_database}'
+AND ROUTINE_TYPE = 'FUNCTION';""",
+        'parameters': ['target_database'],
+    },
+}
+
+
+def get_query_resource(query_name: str, max_query_results: int, **params) -> Dict[str, Any]:
+    """Get a SQL query resource with parameters substituted."""
+    if query_name not in mysql_analysis_queries:
+        raise ValueError(f"Query '{query_name}' not found")
+
+    query_info = mysql_analysis_queries[query_name].copy()
+
+    # Substitute parameters in SQL
+    if params:
+        query_info['sql'] = query_info['sql'].format(**params)
+
+    # Apply LIMIT to all queries
+    sql = query_info['sql'].rstrip(';')
+    query_info['sql'] = f'{sql} LIMIT {max_query_results};'
+
+    return query_info

awslabs/dynamodb_mcp_server/database_analyzers.py

@@ -0,0 +1,383 @@
+# 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.
+
+"""Database analyzer classes for source database analysis."""
+
+import json
+import os
+from awslabs.dynamodb_mcp_server.database_analysis_queries import get_query_resource
+from awslabs.mysql_mcp_server.server import DBConnection, DummyCtx
+from awslabs.mysql_mcp_server.server import run_query as mysql_query
+from datetime import datetime
+from loguru import logger
+from typing import Any, Dict, List, Tuple
+
+
+DEFAULT_ANALYSIS_DAYS = 30
+DEFAULT_MAX_QUERY_RESULTS = 500
+SECONDS_PER_DAY = 86400
+DDL_PREFIXES = ('CREATE ', 'DROP ', 'ALTER ', 'TRUNCATE ')
+
+
+class DatabaseAnalyzer:
+    """Base class for database analyzers."""
+
+    @staticmethod
+    def build_connection_params(source_db_type: str, **kwargs) -> Dict[str, Any]:
+        """Build connection parameters for database analysis.
+
+        Args:
+            source_db_type: Type of source database (e.g., 'mysql')
+            **kwargs: Connection parameters (aws_cluster_arn, aws_secret_arn, etc.)
+
+        Returns:
+            Dictionary of connection parameters
+
+        Raises:
+            ValueError: If database type is not supported
+        """
+        if source_db_type == 'mysql':
+            user_provided_dir = kwargs.get('output_dir')
+
+            # Validate user-provided directory
+            if not os.path.isabs(user_provided_dir):
+                raise ValueError(f'Output directory must be an absolute path: {user_provided_dir}')
+            if not os.path.isdir(user_provided_dir) or not os.access(user_provided_dir, os.W_OK):
+                raise ValueError(
+                    f'Output directory does not exist or is not writable: {user_provided_dir}'
+                )
+            output_dir = user_provided_dir
+
+            return {
+                'cluster_arn': kwargs.get('aws_cluster_arn') or os.getenv('MYSQL_CLUSTER_ARN'),
+                'secret_arn': kwargs.get('aws_secret_arn') or os.getenv('MYSQL_SECRET_ARN'),
+                'database': kwargs.get('database_name') or os.getenv('MYSQL_DATABASE'),
+                'region': kwargs.get('aws_region') or os.getenv('AWS_REGION'),
+                'max_results': kwargs.get('max_query_results')
+                or int(os.getenv('MYSQL_MAX_QUERY_RESULTS', str(DEFAULT_MAX_QUERY_RESULTS))),
+                'pattern_analysis_days': kwargs.get(
+                    'pattern_analysis_days', DEFAULT_ANALYSIS_DAYS
+                ),
+                'output_dir': output_dir,
+            }
+        raise ValueError(f'Unsupported database type: {source_db_type}')
+
+    @staticmethod
+    def validate_connection_params(
+        source_db_type: str, connection_params: Dict[str, Any]
+    ) -> Tuple[List[str], Dict[str, str]]:
+        """Validate connection parameters for database type.
+
+        Args:
+            source_db_type: Type of source database
+            connection_params: Dictionary of connection parameters
+
+        Returns:
+            Tuple of (missing_params, param_descriptions)
+        """
+        if source_db_type == 'mysql':
+            required_params = ['cluster_arn', 'secret_arn', 'database', 'region']
+            missing_params = [
+                param
+                for param in required_params
+                if not connection_params.get(param)
+                or (
+                    isinstance(connection_params[param], str)
+                    and connection_params[param].strip() == ''
+                )
+            ]
+
+            param_descriptions = {
+                'cluster_arn': 'AWS cluster ARN',
+                'secret_arn': 'AWS secret ARN',
+                'database': 'Database name',
+                'region': 'AWS region',
+            }
+            return missing_params, param_descriptions
+        return [], {}
+
+    @staticmethod
+    def save_analysis_files(
+        results: Dict[str, Any],
+        source_db_type: str,
+        database: str,
+        pattern_analysis_days: int,
+        max_results: int,
+        output_dir: str,
+    ) -> Tuple[List[str], List[str]]:
+        """Save analysis results to JSON files.
+
+        Args:
+            results: Dictionary of query results
+            source_db_type: Type of source database
+            database: Database name
+            pattern_analysis_days: Number of days to analyze the logs for pattern analysis query
+            max_results: Maximum results per query
+            output_dir: Absolute directory path where the timestamped output analysis folder will be created
+
+        Returns:
+            Tuple of (saved_files, save_errors)
+        """
+        saved_files = []
+        save_errors = []
+
+        logger.info(f'save_analysis_files called with {len(results) if results else 0} results')
+
+        if not results:
+            logger.warning('No results to save - returning empty lists')
+            return saved_files, save_errors
+
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        analysis_folder = os.path.join(output_dir, f'database_analysis_{timestamp}')
+        logger.info(f'Creating analysis folder: {analysis_folder}')
+
+        try:
+            os.makedirs(analysis_folder, exist_ok=True)
+            logger.info(f'Created folder at: {analysis_folder}')
+        except OSError as e:
+            logger.error(f'Failed to create analysis folder: {str(e)}')
+            save_errors.append(f'Failed to create folder {analysis_folder}: {str(e)}')
+            return saved_files, save_errors
+
+        for query_name, query_result in results.items():
+            filename = os.path.join(analysis_folder, f'{query_name}_results.json')
+
+            analysis_data = query_result['data']
+            if query_name == 'query_pattern_analysis':
+                analysis_data = DatabaseAnalyzer.filter_pattern_data(
+                    analysis_data, pattern_analysis_days
+                )
+
+            try:
+                with open(filename, 'w') as f:
+                    json.dump(
+                        {
+                            'query_name': query_name,
+                            'description': query_result['description'],
+                            'source_db_type': source_db_type,
+                            'database': database,
+                            'pattern_analysis_days': pattern_analysis_days,
+                            'max_query_results': max_results,
+                            'data': analysis_data,
+                        },
+                        f,
+                        indent=2,
+                        default=str,
+                    )
+                saved_files.append(filename)
+                logger.info(f'Saved {query_name} results to {filename}')
+            except Exception as e:
+                logger.error(f'Failed to save {query_name}: {str(e)}')
+                save_errors.append(f'Failed to save {query_name}: {str(e)}')
+
+        return saved_files, save_errors
+
+    @staticmethod
+    def filter_pattern_data(
+        data: List[Dict[str, Any]], pattern_analysis_days: int
+    ) -> List[Dict[str, Any]]:
+        """Filter pattern analysis data to exclude DDL statements and add RPS calculations.
+
+        Args:
+            data: List of query pattern dictionaries
+            pattern_analysis_days: Number of days in analysis period
+
+        Returns:
+            Filtered list with calculated RPS added to each pattern
+        """
+        if not data:
+            return data
+
+        total_seconds = (pattern_analysis_days or DEFAULT_ANALYSIS_DAYS) * SECONDS_PER_DAY
+        filtered_patterns = []
+
+        for pattern in data:
+            digest = pattern.get('DIGEST_TEXT', '')
+            # Skip DDL statements
+            if not any(digest.upper().startswith(prefix) for prefix in DDL_PREFIXES):
+                pattern_with_rps = pattern.copy()
+                count = pattern.get('COUNT_STAR', 0)
+                pattern_with_rps['calculated_rps'] = (
+                    round(count / total_seconds, 6) if total_seconds > 0 else 0
+                )
+                filtered_patterns.append(pattern_with_rps)
+
+        return filtered_patterns
+
+
+class MySQLAnalyzer(DatabaseAnalyzer):
+    """MySQL-specific database analyzer."""
+
+    SCHEMA_QUERIES = [
+        'table_analysis',
+        'column_analysis',
+        'foreign_key_analysis',
+        'index_analysis',
+    ]
+    ACCESS_PATTERN_QUERIES = ['performance_schema_check', 'query_pattern_analysis']
+
+    @staticmethod
+    def is_performance_schema_enabled(result):
+        """Check if MySQL performance schema is enabled from query result."""
+        if result and len(result) > 0:
+            performance_schema_value = str(
+                result[0].get('', '0')
+            )  # Key is empty string by mysql package design, so checking only value here
+            return performance_schema_value == '1'
+        return False
+
+    def __init__(self, connection_params):
+        """Initialize MySQL analyzer with connection parameters."""
+        self.cluster_arn = connection_params['cluster_arn']
+        self.secret_arn = connection_params['secret_arn']
+        self.database = connection_params['database']
+        self.region = connection_params['region']
+        self.max_results = connection_params['max_results']
+        self.pattern_analysis_days = connection_params['pattern_analysis_days']
+
+    async def _run_query(self, sql, query_parameters=None):
+        """Internal method to run SQL queries against MySQL database."""
+        try:
+            # Create a new connection with current parameters
+            db_connection = DBConnection(
+                self.cluster_arn, self.secret_arn, self.database, self.region, True
+            )
+            # Pass connection parameter directly to mysql_query
+            result = await mysql_query(sql, DummyCtx(), db_connection, query_parameters)
+            return result
+        except Exception as e:
+            logger.error(f'MySQL query execution failed - {type(e).__name__}: {str(e)}')
+            return [{'error': f'MySQL query failed: {str(e)}'}]
+
+    async def execute_query_batch(
+        self, query_names: List[str], pattern_analysis_days: int = None
+    ) -> Tuple[Dict[str, Any], List[str]]:
+        """Execute a batch of analysis queries.
+
+        Args:
+            query_names: List of query names to execute
+            pattern_analysis_days: Optional analysis period for pattern queries
+
+        Returns:
+            Tuple of (results_dict, errors_list)
+        """
+        results = {}
+        errors = []
+
+        for query_name in query_names:
+            try:
+                # Get query with appropriate parameters
+                if query_name == 'query_pattern_analysis' and pattern_analysis_days:
+                    query = get_query_resource(
+                        query_name,
+                        max_query_results=self.max_results,
+                        target_database=self.database,
+                        pattern_analysis_days=pattern_analysis_days,
+                    )
+                else:
+                    query = get_query_resource(
+                        query_name,
+                        max_query_results=self.max_results,
+                        target_database=self.database,
+                    )
+
+                result = await self._run_query(query['sql'])
+
+                if result and isinstance(result, list) and len(result) > 0:
+                    if 'error' in result[0]:
+                        errors.append(f'{query_name}: {result[0]["error"]}')
+                    else:
+                        results[query_name] = {
+                            'description': query['description'],
+                            'data': result,
+                        }
+                else:
+                    # Handle empty results
+                    results[query_name] = {
+                        'description': query['description'],
+                        'data': [],
+                    }
+
+            except Exception as e:
+                errors.append(f'{query_name}: {str(e)}')
+
+        return results, errors
+
+    @classmethod
+    async def analyze(cls, connection_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute MySQL-specific analysis workflow.
+
+        Args:
+            connection_params: Dictionary of connection parameters
+
+        Returns:
+            Dictionary containing results, errors, and performance schema status
+        """
+        analyzer = cls(connection_params)
+
+        # Execute schema analysis
+        schema_results, schema_errors = await analyzer.execute_query_batch(cls.SCHEMA_QUERIES)
+
+        # Execute performance schema check
+        (
+            performance_schema_check_results,
+            performance_schema_check_errors,
+        ) = await analyzer.execute_query_batch(['performance_schema_check'])
+
+        performance_enabled = False
+        all_results = {**schema_results}
+        all_errors = schema_errors + performance_schema_check_errors
+
+        # Check performance schema status and run pattern analysis if enabled
+        if 'performance_schema_check' in performance_schema_check_results:
+            performance_enabled = cls.is_performance_schema_enabled(
+                performance_schema_check_results['performance_schema_check']['data']
+            )
+
+            if performance_enabled:
+                pattern_results, pattern_errors = await analyzer.execute_query_batch(
+                    ['query_pattern_analysis'], analyzer.pattern_analysis_days
+                )
+                all_results.update(pattern_results)
+                all_errors.extend(pattern_errors)
+            if not performance_enabled:
+                all_errors.append('Performance Schema disabled - skipping query_pattern_analysis')
+
+        return {
+            'results': all_results,
+            'errors': all_errors,
+            'performance_enabled': performance_enabled,
+            'performance_feature': 'Performance Schema',
+        }
+
+
+class DatabaseAnalyzerRegistry:
+    """Registry for database-specific analyzers."""
+
+    _analyzers = {
+        'mysql': MySQLAnalyzer,
+    }
+
+    @classmethod
+    def get_analyzer(cls, source_db_type: str):
+        """Get the appropriate analyzer class for the database type."""
+        analyzer = cls._analyzers.get(source_db_type.lower())
+        if not analyzer:
+            raise ValueError(f'Unsupported database type: {source_db_type}')
+        return analyzer
+
+    @classmethod
+    def get_supported_types(cls) -> List[str]:
+        """Get list of supported database types."""
+        return list(cls._analyzers.keys())

awslabs/dynamodb_mcp_server/prompts/dynamodb_architect.md

@@ -9,6 +9,19 @@ You are an AI pair programming with a USER. Your goal is to help the USER create
 
 🔴 **CRITICAL**: You MUST limit the number of questions you ask at any given time, try to limit it to one question, or AT MOST: three related questions.
 
+## Initial Assessment for Requirement Gathering
+
+**If user provides specific context, respond accordingly. Otherwise, present these options:**
+"How would you like to gather requirements for your DynamoDB model?
+
+**Natural Language Requirement gathering** - We'll gather requirements through Q&A (for new or existing applications)
+**Existing Database Analysis** - I can analyze your database to discover schema and patterns automatically using the `source_db_analyzer` tool
+
+Which approach would you prefer?"
+
+🔴 **CRITICAL DATABASE ANALYSIS WORKFLOW**:
+After running `source_db_analyzer`, you MUST IMMEDIATELY read ALL JSON files from the timestamped analysis directory (database_analysis_YYYYMMDD_HHMMSS) and proceed with DynamoDB Data Modeling using the complete analysis.
+
 ## Documentation Workflow
 
 🔴 CRITICAL FILE MANAGEMENT:

awslabs/dynamodb_mcp_server/server.py

@@ -14,9 +14,17 @@
 
 #!/usr/bin/env python3
 
+
 from awslabs.dynamodb_mcp_server.common import handle_exceptions
+from awslabs.dynamodb_mcp_server.database_analyzers import (
+    DatabaseAnalyzer,
+    DatabaseAnalyzerRegistry,
+)
+from loguru import logger
 from mcp.server.fastmcp import FastMCP
 from pathlib import Path
+from pydantic import Field
+from typing import Optional
 
 
 # Define server instructions and dependencies
@@ -29,11 +37,18 @@ Option 1(RECOMMENDED): AWS API MCP Server
    Migration guide: https://github.com/awslabs/mcp/tree/main/src/aws-api-mcp-server
 Option 2(NOT RECOMMENDED): Legacy version 1.0.9
 
-Available Tool:
+Available Tools:
 --------------
 Use the `dynamodb_data_modeling` tool to access enterprise-level DynamoDB design expertise.
 This tool provides systematic methodology for creating production-ready multi-table design with
 advanced optimizations, cost analysis, and integration patterns.
+
+Use the `source_db_analyzer` tool to analyze existing MySQL/Aurora databases for DynamoDB Data Modeling:
+- Extracts schema structure (tables, columns, indexes, foreign keys)
+- Captures access patterns from Performance Schema (query patterns, RPS, frequencies)
+- Generates timestamped analysis files (JSON format) for use with dynamodb_data_modeling
+- Requires AWS RDS Data API and credentials in Secrets Manager
+- Safe for production use (read-only analysis)
 """
 
 
@@ -72,6 +87,156 @@ async def dynamodb_data_modeling() -> str:
     return architect_prompt
 
 
+@app.tool()
+@handle_exceptions
+async def source_db_analyzer(
+    source_db_type: str = Field(description="Supported Source Database type: 'mysql'"),
+    database_name: Optional[str] = Field(
+        default=None, description='Database name to analyze (overrides MYSQL_DATABASE env var)'
+    ),
+    pattern_analysis_days: Optional[int] = Field(
+        default=30,
+        description='Number of days to analyze the logs for pattern analysis query',
+        ge=1,
+    ),
+    max_query_results: Optional[int] = Field(
+        default=None,
+        description='Maximum number of rows to include in analysis output files for schema and query log data (overrides MYSQL_MAX_QUERY_RESULTS env var)',
+        ge=1,
+    ),
+    aws_cluster_arn: Optional[str] = Field(
+        default=None, description='AWS cluster ARN (overrides MYSQL_CLUSTER_ARN env var)'
+    ),
+    aws_secret_arn: Optional[str] = Field(
+        default=None, description='AWS secret ARN (overrides MYSQL_SECRET_ARN env var)'
+    ),
+    aws_region: Optional[str] = Field(
+        default=None, description='AWS region (overrides AWS_REGION env var)'
+    ),
+    output_dir: str = Field(
+        description='Absolute directory path where the timestamped output analysis folder will be created.'
+    ),
+) -> str:
+    """Analyzes your source database to extract schema and access patterns for DynamoDB Data Modeling.
+
+    This tool connects to your existing relational database, examines your current database structure and query
+    patterns to help you design an optimal DynamoDB data model.
+
+    Output & Next Steps:
+    - Creates timestamped folder (database_analysis_YYYYMMDD_HHMMSS) with 4-5 JSON files:
+      * table_analysis_results.json - Table-level statistics
+      * column_analysis_results.json - Column definitions for all tables
+      * index_analysis_results.json - Index structures and compositions
+      * foreign_key_analysis_results.json - Relationship mappings
+      * query_pattern_analysis_results.json - Query patterns (only if Performance Schema enabled)
+    - Each file contains query results with metadata (database name, analysis period, descriptions)
+    - Use these files with the dynamodb_data_modeling tool to design your DynamoDB schema
+    - Analysis is read-only
+
+    Connection Requirements (MySQL/Aurora):
+    - AWS RDS Data API enabled on your Aurora MySQL cluster
+    - Database credentials stored in AWS Secrets Manager
+    - Appropriate IAM permissions to access RDS Data API and Secrets Manager
+    - For complete analysis: MySQL Performance Schema must be enabled (set performance_schema=ON)
+    - Without Performance Schema: Schema-only analysis is performed (no query pattern data)
+
+    Environment Variables (Optional):
+    You can set these instead of passing parameters:
+    - MYSQL_DATABASE: Database name to analyze
+    - MYSQL_CLUSTER_ARN: Aurora cluster ARN
+    - MYSQL_SECRET_ARN: Secrets Manager secret ARN containing DB credentials
+    - AWS_REGION: AWS region where your database is located
+    - MYSQL_MAX_QUERY_RESULTS: Maximum rows per query (default: 500)
+
+    Typical Usage:
+    1. Run this tool against your source database
+    2. Review the generated analysis files to understand your current schema and patterns
+    3. Use dynamodb_data_modeling tool with these files to design your DynamoDB tables
+    4. The analysis helps identify entity relationships, access patterns, and optimization opportunities
+
+    Returns: Analysis summary with saved file locations, query statistics, and next steps.
+    """
+    try:
+        analyzer_class = DatabaseAnalyzerRegistry.get_analyzer(source_db_type)
+    except ValueError as e:
+        supported_types = DatabaseAnalyzerRegistry.get_supported_types()
+        return f'{str(e)}. Supported types: {supported_types}'
+
+    # Build connection parameters based on database type
+    connection_params = DatabaseAnalyzer.build_connection_params(
+        source_db_type,
+        database_name=database_name,
+        pattern_analysis_days=pattern_analysis_days,
+        max_query_results=max_query_results,
+        aws_cluster_arn=aws_cluster_arn,
+        aws_secret_arn=aws_secret_arn,
+        aws_region=aws_region,
+        output_dir=output_dir,
+    )
+
+    # Validate parameters based on database type
+    missing_params, param_descriptions = DatabaseAnalyzer.validate_connection_params(
+        source_db_type, connection_params
+    )
+    if missing_params:
+        missing_descriptions = [param_descriptions[param] for param in missing_params]
+        return (
+            f'To analyze your {source_db_type} database, I need: {", ".join(missing_descriptions)}'
+        )
+
+    logger.info(
+        f'Starting database analysis for {source_db_type} database: {connection_params.get("database")}'
+    )
+
+    try:
+        analysis_result = await analyzer_class.analyze(connection_params)
+
+        # Save results to files
+        saved_files, save_errors = DatabaseAnalyzer.save_analysis_files(
+            analysis_result['results'],
+            source_db_type,
+            connection_params.get('database'),
+            connection_params.get('pattern_analysis_days'),
+            connection_params.get('max_results'),
+            connection_params.get('output_dir'),
+        )
+
+        # Generate report
+        logger.info('Generating analysis report')
+        if analysis_result['results']:
+            report = f"""Database Analysis Complete
+
+Summary:
+- Database: {connection_params.get('database')}
+- Analysis Period: {connection_params.get('pattern_analysis_days')} days
+- {analysis_result['performance_feature']}: {'Enabled' if analysis_result['performance_enabled'] else 'Disabled'}"""
+
+            if saved_files:
+                report += f'\n\nSaved Files:\n{chr(10).join(f"- {f}" for f in saved_files)}'
+
+            if save_errors:
+                report += f'\n\nFile Save Errors:\n{chr(10).join(f"- {e}" for e in save_errors)}'
+
+            if analysis_result['errors']:
+                report += f'\n\nQuery Errors ({len(analysis_result["errors"])}):\n' + '\n'.join(
+                    f'{i}. {error}' for i, error in enumerate(analysis_result['errors'], 1)
+                )
+
+        else:
+            report = (
+                f'Database Analysis Failed\n\nAll {len(analysis_result["errors"])} queries failed:\n'
+                + '\n'.join(
+                    f'{i}. {error}' for i, error in enumerate(analysis_result['errors'], 1)
+                )
+            )
+
+        return report
+
+    except Exception as e:
+        logger.error(f'Analysis failed with exception: {str(e)}')
+        return f'Analysis failed: {str(e)}'
+
+
 def main():
     """Main entry point for the MCP server application."""
     app.run()

awslabs_dynamodb_mcp_server-2.0.2.dist-info/METADATA

@@ -0,0 +1,256 @@
+Metadata-Version: 2.4
+Name: awslabs.dynamodb-mcp-server
+Version: 2.0.2
+Summary: The official MCP Server for interacting with AWS DynamoDB
+Project-URL: homepage, https://awslabs.github.io/mcp/
+Project-URL: docs, https://awslabs.github.io/mcp/servers/dynamodb-mcp-server/
+Project-URL: documentation, https://awslabs.github.io/mcp/servers/dynamodb-mcp-server/
+Project-URL: repository, https://github.com/awslabs/mcp.git
+Project-URL: changelog, https://github.com/awslabs/mcp/blob/main/src/dynamodb-mcp-server/CHANGELOG.md
+Author: Amazon Web Services
+Author-email: AWSLabs MCP <203918161+awslabs-mcp@users.noreply.github.com>, Erben Mo <moerben@amazon.com>
+License: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: awslabs-mysql-mcp-server==1.0.5
+Requires-Dist: boto3==1.40.5
+Requires-Dist: dspy-ai>=2.6.27
+Requires-Dist: loguru==0.7.3
+Requires-Dist: mcp[cli]==1.12.4
+Requires-Dist: pydantic==2.11.7
+Requires-Dist: strands-agents>=1.5.0
+Requires-Dist: typing-extensions==4.14.1
+Description-Content-Type: text/markdown
+
+# AWS DynamoDB MCP Server
+
+The official developer experience MCP Server for Amazon DynamoDB. This server provides DynamoDB expert design guidance and data modeling assistance.
+
+## Available MCP Tools
+
+Right now the DynamoDB MCP server contains two tools that support data modeling tasks. You can design a data model in natural language by using only the `dynamodb_data_modeling` tool or you can analyze your MySQL database and convert the analysis into a DynamoDB data model by using the `source_db_analyzer` tool.
+
+### Design & Modeling
+
+* `dynamodb_data_modeling` - Retrieves the complete DynamoDB Data Modeling Expert prompt
+* `source_db_analyzer` - Executes predefined SQL queries against source databases to analyze schema and access patterns
+
+## Migration Notice
+
+Starting with version 2.0.0, this server focuses exclusively on DynamoDB design and modeling guidance. All operational DynamoDB management tools (table operations, item operations, queries, backups, etc.) have been removed in favor of the [AWS API MCP Server](https://github.com/awslabs/mcp/tree/main/src/aws-api-mcp-server) which provides the same capability and more.
+
+**This server does not do:**
+
+- ❌ Operational DynamoDB management (CRUD operations)
+- ❌ Table creation or data migration
+- ❌ Direct data queries or transformations
+
+### Recommended: AWS API MCP Server
+
+For operational DynamoDB management (retrieving data, managing tables, etc.), use the [AWS API MCP Server](https://github.com/awslabs/mcp/tree/main/src/aws-api-mcp-server) which provides comprehensive DynamoDB operations. [Migration guide available here](https://github.com/awslabs/mcp/tree/main/src/aws-api-mcp-server).
+
+### Not Recommended: Legacy Version
+
+If you must use the previous operational tools, you can pin to version 1.0.9, though this is not recommended:
+
+```json
+{
+  "mcpServers": {
+    "awslabs.dynamodb-mcp-server": {
+      "command": "uvx",
+      "args": ["awslabs.dynamodb-mcp-server@1.0.9"],
+      "env": {
+        "DDB-MCP-READONLY": "true",
+        "AWS_PROFILE": "default",
+        "AWS_REGION": "us-west-2",
+        "FASTMCP_LOG_LEVEL": "ERROR"
+      },
+      "disabled": false,
+      "autoApprove": []
+    }
+  }
+}
+```
+
+## Instructions
+
+To design a data model in natural language you can simply ask your AI agent to “use my DynamoDB MCP to help me design a DynamoDB data model,” or something similar. If you want to analyze your MySQL query patterns then you can follow these additional steps below to setup connectivity and then say something like “analyze my MySQL database and then help me design a DynamoDB data model.”
+
+## Source Database Integration
+
+The DynamoDB MCP server includes source database integration for database analysis and the tool `source_db_analyzer` is useful to get the actual source database schema and access patterns which helps to design the model in DynamoDB. We recommend running this tool against a non-production database instance and it currently supports Aurora MySQL with additional database support planned for future releases.
+
+### Prerequisites for MySQL Integration
+
+1. Aurora MySQL Cluster with MySQL username and password stored in AWS Secrets Manager
+2. Enable RDS Data API for your Aurora MySQL Cluster
+3. Enable Performance Schema for access pattern analysis (optional):
+
+    * Go to the parameter group for your DB instance and set performance_schema value to 1. Make sure to reboot the DB instance after the changes whenever you turn the Performance Schema on or off. Follow the [Instructions](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_WorkingWithParamGroups.Modifying.html) to modify DB parameter group in Amazon Aurora.
+    * After the parameter values are modified, you can run the "SHOW GLOBAL VARIABLES LIKE'%performance_schema'"; command to view the value of the performance_schema parameter of the database instance, also consider tunning the below parameters if required.
+    * `performance_schema_digests_size` [parameter](https://dev.mysql.com/doc/refman/8.0/en/performance-schema-system-variables.html#sysvar_performance_schema_digests_size) - Sets the maximum number of rows stored in the events_statements_summary_by_digest table for querying access pattern. (When you hit this limit, some logs will be lost, potentially missing important access patterns)
+    * `performance_schema_max_digest_length` [parameter](https://dev.mysql.com/doc/refman/8.0/en/performance-schema-system-variables.html#sysvar_performance_schema_max_digest_length) - Sets the maximum byte length for each individual statement digest (access pattern) that the Performance Schema stores. (Default is 1024 bytes, Complex queries might not be fully captured when you hit this limit)
+    * Without these Performance Schema query access patterns, DynamoDB Data Modeler tool recommends access patterns based on the information schema from the source Database.
+
+1. Set up AWS credentials with access to AWS services:
+
+    * Configure AWS credentials with `aws configure` or environment variables (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_SESSION_TOKEN) . The server will automatically use credentials from environment variables or other standard AWS credential sources.
+    * AWS profile with permissions to access RDS Data API and AWS Secrets Manager
+
+### MySQL Environment Variables
+
+Add these environment variables to DynamoDB MCP Server configuration to enable MySQL integration:
+
+* `MYSQL_CLUSTER_ARN`: The Resource ARN of the Aurora MySQL cluster
+* `MYSQL_SECRET_ARN`: The ARN of the secret containing database credentials
+* `MYSQL_DATABASE`: The name of the database to connect to
+* `AWS_REGION`: AWS region of the Aurora MySQL cluster
+* `MYSQL_MAX_QUERY_RESULTS`: Maximum number of rows to include in analysis output files for schema and access_pattern logs (optional, default: "500")
+
+### MCP configuration with MySQL Environment Variables
+
+```json
+{
+  "mcpServers": {
+    "awslabs.dynamodb-mcp-server": {
+      "command": "uvx",
+      "args": ["awslabs.dynamodb-mcp-server@latest"],
+      "env": {
+        "DDB-MCP-READONLY": "true",
+        "AWS_PROFILE": "default",
+        "AWS_REGION": "us-west-2",
+        "FASTMCP_LOG_LEVEL": "ERROR",
+        "MYSQL_CLUSTER_ARN":"arn:aws:rds:$REGION:$ACCOUNT_ID:cluster:$CLUSTER_NAME",
+        "MYSQL_SECRET_ARN":"arn:aws:secretsmanager:$REGION:$ACCOUNT_ID:secret:$SECRET_NAME",
+        "MYSQL_DATABASE":"<DATABASE_NAME>",
+        "MYSQL_MAX_QUERY_RESULTS": 500
+      },
+      "disabled": false,
+      "autoApprove": []
+    }
+  }
+}
+```
+
+## Prerequisites
+
+1. Install `uv` from [Astral](https://docs.astral.sh/uv/getting-started/installation/) or the [GitHub README](https://github.com/astral-sh/uv#installation)
+2. Install Python using `uv python install 3.10`
+3. Set up AWS credentials with access to AWS services
+
+    * Consider setting up Read-only permission if you don't want the LLM to modify any resources
+
+## Installation
+
+| Cursor | VS Code |
+|:------:|:-------:|
+| [![Install MCP Server](https://cursor.com/deeplink/mcp-install-light.svg)](https://cursor.com/en/install-mcp?name=awslabs.dynamodb-mcp-server&config=JTdCJTIyY29tbWFuZCUyMiUzQSUyMnV2eCUyMGF3c2xhYnMuZHluYW1vZGItbWNwLXNlcnZlciU0MGxhdGVzdCUyMiUyQyUyMmVudiUyMiUzQSU3QiUyMkREQi1NQ1AtUkVBRE9OTFklMjIlM0ElMjJ0cnVlJTIyJTJDJTIyQVdTX1BST0ZJTEUlMjIlM0ElMjJkZWZhdWx0JTIyJTJDJTIyQVdTX1JFR0lPTiUyMiUzQSUyMnVzLXdlc3QtMiUyMiUyQyUyMkZBU1RNQ1BfTE9HX0xFVkVMJTIyJTNBJTIyRVJST1IlMjIlN0QlMkMlMjJkaXNhYmxlZCUyMiUzQWZhbHNlJTJDJTIyYXV0b0FwcHJvdmUlMjIlM0ElNUIlNUQlN0Q%3D)| [![Install on VS Code](https://img.shields.io/badge/Install_on-VS_Code-FF9900?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=DynamoDB%20MCP%20Server&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22awslabs.dynamodb-mcp-server%40latest%22%5D%2C%22env%22%3A%7B%22DDB-MCP-READONLY%22%3A%22true%22%2C%22AWS_PROFILE%22%3A%22default%22%2C%22AWS_REGION%22%3A%22us-west-2%22%2C%22FASTMCP_LOG_LEVEL%22%3A%22ERROR%22%7D%2C%22disabled%22%3Afalse%2C%22autoApprove%22%3A%5B%5D%7D) |
+
+Add the MCP to your favorite agentic tools. (e.g. for Amazon Q Developer CLI MCP, `~/.aws/amazonq/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "awslabs.dynamodb-mcp-server": {
+      "command": "uvx",
+      "args": ["awslabs.dynamodb-mcp-server@latest"],
+      "env": {
+        "DDB-MCP-READONLY": "true",
+        "AWS_PROFILE": "default",
+        "AWS_REGION": "us-west-2",
+        "FASTMCP_LOG_LEVEL": "ERROR"
+      },
+      "disabled": false,
+      "autoApprove": []
+    }
+  }
+}
+```
+
+### Windows Installation
+
+For Windows users, the MCP server configuration format is slightly different:
+
+```json
+{
+  "mcpServers": {
+    "awslabs.dynamodb-mcp-server": {
+      "disabled": false,
+      "timeout": 60,
+      "type": "stdio",
+      "command": "uv",
+      "args": [
+        "tool",
+        "run",
+        "--from",
+        "awslabs.dynamodb-mcp-server@latest",
+        "awslabs.dynamodb-mcp-server.exe"
+      ],
+      "env": {
+        "FASTMCP_LOG_LEVEL": "ERROR",
+        "AWS_PROFILE": "your-aws-profile",
+        "AWS_REGION": "us-west-2"
+      }
+    }
+  }
+}
+```
+
+
+or docker after a successful `docker build -t awslabs/dynamodb-mcp-server .`:
+
+```json
+  {
+    "mcpServers": {
+      "awslabs.dynamodb-mcp-server": {
+        "command": "docker",
+        "args": [
+          "run",
+          "--rm",
+          "--interactive",
+          "--env",
+          "FASTMCP_LOG_LEVEL=ERROR",
+          "awslabs/dynamodb-mcp-server:latest"
+        ],
+        "env": {},
+        "disabled": false,
+        "autoApprove": []
+      }
+    }
+  }
+```
+
+## Limitations & Considerations
+
+### **Application-Level Patterns:**
+
+* Queries generated dynamically in application code
+* Caching layer behavior (Redis, Memcached)
+* Real-time vs. analytics query differentiation
+* Background job access patterns
+
+### Business Context:
+
+* Data consistency requirements
+* Compliance and audit requirements
+* Geographic distribution requirements
+
+### Recommendation:
+
+Supplement analysis with documentation or natural language descriptions based on:
+
+* Application code review
+* Architecture documentation review
+* Stakeholder interviews with development team
+* Load testing results analysis
+
+There are also more complex patterns that result from stored procedures, triggers, aggregations, that the tool does not currently handle consistently but we plan to improve in future iterations.

awslabs_dynamodb_mcp_server-2.0.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+awslabs/__init__.py,sha256=eSOf255HxkdQFKpFsCp-JsTvhFfgcK2rW2e_sJ_WjUU,1898
+awslabs/dynamodb_mcp_server/__init__.py,sha256=l3xb-tR1nhO6wtXwU9pZ3xwEykkQfqP9rqZcUSfWb7Q,673
+awslabs/dynamodb_mcp_server/common.py,sha256=--RWFURrGYjRjAnOuIbyX-DDrfZy1EeQXXRg4lASFB4,1677
+awslabs/dynamodb_mcp_server/database_analysis_queries.py,sha256=iHngCENDnX5F0XBOrYVq0cA-fP4QCpmPhDNRCFtvGgA,8166
+awslabs/dynamodb_mcp_server/database_analyzers.py,sha256=GEZubzjEiCW898LbKlDYHuvvirt_Z7ubJ8QZdkFMh-c,15046
+awslabs/dynamodb_mcp_server/server.py,sha256=sbCebTs6AtW7nYQRNwGbpVokxSRR0VQE_rRUqFqZTPA,10181
+awslabs/dynamodb_mcp_server/prompts/dynamodb_architect.md,sha256=ZTu64seZOwhnep7Jqi9PG5rkGwO8irkk3Lro6bdzU48,40644
+awslabs_dynamodb_mcp_server-2.0.2.dist-info/METADATA,sha256=DNKybWJCXo8RtvISfwjCcA4KVczArYGu1aoFxLsoxLk,11868
+awslabs_dynamodb_mcp_server-2.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+awslabs_dynamodb_mcp_server-2.0.2.dist-info/entry_points.txt,sha256=Vn6TvAN9d67Lsbkcs0UcIiOBI5xDpNBm_MOOzc1h-YU,88
+awslabs_dynamodb_mcp_server-2.0.2.dist-info/licenses/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+awslabs_dynamodb_mcp_server-2.0.2.dist-info/licenses/NOTICE,sha256=47UMmTFkf8rUc_JaJfdWe6NsAJQOcZNPZIL6JzU_k5U,95
+awslabs_dynamodb_mcp_server-2.0.2.dist-info/RECORD,,

awslabs_dynamodb_mcp_server-2.0.1.dist-info/METADATA

@@ -1,164 +0,0 @@
-Metadata-Version: 2.4
-Name: awslabs.dynamodb-mcp-server
-Version: 2.0.1
-Summary: The official MCP Server for interacting with AWS DynamoDB
-Project-URL: homepage, https://awslabs.github.io/mcp/
-Project-URL: docs, https://awslabs.github.io/mcp/servers/dynamodb-mcp-server/
-Project-URL: documentation, https://awslabs.github.io/mcp/servers/dynamodb-mcp-server/
-Project-URL: repository, https://github.com/awslabs/mcp.git
-Project-URL: changelog, https://github.com/awslabs/mcp/blob/main/src/dynamodb-mcp-server/CHANGELOG.md
-Author: Amazon Web Services
-Author-email: AWSLabs MCP <203918161+awslabs-mcp@users.noreply.github.com>, Erben Mo <moerben@amazon.com>
-License: Apache-2.0
-License-File: LICENSE
-License-File: NOTICE
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.10
-Requires-Dist: boto3==1.40.5
-Requires-Dist: dspy-ai>=2.6.27
-Requires-Dist: loguru==0.7.3
-Requires-Dist: mcp[cli]==1.12.4
-Requires-Dist: pydantic==2.11.7
-Requires-Dist: strands-agents>=1.5.0
-Requires-Dist: typing-extensions==4.14.1
-Description-Content-Type: text/markdown
-
-# AWS DynamoDB MCP Server
-
-The official MCP Server for interacting with AWS DynamoDB
-
-This server provides expert DynamoDB design guidance and data modeling assistance.
-
-## Available MCP Tools
-
-### Design & Modeling
-- `dynamodb_data_modeling` - Retrieves the complete DynamoDB Data Modeling Expert prompt
-
-## Migration Notice
-
-Starting with version 2.0.0, this server focuses exclusively on DynamoDB design and modeling guidance. All operational DynamoDB management tools (table operations, item operations, queries, backups, etc.) have been removed in favour of the [AWS API MCP Server](https://github.com/awslabs/mcp/tree/main/src/aws-api-mcp-server) which provides the same capability and more.
-
-### Recommended: AWS API MCP Server
-
-For operational DynamoDB management, use the [AWS API MCP Server](https://github.com/awslabs/mcp/tree/main/src/aws-api-mcp-server) which provides comprehensive AWS service management including all DynamoDB operations. [Migration guide available here](https://github.com/awslabs/mcp/tree/main/src/aws-api-mcp-server).
-
-### Not Recommended: Legacy Version
-
-If you must use the previous operational tools, you can pin to version 1.0.9, though this is not recommended:
-
-```json
-{
-  "mcpServers": {
-    "awslabs.dynamodb-mcp-server": {
-      "command": "uvx",
-      "args": ["awslabs.dynamodb-mcp-server@1.0.9"],
-      "env": {
-        "DDB-MCP-READONLY": "true",
-        "AWS_PROFILE": "default",
-        "AWS_REGION": "us-west-2",
-        "FASTMCP_LOG_LEVEL": "ERROR"
-      },
-      "disabled": false,
-      "autoApprove": []
-    }
-  }
-}
-```
-
-## Instructions
-
-This MCP Server provides DynamoDB design and modeling guidance only. For operational DynamoDB management (retrieving data, managing tables, etc.), use the [AWS API MCP Server](https://github.com/awslabs/mcp/tree/main/src/aws-api-mcp-server) which provides comprehensive DynamoDB operations. [Migration guide available here](https://github.com/awslabs/mcp/tree/main/src/aws-api-mcp-server).
-
-
-## Prerequisites
-
-1. Install `uv` from [Astral](https://docs.astral.sh/uv/getting-started/installation/) or the [GitHub README](https://github.com/astral-sh/uv#installation)
-2. Install Python using `uv python install 3.10`
-3. Set up AWS credentials with access to AWS services
-   - Consider setting up Read-only permission if you don't want the LLM to modify any resources
-
-## Installation
-
-| Cursor | VS Code |
-|:------:|:-------:|
-| [![Install MCP Server](https://cursor.com/deeplink/mcp-install-light.svg)](https://cursor.com/en/install-mcp?name=awslabs.dynamodb-mcp-server&config=JTdCJTIyY29tbWFuZCUyMiUzQSUyMnV2eCUyMGF3c2xhYnMuZHluYW1vZGItbWNwLXNlcnZlciU0MGxhdGVzdCUyMiUyQyUyMmVudiUyMiUzQSU3QiUyMkREQi1NQ1AtUkVBRE9OTFklMjIlM0ElMjJ0cnVlJTIyJTJDJTIyQVdTX1BST0ZJTEUlMjIlM0ElMjJkZWZhdWx0JTIyJTJDJTIyQVdTX1JFR0lPTiUyMiUzQSUyMnVzLXdlc3QtMiUyMiUyQyUyMkZBU1RNQ1BfTE9HX0xFVkVMJTIyJTNBJTIyRVJST1IlMjIlN0QlMkMlMjJkaXNhYmxlZCUyMiUzQWZhbHNlJTJDJTIyYXV0b0FwcHJvdmUlMjIlM0ElNUIlNUQlN0Q%3D)| [![Install on VS Code](https://img.shields.io/badge/Install_on-VS_Code-FF9900?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=DynamoDB%20MCP%20Server&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22awslabs.dynamodb-mcp-server%40latest%22%5D%2C%22env%22%3A%7B%22DDB-MCP-READONLY%22%3A%22true%22%2C%22AWS_PROFILE%22%3A%22default%22%2C%22AWS_REGION%22%3A%22us-west-2%22%2C%22FASTMCP_LOG_LEVEL%22%3A%22ERROR%22%7D%2C%22disabled%22%3Afalse%2C%22autoApprove%22%3A%5B%5D%7D) |
-
-Add the MCP to your favorite agentic tools. (e.g. for Amazon Q Developer CLI MCP, `~/.aws/amazonq/mcp.json`):
-
-```json
-{
-  "mcpServers": {
-    "awslabs.dynamodb-mcp-server": {
-      "command": "uvx",
-      "args": ["awslabs.dynamodb-mcp-server@latest"],
-      "env": {
-        "DDB-MCP-READONLY": "true",
-        "AWS_PROFILE": "default",
-        "AWS_REGION": "us-west-2",
-        "FASTMCP_LOG_LEVEL": "ERROR"
-      },
-      "disabled": false,
-      "autoApprove": []
-    }
-  }
-}
-```
-### Windows Installation
-
-For Windows users, the MCP server configuration format is slightly different:
-
-```json
-{
-  "mcpServers": {
-    "awslabs.dynamodb-mcp-server": {
-      "disabled": false,
-      "timeout": 60,
-      "type": "stdio",
-      "command": "uv",
-      "args": [
-        "tool",
-        "run",
-        "--from",
-        "awslabs.dynamodb-mcp-server@latest",
-        "awslabs.dynamodb-mcp-server.exe"
-      ],
-      "env": {
-        "FASTMCP_LOG_LEVEL": "ERROR",
-        "AWS_PROFILE": "your-aws-profile",
-        "AWS_REGION": "us-east-1"
-      }
-    }
-  }
-}
-```
-
-
-or docker after a successful `docker build -t awslabs/dynamodb-mcp-server .`:
-
-```json
-  {
-    "mcpServers": {
-      "awslabs.dynamodb-mcp-server": {
-        "command": "docker",
-        "args": [
-          "run",
-          "--rm",
-          "--interactive",
-          "--env",
-          "FASTMCP_LOG_LEVEL=ERROR",
-          "awslabs/dynamodb-mcp-server:latest"
-        ],
-        "env": {},
-        "disabled": false,
-        "autoApprove": []
-      }
-    }
-  }
-```

awslabs_dynamodb_mcp_server-2.0.1.dist-info/RECORD

@@ -1,11 +0,0 @@
-awslabs/__init__.py,sha256=WuqxdDgUZylWNmVoPKiK7qGsTB_G4UmuXIrJ-VBwDew,731
-awslabs/dynamodb_mcp_server/__init__.py,sha256=hJ7kw5_k2dM1Oyf4t2H4FTU6MFmdqfhbdtGgoodLci4,673
-awslabs/dynamodb_mcp_server/common.py,sha256=--RWFURrGYjRjAnOuIbyX-DDrfZy1EeQXXRg4lASFB4,1677
-awslabs/dynamodb_mcp_server/server.py,sha256=-g3MIL7wYG7LnOUV47mAb2lrJTvOGipTbWbBA-jvGFs,2919
-awslabs/dynamodb_mcp_server/prompts/dynamodb_architect.md,sha256=gaWjHmTu2oFiFnEKCs20Xe2JbClr6q4kP9e4_MK1Shw,39866
-awslabs_dynamodb_mcp_server-2.0.1.dist-info/METADATA,sha256=lMeU3euDvfmGDzSKS_vimIw-c-3ErSA4WoJ1b-iNvOs,6459
-awslabs_dynamodb_mcp_server-2.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-awslabs_dynamodb_mcp_server-2.0.1.dist-info/entry_points.txt,sha256=Vn6TvAN9d67Lsbkcs0UcIiOBI5xDpNBm_MOOzc1h-YU,88
-awslabs_dynamodb_mcp_server-2.0.1.dist-info/licenses/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-awslabs_dynamodb_mcp_server-2.0.1.dist-info/licenses/NOTICE,sha256=47UMmTFkf8rUc_JaJfdWe6NsAJQOcZNPZIL6JzU_k5U,95
-awslabs_dynamodb_mcp_server-2.0.1.dist-info/RECORD,,