This is page 374 of 389. Use http://codebase.md/awslabs/mcp?lines=false&page={x} to view the full context.
# Directory Structure
```
├── .devcontainer
│ └── devcontainer.json
├── .github
│ ├── actions
│ │ ├── build-and-push-container-image
│ │ │ └── action.yml
│ │ └── clear-space-ubuntu-latest-agressively
│ │ └── action.yml
│ ├── codecov.yml
│ ├── CODEOWNERS
│ ├── dependabot.yml
│ ├── ISSUE_TEMPLATE
│ │ ├── bug_report.yml
│ │ ├── documentation.yml
│ │ ├── feature_request.yml
│ │ ├── rfc.yml
│ │ └── support_awslabs_mcp_servers.yml
│ ├── pull_request_template.md
│ ├── SECURITY
│ ├── SUPPORT
│ └── workflows
│ ├── aws-api-mcp-upgrade-version.yml
│ ├── bandit-requirements.txt
│ ├── bandit.yml
│ ├── cfn_nag.yml
│ ├── check-gh-pages-builds.yml
│ ├── check-license-header-hash.txt
│ ├── check-license-header.json
│ ├── check-license-header.yml
│ ├── checkov.yml
│ ├── codeql.yml
│ ├── dependency-review-action.yml
│ ├── detect-secrets-requirements.txt
│ ├── gh-pages.yml
│ ├── merge-prevention.yml
│ ├── powershell.yml
│ ├── pre-commit-requirements.txt
│ ├── pre-commit.yml
│ ├── pull-request-lint.yml
│ ├── python.yml
│ ├── RELEASE_INSTRUCTIONS.md
│ ├── release-initiate-branch.yml
│ ├── release-merge-tag.yml
│ ├── release.py
│ ├── release.yml
│ ├── scanners.yml
│ ├── scorecard-analysis.yml
│ ├── semgrep-requirements.txt
│ ├── semgrep.yml
│ ├── stale.yml
│ ├── trivy.yml
│ └── typescript.yml
├── .gitignore
├── .pre-commit-config.yaml
├── .python-version
├── .ruff.toml
├── .secrets.baseline
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── DESIGN_GUIDELINES.md
├── DEVELOPER_GUIDE.md
├── docs
│ └── images
│ └── root-readme
│ ├── cline-api-provider-filled.png
│ ├── cline-chat-interface.png
│ ├── cline-custom-instructions.png
│ ├── cline-select-aws-profile.png
│ ├── cline-select-bedrock.png
│ ├── configure-mcp-servers.png
│ ├── install-cline-extension.png
│ ├── mcp-servers-installed.png
│ └── select-mcp-servers.png
├── docusaurus
│ ├── .gitignore
│ ├── docs
│ │ ├── installation.md
│ │ ├── intro.md
│ │ ├── samples
│ │ │ ├── index.md
│ │ │ ├── mcp-integration-with-kb.md
│ │ │ ├── mcp-integration-with-nova-canvas.md
│ │ │ └── stepfunctions-tool-mcp-server.md
│ │ ├── servers
│ │ │ ├── amazon-bedrock-agentcore-mcp-server.md
│ │ │ ├── amazon-keyspaces-mcp-server.md
│ │ │ ├── amazon-mq-mcp-server.md
│ │ │ ├── amazon-neptune-mcp-server.md
│ │ │ ├── amazon-qbusiness-anonymous-mcp-server.md
│ │ │ ├── amazon-qindex-mcp-server.md
│ │ │ ├── amazon-sns-sqs-mcp-server.md
│ │ │ ├── aurora-dsql-mcp-server.md
│ │ │ ├── aws-api-mcp-server.md
│ │ │ ├── aws-appsync-mcp-server.md
│ │ │ ├── aws-bedrock-custom-model-import-mcp-server.md
│ │ │ ├── aws-bedrock-data-automation-mcp-server.md
│ │ │ ├── aws-dataprocessing-mcp-server.md
│ │ │ ├── aws-diagram-mcp-server.md
│ │ │ ├── aws-documentation-mcp-server.md
│ │ │ ├── aws-healthomics-mcp-server.md
│ │ │ ├── aws-iot-sitewise-mcp-server.md
│ │ │ ├── aws-knowledge-mcp-server.md
│ │ │ ├── aws-location-mcp-server.md
│ │ │ ├── aws-msk-mcp-server.md
│ │ │ ├── aws-pricing-mcp-server.md
│ │ │ ├── aws-serverless-mcp-server.md
│ │ │ ├── aws-support-mcp-server.md
│ │ │ ├── bedrock-kb-retrieval-mcp-server.md
│ │ │ ├── billing-cost-management-mcp-server.md
│ │ │ ├── ccapi-mcp-server.md
│ │ │ ├── cdk-mcp-server.md
│ │ │ ├── cfn-mcp-server.md
│ │ │ ├── cloudtrail-mcp-server.md
│ │ │ ├── cloudwatch-appsignals-mcp-server.md
│ │ │ ├── cloudwatch-mcp-server.md
│ │ │ ├── code-doc-gen-mcp-server.md
│ │ │ ├── core-mcp-server.md
│ │ │ ├── cost-explorer-mcp-server.md
│ │ │ ├── documentdb-mcp-server.md
│ │ │ ├── dynamodb-mcp-server.md
│ │ │ ├── ecs-mcp-server.md
│ │ │ ├── eks-mcp-server.md
│ │ │ ├── elasticache-mcp-server.md
│ │ │ ├── finch-mcp-server.md
│ │ │ ├── frontend-mcp-server.md
│ │ │ ├── git-repo-research-mcp-server.md
│ │ │ ├── healthlake-mcp-server.md
│ │ │ ├── iam-mcp-server.md
│ │ │ ├── kendra-index-mcp-server.md
│ │ │ ├── lambda-tool-mcp-server.md
│ │ │ ├── memcached-mcp-server.md
│ │ │ ├── mysql-mcp-server.md
│ │ │ ├── nova-canvas-mcp-server.md
│ │ │ ├── openapi-mcp-server.md
│ │ │ ├── postgres-mcp-server.md
│ │ │ ├── prometheus-mcp-server.md
│ │ │ ├── redshift-mcp-server.md
│ │ │ ├── s3-tables-mcp-server.md
│ │ │ ├── stepfunctions-tool-mcp-server.md
│ │ │ ├── syntheticdata-mcp-server.md
│ │ │ ├── terraform-mcp-server.md
│ │ │ ├── timestream-for-influxdb-mcp-server.md
│ │ │ ├── valkey-mcp-server.md
│ │ │ └── well-architected-security-mcp-server.mdx
│ │ └── vibe_coding.md
│ ├── docusaurus.config.ts
│ ├── package-lock.json
│ ├── package.json
│ ├── README.md
│ ├── sidebars.ts
│ ├── src
│ │ ├── components
│ │ │ ├── HomepageFeatures
│ │ │ │ └── styles.module.css
│ │ │ └── ServerCards
│ │ │ ├── index.tsx
│ │ │ └── styles.module.css
│ │ ├── css
│ │ │ ├── custom.css
│ │ │ └── doc-override.css
│ │ └── pages
│ │ ├── index.module.css
│ │ └── servers.tsx
│ ├── static
│ │ ├── .nojekyll
│ │ ├── assets
│ │ │ ├── icons
│ │ │ │ ├── activity.svg
│ │ │ │ ├── book-open.svg
│ │ │ │ ├── cpu.svg
│ │ │ │ ├── database.svg
│ │ │ │ ├── dollar-sign.svg
│ │ │ │ ├── help-circle.svg
│ │ │ │ ├── key.svg
│ │ │ │ ├── server.svg
│ │ │ │ ├── share-2.svg
│ │ │ │ ├── tool.svg
│ │ │ │ └── zap.svg
│ │ │ └── server-cards.json
│ │ └── img
│ │ ├── aws-logo.svg
│ │ └── logo.png
│ └── tsconfig.json
├── LICENSE
├── NOTICE
├── README.md
├── samples
│ ├── mcp-integration-with-kb
│ │ ├── .env.example
│ │ ├── .python-version
│ │ ├── assets
│ │ │ └── simplified-mcp-flow-diagram.png
│ │ ├── clients
│ │ │ └── client_server.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── user_interfaces
│ │ │ └── chat_bedrock_st.py
│ │ └── uv.lock
│ ├── mcp-integration-with-nova-canvas
│ │ ├── .env.example
│ │ ├── .python-version
│ │ ├── clients
│ │ │ └── client_server.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── user_interfaces
│ │ │ └── image_generator_st.py
│ │ └── uv.lock
│ ├── README.md
│ └── stepfunctions-tool-mcp-server
│ ├── README.md
│ └── sample_state_machines
│ ├── customer-create
│ │ └── app.py
│ ├── customer-id-from-email
│ │ └── app.py
│ ├── customer-info-from-id
│ │ └── app.py
│ └── template.yml
├── src
│ ├── amazon-bedrock-agentcore-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_bedrock_agentcore_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── config.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── cache.py
│ │ │ ├── doc_fetcher.py
│ │ │ ├── indexer.py
│ │ │ ├── text_processor.py
│ │ │ └── url_validator.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── SECURITY.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_cache.py
│ │ │ ├── test_config.py
│ │ │ ├── test_doc_fetcher.py
│ │ │ ├── test_indexer.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_server.py
│ │ │ ├── test_text_processor.py
│ │ │ └── test_url_validator.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-kendra-index-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_kendra_index_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── util.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-keyspaces-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_keyspaces_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── config.py
│ │ │ ├── consts.py
│ │ │ ├── llm_context.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── services.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_client.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_query_analysis_service.py
│ │ │ ├── test_server.py
│ │ │ └── test_services.py
│ │ └── uv.lock
│ ├── amazon-mq-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_mq_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_service_mcp_generator.py
│ │ │ ├── consts.py
│ │ │ ├── rabbitmq
│ │ │ │ ├── __init__.py
│ │ │ │ ├── admin.py
│ │ │ │ ├── connection.py
│ │ │ │ ├── doc
│ │ │ │ │ ├── rabbitmq_broker_sizing_guide.md
│ │ │ │ │ ├── rabbitmq_performance_optimization_best_practice.md
│ │ │ │ │ ├── rabbitmq_production_deployment_guidelines.md
│ │ │ │ │ ├── rabbitmq_quorum_queue_migration_guide.md
│ │ │ │ │ └── rabbitmq_setup_best_practice.md
│ │ │ │ ├── handlers.py
│ │ │ │ └── module.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── example
│ │ │ └── sample_mcp_q_cli.json
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── rabbitmq
│ │ │ │ ├── __init__.py
│ │ │ │ ├── conftest.py
│ │ │ │ ├── test_admin.py
│ │ │ │ ├── test_connection.py
│ │ │ │ ├── test_handlers.py
│ │ │ │ └── test_module.py
│ │ │ ├── test_aws_service_mcp_generator.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-neptune-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_neptune_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── exceptions.py
│ │ │ ├── graph_store
│ │ │ │ ├── __init__.py
│ │ │ │ ├── analytics.py
│ │ │ │ ├── base.py
│ │ │ │ └── database.py
│ │ │ ├── models.py
│ │ │ ├── neptune.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_analytics.py
│ │ │ ├── test_database.py
│ │ │ ├── test_exceptions.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_neptune.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-qbusiness-anonymous-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_qbusiness_anonymous_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── clients.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-qindex-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_qindex_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── clients.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_clients.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ └── uv.lock
│ ├── amazon-sns-sqs-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_sns_sqs_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── consts.py
│ │ │ ├── generator.py
│ │ │ ├── server.py
│ │ │ ├── sns.py
│ │ │ └── sqs.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── print_tools.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── README.md
│ │ │ ├── test_common.py
│ │ │ ├── test_generator.py
│ │ │ ├── test_server.py
│ │ │ ├── test_sns.py
│ │ │ └── test_sqs.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aurora-dsql-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aurora_dsql_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── mutable_sql_detector.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_connection_reuse.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_profile_option.py
│ │ │ ├── test_readonly_enforcement.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-api-mcp-server
│ │ ├── .gitattributes
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_api_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ ├── agent_scripts
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── manager.py
│ │ │ │ │ ├── models.py
│ │ │ │ │ └── registry
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── application-failure-troubleshooting.script.md
│ │ │ │ │ ├── cloudtral-mutli-region-setup.script.md
│ │ │ │ │ ├── create_amazon_aurora_db_cluster_with_instances.script.md
│ │ │ │ │ ├── lambda-timeout-debugging.script.md
│ │ │ │ │ ├── scripts_format.md
│ │ │ │ │ └── troubleshoot-permissions-with-cloudtrail-events.script.md
│ │ │ │ ├── aws
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── driver.py
│ │ │ │ │ ├── pagination.py
│ │ │ │ │ ├── regions.py
│ │ │ │ │ ├── service.py
│ │ │ │ │ └── services.py
│ │ │ │ ├── common
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── command_metadata.py
│ │ │ │ │ ├── command.py
│ │ │ │ │ ├── config.py
│ │ │ │ │ ├── errors.py
│ │ │ │ │ ├── file_operations.py
│ │ │ │ │ ├── file_system_controls.py
│ │ │ │ │ ├── helpers.py
│ │ │ │ │ ├── models.py
│ │ │ │ │ └── py.typed
│ │ │ │ ├── data
│ │ │ │ │ └── api_metadata.json
│ │ │ │ ├── metadata
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── read_only_operations_list.py
│ │ │ │ ├── parser
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── custom_validators
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── botocore_param_validator.py
│ │ │ │ │ │ ├── ec2_validator.py
│ │ │ │ │ │ └── ssm_validator.py
│ │ │ │ │ ├── interpretation.py
│ │ │ │ │ ├── lexer.py
│ │ │ │ │ └── parser.py
│ │ │ │ ├── py.typed
│ │ │ │ └── security
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_api_customization.json
│ │ │ │ └── policy.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── CONTRIBUTING.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── agent_scripts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_manager.py
│ │ │ │ └── test_registry
│ │ │ │ ├── another_valid_script.script.md
│ │ │ │ ├── test_script.script.md
│ │ │ │ └── valid_script.script.md
│ │ │ ├── aws
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_driver.py
│ │ │ │ ├── test_pagination.py
│ │ │ │ ├── test_service.py
│ │ │ │ └── test_services.py
│ │ │ ├── common
│ │ │ │ ├── test_command.py
│ │ │ │ ├── test_config.py
│ │ │ │ ├── test_file_operations.py
│ │ │ │ ├── test_file_system_controls.py
│ │ │ │ ├── test_file_validation.py
│ │ │ │ └── test_helpers.py
│ │ │ ├── fixtures.py
│ │ │ ├── history_handler.py
│ │ │ ├── metadata
│ │ │ │ ├── __init__.py
│ │ │ │ └── test_read_only_operations_list.py
│ │ │ ├── parser
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_file_path_detection.py
│ │ │ │ ├── test_lexer.py
│ │ │ │ ├── test_parser_customizations.py
│ │ │ │ └── test_parser.py
│ │ │ ├── test_security_policy.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-appsync-mcp-server
│ │ ├── .dockerignore
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_appsync_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── decorators.py
│ │ │ ├── helpers.py
│ │ │ ├── operations
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_api_cache.py
│ │ │ │ ├── create_api_key.py
│ │ │ │ ├── create_api.py
│ │ │ │ ├── create_channel_namespace.py
│ │ │ │ ├── create_datasource.py
│ │ │ │ ├── create_domain_name.py
│ │ │ │ ├── create_function.py
│ │ │ │ ├── create_graphql_api.py
│ │ │ │ ├── create_resolver.py
│ │ │ │ └── create_schema.py
│ │ │ ├── server.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_api_cache.py
│ │ │ │ ├── create_api_key.py
│ │ │ │ ├── create_api.py
│ │ │ │ ├── create_channel_namespace.py
│ │ │ │ ├── create_datasource.py
│ │ │ │ ├── create_domain_name.py
│ │ │ │ ├── create_function.py
│ │ │ │ ├── create_graphql_api.py
│ │ │ │ ├── create_resolver.py
│ │ │ │ └── create_schema.py
│ │ │ └── validators.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_all_create_tools_write_protection.py
│ │ │ ├── test_create_api_cache.py
│ │ │ ├── test_create_api_key.py
│ │ │ ├── test_create_api.py
│ │ │ ├── test_create_channel_namespace.py
│ │ │ ├── test_create_datasource_tool.py
│ │ │ ├── test_create_datasource.py
│ │ │ ├── test_create_domain_name.py
│ │ │ ├── test_create_function.py
│ │ │ ├── test_create_graphql_api.py
│ │ │ ├── test_create_resolver.py
│ │ │ ├── test_create_schema_tool.py
│ │ │ ├── test_create_schema.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_server.py
│ │ │ ├── test_validators.py
│ │ │ └── test_write_operation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-bedrock-custom-model-import-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_bedrock_custom_model_import_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── llm_context.py
│ │ │ ├── models.py
│ │ │ ├── prompts.py
│ │ │ ├── server.py
│ │ │ ├── services
│ │ │ │ ├── __init__.py
│ │ │ │ ├── imported_model_service.py
│ │ │ │ └── model_import_service.py
│ │ │ ├── tools
│ │ │ │ ├── create_model_import_job.py
│ │ │ │ ├── delete_imported_model.py
│ │ │ │ ├── get_imported_model.py
│ │ │ │ ├── get_model_import_job.py
│ │ │ │ ├── list_imported_models.py
│ │ │ │ └── list_model_import_jobs.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws.py
│ │ │ ├── config.py
│ │ │ ├── consts.py
│ │ │ └── matching.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── services
│ │ │ │ ├── test_imported_model_service.py
│ │ │ │ └── test_model_import_service.py
│ │ │ ├── test_client.py
│ │ │ ├── test_init.py
│ │ │ ├── test_llm_context.py
│ │ │ ├── test_prompts.py
│ │ │ ├── test_server.py
│ │ │ ├── tools
│ │ │ │ ├── test_create_model_import_job.py
│ │ │ │ ├── test_delete_imported_model.py
│ │ │ │ ├── test_get_imported_model.py
│ │ │ │ ├── test_get_model_import_job.py
│ │ │ │ ├── test_list_imported_models.py
│ │ │ │ └── test_list_model_import_jobs.py
│ │ │ └── utils
│ │ │ ├── test_aws.py
│ │ │ ├── test_config.py
│ │ │ └── test_matching.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-bedrock-data-automation-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_bedrock_data_automation_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── helpers.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-dataprocessing-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_dataprocessing_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ └── glue_data_catalog
│ │ │ │ ├── __init__.py
│ │ │ │ ├── data_catalog_database_manager.py
│ │ │ │ ├── data_catalog_handler.py
│ │ │ │ └── data_catalog_table_manager.py
│ │ │ ├── handlers
│ │ │ │ ├── __init__.py
│ │ │ │ ├── athena
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── athena_data_catalog_handler.py
│ │ │ │ │ ├── athena_query_handler.py
│ │ │ │ │ └── athena_workgroup_handler.py
│ │ │ │ ├── commons
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── common_resource_handler.py
│ │ │ │ ├── emr
│ │ │ │ │ ├── emr_ec2_cluster_handler.py
│ │ │ │ │ ├── emr_ec2_instance_handler.py
│ │ │ │ │ └── emr_ec2_steps_handler.py
│ │ │ │ └── glue
│ │ │ │ ├── __init__.py
│ │ │ │ ├── crawler_handler.py
│ │ │ │ ├── data_catalog_handler.py
│ │ │ │ ├── glue_commons_handler.py
│ │ │ │ ├── glue_etl_handler.py
│ │ │ │ ├── interactive_sessions_handler.py
│ │ │ │ └── worklows_handler.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ ├── athena_models.py
│ │ │ │ ├── common_resource_models.py
│ │ │ │ ├── data_catalog_models.py
│ │ │ │ ├── emr_models.py
│ │ │ │ └── glue_models.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws_helper.py
│ │ │ ├── consts.py
│ │ │ ├── logging_helper.py
│ │ │ └── mutable_sql_detector.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ └── glue_data_catalog
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_data_catalog_database_manager.py
│ │ │ │ ├── test_data_catalog_handler.py
│ │ │ │ └── test_data_catalog_table_manager.py
│ │ │ ├── handlers
│ │ │ │ ├── __init__.py
│ │ │ │ ├── athena
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── test_athena_data_catalog_handler.py
│ │ │ │ │ ├── test_athena_query_handler.py
│ │ │ │ │ ├── test_athena_workgroup_handler.py
│ │ │ │ │ └── test_custom_tags_athena.py
│ │ │ │ ├── commons
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── test_common_resource_handler.py
│ │ │ │ ├── emr
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── test_custom_tags_emr.py
│ │ │ │ │ ├── test_emr_ec2_cluster_handler.py
│ │ │ │ │ ├── test_emr_ec2_instance_handler.py
│ │ │ │ │ └── test_emr_ec2_steps_handler.py
│ │ │ │ └── glue
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_crawler_handler.py
│ │ │ │ ├── test_custom_tags_glue.py
│ │ │ │ ├── test_data_catalog_handler.py
│ │ │ │ ├── test_glue_commons_handler.py
│ │ │ │ ├── test_glue_etl_handler.py
│ │ │ │ ├── test_glue_interactive_sessions_handler.py
│ │ │ │ └── test_glue_workflows_handler.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_athena_models.py
│ │ │ │ ├── test_common_resource_models.py
│ │ │ │ ├── test_data_catalog_models.py
│ │ │ │ ├── test_emr_models.py
│ │ │ │ ├── test_glue_models.py
│ │ │ │ ├── test_interactive_sessions_models.py
│ │ │ │ └── test_workflows_models.py
│ │ │ ├── test_init.py
│ │ │ ├── test_server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── test_aws_helper.py
│ │ │ ├── test_custom_tags.py
│ │ │ └── test_logging_helper.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-diagram-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_diagram_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── diagrams_tools.py
│ │ │ ├── models.py
│ │ │ ├── scanner.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── resources
│ │ │ │ ├── __init__.py
│ │ │ │ └── example_diagrams
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_example.py
│ │ │ │ ├── flow_example.py
│ │ │ │ └── sequence_example.py
│ │ │ ├── test_diagrams.py
│ │ │ ├── test_models.py
│ │ │ ├── test_sarif_fix.py
│ │ │ ├── test_scanner.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-documentation-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_documentation_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── models.py
│ │ │ ├── server_aws_cn.py
│ │ │ ├── server_aws.py
│ │ │ ├── server_utils.py
│ │ │ ├── server.py
│ │ │ └── util.py
│ │ ├── basic-usage.gif
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── constants.py
│ │ │ ├── resources
│ │ │ │ └── lambda_sns_raw.html
│ │ │ ├── test_aws_cn_get_available_services_live.py
│ │ │ ├── test_aws_cn_read_documentation_live.py
│ │ │ ├── test_aws_read_documentation_live.py
│ │ │ ├── test_aws_recommend_live.py
│ │ │ ├── test_aws_search_live.py
│ │ │ ├── test_metadata_handling.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server_aws_cn.py
│ │ │ ├── test_server_aws.py
│ │ │ ├── test_server_utils.py
│ │ │ ├── test_server.py
│ │ │ └── test_util.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-healthomics-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_healthomics_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── helper_tools.py
│ │ │ │ ├── run_analysis.py
│ │ │ │ ├── troubleshooting.py
│ │ │ │ ├── workflow_analysis.py
│ │ │ │ ├── workflow_execution.py
│ │ │ │ ├── workflow_linting.py
│ │ │ │ └── workflow_management.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws_utils.py
│ │ │ ├── s3_utils.py
│ │ │ └── validation_utils.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── docs
│ │ │ └── workflow_linting.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_aws_utils.py
│ │ │ ├── test_consts.py
│ │ │ ├── test_helper_tools.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_run_analysis.py
│ │ │ ├── test_s3_utils.py
│ │ │ ├── test_server.py
│ │ │ ├── test_troubleshooting.py
│ │ │ ├── test_workflow_analysis.py
│ │ │ ├── test_workflow_execution.py
│ │ │ ├── test_workflow_linting.py
│ │ │ ├── test_workflow_management.py
│ │ │ └── test_workflow_tools.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-iot-sitewise-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_iot_sitewise_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── asset_hierarchy.py
│ │ │ │ ├── bulk_import_workflow.py
│ │ │ │ ├── data_exploration.py
│ │ │ │ └── data_ingestion.py
│ │ │ ├── server.py
│ │ │ ├── tool_metadata.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── sitewise_access.py
│ │ │ │ ├── sitewise_asset_models.py
│ │ │ │ ├── sitewise_assets.py
│ │ │ │ ├── sitewise_data.py
│ │ │ │ └── sitewise_gateways.py
│ │ │ └── validation.py
│ │ ├── CHANGELOG.md
│ │ ├── DEVELOPMENT.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ └── wind_farm_example.py
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_server.py
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_client.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_server.py
│ │ │ ├── test_sitewise_access.py
│ │ │ ├── test_sitewise_asset_models.py
│ │ │ ├── test_sitewise_assets.py
│ │ │ ├── test_sitewise_data.py
│ │ │ ├── test_sitewise_gateways.py
│ │ │ └── test_validation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-knowledge-mcp-server
│ │ └── README.md
│ ├── aws-location-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_location_server
│ │ │ ├── __init__.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_server_integration.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-msk-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_msk_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── tools
│ │ │ ├── __init__.py
│ │ │ ├── common_functions
│ │ │ │ ├── __init__.py
│ │ │ │ ├── client_manager.py
│ │ │ │ └── common_functions.py
│ │ │ ├── logs_and_telemetry
│ │ │ │ ├── __init__.py
│ │ │ │ ├── cluster_metrics_tools.py
│ │ │ │ ├── list_customer_iam_access.py
│ │ │ │ └── metric_config.py
│ │ │ ├── mutate_cluster
│ │ │ │ ├── __init__.py
│ │ │ │ ├── batch_associate_scram_secret.py
│ │ │ │ ├── batch_disassociate_scram_secret.py
│ │ │ │ ├── create_cluster_v2.py
│ │ │ │ ├── put_cluster_policy.py
│ │ │ │ ├── reboot_broker.py
│ │ │ │ ├── update_broker_count.py
│ │ │ │ ├── update_broker_storage.py
│ │ │ │ ├── update_broker_type.py
│ │ │ │ ├── update_cluster_configuration.py
│ │ │ │ ├── update_monitoring.py
│ │ │ │ └── update_security.py
│ │ │ ├── mutate_config
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_configuration.py
│ │ │ │ ├── tag_resource.py
│ │ │ │ ├── untag_resource.py
│ │ │ │ └── update_configuration.py
│ │ │ ├── mutate_vpc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_vpc_connection.py
│ │ │ │ ├── delete_vpc_connection.py
│ │ │ │ └── reject_client_vpc_connection.py
│ │ │ ├── read_cluster
│ │ │ │ ├── __init__.py
│ │ │ │ ├── describe_cluster_operation.py
│ │ │ │ ├── describe_cluster.py
│ │ │ │ ├── get_bootstrap_brokers.py
│ │ │ │ ├── get_cluster_policy.py
│ │ │ │ ├── get_compatible_kafka_versions.py
│ │ │ │ ├── list_client_vpc_connections.py
│ │ │ │ ├── list_cluster_operations.py
│ │ │ │ ├── list_nodes.py
│ │ │ │ └── list_scram_secrets.py
│ │ │ ├── read_config
│ │ │ │ ├── __init__.py
│ │ │ │ ├── describe_configuration_revision.py
│ │ │ │ ├── describe_configuration.py
│ │ │ │ ├── list_configuration_revisions.py
│ │ │ │ └── list_tags_for_resource.py
│ │ │ ├── read_global
│ │ │ │ ├── __init__.py
│ │ │ │ ├── list_clusters.py
│ │ │ │ ├── list_configurations.py
│ │ │ │ ├── list_kafka_versions.py
│ │ │ │ └── list_vpc_connections.py
│ │ │ ├── read_vpc
│ │ │ │ ├── __init__.py
│ │ │ │ └── describe_vpc_connection.py
│ │ │ └── static_tools
│ │ │ ├── __init__.py
│ │ │ └── cluster_best_practices.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_client_manager.py
│ │ │ ├── test_cluster_metrics_tools.py
│ │ │ ├── test_common_functions.py
│ │ │ ├── test_create_cluster_v2.py
│ │ │ ├── test_create_configuration.py
│ │ │ ├── test_create_vpc_connection.py
│ │ │ ├── test_delete_vpc_connection.py
│ │ │ ├── test_describe_cluster_operation.py
│ │ │ ├── test_describe_cluster.py
│ │ │ ├── test_describe_configuration_revision.py
│ │ │ ├── test_describe_configuration.py
│ │ │ ├── test_describe_vpc_connection.py
│ │ │ ├── test_get_bootstrap_brokers.py
│ │ │ ├── test_get_cluster_policy.py
│ │ │ ├── test_get_compatible_kafka_versions.py
│ │ │ ├── test_init.py
│ │ │ ├── test_list_client_vpc_connections.py
│ │ │ ├── test_list_cluster_operations.py
│ │ │ ├── test_list_clusters.py
│ │ │ ├── test_list_configuration_revisions.py
│ │ │ ├── test_list_configurations.py
│ │ │ ├── test_list_customer_iam_access.py
│ │ │ ├── test_list_kafka_versions.py
│ │ │ ├── test_list_nodes.py
│ │ │ ├── test_list_scram_secrets.py
│ │ │ ├── test_list_tags_for_resource.py
│ │ │ ├── test_list_vpc_connections.py
│ │ │ ├── test_logs_and_telemetry.py
│ │ │ ├── test_main.py
│ │ │ ├── test_mutate_cluster_init.py
│ │ │ ├── test_mutate_cluster_success_cases.py
│ │ │ ├── test_mutate_cluster.py
│ │ │ ├── test_mutate_config_init.py
│ │ │ ├── test_mutate_vpc_init.py
│ │ │ ├── test_read_cluster_init_updated.py
│ │ │ ├── test_read_cluster_init.py
│ │ │ ├── test_read_config_init.py
│ │ │ ├── test_read_global_init.py
│ │ │ ├── test_read_vpc_init.py
│ │ │ ├── test_reject_client_vpc_connection.py
│ │ │ ├── test_server.py
│ │ │ ├── test_static_tools_init.py
│ │ │ ├── test_tag_resource.py
│ │ │ ├── test_tool_descriptions.py
│ │ │ ├── test_untag_resource.py
│ │ │ └── test_update_configuration.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-pricing-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_pricing_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── cdk_analyzer.py
│ │ │ ├── consts.py
│ │ │ ├── helpers.py
│ │ │ ├── models.py
│ │ │ ├── pricing_client.py
│ │ │ ├── pricing_transformer.py
│ │ │ ├── report_generator.py
│ │ │ ├── server.py
│ │ │ ├── static
│ │ │ │ ├── __init__.py
│ │ │ │ ├── COST_REPORT_TEMPLATE.md
│ │ │ │ └── patterns
│ │ │ │ ├── __init__.py
│ │ │ │ └── BEDROCK.md
│ │ │ └── terraform_analyzer.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_cdk_analyzer.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_pricing_client.py
│ │ │ ├── test_pricing_transformer.py
│ │ │ ├── test_report_generator.py
│ │ │ ├── test_server.py
│ │ │ └── test_terraform_analyzer.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-serverless-mcp-server
│ │ ├── .pre-commit.config.yaml
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_serverless_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── models.py
│ │ │ ├── resources
│ │ │ │ ├── __init__.py
│ │ │ │ ├── deployment_details.py
│ │ │ │ ├── deployment_list.py
│ │ │ │ ├── template_details.py
│ │ │ │ └── template_list.py
│ │ │ ├── server.py
│ │ │ ├── template
│ │ │ │ ├── __init__.py
│ │ │ │ ├── registry.py
│ │ │ │ ├── renderer.py
│ │ │ │ └── templates
│ │ │ │ ├── backend.j2
│ │ │ │ ├── frontend.j2
│ │ │ │ ├── fullstack.j2
│ │ │ │ └── README.md
│ │ │ ├── tools
│ │ │ │ ├── common
│ │ │ │ │ └── base_tool.py
│ │ │ │ ├── guidance
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── deploy_serverless_app_help.py
│ │ │ │ │ ├── get_iac_guidance.py
│ │ │ │ │ ├── get_lambda_event_schemas.py
│ │ │ │ │ ├── get_lambda_guidance.py
│ │ │ │ │ └── get_serverless_templates.py
│ │ │ │ ├── sam
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── sam_build.py
│ │ │ │ │ ├── sam_deploy.py
│ │ │ │ │ ├── sam_init.py
│ │ │ │ │ ├── sam_local_invoke.py
│ │ │ │ │ └── sam_logs.py
│ │ │ │ ├── schemas
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── describe_schema.py
│ │ │ │ │ ├── list_registries.py
│ │ │ │ │ └── search_schema.py
│ │ │ │ └── webapps
│ │ │ │ ├── __init__.py
│ │ │ │ ├── configure_domain.py
│ │ │ │ ├── deploy_webapp.py
│ │ │ │ ├── get_metrics.py
│ │ │ │ ├── update_webapp_frontend.py
│ │ │ │ ├── utils
│ │ │ │ │ ├── deploy_service.py
│ │ │ │ │ ├── frontend_uploader.py
│ │ │ │ │ └── startup_script_generator.py
│ │ │ │ └── webapp_deployment_help.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws_client_helper.py
│ │ │ ├── cloudformation.py
│ │ │ ├── const.py
│ │ │ ├── deployment_manager.py
│ │ │ ├── github.py
│ │ │ └── process.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_cloudformation.py
│ │ │ ├── test_configure_domain.py
│ │ │ ├── test_deploy_serverless_app_help.py
│ │ │ ├── test_deploy_service.py
│ │ │ ├── test_deploy_webapp.py
│ │ │ ├── test_deployment_details.py
│ │ │ ├── test_deployment_help.py
│ │ │ ├── test_deployment_list.py
│ │ │ ├── test_deployment_manager.py
│ │ │ ├── test_frontend_uploader.py
│ │ │ ├── test_get_iac_guidance.py
│ │ │ ├── test_get_lambda_event_schemas.py
│ │ │ ├── test_get_lambda_guidance.py
│ │ │ ├── test_get_metrics.py
│ │ │ ├── test_get_serverless_templates.py
│ │ │ ├── test_github.py
│ │ │ ├── test_models.py
│ │ │ ├── test_process.py
│ │ │ ├── test_sam_build.py
│ │ │ ├── test_sam_deploy.py
│ │ │ ├── test_sam_init.py
│ │ │ ├── test_sam_local_invoke.py
│ │ │ ├── test_sam_logs.py
│ │ │ ├── test_schemas.py
│ │ │ ├── test_server.py
│ │ │ ├── test_startup_script_generator.py
│ │ │ ├── test_template_details.py
│ │ │ ├── test_template_list.py
│ │ │ ├── test_template_registry.py
│ │ │ ├── test_template_renderer.py
│ │ │ └── test_update_webapp_frontend.py
│ │ └── uv.lock
│ ├── aws-support-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_support_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── consts.py
│ │ │ ├── debug_helper.py
│ │ │ ├── errors.py
│ │ │ ├── formatters.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftests.py
│ │ │ ├── test_aws_support_mcp_server.py
│ │ │ └── test_models.py
│ │ └── uv.lock
│ ├── bedrock-kb-retrieval-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── bedrock_kb_retrieval_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── knowledgebases
│ │ │ │ ├── __init__.py
│ │ │ │ ├── clients.py
│ │ │ │ ├── discovery.py
│ │ │ │ └── retrieval.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_clients.py
│ │ │ ├── test_discovery.py
│ │ │ ├── test_env_config.py
│ │ │ ├── test_models.py
│ │ │ ├── test_retrieval.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── billing-cost-management-mcp-server
│ │ ├── __init__.py
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── billing_cost_management_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── models.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── decorator.py
│ │ │ │ ├── graviton_migration.py
│ │ │ │ ├── README.md
│ │ │ │ ├── savings_plans.py
│ │ │ │ └── types.py
│ │ │ ├── server.py
│ │ │ ├── templates
│ │ │ │ └── recommendation_templates
│ │ │ │ ├── ebs_volume.template
│ │ │ │ ├── ec2_asg.template
│ │ │ │ ├── ec2_instance.template
│ │ │ │ ├── ecs_service.template
│ │ │ │ ├── idle.template
│ │ │ │ ├── lambda_function.template
│ │ │ │ ├── rds_database.template
│ │ │ │ ├── reserved_instances.template
│ │ │ │ └── savings_plans.template
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_pricing_operations.py
│ │ │ │ ├── aws_pricing_tools.py
│ │ │ │ ├── bcm_pricing_calculator_tools.py
│ │ │ │ ├── budget_tools.py
│ │ │ │ ├── compute_optimizer_tools.py
│ │ │ │ ├── cost_anomaly_tools.py
│ │ │ │ ├── cost_comparison_tools.py
│ │ │ │ ├── cost_explorer_operations.py
│ │ │ │ ├── cost_explorer_tools.py
│ │ │ │ ├── cost_optimization_hub_helpers.py
│ │ │ │ ├── cost_optimization_hub_tools.py
│ │ │ │ ├── free_tier_usage_tools.py
│ │ │ │ ├── recommendation_details_tools.py
│ │ │ │ ├── ri_performance_tools.py
│ │ │ │ ├── sp_performance_tools.py
│ │ │ │ ├── storage_lens_tools.py
│ │ │ │ └── unified_sql_tools.py
│ │ │ └── utilities
│ │ │ ├── __init__.py
│ │ │ ├── aws_service_base.py
│ │ │ ├── constants.py
│ │ │ ├── logging_utils.py
│ │ │ └── sql_utils.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── requirements.txt
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ └── test_prompts.py
│ │ │ ├── README.md
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── fixtures.py
│ │ │ │ ├── test_aws_bcm_pricing_calculator_tools.py
│ │ │ │ ├── test_aws_pricing_tools.py
│ │ │ │ ├── test_budget_tools.py
│ │ │ │ ├── test_compute_optimizer_tools.py
│ │ │ │ ├── test_cost_anomaly_tools_enhanced.py
│ │ │ │ ├── test_cost_anomaly_tools.py
│ │ │ │ ├── test_cost_comparison_tools.py
│ │ │ │ ├── test_cost_explorer_operations.py
│ │ │ │ ├── test_cost_explorer_tools.py
│ │ │ │ ├── test_cost_optimization_hub_helpers.py
│ │ │ │ ├── test_cost_optimization_hub_tools.py
│ │ │ │ ├── test_free_tier_usage_tools_new.py
│ │ │ │ ├── test_recommendation_details_tools.py
│ │ │ │ ├── test_ri_performance_tools.py
│ │ │ │ ├── test_sp_performance_tools.py
│ │ │ │ ├── test_storage_lens_tools.py
│ │ │ │ └── test_unified_sql_tools.py
│ │ │ └── utilities
│ │ │ ├── test_aws_service_base.py
│ │ │ └── test_sql_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── ccapi-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── ccapi_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_client.py
│ │ │ ├── cloud_control_utils.py
│ │ │ ├── context.py
│ │ │ ├── errors.py
│ │ │ ├── iac_generator.py
│ │ │ ├── impl
│ │ │ │ ├── __init__.py
│ │ │ │ ├── tools
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── explanation.py
│ │ │ │ │ ├── infrastructure_generation.py
│ │ │ │ │ ├── resource_operations.py
│ │ │ │ │ ├── security_scanning.py
│ │ │ │ │ └── session_management.py
│ │ │ │ └── utils
│ │ │ │ ├── __init__.py
│ │ │ │ └── validation.py
│ │ │ ├── infrastructure_generator.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ └── models.py
│ │ │ ├── schema_manager.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ └── __init__.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_aws_client.py
│ │ │ ├── test_checkov_install.py
│ │ │ ├── test_cloud_control_utils.py
│ │ │ ├── test_context.py
│ │ │ ├── test_errors.py
│ │ │ ├── test_explanation.py
│ │ │ ├── test_iac_generator.py
│ │ │ ├── test_infrastructure_generation.py
│ │ │ ├── test_infrastructure_generator.py
│ │ │ ├── test_models.py
│ │ │ ├── test_resource_operations.py
│ │ │ ├── test_schema_manager.py
│ │ │ ├── test_security_scanning.py
│ │ │ ├── test_server.py
│ │ │ ├── test_session_management.py
│ │ │ └── test_validation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cdk-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cdk_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ ├── resources.py
│ │ │ │ ├── search_utils.py
│ │ │ │ ├── server.py
│ │ │ │ └── tools.py
│ │ │ ├── data
│ │ │ │ ├── __init__.py
│ │ │ │ ├── cdk_nag_parser.py
│ │ │ │ ├── construct_descriptions.py
│ │ │ │ ├── genai_cdk_loader.py
│ │ │ │ ├── lambda_layer_parser.py
│ │ │ │ ├── lambda_powertools_loader.py
│ │ │ │ ├── schema_generator.py
│ │ │ │ └── solutions_constructs_parser.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ ├── __init__.py
│ │ │ ├── CDK_GENERAL_GUIDANCE.md
│ │ │ ├── CDK_NAG_GUIDANCE.md
│ │ │ └── lambda_powertools
│ │ │ ├── bedrock.md
│ │ │ ├── cdk.md
│ │ │ ├── dependencies.md
│ │ │ ├── index.md
│ │ │ ├── insights.md
│ │ │ ├── logging.md
│ │ │ ├── metrics.md
│ │ │ └── tracing.md
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── test_resources_enhanced.py
│ │ │ │ ├── test_resources.py
│ │ │ │ ├── test_search_utils.py
│ │ │ │ ├── test_server.py
│ │ │ │ └── test_tools.py
│ │ │ └── data
│ │ │ ├── test_cdk_nag_parser.py
│ │ │ ├── test_genai_cdk_loader.py
│ │ │ ├── test_lambda_powertools_loader.py
│ │ │ ├── test_schema_generator.py
│ │ │ └── test_solutions_constructs_parser.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cfn-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cfn_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_client.py
│ │ │ ├── cloud_control_utils.py
│ │ │ ├── context.py
│ │ │ ├── errors.py
│ │ │ ├── iac_generator.py
│ │ │ ├── schema_manager.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_aws_client.py
│ │ │ ├── test_cloud_control_utils.py
│ │ │ ├── test_errors.py
│ │ │ ├── test_iac_generator.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_schema_manager.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cloudtrail-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cloudtrail_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── tools.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ └── test_tools.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cloudwatch-appsignals-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cloudwatch_appsignals_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── audit_presentation_utils.py
│ │ │ ├── audit_utils.py
│ │ │ ├── aws_clients.py
│ │ │ ├── canary_utils.py
│ │ │ ├── server.py
│ │ │ ├── service_audit_utils.py
│ │ │ ├── service_tools.py
│ │ │ ├── sli_report_client.py
│ │ │ ├── slo_tools.py
│ │ │ ├── trace_tools.py
│ │ │ └── utils.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_audit_presentation_utils.py
│ │ │ ├── test_audit_utils.py
│ │ │ ├── test_aws_profile.py
│ │ │ ├── test_canary_utils.py
│ │ │ ├── test_initialization.py
│ │ │ ├── test_server_audit_functions.py
│ │ │ ├── test_server_audit_tools.py
│ │ │ ├── test_server.py
│ │ │ ├── test_service_audit_utils.py
│ │ │ ├── test_service_tools_operations.py
│ │ │ ├── test_sli_report_client.py
│ │ │ ├── test_slo_tools.py
│ │ │ └── test_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cloudwatch-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cloudwatch_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── cloudwatch_alarms
│ │ │ │ ├── models.py
│ │ │ │ └── tools.py
│ │ │ ├── cloudwatch_logs
│ │ │ │ ├── models.py
│ │ │ │ └── tools.py
│ │ │ ├── cloudwatch_metrics
│ │ │ │ ├── data
│ │ │ │ │ └── metric_metadata.json
│ │ │ │ ├── models.py
│ │ │ │ └── tools.py
│ │ │ ├── common.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── cloudwatch_alarms
│ │ │ │ ├── test_active_alarms.py
│ │ │ │ ├── test_alarm_history_integration.py
│ │ │ │ ├── test_alarm_history.py
│ │ │ │ └── test_alarms_error_handling.py
│ │ │ ├── cloudwatch_logs
│ │ │ │ ├── test_logs_error_handling.py
│ │ │ │ ├── test_logs_models.py
│ │ │ │ └── test_logs_server.py
│ │ │ ├── cloudwatch_metrics
│ │ │ │ ├── test_metrics_error_handling.py
│ │ │ │ ├── test_metrics_models.py
│ │ │ │ ├── test_metrics_server.py
│ │ │ │ └── test_validation_error.py
│ │ │ ├── test_common_and_server.py
│ │ │ ├── test_init.py
│ │ │ └── test_main.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── code-doc-gen-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── code_doc_gen_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── doc_generator.py
│ │ │ ├── models.py
│ │ │ ├── repomix_manager.py
│ │ │ └── templates.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_doc_generator_edge_cases.py
│ │ │ ├── test_doc_generator.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_repomix_manager_scenarios.py
│ │ │ ├── test_repomix_manager.py
│ │ │ ├── test_repomix_statistics.py
│ │ │ ├── test_server_extended.py
│ │ │ ├── test_server.py
│ │ │ └── test_templates.py
│ │ └── uv.lock
│ ├── core-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── core_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ ├── __init__.py
│ │ │ └── PROMPT_UNDERSTANDING.md
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_response_types.py
│ │ │ ├── test_server.py
│ │ │ └── test_static.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cost-explorer-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cost_explorer_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── comparison_handler.py
│ │ │ ├── constants.py
│ │ │ ├── cost_usage_handler.py
│ │ │ ├── forecasting_handler.py
│ │ │ ├── helpers.py
│ │ │ ├── metadata_handler.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── utility_handler.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_comparison_handler.py
│ │ │ ├── test_cost_usage_handler.py
│ │ │ ├── test_forecasting_handler.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_metadata_handler.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ └── test_utility_handler.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── documentdb-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ └── documentdb_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── analytic_tools.py
│ │ │ ├── config.py
│ │ │ ├── connection_tools.py
│ │ │ ├── db_management_tools.py
│ │ │ ├── query_tools.py
│ │ │ ├── server.py
│ │ │ └── write_tools.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_analytic_tools.py
│ │ │ ├── test_connection_tools.py
│ │ │ ├── test_db_management_tools.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_query_tools.py
│ │ │ └── test_write_tools.py
│ │ └── uv.lock
│ ├── dynamodb-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── dynamodb_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── database_analysis_queries.py
│ │ │ ├── database_analyzers.py
│ │ │ ├── prompts
│ │ │ │ └── dynamodb_architect.md
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── evals
│ │ │ │ ├── dynamic_evaluators.py
│ │ │ │ ├── evaluation_registry.py
│ │ │ │ ├── logging_config.py
│ │ │ │ ├── multiturn_evaluator.py
│ │ │ │ ├── README.md
│ │ │ │ ├── scenarios.py
│ │ │ │ └── test_dspy_evals.py
│ │ │ ├── test_dynamodb_server.py
│ │ │ └── test_source_db_integration.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── ecs-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── ecs_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── api
│ │ │ │ ├── __init__.py
│ │ │ │ ├── containerize.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── ecs_troubleshooting.py
│ │ │ │ ├── infrastructure.py
│ │ │ │ ├── resource_management.py
│ │ │ │ ├── status.py
│ │ │ │ └── troubleshooting_tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── detect_image_pull_failures.py
│ │ │ │ ├── fetch_cloudformation_status.py
│ │ │ │ ├── fetch_network_configuration.py
│ │ │ │ ├── fetch_service_events.py
│ │ │ │ ├── fetch_task_failures.py
│ │ │ │ ├── fetch_task_logs.py
│ │ │ │ ├── get_ecs_troubleshooting_guidance.py
│ │ │ │ └── utils.py
│ │ │ ├── main.py
│ │ │ ├── modules
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_knowledge_proxy.py
│ │ │ │ ├── containerize.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── deployment_status.py
│ │ │ │ ├── infrastructure.py
│ │ │ │ ├── resource_management.py
│ │ │ │ └── troubleshooting.py
│ │ │ ├── templates
│ │ │ │ ├── ecr_infrastructure.json
│ │ │ │ └── ecs_infrastructure.json
│ │ │ └── utils
│ │ │ ├── arn_parser.py
│ │ │ ├── aws.py
│ │ │ ├── config.py
│ │ │ ├── docker.py
│ │ │ ├── security.py
│ │ │ ├── templates.py
│ │ │ └── time_utils.py
│ │ ├── DEVELOPMENT.md
│ │ ├── pyproject.toml
│ │ ├── pyrightconfig.json
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── integ
│ │ │ │ └── mcp-inspector
│ │ │ │ ├── .gitignore
│ │ │ │ ├── README.md
│ │ │ │ ├── run-tests.sh
│ │ │ │ └── scenarios
│ │ │ │ ├── 01_comprehensive_troubleshooting
│ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ ├── 03_cleanup.sh
│ │ │ │ │ ├── description.txt
│ │ │ │ │ └── utils
│ │ │ │ │ ├── mcp_helpers.sh
│ │ │ │ │ └── validation_helpers.sh
│ │ │ │ └── 02_test_knowledge_proxy_tools
│ │ │ │ ├── 01_create.sh
│ │ │ │ ├── 02_validate.sh
│ │ │ │ ├── 03_cleanup.sh
│ │ │ │ ├── description.txt
│ │ │ │ └── utils
│ │ │ │ ├── knowledge_validation_helpers.sh
│ │ │ │ └── mcp_knowledge_helpers.sh
│ │ │ ├── llm_testing
│ │ │ │ ├── invalid_cfn_template.yaml
│ │ │ │ ├── README.md
│ │ │ │ ├── run_tests.sh
│ │ │ │ ├── scenarios
│ │ │ │ │ ├── 01_cloudformation_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 04_evaluation.md
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 02_service_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 04_evaluation.md
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 03_task_exit_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 04_evaluation.md
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 04_network_configuration_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 05_resource_constraint_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ └── 06_load_balancer_failure
│ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ └── description.txt
│ │ │ │ ├── SCRIPT_IMPROVEMENTS.md
│ │ │ │ └── utils
│ │ │ │ ├── aws_helpers.sh
│ │ │ │ └── evaluation_template.md
│ │ │ └── unit
│ │ │ ├── __init__.py
│ │ │ ├── api
│ │ │ │ ├── conftest.py
│ │ │ │ ├── test_delete_api.py
│ │ │ │ ├── test_ecs_troubleshooting.py
│ │ │ │ ├── test_resource_management_api.py
│ │ │ │ └── troubleshooting_tools
│ │ │ │ └── test_fetch_network_configuration.py
│ │ │ ├── conftest.py
│ │ │ ├── modules
│ │ │ │ ├── test_aws_knowledge_proxy.py
│ │ │ │ └── test_resource_management_module.py
│ │ │ ├── test_aws_role_utils.py
│ │ │ ├── test_aws_utils.py
│ │ │ ├── test_containerize.py
│ │ │ ├── test_delete.py
│ │ │ ├── test_docker_utils.py
│ │ │ ├── test_docker_with_role.py
│ │ │ ├── test_image_pull_failure_extended.py
│ │ │ ├── test_image_pull_failure.py
│ │ │ ├── test_infrastructure_role.py
│ │ │ ├── test_infrastructure.py
│ │ │ ├── test_integration.py
│ │ │ ├── test_main.py
│ │ │ ├── test_resource_management_api_operation.py
│ │ │ ├── test_resource_management_tool.py
│ │ │ ├── test_resource_management.py
│ │ │ ├── test_security_integration.py
│ │ │ ├── test_status_pytest.py
│ │ │ ├── test_status.py
│ │ │ ├── troubleshooting_tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── conftest.py
│ │ │ │ ├── test_detect_image_pull_failures.py
│ │ │ │ ├── test_fetch_cloudformation_status.py
│ │ │ │ ├── test_fetch_service_events.py
│ │ │ │ ├── test_fetch_task_failures.py
│ │ │ │ ├── test_fetch_task_logs.py
│ │ │ │ ├── test_get_ecs_troubleshooting_guidance.py
│ │ │ │ ├── test_is_ecr_image_security.py
│ │ │ │ └── test_utils.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── async_test_utils.py
│ │ │ ├── test_arn_parser.py
│ │ │ ├── test_config.py
│ │ │ ├── test_docker.py
│ │ │ ├── test_response_sanitization.py
│ │ │ ├── test_security_extended.py
│ │ │ ├── test_security.py
│ │ │ ├── test_templates.py
│ │ │ └── test_time_utils.py
│ │ └── uv.lock
│ ├── eks-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── eks_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_helper.py
│ │ │ ├── cloudwatch_handler.py
│ │ │ ├── cloudwatch_metrics_guidance_handler.py
│ │ │ ├── consts.py
│ │ │ ├── data
│ │ │ │ └── eks_cloudwatch_metrics_guidance.json
│ │ │ ├── eks_kb_handler.py
│ │ │ ├── eks_stack_handler.py
│ │ │ ├── iam_handler.py
│ │ │ ├── insights_handler.py
│ │ │ ├── k8s_apis.py
│ │ │ ├── k8s_client_cache.py
│ │ │ ├── k8s_handler.py
│ │ │ ├── logging_helper.py
│ │ │ ├── models.py
│ │ │ ├── scripts
│ │ │ │ └── update_eks_cloudwatch_metrics_guidance.py
│ │ │ ├── server.py
│ │ │ ├── templates
│ │ │ │ ├── eks-templates
│ │ │ │ │ └── eks-with-vpc.yaml
│ │ │ │ └── k8s-templates
│ │ │ │ ├── deployment.yaml
│ │ │ │ └── service.yaml
│ │ │ └── vpc_config_handler.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_aws_helper.py
│ │ │ ├── test_cloudwatch_handler.py
│ │ │ ├── test_cloudwatch_metrics_guidance_handler.py
│ │ │ ├── test_eks_kb_handler.py
│ │ │ ├── test_eks_stack_handler.py
│ │ │ ├── test_iam_handler.py
│ │ │ ├── test_init.py
│ │ │ ├── test_insights_handler.py
│ │ │ ├── test_k8s_apis.py
│ │ │ ├── test_k8s_client_cache.py
│ │ │ ├── test_k8s_handler.py
│ │ │ ├── test_logging_helper.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ └── test_vpc_config_handler.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── elasticache-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── elasticache_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common
│ │ │ │ ├── __init__.py
│ │ │ │ ├── connection.py
│ │ │ │ ├── decorators.py
│ │ │ │ └── server.py
│ │ │ ├── context.py
│ │ │ ├── main.py
│ │ │ └── tools
│ │ │ ├── __init__.py
│ │ │ ├── cc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── connect.py
│ │ │ │ ├── create.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── describe.py
│ │ │ │ ├── modify.py
│ │ │ │ ├── parsers.py
│ │ │ │ └── processors.py
│ │ │ ├── ce
│ │ │ │ ├── __init__.py
│ │ │ │ └── get_cost_and_usage.py
│ │ │ ├── cw
│ │ │ │ ├── __init__.py
│ │ │ │ └── get_metric_statistics.py
│ │ │ ├── cwlogs
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_log_group.py
│ │ │ │ ├── describe_log_groups.py
│ │ │ │ ├── describe_log_streams.py
│ │ │ │ ├── filter_log_events.py
│ │ │ │ └── get_log_events.py
│ │ │ ├── firehose
│ │ │ │ ├── __init__.py
│ │ │ │ └── list_delivery_streams.py
│ │ │ ├── misc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── batch_apply_update_action.py
│ │ │ │ ├── batch_stop_update_action.py
│ │ │ │ ├── describe_cache_engine_versions.py
│ │ │ │ ├── describe_engine_default_parameters.py
│ │ │ │ ├── describe_events.py
│ │ │ │ └── describe_service_updates.py
│ │ │ ├── rg
│ │ │ │ ├── __init__.py
│ │ │ │ ├── complete_migration.py
│ │ │ │ ├── connect.py
│ │ │ │ ├── create.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── describe.py
│ │ │ │ ├── modify.py
│ │ │ │ ├── parsers.py
│ │ │ │ ├── processors.py
│ │ │ │ ├── start_migration.py
│ │ │ │ └── test_migration.py
│ │ │ └── serverless
│ │ │ ├── __init__.py
│ │ │ ├── connect.py
│ │ │ ├── create.py
│ │ │ ├── delete.py
│ │ │ ├── describe.py
│ │ │ ├── models.py
│ │ │ └── modify.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_connection.py
│ │ │ ├── test_decorators.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── tools
│ │ │ ├── cc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_connect_additional.py
│ │ │ │ ├── test_connect_coverage_additional.py
│ │ │ │ ├── test_connect_coverage.py
│ │ │ │ ├── test_connect.py
│ │ │ │ ├── test_create_additional.py
│ │ │ │ ├── test_create.py
│ │ │ │ ├── test_delete.py
│ │ │ │ ├── test_describe.py
│ │ │ │ ├── test_modify.py
│ │ │ │ ├── test_parsers.py
│ │ │ │ └── test_processors.py
│ │ │ ├── ce
│ │ │ │ ├── __init__.py
│ │ │ │ └── test_get_cost_and_usage.py
│ │ │ ├── cw
│ │ │ │ └── test_get_metric_statistics.py
│ │ │ ├── cwlogs
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_create_log_group.py
│ │ │ │ ├── test_describe_log_groups.py
│ │ │ │ ├── test_describe_log_streams.py
│ │ │ │ ├── test_filter_log_events.py
│ │ │ │ └── test_get_log_events.py
│ │ │ ├── firehose
│ │ │ │ └── test_list_delivery_streams.py
│ │ │ ├── misc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_batch_apply_update_action.py
│ │ │ │ ├── test_batch_stop_update_action.py
│ │ │ │ ├── test_describe_cache_engine_versions.py
│ │ │ │ ├── test_describe_engine_default_parameters.py
│ │ │ │ ├── test_describe_events.py
│ │ │ │ └── test_describe_service_updates.py
│ │ │ ├── rg
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_complete_migration.py
│ │ │ │ ├── test_connect_additional.py
│ │ │ │ ├── test_connect_coverage_additional.py
│ │ │ │ ├── test_connect_optional_fields.py
│ │ │ │ ├── test_connect_partial_coverage.py
│ │ │ │ ├── test_connect.py
│ │ │ │ ├── test_create.py
│ │ │ │ ├── test_delete.py
│ │ │ │ ├── test_describe.py
│ │ │ │ ├── test_modify.py
│ │ │ │ ├── test_parsers.py
│ │ │ │ ├── test_processors.py
│ │ │ │ ├── test_start_migration.py
│ │ │ │ └── test_test_migration.py
│ │ │ └── serverless
│ │ │ ├── test_connect_additional.py
│ │ │ ├── test_connect_coverage_additional.py
│ │ │ ├── test_connect_optional_fields.py
│ │ │ ├── test_connect.py
│ │ │ ├── test_create.py
│ │ │ ├── test_delete.py
│ │ │ ├── test_describe.py
│ │ │ └── test_modify.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── finch-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── finch_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── build.py
│ │ │ ├── common.py
│ │ │ ├── ecr.py
│ │ │ ├── push.py
│ │ │ └── vm.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_cli_flags.py
│ │ │ ├── test_logging_configuration.py
│ │ │ ├── test_server.py
│ │ │ ├── test_utils_build.py
│ │ │ ├── test_utils_common.py
│ │ │ ├── test_utils_ecr.py
│ │ │ ├── test_utils_push.py
│ │ │ └── test_utils_vm.py
│ │ └── uv.lock
│ ├── frontend-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── frontend_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ ├── static
│ │ │ │ └── react
│ │ │ │ ├── essential-knowledge.md
│ │ │ │ └── troubleshooting.md
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ └── file_utils.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_file_utils.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ └── uv.lock
│ ├── git-repo-research-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── git_repo_research_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── defaults.py
│ │ │ ├── embeddings.py
│ │ │ ├── github_search.py
│ │ │ ├── indexer.py
│ │ │ ├── models.py
│ │ │ ├── repository.py
│ │ │ ├── search.py
│ │ │ ├── server.py
│ │ │ └── utils.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_errors_repository.py
│ │ │ ├── test_github_search_edge_cases.py
│ │ │ ├── test_graphql_github_search.py
│ │ │ ├── test_local_repository.py
│ │ │ ├── test_repository_utils.py
│ │ │ ├── test_rest_github_search.py
│ │ │ ├── test_search.py
│ │ │ ├── test_server.py
│ │ │ └── test_url_repository.py
│ │ └── uv.lock
│ ├── healthlake-mcp-server
│ │ ├── .dockerignore
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── healthlake_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── fhir_operations.py
│ │ │ ├── main.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── CONTRIBUTING.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ ├── mcp_config.json
│ │ │ └── README.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_fhir_client_comprehensive.py
│ │ │ ├── test_fhir_error_scenarios.py
│ │ │ ├── test_fhir_operations.py
│ │ │ ├── test_integration_mock_based.py
│ │ │ ├── test_main_edge_cases.py
│ │ │ ├── test_main.py
│ │ │ ├── test_mcp_integration_coverage.py
│ │ │ ├── test_models_edge_cases.py
│ │ │ ├── test_models.py
│ │ │ ├── test_readonly_mode.py
│ │ │ ├── test_server_core.py
│ │ │ ├── test_server_error_handling.py
│ │ │ ├── test_server_mcp_handlers.py
│ │ │ ├── test_server_toolhandler.py
│ │ │ └── test_server_validation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── iam-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── iam_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_client.py
│ │ │ ├── context.py
│ │ │ ├── errors.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── DESIGN_COMPLIANCE.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ ├── get_policy_document_example.py
│ │ │ └── inline_policy_demo.py
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── test_context.py
│ │ │ ├── test_errors.py
│ │ │ ├── test_inline_policies.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── lambda-tool-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── lambda_tool_mcp_server
│ │ │ ├── __init__.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ ├── README.md
│ │ │ └── sample_functions
│ │ │ ├── customer-create
│ │ │ │ └── app.py
│ │ │ ├── customer-id-from-email
│ │ │ │ └── app.py
│ │ │ ├── customer-info-from-id
│ │ │ │ └── app.py
│ │ │ └── template.yml
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_format_lambda_response.py
│ │ │ ├── test_integration_coverage.py
│ │ │ ├── test_integration.py
│ │ │ ├── test_register_lambda_functions.py
│ │ │ ├── test_schema_integration.py
│ │ │ ├── test_server_coverage_additional.py
│ │ │ ├── test_server_coverage.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── mcp-lambda-handler
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ └── mcp_lambda_handler
│ │ │ ├── __init__.py
│ │ │ ├── mcp_lambda_handler.py
│ │ │ ├── session.py
│ │ │ └── types.py
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ └── test_lambda_handler.py
│ │ └── uv.lock
│ ├── memcached-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── memcached_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common
│ │ │ │ ├── config.py
│ │ │ │ ├── connection.py
│ │ │ │ └── server.py
│ │ │ ├── context.py
│ │ │ ├── main.py
│ │ │ └── tools
│ │ │ └── cache.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── ELASTICACHECONNECT.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_cache_readonly.py
│ │ │ ├── test_cache.py
│ │ │ ├── test_connection.py
│ │ │ ├── test_init.py
│ │ │ └── test_main.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── mysql-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── mysql_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── mutable_sql_detector.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── nova-canvas-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── nova_canvas_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── novacanvas.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_models.py
│ │ │ ├── test_novacanvas.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── openapi-mcp-server
│ │ ├── .coveragerc
│ │ ├── .dockerignore
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── AUTHENTICATION.md
│ │ ├── AWS_BEST_PRACTICES.md
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── openapi_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── api
│ │ │ │ ├── __init__.py
│ │ │ │ └── config.py
│ │ │ ├── auth
│ │ │ │ ├── __init__.py
│ │ │ │ ├── api_key_auth.py
│ │ │ │ ├── auth_cache.py
│ │ │ │ ├── auth_errors.py
│ │ │ │ ├── auth_factory.py
│ │ │ │ ├── auth_protocol.py
│ │ │ │ ├── auth_provider.py
│ │ │ │ ├── base_auth.py
│ │ │ │ ├── basic_auth.py
│ │ │ │ ├── bearer_auth.py
│ │ │ │ ├── cognito_auth.py
│ │ │ │ └── register.py
│ │ │ ├── patch
│ │ │ │ └── __init__.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── generators
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── operation_prompts.py
│ │ │ │ │ └── workflow_prompts.py
│ │ │ │ ├── models.py
│ │ │ │ └── prompt_manager.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── cache_provider.py
│ │ │ ├── config.py
│ │ │ ├── error_handler.py
│ │ │ ├── http_client.py
│ │ │ ├── metrics_provider.py
│ │ │ ├── openapi_validator.py
│ │ │ └── openapi.py
│ │ ├── CHANGELOG.md
│ │ ├── DEPLOYMENT.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── OBSERVABILITY.md
│ │ ├── pyproject.toml
│ │ ├── pyrightconfig.json
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── api
│ │ │ │ └── test_config.py
│ │ │ ├── auth
│ │ │ │ ├── test_api_key_auth.py
│ │ │ │ ├── test_auth_cache.py
│ │ │ │ ├── test_auth_errors.py
│ │ │ │ ├── test_auth_factory_caching.py
│ │ │ │ ├── test_auth_factory_coverage.py
│ │ │ │ ├── test_auth_factory.py
│ │ │ │ ├── test_auth_protocol_additional.py
│ │ │ │ ├── test_auth_protocol_boost.py
│ │ │ │ ├── test_auth_protocol_coverage.py
│ │ │ │ ├── test_auth_protocol_extended.py
│ │ │ │ ├── test_auth_protocol_improved.py
│ │ │ │ ├── test_auth_protocol.py
│ │ │ │ ├── test_auth_provider_additional.py
│ │ │ │ ├── test_base_auth_coverage.py
│ │ │ │ ├── test_base_auth.py
│ │ │ │ ├── test_basic_auth.py
│ │ │ │ ├── test_bearer_auth.py
│ │ │ │ ├── test_cognito_auth_additional_coverage.py
│ │ │ │ ├── test_cognito_auth_boost_coverage.py
│ │ │ │ ├── test_cognito_auth_client_credentials.py
│ │ │ │ ├── test_cognito_auth_coverage_boost.py
│ │ │ │ ├── test_cognito_auth_exceptions.py
│ │ │ │ ├── test_cognito_auth.py
│ │ │ │ ├── test_register_coverage.py
│ │ │ │ └── test_register.py
│ │ │ ├── prompts
│ │ │ │ ├── standalone
│ │ │ │ │ ├── test_operation_prompt.py
│ │ │ │ │ ├── test_prompt_arguments.py
│ │ │ │ │ └── test_secure_operation_prompt.py
│ │ │ │ ├── test_mcp_prompt_manager_integration.py
│ │ │ │ ├── test_mcp_prompt_manager.py
│ │ │ │ ├── test_models_dict_method.py
│ │ │ │ ├── test_operation_prompts_extended.py
│ │ │ │ ├── test_prompt_manager_additional.py
│ │ │ │ ├── test_prompt_manager_comprehensive.py
│ │ │ │ ├── test_prompt_manager_coverage.py
│ │ │ │ └── test_prompt_registration.py
│ │ │ ├── README.md
│ │ │ ├── test_api_name.py
│ │ │ ├── test_cache_coverage_89.py
│ │ │ ├── test_client.py
│ │ │ ├── test_coverage_boost.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main_extended.py
│ │ │ ├── test_main.py
│ │ │ ├── test_openapi_coverage_89.py
│ │ │ ├── test_server_auth_errors.py
│ │ │ ├── test_server_coverage_boost_2.py
│ │ │ ├── test_server_coverage_boost.py
│ │ │ ├── test_server_exception_handling.py
│ │ │ ├── test_server_extended.py
│ │ │ ├── test_server_httpx_version.py
│ │ │ ├── test_server_part1.py
│ │ │ ├── test_server_route_logging.py
│ │ │ ├── test_server_signal_handlers.py
│ │ │ ├── test_server.py
│ │ │ └── utils
│ │ │ ├── test_cache_provider.py
│ │ │ ├── test_error_handler_boost.py
│ │ │ ├── test_error_handler_extended.py
│ │ │ ├── test_error_handler_fix.py
│ │ │ ├── test_error_handler.py
│ │ │ ├── test_http_client_comprehensive.py
│ │ │ ├── test_http_client_extended.py
│ │ │ ├── test_http_client_extended2.py
│ │ │ ├── test_http_client_import_error.py
│ │ │ ├── test_http_client.py
│ │ │ ├── test_metrics_provider_decorators.py
│ │ │ ├── test_metrics_provider_extended2.py
│ │ │ ├── test_metrics_provider_prometheus.py
│ │ │ ├── test_metrics_provider.py
│ │ │ ├── test_openapi_validator.py
│ │ │ └── test_openapi.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── postgres-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── postgres_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── connection
│ │ │ │ ├── __init__.py
│ │ │ │ ├── abstract_db_connection.py
│ │ │ │ ├── db_connection_singleton.py
│ │ │ │ ├── psycopg_pool_connection.py
│ │ │ │ └── rds_api_connection.py
│ │ │ ├── mutable_sql_detector.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_psycopg_connector.py
│ │ │ ├── test_server.py
│ │ │ └── test_singleton.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── prometheus-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── prometheus_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_aws_credentials.py
│ │ │ ├── test_config_manager.py
│ │ │ ├── test_consts.py
│ │ │ ├── test_coverage_gaps.py
│ │ │ ├── test_coverage_improvement.py
│ │ │ ├── test_final_coverage.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_prometheus_client.py
│ │ │ ├── test_prometheus_connection.py
│ │ │ ├── test_security_validator.py
│ │ │ ├── test_server_coverage.py
│ │ │ ├── test_tools.py
│ │ │ └── test_workspace_config.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── redshift-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── redshift_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── redshift.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_redshift.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── s3-tables-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── s3_tables_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── constants.py
│ │ │ ├── database.py
│ │ │ ├── engines
│ │ │ │ ├── __init__.py
│ │ │ │ └── pyiceberg.py
│ │ │ ├── file_processor
│ │ │ │ ├── __init__.py
│ │ │ │ ├── csv.py
│ │ │ │ ├── parquet.py
│ │ │ │ └── utils.py
│ │ │ ├── models.py
│ │ │ ├── namespaces.py
│ │ │ ├── resources.py
│ │ │ ├── s3_operations.py
│ │ │ ├── server.py
│ │ │ ├── table_buckets.py
│ │ │ ├── tables.py
│ │ │ └── utils.py
│ │ ├── CHANGELOG.md
│ │ ├── CONTEXT.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_csv.py
│ │ │ ├── test_database.py
│ │ │ ├── test_file_processor_utils.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_namespaces.py
│ │ │ ├── test_parquet.py
│ │ │ ├── test_pyiceberg.py
│ │ │ ├── test_resources.py
│ │ │ ├── test_s3_operations.py
│ │ │ ├── test_server.py
│ │ │ ├── test_table_buckets.py
│ │ │ ├── test_tables.py
│ │ │ └── test_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── stepfunctions-tool-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── stepfunctions_tool_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_helper.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── README.md
│ │ │ ├── test_aws_helper.py
│ │ │ ├── test_create_state_machine_tool.py
│ │ │ ├── test_filter_state_machines_by_tag.py
│ │ │ ├── test_format_state_machine_response.py
│ │ │ ├── test_get_schema_arn_from_state_machine_arn.py
│ │ │ ├── test_get_schema_from_registry.py
│ │ │ ├── test_invoke_express_state_machine_impl.py
│ │ │ ├── test_invoke_standard_state_machine_impl.py
│ │ │ ├── test_main.py
│ │ │ ├── test_register_state_machines.py
│ │ │ ├── test_sanitize_tool_name.py
│ │ │ ├── test_server.py
│ │ │ └── test_validate_state_machine_name.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── syntheticdata-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── syntheticdata_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── pandas_interpreter.py
│ │ │ ├── server.py
│ │ │ └── storage
│ │ │ ├── __init__.py
│ │ │ ├── base.py
│ │ │ ├── loader.py
│ │ │ └── s3.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_constants.py
│ │ │ ├── test_pandas_interpreter.py
│ │ │ ├── test_server.py
│ │ │ └── test_storage
│ │ │ ├── __init__.py
│ │ │ ├── test_loader.py
│ │ │ └── test_s3.py
│ │ └── uv.lock
│ ├── terraform-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── terraform_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── impl
│ │ │ │ ├── resources
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── terraform_aws_provider_resources_listing.py
│ │ │ │ │ └── terraform_awscc_provider_resources_listing.py
│ │ │ │ └── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── execute_terraform_command.py
│ │ │ │ ├── execute_terragrunt_command.py
│ │ │ │ ├── run_checkov_scan.py
│ │ │ │ ├── search_aws_provider_docs.py
│ │ │ │ ├── search_awscc_provider_docs.py
│ │ │ │ ├── search_specific_aws_ia_modules.py
│ │ │ │ ├── search_user_provided_module.py
│ │ │ │ └── utils.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ └── models.py
│ │ │ ├── scripts
│ │ │ │ ├── generate_aws_provider_resources.py
│ │ │ │ ├── generate_awscc_provider_resources.py
│ │ │ │ └── scrape_aws_terraform_best_practices.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ ├── __init__.py
│ │ │ ├── AWS_PROVIDER_RESOURCES.md
│ │ │ ├── AWS_TERRAFORM_BEST_PRACTICES.md
│ │ │ ├── AWSCC_PROVIDER_RESOURCES.md
│ │ │ ├── MCP_INSTRUCTIONS.md
│ │ │ └── TERRAFORM_WORKFLOW_GUIDE.md
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_command_impl.py
│ │ │ ├── test_execute_terraform_command.py
│ │ │ ├── test_execute_terragrunt_command.py
│ │ │ ├── test_models.py
│ │ │ ├── test_parameter_annotations.py
│ │ │ ├── test_resources.py
│ │ │ ├── test_run_checkov_scan.py
│ │ │ ├── test_search_user_provided_module.py
│ │ │ ├── test_server.py
│ │ │ ├── test_tool_implementations.py
│ │ │ ├── test_utils_additional.py
│ │ │ └── test_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── timestream-for-influxdb-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── timestream_for_influxdb_mcp_server
│ │ │ ├── __init__.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── valkey-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── valkey_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common
│ │ │ │ ├── __init__.py
│ │ │ │ ├── config.py
│ │ │ │ ├── connection.py
│ │ │ │ └── server.py
│ │ │ ├── context.py
│ │ │ ├── main.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── bitmap.py
│ │ │ │ ├── hash.py
│ │ │ │ ├── hyperloglog.py
│ │ │ │ ├── json.py
│ │ │ │ ├── list.py
│ │ │ │ ├── misc.py
│ │ │ │ ├── server_management.py
│ │ │ │ ├── set.py
│ │ │ │ ├── sorted_set.py
│ │ │ │ ├── stream.py
│ │ │ │ └── string.py
│ │ │ └── version.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── ELASTICACHECONNECT.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_bitmap.py
│ │ │ ├── test_config.py
│ │ │ ├── test_connection.py
│ │ │ ├── test_hash.py
│ │ │ ├── test_hyperloglog.py
│ │ │ ├── test_init.py
│ │ │ ├── test_json_additional.py
│ │ │ ├── test_json_readonly.py
│ │ │ ├── test_json.py
│ │ │ ├── test_list_additional.py
│ │ │ ├── test_list_readonly.py
│ │ │ ├── test_list.py
│ │ │ ├── test_main.py
│ │ │ ├── test_misc.py
│ │ │ ├── test_server_management.py
│ │ │ ├── test_set_readonly.py
│ │ │ ├── test_set.py
│ │ │ ├── test_sorted_set_additional.py
│ │ │ ├── test_sorted_set_readonly.py
│ │ │ ├── test_sorted_set.py
│ │ │ ├── test_stream_additional.py
│ │ │ ├── test_stream_readonly.py
│ │ │ ├── test_stream.py
│ │ │ └── test_string.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ └── well-architected-security-mcp-server
│ ├── .python-version
│ ├── awslabs
│ │ └── well_architected_security_mcp_server
│ │ ├── __init__.py
│ │ ├── consts.py
│ │ ├── server.py
│ │ └── util
│ │ ├── __init__.py
│ │ ├── network_security.py
│ │ ├── prompt_utils.py
│ │ ├── resource_utils.py
│ │ ├── security_services.py
│ │ └── storage_security.py
│ ├── PROMPT_TEMPLATE.md
│ ├── pyproject.toml
│ ├── README.md
│ ├── tests
│ │ ├── __init__.py
│ │ ├── conftest.py
│ │ ├── README.md
│ │ ├── test_access_analyzer_fix.py
│ │ ├── test_network_security_additional.py
│ │ ├── test_network_security.py
│ │ ├── test_prompt_utils_coverage.py
│ │ ├── test_prompt_utils.py
│ │ ├── test_resource_utils_fix.py
│ │ ├── test_resource_utils.py
│ │ ├── test_security_services_additional.py
│ │ ├── test_security_services_coverage.py
│ │ ├── test_security_services.py
│ │ ├── test_server_additional.py
│ │ ├── test_server_coverage.py
│ │ ├── test_server_prompts.py
│ │ ├── test_server_security_findings.py
│ │ ├── test_server.py
│ │ ├── test_storage_security_additional.py
│ │ ├── test_storage_security_comprehensive.py
│ │ ├── test_storage_security_edge_cases.py
│ │ ├── test_storage_security_recommendations.py
│ │ ├── test_storage_security.py
│ │ └── test_user_agent_config.py
│ └── uv.lock
└── VIBE_CODING_TIPS_TRICKS.md
```
# Files
--------------------------------------------------------------------------------
/src/aws-dataprocessing-mcp-server/tests/handlers/commons/test_common_resource_handler.py:
--------------------------------------------------------------------------------
```python
# 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.
import json
import pytest
from awslabs.aws_dataprocessing_mcp_server.handlers.commons.common_resource_handler import (
CommonResourceHandler,
)
from botocore.exceptions import ClientError
from datetime import datetime, timedelta
from mcp.server.fastmcp import Context
from typing import Type
from unittest.mock import Mock, patch
class Exceptions:
"""Mock exceptions class for IAM client testing."""
class NoSuchEntityException(ClientError):
"""Mock NoSuchEntityException for testing IAM client exceptions."""
def __init__(self):
"""Initialize the NoSuchEntityException with appropriate error response."""
operation_name = 'GetRolePolicy'
error_response = {
'Error': {'Code': 'NoSuchEntity', 'Message': 'Role policy not found'}
}
super().__init__(error_response, operation_name)
class MockIAMClient(Mock):
"""Mock IAM client for testing with exception handling capabilities."""
exceptions: Type[Exceptions]
def __init__(self, *args, **kwargs):
"""Initialize the MockIAMClient with exceptions property."""
super().__init__(*args, **kwargs)
# Set up exceptions as a property
self.exceptions = Exceptions
@pytest.fixture
def mock_iam_client():
"""Create a mock IAM client instance for testing."""
return Mock()
@pytest.fixture
def mock_s3_client():
"""Create a mock S3 client instance for testing."""
return Mock()
@pytest.fixture
def mock_aws_helper():
"""Create a mock AwsHelper instance for testing."""
with patch(
'awslabs.aws_dataprocessing_mcp_server.handlers.commons.common_resource_handler.AwsHelper'
) as mock:
mock.create_boto3_client.return_value = Mock()
yield mock
@pytest.fixture
def handler(mock_aws_helper):
"""Create a mock CommonResourceHandler instance for testing."""
mcp = Mock()
return CommonResourceHandler(mcp, allow_write=True)
@pytest.fixture
def read_only_handler(mock_aws_helper):
"""Create a mock CommonResourceHandler instance with read-only access for testing."""
mcp = Mock()
return CommonResourceHandler(mcp, allow_write=False)
@pytest.fixture
def mock_context():
"""Create a mock context instance for testing."""
return Mock(spec=Context)
# ============================================================================
# IAM Operations Tests
# ============================================================================
@pytest.mark.asyncio
async def test_get_policies_for_role_success(handler, mock_iam_client):
"""Test successful retrieval of policies for a role."""
handler.iam_client = mock_iam_client
# Mock role response
mock_iam_client.get_role.return_value = {
'Role': {
'Arn': 'arn:aws:iam::123456789012:role/test-role',
'AssumeRolePolicyDocument': {
'Version': '2012-10-17',
'Statement': [
{
'Effect': 'Allow',
'Principal': {'Service': 'glue.amazonaws.com'},
'Action': 'sts:AssumeRole',
}
],
},
'Description': 'Test role description',
}
}
# Mock managed policies
mock_iam_client.list_attached_role_policies.return_value = {
'AttachedPolicies': [
{
'PolicyName': 'TestManagedPolicy',
'PolicyArn': 'arn:aws:iam::aws:policy/TestManagedPolicy',
}
]
}
mock_iam_client.get_policy.return_value = {
'Policy': {'DefaultVersionId': 'v1', 'Description': 'Test managed policy'}
}
mock_iam_client.get_policy_version.return_value = {
'PolicyVersion': {
'Document': {
'Version': '2012-10-17',
'Statement': [{'Effect': 'Allow', 'Action': 's3:GetObject', 'Resource': '*'}],
}
}
}
# Mock inline policies
mock_iam_client.list_role_policies.return_value = {'PolicyNames': ['TestInlinePolicy']}
mock_iam_client.get_role_policy.return_value = {
'PolicyDocument': {
'Version': '2012-10-17',
'Statement': [{'Effect': 'Allow', 'Action': 's3:PutObject', 'Resource': '*'}],
}
}
ctx = Mock()
response = await handler.get_policies_for_role(ctx, role_name='test-role')
assert not response.isError
assert response.role_arn == 'arn:aws:iam::123456789012:role/test-role'
assert response.description == 'Test role description'
assert len(response.managed_policies) == 1
assert len(response.inline_policies) == 1
assert response.managed_policies[0].policy_type == 'Managed'
assert response.inline_policies[0].policy_type == 'Inline'
@pytest.mark.asyncio
async def test_get_policies_for_role_with_string_assume_role_policy(handler, mock_iam_client):
"""Test retrieval of policies for a role with string assume role policy document."""
handler.iam_client = mock_iam_client
# Mock role response with string assume role policy document
assume_role_policy_str = json.dumps(
{
'Version': '2012-10-17',
'Statement': [
{
'Effect': 'Allow',
'Principal': {'Service': 'glue.amazonaws.com'},
'Action': 'sts:AssumeRole',
}
],
}
)
mock_iam_client.get_role.return_value = {
'Role': {
'Arn': 'arn:aws:iam::123456789012:role/test-role',
'AssumeRolePolicyDocument': assume_role_policy_str,
'Description': 'Test role description',
}
}
# Mock empty policies
mock_iam_client.list_attached_role_policies.return_value = {'AttachedPolicies': []}
mock_iam_client.list_role_policies.return_value = {'PolicyNames': []}
ctx = Mock()
response = await handler.get_policies_for_role(ctx, role_name='test-role')
assert not response.isError
assert response.assume_role_policy_document['Version'] == '2012-10-17'
assert len(response.assume_role_policy_document['Statement']) == 1
@pytest.mark.asyncio
async def test_get_policies_for_role_error_handling(handler, mock_iam_client):
"""Test error handling when getting policies for a role fails."""
handler.iam_client = mock_iam_client
mock_iam_client.get_role.side_effect = ClientError(
{'Error': {'Code': 'NoSuchEntity', 'Message': 'Role not found'}}, 'GetRole'
)
ctx = Mock()
response = await handler.get_policies_for_role(ctx, role_name='nonexistent-role')
assert response.isError
assert 'Failed to describe IAM role' in response.content[0].text
assert response.role_arn == ''
@pytest.mark.asyncio
async def test_add_inline_policy_success(handler):
"""Test successful addition of an inline policy."""
mock_iam_local_client = MockIAMClient()
mock_iam_local_client.get_role_policy.side_effect = (
mock_iam_local_client.exceptions.NoSuchEntityException()
)
handler.iam_client = mock_iam_local_client
permissions = {
'Effect': 'Allow',
'Action': ['s3:GetObject', 's3:PutObject'],
'Resource': 'arn:aws:s3:::test-bucket/*',
}
ctx = Mock()
response = await handler.add_inline_policy(
ctx, policy_name='test-policy', role_name='test-role', permissions=permissions
)
assert not response.isError
assert response.policy_name == 'test-policy'
assert response.role_name == 'test-role'
assert response.permissions_added == permissions
mock_iam_local_client.put_role_policy.assert_called_once()
@pytest.mark.asyncio
async def test_add_inline_policy_with_list_permissions(handler):
"""Test successful addition of an inline policy with list of permissions."""
mock_iam_local_client = MockIAMClient()
mock_iam_local_client.get_role_policy.side_effect = (
mock_iam_local_client.exceptions.NoSuchEntityException()
)
mock_iam_local_client.put_role_policy.return_value = {
'ResponseMetadata': {
'test': 'dummy',
},
}
handler.iam_client = mock_iam_local_client
permissions = [
{'Effect': 'Allow', 'Action': ['s3:GetObject'], 'Resource': 'arn:aws:s3:::test-bucket/*'},
{'Effect': 'Allow', 'Action': ['s3:PutObject'], 'Resource': 'arn:aws:s3:::test-bucket/*'},
]
ctx = Mock()
response = await handler.add_inline_policy(
ctx, policy_name='test-policy', role_name='test-role', permissions=permissions
)
assert not response.isError
assert response.policy_name == 'test-policy'
assert response.role_name == 'test-role'
assert response.permissions_added == permissions
@pytest.mark.asyncio
async def test_add_inline_policy_without_write_permission(read_only_handler):
"""Test that adding inline policy fails when write access is disabled."""
ctx = Mock()
response = await read_only_handler.add_inline_policy(
ctx,
policy_name='test-policy',
role_name='test-role',
permissions={'Effect': 'Allow', 'Action': 's3:GetObject', 'Resource': '*'},
)
assert response.isError
assert 'requires --allow-write flag' in response.content[0].text
@pytest.mark.asyncio
async def test_add_inline_policy_already_exists(handler, mock_iam_client):
"""Test that adding inline policy fails when policy already exists."""
handler.iam_client = mock_iam_client
# Mock that policy already exists
mock_iam_client.get_role_policy.return_value = {
'PolicyDocument': {'Version': '2012-10-17', 'Statement': []}
}
ctx = Mock()
response = await handler.add_inline_policy(
ctx,
policy_name='existing-policy',
role_name='test-role',
permissions={'Effect': 'Allow', 'Action': 's3:GetObject', 'Resource': '*'},
)
assert response.isError
assert 'already exists' in response.content[0].text
@pytest.mark.asyncio
async def test_create_data_processing_role_glue_success(handler, mock_iam_client):
"""Test successful creation of a Glue data processing role."""
handler.iam_client = mock_iam_client
mock_iam_client.create_role.return_value = {
'Role': {'Arn': 'arn:aws:iam::123456789012:role/test-glue-role'}
}
ctx = Mock()
response = await handler.create_data_processing_role(
ctx,
role_name='test-glue-role',
service_type='glue',
description='Test Glue role',
managed_policy_arns=['arn:aws:iam::aws:policy/service-role/AWSGlueServiceRole'],
)
assert not response.isError
assert response.role_name == 'test-glue-role'
assert response.role_arn == 'arn:aws:iam::123456789012:role/test-glue-role'
# Verify create_role was called with correct trust relationship
create_role_call = mock_iam_client.create_role.call_args
assume_role_policy = json.loads(create_role_call[1]['AssumeRolePolicyDocument'])
assert assume_role_policy['Statement'][0]['Principal']['Service'] == 'glue.amazonaws.com'
# Verify managed policy was attached
mock_iam_client.attach_role_policy.assert_called_once_with(
RoleName='test-glue-role',
PolicyArn='arn:aws:iam::aws:policy/service-role/AWSGlueServiceRole',
)
@pytest.mark.asyncio
async def test_create_data_processing_role_emr_success(handler, mock_iam_client):
"""Test successful creation of an EMR data processing role."""
handler.iam_client = mock_iam_client
mock_iam_client.create_role.return_value = {
'Role': {'Arn': 'arn:aws:iam::123456789012:role/test-emr-role'}
}
ctx = Mock()
response = await handler.create_data_processing_role(
ctx, role_name='test-emr-role', service_type='emr'
)
assert not response.isError
assert response.role_name == 'test-emr-role'
# Verify create_role was called with correct trust relationship
create_role_call = mock_iam_client.create_role.call_args
assume_role_policy = json.loads(create_role_call[1]['AssumeRolePolicyDocument'])
assert (
assume_role_policy['Statement'][0]['Principal']['Service']
== 'elasticmapreduce.amazonaws.com'
)
@pytest.mark.asyncio
async def test_create_data_processing_role_athena_success(handler, mock_iam_client):
"""Test successful creation of an Athena data processing role."""
handler.iam_client = mock_iam_client
mock_iam_client.create_role.return_value = {
'Role': {'Arn': 'arn:aws:iam::123456789012:role/test-athena-role'}
}
ctx = Mock()
response = await handler.create_data_processing_role(
ctx, role_name='test-athena-role', service_type='athena'
)
assert not response.isError
assert response.role_name == 'test-athena-role'
# Verify create_role was called with correct trust relationship
create_role_call = mock_iam_client.create_role.call_args
assume_role_policy = json.loads(create_role_call[1]['AssumeRolePolicyDocument'])
assert assume_role_policy['Statement'][0]['Principal']['Service'] == 'athena.amazonaws.com'
@pytest.mark.asyncio
async def test_create_data_processing_role_with_inline_policy(handler, mock_iam_client):
"""Test successful creation of a role with inline policy."""
handler.iam_client = mock_iam_client
mock_iam_client.create_role.return_value = {
'Role': {'Arn': 'arn:aws:iam::123456789012:role/test-role'}
}
inline_policy = {
'Effect': 'Allow',
'Action': ['s3:GetObject'],
'Resource': 'arn:aws:s3:::test-bucket/*',
}
ctx = Mock()
response = await handler.create_data_processing_role(
ctx, role_name='test-role', service_type='glue', inline_policy=inline_policy
)
assert not response.isError
# Verify inline policy was added
mock_iam_client.put_role_policy.assert_called_once()
put_policy_call = mock_iam_client.put_role_policy.call_args
policy_document = json.loads(put_policy_call[1]['PolicyDocument'])
assert policy_document['Statement'][0]['Action'] == ['s3:GetObject']
@pytest.mark.asyncio
async def test_create_data_processing_role_invalid_service_type(handler):
"""Test that creating role fails with invalid service type."""
ctx = Mock()
response = await handler.create_data_processing_role(
ctx, role_name='test-role', service_type='invalid-service'
)
assert response.isError
assert 'Invalid service type' in response.content[0].text
@pytest.mark.asyncio
async def test_create_data_processing_role_without_write_permission(read_only_handler):
"""Test that creating role fails when write access is disabled."""
ctx = Mock()
response = await read_only_handler.create_data_processing_role(
ctx, role_name='test-role', service_type='glue'
)
assert response.isError
assert 'requires --allow-write flag' in response.content[0].text
@pytest.mark.asyncio
async def test_get_roles_for_service_success(handler, mock_iam_client):
"""Test successful retrieval of roles for a service."""
handler.iam_client = mock_iam_client
# Mock paginator
mock_paginator = Mock()
mock_iam_client.get_paginator.return_value = mock_paginator
# Mock role data
mock_paginator.paginate.return_value = [
{
'Roles': [
{
'RoleName': 'glue-role-1',
'Arn': 'arn:aws:iam::123456789012:role/glue-role-1',
'Description': 'Glue role 1',
'CreateDate': datetime(2023, 1, 1),
'AssumeRolePolicyDocument': {
'Version': '2012-10-17',
'Statement': [
{
'Effect': 'Allow',
'Principal': {'Service': 'glue.amazonaws.com'},
'Action': 'sts:AssumeRole',
}
],
},
},
{
'RoleName': 'emr-role-1',
'Arn': 'arn:aws:iam::123456789012:role/emr-role-1',
'CreateDate': datetime(2023, 1, 2),
'AssumeRolePolicyDocument': {
'Version': '2012-10-17',
'Statement': [
{
'Effect': 'Allow',
'Principal': {'Service': 'elasticmapreduce.amazonaws.com'},
'Action': 'sts:AssumeRole',
}
],
},
},
]
}
]
ctx = Mock()
response = await handler.get_roles_for_service(ctx, service_type='glue')
assert not response.isError
assert response.service_type == 'glue'
assert len(response.roles) == 1 # Only the Glue role should be returned
assert response.roles[0].role_name == 'glue-role-1'
@pytest.mark.asyncio
async def test_get_roles_for_service_with_string_assume_role_policy(handler, mock_iam_client):
"""Test retrieval of roles for a service with string assume role policy document."""
handler.iam_client = mock_iam_client
# Mock paginator
mock_paginator = Mock()
mock_iam_client.get_paginator.return_value = mock_paginator
# Mock role data with string assume role policy document
assume_role_policy_str = json.dumps(
{
'Version': '2012-10-17',
'Statement': [
{
'Effect': 'Allow',
'Principal': {'Service': 'glue.amazonaws.com'},
'Action': 'sts:AssumeRole',
}
],
}
)
mock_paginator.paginate.return_value = [
{
'Roles': [
{
'RoleName': 'glue-role-1',
'Arn': 'arn:aws:iam::123456789012:role/glue-role-1',
'CreateDate': datetime(2023, 1, 1),
'AssumeRolePolicyDocument': assume_role_policy_str,
}
]
}
]
ctx = Mock()
response = await handler.get_roles_for_service(ctx, service_type='glue')
assert not response.isError
assert len(response.roles) == 1
assert response.roles[0].role_name == 'glue-role-1'
@pytest.mark.asyncio
async def test_get_roles_for_service_error_handling(handler, mock_iam_client):
"""Test error handling when getting roles for a service fails."""
handler.iam_client = mock_iam_client
mock_iam_client.get_paginator.side_effect = ClientError(
{'Error': {'Code': 'AccessDenied', 'Message': 'Access denied'}}, 'ListRoles'
)
ctx = Mock()
response = await handler.get_roles_for_service(ctx, service_type='glue')
assert response.isError
assert 'Failed to list IAM roles' in response.content[0].text
# ============================================================================
# S3 Operations Tests
# ============================================================================
@pytest.mark.asyncio
async def test_list_s3_buckets_success(handler, mock_s3_client):
"""Test successful listing of S3 buckets."""
handler.s3_client = mock_s3_client
# Mock list_buckets response
mock_s3_client.list_buckets.return_value = {
'Buckets': [
{'Name': 'test-glue-bucket', 'CreationDate': datetime(2023, 1, 1)},
{'Name': 'other-bucket', 'CreationDate': datetime(2023, 1, 2)},
]
}
# Mock bucket location
mock_s3_client.get_bucket_location.return_value = {'LocationConstraint': 'us-east-1'}
# Mock list_objects_v2 response
mock_s3_client.list_objects_v2.return_value = {
'KeyCount': 5,
'Contents': [{'LastModified': datetime(2023, 6, 1)}],
}
ctx = Mock()
response = await handler.list_s3_buckets(ctx, region='us-east-1')
assert not response.isError
assert response.region == 'us-east-1'
assert response.bucket_count == 1 # Only the bucket with 'glue' in name
assert len(response.buckets) == 1
assert response.buckets[0].name == 'test-glue-bucket'
@pytest.mark.asyncio
async def test_list_s3_buckets_with_environment_region(handler, mock_s3_client):
"""Test listing S3 buckets using environment region."""
handler.s3_client = mock_s3_client
with patch('os.getenv', return_value='us-west-2'):
mock_s3_client.list_buckets.return_value = {'Buckets': []}
ctx = Mock()
response = await handler.list_s3_buckets(ctx)
assert not response.isError
assert response.region == 'us-west-2'
@pytest.mark.asyncio
async def test_list_s3_buckets_error_handling(handler, mock_s3_client):
"""Test error handling when listing S3 buckets fails."""
handler.s3_client = mock_s3_client
mock_s3_client.list_buckets.side_effect = ClientError(
{'Error': {'Code': 'AccessDenied', 'Message': 'Access denied'}}, 'ListBuckets'
)
ctx = Mock()
response = await handler.list_s3_buckets(ctx)
assert response.isError
assert 'AWS Error' in response.content[0].text
@pytest.mark.asyncio
async def test_analyze_s3_usage_glue_connections_error(handler, mock_s3_client):
"""Test error handling when Glue connections check fails in analyze_s3_usage_for_data_processing."""
handler.s3_client = mock_s3_client
# Mock list_buckets response
mock_s3_client.list_buckets.return_value = {'Buckets': [{'Name': 'test-bucket'}]}
# Mock list_objects_v2 response
mock_s3_client.list_objects_v2.return_value = {'KeyCount': 0}
# Mock AWS service clients
with patch(
'awslabs.aws_dataprocessing_mcp_server.handlers.commons.common_resource_handler.AwsHelper'
) as mock_aws_helper:
mock_glue_client = Mock()
mock_athena_client = Mock()
mock_emr_client = Mock()
mock_aws_helper.create_boto3_client.side_effect = lambda service: {
'glue': mock_glue_client,
'athena': mock_athena_client,
'emr': mock_emr_client,
}[service]
# Mock Glue connections to raise an exception
mock_glue_client.get_connections.side_effect = ClientError(
{'Error': {'Code': 'AccessDenied', 'Message': 'Access denied'}}, 'GetConnections'
)
# Mock other service responses
mock_athena_client.list_work_groups.return_value = {'WorkGroups': []}
mock_emr_client.list_clusters.return_value = {'Clusters': []}
ctx = Mock()
response = await handler.analyze_s3_usage_for_data_processing(ctx)
assert not response.isError
# Should still return results but with error details in the text
assert 'Error checking Glue usage' in response.analysis_summary
@pytest.mark.asyncio
async def test_analyze_s3_usage_athena_workgroups_error(handler, mock_s3_client):
"""Test error handling when Athena workgroups check fails in analyze_s3_usage_for_data_processing."""
handler.s3_client = mock_s3_client
# Mock list_buckets response
mock_s3_client.list_buckets.return_value = {'Buckets': [{'Name': 'test-bucket'}]}
# Mock list_objects_v2 response
mock_s3_client.list_objects_v2.return_value = {'KeyCount': 0}
# Mock AWS service clients
with patch(
'awslabs.aws_dataprocessing_mcp_server.handlers.commons.common_resource_handler.AwsHelper'
) as mock_aws_helper:
mock_glue_client = Mock()
mock_athena_client = Mock()
mock_emr_client = Mock()
mock_aws_helper.create_boto3_client.side_effect = lambda service: {
'glue': mock_glue_client,
'athena': mock_athena_client,
'emr': mock_emr_client,
}[service]
# Mock service responses
mock_glue_client.get_connections.return_value = {'ConnectionList': []}
mock_glue_client.get_crawlers.return_value = {'Crawlers': []}
mock_glue_client.get_jobs.return_value = {'Jobs': []}
# Mock Athena list_work_groups to raise an exception
mock_athena_client.list_work_groups.side_effect = ClientError(
{'Error': {'Code': 'AccessDenied', 'Message': 'Access denied'}}, 'ListWorkGroups'
)
mock_emr_client.list_clusters.return_value = {'Clusters': []}
ctx = Mock()
response = await handler.analyze_s3_usage_for_data_processing(ctx)
assert not response.isError
# Should still return results but with error details in the text
assert 'Error checking Athena usage' in response.analysis_summary
@pytest.mark.asyncio
async def test_analyze_s3_usage_athena_workgroup_details_error(handler, mock_s3_client):
"""Test error handling when getting Athena workgroup details fails in analyze_s3_usage_for_data_processing."""
handler.s3_client = mock_s3_client
# Mock list_buckets response
mock_s3_client.list_buckets.return_value = {'Buckets': [{'Name': 'test-bucket'}]}
# Mock list_objects_v2 response
mock_s3_client.list_objects_v2.return_value = {'KeyCount': 0}
# Mock AWS service clients
with patch(
'awslabs.aws_dataprocessing_mcp_server.handlers.commons.common_resource_handler.AwsHelper'
) as mock_aws_helper:
mock_glue_client = Mock()
mock_athena_client = Mock()
mock_emr_client = Mock()
mock_aws_helper.create_boto3_client.side_effect = lambda service: {
'glue': mock_glue_client,
'athena': mock_athena_client,
'emr': mock_emr_client,
}[service]
# Mock service responses
mock_glue_client.get_connections.return_value = {'ConnectionList': []}
mock_glue_client.get_crawlers.return_value = {'Crawlers': []}
mock_glue_client.get_jobs.return_value = {'Jobs': []}
# Mock Athena workgroups
mock_athena_client.list_work_groups.return_value = {
'WorkGroups': [{'Name': 'test-workgroup'}]
}
# Mock get_work_group to raise an exception
mock_athena_client.get_work_group.side_effect = ClientError(
{'Error': {'Code': 'AccessDenied', 'Message': 'Access denied'}}, 'GetWorkGroup'
)
mock_emr_client.list_clusters.return_value = {'Clusters': []}
ctx = Mock()
response = await handler.analyze_s3_usage_for_data_processing(ctx)
assert not response.isError
# Should still return results but with warning about workgroup check
assert 'Warning: Could not check workgroup test-workgroup' in response.analysis_summary
@pytest.mark.asyncio
async def test_analyze_s3_usage_emr_clusters_error(handler, mock_s3_client):
"""Test error handling when EMR clusters check fails in analyze_s3_usage_for_data_processing."""
handler.s3_client = mock_s3_client
# Mock list_buckets response
mock_s3_client.list_buckets.return_value = {'Buckets': [{'Name': 'test-bucket'}]}
# Mock list_objects_v2 response
mock_s3_client.list_objects_v2.return_value = {'KeyCount': 0}
# Mock AWS service clients
with patch(
'awslabs.aws_dataprocessing_mcp_server.handlers.commons.common_resource_handler.AwsHelper'
) as mock_aws_helper:
mock_glue_client = Mock()
mock_athena_client = Mock()
mock_emr_client = Mock()
mock_aws_helper.create_boto3_client.side_effect = lambda service: {
'glue': mock_glue_client,
'athena': mock_athena_client,
'emr': mock_emr_client,
}[service]
# Mock service responses
mock_glue_client.get_connections.return_value = {'ConnectionList': []}
mock_glue_client.get_crawlers.return_value = {'Crawlers': []}
mock_glue_client.get_jobs.return_value = {'Jobs': []}
mock_athena_client.list_work_groups.return_value = {'WorkGroups': []}
# Mock EMR list_clusters to raise an exception
mock_emr_client.list_clusters.side_effect = ClientError(
{'Error': {'Code': 'AccessDenied', 'Message': 'Access denied'}}, 'ListClusters'
)
ctx = Mock()
response = await handler.analyze_s3_usage_for_data_processing(ctx)
assert not response.isError
# Should still return results but with error details in the text
assert 'Error checking EMR usage' in response.analysis_summary
@pytest.mark.asyncio
async def test_analyze_s3_usage_emr_cluster_details_error(handler, mock_s3_client):
"""Test error handling when getting EMR cluster details fails in analyze_s3_usage_for_data_processing."""
handler.s3_client = mock_s3_client
# Mock list_buckets response
mock_s3_client.list_buckets.return_value = {'Buckets': [{'Name': 'test-bucket'}]}
# Mock list_objects_v2 response
mock_s3_client.list_objects_v2.return_value = {'KeyCount': 0}
# Mock AWS service clients
with patch(
'awslabs.aws_dataprocessing_mcp_server.handlers.commons.common_resource_handler.AwsHelper'
) as mock_aws_helper:
mock_glue_client = Mock()
mock_athena_client = Mock()
mock_emr_client = Mock()
mock_aws_helper.create_boto3_client.side_effect = lambda service: {
'glue': mock_glue_client,
'athena': mock_athena_client,
'emr': mock_emr_client,
}[service]
# Mock service responses
mock_glue_client.get_connections.return_value = {'ConnectionList': []}
mock_glue_client.get_crawlers.return_value = {'Crawlers': []}
mock_glue_client.get_jobs.return_value = {'Jobs': []}
mock_athena_client.list_work_groups.return_value = {'WorkGroups': []}
# Mock EMR clusters
mock_emr_client.list_clusters.return_value = {
'Clusters': [{'Id': 'j-1234567890123', 'Name': 'test-cluster'}]
}
# Mock describe_cluster to raise an exception
mock_emr_client.describe_cluster.side_effect = ClientError(
{'Error': {'Code': 'AccessDenied', 'Message': 'Access denied'}}, 'DescribeCluster'
)
ctx = Mock()
response = await handler.analyze_s3_usage_for_data_processing(ctx)
assert not response.isError
# Should still return results but with warning about cluster check
assert 'Warning: Could not check cluster j-1234567890123' in response.analysis_summary
@pytest.mark.asyncio
async def test_analyze_s3_usage_last_activity_error(handler, mock_s3_client):
"""Test error handling when checking last activity fails in analyze_s3_usage_for_data_processing."""
handler.s3_client = mock_s3_client
# Mock list_buckets response
mock_s3_client.list_buckets.return_value = {'Buckets': [{'Name': 'test-bucket'}]}
# Mock list_objects_v2 to raise an exception
mock_s3_client.list_objects_v2.side_effect = ClientError(
{'Error': {'Code': 'AccessDenied', 'Message': 'Access denied'}}, 'ListObjectsV2'
)
# Mock AWS service clients
with patch(
'awslabs.aws_dataprocessing_mcp_server.handlers.commons.common_resource_handler.AwsHelper'
) as mock_aws_helper:
mock_glue_client = Mock()
mock_athena_client = Mock()
mock_emr_client = Mock()
mock_aws_helper.create_boto3_client.side_effect = lambda service: {
'glue': mock_glue_client,
'athena': mock_athena_client,
'emr': mock_emr_client,
}[service]
# Mock service responses
mock_glue_client.get_connections.return_value = {'ConnectionList': []}
mock_glue_client.get_crawlers.return_value = {'Crawlers': []}
mock_glue_client.get_jobs.return_value = {'Jobs': []}
mock_athena_client.list_work_groups.return_value = {'WorkGroups': []}
mock_emr_client.list_clusters.return_value = {'Clusters': []}
ctx = Mock()
response = await handler.analyze_s3_usage_for_data_processing(ctx)
assert not response.isError
# Should still return results but with error details in the text
assert 'Error checking last activity' in response.analysis_summary
@pytest.mark.asyncio
async def test_analyze_s3_usage_bucket_name_hints(handler, mock_s3_client):
"""Test bucket name hint detection in analyze_s3_usage_for_data_processing."""
handler.s3_client = mock_s3_client
# Mock list_buckets response with buckets that have hints in their names
mock_s3_client.list_buckets.return_value = {
'Buckets': [
{'Name': 'my-glue-etl-bucket'},
{'Name': 'athena-query-results'},
{'Name': 'emr-hadoop-logs'},
{'Name': 'random-bucket-name'},
]
}
# Mock list_objects_v2 response
mock_s3_client.list_objects_v2.return_value = {'KeyCount': 0}
# Mock AWS service clients
with patch(
'awslabs.aws_dataprocessing_mcp_server.handlers.commons.common_resource_handler.AwsHelper'
) as mock_aws_helper:
mock_glue_client = Mock()
mock_athena_client = Mock()
mock_emr_client = Mock()
mock_aws_helper.create_boto3_client.side_effect = lambda service: {
'glue': mock_glue_client,
'athena': mock_athena_client,
'emr': mock_emr_client,
}[service]
# Mock service responses - no active usage detected
mock_glue_client.get_connections.return_value = {'ConnectionList': []}
mock_glue_client.get_crawlers.return_value = {'Crawlers': []}
mock_glue_client.get_jobs.return_value = {'Jobs': []}
mock_athena_client.list_work_groups.return_value = {'WorkGroups': []}
mock_emr_client.list_clusters.return_value = {'Clusters': []}
ctx = Mock()
response = await handler.analyze_s3_usage_for_data_processing(ctx)
assert not response.isError
# Should detect bucket name hints
assert (
'Likely Glue bucket (based on name) but no active usage detected'
in response.analysis_summary
)
assert (
'Likely Athena bucket (based on name) but no active usage detected'
in response.analysis_summary
)
assert (
'Likely EMR bucket (based on name) but no active usage detected'
in response.analysis_summary
)
assert 'No data processing service usage detected' in response.analysis_summary
@pytest.mark.asyncio
async def test_upload_to_s3_success(handler, mock_s3_client):
"""Test successful upload to S3."""
handler.s3_client = mock_s3_client
# Mock bucket location
mock_s3_client.get_bucket_location.return_value = {'LocationConstraint': 'us-east-1'}
code_content = "print('Hello, World!')"
ctx = Mock()
response = await handler.upload_to_s3(
ctx, code_content=code_content, bucket_name='test-bucket', s3_key='scripts/test.py'
)
assert not response.isError
assert response.s3_uri == 's3://test-bucket/scripts/test.py'
assert response.bucket_name == 'test-bucket'
assert response.s3_key == 'scripts/test.py'
# Verify put_object was called
mock_s3_client.put_object.assert_called_once_with(
Body=code_content, Bucket='test-bucket', Key='scripts/test.py', ContentType='text/x-python'
)
@pytest.mark.asyncio
async def test_upload_to_s3_make_public(handler, mock_s3_client):
"""Test successful upload to S3 with public access."""
handler.s3_client = mock_s3_client
# Mock bucket location
mock_s3_client.get_bucket_location.return_value = {'LocationConstraint': 'us-east-1'}
code_content = "print('Hello, World!')"
ctx = Mock()
response = await handler.upload_to_s3(
ctx,
code_content=code_content,
bucket_name='test-bucket',
s3_key='scripts/test.py',
make_public=True,
)
assert not response.isError
# Verify put_object_acl was called
mock_s3_client.put_object_acl.assert_called_once_with(
Bucket='test-bucket', Key='scripts/test.py', ACL='public-read'
)
@pytest.mark.asyncio
async def test_upload_to_s3_without_write_permission(read_only_handler):
"""Test that uploading to S3 fails when write access is disabled."""
ctx = Mock()
response = await read_only_handler.upload_to_s3(
ctx, code_content="print('test')", bucket_name='test-bucket', s3_key='test.py'
)
assert response.isError
assert 'requires --allow-write flag' in response.content[0].text
@pytest.mark.asyncio
async def test_upload_to_s3_bucket_not_found(handler, mock_s3_client):
"""Test upload to S3 when bucket doesn't exist."""
handler.s3_client = mock_s3_client
# Mock bucket not found
mock_s3_client.head_bucket.side_effect = ClientError(
{'Error': {'Code': '404', 'Message': 'Not Found'}}, 'HeadBucket'
)
ctx = Mock()
response = await handler.upload_to_s3(
ctx, code_content="print('test')", bucket_name='nonexistent-bucket', s3_key='test.py'
)
assert response.isError
assert 'does not exist' in response.content[0].text
@pytest.mark.asyncio
async def test_analyze_s3_usage_for_data_processing_success(handler, mock_s3_client):
"""Test successful S3 usage analysis."""
handler.s3_client = mock_s3_client
# Mock list_buckets response
mock_s3_client.list_buckets.return_value = {'Buckets': [{'Name': 'test-glue-bucket'}]}
# Mock list_objects_v2 response
mock_s3_client.list_objects_v2.return_value = {
'KeyCount': 1,
'Contents': [{'LastModified': datetime(2023, 6, 1)}],
}
# Mock AWS service clients
with patch(
'awslabs.aws_dataprocessing_mcp_server.handlers.commons.common_resource_handler.AwsHelper'
) as mock_aws_helper:
mock_glue_client = Mock()
mock_athena_client = Mock()
mock_emr_client = Mock()
mock_aws_helper.create_boto3_client.side_effect = lambda service: {
'glue': mock_glue_client,
'athena': mock_athena_client,
'emr': mock_emr_client,
}[service]
# Mock service responses
mock_glue_client.get_connections.return_value = {'ConnectionList': []}
mock_glue_client.get_crawlers.return_value = {'Crawlers': []}
mock_glue_client.get_jobs.return_value = {'Jobs': []}
mock_athena_client.list_work_groups.return_value = {'WorkGroups': []}
mock_emr_client.list_clusters.return_value = {'Clusters': []}
ctx = Mock()
response = await handler.analyze_s3_usage_for_data_processing(ctx)
assert not response.isError
assert 'S3 Usage Analysis' in response.analysis_summary
assert response.service_usage is not None
assert 'glue' in response.service_usage
assert 'athena' in response.service_usage
assert 'emr' in response.service_usage
assert 'idle' in response.service_usage
assert 'unknown' in response.service_usage
@pytest.mark.asyncio
async def test_analyze_s3_usage_specific_bucket(handler, mock_s3_client):
"""Test S3 usage analysis for a specific bucket."""
handler.s3_client = mock_s3_client
# Mock list_objects_v2 response
mock_s3_client.list_objects_v2.return_value = {
'KeyCount': 1,
'Contents': [{'LastModified': datetime(2023, 6, 1)}],
}
# Mock AWS service clients
with patch(
'awslabs.aws_dataprocessing_mcp_server.handlers.commons.common_resource_handler.AwsHelper'
) as mock_aws_helper:
mock_glue_client = Mock()
mock_athena_client = Mock()
mock_emr_client = Mock()
mock_aws_helper.create_boto3_client.side_effect = lambda service: {
'glue': mock_glue_client,
'athena': mock_athena_client,
'emr': mock_emr_client,
}[service]
# Mock service responses
mock_glue_client.get_connections.return_value = {'ConnectionList': []}
mock_glue_client.get_crawlers.return_value = {'Crawlers': []}
mock_glue_client.get_jobs.return_value = {'Jobs': []}
mock_athena_client.list_work_groups.return_value = {'WorkGroups': []}
mock_emr_client.list_clusters.return_value = {'Clusters': []}
ctx = Mock()
response = await handler.analyze_s3_usage_for_data_processing(
ctx, bucket_name='test-bucket'
)
assert not response.isError
assert 'S3 Usage Analysis' in response.analysis_summary
@pytest.mark.asyncio
async def test_analyze_s3_usage_bucket_not_found(handler, mock_s3_client):
"""Test S3 usage analysis when specific bucket doesn't exist."""
handler.s3_client = mock_s3_client
# Mock bucket not found
mock_s3_client.head_bucket.side_effect = ClientError(
{'Error': {'Code': '404', 'Message': 'Not Found'}}, 'HeadBucket'
)
ctx = Mock()
response = await handler.analyze_s3_usage_for_data_processing(
ctx, bucket_name='nonexistent-bucket'
)
assert response.isError
assert 'does not exist or is not accessible' in response.content[0].text
@pytest.mark.asyncio
async def test_analyze_s3_usage_error_handling(handler, mock_s3_client):
"""Test error handling when S3 usage analysis fails."""
handler.s3_client = mock_s3_client
mock_s3_client.list_buckets.side_effect = ClientError(
{'Error': {'Code': 'AccessDenied', 'Message': 'Access denied'}}, 'ListBuckets'
)
ctx = Mock()
response = await handler.analyze_s3_usage_for_data_processing(ctx)
assert response.isError
assert 'AWS Error' in response.content[0].text
# ============================================================================
# Helper Methods Tests
# ============================================================================
def test_get_trust_relationship_for_service_glue(handler):
"""Test trust relationship generation for Glue service."""
trust_relationship = handler._get_trust_relationship_for_service('glue')
assert trust_relationship['Version'] == '2012-10-17'
assert len(trust_relationship['Statement']) == 1
assert trust_relationship['Statement'][0]['Effect'] == 'Allow'
assert trust_relationship['Statement'][0]['Principal']['Service'] == 'glue.amazonaws.com'
assert trust_relationship['Statement'][0]['Action'] == 'sts:AssumeRole'
def test_get_trust_relationship_for_service_emr(handler):
"""Test trust relationship generation for EMR service."""
trust_relationship = handler._get_trust_relationship_for_service('emr')
assert (
trust_relationship['Statement'][0]['Principal']['Service']
== 'elasticmapreduce.amazonaws.com'
)
def test_get_trust_relationship_for_service_athena(handler):
"""Test trust relationship generation for Athena service."""
trust_relationship = handler._get_trust_relationship_for_service('athena')
assert trust_relationship['Statement'][0]['Principal']['Service'] == 'athena.amazonaws.com'
def test_get_service_principal_known_services(handler):
"""Test service principal mapping for known services."""
assert handler._get_service_principal('glue') == 'glue.amazonaws.com'
assert handler._get_service_principal('emr') == 'elasticmapreduce.amazonaws.com'
assert handler._get_service_principal('athena') == 'athena.amazonaws.com'
assert handler._get_service_principal('lambda') == 'lambda.amazonaws.com'
assert handler._get_service_principal('ec2') == 'ec2.amazonaws.com'
def test_get_service_principal_unknown_service(handler):
"""Test service principal mapping for unknown services."""
assert handler._get_service_principal('unknown-service') == 'unknown-service.amazonaws.com'
def test_can_be_assumed_by_service_single_service(handler):
"""Test checking if role can be assumed by service with single service principal."""
assume_role_policy = {
'Version': '2012-10-17',
'Statement': [
{
'Effect': 'Allow',
'Principal': {'Service': 'glue.amazonaws.com'},
'Action': 'sts:AssumeRole',
}
],
}
assert handler._can_be_assumed_by_service(assume_role_policy, 'glue.amazonaws.com')
assert not handler._can_be_assumed_by_service(assume_role_policy, 'emr.amazonaws.com')
def test_can_be_assumed_by_service_multiple_services(handler):
"""Test checking if role can be assumed by service with multiple service principals."""
assume_role_policy = {
'Version': '2012-10-17',
'Statement': [
{
'Effect': 'Allow',
'Principal': {'Service': ['glue.amazonaws.com', 'emr.amazonaws.com']},
'Action': 'sts:AssumeRole',
}
],
}
assert handler._can_be_assumed_by_service(assume_role_policy, 'glue.amazonaws.com')
assert handler._can_be_assumed_by_service(assume_role_policy, 'emr.amazonaws.com')
assert not handler._can_be_assumed_by_service(assume_role_policy, 'athena.amazonaws.com')
def test_can_be_assumed_by_service_string_action(handler):
"""Test checking if role can be assumed by service with string action."""
assume_role_policy = {
'Version': '2012-10-17',
'Statement': [
{
'Effect': 'Allow',
'Principal': {'Service': 'glue.amazonaws.com'},
'Action': 'sts:AssumeRole',
}
],
}
assert handler._can_be_assumed_by_service(assume_role_policy, 'glue.amazonaws.com')
def test_can_be_assumed_by_service_deny_effect(handler):
"""Test checking if role can be assumed by service with Deny effect."""
assume_role_policy = {
'Version': '2012-10-17',
'Statement': [
{
'Effect': 'Deny',
'Principal': {'Service': 'glue.amazonaws.com'},
'Action': 'sts:AssumeRole',
}
],
}
# The implementation correctly ignores Deny statements and only processes Allow statements
assert not handler._can_be_assumed_by_service(assume_role_policy, 'glue.amazonaws.com')
def test_can_be_assumed_by_service_wrong_action(handler):
"""Test checking if role can be assumed by service with wrong action."""
assume_role_policy = {
'Version': '2012-10-17',
'Statement': [
{
'Effect': 'Allow',
'Principal': {'Service': 'glue.amazonaws.com'},
'Action': 'sts:GetCallerIdentity',
}
],
}
assert not handler._can_be_assumed_by_service(assume_role_policy, 'glue.amazonaws.com')
def test_can_be_assumed_by_service_empty_policy(handler):
"""Test checking if role can be assumed by service with empty policy."""
assert not handler._can_be_assumed_by_service({}, 'glue.amazonaws.com')
assert not handler._can_be_assumed_by_service({'Statement': []}, 'glue.amazonaws.com')
def test_add_permissions_to_document_single_statement(handler):
"""Test adding single permission statement to policy document."""
policy_document = {'Version': '2012-10-17', 'Statement': []}
permissions = {
'Effect': 'Allow',
'Action': ['s3:GetObject'],
'Resource': 'arn:aws:s3:::test-bucket/*',
}
handler._add_permissions_to_document(policy_document, permissions)
assert len(policy_document['Statement']) == 1
assert policy_document['Statement'][0] == permissions
def test_add_permissions_to_document_multiple_statements(handler):
"""Test adding multiple permission statements to policy document."""
policy_document = {'Version': '2012-10-17', 'Statement': []}
permissions = [
{'Effect': 'Allow', 'Action': ['s3:GetObject'], 'Resource': 'arn:aws:s3:::test-bucket/*'},
{'Effect': 'Allow', 'Action': ['s3:PutObject'], 'Resource': 'arn:aws:s3:::test-bucket/*'},
]
handler._add_permissions_to_document(policy_document, permissions)
assert len(policy_document['Statement']) == 2
assert policy_document['Statement'][0] == permissions[0]
assert policy_document['Statement'][1] == permissions[1]
# ============================================================================
# Initialization Tests
# ============================================================================
@pytest.mark.asyncio
async def test_initialization_parameters(mock_aws_helper):
"""Test initialization of parameters for CommonResourceHandler object."""
mcp = Mock()
handler = CommonResourceHandler(mcp, allow_write=True)
assert handler.allow_write
assert handler.mcp == mcp
@pytest.mark.asyncio
async def test_initialization_registers_tools(mock_aws_helper):
"""Test that initialization registers the tools with the MCP server."""
mcp = Mock()
CommonResourceHandler(mcp)
# Verify IAM tools are registered
mcp.tool.assert_any_call(name='add_inline_policy')
mcp.tool.assert_any_call(name='get_policies_for_role')
mcp.tool.assert_any_call(name='create_data_processing_role')
mcp.tool.assert_any_call(name='get_roles_for_service')
# Verify S3 tools are registered
mcp.tool.assert_any_call(name='list_s3_buckets')
mcp.tool.assert_any_call(name='upload_to_s3')
mcp.tool.assert_any_call(name='analyze_s3_usage_for_data_processing')
@pytest.mark.asyncio
async def test_initialization_default_parameters(mock_aws_helper):
"""Test initialization with default parameters."""
mcp = Mock()
handler = CommonResourceHandler(mcp)
assert not handler.allow_write # Default should be False
assert handler.mcp == mcp
@pytest.mark.asyncio
async def test_get_managed_policies_error_handling(handler, mock_iam_client):
"""Test error handling in _get_managed_policies method."""
handler.iam_client = mock_iam_client
# Mock successful list_attached_role_policies
mock_iam_client.list_attached_role_policies.return_value = {
'AttachedPolicies': [
{
'PolicyName': 'TestManagedPolicy',
'PolicyArn': 'arn:aws:iam::aws:policy/TestManagedPolicy',
}
]
}
# Mock successful get_policy
mock_iam_client.get_policy.return_value = {
'Policy': {'DefaultVersionId': 'v1', 'Description': 'Test managed policy'}
}
# Mock get_policy_version to raise an exception
mock_iam_client.get_policy_version.side_effect = ClientError(
{'Error': {'Code': 'AccessDenied', 'Message': 'Access denied'}}, 'GetPolicyVersion'
)
ctx = Mock()
managed_policies = handler._get_managed_policies(ctx, 'test-role')
# Should still return policy summary even if policy version fails
assert len(managed_policies) == 1
assert managed_policies[0].policy_type == 'Managed'
assert managed_policies[0].policy_document is None
@pytest.mark.asyncio
async def test_create_data_processing_role_create_role_error(handler, mock_iam_client):
"""Test error handling when create_role fails in create_data_processing_role."""
handler.iam_client = mock_iam_client
# Mock create_role to raise an exception
mock_iam_client.create_role.side_effect = ClientError(
{'Error': {'Code': 'EntityAlreadyExists', 'Message': 'Role already exists'}}, 'CreateRole'
)
ctx = Mock()
response = await handler.create_data_processing_role(
ctx, role_name='existing-role', service_type='glue'
)
assert response.isError
assert 'Failed to create IAM role' in response.content[0].text
@pytest.mark.asyncio
async def test_analyze_s3_usage_idle_bucket_detection(handler, mock_s3_client):
"""Test idle bucket detection in analyze_s3_usage_for_data_processing."""
handler.s3_client = mock_s3_client
# Mock list_buckets response with a bucket that has old activity
mock_s3_client.list_buckets.return_value = {'Buckets': [{'Name': 'old-bucket'}]}
# Mock list_objects_v2 response with old last modified date (>90 days ago)
old_date = datetime.now() - timedelta(days=100)
mock_s3_client.list_objects_v2.return_value = {
'KeyCount': 1,
'Contents': [{'LastModified': old_date}],
}
# Mock AWS service clients
with patch(
'awslabs.aws_dataprocessing_mcp_server.handlers.commons.common_resource_handler.AwsHelper'
) as mock_aws_helper:
mock_glue_client = Mock()
mock_athena_client = Mock()
mock_emr_client = Mock()
mock_aws_helper.create_boto3_client.side_effect = lambda service: {
'glue': mock_glue_client,
'athena': mock_athena_client,
'emr': mock_emr_client,
}[service]
# Mock service responses - no active usage detected
mock_glue_client.get_connections.return_value = {'ConnectionList': []}
mock_glue_client.get_crawlers.return_value = {'Crawlers': []}
mock_glue_client.get_jobs.return_value = {'Jobs': []}
mock_athena_client.list_work_groups.return_value = {'WorkGroups': []}
mock_emr_client.list_clusters.return_value = {'Clusters': []}
ctx = Mock()
response = await handler.analyze_s3_usage_for_data_processing(ctx)
assert not response.isError
# Should detect idle bucket
assert (
'IDLE: No data processing service usage detected and no activity for 90+ days'
in response.analysis_summary
)
@pytest.mark.asyncio
async def test_analyze_s3_usage_glue_job_detection(handler, mock_s3_client):
"""Test Glue job bucket detection in analyze_s3_usage_for_data_processing."""
handler.s3_client = mock_s3_client
# Mock list_buckets response
mock_s3_client.list_buckets.return_value = {'Buckets': [{'Name': 'test-bucket'}]}
# Mock list_objects_v2 response
mock_s3_client.list_objects_v2.return_value = {'KeyCount': 0}
# Mock AWS service clients
with patch(
'awslabs.aws_dataprocessing_mcp_server.handlers.commons.common_resource_handler.AwsHelper'
) as mock_aws_helper:
mock_glue_client = Mock()
mock_athena_client = Mock()
mock_emr_client = Mock()
mock_aws_helper.create_boto3_client.side_effect = lambda service: {
'glue': mock_glue_client,
'athena': mock_athena_client,
'emr': mock_emr_client,
}[service]
# Mock Glue job with bucket reference in DefaultArguments
mock_glue_client.get_connections.return_value = {'ConnectionList': []}
mock_glue_client.get_crawlers.return_value = {'Crawlers': []}
mock_glue_client.get_jobs.return_value = {
'Jobs': [
{
'Name': 'test-job',
'DefaultArguments': {
'--TempDir': 's3://test-bucket/temp/',
'--job-bookmark-option': 'job-bookmark-enable',
},
}
]
}
mock_athena_client.list_work_groups.return_value = {'WorkGroups': []}
mock_emr_client.list_clusters.return_value = {'Clusters': []}
ctx = Mock()
response = await handler.analyze_s3_usage_for_data_processing(ctx)
assert not response.isError
# Should detect Glue usage
assert '✅ Used by AWS Glue' in response.analysis_summary
@pytest.mark.asyncio
async def test_analyze_s3_usage_glue_crawler_detection(handler, mock_s3_client):
"""Test Glue crawler bucket detection in analyze_s3_usage_for_data_processing."""
handler.s3_client = mock_s3_client
# Mock list_buckets response
mock_s3_client.list_buckets.return_value = {'Buckets': [{'Name': 'test-bucket'}]}
# Mock list_objects_v2 response
mock_s3_client.list_objects_v2.return_value = {'KeyCount': 0}
# Mock AWS service clients
with patch(
'awslabs.aws_dataprocessing_mcp_server.handlers.commons.common_resource_handler.AwsHelper'
) as mock_aws_helper:
mock_glue_client = Mock()
mock_athena_client = Mock()
mock_emr_client = Mock()
mock_aws_helper.create_boto3_client.side_effect = lambda service: {
'glue': mock_glue_client,
'athena': mock_athena_client,
'emr': mock_emr_client,
}[service]
# Mock Glue crawler with S3 target
mock_glue_client.get_connections.return_value = {'ConnectionList': []}
mock_glue_client.get_crawlers.return_value = {
'Crawlers': [
{
'Name': 'test-crawler',
'Targets': {'S3Targets': [{'Path': 's3://test-bucket/data/'}]},
}
]
}
mock_glue_client.get_jobs.return_value = {'Jobs': []}
mock_athena_client.list_work_groups.return_value = {'WorkGroups': []}
mock_emr_client.list_clusters.return_value = {'Clusters': []}
ctx = Mock()
response = await handler.analyze_s3_usage_for_data_processing(ctx)
assert not response.isError
# Should detect Glue usage
assert '✅ Used by AWS Glue' in response.analysis_summary
@pytest.mark.asyncio
async def test_analyze_s3_usage_athena_workgroup_detection(handler, mock_s3_client):
"""Test Athena workgroup bucket detection in analyze_s3_usage_for_data_processing."""
handler.s3_client = mock_s3_client
# Mock list_buckets response
mock_s3_client.list_buckets.return_value = {'Buckets': [{'Name': 'test-bucket'}]}
# Mock list_objects_v2 response
mock_s3_client.list_objects_v2.return_value = {'KeyCount': 0}
# Mock AWS service clients
with patch(
'awslabs.aws_dataprocessing_mcp_server.handlers.commons.common_resource_handler.AwsHelper'
) as mock_aws_helper:
mock_glue_client = Mock()
mock_athena_client = Mock()
mock_emr_client = Mock()
mock_aws_helper.create_boto3_client.side_effect = lambda service: {
'glue': mock_glue_client,
'athena': mock_athena_client,
'emr': mock_emr_client,
}[service]
# Mock service responses
mock_glue_client.get_connections.return_value = {'ConnectionList': []}
mock_glue_client.get_crawlers.return_value = {'Crawlers': []}
mock_glue_client.get_jobs.return_value = {'Jobs': []}
# Mock Athena workgroup with output location
mock_athena_client.list_work_groups.return_value = {
'WorkGroups': [{'Name': 'test-workgroup'}]
}
mock_athena_client.get_work_group.return_value = {
'WorkGroup': {
'Configuration': {
'ResultConfiguration': {'OutputLocation': 's3://test-bucket/athena-results/'}
}
}
}
mock_emr_client.list_clusters.return_value = {'Clusters': []}
ctx = Mock()
response = await handler.analyze_s3_usage_for_data_processing(ctx)
assert not response.isError
# Should detect Athena usage
assert '✅ Used by Amazon Athena' in response.analysis_summary
@pytest.mark.asyncio
async def test_analyze_s3_usage_emr_cluster_detection(handler, mock_s3_client):
"""Test EMR cluster bucket detection in analyze_s3_usage_for_data_processing."""
handler.s3_client = mock_s3_client
# Mock list_buckets response
mock_s3_client.list_buckets.return_value = {'Buckets': [{'Name': 'test-bucket'}]}
# Mock list_objects_v2 response
mock_s3_client.list_objects_v2.return_value = {'KeyCount': 0}
# Mock AWS service clients
with patch(
'awslabs.aws_dataprocessing_mcp_server.handlers.commons.common_resource_handler.AwsHelper'
) as mock_aws_helper:
mock_glue_client = Mock()
mock_athena_client = Mock()
mock_emr_client = Mock()
mock_aws_helper.create_boto3_client.side_effect = lambda service: {
'glue': mock_glue_client,
'athena': mock_athena_client,
'emr': mock_emr_client,
}[service]
# Mock service responses
mock_glue_client.get_connections.return_value = {'ConnectionList': []}
mock_glue_client.get_crawlers.return_value = {'Crawlers': []}
mock_glue_client.get_jobs.return_value = {'Jobs': []}
mock_athena_client.list_work_groups.return_value = {'WorkGroups': []}
# Mock EMR cluster with log URI
mock_emr_client.list_clusters.return_value = {
'Clusters': [{'Id': 'j-1234567890123', 'Name': 'test-cluster'}]
}
mock_emr_client.describe_cluster.return_value = {
'Cluster': {'LogUri': 's3://test-bucket/emr-logs/'}
}
ctx = Mock()
response = await handler.analyze_s3_usage_for_data_processing(ctx)
assert not response.isError
# Should detect EMR usage
assert '✅ Used by Amazon EMR' in response.analysis_summary
@pytest.mark.asyncio
async def test_list_s3_buckets_us_east_1_location_constraint(handler, mock_s3_client):
"""Test list_s3_buckets with us-east-1 location constraint (None)."""
handler.s3_client = mock_s3_client
# Mock list_buckets response
mock_s3_client.list_buckets.return_value = {
'Buckets': [{'Name': 'test-glue-bucket', 'CreationDate': datetime(2023, 1, 1)}]
}
# Mock bucket location returning None (us-east-1 case)
mock_s3_client.get_bucket_location.return_value = {'LocationConstraint': None}
# Mock list_objects_v2 response
mock_s3_client.list_objects_v2.return_value = {
'KeyCount': 5,
'Contents': [{'LastModified': datetime(2023, 6, 1)}],
}
ctx = Mock()
response = await handler.list_s3_buckets(ctx, region='us-east-1')
assert not response.isError
assert response.region == 'us-east-1'
assert response.bucket_count == 1
assert len(response.buckets) == 1
assert response.buckets[0].name == 'test-glue-bucket'
@pytest.mark.asyncio
async def test_list_s3_buckets_truncated_objects(handler, mock_s3_client):
"""Test list_s3_buckets with truncated object list."""
handler.s3_client = mock_s3_client
# Mock list_buckets response
mock_s3_client.list_buckets.return_value = {
'Buckets': [{'Name': 'test-glue-bucket', 'CreationDate': datetime(2023, 1, 1)}]
}
# Mock bucket location
mock_s3_client.get_bucket_location.return_value = {'LocationConstraint': 'us-east-1'}
# Mock list_objects_v2 response with truncated results
mock_s3_client.list_objects_v2.return_value = {
'KeyCount': 1000,
'IsTruncated': True,
'Contents': [{'LastModified': datetime(2023, 6, 1)}],
}
ctx = Mock()
response = await handler.list_s3_buckets(ctx, region='us-east-1')
assert not response.isError
assert response.region == 'us-east-1'
assert response.bucket_count == 1
assert len(response.buckets) == 1
assert response.buckets[0].name == 'test-glue-bucket'
# Should show truncated count
assert '1000+ (truncated)' in response.content[0].text
@pytest.mark.asyncio
async def test_upload_to_s3_us_east_1_location_constraint(handler, mock_s3_client):
"""Test upload_to_s3 with us-east-1 location constraint (None)."""
handler.s3_client = mock_s3_client
# Mock successful head_bucket
mock_s3_client.head_bucket.return_value = {}
# Mock bucket location returning None (us-east-1 case)
mock_s3_client.get_bucket_location.return_value = {'LocationConstraint': None}
code_content = "print('Hello, World!')"
ctx = Mock()
response = await handler.upload_to_s3(
ctx, code_content=code_content, bucket_name='test-bucket', s3_key='scripts/test.py'
)
assert not response.isError
assert response.s3_uri == 's3://test-bucket/scripts/test.py'
assert response.bucket_name == 'test-bucket'
assert response.s3_key == 'scripts/test.py'
# Verify put_object was called
mock_s3_client.put_object.assert_called_once_with(
Body=code_content, Bucket='test-bucket', Key='scripts/test.py', ContentType='text/x-python'
)
def test_can_be_assumed_by_service_list_actions(handler):
"""Test checking if role can be assumed by service with list of actions."""
assume_role_policy = {
'Version': '2012-10-17',
'Statement': [
{
'Effect': 'Allow',
'Principal': {'Service': 'glue.amazonaws.com'},
'Action': ['sts:AssumeRole', 'sts:GetCallerIdentity'],
}
],
}
assert handler._can_be_assumed_by_service(assume_role_policy, 'glue.amazonaws.com')
def test_can_be_assumed_by_service_no_principal_service(handler):
"""Test checking if role can be assumed by service with no Principal.Service."""
assume_role_policy = {
'Version': '2012-10-17',
'Statement': [
{
'Effect': 'Allow',
'Principal': {'AWS': 'arn:aws:iam::123456789012:root'},
'Action': 'sts:AssumeRole',
}
],
}
assert not handler._can_be_assumed_by_service(assume_role_policy, 'glue.amazonaws.com')
@pytest.mark.asyncio
async def test_list_s3_buckets_bucket_location_error(handler, mock_s3_client):
"""Test error handling when get_bucket_location fails in list_s3_buckets."""
handler.s3_client = mock_s3_client
# Mock list_buckets response
mock_s3_client.list_buckets.return_value = {
'Buckets': [{'Name': 'test-glue-bucket', 'CreationDate': datetime(2023, 1, 1)}]
}
# Mock get_bucket_location to raise an exception
mock_s3_client.get_bucket_location.side_effect = ClientError(
{'Error': {'Code': 'AccessDenied', 'Message': 'Access denied'}}, 'GetBucketLocation'
)
ctx = Mock()
response = await handler.list_s3_buckets(ctx, region='us-east-1')
assert not response.isError
# Should still return results but with error details in the text
assert 'Error getting details' in response.content[0].text
@pytest.mark.asyncio
async def test_list_s3_buckets_list_objects_error(handler, mock_s3_client):
"""Test error handling when list_objects_v2 fails in list_s3_buckets."""
handler.s3_client = mock_s3_client
# Mock list_buckets response
mock_s3_client.list_buckets.return_value = {
'Buckets': [{'Name': 'test-glue-bucket', 'CreationDate': datetime(2023, 1, 1)}]
}
# Mock successful get_bucket_location
mock_s3_client.get_bucket_location.return_value = {'LocationConstraint': 'us-east-1'}
# Mock list_objects_v2 to raise an exception
mock_s3_client.list_objects_v2.side_effect = ClientError(
{'Error': {'Code': 'AccessDenied', 'Message': 'Access denied'}}, 'ListObjectsV2'
)
ctx = Mock()
response = await handler.list_s3_buckets(ctx, region='us-east-1')
assert not response.isError
# Should still return results but with error details in the text
assert 'Error getting details' in response.content[0].text
@pytest.mark.asyncio
async def test_upload_to_s3_bucket_access_denied(handler, mock_s3_client):
"""Test upload to S3 when access is denied to bucket."""
handler.s3_client = mock_s3_client
# Mock bucket access denied
mock_s3_client.head_bucket.side_effect = ClientError(
{'Error': {'Code': '403', 'Message': 'Forbidden'}}, 'HeadBucket'
)
ctx = Mock()
response = await handler.upload_to_s3(
ctx, code_content="print('test')", bucket_name='forbidden-bucket', s3_key='test.py'
)
assert response.isError
assert 'Access denied to bucket' in response.content[0].text
@pytest.mark.asyncio
async def test_create_data_processing_role_attach_policy_error(handler, mock_iam_client):
"""Test error handling when attach_role_policy fails in create_data_processing_role."""
handler.iam_client = mock_iam_client
# Mock successful create_role
mock_iam_client.create_role.return_value = {
'Role': {'Arn': 'arn:aws:iam::123456789012:role/test-role'}
}
# Mock attach_role_policy to raise an exception
mock_iam_client.attach_role_policy.side_effect = ClientError(
{'Error': {'Code': 'NoSuchEntity', 'Message': 'Policy not found'}}, 'AttachRolePolicy'
)
ctx = Mock()
response = await handler.create_data_processing_role(
ctx,
role_name='test-role',
service_type='glue',
managed_policy_arns=['arn:aws:iam::aws:policy/NonExistentPolicy'],
)
assert response.isError
assert 'Failed to create IAM role' in response.content[0].text
@pytest.mark.asyncio
async def test_create_data_processing_role_inline_policy_error(handler, mock_iam_client):
"""Test error handling when put_role_policy fails in create_data_processing_role."""
handler.iam_client = mock_iam_client
# Mock successful create_role
mock_iam_client.create_role.return_value = {
'Role': {'Arn': 'arn:aws:iam::123456789012:role/test-role'}
}
# Mock put_role_policy to raise an exception
mock_iam_client.put_role_policy.side_effect = ClientError(
{'Error': {'Code': 'MalformedPolicyDocument', 'Message': 'Invalid policy'}},
'PutRolePolicy',
)
inline_policy = {
'Effect': 'Allow',
'Action': ['s3:GetObject'],
'Resource': 'arn:aws:s3:::test-bucket/*',
}
ctx = Mock()
response = await handler.create_data_processing_role(
ctx, role_name='test-role', service_type='glue', inline_policy=inline_policy
)
assert response.isError
assert 'Failed to create IAM role' in response.content[0].text
```