awslabs.mysql-mcp-server 0.0.1__py3-none-any.whl

awslabs/__init__.py

@@ -0,0 +1,13 @@
+# 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. A copy of the License is located at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+# OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+# and limitations under the License.
+
+# This file is part of the awslabs namespace.
+# It is intentionally minimal to support PEP 420 namespace packages.

awslabs/mysql_mcp_server/__init__.py

@@ -0,0 +1,14 @@
+# 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. A copy of the License is located at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+# OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+# and limitations under the License.
+
+"""awslabs.mysql_mcp_server"""
+
+__version__ = '0.0.0'

awslabs/mysql_mcp_server/mutable_sql_detector.py

@@ -0,0 +1,150 @@
+# 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. A copy of the License is located at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+# OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+# and limitations under the License.
+
+import re
+
+
+# -- Mutating keyword set for quick string matching --
+MUTATING_KEYWORDS = {
+    'INSERT',
+    'UPDATE',
+    'DELETE',
+    'REPLACE',
+    'TRUNCATE',
+    'CREATE',
+    'DROP',
+    'ALTER',
+    'RENAME',
+    'GRANT',
+    'REVOKE',
+    'LOAD DATA',
+    'LOAD XML',
+    'INSTALL PLUGIN',
+    'UNINSTALL PLUGIN',
+}
+
+MUTATING_PATTERN = re.compile(
+    r'(?i)\b(' + '|'.join(re.escape(k) for k in MUTATING_KEYWORDS) + r')\b'
+)
+
+# -- Regex for DDL statements --
+DDL_REGEX = re.compile(
+    r"""
+    ^\s*(
+        CREATE\s+(TABLE|VIEW|INDEX|TRIGGER|PROCEDURE|FUNCTION|EVENT)|
+        DROP\s+(TABLE|VIEW|INDEX|TRIGGER|PROCEDURE|FUNCTION|EVENT)|
+        ALTER\s+(TABLE|VIEW|TRIGGER|PROCEDURE|FUNCTION|EVENT)|
+        RENAME\s+(TABLE)|
+        TRUNCATE
+    )\b
+    """,
+    re.IGNORECASE | re.VERBOSE,
+)
+
+# -- Regex for permission-related statements --
+PERMISSION_REGEX = re.compile(
+    r"""
+    ^\s*(
+        GRANT(\s+ROLE)?|
+        REVOKE(\s+ROLE)?|
+        CREATE\s+(USER|ROLE)|
+        DROP\s+(USER|ROLE)|
+        SET\s+DEFAULT\s+ROLE|
+        SET\s+PASSWORD|
+        ALTER\s+USER|
+        RENAME\s+USER
+    )\b
+    """,
+    re.IGNORECASE | re.VERBOSE,
+)
+
+# -- Regex for system/control-level operations --
+SYSTEM_REGEX = re.compile(
+    r"""
+    ^\s*(
+        SET\s+(GLOBAL|PERSIST|SESSION)|
+        RESET\s+(PERSIST|MASTER|SLAVE)|
+        FLUSH\s+(PRIVILEGES|HOSTS|LOGS|STATUS|TABLES)?|
+        INSTALL\s+PLUGIN|UNINSTALL\s+PLUGIN|
+        CHANGE\s+MASTER\s+TO|
+        START\s+SLAVE|STOP\s+SLAVE|
+        SET\s+GTID_PURGED|
+        PURGE\s+BINARY\s+LOGS|
+        LOAD\s+DATA\s+INFILE|
+        SELECT\s+.*\s+INTO\s+OUTFILE|
+        USE\s+\w+|
+        SET\s+autocommit
+    )\b
+    """,
+    re.IGNORECASE | re.VERBOSE,
+)
+
+# -- Suspicious pattern detection (SQL injection, stacked queries, etc.) --
+SUSPICIOUS_PATTERNS = [
+    r'--.*$',  # single-line comment
+    r'/\*.*?\*/',  # multi-line comment
+    r"(?i)'.*?--",  # comment injection
+    r'(?i)\bor\b\s+\d+\s*=\s*\d+',  # numeric tautology
+    r"(?i)\bor\b\s*'[^']+'\s*=\s*'[^']+'",  # string tautology
+    r'(?i)\bunion\b.*\bselect\b',  # UNION SELECT
+    r'(?i)\bdrop\b',  # DROP
+    r'(?i)\btruncate\b',  # TRUNCATE
+    r'(?i)\bgrant\b|\brevoke\b',  # GRANT or REVOKE
+    r'(?i);',  # stacked queries
+    r'(?i)\bsleep\s*\(',  # time-based injection
+    r'(?i)\bload_file\s*\(',  # file read
+    r'(?i)\binto\s+outfile\b',  # file write
+]
+
+
+def detect_mutating_keywords(sql: str) -> list[str]:
+    """Return a list of mutating keywords found in the SQL (excluding comments)."""
+    matched = []
+
+    if DDL_REGEX.search(sql):
+        matched.append('DDL')
+
+    if PERMISSION_REGEX.search(sql):
+        matched.append('PERMISSION')
+
+    if SYSTEM_REGEX.search(sql):
+        matched.append('SYSTEM')
+
+    # Match individual keywords from MUTATING_KEYWORDS
+    keyword_matches = MUTATING_PATTERN.findall(sql)
+    if keyword_matches:
+        # Deduplicate and normalize casing
+        matched.extend(sorted({k.upper() for k in keyword_matches}))
+
+    return matched
+
+
+def check_sql_injection_risk(sql: str) -> list[dict]:
+    """Check for potential SQL injection risks in sql query.
+
+    Args:
+        sql: query string
+
+    Returns:
+        dictionaries containing detected security issue
+    """
+    issues = []
+    for pattern in SUSPICIOUS_PATTERNS:
+        if re.search(pattern, sql):
+            issues.append(
+                {
+                    'type': 'sql',
+                    'message': f'Suspicious pattern: {pattern}',
+                    'severity': 'high',
+                }
+            )
+            break
+    return issues

