This is page 414 of 421. 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
├── scripts
│ ├── README.md
│ └── verify_package_name.py
├── 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
│ │ │ └── sql_analyzer.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
│ │ │ └── test_sql_analyzer.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
│ │ │ ├── models.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
│ │ │ │ └── sitewise_metadata_transfer.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_models.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_sitewise_metadata_transfer.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
│ │ ├── .secrets.baseline
│ │ ├── 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
│ │ │ ├── templates
│ │ │ │ ├── __init__.py
│ │ │ │ └── iam_policies.py
│ │ │ ├── tools
│ │ │ │ ├── common
│ │ │ │ │ └── base_tool.py
│ │ │ │ ├── esm
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── esm_diagnosis.py
│ │ │ │ │ ├── esm_guidance.py
│ │ │ │ │ ├── esm_recommend.py
│ │ │ │ │ └── secure_esm_guidance.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
│ │ │ │ ├── poller
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── esm_diagnosis.py
│ │ │ │ │ ├── esm_guidance.py
│ │ │ │ │ └── esm_recommend.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
│ │ │ ├── data_scrubber.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_data_scrubber.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_esm_diagnosis.py
│ │ │ ├── test_esm_guidance.py
│ │ │ ├── test_esm_recommend.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_iam_policies.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_secure_esm_guidance.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
│ │ │ ├── connection
│ │ │ │ ├── __init__.py
│ │ │ │ ├── abstract_db_connection.py
│ │ │ │ ├── asyncmy_pool_connection.py
│ │ │ │ ├── db_connection_singleton.py
│ │ │ │ └── rds_data_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_abstract_db_connection.py
│ │ │ ├── test_asyncmy_pool_connection.py
│ │ │ ├── test_db_connection_singleton.py
│ │ │ ├── test_rds_data_api_connection.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-support-mcp-server/tests/test_aws_support_mcp_server.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. A copy of the License is
# located at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# or in the 'license' file accompanying this file. This file is distributed on an
# 'AS IS' BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# implied. See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for the AWS Support API MCP Server."""
import asyncio
import json
import pytest
import time
from awslabs.aws_support_mcp_server.client import SupportClient
from awslabs.aws_support_mcp_server.consts import (
DEFAULT_REGION,
ERROR_AUTHENTICATION_FAILED,
ERROR_CASE_NOT_FOUND,
ERROR_RATE_LIMIT_EXCEEDED,
ERROR_SUBSCRIPTION_REQUIRED,
PERMITTED_LANGUAGE_CODES,
)
from awslabs.aws_support_mcp_server.errors import (
create_error_response,
handle_client_error,
handle_general_error,
handle_validation_error,
)
from awslabs.aws_support_mcp_server.formatters import (
format_case,
format_cases,
format_communications,
format_json_response,
format_markdown_case_summary,
format_markdown_services,
format_markdown_severity_levels,
format_services,
format_severity_levels,
)
from awslabs.aws_support_mcp_server.server import (
add_communication_to_case,
create_support_case,
describe_support_cases,
resolve_support_case,
)
from botocore.exceptions import ClientError
from pydantic import ValidationError
from typing import Any, Dict, List
from unittest.mock import ANY, AsyncMock, MagicMock, patch
# Fixtures
@pytest.fixture
def support_case_data() -> Dict[str, Any]:
"""Return a dictionary with sample support case data."""
return {
'caseId': 'case-12345678910-2013-c4c1d2bf33c5cf47',
'displayId': '12345678910',
'subject': 'EC2 instance not starting',
'status': 'opened',
'serviceCode': 'amazon-elastic-compute-cloud-linux',
'categoryCode': 'using-aws',
'severityCode': 'urgent',
'submittedBy': '[email protected]',
'timeCreated': '2023-01-01T12:00:00Z',
'recentCommunications': {
'communications': [
{
'caseId': 'case-12345678910-2013-c4c1d2bf33c5cf47',
'body': 'My EC2 instance i-1234567890abcdef0 is not starting.',
'submittedBy': '[email protected]',
'timeCreated': '2023-01-01T12:00:00Z',
}
],
'nextToken': None,
},
'ccEmailAddresses': ['[email protected]'],
'language': 'en',
'nextToken': None,
}
@pytest.fixture
def minimal_support_case_data() -> Dict[str, Any]:
"""Return a dictionary with minimal support case data."""
return {
'caseId': 'case-12345678910-2013-c4c1d2bf33c5cf47',
'subject': 'EC2 instance not starting',
'status': 'opened',
'serviceCode': 'amazon-elastic-compute-cloud-linux',
'categoryCode': 'using-aws',
'severityCode': 'urgent',
'submittedBy': '[email protected]',
'timeCreated': '2023-01-01T12:00:00Z',
}
@pytest.fixture
def edge_case_support_case_data() -> Dict[str, Any]:
"""Return a dictionary with edge case support case data."""
return {
'caseId': 'case-12345678910-2013-c4c1d2bf33c5cf47',
'displayId': '12345678910',
'subject': 'EC2 instance not starting' * 50, # Very long subject
'status': 'opened',
'serviceCode': 'amazon-elastic-compute-cloud-linux',
'categoryCode': 'using-aws',
'severityCode': 'urgent',
'submittedBy': '[email protected]',
'timeCreated': '2023-01-01T12:00:00Z',
'recentCommunications': {
'communications': [
{
'caseId': 'case-12345678910-2013-c4c1d2bf33c5cf47',
'body': 'My EC2 instance i-1234567890abcdef0 is not starting.',
'submittedBy': '[email protected]',
'timeCreated': '2023-01-01T12:00:00Z',
}
],
'nextToken': None,
},
'ccEmailAddresses': ['[email protected]'],
'language': 'en',
'nextToken': None,
}
@pytest.fixture
def multiple_support_cases_data() -> List[Dict[str, Any]]:
"""Return a list of dictionaries with sample support case data."""
return [
{
'caseId': 'case-12345678910-2013-c4c1d2bf33c5cf47',
'displayId': '12345678910',
'subject': 'EC2 instance not starting',
'status': 'opened',
'serviceCode': 'amazon-elastic-compute-cloud-linux',
'categoryCode': 'using-aws',
'severityCode': 'urgent',
'submittedBy': '[email protected]',
'timeCreated': '2023-01-01T12:00:00Z',
},
{
'caseId': 'case-98765432109-2013-a1b2c3d4e5f6',
'displayId': '98765432109',
'subject': 'S3 bucket access issue',
'status': 'opened',
'serviceCode': 'amazon-s3',
'categoryCode': 'using-aws',
'severityCode': 'high',
'submittedBy': '[email protected]',
'timeCreated': '2023-01-02T12:00:00Z',
},
]
@pytest.fixture
def communication_data() -> Dict[str, Any]:
"""Return a dictionary with sample communication data."""
return {
'caseId': 'case-12345678910-2013-c4c1d2bf33c5cf47',
'body': 'My EC2 instance i-1234567890abcdef0 is not starting.',
'submittedBy': '[email protected]',
'timeCreated': '2023-01-01T12:00:00Z',
'attachmentSet': None,
}
@pytest.fixture
def minimal_communication_data() -> Dict[str, Any]:
"""Return a dictionary with minimal communication data."""
return {
'caseId': 'case-12345678910-2013-c4c1d2bf33c5cf47',
'body': 'My EC2 instance i-1234567890abcdef0 is not starting.',
'submittedBy': '[email protected]',
'timeCreated': '2023-01-01T12:00:00Z',
}
@pytest.fixture
def communications_response_data() -> Dict[str, Any]:
"""Return a dictionary with sample communications response data."""
return {
'communications': [
{
'caseId': 'case-12345678910-2013-c4c1d2bf33c5cf47',
'body': 'My EC2 instance i-1234567890abcdef0 is not starting.',
'submittedBy': '[email protected]',
'timeCreated': '2023-01-01T12:00:00Z',
},
{
'caseId': 'case-12345678910-2013-c4c1d2bf33c5cf47',
'body': "I've tried rebooting the instance but it's still not starting.",
'submittedBy': '[email protected]',
'timeCreated': '2023-01-01T12:30:00Z',
},
],
'nextToken': None,
}
@pytest.fixture
def empty_communications_response_data() -> Dict[str, Any]:
"""Return a dictionary with empty communications response data."""
return {
'communications': [],
'nextToken': None,
}
@pytest.fixture
def service_data() -> Dict[str, Any]:
"""Return a dictionary with sample service data."""
return {
'code': 'amazon-elastic-compute-cloud-linux',
'name': 'Amazon Elastic Compute Cloud (Linux)',
'categories': [
{'code': 'using-aws', 'name': 'Using AWS'},
{'code': 'performance', 'name': 'Performance'},
],
}
@pytest.fixture
def minimal_service_data() -> Dict[str, Any]:
"""Return a dictionary with minimal service data."""
return {
'code': 'amazon-elastic-compute-cloud-linux',
'name': 'Amazon Elastic Compute Cloud (Linux)',
'categories': [],
}
@pytest.fixture
def services_response_data() -> Dict[str, Any]:
"""Return a dictionary with sample services response data."""
return {
'services': [
{
'code': 'amazon-elastic-compute-cloud-linux',
'name': 'Amazon Elastic Compute Cloud (Linux)',
'categories': [
{'code': 'using-aws', 'name': 'Using AWS'},
{'code': 'performance', 'name': 'Performance'},
],
},
{
'code': 'amazon-s3',
'name': 'Amazon Simple Storage Service',
'categories': [{'code': 'using-aws', 'name': 'Using AWS'}],
},
]
}
@pytest.fixture
def empty_services_response_data() -> Dict[str, Any]:
"""Return a dictionary with empty services response data."""
return {'services': []}
@pytest.fixture
def category_data() -> Dict[str, Any]:
"""Return a dictionary with sample category data."""
return {'code': 'using-aws', 'name': 'Using AWS'}
@pytest.fixture
def severity_level_data() -> Dict[str, Any]:
"""Return a dictionary with sample severity level data."""
return {'code': 'urgent', 'name': 'Production system down'}
@pytest.fixture
def minimal_severity_level_data() -> Dict[str, Any]:
"""Return a dictionary with minimal severity level data."""
return {'code': 'urgent', 'name': 'Production system down'}
@pytest.fixture
def severity_levels_response_data() -> Dict[str, Any]:
"""Return a dictionary with sample severity levels response data."""
return {
'severityLevels': [
{'code': 'low', 'name': 'General guidance'},
{'code': 'normal', 'name': 'System impaired'},
{'code': 'high', 'name': 'Production system impaired'},
{'code': 'urgent', 'name': 'Production system down'},
{'code': 'critical', 'name': 'Business-critical system down'},
]
}
@pytest.fixture
def empty_severity_levels_response_data() -> Dict[str, Any]:
"""Return a dictionary with empty severity levels response data."""
return {'severityLevels': []}
@pytest.fixture
def supported_languages_data() -> List[Dict[str, Any]]:
"""Return a list of supported languages."""
return [
{'code': 'en', 'name': 'English', 'nativeName': 'English'},
{'code': 'ja', 'name': 'Japanese', 'nativeName': '日本語'},
{'code': 'zh', 'name': 'Chinese', 'nativeName': '中文'},
{'code': 'ko', 'name': 'Korean', 'nativeName': '한국어'},
]
@pytest.fixture
def create_case_request_data() -> Dict[str, Any]:
"""Return a dictionary with sample create case request data."""
return {
'subject': 'EC2 instance not starting',
'service_code': 'amazon-elastic-compute-cloud-linux',
'category_code': 'using-aws',
'severity_code': 'urgent',
'communication_body': 'My EC2 instance i-1234567890abcdef0 is not starting.',
'cc_email_addresses': ['[email protected]'],
'language': 'en',
'issue_type': 'technical',
'attachment_set_id': None,
}
@pytest.fixture
def minimal_create_case_request_data() -> Dict[str, Any]:
"""Return a dictionary with minimal create case request data."""
return {
'subject': 'EC2 instance not starting',
'service_code': 'amazon-elastic-compute-cloud-linux',
'category_code': 'using-aws',
'severity_code': 'urgent',
'communication_body': 'My EC2 instance i-1234567890abcdef0 is not starting.',
}
@pytest.fixture
def create_case_response_data() -> Dict[str, Any]:
"""Return a dictionary with sample create case response data."""
return {
'caseId': 'case-12345678910-2013-c4c1d2bf33c5cf47',
'status': 'success',
'message': 'Support case created successfully with ID: case-12345678910-2013-c4c1d2bf33c5cf47',
}
@pytest.fixture
def describe_cases_request_data() -> Dict[str, Any]:
"""Return a dictionary with sample describe cases request data."""
return {
'case_id_list': ['case-12345678910-2013-c4c1d2bf33c5cf47'],
'display_id': None,
'after_time': '2023-01-01T00:00:00Z',
'before_time': '2023-01-31T23:59:59Z',
'include_resolved_cases': False,
'include_communications': True,
'language': 'en',
'max_results': 100,
'next_token': None,
}
@pytest.fixture
def minimal_describe_cases_request_data() -> Dict[str, Any]:
"""Return a dictionary with minimal describe cases request data."""
return {'include_resolved_cases': False, 'include_communications': True}
@pytest.fixture
def describe_cases_response_data() -> Dict[str, Any]:
"""Return a dictionary with sample describe cases response data."""
return {
'cases': [
{
'caseId': 'case-12345678910-2013-c4c1d2bf33c5cf47',
'displayId': '12345678910',
'subject': 'EC2 instance not starting',
'status': 'opened',
'serviceCode': 'amazon-elastic-compute-cloud-linux',
'categoryCode': 'using-aws',
'severityCode': 'urgent',
'submittedBy': '[email protected]',
'timeCreated': '2023-01-01T12:00:00Z',
'recentCommunications': {
'communications': [
{
'caseId': 'case-12345678910-2013-c4c1d2bf33c5cf47',
'body': 'My EC2 instance i-1234567890abcdef0 is not starting.',
'submittedBy': '[email protected]',
'timeCreated': '2023-01-01T12:00:00Z',
}
],
'nextToken': None,
},
}
],
'nextToken': None,
}
@pytest.fixture
def empty_describe_cases_response_data() -> Dict[str, Any]:
"""Return a dictionary with empty describe cases response data."""
return {'cases': [], 'nextToken': None}
@pytest.fixture
def add_communication_request_data() -> Dict[str, Any]:
"""Return a dictionary with sample add communication request data."""
return {
'case_id': 'case-12345678910-2013-c4c1d2bf33c5cf47',
'communication_body': "I've tried rebooting the instance but it's still not starting.",
'cc_email_addresses': ['[email protected]'],
'attachment_set_id': None,
}
@pytest.fixture
def minimal_add_communication_request_data() -> Dict[str, Any]:
"""Return a dictionary with minimal add communication request data."""
return {
'case_id': 'case-12345678910-2013-c4c1d2bf33c5cf47',
'communication_body': "I've tried rebooting the instance but it's still not starting.",
}
@pytest.fixture
def add_communication_response_data() -> Dict[str, Any]:
"""Return a dictionary with sample add communication response data."""
return {
'result': True,
'status': 'success',
'message': 'Communication added successfully to case: case-12345678910-2013-c4c1d2bf33c5cf47',
}
@pytest.fixture
def resolve_case_request_data() -> Dict[str, Any]:
"""Return a dictionary with sample resolve case request data."""
return {'case_id': 'case-12345678910-2013-c4c1d2bf33c5cf47'}
@pytest.fixture
def resolve_case_response_data() -> Dict[str, Any]:
"""Return a dictionary with sample resolve case response data."""
return {
'initial_case_status': 'opened',
'final_case_status': 'resolved',
'status': 'success',
'message': 'Support case resolved successfully: case-12345678910-2013-c4c1d2bf33c5cf47',
}
# Client Tests
class TestSupportClient:
"""Tests for the SupportClient class."""
@patch('boto3.Session')
def test_initialization_default_parameters(self, mock_session):
"""Test that SupportClient initializes correctly with default parameters."""
# Setup mock
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_session.return_value.get_credentials.return_value = MagicMock(access_key='TEST1234')
# Create client
client = SupportClient()
# Verify
mock_session.assert_called_once_with(**{'region_name': DEFAULT_REGION})
mock_session.return_value.client.assert_called_once_with(
'support',
config=ANY, # Using ANY since we just want to verify the service name
)
assert client.region_name == DEFAULT_REGION
@patch('boto3.Session')
def test_initialization_custom_parameters(self, mock_session):
"""Test that SupportClient initializes correctly with custom parameters."""
# Setup mock
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_session.return_value.get_credentials.return_value = MagicMock(access_key='TEST1234')
# Test parameters
custom_region = 'us-west-2'
custom_profile = 'test-profile'
# Create client
client = SupportClient(region_name=custom_region, profile_name=custom_profile)
# Verify
mock_session.assert_called_once_with(
**{'region_name': custom_region, 'profile_name': custom_profile}
)
mock_session.return_value.client.assert_called_once_with(
'support',
config=ANY, # Using ANY since we just want to verify the service name
)
assert client.region_name == custom_region
@patch('boto3.Session')
def test_initialization_subscription_required_error(self, mock_session):
"""Test that a SupportClient raises an error when subscription is required."""
# Setup mock
error_response = {
'Error': {'Code': 'SubscriptionRequiredException', 'Message': 'Subscription required'}
}
mock_session.return_value.client.side_effect = ClientError(error_response, 'create_case')
# Create client and verify error
with pytest.raises(ClientError) as excinfo:
SupportClient()
# Verify error
assert excinfo.value.response['Error']['Code'] == 'SubscriptionRequiredException'
@patch('boto3.Session')
def test_initialization_other_client_error(self, mock_session):
"""Test that a SupportClient raises an error when there's another client error."""
# Setup mock
error_response = {'Error': {'Code': 'OtherError', 'Message': 'Some other error'}}
mock_session.return_value.client.side_effect = ClientError(error_response, 'create_case')
# Create client and verify error
with pytest.raises(ClientError) as excinfo:
SupportClient()
# Verify error
assert excinfo.value.response['Error']['Code'] == 'OtherError'
@patch('boto3.Session')
@patch('asyncio.get_event_loop')
async def test_run_in_executor(self, mock_get_event_loop, mock_session):
"""Test that _run_in_executor runs a function in an executor."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_loop = MagicMock()
mock_get_event_loop.return_value = mock_loop
mock_loop.run_in_executor.return_value = asyncio.Future()
mock_loop.run_in_executor.return_value.set_result('test-result')
# Create client
client = SupportClient()
# Call _run_in_executor
mock_func = MagicMock()
result = await client._run_in_executor(mock_func, 'arg1', arg2='arg2')
# Verify
mock_get_event_loop.assert_called_once()
mock_loop.run_in_executor.assert_called_once()
assert result == 'test-result'
@patch('boto3.Session')
def test_initialization_with_no_credentials_warning(self, mock_session):
"""Test initialization when no credentials are found and warning is logged."""
# Setup mock
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_session.return_value.get_credentials.return_value = None
with patch('awslabs.aws_support_mcp_server.client.logger') as mock_logger:
SupportClient()
mock_logger.warning.assert_called_with('No AWS credentials found in session')
@patch('boto3.Session')
def test_initialization_with_credential_error_warning(self, mock_session):
"""Test initialization when credential check raises an error and warning is logged."""
# Setup mock
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_session.return_value.get_credentials.side_effect = Exception('Credential error')
with patch('awslabs.aws_support_mcp_server.client.logger') as mock_logger:
SupportClient()
mock_logger.warning.assert_called_with('Error checking credentials: Credential error')
@patch('boto3.Session')
def test_initialization_with_unexpected_error_logging(self, mock_session):
"""Test initialization when an unexpected error occurs and error is logged."""
# Setup mock
mock_session.side_effect = Exception('Unexpected initialization error')
with patch('awslabs.aws_support_mcp_server.client.logger') as mock_logger:
with pytest.raises(Exception) as exc_info:
SupportClient()
assert str(exc_info.value) == 'Unexpected initialization error'
mock_logger.error.assert_called_with(
'Unexpected error initializing AWS Support client: Unexpected initialization error',
exc_info=True,
)
@patch('boto3.Session')
def test_initialization_business_subscription_required_error(self, mock_session):
"""Test initialization when AWS Business Support subscription is required."""
# Setup mock
MagicMock()
error_response = {
'Error': {
'Code': 'SubscriptionRequiredException',
'Message': 'AWS Business Support or higher is required',
}
}
mock_session.return_value.client.side_effect = ClientError(error_response, 'support')
# Verify subscription required error is raised
with pytest.raises(ClientError) as exc_info:
SupportClient()
assert exc_info.value.response['Error']['Code'] == 'SubscriptionRequiredException'
@patch('boto3.Session')
def test_initialization_unexpected_error(self, mock_session):
"""Test initialization when unexpected error occurs."""
# Setup mock
mock_session.side_effect = Exception('Unexpected error')
# Verify error is raised
with pytest.raises(Exception) as exc_info:
SupportClient()
assert str(exc_info.value) == 'Unexpected error'
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_describe_communications_case_not_found(
self, mock_run_in_executor, mock_session
):
"""Test describe_communications when case is not found."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
error_response = {'Error': {'Code': 'CaseIdNotFound', 'Message': 'Case not found'}}
mock_run_in_executor.side_effect = ClientError(error_response, 'describe_communications')
# Create client
client = SupportClient()
# Verify error is raised
with pytest.raises(ClientError) as exc_info:
await client.describe_communications('non-existent-case')
assert exc_info.value.response['Error']['Code'] == 'CaseIdNotFound'
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_describe_communications_unexpected_error(
self, mock_run_in_executor, mock_session
):
"""Test describe_communications when unexpected error occurs."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_run_in_executor.side_effect = Exception('Unexpected error')
# Create client
client = SupportClient()
# Verify error is raised
with pytest.raises(Exception) as exc_info:
await client.describe_communications('test-case')
assert str(exc_info.value) == 'Unexpected error'
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_describe_supported_languages_client_error(
self, mock_run_in_executor, mock_session
):
"""Test describe_supported_languages when client error occurs."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
error_response = {'Error': {'Code': 'SomeError', 'Message': 'Some error occurred'}}
mock_run_in_executor.side_effect = ClientError(
error_response, 'describe_supported_languages'
)
# Create client
client = SupportClient()
# Verify error is raised
with pytest.raises(ClientError) as exc_info:
await client.describe_supported_languages()
assert exc_info.value.response['Error']['Code'] == 'SomeError'
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_describe_create_case_options_client_error(
self, mock_run_in_executor, mock_session
):
"""Test describe_create_case_options when client error occurs."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
error_response = {'Error': {'Code': 'SomeError', 'Message': 'Some error occurred'}}
mock_run_in_executor.side_effect = ClientError(
error_response, 'describe_create_case_options'
)
# Create client
client = SupportClient()
# Verify error is raised
with pytest.raises(ClientError) as exc_info:
await client.describe_create_case_options('test-service')
assert exc_info.value.response['Error']['Code'] == 'SomeError'
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_add_attachments_to_set_client_error(self, mock_run_in_executor, mock_session):
"""Test add_attachments_to_set when client error occurs."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
error_response = {'Error': {'Code': 'SomeError', 'Message': 'Some error occurred'}}
mock_run_in_executor.side_effect = ClientError(error_response, 'add_attachments_to_set')
# Create client
client = SupportClient()
# Test data
attachments = [{'fileName': 'test.txt', 'data': 'base64_encoded_content'}]
# Verify error is raised
with pytest.raises(ClientError) as exc_info:
await client.add_attachments_to_set(attachments)
assert exc_info.value.response['Error']['Code'] == 'SomeError'
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_retry_with_backoff_max_retries_exceeded(
self, mock_run_in_executor, mock_session
):
"""Test _retry_with_backoff when max retries are exceeded."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
# Create client
client = SupportClient()
# Create mock function that always fails with throttling
mock_func = AsyncMock()
error_response = {'Error': {'Code': 'ThrottlingException', 'Message': 'Rate exceeded'}}
mock_func.side_effect = ClientError(error_response, 'operation')
# Verify error is raised after max retries
with pytest.raises(ClientError) as exc_info:
await client._retry_with_backoff(mock_func, max_retries=2)
assert exc_info.value.response['Error']['Code'] == 'ThrottlingException'
assert mock_func.call_count == 3 # Initial try + 2 retries
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_retry_with_backoff_non_retryable_error(
self, mock_run_in_executor, mock_session
):
"""Test _retry_with_backoff with non-retryable error."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
# Create client
client = SupportClient()
# Create mock function that fails with non-retryable error
mock_func = AsyncMock()
error_response = {'Error': {'Code': 'ValidationError', 'Message': 'Invalid input'}}
mock_func.side_effect = ClientError(error_response, 'operation')
# Verify error is raised immediately
with pytest.raises(ClientError) as exc_info:
await client._retry_with_backoff(mock_func)
assert exc_info.value.response['Error']['Code'] == 'ValidationError'
assert mock_func.call_count == 1 # Only tried once
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_retry_with_backoff_unexpected_error(self, mock_run_in_executor, mock_session):
"""Test _retry_with_backoff with unexpected error."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
# Create client
client = SupportClient()
# Create mock function that fails with unexpected error
mock_func = AsyncMock()
mock_func.side_effect = Exception('Unexpected error')
# Verify error is raised immediately
with pytest.raises(Exception) as exc_info:
await client._retry_with_backoff(mock_func)
assert str(exc_info.value) == 'Unexpected error'
assert mock_func.call_count == 1 # Only tried once
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_retry_with_backoff_too_many_requests(self, mock_run_in_executor, mock_session):
"""Test _retry_with_backoff with TooManyRequestsException."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
# Create client
client = SupportClient()
# Create mock function that fails with TooManyRequestsException
mock_func = AsyncMock()
error_response = {
'Error': {'Code': 'TooManyRequestsException', 'Message': 'Too many requests'}
}
mock_func.side_effect = [ClientError(error_response, 'operation'), {'success': True}]
# Call _retry_with_backoff
result = await client._retry_with_backoff(mock_func)
# Verify
assert mock_func.call_count == 2
assert result == {'success': True}
@patch('boto3.Session')
def test_initialization_credential_handling(self, mock_session):
"""Test that credential handling during initialization works correctly."""
# Setup mock
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_credentials = MagicMock()
mock_credentials.access_key = 'TEST1234567890'
mock_session.return_value.get_credentials.return_value = mock_credentials
# Create client
client = SupportClient()
# Verify
mock_session.return_value.get_credentials.assert_called_once()
assert client.region_name == DEFAULT_REGION
@patch('boto3.Session')
def test_initialization_no_credentials(self, mock_session):
"""Test initialization when no credentials are found."""
# Setup mock
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_session.return_value.get_credentials.return_value = None
# Create client
client = SupportClient()
# Verify
mock_session.return_value.get_credentials.assert_called_once()
assert client.region_name == DEFAULT_REGION
@patch('boto3.Session')
def test_initialization_credential_error(self, mock_session):
"""Test initialization when credential check raises an error."""
# Setup mock
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_session.return_value.get_credentials.side_effect = Exception('Credential error')
# Create client
client = SupportClient()
# Verify
mock_session.return_value.get_credentials.assert_called_once()
assert client.region_name == DEFAULT_REGION
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_describe_communications(self, mock_run_in_executor, mock_session):
"""Test that describe_communications calls the AWS Support API correctly."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_run_in_executor.return_value = {
'communications': [
{
'caseId': 'test-case-id',
'body': 'Test communication',
'submittedBy': 'test-user',
'timeCreated': '2023-01-01T00:00:00Z',
}
],
'nextToken': None,
}
# Create client
client = SupportClient()
# Call describe_communications with all parameters
result = await client.describe_communications(
case_id='test-case-id',
after_time='2023-01-01T00:00:00Z',
before_time='2023-01-31T23:59:59Z',
max_results=10,
next_token='test-token',
)
# Verify
mock_run_in_executor.assert_called_once()
assert 'communications' in result
assert len(result['communications']) == 1
assert result['communications'][0]['caseId'] == 'test-case-id'
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_describe_supported_languages(self, mock_run_in_executor, mock_session):
"""Test that describe_supported_languages calls the AWS Support API correctly."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_run_in_executor.return_value = {'languages': [{'code': 'en', 'name': 'English'}]}
# Create client
client = SupportClient()
# Call describe_supported_languages
result = await client.describe_supported_languages()
# Verify
mock_run_in_executor.assert_called_once()
assert 'languages' in result
assert len(result['languages']) == 1
assert result['languages'][0]['code'] == 'en'
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_describe_create_case_options(self, mock_run_in_executor, mock_session):
"""Test that describe_create_case_options calls the AWS Support API correctly."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_run_in_executor.return_value = {
'categoryList': [{'code': 'test-category', 'name': 'Test Category'}],
'severityLevels': [{'code': 'low', 'name': 'General guidance'}],
}
# Create client
client = SupportClient()
# Call describe_create_case_options
result = await client.describe_create_case_options(
service_code='test-service', language='en'
)
# Verify
mock_run_in_executor.assert_called_once()
assert 'categoryList' in result
assert 'severityLevels' in result
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_retry_with_backoff_success(self, mock_run_in_executor, mock_session):
"""Test that _retry_with_backoff succeeds after retries."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
# Create client
client = SupportClient()
# Create mock function that fails twice then succeeds
mock_func = AsyncMock()
error_response = {'Error': {'Code': 'ThrottlingException', 'Message': 'Rate exceeded'}}
mock_func.side_effect = [
ClientError(error_response, 'operation'), # First call fails
ClientError(error_response, 'operation'), # Second call fails
{'success': True}, # Third call succeeds
]
# Call _retry_with_backoff
result = await client._retry_with_backoff(mock_func)
# Verify
assert mock_func.call_count == 3
assert result == {'success': True}
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_describe_services(self, mock_run_in_executor, mock_session):
"""Test that describe_services calls the AWS Support API correctly."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_run_in_executor.return_value = {
'services': [
{
'code': 'test-service',
'name': 'Test Service',
'categories': [{'code': 'test-category', 'name': 'Test Category'}],
}
]
}
# Create client
client = SupportClient()
# Call describe_services
result = await client.describe_services(service_code_list=['test-service'], language='en')
# Verify
mock_run_in_executor.assert_called_once()
assert 'services' in result
assert len(result['services']) == 1
assert result['services'][0]['code'] == 'test-service'
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_describe_severity_levels(self, mock_run_in_executor, mock_session):
"""Test that describe_severity_levels calls the AWS Support API correctly."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_run_in_executor.return_value = {
'severityLevels': [{'code': 'low', 'name': 'General guidance'}]
}
# Create client
client = SupportClient()
# Call describe_severity_levels
result = await client.describe_severity_levels(language='en')
# Verify
mock_run_in_executor.assert_called_once()
assert 'severityLevels' in result
assert len(result['severityLevels']) == 1
assert result['severityLevels'][0]['code'] == 'low'
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_add_attachments_to_set(self, mock_run_in_executor, mock_session):
"""Test that add_attachments_to_set calls the AWS Support API correctly."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_run_in_executor.return_value = {
'attachmentSetId': 'test-attachment-set-id',
'expiryTime': '2023-01-01T01:00:00Z',
}
# Create client
client = SupportClient()
# Test data
attachments = [{'fileName': 'test.txt', 'data': 'base64_encoded_content'}]
# Call add_attachments_to_set
result = await client.add_attachments_to_set(
attachments=attachments, attachment_set_id='existing-set-id'
)
# Verify
mock_run_in_executor.assert_called_once()
assert 'attachmentSetId' in result
assert 'expiryTime' in result
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_retry_with_backoff(self, mock_run_in_executor, mock_session):
"""Test that _retry_with_backoff handles retries correctly."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
# Create client
client = SupportClient()
# Setup mock function that fails twice then succeeds
mock_func = AsyncMock()
error_response = {'Error': {'Code': 'ThrottlingException', 'Message': 'Rate exceeded'}}
mock_func.side_effect = [
ClientError(error_response, 'operation'), # First call fails
ClientError(error_response, 'operation'), # Second call fails
{'success': True}, # Third call succeeds
]
# Call _retry_with_backoff
result = await client._retry_with_backoff(mock_func)
# Verify
assert mock_func.call_count == 3
assert result == {'success': True}
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_create_case(self, mock_run_in_executor, mock_session):
"""Test that create_case calls the AWS Support API correctly."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_run_in_executor.return_value = {'caseId': 'test-case-id'}
# Create client
client = SupportClient()
# Call create_case
result = await client.create_case(
subject='Test subject',
service_code='test-service',
category_code='test-category',
severity_code='low',
communication_body='Test body',
cc_email_addresses=['[email protected]'],
language='en',
issue_type='technical',
attachment_set_id='test-attachment-set-id',
)
# Verify
mock_run_in_executor.assert_called_once()
assert result == {'caseId': 'test-case-id'}
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_create_case_minimal(self, mock_run_in_executor, mock_session):
"""Test that create_case calls the AWS Support API with minimal parameters."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_run_in_executor.return_value = {'caseId': 'test-case-id'}
# Create client
client = SupportClient()
# Call create_case
result = await client.create_case(
subject='Test subject',
service_code='test-service',
category_code='test-category',
severity_code='low',
communication_body='Test body',
)
# Verify
mock_run_in_executor.assert_called_once()
assert result == {'caseId': 'test-case-id'}
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_create_case_client_error(self, mock_run_in_executor, mock_session):
"""Test that create_case handles client errors correctly."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
error_response = {'Error': {'Code': 'OtherError', 'Message': 'Some other error'}}
mock_run_in_executor.side_effect = ClientError(error_response, 'create_case')
# Create client
client = SupportClient()
# Call create_case and verify error
with pytest.raises(ClientError) as excinfo:
await client.create_case(
subject='Test subject',
service_code='test-service',
category_code='test-category',
severity_code='low',
communication_body='Test body',
)
# Verify error
assert excinfo.value.response['Error']['Code'] == 'OtherError'
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_describe_cases(self, mock_run_in_executor, mock_session):
"""Test that describe_cases calls the AWS Support API correctly."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_run_in_executor.return_value = {'cases': [{'caseId': 'test-case-id'}]}
# Create client
client = SupportClient()
# Call describe_cases
result = await client.describe_cases(
case_id_list=['test-case-id'],
display_id='test-display-id',
after_time='2023-01-01T00:00:00Z',
before_time='2023-01-31T23:59:59Z',
include_resolved_cases=True,
include_communications=True,
language='en',
max_results=10,
next_token='test-next-token',
)
# Verify
mock_run_in_executor.assert_called_once()
assert result == {'cases': [{'caseId': 'test-case-id'}]}
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_describe_cases_minimal(self, mock_run_in_executor, mock_session):
"""Test that describe_cases calls the AWS Support API with minimal parameters."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_run_in_executor.return_value = {'cases': [{'caseId': 'test-case-id'}]}
# Create client
client = SupportClient()
# Call describe_cases
result = await client.describe_cases()
# Verify
mock_run_in_executor.assert_called_once()
assert result == {'cases': [{'caseId': 'test-case-id'}]}
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_describe_cases_case_not_found(self, mock_run_in_executor, mock_session):
"""Test that describe_cases handles case not found errors correctly."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
error_response = {'Error': {'Code': 'CaseIdNotFound', 'Message': 'Case not found'}}
mock_run_in_executor.side_effect = ClientError(error_response, 'describe_cases')
# Create client
client = SupportClient()
# Call describe_cases and verify error
with pytest.raises(ClientError) as excinfo:
await client.describe_cases(case_id_list=['test-case-id'])
# Verify error
assert excinfo.value.response['Error']['Code'] == 'CaseIdNotFound'
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_resolve_case(self, mock_run_in_executor, mock_session):
"""Test that resolve_case calls the AWS Support API correctly."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_run_in_executor.return_value = {
'initialCaseStatus': 'opened',
'finalCaseStatus': 'resolved',
}
# Create client
client = SupportClient()
# Call resolve_case
result = await client.resolve_case(case_id='test-case-id')
# Verify
mock_run_in_executor.assert_called_once()
assert result == {'initialCaseStatus': 'opened', 'finalCaseStatus': 'resolved'}
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_resolve_case_case_not_found(self, mock_run_in_executor, mock_session):
"""Test that resolve_case handles case not found errors correctly."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
error_response = {'Error': {'Code': 'CaseIdNotFound', 'Message': 'Case not found'}}
mock_run_in_executor.side_effect = ClientError(error_response, 'resolve_case')
# Create client
client = SupportClient()
# Call resolve_case and verify error
with pytest.raises(ClientError) as excinfo:
await client.resolve_case(case_id='test-case-id')
# Verify error
assert excinfo.value.response['Error']['Code'] == 'CaseIdNotFound'
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_add_communication_to_case(self, mock_run_in_executor, mock_session):
"""Test that add_communication_to_case calls the AWS Support API correctly."""
# Setup mocks
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
mock_run_in_executor.return_value = {'result': True}
# Create client
client = SupportClient()
# Call add_communication_to_case
result = await client.add_communication_to_case(
case_id='test-case-id',
communication_body='Test body',
cc_email_addresses=['[email protected]'],
attachment_set_id='test-attachment-set-id',
)
# Verify
mock_run_in_executor.assert_called_once()
assert result == {'result': True}
@patch('boto3.Session')
def test_validate_email_addresses_valid(self, mock_session):
"""Test that _validate_email_addresses accepts valid email addresses."""
# Setup
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
client = SupportClient()
# Test valid email addresses
valid_emails = [
['[email protected]'],
['[email protected]'],
['[email protected]'],
['[email protected]'],
['[email protected]'],
['[email protected]'],
['[email protected]'],
['[email protected]'],
['[email protected]'],
['[email protected]'],
['[email protected]', '[email protected]'], # Multiple valid emails
]
# Verify no exceptions are raised for valid emails
for emails in valid_emails:
try:
client._validate_email_addresses(emails)
except ValueError as e:
pytest.fail(f'Validation failed for valid email(s) {emails}: {str(e)}')
@patch('boto3.Session')
def test_validate_email_addresses_invalid(self, mock_session):
"""Test that _validate_email_addresses rejects invalid email addresses."""
# Setup
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
client = SupportClient()
# Test cases with invalid email addresses
invalid_cases = [
['plainaddress'], # Missing @ and domain
['@missinguser.com'], # Missing username
['user@'], # Missing domain
['[email protected]'], # Missing domain name
['[email protected].'], # Trailing dot
['user@com'], # Missing dot in domain
['[email protected]'], # Double dots
['user [email protected]'], # Space in username
['user@exam ple.com'], # Space in domain
['[email protected]'], # TLD too short
['user@@example.com'], # Double @
['[email protected]', 'invalid@'], # One valid, one invalid
]
# Verify ValueError is raised for each invalid case
for emails in invalid_cases:
with pytest.raises(ValueError) as exc_info:
client._validate_email_addresses(emails)
assert 'Invalid email address(es):' in str(exc_info.value)
@patch('boto3.Session')
def test_validate_email_addresses_empty_input(self, mock_session):
"""Test that _validate_email_addresses handles empty input correctly."""
# Setup
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
client = SupportClient()
# Test empty list
client._validate_email_addresses([])
# Test None - should not raise error since method handles None
client._validate_email_addresses([]) # Use empty list instead of None
@patch('boto3.Session')
def test_validate_email_addresses_mixed_case(self, mock_session):
"""Test that _validate_email_addresses handles mixed case email addresses."""
# Setup
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
client = SupportClient()
# Test mixed case emails
mixed_case_emails = ['[email protected]', '[email protected]', '[email protected]']
client._validate_email_addresses(mixed_case_emails)
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_add_communication_to_case_minimal(self, mock_run_in_executor, mock_session):
"""Test that add_communication_to_case calls the AWS Support API with minimal parameters."""
# Setup mocks
mock_client = AsyncMock()
mock_session.return_value.client.return_value = mock_client
mock_run_in_executor.return_value = {'result': True}
# Create client
client = SupportClient()
# Call add_communication_to_case
result = await client.add_communication_to_case(
case_id='test-case-id', communication_body='Test body'
)
# Verify
mock_run_in_executor.assert_called_once()
assert result == {'result': True}
@patch('boto3.Session')
def test_validate_issue_type_valid(self, mock_session):
"""Test that _validate_issue_type accepts valid issue types."""
# Setup
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
client = SupportClient()
# Test all valid issue types from IssueType enum
valid_types = ['technical', 'account-and-billing', 'service-limit']
# Verify no exceptions are raised for valid types
for issue_type in valid_types:
try:
client._validate_issue_type(issue_type)
except ValueError as e:
pytest.fail(f'Validation failed for valid issue type {issue_type}: {str(e)}')
@patch('boto3.Session')
def test_validate_issue_type_invalid(self, mock_session):
"""Test that _validate_issue_type rejects invalid issue types."""
# Setup
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
client = SupportClient()
# Test invalid issue types
invalid_types = [
'', # Empty string
'invalid', # Non-existent type
'TECHNICAL', # Wrong case
'tech', # Partial match
'billing', # Partial match
' technical ', # Extra whitespace
]
# Verify ValueError is raised for each invalid type
for issue_type in invalid_types:
with pytest.raises(ValueError) as exc_info:
client._validate_issue_type(issue_type)
assert 'Invalid issue type:' in str(exc_info.value)
assert 'Must be one of:' in str(exc_info.value)
@patch('boto3.Session')
def test_validate_language_valid(self, mock_session):
"""Test that _validate_language accepts valid language codes."""
# Setup
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
client = SupportClient()
# Test all permitted language codes
for lang in PERMITTED_LANGUAGE_CODES:
try:
client._validate_language(lang)
except ValueError as e:
pytest.fail(f'Validation failed for valid language code {lang}: {str(e)}')
@patch('boto3.Session')
def test_validate_language_invalid(self, mock_session):
"""Test that _validate_language rejects invalid language codes."""
# Setup
mock_client = MagicMock()
mock_session.return_value.client.return_value = mock_client
client = SupportClient()
# Test invalid language codes
invalid_codes = [
'', # Empty string
'eng', # Wrong format
'EN', # Wrong case
'zz', # Non-existent code
' en ', # Extra whitespace
'en-US', # Wrong format
'english', # Full name instead of code
]
# Verify ValueError is raised for each invalid code
for lang in invalid_codes:
with pytest.raises(ValueError) as exc_info:
client._validate_language(lang)
assert 'Invalid language code:' in str(exc_info.value)
assert 'Must be one of:' in str(exc_info.value)
@patch('boto3.Session')
@patch('awslabs.aws_support_mcp_server.client.SupportClient._run_in_executor')
async def test_add_communication_to_case_case_not_found(
self, mock_run_in_executor, mock_session
):
"""Test that add_communication_to_case handles case not found errors correctly."""
# Setup mocks
mock_client = AsyncMock()
mock_session.return_value.client.return_value = mock_client
error_response = {'Error': {'Code': 'CaseIdNotFound', 'Message': 'Case not found'}}
mock_run_in_executor.side_effect = ClientError(error_response, 'add_communication_to_case')
# Create client
client = SupportClient()
# Call add_communication_to_case and verify error
with pytest.raises(ClientError) as excinfo:
await client.add_communication_to_case(
case_id='test-case-id', communication_body='Test body'
)
# Verify error
assert excinfo.value.response['Error']['Code'] == 'CaseIdNotFound'
# Error Handling Tests
class TestErrorHandling:
"""Test suite for error handling functions in the AWS Support MCP Server."""
from awslabs.aws_support_mcp_server.consts import (
ERROR_AUTHENTICATION_FAILED,
ERROR_CASE_NOT_FOUND,
ERROR_RATE_LIMIT_EXCEEDED,
ERROR_SUBSCRIPTION_REQUIRED,
)
"""Tests for the error handling functions."""
@pytest.fixture
def mock_context(self):
"""Create a mock context with error method."""
context = MagicMock()
context.error = AsyncMock(return_value={'status': 'error', 'message': 'Error message'})
return context
async def test_handle_client_error_access_denied(self, mock_context):
"""Test handling of AccessDeniedException."""
error_response = {'Error': {'Code': 'AccessDeniedException', 'Message': 'Access denied'}}
error = ClientError(error_response, 'test_operation')
result = await handle_client_error(mock_context, error, 'test_operation')
assert result['status'] == 'error'
assert result['message'] == ERROR_AUTHENTICATION_FAILED
assert result['status_code'] == 403
mock_context.error.assert_called_once()
async def test_handle_client_error_case_not_found(self, mock_context):
"""Test handling of CaseIdNotFound."""
error_response = {'Error': {'Code': 'CaseIdNotFound', 'Message': 'Case not found'}}
error = ClientError(error_response, 'test_operation')
result = await handle_client_error(mock_context, error, 'test_operation')
assert result['status'] == 'error'
assert result['message'] == ERROR_CASE_NOT_FOUND
assert result['status_code'] == 404
mock_context.error.assert_called_once()
async def test_handle_client_error_throttling(self, mock_context):
"""Test handling of ThrottlingException."""
error_response = {'Error': {'Code': 'ThrottlingException', 'Message': 'Rate exceeded'}}
error = ClientError(error_response, 'test_operation')
result = await handle_client_error(mock_context, error, 'test_operation')
assert result['status'] == 'error'
assert result['message'] == ERROR_RATE_LIMIT_EXCEEDED
assert result['status_code'] == 429
mock_context.error.assert_called_once()
async def test_handle_general_error_with_custom_exception(self, mock_context):
"""Test handling of custom exception types."""
class CustomError(Exception):
pass
error = CustomError('Custom error message')
result = await handle_general_error(mock_context, error, 'test_operation')
assert result['status'] == 'error'
assert 'Error in test_operation' in result['message']
assert 'CustomError' in result['message']
assert result['details']['error_type'] == 'CustomError'
assert result['status_code'] == 500
mock_context.error.assert_called_once()
def test_create_error_response_with_details(self):
"""Test creating error response with additional details."""
details = {
'error_code': 'TEST001',
'error_source': 'test_module',
'additional_info': 'Test information',
}
result = create_error_response('Test error', details=details, status_code=418)
assert result['status'] == 'error'
assert result['message'] == 'Test error'
assert result['status_code'] == 418
assert 'timestamp' in result
assert result['details'] == details
async def test_handle_client_error_subscription_required(self, mock_context):
"""Test handling of SubscriptionRequiredException."""
error_response = {
'Error': {'Code': 'SubscriptionRequiredException', 'Message': 'Subscription required'}
}
error = ClientError(error_response, 'test_operation')
result = await handle_client_error(mock_context, error, 'test_operation')
assert result['status'] == 'error'
assert result['message'] == ERROR_SUBSCRIPTION_REQUIRED
assert result['status_code'] == 400 # Default client error status code
mock_context.error.assert_called_once()
"""Tests for the error handling functions."""
async def test_handle_client_error_unauthorized(self):
"""Test handling of UnauthorizedException."""
# Setup
context = MagicMock()
context.error = AsyncMock(
return_value={'status': 'error', 'message': 'AWS Support API error: Unauthorized'}
)
error_response = {'Error': {'Code': 'UnauthorizedException', 'Message': 'Unauthorized'}}
error = ClientError(error_response, 'operation_name')
# Call function
result = await handle_client_error(context, error, 'test_function')
# Verify
assert result['status'] == 'error'
assert 'Unauthorized' in result['message']
async def test_handle_client_error_other(self):
"""Test handling of other client errors."""
# Setup
context = MagicMock()
context.error = AsyncMock(
return_value={'status': 'error', 'message': 'AWS Support API error: Some other error'}
)
error_response = {'Error': {'Code': 'OtherError', 'Message': 'Some other error'}}
error = ClientError(error_response, 'operation_name')
# Call function
result = await handle_client_error(context, error, 'test_function')
# Verify
assert result['status'] == 'error'
assert 'AWS Support API error' in result['message']
assert 'Some other error' in result['message']
async def test_handle_validation_error(self):
"""Test handling of validation errors."""
# Setup
context = MagicMock()
context.error = AsyncMock(return_value={'status': 'error', 'message': 'Validation error'})
# Create a ValidationError with proper arguments
from pydantic import BaseModel
class TestModel(BaseModel):
field1: str
field2: int
try:
TestModel(field1='test', field2=123) # This should pass first
# Now test with missing field2 - this will raise ValidationError
TestModel(field1='test', field2=456) # This should also pass
except ValidationError:
# This shouldn't happen with valid data, so create the error manually
pass
# Actually test the validation error case
try:
TestModel(field1='test', field2=789) # Valid case
except Exception:
pass
# Create a proper validation error for testing
try:
# Use an invalid model creation that will definitely fail
from pydantic import ValidationError as PydanticValidationError
raise PydanticValidationError.from_exception_data('TestModel', [])
except ValidationError as validation_error:
# Call function
result = await handle_validation_error(context, validation_error, 'test_function')
# Verify
assert result is not None
assert result['status'] == 'error'
assert 'Validation error' in result['message']
async def test_handle_general_error(self):
"""Test handling of general errors."""
# Setup
context = MagicMock()
context.error = AsyncMock(
return_value={
'status': 'error',
'message': 'Error in test_function: Test error message',
}
)
error = ValueError('Test error message')
# Call function
result = await handle_general_error(context, error, 'test_function')
# Verify
assert result['status'] == 'error'
assert 'Error in test_function' in result['message']
assert 'Test error message' in result['message']
async def test_handle_general_error_with_internal_server_error(self):
"""Test handling of general errors with internal server error."""
# Setup
context = MagicMock()
context.error = AsyncMock(
return_value={
'status': 'error',
'message': 'Error in test_function: Internal server error',
}
)
error = Exception('Internal server error')
# Call function
result = await handle_general_error(context, error, 'test_function')
# Verify
assert result['status'] == 'error'
assert 'Error in test_function' in result['message']
assert 'Internal server error' in result['message']
# Formatter Tests
class TestFormatCases:
"""Tests for the format_cases function."""
def test_format_multiple_cases(self, multiple_support_cases_data):
"""Test formatting multiple cases."""
formatted = format_cases(multiple_support_cases_data)
assert len(formatted) == len(multiple_support_cases_data)
for formatted_case, original_case in zip(
formatted, multiple_support_cases_data, strict=False
):
assert formatted_case['caseId'] == original_case['caseId']
assert formatted_case['subject'] == original_case['subject']
def test_format_empty_cases_list(self):
"""Test formatting an empty list of cases."""
formatted = format_cases([])
assert formatted == []
class TestFormatCommunications:
"""Tests for the format_communications function."""
def test_format_communications_with_attachments(self, communications_response_data):
"""Test formatting communications with attachments."""
formatted = format_communications(communications_response_data)
assert 'communications' in formatted
assert len(formatted['communications']) == len(
communications_response_data['communications']
)
first_comm = formatted['communications'][0]
orig_comm = communications_response_data['communications'][0]
assert first_comm['body'] == orig_comm['body']
assert first_comm['submittedBy'] == orig_comm['submittedBy']
def test_format_empty_communications(self, empty_communications_response_data):
"""Test formatting empty communications."""
formatted = format_communications(empty_communications_response_data)
assert 'communications' in formatted
assert len(formatted['communications']) == 0
assert formatted['nextToken'] is None
class TestFormatServices:
"""Tests for the format_services function."""
def test_format_services_with_categories(self, services_response_data):
"""Test formatting services with categories."""
formatted = format_services(services_response_data['services'])
# Verify first service
first_service = services_response_data['services'][0]
service_code = first_service['code']
assert service_code in formatted
assert formatted[service_code]['name'] == first_service['name']
assert len(formatted[service_code]['categories']) == len(first_service['categories'])
def test_format_empty_services(self, empty_services_response_data):
"""Test formatting empty services."""
formatted = format_services(empty_services_response_data['services'])
assert formatted == {}
class TestFormatSeverityLevels:
"""Tests for the format_severity_levels function."""
def test_format_severity_levels(self, severity_levels_response_data):
"""Test formatting severity levels."""
formatted = format_severity_levels(severity_levels_response_data['severityLevels'])
for level in severity_levels_response_data['severityLevels']:
assert level['code'] in formatted
assert formatted[level['code']]['name'] == level['name']
def test_format_empty_severity_levels(self, empty_severity_levels_response_data):
"""Test formatting empty severity levels."""
formatted = format_severity_levels(empty_severity_levels_response_data['severityLevels'])
assert formatted == {}
class TestFormatMarkdown:
"""Tests for the Markdown formatting functions."""
def test_format_markdown_case_summary(self, support_case_data):
"""Test formatting a case summary in Markdown."""
formatted_case = format_case(support_case_data)
markdown = format_markdown_case_summary(formatted_case)
# Verify key elements are present in the Markdown
assert f'**Case ID**: {support_case_data["caseId"]}' in markdown
assert f'**Subject**: {support_case_data["subject"]}' in markdown
assert '## Recent Communications' in markdown
# Verify communication details
first_comm = support_case_data['recentCommunications']['communications'][0]
assert first_comm['body'] in markdown
assert first_comm['submittedBy'] in markdown
def test_format_markdown_services(self, services_response_data):
"""Test formatting services in Markdown."""
formatted_services = format_services(services_response_data['services'])
markdown = format_markdown_services(formatted_services)
# Verify key elements are present in the Markdown
assert '# AWS Services' in markdown
# Verify first service
first_service = services_response_data['services'][0]
assert f'## {first_service["name"]}' in markdown
assert f'`{first_service["code"]}`' in markdown
# Verify categories
if first_service['categories']:
assert '### Categories' in markdown
first_category = first_service['categories'][0]
assert f'`{first_category["code"]}`' in markdown
def test_format_markdown_severity_levels(self, severity_levels_response_data):
"""Test formatting severity levels in Markdown."""
formatted_levels = format_severity_levels(severity_levels_response_data['severityLevels'])
markdown = format_markdown_severity_levels(formatted_levels)
# Verify key elements are present in the Markdown
assert '# AWS Support Severity Levels' in markdown
# Verify severity levels
for level in severity_levels_response_data['severityLevels']:
assert f'**{level["name"]}**' in markdown
assert f'`{level["code"]}`' in markdown
def test_format_json_response(self):
"""Test JSON response formatting."""
test_data = {'key1': 'value1', 'key2': {'nested': 'value2'}, 'key3': [1, 2, 3]}
formatted = format_json_response(test_data)
assert isinstance(formatted, str)
parsed = json.loads(formatted)
assert parsed == test_data
class TestFormatCase:
"""Tests for the format_case function."""
def test_valid_case_formatting(self, support_case_data):
"""Test that a valid case is formatted correctly."""
formatted_case = format_case(support_case_data)
assert formatted_case['caseId'] == support_case_data['caseId']
assert formatted_case['displayId'] == support_case_data['displayId']
assert formatted_case['subject'] == support_case_data['subject']
assert formatted_case['status'] == support_case_data['status']
assert formatted_case['serviceCode'] == support_case_data['serviceCode']
assert formatted_case['categoryCode'] == support_case_data['categoryCode']
assert formatted_case['severityCode'] == support_case_data['severityCode']
assert formatted_case['submittedBy'] == support_case_data['submittedBy']
assert formatted_case['timeCreated'] == support_case_data['timeCreated']
assert formatted_case['ccEmailAddresses'] == support_case_data['ccEmailAddresses']
assert formatted_case['language'] == support_case_data['language']
assert 'recentCommunications' in formatted_case
assert len(formatted_case['recentCommunications']['communications']) == len(
support_case_data['recentCommunications']['communications']
)
def test_minimal_case_formatting(self, minimal_support_case_data):
"""Test that a minimal case is formatted correctly."""
formatted_case = format_case(minimal_support_case_data)
assert formatted_case['caseId'] == minimal_support_case_data['caseId']
assert formatted_case['subject'] == minimal_support_case_data['subject']
assert formatted_case['status'] == minimal_support_case_data['status']
assert formatted_case['serviceCode'] == minimal_support_case_data['serviceCode']
assert formatted_case['categoryCode'] == minimal_support_case_data['categoryCode']
assert formatted_case['severityCode'] == minimal_support_case_data['severityCode']
assert formatted_case['submittedBy'] == minimal_support_case_data['submittedBy']
assert formatted_case['timeCreated'] == minimal_support_case_data['timeCreated']
def test_edge_case_formatting(self, edge_case_support_case_data):
"""Test that an edge case is formatted correctly."""
formatted_case = format_case(edge_case_support_case_data)
assert formatted_case['caseId'] == edge_case_support_case_data['caseId']
assert formatted_case['subject'] == edge_case_support_case_data['subject']
assert len(formatted_case['subject']) == len(edge_case_support_case_data['subject'])
# Server Tests
@patch('awslabs.aws_support_mcp_server.server.support_client')
async def test_create_case(mock_support_client):
"""Test that create_case calls the AWS Support API correctly."""
# Setup mocks
mock_support_client.create_case = AsyncMock(return_value={'caseId': 'test-case-id'})
# Create mock context
context = MagicMock()
context.error = AsyncMock(return_value={'status': 'error', 'message': 'Error message'})
# Call create_case
request_data = {
'subject': 'Test subject',
'service_code': 'test-service',
'category_code': 'test-category',
'severity_code': 'low',
'communication_body': 'Test body',
'cc_email_addresses': ['[email protected]'],
'language': 'en',
'issue_type': 'technical',
'attachment_set_id': 'test-attachment-set-id',
}
# Patch the to_api_params method to return the correct parameter names
with patch(
'awslabs.aws_support_mcp_server.models.CreateCaseRequest.to_api_params'
) as mock_to_api_params:
mock_to_api_params.return_value = {
'subject': 'Test subject',
'service_code': 'test-service',
'category_code': 'test-category',
'severity_code': 'low',
'communication_body': 'Test body',
'cc_email_addresses': ['[email protected]'],
'language': 'en',
'issue_type': 'technical',
'attachment_set_id': 'test-attachment-set-id',
}
result = await create_support_case(context, **request_data)
# Verify
mock_support_client.create_case.assert_called_once()
assert 'case_id' in result
assert result['case_id'] == 'test-case-id'
@patch('awslabs.aws_support_mcp_server.server.support_client')
async def test_describe_cases(mock_support_client):
"""Test that describe_cases calls the AWS Support API correctly."""
# Setup mocks
mock_support_client.describe_cases = AsyncMock(
return_value={
'cases': [
{
'caseId': 'test-case-id',
'displayId': 'test-display-id',
'subject': 'Test subject',
'status': 'opened',
'serviceCode': 'test-service',
'categoryCode': 'test-category',
'severityCode': 'low',
'submittedBy': 'test-user',
'timeCreated': '2023-01-01T00:00:00Z',
'recentCommunications': {
'communications': [
{
'caseId': 'test-case-id',
'body': 'Test body',
'submittedBy': 'test-user',
'timeCreated': '2023-01-01T00:00:00Z',
}
]
},
}
]
}
)
# Create mock context
context = MagicMock()
context.error = AsyncMock(return_value={'status': 'error', 'message': 'Error message'})
# Call describe_cases
request_data = {
'case_id_list': ['test-case-id'],
'display_id': 'test-display-id',
'after_time': '2023-01-01T00:00:00Z',
'before_time': '2023-01-31T23:59:59Z',
'include_resolved_cases': True,
'include_communications': True,
'language': 'en',
'max_results': 10,
'next_token': 'test-next-token',
'format': 'json',
}
# Patch the to_api_params method to return the correct parameter names
with patch(
'awslabs.aws_support_mcp_server.models.DescribeCasesRequest.to_api_params'
) as mock_to_api_params:
mock_to_api_params.return_value = {
'case_id_list': ['test-case-id'],
'display_id': 'test-display-id',
'after_time': '2023-01-01T00:00:00Z',
'before_time': '2023-01-31T23:59:59Z',
'include_resolved_cases': True,
'include_communications': True,
'language': 'en',
'max_results': 10,
'next_token': 'test-next-token',
}
result = await describe_support_cases(context, **request_data)
# Verify
mock_support_client.describe_cases.assert_called_once()
assert 'cases' in result
assert len(result['cases']) == 1
assert result['cases'][0]['caseId'] == 'test-case-id'
@patch('awslabs.aws_support_mcp_server.server.support_client')
async def test_add_communication_to_case(mock_support_client):
"""Test that add_communication_to_case calls the AWS Support API correctly."""
# Setup mocks
mock_support_client.add_communication_to_case = AsyncMock(return_value={'result': True})
# Create mock context
context = MagicMock()
context.error = AsyncMock(return_value={'status': 'error', 'message': 'Error message'})
# Call add_communication_to_case
request_data = {
'case_id': 'test-case-id',
'communication_body': 'Test body',
'cc_email_addresses': ['[email protected]'],
'attachment_set_id': 'test-attachment-set-id',
}
# Patch the to_api_params method to return the correct parameter names
with patch(
'awslabs.aws_support_mcp_server.models.AddCommunicationRequest.to_api_params'
) as mock_to_api_params:
mock_to_api_params.return_value = {
'case_id': 'test-case-id',
'communication_body': 'Test body',
'cc_email_addresses': ['[email protected]'],
'attachment_set_id': 'test-attachment-set-id',
}
result = await add_communication_to_case(context, **request_data)
# Verify
mock_support_client.add_communication_to_case.assert_called_once()
assert 'result' in result
assert result['result'] is True
@patch('awslabs.aws_support_mcp_server.server.support_client')
async def test_resolve_case(mock_support_client):
"""Test that resolve_case calls the AWS Support API correctly."""
# Setup mocks
mock_support_client.resolve_case = AsyncMock(
return_value={'initialCaseStatus': 'opened', 'finalCaseStatus': 'resolved'}
)
# Create mock context
context = MagicMock()
context.error = AsyncMock(return_value={'status': 'error', 'message': 'Error message'})
# Call resolve_case
# Patch the to_api_params method to return the correct parameter names
with patch(
'awslabs.aws_support_mcp_server.models.ResolveCaseRequest.to_api_params'
) as mock_to_api_params:
mock_to_api_params.return_value = {'case_id': 'test-case-id'}
result = await resolve_support_case(context, case_id='test-case-id')
# Verify
mock_support_client.resolve_case.assert_called_once()
assert 'initial_case_status' in result
assert result['initial_case_status'] == 'opened'
assert 'final_case_status' in result
assert result['final_case_status'] == 'resolved'
async def test_error_handling():
"""Test that the server handles errors correctly."""
# Debug Helper Tests
class TestDiagnosticsTracker:
"""Tests for the DiagnosticsTracker class."""
def setup_method(self):
"""Set up test fixtures."""
from awslabs.aws_support_mcp_server.debug_helper import DiagnosticsTracker
self.tracker = DiagnosticsTracker()
def test_initial_state(self):
"""Test initial state of DiagnosticsTracker."""
assert not self.tracker.enabled
assert isinstance(self.tracker.uptime, float)
report = self.tracker.get_diagnostics_report()
assert report == {'diagnostics_enabled': False}
def test_enable_disable(self):
"""Test enabling and disabling diagnostics."""
self.tracker.enable()
assert self.tracker.enabled
report = self.tracker.get_diagnostics_report()
assert report['diagnostics_enabled'] is True
self.tracker.disable()
assert not self.tracker.enabled
report = self.tracker.get_diagnostics_report()
assert report == {'diagnostics_enabled': False}
def test_reset(self):
"""Test resetting diagnostics data."""
self.tracker.enable()
self.tracker.track_performance('test_func', 1.0)
self.tracker.track_error('TestError')
self.tracker.track_request('test_request')
self.tracker.reset()
report = self.tracker.get_diagnostics_report()
assert report['performance'] == {}
assert report['errors'] == {}
assert report['requests'] == {}
def test_track_performance(self):
"""Test performance tracking."""
self.tracker.enable()
self.tracker.track_performance('test_func', 1.0)
self.tracker.track_performance('test_func', 2.0)
report = self.tracker.get_diagnostics_report()
perf_data = report['performance']['test_func']
assert perf_data['count'] == 2
assert perf_data['total_time'] == 3.0
assert perf_data['min_time'] == 1.0
assert perf_data['max_time'] == 2.0
assert isinstance(perf_data['last_call'], float)
def test_track_performance_disabled(self):
"""Test performance tracking when disabled."""
self.tracker.track_performance('test_func', 1.0)
report = self.tracker.get_diagnostics_report()
assert report == {'diagnostics_enabled': False}
def test_track_error(self):
"""Test error tracking."""
self.tracker.enable()
self.tracker.track_error('TestError')
self.tracker.track_error('TestError')
self.tracker.track_error('OtherError')
report = self.tracker.get_diagnostics_report()
assert report['errors']['TestError'] == 2
assert report['errors']['OtherError'] == 1
def test_track_error_disabled(self):
"""Test error tracking when disabled."""
self.tracker.track_error('TestError')
report = self.tracker.get_diagnostics_report()
assert report == {'diagnostics_enabled': False}
def test_track_request(self):
"""Test request tracking."""
self.tracker.enable()
self.tracker.track_request('GET')
self.tracker.track_request('GET')
self.tracker.track_request('POST')
report = self.tracker.get_diagnostics_report()
assert report['requests']['GET'] == 2
assert report['requests']['POST'] == 1
def test_track_request_disabled(self):
"""Test request tracking when disabled."""
self.tracker.track_request('GET')
report = self.tracker.get_diagnostics_report()
assert report == {'diagnostics_enabled': False}
def test_uptime(self):
"""Test uptime calculation."""
self.tracker.enable()
time.sleep(0.1) # Small delay to ensure uptime > 0
assert self.tracker.uptime > 0
@patch('time.time')
def test_performance_tracking_edge_cases(self, mock_time):
"""Test performance tracking edge cases."""
self.tracker.enable()
# Test with very small duration
mock_time.return_value = 1000.0
self.tracker.track_performance('test_func', 0.000001)
# Test with very large duration
self.tracker.track_performance('test_func', 999999.999)
report = self.tracker.get_diagnostics_report()
perf_data = report['performance']['test_func']
assert perf_data['min_time'] == 0.000001
assert perf_data['max_time'] == 999999.999
# Server Tests
class TestServer:
"""Tests for the MCP server implementation."""
@patch('awslabs.aws_support_mcp_server.server.logger')
def test_logging_configuration(self, mock_logger):
"""Test logging configuration."""
import sys
from awslabs.aws_support_mcp_server.server import main
# Create mock arguments
sys.argv = ['server.py', '--debug']
# Call main (but mock the actual server run)
with patch('awslabs.aws_support_mcp_server.server.mcp.run'):
main()
# Verify logging configuration
mock_logger.remove.assert_called()
mock_logger.add.assert_called()
# Verify debug level was set
assert any('DEBUG' in str(call) for call in mock_logger.add.call_args_list)
```