awslabs/mysql_mcp_server/server.py

@@ -0,0 +1,374 @@
+# 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. A copy of the License is located at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+# OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+# and limitations under the License.
+
+"""awslabs mysql MCP Server implementation."""
+
+import argparse
+import asyncio
+import boto3
+import sys
+from awslabs.mysql_mcp_server.mutable_sql_detector import (
+    check_sql_injection_risk,
+    detect_mutating_keywords,
+)
+from botocore.exceptions import BotoCoreError, ClientError
+from loguru import logger
+from mcp.server.fastmcp import Context, FastMCP
+from pydantic import Field
+from typing import Annotated, Any, Dict, List, Optional
+
+
+client_error_code_key = 'run_query ClientError code'
+unexpected_error_key = 'run_query unexpected error'
+write_query_prohibited_key = 'Your MCP tool only allows readonly query. If you want to write, change the MCP configuration per README.md'
+query_injection_risk_key = 'Your query contains risky injection patterns'
+
+
+class DummyCtx:
+    """A dummy context class for error handling in MCP tools."""
+
+    async def error(self, message):
+        """Raise a runtime error with the given message.
+
+        Args:
+            message: The error message to include in the runtime error
+        """
+        # Do nothing
+        pass
+
+
+class DBConnection:
+    """Class that wraps DB connection client by RDS API."""
+
+    def __init__(self, cluster_arn, secret_arn, database, region, readonly, is_test=False):
+        """Initialize a new DB connection.
+
+        Args:
+            cluster_arn: The ARN of the RDS cluster
+            secret_arn: The ARN of the secret containing credentials
+            database: The name of the database to connect to
+            region: The AWS region where the RDS instance is located
+            readonly: Whether the connection should be read-only
+            is_test: Whether this is a test connection
+        """
+        self.cluster_arn = cluster_arn
+        self.secret_arn = secret_arn
+        self.database = database
+        self.readonly = readonly
+        if not is_test:
+            self.data_client = boto3.client('rds-data', region_name=region)
+
+    @property
+    def readonly_query(self):
+        """Get whether this connection is read-only.
+
+        Returns:
+            bool: True if the connection is read-only, False otherwise
+        """
+        return self.readonly
+
+
+class DBConnectionSingleton:
+    """Manages a single DBConnection instance across the application.
+
+    This singleton ensures that only one DBConnection is created and reused.
+    """
+
+    _instance = None
+
+    def __init__(self, resource_arn, secret_arn, database, region, readonly, is_test=False):
+        """Initialize a new DB connection singleton.
+
+        Args:
+            resource_arn: The ARN of the RDS resource
+            secret_arn: The ARN of the secret containing credentials
+            database: The name of the database to connect to
+            region: The AWS region where the RDS instance is located
+            readonly: Whether the connection should be read-only
+            is_test: Whether this is a test connection
+        """
+        if not all([resource_arn, secret_arn, database, region]):
+            raise ValueError(
+                'Missing required connection parameters. '
+                'Please provide resource_arn, secret_arn, database, and region.'
+            )
+        self._db_connection = DBConnection(
+            resource_arn, secret_arn, database, region, readonly, is_test
+        )
+
+    @classmethod
+    def initialize(cls, resource_arn, secret_arn, database, region, readonly, is_test=False):
+        """Initialize the singleton instance if it doesn't exist.
+
+        Args:
+            resource_arn: The ARN of the RDS resource
+            secret_arn: The ARN of the secret containing credentials
+            database: The name of the database to connect to
+            region: The AWS region where the RDS instance is located
+            readonly: Whether the connection should be read-only
+            is_test: Whether this is a test connection
+        """
+        if cls._instance is None:
+            cls._instance = cls(resource_arn, secret_arn, database, region, readonly, is_test)
+
+    @classmethod
+    def get(cls):
+        """Get the singleton instance.
+
+        Returns:
+            DBConnectionSingleton: The singleton instance
+
+        Raises:
+            RuntimeError: If the singleton has not been initialized
+        """
+        if cls._instance is None:
+            raise RuntimeError('DBConnectionSingleton is not initialized.')
+        return cls._instance
+
+    @property
+    def db_connection(self):
+        """Get the database connection.
+
+        Returns:
+            DBConnection: The database connection instance
+        """
+        return self._db_connection
+
+
+def extract_cell(cell: dict):
+    """Extracts the scalar or array value from a single cell."""
+    if cell.get('isNull'):
+        return None
+    for key in (
+        'stringValue',
+        'longValue',
+        'doubleValue',
+        'booleanValue',
+        'blobValue',
+        'arrayValue',
+    ):
+        if key in cell:
+            return cell[key]
+    return None
+
+
+def parse_execute_response(response: dict) -> list[dict]:
+    """Convert RDS Data API execute_statement response to list of rows."""
+    columns = [col['name'] for col in response.get('columnMetadata', [])]
+    records = []
+
+    for row in response.get('records', []):
+        row_data = {col: extract_cell(cell) for col, cell in zip(columns, row)}
+        records.append(row_data)
+
+    return records
+
+
+mcp = FastMCP(
+    'awslabs.mysql-mcp-server',
+    instructions='You are an expert MySQL assistant. Use run_query and get_table_schema to interfact with the database.',
+    dependencies=['loguru', 'boto3', 'pydantic'],
+)
+
+
+@mcp.tool(name='run_query', description='Run a SQL query against a MySQL database')
+async def run_query(
+    sql: Annotated[str, Field(description='The SQL query to run')],
+    ctx: Context,
+    db_connection=None,
+    query_parameters: Annotated[
+        Optional[List[Dict[str, Any]]], Field(description='Parameters for the SQL query')
+    ] = None,
+) -> list[dict]:  # type: ignore
+    """Run a SQL query against a MySQL database.
+
+    Args:
+        sql: The sql statement to run
+        ctx: MCP context for logging and state management
+        db_connection: DB connection object passed by unit test. It should be None if if called by MCP server.
+        query_parameters: Parameters for the SQL query
+
+    Returns:
+        List of dictionary that contains query response rows
+    """
+    global client_error_code_key
+    global unexpected_error_key
+    global write_query_prohibited_key
+
+    if db_connection is None:
+        db_connection = DBConnectionSingleton.get().db_connection
+
+    if db_connection.readonly_query:
+        matches = detect_mutating_keywords(sql)
+        if (bool)(matches):
+            logger.info(
+                f'query is rejected because current setting only allows readonly query. detected keywords: {matches}, SQL query: {sql}'
+            )
+
+            await ctx.error(write_query_prohibited_key)
+            return [{'error': write_query_prohibited_key}]
+
+    issues = check_sql_injection_risk(sql)
+    if issues:
+        logger.info(
+            f'query is rejected because it contains risky SQL pattern, SQL query: {sql}, reasons: {issues}'
+        )
+        await ctx.error(
+            str({'message': 'Query parameter contains suspicious pattern', 'details': issues})
+        )
+        return [{'error': query_injection_risk_key}]
+
+    try:
+        logger.info(f'run_query: readonly:{db_connection.readonly_query}, SQL:{sql}')
+
+        execute_params = {
+            'resourceArn': db_connection.cluster_arn,
+            'secretArn': db_connection.secret_arn,
+            'database': db_connection.database,
+            'sql': sql,
+            'includeResultMetadata': True,
+        }
+
+        if query_parameters:
+            execute_params['parameters'] = query_parameters
+
+        response = await asyncio.to_thread(
+            db_connection.data_client.execute_statement, **execute_params
+        )
+
+        logger.success('run_query successfully executed query:{}', sql)
+        return parse_execute_response(response)
+    except ClientError as e:
+        logger.exception(client_error_code_key)
+        await ctx.error(
+            str({'code': e.response['Error']['Code'], 'message': e.response['Error']['Message']})
+        )
+        return [{'error': client_error_code_key}]
+    except Exception as e:
+        logger.exception(unexpected_error_key)
+        error_details = f'{type(e).__name__}: {str(e)}'
+        await ctx.error(str({'message': error_details}))
+        return [{'error': unexpected_error_key}]
+
+
+@mcp.tool(
+    name='get_table_schema',
+    description='Fetch table schema from the MySQL database',
+)
+async def get_table_schema(
+    table_name: Annotated[str, Field(description='name of the table')],
+    database_name: Annotated[str, Field(description='name of the database')],
+    ctx: Context,
+) -> list[dict]:
+    """Get a table's schema information given the table name.
+
+    Args:
+        table_name: name of the table
+        database_name: name of the database
+        ctx: MCP context for logging and state management
+
+    Returns:
+        List of dictionary that contains query response rows
+    """
+    logger.info(f'get_table_schema: {table_name}')
+
+    sql = """
+        SELECT
+            COLUMN_NAME,
+            COLUMN_TYPE,
+            IS_NULLABLE,
+            COLUMN_DEFAULT,
+            EXTRA,
+            COLUMN_KEY,
+            COLUMN_COMMENT
+        FROM
+            information_schema.columns
+        WHERE
+            table_schema = :database_name
+            AND table_name = :table_name
+        ORDER BY
+            ORDINAL_POSITION
+    """
+    params = [
+        {'name': 'table_name', 'value': {'stringValue': table_name}},
+        {'name': 'database_name', 'value': {'stringValue': database_name}},
+    ]
+
+    return await run_query(sql=sql, ctx=ctx, query_parameters=params)
+
+
+def main():
+    """Main entry point for the MCP server application."""
+    global client_error_code_key
+
+    """Run the MCP server with CLI argument support."""
+    parser = argparse.ArgumentParser(
+        description='An AWS Labs Model Context Protocol (MCP) server for MySQL'
+    )
+    parser.add_argument('--sse', action='store_true', help='Use SSE transport')
+    parser.add_argument('--port', type=int, default=8888, help='Port to run the server on')
+    parser.add_argument('--resource_arn', required=True, help='ARN of the RDS cluster')
+    parser.add_argument(
+        '--secret_arn',
+        required=True,
+        help='ARN of the Secrets Manager secret for database credentials',
+    )
+    parser.add_argument('--database', required=True, help='Database name')
+    parser.add_argument(
+        '--region', required=True, help='AWS region for RDS Data API (default: us-west-2)'
+    )
+    parser.add_argument(
+        '--readonly', required=True, help='Enforce NL to SQL to only allow readonly sql statement'
+    )
+    args = parser.parse_args()
+
+    logger.info(
+        'MySQL MCP init with CLUSTER_ARN:{}, SECRET_ARN:{}, REGION:{}, DATABASE:{}, READONLY:{}',
+        args.resource_arn,
+        args.secret_arn,
+        args.region,
+        args.database,
+        args.readonly,
+    )
+
+    try:
+        DBConnectionSingleton.initialize(
+            args.resource_arn, args.secret_arn, args.database, args.region, args.readonly
+        )
+    except BotoCoreError:
+        logger.exception('Failed to RDS API client object for MySQL. Exit the MCP server')
+        sys.exit(1)
+
+    # Test RDS API connection
+    ctx = DummyCtx()
+    response = asyncio.run(run_query('SELECT 1', ctx))
+    if (
+        isinstance(response, list)
+        and len(response) == 1
+        and isinstance(response[0], dict)
+        and 'error' in response[0]
+    ):
+        logger.error('Failed to validate RDS API db connection to MySQL. Exit the MCP server')
+        sys.exit(1)
+
+    logger.success('Successfully validated RDS API db connection to MySQL')
+
+    # Run server with appropriate transport
+    if args.sse:
+        mcp.settings.port = args.port
+        mcp.run(transport='sse')
+    else:
+        logger.info('Starting MySQL MCP server')
+        mcp.run()
+
+
+if __name__ == '__main__':
+    main()

awslabs_mysql_mcp_server-0.0.1.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: awslabs.mysql-mcp-server
+Version: 0.0.1
+Summary: An AWS Labs Model Context Protocol (MCP) server for mysql
+Project-URL: homepage, https://awslabs.github.io/mcp/
+Project-URL: docs, https://awslabs.github.io/mcp/servers/mysql-mcp-server/
+Project-URL: documentation, https://awslabs.github.io/mcp/servers/mysql-mcp-server/
+Project-URL: repository, https://github.com/awslabs/mcp.git
+Project-URL: changelog, https://github.com/awslabs/mcp/blob/main/src/mysql-mcp-server/CHANGELOG.md
+Author: Amazon Web Services
+Author-email: AWSLabs MCP <203918161+awslabs-mcp@users.noreply.github.com>, Ken Zhang <kennthhz@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.38.14
+Requires-Dist: botocore>=1.38.14
+Requires-Dist: loguru>=0.7.0
+Requires-Dist: mcp[cli]>=1.6.0
+Requires-Dist: pydantic>=2.10.6
+Description-Content-Type: text/markdown
+
+# AWS Labs MySQL MCP Server
+
+An AWS Labs Model Context Protocol (MCP) server for Aurora MySQL
+
+## Features
+
+### Natural language to MySQL SQL query
+
+- Converting human-readable questions and commands into structured MySQL-compatible SQL queries and executing them against the configured Aurora MySQL database.
+
+## 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. Aurora MySQL Cluster with MySQL username and password stored in AWS Secrets Manager
+4. Enable RDS Data API for your Aurora MySQL Cluster, see [instructions here](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/data-api.html)
+5. This MCP server can only be run locally on the same host as your LLM client.
+6. Docker runtime
+7. Set up AWS credentials with access to AWS services
+   - You need an AWS account with appropriate permissions
+   - Configure AWS credentials with `aws configure` or environment variables
+
+## Installation
+
+Here are some ways you can work with MCP across AWS, and we'll be adding support to more products including Amazon Q Developer CLI soon: (e.g. for Amazon Q Developer CLI MCP, `~/.aws/amazonq/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "awslabs.mysql-mcp-server": {
+      "command": "uvx",
+      "args": [
+        "awslabs.mysql-mcp-server@latest",
+        "--resource_arn", "[your data]",
+        "--secret_arn", "[your data]",
+        "--database", "[your data]",
+        "--region", "[your data]",
+        "--readonly", "True"
+      ],
+      "env": {
+        "AWS_PROFILE": "your-aws-profile",
+        "AWS_REGION": "us-east-1",
+        "FASTMCP_LOG_LEVEL": "ERROR"
+      },
+      "disabled": false,
+      "autoApprove": []
+    }
+  }
+}
+```
+
+### Build and install docker image locally on the same host of your LLM client
+
+1. 'git clone https://github.com/awslabs/mcp.git'
+2. Go to sub-directory 'src/mysql-mcp-server/'
+3. Run 'docker build -t awslabs/mysql-mcp-server:latest .'
+
+### Add or update your LLM client's config with following:
+<pre><code>
+{
+  "mcpServers": {
+    "awslabs.mysql-mcp-server": {
+      "command": "docker",
+      "args": [
+        "run",
+        "-i",
+        "--rm",
+        "-e", "AWS_ACCESS_KEY_ID=[your data]",
+        "-e", "AWS_SECRET_ACCESS_KEY=[your data]",
+        "-e", "AWS_REGION=[your data]",
+        "awslabs/mysql-mcp-server:latest",
+        "--resource_arn", "[your data]",
+        "--secret_arn", "[your data]",
+        "--database", "[your data]",
+        "--region", "[your data]",
+        "--readonly", "True"
+      ]
+    }
+  }
+}
+</code></pre>
+
+NOTE: By default, only read-only queries are allowed and it is controlled by --readonly parameter above. Set it to False if you also want to allow writable DML or DDL.
+
+### AWS Authentication
+
+The MCP server uses the AWS profile specified in the `AWS_PROFILE` environment variable. If not provided, it defaults to the "default" profile in your AWS configuration file.
+
+```json
+"env": {
+  "AWS_PROFILE": "your-aws-profile"
+}
+```
+
+Make sure the AWS profile has permissions to access the [RDS data API](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/data-api.html#data-api.access), and the secret from AWS Secrets Manager. The MCP server creates a boto3 session using the specified profile to authenticate with AWS services. Your AWS IAM credentials remain on your local machine and are strictly used for accessing AWS services.

awslabs_mysql_mcp_server-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+awslabs/__init__.py,sha256=47wJeKcStxEJwX7SVVV2pnAWYR8FxcaYoT3YTmZ5Plg,674
+awslabs/mysql_mcp_server/__init__.py,sha256=_BajTXfPB4ubIrro0PBWJrVdwecctN3j2BaUo18DdL4,613
+awslabs/mysql_mcp_server/mutable_sql_detector.py,sha256=iaZZz1_p2VRBkJPclcGMSUU51Vo70lDMK_o2fntvQ5w,4162
+awslabs/mysql_mcp_server/server.py,sha256=H51EjatD4CudZvIaH7SfxS9Dc31DSqwBzDtty8CoKyY,12722
+awslabs_mysql_mcp_server-0.0.1.dist-info/METADATA,sha256=fCj0xCeS-uhRPBLt96bLdgXB5nMW3j68QuLQuTUPD6E,4842
+awslabs_mysql_mcp_server-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+awslabs_mysql_mcp_server-0.0.1.dist-info/entry_points.txt,sha256=dQAG1BpfKE6diUKtCqzxwvWfPxDWGIEa87YcEb0T4rc,82
+awslabs_mysql_mcp_server-0.0.1.dist-info/licenses/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+awslabs_mysql_mcp_server-0.0.1.dist-info/licenses/NOTICE,sha256=lpdr2_2JGgD-RqTEnqMJttKCZVvC88gX4rbk0m8UifU,92
+awslabs_mysql_mcp_server-0.0.1.dist-info/RECORD,,

awslabs_mysql_mcp_server-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

awslabs_mysql_mcp_server-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+awslabs.mysql-mcp-server = awslabs.mysql_mcp_server.server:main

awslabs_mysql_mcp_server-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,175 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.

awslabs_mysql_mcp_server-0.0.1.dist-info/licenses/NOTICE

@@ -0,0 +1,2 @@
+awslabs.mysql-mcp-server
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.