This is page 378 of 384. Use http://codebase.md/awslabs/mcp?lines=false&page={x} to view the full context.
# Directory Structure
```
├── .devcontainer
│ └── devcontainer.json
├── .github
│ ├── actions
│ │ ├── build-and-push-container-image
│ │ │ └── action.yml
│ │ └── clear-space-ubuntu-latest-agressively
│ │ └── action.yml
│ ├── codecov.yml
│ ├── CODEOWNERS
│ ├── dependabot.yml
│ ├── ISSUE_TEMPLATE
│ │ ├── bug_report.yml
│ │ ├── documentation.yml
│ │ ├── feature_request.yml
│ │ ├── rfc.yml
│ │ └── support_awslabs_mcp_servers.yml
│ ├── pull_request_template.md
│ ├── SECURITY
│ ├── SUPPORT
│ └── workflows
│ ├── aws-api-mcp-upgrade-version.yml
│ ├── bandit-requirements.txt
│ ├── bandit.yml
│ ├── cfn_nag.yml
│ ├── check-gh-pages-builds.yml
│ ├── check-license-header-hash.txt
│ ├── check-license-header.json
│ ├── check-license-header.yml
│ ├── checkov.yml
│ ├── codeql.yml
│ ├── dependency-review-action.yml
│ ├── detect-secrets-requirements.txt
│ ├── gh-pages.yml
│ ├── merge-prevention.yml
│ ├── powershell.yml
│ ├── pre-commit-requirements.txt
│ ├── pre-commit.yml
│ ├── pull-request-lint.yml
│ ├── python.yml
│ ├── RELEASE_INSTRUCTIONS.md
│ ├── release-initiate-branch.yml
│ ├── release-merge-tag.yml
│ ├── release.py
│ ├── release.yml
│ ├── scanners.yml
│ ├── scorecard-analysis.yml
│ ├── semgrep-requirements.txt
│ ├── semgrep.yml
│ ├── stale.yml
│ ├── trivy.yml
│ └── typescript.yml
├── .gitignore
├── .pre-commit-config.yaml
├── .python-version
├── .ruff.toml
├── .secrets.baseline
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── DESIGN_GUIDELINES.md
├── DEVELOPER_GUIDE.md
├── docs
│ └── images
│ └── root-readme
│ ├── cline-api-provider-filled.png
│ ├── cline-chat-interface.png
│ ├── cline-custom-instructions.png
│ ├── cline-select-aws-profile.png
│ ├── cline-select-bedrock.png
│ ├── configure-mcp-servers.png
│ ├── install-cline-extension.png
│ ├── mcp-servers-installed.png
│ └── select-mcp-servers.png
├── docusaurus
│ ├── .gitignore
│ ├── docs
│ │ ├── installation.md
│ │ ├── intro.md
│ │ ├── samples
│ │ │ ├── index.md
│ │ │ ├── mcp-integration-with-kb.md
│ │ │ ├── mcp-integration-with-nova-canvas.md
│ │ │ └── stepfunctions-tool-mcp-server.md
│ │ ├── servers
│ │ │ ├── amazon-bedrock-agentcore-mcp-server.md
│ │ │ ├── amazon-keyspaces-mcp-server.md
│ │ │ ├── amazon-mq-mcp-server.md
│ │ │ ├── amazon-neptune-mcp-server.md
│ │ │ ├── amazon-qbusiness-anonymous-mcp-server.md
│ │ │ ├── amazon-qindex-mcp-server.md
│ │ │ ├── amazon-sns-sqs-mcp-server.md
│ │ │ ├── aurora-dsql-mcp-server.md
│ │ │ ├── aws-api-mcp-server.md
│ │ │ ├── aws-appsync-mcp-server.md
│ │ │ ├── aws-bedrock-custom-model-import-mcp-server.md
│ │ │ ├── aws-bedrock-data-automation-mcp-server.md
│ │ │ ├── aws-dataprocessing-mcp-server.md
│ │ │ ├── aws-diagram-mcp-server.md
│ │ │ ├── aws-documentation-mcp-server.md
│ │ │ ├── aws-healthomics-mcp-server.md
│ │ │ ├── aws-iot-sitewise-mcp-server.md
│ │ │ ├── aws-knowledge-mcp-server.md
│ │ │ ├── aws-location-mcp-server.md
│ │ │ ├── aws-msk-mcp-server.md
│ │ │ ├── aws-pricing-mcp-server.md
│ │ │ ├── aws-serverless-mcp-server.md
│ │ │ ├── aws-support-mcp-server.md
│ │ │ ├── bedrock-kb-retrieval-mcp-server.md
│ │ │ ├── billing-cost-management-mcp-server.md
│ │ │ ├── ccapi-mcp-server.md
│ │ │ ├── cdk-mcp-server.md
│ │ │ ├── cfn-mcp-server.md
│ │ │ ├── cloudtrail-mcp-server.md
│ │ │ ├── cloudwatch-appsignals-mcp-server.md
│ │ │ ├── cloudwatch-mcp-server.md
│ │ │ ├── code-doc-gen-mcp-server.md
│ │ │ ├── core-mcp-server.md
│ │ │ ├── cost-explorer-mcp-server.md
│ │ │ ├── documentdb-mcp-server.md
│ │ │ ├── dynamodb-mcp-server.md
│ │ │ ├── ecs-mcp-server.md
│ │ │ ├── eks-mcp-server.md
│ │ │ ├── elasticache-mcp-server.md
│ │ │ ├── finch-mcp-server.md
│ │ │ ├── frontend-mcp-server.md
│ │ │ ├── git-repo-research-mcp-server.md
│ │ │ ├── healthlake-mcp-server.md
│ │ │ ├── iam-mcp-server.md
│ │ │ ├── kendra-index-mcp-server.md
│ │ │ ├── lambda-tool-mcp-server.md
│ │ │ ├── memcached-mcp-server.md
│ │ │ ├── mysql-mcp-server.md
│ │ │ ├── nova-canvas-mcp-server.md
│ │ │ ├── openapi-mcp-server.md
│ │ │ ├── postgres-mcp-server.md
│ │ │ ├── prometheus-mcp-server.md
│ │ │ ├── redshift-mcp-server.md
│ │ │ ├── s3-tables-mcp-server.md
│ │ │ ├── stepfunctions-tool-mcp-server.md
│ │ │ ├── syntheticdata-mcp-server.md
│ │ │ ├── terraform-mcp-server.md
│ │ │ ├── timestream-for-influxdb-mcp-server.md
│ │ │ ├── valkey-mcp-server.md
│ │ │ └── well-architected-security-mcp-server.mdx
│ │ └── vibe_coding.md
│ ├── docusaurus.config.ts
│ ├── package-lock.json
│ ├── package.json
│ ├── README.md
│ ├── sidebars.ts
│ ├── src
│ │ ├── components
│ │ │ ├── HomepageFeatures
│ │ │ │ └── styles.module.css
│ │ │ └── ServerCards
│ │ │ ├── index.tsx
│ │ │ └── styles.module.css
│ │ ├── css
│ │ │ ├── custom.css
│ │ │ └── doc-override.css
│ │ └── pages
│ │ ├── index.module.css
│ │ └── servers.tsx
│ ├── static
│ │ ├── .nojekyll
│ │ ├── assets
│ │ │ ├── icons
│ │ │ │ ├── activity.svg
│ │ │ │ ├── book-open.svg
│ │ │ │ ├── cpu.svg
│ │ │ │ ├── database.svg
│ │ │ │ ├── dollar-sign.svg
│ │ │ │ ├── help-circle.svg
│ │ │ │ ├── key.svg
│ │ │ │ ├── server.svg
│ │ │ │ ├── share-2.svg
│ │ │ │ ├── tool.svg
│ │ │ │ └── zap.svg
│ │ │ └── server-cards.json
│ │ └── img
│ │ ├── aws-logo.svg
│ │ └── logo.png
│ └── tsconfig.json
├── LICENSE
├── NOTICE
├── README.md
├── samples
│ ├── mcp-integration-with-kb
│ │ ├── .env.example
│ │ ├── .python-version
│ │ ├── assets
│ │ │ └── simplified-mcp-flow-diagram.png
│ │ ├── clients
│ │ │ └── client_server.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── user_interfaces
│ │ │ └── chat_bedrock_st.py
│ │ └── uv.lock
│ ├── mcp-integration-with-nova-canvas
│ │ ├── .env.example
│ │ ├── .python-version
│ │ ├── clients
│ │ │ └── client_server.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── user_interfaces
│ │ │ └── image_generator_st.py
│ │ └── uv.lock
│ ├── README.md
│ └── stepfunctions-tool-mcp-server
│ ├── README.md
│ └── sample_state_machines
│ ├── customer-create
│ │ └── app.py
│ ├── customer-id-from-email
│ │ └── app.py
│ ├── customer-info-from-id
│ │ └── app.py
│ └── template.yml
├── src
│ ├── amazon-bedrock-agentcore-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_bedrock_agentcore_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── config.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── cache.py
│ │ │ ├── doc_fetcher.py
│ │ │ ├── indexer.py
│ │ │ ├── text_processor.py
│ │ │ └── url_validator.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── SECURITY.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_cache.py
│ │ │ ├── test_config.py
│ │ │ ├── test_doc_fetcher.py
│ │ │ ├── test_indexer.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_server.py
│ │ │ ├── test_text_processor.py
│ │ │ └── test_url_validator.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-kendra-index-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_kendra_index_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── util.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-keyspaces-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_keyspaces_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── config.py
│ │ │ ├── consts.py
│ │ │ ├── llm_context.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── services.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_client.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_query_analysis_service.py
│ │ │ ├── test_server.py
│ │ │ └── test_services.py
│ │ └── uv.lock
│ ├── amazon-mq-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_mq_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_service_mcp_generator.py
│ │ │ ├── consts.py
│ │ │ ├── rabbitmq
│ │ │ │ ├── __init__.py
│ │ │ │ ├── admin.py
│ │ │ │ ├── connection.py
│ │ │ │ ├── doc
│ │ │ │ │ ├── rabbitmq_broker_sizing_guide.md
│ │ │ │ │ ├── rabbitmq_performance_optimization_best_practice.md
│ │ │ │ │ ├── rabbitmq_production_deployment_guidelines.md
│ │ │ │ │ ├── rabbitmq_quorum_queue_migration_guide.md
│ │ │ │ │ └── rabbitmq_setup_best_practice.md
│ │ │ │ ├── handlers.py
│ │ │ │ └── module.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── example
│ │ │ └── sample_mcp_q_cli.json
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── rabbitmq
│ │ │ │ ├── __init__.py
│ │ │ │ ├── conftest.py
│ │ │ │ ├── test_admin.py
│ │ │ │ ├── test_connection.py
│ │ │ │ ├── test_handlers.py
│ │ │ │ └── test_module.py
│ │ │ ├── test_aws_service_mcp_generator.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-neptune-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_neptune_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── exceptions.py
│ │ │ ├── graph_store
│ │ │ │ ├── __init__.py
│ │ │ │ ├── analytics.py
│ │ │ │ ├── base.py
│ │ │ │ └── database.py
│ │ │ ├── models.py
│ │ │ ├── neptune.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_analytics.py
│ │ │ ├── test_database.py
│ │ │ ├── test_exceptions.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_neptune.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-qbusiness-anonymous-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_qbusiness_anonymous_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── clients.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-qindex-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_qindex_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── clients.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_clients.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ └── uv.lock
│ ├── amazon-sns-sqs-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_sns_sqs_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── consts.py
│ │ │ ├── generator.py
│ │ │ ├── server.py
│ │ │ ├── sns.py
│ │ │ └── sqs.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── print_tools.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── README.md
│ │ │ ├── test_common.py
│ │ │ ├── test_generator.py
│ │ │ ├── test_server.py
│ │ │ ├── test_sns.py
│ │ │ └── test_sqs.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aurora-dsql-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aurora_dsql_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── mutable_sql_detector.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_connection_reuse.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_profile_option.py
│ │ │ ├── test_readonly_enforcement.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-api-mcp-server
│ │ ├── .gitattributes
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_api_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ ├── agent_scripts
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── manager.py
│ │ │ │ │ ├── models.py
│ │ │ │ │ └── registry
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── application-failure-troubleshooting.script.md
│ │ │ │ │ ├── cloudtral-mutli-region-setup.script.md
│ │ │ │ │ ├── create_amazon_aurora_db_cluster_with_instances.script.md
│ │ │ │ │ ├── lambda-timeout-debugging.script.md
│ │ │ │ │ ├── scripts_format.md
│ │ │ │ │ └── troubleshoot-permissions-with-cloudtrail-events.script.md
│ │ │ │ ├── aws
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── driver.py
│ │ │ │ │ ├── pagination.py
│ │ │ │ │ ├── regions.py
│ │ │ │ │ ├── service.py
│ │ │ │ │ └── services.py
│ │ │ │ ├── common
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── command_metadata.py
│ │ │ │ │ ├── command.py
│ │ │ │ │ ├── config.py
│ │ │ │ │ ├── errors.py
│ │ │ │ │ ├── file_operations.py
│ │ │ │ │ ├── file_system_controls.py
│ │ │ │ │ ├── helpers.py
│ │ │ │ │ ├── models.py
│ │ │ │ │ └── py.typed
│ │ │ │ ├── data
│ │ │ │ │ └── api_metadata.json
│ │ │ │ ├── metadata
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── read_only_operations_list.py
│ │ │ │ ├── parser
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── custom_validators
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── botocore_param_validator.py
│ │ │ │ │ │ ├── ec2_validator.py
│ │ │ │ │ │ └── ssm_validator.py
│ │ │ │ │ ├── interpretation.py
│ │ │ │ │ ├── lexer.py
│ │ │ │ │ └── parser.py
│ │ │ │ ├── py.typed
│ │ │ │ └── security
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_api_customization.json
│ │ │ │ └── policy.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── CONTRIBUTING.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── agent_scripts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_manager.py
│ │ │ │ └── test_registry
│ │ │ │ ├── another_valid_script.script.md
│ │ │ │ ├── test_script.script.md
│ │ │ │ └── valid_script.script.md
│ │ │ ├── aws
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_driver.py
│ │ │ │ ├── test_pagination.py
│ │ │ │ ├── test_service.py
│ │ │ │ └── test_services.py
│ │ │ ├── common
│ │ │ │ ├── test_command.py
│ │ │ │ ├── test_config.py
│ │ │ │ ├── test_file_operations.py
│ │ │ │ ├── test_file_system_controls.py
│ │ │ │ ├── test_file_validation.py
│ │ │ │ └── test_helpers.py
│ │ │ ├── fixtures.py
│ │ │ ├── history_handler.py
│ │ │ ├── metadata
│ │ │ │ ├── __init__.py
│ │ │ │ └── test_read_only_operations_list.py
│ │ │ ├── parser
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_file_path_detection.py
│ │ │ │ ├── test_lexer.py
│ │ │ │ ├── test_parser_customizations.py
│ │ │ │ └── test_parser.py
│ │ │ ├── test_security_policy.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-appsync-mcp-server
│ │ ├── .dockerignore
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_appsync_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── decorators.py
│ │ │ ├── helpers.py
│ │ │ ├── operations
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_api_cache.py
│ │ │ │ ├── create_api_key.py
│ │ │ │ ├── create_api.py
│ │ │ │ ├── create_channel_namespace.py
│ │ │ │ ├── create_datasource.py
│ │ │ │ ├── create_domain_name.py
│ │ │ │ ├── create_function.py
│ │ │ │ ├── create_graphql_api.py
│ │ │ │ ├── create_resolver.py
│ │ │ │ └── create_schema.py
│ │ │ ├── server.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_api_cache.py
│ │ │ │ ├── create_api_key.py
│ │ │ │ ├── create_api.py
│ │ │ │ ├── create_channel_namespace.py
│ │ │ │ ├── create_datasource.py
│ │ │ │ ├── create_domain_name.py
│ │ │ │ ├── create_function.py
│ │ │ │ ├── create_graphql_api.py
│ │ │ │ ├── create_resolver.py
│ │ │ │ └── create_schema.py
│ │ │ └── validators.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_all_create_tools_write_protection.py
│ │ │ ├── test_create_api_cache.py
│ │ │ ├── test_create_api_key.py
│ │ │ ├── test_create_api.py
│ │ │ ├── test_create_channel_namespace.py
│ │ │ ├── test_create_datasource_tool.py
│ │ │ ├── test_create_datasource.py
│ │ │ ├── test_create_domain_name.py
│ │ │ ├── test_create_function.py
│ │ │ ├── test_create_graphql_api.py
│ │ │ ├── test_create_resolver.py
│ │ │ ├── test_create_schema_tool.py
│ │ │ ├── test_create_schema.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_server.py
│ │ │ ├── test_validators.py
│ │ │ └── test_write_operation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-bedrock-custom-model-import-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_bedrock_custom_model_import_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── llm_context.py
│ │ │ ├── models.py
│ │ │ ├── prompts.py
│ │ │ ├── server.py
│ │ │ ├── services
│ │ │ │ ├── __init__.py
│ │ │ │ ├── imported_model_service.py
│ │ │ │ └── model_import_service.py
│ │ │ ├── tools
│ │ │ │ ├── create_model_import_job.py
│ │ │ │ ├── delete_imported_model.py
│ │ │ │ ├── get_imported_model.py
│ │ │ │ ├── get_model_import_job.py
│ │ │ │ ├── list_imported_models.py
│ │ │ │ └── list_model_import_jobs.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws.py
│ │ │ ├── config.py
│ │ │ ├── consts.py
│ │ │ └── matching.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── services
│ │ │ │ ├── test_imported_model_service.py
│ │ │ │ └── test_model_import_service.py
│ │ │ ├── test_client.py
│ │ │ ├── test_init.py
│ │ │ ├── test_llm_context.py
│ │ │ ├── test_prompts.py
│ │ │ ├── test_server.py
│ │ │ ├── tools
│ │ │ │ ├── test_create_model_import_job.py
│ │ │ │ ├── test_delete_imported_model.py
│ │ │ │ ├── test_get_imported_model.py
│ │ │ │ ├── test_get_model_import_job.py
│ │ │ │ ├── test_list_imported_models.py
│ │ │ │ └── test_list_model_import_jobs.py
│ │ │ └── utils
│ │ │ ├── test_aws.py
│ │ │ ├── test_config.py
│ │ │ └── test_matching.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-bedrock-data-automation-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_bedrock_data_automation_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── helpers.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-dataprocessing-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_dataprocessing_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ └── glue_data_catalog
│ │ │ │ ├── __init__.py
│ │ │ │ ├── data_catalog_database_manager.py
│ │ │ │ ├── data_catalog_handler.py
│ │ │ │ └── data_catalog_table_manager.py
│ │ │ ├── handlers
│ │ │ │ ├── __init__.py
│ │ │ │ ├── athena
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── athena_data_catalog_handler.py
│ │ │ │ │ ├── athena_query_handler.py
│ │ │ │ │ └── athena_workgroup_handler.py
│ │ │ │ ├── commons
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── common_resource_handler.py
│ │ │ │ ├── emr
│ │ │ │ │ ├── emr_ec2_cluster_handler.py
│ │ │ │ │ ├── emr_ec2_instance_handler.py
│ │ │ │ │ └── emr_ec2_steps_handler.py
│ │ │ │ └── glue
│ │ │ │ ├── __init__.py
│ │ │ │ ├── crawler_handler.py
│ │ │ │ ├── data_catalog_handler.py
│ │ │ │ ├── glue_commons_handler.py
│ │ │ │ ├── glue_etl_handler.py
│ │ │ │ ├── interactive_sessions_handler.py
│ │ │ │ └── worklows_handler.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ ├── athena_models.py
│ │ │ │ ├── common_resource_models.py
│ │ │ │ ├── data_catalog_models.py
│ │ │ │ ├── emr_models.py
│ │ │ │ └── glue_models.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws_helper.py
│ │ │ ├── consts.py
│ │ │ ├── logging_helper.py
│ │ │ └── mutable_sql_detector.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ └── glue_data_catalog
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_data_catalog_database_manager.py
│ │ │ │ ├── test_data_catalog_handler.py
│ │ │ │ └── test_data_catalog_table_manager.py
│ │ │ ├── handlers
│ │ │ │ ├── __init__.py
│ │ │ │ ├── athena
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── test_athena_data_catalog_handler.py
│ │ │ │ │ ├── test_athena_query_handler.py
│ │ │ │ │ ├── test_athena_workgroup_handler.py
│ │ │ │ │ └── test_custom_tags_athena.py
│ │ │ │ ├── commons
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── test_common_resource_handler.py
│ │ │ │ ├── emr
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── test_custom_tags_emr.py
│ │ │ │ │ ├── test_emr_ec2_cluster_handler.py
│ │ │ │ │ ├── test_emr_ec2_instance_handler.py
│ │ │ │ │ └── test_emr_ec2_steps_handler.py
│ │ │ │ └── glue
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_crawler_handler.py
│ │ │ │ ├── test_custom_tags_glue.py
│ │ │ │ ├── test_data_catalog_handler.py
│ │ │ │ ├── test_glue_commons_handler.py
│ │ │ │ ├── test_glue_etl_handler.py
│ │ │ │ ├── test_glue_interactive_sessions_handler.py
│ │ │ │ └── test_glue_workflows_handler.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_athena_models.py
│ │ │ │ ├── test_common_resource_models.py
│ │ │ │ ├── test_data_catalog_models.py
│ │ │ │ ├── test_emr_models.py
│ │ │ │ ├── test_glue_models.py
│ │ │ │ ├── test_interactive_sessions_models.py
│ │ │ │ └── test_workflows_models.py
│ │ │ ├── test_init.py
│ │ │ ├── test_server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── test_aws_helper.py
│ │ │ ├── test_custom_tags.py
│ │ │ └── test_logging_helper.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-diagram-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_diagram_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── diagrams_tools.py
│ │ │ ├── models.py
│ │ │ ├── scanner.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── resources
│ │ │ │ ├── __init__.py
│ │ │ │ └── example_diagrams
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_example.py
│ │ │ │ ├── flow_example.py
│ │ │ │ └── sequence_example.py
│ │ │ ├── test_diagrams.py
│ │ │ ├── test_models.py
│ │ │ ├── test_sarif_fix.py
│ │ │ ├── test_scanner.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-documentation-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_documentation_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── models.py
│ │ │ ├── server_aws_cn.py
│ │ │ ├── server_aws.py
│ │ │ ├── server_utils.py
│ │ │ ├── server.py
│ │ │ └── util.py
│ │ ├── basic-usage.gif
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── constants.py
│ │ │ ├── resources
│ │ │ │ └── lambda_sns_raw.html
│ │ │ ├── test_aws_cn_get_available_services_live.py
│ │ │ ├── test_aws_cn_read_documentation_live.py
│ │ │ ├── test_aws_read_documentation_live.py
│ │ │ ├── test_aws_recommend_live.py
│ │ │ ├── test_aws_search_live.py
│ │ │ ├── test_metadata_handling.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server_aws_cn.py
│ │ │ ├── test_server_aws.py
│ │ │ ├── test_server_utils.py
│ │ │ ├── test_server.py
│ │ │ └── test_util.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-healthomics-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_healthomics_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── helper_tools.py
│ │ │ │ ├── run_analysis.py
│ │ │ │ ├── troubleshooting.py
│ │ │ │ ├── workflow_analysis.py
│ │ │ │ ├── workflow_execution.py
│ │ │ │ ├── workflow_linting.py
│ │ │ │ └── workflow_management.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws_utils.py
│ │ │ ├── s3_utils.py
│ │ │ └── validation_utils.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── docs
│ │ │ └── workflow_linting.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_aws_utils.py
│ │ │ ├── test_consts.py
│ │ │ ├── test_helper_tools.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_run_analysis.py
│ │ │ ├── test_s3_utils.py
│ │ │ ├── test_server.py
│ │ │ ├── test_troubleshooting.py
│ │ │ ├── test_workflow_analysis.py
│ │ │ ├── test_workflow_execution.py
│ │ │ ├── test_workflow_linting.py
│ │ │ ├── test_workflow_management.py
│ │ │ └── test_workflow_tools.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-iot-sitewise-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_iot_sitewise_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── asset_hierarchy.py
│ │ │ │ ├── data_exploration.py
│ │ │ │ └── data_ingestion.py
│ │ │ ├── server.py
│ │ │ ├── tool_metadata.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── sitewise_access.py
│ │ │ │ ├── sitewise_asset_models.py
│ │ │ │ ├── sitewise_assets.py
│ │ │ │ ├── sitewise_data.py
│ │ │ │ └── sitewise_gateways.py
│ │ │ └── validation.py
│ │ ├── CHANGELOG.md
│ │ ├── DEVELOPMENT.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ └── wind_farm_example.py
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_server.py
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_server.py
│ │ │ ├── test_sitewise_access.py
│ │ │ ├── test_sitewise_asset_models.py
│ │ │ ├── test_sitewise_assets.py
│ │ │ ├── test_sitewise_data.py
│ │ │ ├── test_sitewise_gateways.py
│ │ │ └── test_validation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-knowledge-mcp-server
│ │ └── README.md
│ ├── aws-location-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_location_server
│ │ │ ├── __init__.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_server_integration.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-msk-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_msk_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── tools
│ │ │ ├── __init__.py
│ │ │ ├── common_functions
│ │ │ │ ├── __init__.py
│ │ │ │ ├── client_manager.py
│ │ │ │ └── common_functions.py
│ │ │ ├── logs_and_telemetry
│ │ │ │ ├── __init__.py
│ │ │ │ ├── cluster_metrics_tools.py
│ │ │ │ ├── list_customer_iam_access.py
│ │ │ │ └── metric_config.py
│ │ │ ├── mutate_cluster
│ │ │ │ ├── __init__.py
│ │ │ │ ├── batch_associate_scram_secret.py
│ │ │ │ ├── batch_disassociate_scram_secret.py
│ │ │ │ ├── create_cluster_v2.py
│ │ │ │ ├── put_cluster_policy.py
│ │ │ │ ├── reboot_broker.py
│ │ │ │ ├── update_broker_count.py
│ │ │ │ ├── update_broker_storage.py
│ │ │ │ ├── update_broker_type.py
│ │ │ │ ├── update_cluster_configuration.py
│ │ │ │ ├── update_monitoring.py
│ │ │ │ └── update_security.py
│ │ │ ├── mutate_config
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_configuration.py
│ │ │ │ ├── tag_resource.py
│ │ │ │ ├── untag_resource.py
│ │ │ │ └── update_configuration.py
│ │ │ ├── mutate_vpc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_vpc_connection.py
│ │ │ │ ├── delete_vpc_connection.py
│ │ │ │ └── reject_client_vpc_connection.py
│ │ │ ├── read_cluster
│ │ │ │ ├── __init__.py
│ │ │ │ ├── describe_cluster_operation.py
│ │ │ │ ├── describe_cluster.py
│ │ │ │ ├── get_bootstrap_brokers.py
│ │ │ │ ├── get_cluster_policy.py
│ │ │ │ ├── get_compatible_kafka_versions.py
│ │ │ │ ├── list_client_vpc_connections.py
│ │ │ │ ├── list_cluster_operations.py
│ │ │ │ ├── list_nodes.py
│ │ │ │ └── list_scram_secrets.py
│ │ │ ├── read_config
│ │ │ │ ├── __init__.py
│ │ │ │ ├── describe_configuration_revision.py
│ │ │ │ ├── describe_configuration.py
│ │ │ │ ├── list_configuration_revisions.py
│ │ │ │ └── list_tags_for_resource.py
│ │ │ ├── read_global
│ │ │ │ ├── __init__.py
│ │ │ │ ├── list_clusters.py
│ │ │ │ ├── list_configurations.py
│ │ │ │ ├── list_kafka_versions.py
│ │ │ │ └── list_vpc_connections.py
│ │ │ ├── read_vpc
│ │ │ │ ├── __init__.py
│ │ │ │ └── describe_vpc_connection.py
│ │ │ └── static_tools
│ │ │ ├── __init__.py
│ │ │ └── cluster_best_practices.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_client_manager.py
│ │ │ ├── test_cluster_metrics_tools.py
│ │ │ ├── test_common_functions.py
│ │ │ ├── test_create_cluster_v2.py
│ │ │ ├── test_create_configuration.py
│ │ │ ├── test_create_vpc_connection.py
│ │ │ ├── test_delete_vpc_connection.py
│ │ │ ├── test_describe_cluster_operation.py
│ │ │ ├── test_describe_cluster.py
│ │ │ ├── test_describe_configuration_revision.py
│ │ │ ├── test_describe_configuration.py
│ │ │ ├── test_describe_vpc_connection.py
│ │ │ ├── test_get_bootstrap_brokers.py
│ │ │ ├── test_get_cluster_policy.py
│ │ │ ├── test_get_compatible_kafka_versions.py
│ │ │ ├── test_init.py
│ │ │ ├── test_list_client_vpc_connections.py
│ │ │ ├── test_list_cluster_operations.py
│ │ │ ├── test_list_clusters.py
│ │ │ ├── test_list_configuration_revisions.py
│ │ │ ├── test_list_configurations.py
│ │ │ ├── test_list_customer_iam_access.py
│ │ │ ├── test_list_kafka_versions.py
│ │ │ ├── test_list_nodes.py
│ │ │ ├── test_list_scram_secrets.py
│ │ │ ├── test_list_tags_for_resource.py
│ │ │ ├── test_list_vpc_connections.py
│ │ │ ├── test_logs_and_telemetry.py
│ │ │ ├── test_main.py
│ │ │ ├── test_mutate_cluster_init.py
│ │ │ ├── test_mutate_cluster_success_cases.py
│ │ │ ├── test_mutate_cluster.py
│ │ │ ├── test_mutate_config_init.py
│ │ │ ├── test_mutate_vpc_init.py
│ │ │ ├── test_read_cluster_init_updated.py
│ │ │ ├── test_read_cluster_init.py
│ │ │ ├── test_read_config_init.py
│ │ │ ├── test_read_global_init.py
│ │ │ ├── test_read_vpc_init.py
│ │ │ ├── test_reject_client_vpc_connection.py
│ │ │ ├── test_server.py
│ │ │ ├── test_static_tools_init.py
│ │ │ ├── test_tag_resource.py
│ │ │ ├── test_tool_descriptions.py
│ │ │ ├── test_untag_resource.py
│ │ │ └── test_update_configuration.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-pricing-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_pricing_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── cdk_analyzer.py
│ │ │ ├── consts.py
│ │ │ ├── helpers.py
│ │ │ ├── models.py
│ │ │ ├── pricing_client.py
│ │ │ ├── pricing_transformer.py
│ │ │ ├── report_generator.py
│ │ │ ├── server.py
│ │ │ ├── static
│ │ │ │ ├── __init__.py
│ │ │ │ ├── COST_REPORT_TEMPLATE.md
│ │ │ │ └── patterns
│ │ │ │ ├── __init__.py
│ │ │ │ └── BEDROCK.md
│ │ │ └── terraform_analyzer.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_cdk_analyzer.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_pricing_client.py
│ │ │ ├── test_pricing_transformer.py
│ │ │ ├── test_report_generator.py
│ │ │ ├── test_server.py
│ │ │ └── test_terraform_analyzer.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-serverless-mcp-server
│ │ ├── .pre-commit.config.yaml
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_serverless_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── models.py
│ │ │ ├── resources
│ │ │ │ ├── __init__.py
│ │ │ │ ├── deployment_details.py
│ │ │ │ ├── deployment_list.py
│ │ │ │ ├── template_details.py
│ │ │ │ └── template_list.py
│ │ │ ├── server.py
│ │ │ ├── template
│ │ │ │ ├── __init__.py
│ │ │ │ ├── registry.py
│ │ │ │ ├── renderer.py
│ │ │ │ └── templates
│ │ │ │ ├── backend.j2
│ │ │ │ ├── frontend.j2
│ │ │ │ ├── fullstack.j2
│ │ │ │ └── README.md
│ │ │ ├── tools
│ │ │ │ ├── common
│ │ │ │ │ └── base_tool.py
│ │ │ │ ├── guidance
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── deploy_serverless_app_help.py
│ │ │ │ │ ├── get_iac_guidance.py
│ │ │ │ │ ├── get_lambda_event_schemas.py
│ │ │ │ │ ├── get_lambda_guidance.py
│ │ │ │ │ └── get_serverless_templates.py
│ │ │ │ ├── sam
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── sam_build.py
│ │ │ │ │ ├── sam_deploy.py
│ │ │ │ │ ├── sam_init.py
│ │ │ │ │ ├── sam_local_invoke.py
│ │ │ │ │ └── sam_logs.py
│ │ │ │ ├── schemas
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── describe_schema.py
│ │ │ │ │ ├── list_registries.py
│ │ │ │ │ └── search_schema.py
│ │ │ │ └── webapps
│ │ │ │ ├── __init__.py
│ │ │ │ ├── configure_domain.py
│ │ │ │ ├── deploy_webapp.py
│ │ │ │ ├── get_metrics.py
│ │ │ │ ├── update_webapp_frontend.py
│ │ │ │ ├── utils
│ │ │ │ │ ├── deploy_service.py
│ │ │ │ │ ├── frontend_uploader.py
│ │ │ │ │ └── startup_script_generator.py
│ │ │ │ └── webapp_deployment_help.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws_client_helper.py
│ │ │ ├── cloudformation.py
│ │ │ ├── const.py
│ │ │ ├── deployment_manager.py
│ │ │ ├── github.py
│ │ │ └── process.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_cloudformation.py
│ │ │ ├── test_configure_domain.py
│ │ │ ├── test_deploy_serverless_app_help.py
│ │ │ ├── test_deploy_service.py
│ │ │ ├── test_deploy_webapp.py
│ │ │ ├── test_deployment_details.py
│ │ │ ├── test_deployment_help.py
│ │ │ ├── test_deployment_list.py
│ │ │ ├── test_deployment_manager.py
│ │ │ ├── test_frontend_uploader.py
│ │ │ ├── test_get_iac_guidance.py
│ │ │ ├── test_get_lambda_event_schemas.py
│ │ │ ├── test_get_lambda_guidance.py
│ │ │ ├── test_get_metrics.py
│ │ │ ├── test_get_serverless_templates.py
│ │ │ ├── test_github.py
│ │ │ ├── test_models.py
│ │ │ ├── test_process.py
│ │ │ ├── test_sam_build.py
│ │ │ ├── test_sam_deploy.py
│ │ │ ├── test_sam_init.py
│ │ │ ├── test_sam_local_invoke.py
│ │ │ ├── test_sam_logs.py
│ │ │ ├── test_schemas.py
│ │ │ ├── test_server.py
│ │ │ ├── test_startup_script_generator.py
│ │ │ ├── test_template_details.py
│ │ │ ├── test_template_list.py
│ │ │ ├── test_template_registry.py
│ │ │ ├── test_template_renderer.py
│ │ │ └── test_update_webapp_frontend.py
│ │ └── uv.lock
│ ├── aws-support-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_support_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── consts.py
│ │ │ ├── debug_helper.py
│ │ │ ├── errors.py
│ │ │ ├── formatters.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftests.py
│ │ │ ├── test_aws_support_mcp_server.py
│ │ │ └── test_models.py
│ │ └── uv.lock
│ ├── bedrock-kb-retrieval-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── bedrock_kb_retrieval_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── knowledgebases
│ │ │ │ ├── __init__.py
│ │ │ │ ├── clients.py
│ │ │ │ ├── discovery.py
│ │ │ │ └── retrieval.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_clients.py
│ │ │ ├── test_discovery.py
│ │ │ ├── test_env_config.py
│ │ │ ├── test_models.py
│ │ │ ├── test_retrieval.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── billing-cost-management-mcp-server
│ │ ├── __init__.py
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── billing_cost_management_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── models.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── decorator.py
│ │ │ │ ├── graviton_migration.py
│ │ │ │ ├── README.md
│ │ │ │ ├── savings_plans.py
│ │ │ │ └── types.py
│ │ │ ├── server.py
│ │ │ ├── templates
│ │ │ │ └── recommendation_templates
│ │ │ │ ├── ebs_volume.template
│ │ │ │ ├── ec2_asg.template
│ │ │ │ ├── ec2_instance.template
│ │ │ │ ├── ecs_service.template
│ │ │ │ ├── idle.template
│ │ │ │ ├── lambda_function.template
│ │ │ │ ├── rds_database.template
│ │ │ │ ├── reserved_instances.template
│ │ │ │ └── savings_plans.template
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_pricing_operations.py
│ │ │ │ ├── aws_pricing_tools.py
│ │ │ │ ├── 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_pricing_tools.py
│ │ │ │ ├── test_budget_tools.py
│ │ │ │ ├── test_compute_optimizer_tools.py
│ │ │ │ ├── test_cost_anomaly_tools_enhanced.py
│ │ │ │ ├── test_cost_anomaly_tools.py
│ │ │ │ ├── test_cost_comparison_tools.py
│ │ │ │ ├── test_cost_explorer_operations.py
│ │ │ │ ├── test_cost_explorer_tools.py
│ │ │ │ ├── test_cost_optimization_hub_helpers.py
│ │ │ │ ├── test_cost_optimization_hub_tools.py
│ │ │ │ ├── test_free_tier_usage_tools_new.py
│ │ │ │ ├── test_recommendation_details_tools.py
│ │ │ │ ├── test_ri_performance_tools.py
│ │ │ │ ├── test_sp_performance_tools.py
│ │ │ │ ├── test_storage_lens_tools.py
│ │ │ │ └── test_unified_sql_tools.py
│ │ │ └── utilities
│ │ │ ├── test_aws_service_base.py
│ │ │ └── test_sql_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── ccapi-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── ccapi_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_client.py
│ │ │ ├── cloud_control_utils.py
│ │ │ ├── context.py
│ │ │ ├── errors.py
│ │ │ ├── iac_generator.py
│ │ │ ├── impl
│ │ │ │ ├── __init__.py
│ │ │ │ ├── tools
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── explanation.py
│ │ │ │ │ ├── infrastructure_generation.py
│ │ │ │ │ ├── resource_operations.py
│ │ │ │ │ ├── security_scanning.py
│ │ │ │ │ └── session_management.py
│ │ │ │ └── utils
│ │ │ │ ├── __init__.py
│ │ │ │ └── validation.py
│ │ │ ├── infrastructure_generator.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ └── models.py
│ │ │ ├── schema_manager.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ └── __init__.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_aws_client.py
│ │ │ ├── test_checkov_install.py
│ │ │ ├── test_cloud_control_utils.py
│ │ │ ├── test_context.py
│ │ │ ├── test_errors.py
│ │ │ ├── test_explanation.py
│ │ │ ├── test_iac_generator.py
│ │ │ ├── test_infrastructure_generation.py
│ │ │ ├── test_infrastructure_generator.py
│ │ │ ├── test_models.py
│ │ │ ├── test_resource_operations.py
│ │ │ ├── test_schema_manager.py
│ │ │ ├── test_security_scanning.py
│ │ │ ├── test_server.py
│ │ │ ├── test_session_management.py
│ │ │ └── test_validation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cdk-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cdk_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ ├── resources.py
│ │ │ │ ├── search_utils.py
│ │ │ │ ├── server.py
│ │ │ │ └── tools.py
│ │ │ ├── data
│ │ │ │ ├── __init__.py
│ │ │ │ ├── cdk_nag_parser.py
│ │ │ │ ├── construct_descriptions.py
│ │ │ │ ├── genai_cdk_loader.py
│ │ │ │ ├── lambda_layer_parser.py
│ │ │ │ ├── lambda_powertools_loader.py
│ │ │ │ ├── schema_generator.py
│ │ │ │ └── solutions_constructs_parser.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ ├── __init__.py
│ │ │ ├── CDK_GENERAL_GUIDANCE.md
│ │ │ ├── CDK_NAG_GUIDANCE.md
│ │ │ └── lambda_powertools
│ │ │ ├── bedrock.md
│ │ │ ├── cdk.md
│ │ │ ├── dependencies.md
│ │ │ ├── index.md
│ │ │ ├── insights.md
│ │ │ ├── logging.md
│ │ │ ├── metrics.md
│ │ │ └── tracing.md
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── test_resources_enhanced.py
│ │ │ │ ├── test_resources.py
│ │ │ │ ├── test_search_utils.py
│ │ │ │ ├── test_server.py
│ │ │ │ └── test_tools.py
│ │ │ └── data
│ │ │ ├── test_cdk_nag_parser.py
│ │ │ ├── test_genai_cdk_loader.py
│ │ │ ├── test_lambda_powertools_loader.py
│ │ │ ├── test_schema_generator.py
│ │ │ └── test_solutions_constructs_parser.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cfn-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cfn_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_client.py
│ │ │ ├── cloud_control_utils.py
│ │ │ ├── context.py
│ │ │ ├── errors.py
│ │ │ ├── iac_generator.py
│ │ │ ├── schema_manager.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_aws_client.py
│ │ │ ├── test_cloud_control_utils.py
│ │ │ ├── test_errors.py
│ │ │ ├── test_iac_generator.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_schema_manager.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cloudtrail-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cloudtrail_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── tools.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ └── test_tools.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cloudwatch-appsignals-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cloudwatch_appsignals_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── audit_presentation_utils.py
│ │ │ ├── audit_utils.py
│ │ │ ├── aws_clients.py
│ │ │ ├── canary_utils.py
│ │ │ ├── server.py
│ │ │ ├── service_audit_utils.py
│ │ │ ├── service_tools.py
│ │ │ ├── sli_report_client.py
│ │ │ ├── slo_tools.py
│ │ │ ├── trace_tools.py
│ │ │ └── utils.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_audit_presentation_utils.py
│ │ │ ├── test_audit_utils.py
│ │ │ ├── test_aws_profile.py
│ │ │ ├── test_canary_utils.py
│ │ │ ├── test_initialization.py
│ │ │ ├── test_server_audit_functions.py
│ │ │ ├── test_server_audit_tools.py
│ │ │ ├── test_server.py
│ │ │ ├── test_service_audit_utils.py
│ │ │ ├── test_service_tools_operations.py
│ │ │ ├── test_sli_report_client.py
│ │ │ ├── test_slo_tools.py
│ │ │ └── test_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cloudwatch-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cloudwatch_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── cloudwatch_alarms
│ │ │ │ ├── models.py
│ │ │ │ └── tools.py
│ │ │ ├── cloudwatch_logs
│ │ │ │ ├── models.py
│ │ │ │ └── tools.py
│ │ │ ├── cloudwatch_metrics
│ │ │ │ ├── data
│ │ │ │ │ └── metric_metadata.json
│ │ │ │ ├── models.py
│ │ │ │ └── tools.py
│ │ │ ├── common.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── cloudwatch_alarms
│ │ │ │ ├── test_active_alarms.py
│ │ │ │ ├── test_alarm_history_integration.py
│ │ │ │ ├── test_alarm_history.py
│ │ │ │ └── test_alarms_error_handling.py
│ │ │ ├── cloudwatch_logs
│ │ │ │ ├── test_logs_error_handling.py
│ │ │ │ ├── test_logs_models.py
│ │ │ │ └── test_logs_server.py
│ │ │ ├── cloudwatch_metrics
│ │ │ │ ├── test_metrics_error_handling.py
│ │ │ │ ├── test_metrics_models.py
│ │ │ │ ├── test_metrics_server.py
│ │ │ │ └── test_validation_error.py
│ │ │ ├── test_common_and_server.py
│ │ │ ├── test_init.py
│ │ │ └── test_main.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── code-doc-gen-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── code_doc_gen_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── doc_generator.py
│ │ │ ├── models.py
│ │ │ ├── repomix_manager.py
│ │ │ └── templates.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_doc_generator_edge_cases.py
│ │ │ ├── test_doc_generator.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_repomix_manager_scenarios.py
│ │ │ ├── test_repomix_manager.py
│ │ │ ├── test_repomix_statistics.py
│ │ │ ├── test_server_extended.py
│ │ │ ├── test_server.py
│ │ │ └── test_templates.py
│ │ └── uv.lock
│ ├── core-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── core_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ ├── __init__.py
│ │ │ └── PROMPT_UNDERSTANDING.md
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_response_types.py
│ │ │ ├── test_server.py
│ │ │ └── test_static.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cost-explorer-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cost_explorer_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── comparison_handler.py
│ │ │ ├── constants.py
│ │ │ ├── cost_usage_handler.py
│ │ │ ├── forecasting_handler.py
│ │ │ ├── helpers.py
│ │ │ ├── metadata_handler.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── utility_handler.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_comparison_handler.py
│ │ │ ├── test_cost_usage_handler.py
│ │ │ ├── test_forecasting_handler.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_metadata_handler.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ └── test_utility_handler.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── documentdb-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ └── documentdb_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── analytic_tools.py
│ │ │ ├── config.py
│ │ │ ├── connection_tools.py
│ │ │ ├── db_management_tools.py
│ │ │ ├── query_tools.py
│ │ │ ├── server.py
│ │ │ └── write_tools.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_analytic_tools.py
│ │ │ ├── test_connection_tools.py
│ │ │ ├── test_db_management_tools.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_query_tools.py
│ │ │ └── test_write_tools.py
│ │ └── uv.lock
│ ├── dynamodb-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── dynamodb_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── database_analysis_queries.py
│ │ │ ├── database_analyzers.py
│ │ │ ├── prompts
│ │ │ │ └── dynamodb_architect.md
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── evals
│ │ │ │ ├── dynamic_evaluators.py
│ │ │ │ ├── evaluation_registry.py
│ │ │ │ ├── logging_config.py
│ │ │ │ ├── multiturn_evaluator.py
│ │ │ │ ├── README.md
│ │ │ │ ├── scenarios.py
│ │ │ │ └── test_dspy_evals.py
│ │ │ ├── test_dynamodb_server.py
│ │ │ └── test_source_db_integration.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── ecs-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── ecs_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── api
│ │ │ │ ├── __init__.py
│ │ │ │ ├── containerize.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── ecs_troubleshooting.py
│ │ │ │ ├── infrastructure.py
│ │ │ │ ├── resource_management.py
│ │ │ │ ├── status.py
│ │ │ │ └── troubleshooting_tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── detect_image_pull_failures.py
│ │ │ │ ├── fetch_cloudformation_status.py
│ │ │ │ ├── fetch_network_configuration.py
│ │ │ │ ├── fetch_service_events.py
│ │ │ │ ├── fetch_task_failures.py
│ │ │ │ ├── fetch_task_logs.py
│ │ │ │ ├── get_ecs_troubleshooting_guidance.py
│ │ │ │ └── utils.py
│ │ │ ├── main.py
│ │ │ ├── modules
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_knowledge_proxy.py
│ │ │ │ ├── containerize.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── deployment_status.py
│ │ │ │ ├── infrastructure.py
│ │ │ │ ├── resource_management.py
│ │ │ │ └── troubleshooting.py
│ │ │ ├── templates
│ │ │ │ ├── ecr_infrastructure.json
│ │ │ │ └── ecs_infrastructure.json
│ │ │ └── utils
│ │ │ ├── arn_parser.py
│ │ │ ├── aws.py
│ │ │ ├── config.py
│ │ │ ├── docker.py
│ │ │ ├── security.py
│ │ │ ├── templates.py
│ │ │ └── time_utils.py
│ │ ├── DEVELOPMENT.md
│ │ ├── pyproject.toml
│ │ ├── pyrightconfig.json
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── integ
│ │ │ │ └── mcp-inspector
│ │ │ │ ├── .gitignore
│ │ │ │ ├── README.md
│ │ │ │ ├── run-tests.sh
│ │ │ │ └── scenarios
│ │ │ │ ├── 01_comprehensive_troubleshooting
│ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ ├── 03_cleanup.sh
│ │ │ │ │ ├── description.txt
│ │ │ │ │ └── utils
│ │ │ │ │ ├── mcp_helpers.sh
│ │ │ │ │ └── validation_helpers.sh
│ │ │ │ └── 02_test_knowledge_proxy_tools
│ │ │ │ ├── 01_create.sh
│ │ │ │ ├── 02_validate.sh
│ │ │ │ ├── 03_cleanup.sh
│ │ │ │ ├── description.txt
│ │ │ │ └── utils
│ │ │ │ ├── knowledge_validation_helpers.sh
│ │ │ │ └── mcp_knowledge_helpers.sh
│ │ │ ├── llm_testing
│ │ │ │ ├── invalid_cfn_template.yaml
│ │ │ │ ├── README.md
│ │ │ │ ├── run_tests.sh
│ │ │ │ ├── scenarios
│ │ │ │ │ ├── 01_cloudformation_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 04_evaluation.md
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 02_service_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 04_evaluation.md
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 03_task_exit_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 04_evaluation.md
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 04_network_configuration_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 05_resource_constraint_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ └── 06_load_balancer_failure
│ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ └── description.txt
│ │ │ │ ├── SCRIPT_IMPROVEMENTS.md
│ │ │ │ └── utils
│ │ │ │ ├── aws_helpers.sh
│ │ │ │ └── evaluation_template.md
│ │ │ └── unit
│ │ │ ├── __init__.py
│ │ │ ├── api
│ │ │ │ ├── conftest.py
│ │ │ │ ├── test_delete_api.py
│ │ │ │ ├── test_ecs_troubleshooting.py
│ │ │ │ ├── test_resource_management_api.py
│ │ │ │ └── troubleshooting_tools
│ │ │ │ └── test_fetch_network_configuration.py
│ │ │ ├── conftest.py
│ │ │ ├── modules
│ │ │ │ ├── test_aws_knowledge_proxy.py
│ │ │ │ └── test_resource_management_module.py
│ │ │ ├── test_aws_role_utils.py
│ │ │ ├── test_aws_utils.py
│ │ │ ├── test_containerize.py
│ │ │ ├── test_delete.py
│ │ │ ├── test_docker_utils.py
│ │ │ ├── test_docker_with_role.py
│ │ │ ├── test_image_pull_failure_extended.py
│ │ │ ├── test_image_pull_failure.py
│ │ │ ├── test_infrastructure_role.py
│ │ │ ├── test_infrastructure.py
│ │ │ ├── test_integration.py
│ │ │ ├── test_main.py
│ │ │ ├── test_resource_management_api_operation.py
│ │ │ ├── test_resource_management_tool.py
│ │ │ ├── test_resource_management.py
│ │ │ ├── test_security_integration.py
│ │ │ ├── test_status_pytest.py
│ │ │ ├── test_status.py
│ │ │ ├── troubleshooting_tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── conftest.py
│ │ │ │ ├── test_detect_image_pull_failures.py
│ │ │ │ ├── test_fetch_cloudformation_status.py
│ │ │ │ ├── test_fetch_service_events.py
│ │ │ │ ├── test_fetch_task_failures.py
│ │ │ │ ├── test_fetch_task_logs.py
│ │ │ │ ├── test_get_ecs_troubleshooting_guidance.py
│ │ │ │ ├── test_is_ecr_image_security.py
│ │ │ │ └── test_utils.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── async_test_utils.py
│ │ │ ├── test_arn_parser.py
│ │ │ ├── test_config.py
│ │ │ ├── test_docker.py
│ │ │ ├── test_response_sanitization.py
│ │ │ ├── test_security_extended.py
│ │ │ ├── test_security.py
│ │ │ ├── test_templates.py
│ │ │ └── test_time_utils.py
│ │ └── uv.lock
│ ├── eks-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── eks_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_helper.py
│ │ │ ├── cloudwatch_handler.py
│ │ │ ├── cloudwatch_metrics_guidance_handler.py
│ │ │ ├── consts.py
│ │ │ ├── data
│ │ │ │ └── eks_cloudwatch_metrics_guidance.json
│ │ │ ├── eks_kb_handler.py
│ │ │ ├── eks_stack_handler.py
│ │ │ ├── iam_handler.py
│ │ │ ├── insights_handler.py
│ │ │ ├── k8s_apis.py
│ │ │ ├── k8s_client_cache.py
│ │ │ ├── k8s_handler.py
│ │ │ ├── logging_helper.py
│ │ │ ├── models.py
│ │ │ ├── scripts
│ │ │ │ └── update_eks_cloudwatch_metrics_guidance.py
│ │ │ ├── server.py
│ │ │ ├── templates
│ │ │ │ ├── eks-templates
│ │ │ │ │ └── eks-with-vpc.yaml
│ │ │ │ └── k8s-templates
│ │ │ │ ├── deployment.yaml
│ │ │ │ └── service.yaml
│ │ │ └── vpc_config_handler.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_aws_helper.py
│ │ │ ├── test_cloudwatch_handler.py
│ │ │ ├── test_cloudwatch_metrics_guidance_handler.py
│ │ │ ├── test_eks_kb_handler.py
│ │ │ ├── test_eks_stack_handler.py
│ │ │ ├── test_iam_handler.py
│ │ │ ├── test_init.py
│ │ │ ├── test_insights_handler.py
│ │ │ ├── test_k8s_apis.py
│ │ │ ├── test_k8s_client_cache.py
│ │ │ ├── test_k8s_handler.py
│ │ │ ├── test_logging_helper.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ └── test_vpc_config_handler.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── elasticache-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── elasticache_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common
│ │ │ │ ├── __init__.py
│ │ │ │ ├── connection.py
│ │ │ │ ├── decorators.py
│ │ │ │ └── server.py
│ │ │ ├── context.py
│ │ │ ├── main.py
│ │ │ └── tools
│ │ │ ├── __init__.py
│ │ │ ├── cc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── connect.py
│ │ │ │ ├── create.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── describe.py
│ │ │ │ ├── modify.py
│ │ │ │ ├── parsers.py
│ │ │ │ └── processors.py
│ │ │ ├── ce
│ │ │ │ ├── __init__.py
│ │ │ │ └── get_cost_and_usage.py
│ │ │ ├── cw
│ │ │ │ ├── __init__.py
│ │ │ │ └── get_metric_statistics.py
│ │ │ ├── cwlogs
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_log_group.py
│ │ │ │ ├── describe_log_groups.py
│ │ │ │ ├── describe_log_streams.py
│ │ │ │ ├── filter_log_events.py
│ │ │ │ └── get_log_events.py
│ │ │ ├── firehose
│ │ │ │ ├── __init__.py
│ │ │ │ └── list_delivery_streams.py
│ │ │ ├── misc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── batch_apply_update_action.py
│ │ │ │ ├── batch_stop_update_action.py
│ │ │ │ ├── describe_cache_engine_versions.py
│ │ │ │ ├── describe_engine_default_parameters.py
│ │ │ │ ├── describe_events.py
│ │ │ │ └── describe_service_updates.py
│ │ │ ├── rg
│ │ │ │ ├── __init__.py
│ │ │ │ ├── complete_migration.py
│ │ │ │ ├── connect.py
│ │ │ │ ├── create.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── describe.py
│ │ │ │ ├── modify.py
│ │ │ │ ├── parsers.py
│ │ │ │ ├── processors.py
│ │ │ │ ├── start_migration.py
│ │ │ │ └── test_migration.py
│ │ │ └── serverless
│ │ │ ├── __init__.py
│ │ │ ├── connect.py
│ │ │ ├── create.py
│ │ │ ├── delete.py
│ │ │ ├── describe.py
│ │ │ ├── models.py
│ │ │ └── modify.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_connection.py
│ │ │ ├── test_decorators.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── tools
│ │ │ ├── cc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_connect_additional.py
│ │ │ │ ├── test_connect_coverage_additional.py
│ │ │ │ ├── test_connect_coverage.py
│ │ │ │ ├── test_connect.py
│ │ │ │ ├── test_create_additional.py
│ │ │ │ ├── test_create.py
│ │ │ │ ├── test_delete.py
│ │ │ │ ├── test_describe.py
│ │ │ │ ├── test_modify.py
│ │ │ │ ├── test_parsers.py
│ │ │ │ └── test_processors.py
│ │ │ ├── ce
│ │ │ │ ├── __init__.py
│ │ │ │ └── test_get_cost_and_usage.py
│ │ │ ├── cw
│ │ │ │ └── test_get_metric_statistics.py
│ │ │ ├── cwlogs
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_create_log_group.py
│ │ │ │ ├── test_describe_log_groups.py
│ │ │ │ ├── test_describe_log_streams.py
│ │ │ │ ├── test_filter_log_events.py
│ │ │ │ └── test_get_log_events.py
│ │ │ ├── firehose
│ │ │ │ └── test_list_delivery_streams.py
│ │ │ ├── misc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_batch_apply_update_action.py
│ │ │ │ ├── test_batch_stop_update_action.py
│ │ │ │ ├── test_describe_cache_engine_versions.py
│ │ │ │ ├── test_describe_engine_default_parameters.py
│ │ │ │ ├── test_describe_events.py
│ │ │ │ └── test_describe_service_updates.py
│ │ │ ├── rg
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_complete_migration.py
│ │ │ │ ├── test_connect_additional.py
│ │ │ │ ├── test_connect_coverage_additional.py
│ │ │ │ ├── test_connect_optional_fields.py
│ │ │ │ ├── test_connect_partial_coverage.py
│ │ │ │ ├── test_connect.py
│ │ │ │ ├── test_create.py
│ │ │ │ ├── test_delete.py
│ │ │ │ ├── test_describe.py
│ │ │ │ ├── test_modify.py
│ │ │ │ ├── test_parsers.py
│ │ │ │ ├── test_processors.py
│ │ │ │ ├── test_start_migration.py
│ │ │ │ └── test_test_migration.py
│ │ │ └── serverless
│ │ │ ├── test_connect_additional.py
│ │ │ ├── test_connect_coverage_additional.py
│ │ │ ├── test_connect_optional_fields.py
│ │ │ ├── test_connect.py
│ │ │ ├── test_create.py
│ │ │ ├── test_delete.py
│ │ │ ├── test_describe.py
│ │ │ └── test_modify.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── finch-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── finch_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── build.py
│ │ │ ├── common.py
│ │ │ ├── ecr.py
│ │ │ ├── push.py
│ │ │ └── vm.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_cli_flags.py
│ │ │ ├── test_logging_configuration.py
│ │ │ ├── test_server.py
│ │ │ ├── test_utils_build.py
│ │ │ ├── test_utils_common.py
│ │ │ ├── test_utils_ecr.py
│ │ │ ├── test_utils_push.py
│ │ │ └── test_utils_vm.py
│ │ └── uv.lock
│ ├── frontend-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── frontend_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ ├── static
│ │ │ │ └── react
│ │ │ │ ├── essential-knowledge.md
│ │ │ │ └── troubleshooting.md
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ └── file_utils.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_file_utils.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ └── uv.lock
│ ├── git-repo-research-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── git_repo_research_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── defaults.py
│ │ │ ├── embeddings.py
│ │ │ ├── github_search.py
│ │ │ ├── indexer.py
│ │ │ ├── models.py
│ │ │ ├── repository.py
│ │ │ ├── search.py
│ │ │ ├── server.py
│ │ │ └── utils.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_errors_repository.py
│ │ │ ├── test_github_search_edge_cases.py
│ │ │ ├── test_graphql_github_search.py
│ │ │ ├── test_local_repository.py
│ │ │ ├── test_repository_utils.py
│ │ │ ├── test_rest_github_search.py
│ │ │ ├── test_search.py
│ │ │ ├── test_server.py
│ │ │ └── test_url_repository.py
│ │ └── uv.lock
│ ├── healthlake-mcp-server
│ │ ├── .dockerignore
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── healthlake_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── fhir_operations.py
│ │ │ ├── main.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── CONTRIBUTING.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ ├── mcp_config.json
│ │ │ └── README.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_fhir_client_comprehensive.py
│ │ │ ├── test_fhir_error_scenarios.py
│ │ │ ├── test_fhir_operations.py
│ │ │ ├── test_integration_mock_based.py
│ │ │ ├── test_main_edge_cases.py
│ │ │ ├── test_main.py
│ │ │ ├── test_mcp_integration_coverage.py
│ │ │ ├── test_models_edge_cases.py
│ │ │ ├── test_models.py
│ │ │ ├── test_readonly_mode.py
│ │ │ ├── test_server_core.py
│ │ │ ├── test_server_error_handling.py
│ │ │ ├── test_server_mcp_handlers.py
│ │ │ ├── test_server_toolhandler.py
│ │ │ └── test_server_validation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── iam-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── iam_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_client.py
│ │ │ ├── context.py
│ │ │ ├── errors.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── DESIGN_COMPLIANCE.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ ├── get_policy_document_example.py
│ │ │ └── inline_policy_demo.py
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── test_context.py
│ │ │ ├── test_errors.py
│ │ │ ├── test_inline_policies.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── lambda-tool-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── lambda_tool_mcp_server
│ │ │ ├── __init__.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ ├── README.md
│ │ │ └── sample_functions
│ │ │ ├── customer-create
│ │ │ │ └── app.py
│ │ │ ├── customer-id-from-email
│ │ │ │ └── app.py
│ │ │ ├── customer-info-from-id
│ │ │ │ └── app.py
│ │ │ └── template.yml
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_format_lambda_response.py
│ │ │ ├── test_integration_coverage.py
│ │ │ ├── test_integration.py
│ │ │ ├── test_register_lambda_functions.py
│ │ │ ├── test_schema_integration.py
│ │ │ ├── test_server_coverage_additional.py
│ │ │ ├── test_server_coverage.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── mcp-lambda-handler
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ └── mcp_lambda_handler
│ │ │ ├── __init__.py
│ │ │ ├── mcp_lambda_handler.py
│ │ │ ├── session.py
│ │ │ └── types.py
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ └── test_lambda_handler.py
│ │ └── uv.lock
│ ├── memcached-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── memcached_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common
│ │ │ │ ├── config.py
│ │ │ │ ├── connection.py
│ │ │ │ └── server.py
│ │ │ ├── context.py
│ │ │ ├── main.py
│ │ │ └── tools
│ │ │ └── cache.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── ELASTICACHECONNECT.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_cache_readonly.py
│ │ │ ├── test_cache.py
│ │ │ ├── test_connection.py
│ │ │ ├── test_init.py
│ │ │ └── test_main.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── mysql-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── mysql_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── mutable_sql_detector.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── nova-canvas-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── nova_canvas_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── novacanvas.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_models.py
│ │ │ ├── test_novacanvas.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── openapi-mcp-server
│ │ ├── .coveragerc
│ │ ├── .dockerignore
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── AUTHENTICATION.md
│ │ ├── AWS_BEST_PRACTICES.md
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── openapi_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── api
│ │ │ │ ├── __init__.py
│ │ │ │ └── config.py
│ │ │ ├── auth
│ │ │ │ ├── __init__.py
│ │ │ │ ├── api_key_auth.py
│ │ │ │ ├── auth_cache.py
│ │ │ │ ├── auth_errors.py
│ │ │ │ ├── auth_factory.py
│ │ │ │ ├── auth_protocol.py
│ │ │ │ ├── auth_provider.py
│ │ │ │ ├── base_auth.py
│ │ │ │ ├── basic_auth.py
│ │ │ │ ├── bearer_auth.py
│ │ │ │ ├── cognito_auth.py
│ │ │ │ └── register.py
│ │ │ ├── patch
│ │ │ │ └── __init__.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── generators
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── operation_prompts.py
│ │ │ │ │ └── workflow_prompts.py
│ │ │ │ ├── models.py
│ │ │ │ └── prompt_manager.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── cache_provider.py
│ │ │ ├── config.py
│ │ │ ├── error_handler.py
│ │ │ ├── http_client.py
│ │ │ ├── metrics_provider.py
│ │ │ ├── openapi_validator.py
│ │ │ └── openapi.py
│ │ ├── CHANGELOG.md
│ │ ├── DEPLOYMENT.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── OBSERVABILITY.md
│ │ ├── pyproject.toml
│ │ ├── pyrightconfig.json
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── api
│ │ │ │ └── test_config.py
│ │ │ ├── auth
│ │ │ │ ├── test_api_key_auth.py
│ │ │ │ ├── test_auth_cache.py
│ │ │ │ ├── test_auth_errors.py
│ │ │ │ ├── test_auth_factory_caching.py
│ │ │ │ ├── test_auth_factory_coverage.py
│ │ │ │ ├── test_auth_factory.py
│ │ │ │ ├── test_auth_protocol_additional.py
│ │ │ │ ├── test_auth_protocol_boost.py
│ │ │ │ ├── test_auth_protocol_coverage.py
│ │ │ │ ├── test_auth_protocol_extended.py
│ │ │ │ ├── test_auth_protocol_improved.py
│ │ │ │ ├── test_auth_protocol.py
│ │ │ │ ├── test_auth_provider_additional.py
│ │ │ │ ├── test_base_auth_coverage.py
│ │ │ │ ├── test_base_auth.py
│ │ │ │ ├── test_basic_auth.py
│ │ │ │ ├── test_bearer_auth.py
│ │ │ │ ├── test_cognito_auth_additional_coverage.py
│ │ │ │ ├── test_cognito_auth_boost_coverage.py
│ │ │ │ ├── test_cognito_auth_client_credentials.py
│ │ │ │ ├── test_cognito_auth_coverage_boost.py
│ │ │ │ ├── test_cognito_auth_exceptions.py
│ │ │ │ ├── test_cognito_auth.py
│ │ │ │ ├── test_register_coverage.py
│ │ │ │ └── test_register.py
│ │ │ ├── prompts
│ │ │ │ ├── standalone
│ │ │ │ │ ├── test_operation_prompt.py
│ │ │ │ │ ├── test_prompt_arguments.py
│ │ │ │ │ └── test_secure_operation_prompt.py
│ │ │ │ ├── test_mcp_prompt_manager_integration.py
│ │ │ │ ├── test_mcp_prompt_manager.py
│ │ │ │ ├── test_models_dict_method.py
│ │ │ │ ├── test_operation_prompts_extended.py
│ │ │ │ ├── test_prompt_manager_additional.py
│ │ │ │ ├── test_prompt_manager_comprehensive.py
│ │ │ │ ├── test_prompt_manager_coverage.py
│ │ │ │ └── test_prompt_registration.py
│ │ │ ├── README.md
│ │ │ ├── test_api_name.py
│ │ │ ├── test_cache_coverage_89.py
│ │ │ ├── test_client.py
│ │ │ ├── test_coverage_boost.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main_extended.py
│ │ │ ├── test_main.py
│ │ │ ├── test_openapi_coverage_89.py
│ │ │ ├── test_server_auth_errors.py
│ │ │ ├── test_server_coverage_boost_2.py
│ │ │ ├── test_server_coverage_boost.py
│ │ │ ├── test_server_exception_handling.py
│ │ │ ├── test_server_extended.py
│ │ │ ├── test_server_httpx_version.py
│ │ │ ├── test_server_part1.py
│ │ │ ├── test_server_route_logging.py
│ │ │ ├── test_server_signal_handlers.py
│ │ │ ├── test_server.py
│ │ │ └── utils
│ │ │ ├── test_cache_provider.py
│ │ │ ├── test_error_handler_boost.py
│ │ │ ├── test_error_handler_extended.py
│ │ │ ├── test_error_handler_fix.py
│ │ │ ├── test_error_handler.py
│ │ │ ├── test_http_client_comprehensive.py
│ │ │ ├── test_http_client_extended.py
│ │ │ ├── test_http_client_extended2.py
│ │ │ ├── test_http_client_import_error.py
│ │ │ ├── test_http_client.py
│ │ │ ├── test_metrics_provider_decorators.py
│ │ │ ├── test_metrics_provider_extended2.py
│ │ │ ├── test_metrics_provider_prometheus.py
│ │ │ ├── test_metrics_provider.py
│ │ │ ├── test_openapi_validator.py
│ │ │ └── test_openapi.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── postgres-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── postgres_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── connection
│ │ │ │ ├── __init__.py
│ │ │ │ ├── abstract_db_connection.py
│ │ │ │ ├── db_connection_singleton.py
│ │ │ │ ├── psycopg_pool_connection.py
│ │ │ │ └── rds_api_connection.py
│ │ │ ├── mutable_sql_detector.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_psycopg_connector.py
│ │ │ ├── test_server.py
│ │ │ └── test_singleton.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── prometheus-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── prometheus_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_aws_credentials.py
│ │ │ ├── test_config_manager.py
│ │ │ ├── test_consts.py
│ │ │ ├── test_coverage_gaps.py
│ │ │ ├── test_coverage_improvement.py
│ │ │ ├── test_final_coverage.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_prometheus_client.py
│ │ │ ├── test_prometheus_connection.py
│ │ │ ├── test_security_validator.py
│ │ │ ├── test_server_coverage.py
│ │ │ ├── test_tools.py
│ │ │ └── test_workspace_config.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── redshift-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── redshift_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── redshift.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_redshift.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── s3-tables-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── s3_tables_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── constants.py
│ │ │ ├── database.py
│ │ │ ├── engines
│ │ │ │ ├── __init__.py
│ │ │ │ └── pyiceberg.py
│ │ │ ├── file_processor
│ │ │ │ ├── __init__.py
│ │ │ │ ├── csv.py
│ │ │ │ ├── parquet.py
│ │ │ │ └── utils.py
│ │ │ ├── models.py
│ │ │ ├── namespaces.py
│ │ │ ├── resources.py
│ │ │ ├── s3_operations.py
│ │ │ ├── server.py
│ │ │ ├── table_buckets.py
│ │ │ ├── tables.py
│ │ │ └── utils.py
│ │ ├── CHANGELOG.md
│ │ ├── CONTEXT.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_csv.py
│ │ │ ├── test_database.py
│ │ │ ├── test_file_processor_utils.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_namespaces.py
│ │ │ ├── test_parquet.py
│ │ │ ├── test_pyiceberg.py
│ │ │ ├── test_resources.py
│ │ │ ├── test_s3_operations.py
│ │ │ ├── test_server.py
│ │ │ ├── test_table_buckets.py
│ │ │ ├── test_tables.py
│ │ │ └── test_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── stepfunctions-tool-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── stepfunctions_tool_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_helper.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── README.md
│ │ │ ├── test_aws_helper.py
│ │ │ ├── test_create_state_machine_tool.py
│ │ │ ├── test_filter_state_machines_by_tag.py
│ │ │ ├── test_format_state_machine_response.py
│ │ │ ├── test_get_schema_arn_from_state_machine_arn.py
│ │ │ ├── test_get_schema_from_registry.py
│ │ │ ├── test_invoke_express_state_machine_impl.py
│ │ │ ├── test_invoke_standard_state_machine_impl.py
│ │ │ ├── test_main.py
│ │ │ ├── test_register_state_machines.py
│ │ │ ├── test_sanitize_tool_name.py
│ │ │ ├── test_server.py
│ │ │ └── test_validate_state_machine_name.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── syntheticdata-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── syntheticdata_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── pandas_interpreter.py
│ │ │ ├── server.py
│ │ │ └── storage
│ │ │ ├── __init__.py
│ │ │ ├── base.py
│ │ │ ├── loader.py
│ │ │ └── s3.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_constants.py
│ │ │ ├── test_pandas_interpreter.py
│ │ │ ├── test_server.py
│ │ │ └── test_storage
│ │ │ ├── __init__.py
│ │ │ ├── test_loader.py
│ │ │ └── test_s3.py
│ │ └── uv.lock
│ ├── terraform-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── terraform_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── impl
│ │ │ │ ├── resources
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── terraform_aws_provider_resources_listing.py
│ │ │ │ │ └── terraform_awscc_provider_resources_listing.py
│ │ │ │ └── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── execute_terraform_command.py
│ │ │ │ ├── execute_terragrunt_command.py
│ │ │ │ ├── run_checkov_scan.py
│ │ │ │ ├── search_aws_provider_docs.py
│ │ │ │ ├── search_awscc_provider_docs.py
│ │ │ │ ├── search_specific_aws_ia_modules.py
│ │ │ │ ├── search_user_provided_module.py
│ │ │ │ └── utils.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ └── models.py
│ │ │ ├── scripts
│ │ │ │ ├── generate_aws_provider_resources.py
│ │ │ │ ├── generate_awscc_provider_resources.py
│ │ │ │ └── scrape_aws_terraform_best_practices.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ ├── __init__.py
│ │ │ ├── AWS_PROVIDER_RESOURCES.md
│ │ │ ├── AWS_TERRAFORM_BEST_PRACTICES.md
│ │ │ ├── AWSCC_PROVIDER_RESOURCES.md
│ │ │ ├── MCP_INSTRUCTIONS.md
│ │ │ └── TERRAFORM_WORKFLOW_GUIDE.md
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_command_impl.py
│ │ │ ├── test_execute_terraform_command.py
│ │ │ ├── test_execute_terragrunt_command.py
│ │ │ ├── test_models.py
│ │ │ ├── test_parameter_annotations.py
│ │ │ ├── test_resources.py
│ │ │ ├── test_run_checkov_scan.py
│ │ │ ├── test_search_user_provided_module.py
│ │ │ ├── test_server.py
│ │ │ ├── test_tool_implementations.py
│ │ │ ├── test_utils_additional.py
│ │ │ └── test_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── timestream-for-influxdb-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── timestream_for_influxdb_mcp_server
│ │ │ ├── __init__.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── valkey-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── valkey_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common
│ │ │ │ ├── __init__.py
│ │ │ │ ├── config.py
│ │ │ │ ├── connection.py
│ │ │ │ └── server.py
│ │ │ ├── context.py
│ │ │ ├── main.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── bitmap.py
│ │ │ │ ├── hash.py
│ │ │ │ ├── hyperloglog.py
│ │ │ │ ├── json.py
│ │ │ │ ├── list.py
│ │ │ │ ├── misc.py
│ │ │ │ ├── server_management.py
│ │ │ │ ├── set.py
│ │ │ │ ├── sorted_set.py
│ │ │ │ ├── stream.py
│ │ │ │ └── string.py
│ │ │ └── version.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── ELASTICACHECONNECT.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_bitmap.py
│ │ │ ├── test_config.py
│ │ │ ├── test_connection.py
│ │ │ ├── test_hash.py
│ │ │ ├── test_hyperloglog.py
│ │ │ ├── test_init.py
│ │ │ ├── test_json_additional.py
│ │ │ ├── test_json_readonly.py
│ │ │ ├── test_json.py
│ │ │ ├── test_list_additional.py
│ │ │ ├── test_list_readonly.py
│ │ │ ├── test_list.py
│ │ │ ├── test_main.py
│ │ │ ├── test_misc.py
│ │ │ ├── test_server_management.py
│ │ │ ├── test_set_readonly.py
│ │ │ ├── test_set.py
│ │ │ ├── test_sorted_set_additional.py
│ │ │ ├── test_sorted_set_readonly.py
│ │ │ ├── test_sorted_set.py
│ │ │ ├── test_stream_additional.py
│ │ │ ├── test_stream_readonly.py
│ │ │ ├── test_stream.py
│ │ │ └── test_string.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ └── well-architected-security-mcp-server
│ ├── .python-version
│ ├── awslabs
│ │ └── well_architected_security_mcp_server
│ │ ├── __init__.py
│ │ ├── consts.py
│ │ ├── server.py
│ │ └── util
│ │ ├── __init__.py
│ │ ├── network_security.py
│ │ ├── prompt_utils.py
│ │ ├── resource_utils.py
│ │ ├── security_services.py
│ │ └── storage_security.py
│ ├── PROMPT_TEMPLATE.md
│ ├── pyproject.toml
│ ├── README.md
│ ├── tests
│ │ ├── __init__.py
│ │ ├── conftest.py
│ │ ├── README.md
│ │ ├── test_access_analyzer_fix.py
│ │ ├── test_network_security_additional.py
│ │ ├── test_network_security.py
│ │ ├── test_prompt_utils_coverage.py
│ │ ├── test_prompt_utils.py
│ │ ├── test_resource_utils_fix.py
│ │ ├── test_resource_utils.py
│ │ ├── test_security_services_additional.py
│ │ ├── test_security_services_coverage.py
│ │ ├── test_security_services.py
│ │ ├── test_server_additional.py
│ │ ├── test_server_coverage.py
│ │ ├── test_server_prompts.py
│ │ ├── test_server_security_findings.py
│ │ ├── test_server.py
│ │ ├── test_storage_security_additional.py
│ │ ├── test_storage_security_comprehensive.py
│ │ ├── test_storage_security_edge_cases.py
│ │ ├── test_storage_security_recommendations.py
│ │ ├── test_storage_security.py
│ │ └── test_user_agent_config.py
│ └── uv.lock
└── VIBE_CODING_TIPS_TRICKS.md
```
# Files
--------------------------------------------------------------------------------
/src/aws-pricing-mcp-server/tests/test_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.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for the server module of the aws-pricing-mcp-server."""
import pytest
from awslabs.aws_pricing_mcp_server.models import PricingFilter
from awslabs.aws_pricing_mcp_server.pricing_transformer import (
_is_free_product,
)
from awslabs.aws_pricing_mcp_server.server import (
analyze_cdk_project_wrapper,
generate_cost_report_wrapper,
get_bedrock_patterns,
get_price_list_urls,
get_pricing,
get_pricing_attribute_values,
get_pricing_service_attributes,
get_pricing_service_codes,
)
from unittest.mock import patch
class TestAnalyzeCdkProject:
"""Tests for the analyze_cdk_project_wrapper function."""
@pytest.mark.asyncio
async def test_analyze_valid_project(self, mock_context, sample_cdk_project):
"""Test analyzing a valid CDK project."""
result = await analyze_cdk_project_wrapper(mock_context, sample_cdk_project)
assert result is not None
assert result['status'] == 'success'
assert 'services' in result
# Check for expected services
services = {service['name'] for service in result['services']}
assert 'lambda' in services
assert 'dynamodb' in services
assert 's3' in services
assert 'iam' in services
@pytest.mark.asyncio
async def test_analyze_invalid_project(self, mock_context, temp_output_dir):
"""Test analyzing an invalid/empty project directory."""
result = await analyze_cdk_project_wrapper(mock_context, temp_output_dir)
assert result is not None
assert result['status'] == 'success'
assert 'services' in result
assert (
len(result['services']) == 0
) # Empty project still returns success with empty services
@pytest.mark.asyncio
async def test_analyze_nonexistent_project(self, mock_context):
"""Test analyzing a nonexistent project directory."""
result = await analyze_cdk_project_wrapper(mock_context, '/nonexistent/path')
assert result is not None
assert 'services' in result
assert len(result['services']) == 0 # Nonexistent path returns success with empty services
class TestGetPricing:
"""Tests for the get_pricing function."""
@pytest.mark.asyncio
async def test_get_valid_pricing(self, mock_boto3, mock_context):
"""Test getting pricing for a valid service."""
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing(mock_context, 'AWSLambda', 'us-west-2')
assert result is not None
assert result['status'] == 'success'
assert result['service_name'] == 'AWSLambda'
assert 'data' in result
assert isinstance(result['data'], list)
assert len(result['data']) > 0
assert 'message' in result
assert 'AWSLambda' in result['message']
assert 'us-west-2' in result['message']
@pytest.mark.asyncio
async def test_get_pricing_with_filters(self, mock_boto3, mock_context):
"""Test getting pricing with filters."""
# Create filters using the Pydantic models
filters = [
PricingFilter(Field='instanceType', Value='t3.medium'),
PricingFilter(Field='location', Value='US East (N. Virginia)', Type='EQUALS'),
]
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing(mock_context, 'AmazonEC2', 'us-east-1', filters)
assert result is not None
assert result['status'] == 'success'
assert result['service_name'] == 'AmazonEC2'
assert isinstance(result['data'], list)
# Verify that the mocked pricing client was called with correct filters
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_products.assert_called_once()
call_args = pricing_client.get_products.call_args[1]
assert 'Filters' in call_args
assert len(call_args['Filters']) == 3 # region + 2 custom filters
# Check that our custom filters are included
filter_fields = [f['Field'] for f in call_args['Filters']]
assert 'instanceType' in filter_fields
assert 'location' in filter_fields
assert 'regionCode' in filter_fields # Always added by the function
@pytest.mark.asyncio
async def test_pricing_filter_model_validation(self):
"""Test that PricingFilter model validates correctly."""
# Test valid filter creation
valid_filter = PricingFilter(Field='instanceType', Value='t3.medium')
assert valid_filter.field == 'instanceType'
assert valid_filter.value == 't3.medium'
assert valid_filter.type == 'EQUALS'
# Test serialization with aliases
filter_dict = valid_filter.model_dump(by_alias=True)
assert 'Field' in filter_dict
assert 'Value' in filter_dict
assert 'Type' in filter_dict
assert filter_dict['Field'] == 'instanceType'
assert filter_dict['Value'] == 't3.medium'
assert filter_dict['Type'] == 'EQUALS'
@pytest.mark.asyncio
async def test_new_filter_types_validation(self):
"""Test that new filter types work correctly."""
# Test ANY_OF filter type
any_of_filter = PricingFilter(
Field='instanceType', Value=['t3.medium', 'm5.large'], Type='ANY_OF'
)
assert any_of_filter.type == 'ANY_OF'
assert any_of_filter.value == ['t3.medium', 'm5.large']
# Test CONTAINS filter type
contains_filter = PricingFilter(Field='instanceType', Value='m5', Type='CONTAINS')
assert contains_filter.type == 'CONTAINS'
assert contains_filter.value == 'm5'
# Test NONE_OF filter type
none_of_filter = PricingFilter(Field='instanceType', Value=['t2', 'm4'], Type='NONE_OF')
assert none_of_filter.type == 'NONE_OF'
assert none_of_filter.value == ['t2', 'm4']
# Test serialization converts ANY_OF and NONE_OF to comma-separated strings
any_of_dict = any_of_filter.model_dump(by_alias=True)
assert any_of_dict['Type'] == 'ANY_OF'
assert any_of_dict['Value'] == 't3.medium,m5.large' # Should be comma-separated string
contains_dict = contains_filter.model_dump(by_alias=True)
assert contains_dict['Type'] == 'CONTAINS'
assert contains_dict['Value'] == 'm5' # Should remain as string
none_of_dict = none_of_filter.model_dump(by_alias=True)
assert none_of_dict['Type'] == 'NONE_OF'
assert none_of_dict['Value'] == 't2,m4' # Should be comma-separated string
@pytest.mark.asyncio
async def test_filter_serialization_comma_separated(self):
"""Test that ANY_OF and NONE_OF filters serialize values as comma-separated strings."""
# Test ANY_OF filter serialization
any_of_filter = PricingFilter(
Field='instanceType', Value=['t3.medium', 'm5.large'], Type='ANY_OF'
)
serialized = any_of_filter.model_dump(by_alias=True)
assert serialized['Value'] == 't3.medium,m5.large' # Should be comma-separated string
assert serialized['Type'] == 'ANY_OF'
# Test NONE_OF filter serialization
none_of_filter = PricingFilter(
Field='instanceType', Value=['t2.micro', 'm4.large'], Type='NONE_OF'
)
serialized = none_of_filter.model_dump(by_alias=True)
assert serialized['Value'] == 't2.micro,m4.large' # Should be comma-separated string
assert serialized['Type'] == 'NONE_OF'
# Test EQUALS filter serialization (should not change)
equals_filter = PricingFilter(Field='instanceType', Value='m5.large', Type='EQUALS')
serialized = equals_filter.model_dump(by_alias=True)
assert serialized['Value'] == 'm5.large' # Should remain a string
assert serialized['Type'] == 'EQUALS'
# Test CONTAINS filter serialization (should not change)
contains_filter = PricingFilter(Field='instanceType', Value='m5', Type='CONTAINS')
serialized = contains_filter.model_dump(by_alias=True)
assert serialized['Value'] == 'm5' # Should remain a string
assert serialized['Type'] == 'CONTAINS'
@pytest.mark.asyncio
async def test_multi_region_pricing(self, mock_boto3, mock_context):
"""Test getting pricing for multiple regions using ANY_OF filter."""
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing(
mock_context, 'AmazonEC2', ['us-east-1', 'us-west-2', 'eu-west-1']
)
assert result is not None
assert result['status'] == 'success'
assert result['service_name'] == 'AmazonEC2'
# Verify that the mocked pricing client was called with correct multi-region filter
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_products.assert_called_once()
call_args = pricing_client.get_products.call_args[1]
assert 'Filters' in call_args
# Should have exactly one region filter (automatically added)
region_filters = [f for f in call_args['Filters'] if f['Field'] == 'regionCode']
assert len(region_filters) == 1
# The region filter should use ANY_OF with comma-separated values
region_filter = region_filters[0]
assert region_filter['Type'] == 'ANY_OF'
assert region_filter['Value'] == 'us-east-1,us-west-2,eu-west-1'
@pytest.mark.asyncio
async def test_single_region_backward_compatibility(self, mock_boto3, mock_context):
"""Test that single region strings still work with EQUALS for backward compatibility."""
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing(mock_context, 'AmazonEC2', 'us-east-1')
assert result is not None
assert result['status'] == 'success'
assert result['service_name'] == 'AmazonEC2'
# Verify that the mocked pricing client was called with EQUALS for single region
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_products.assert_called_once()
call_args = pricing_client.get_products.call_args[1]
assert 'Filters' in call_args
# Should have exactly one region filter
region_filters = [f for f in call_args['Filters'] if f['Field'] == 'regionCode']
assert len(region_filters) == 1
# The region filter should use EQUALS for backward compatibility
region_filter = region_filters[0]
assert region_filter['Type'] == 'EQUALS'
assert region_filter['Value'] == 'us-east-1'
@pytest.mark.asyncio
async def test_get_pricing_response_structure_validation(self, mock_boto3, mock_context):
"""Test that the response structure is properly validated."""
# Mock a more realistic pricing response
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_products.return_value = {
'PriceList': [
'{"product":{"sku":"ABC123","productFamily":"Compute","attributes":{"instanceType":"t3.medium"}},"terms":{"OnDemand":{"ABC123.TERM1":{"priceDimensions":{"ABC123.TERM1.DIM1":{"unit":"Hrs","pricePerUnit":{"USD":"0.0416"}}}}}},"serviceCode":"AmazonEC2"}'
]
}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing(mock_context, 'AmazonEC2', 'us-east-1')
# Validate top-level response structure
assert result['status'] == 'success'
assert result['service_name'] == 'AmazonEC2'
assert isinstance(result['data'], list)
assert len(result['data']) == 1
assert isinstance(result['message'], str)
# Validate the pricing data structure (data is already parsed from JSON)
pricing_item = result['data'][0]
# Validate required fields in pricing item
assert 'product' in pricing_item
assert 'terms' in pricing_item
assert 'sku' in pricing_item['product']
assert 'attributes' in pricing_item['product']
assert 'OnDemand' in pricing_item['terms']
# Validate pricing structure
product = pricing_item['product']
assert product['sku'] == 'ABC123'
assert 'instanceType' in product['attributes']
assert product['attributes']['instanceType'] == 't3.medium'
@pytest.mark.asyncio
async def test_get_pricing_empty_results(self, mock_boto3, mock_context):
"""Test handling of empty pricing results."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_products.return_value = {'PriceList': []}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing(mock_context, 'InvalidService', 'us-west-2')
assert result is not None
assert result['status'] == 'error'
assert result['error_type'] == 'empty_results'
assert 'InvalidService' in result['message']
assert 'No results found for given filters' in result['message']
assert result['service_code'] == 'InvalidService'
assert result['region'] == 'us-west-2'
assert 'examples' in result
assert 'Example service codes' in result['examples']
assert 'Example regions' in result['examples']
assert 'suggestion' in result
assert (
'Verify that the service code is valid. Use get_service_codes() to get valid service codes'
in result['suggestion']
)
assert (
'Validate region and filter values using get_pricing_attribute_values()'
in result['suggestion']
)
assert 'Test with fewer filters' in result['suggestion']
mock_context.error.assert_called_once()
@pytest.mark.asyncio
async def test_get_pricing_api_error(self, mock_boto3, mock_context):
"""Test handling of API errors."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_products.side_effect = Exception('API Error')
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing(mock_context, 'AWSLambda', 'us-west-2')
assert result is not None
assert result['status'] == 'error'
assert result['error_type'] == 'api_error'
assert 'API Error' in result['message']
assert result['service_code'] == 'AWSLambda'
assert result['region'] == 'us-west-2'
assert 'suggestion' in result
mock_context.error.assert_called_once()
@pytest.mark.asyncio
async def test_get_pricing_data_processing_error(self, mock_boto3, mock_context):
"""Test handling of data processing errors in transform_pricing_data."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_products.return_value = {'PriceList': ['invalid json']}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing(mock_context, 'AWSLambda', 'us-west-2')
assert result is not None
assert result['status'] == 'error'
assert result['error_type'] == 'data_processing_error'
assert 'Failed to process pricing data' in result['message']
assert result['service_code'] == 'AWSLambda'
assert result['region'] == 'us-west-2'
mock_context.error.assert_called_once()
@pytest.mark.asyncio
async def test_get_pricing_client_creation_error(self, mock_context):
"""Test handling of client creation errors."""
with patch(
'awslabs.aws_pricing_mcp_server.server.create_pricing_client',
side_effect=Exception('Client creation failed'),
):
result = await get_pricing(mock_context, 'AWSLambda', 'us-west-2')
assert result is not None
assert result['status'] == 'error'
assert result['error_type'] == 'client_creation_failed'
assert 'Failed to create AWS Pricing client' in result['message']
assert 'Client creation failed' in result['message']
assert result['service_code'] == 'AWSLambda'
assert result['region'] == 'us-west-2'
mock_context.error.assert_called_once()
@pytest.mark.asyncio
async def test_get_pricing_result_threshold_exceeded(self, mock_boto3, mock_context):
"""Test that the tool returns an error when result character count exceeds the threshold."""
# Create a mock response with large JSON records that exceed character threshold
# Each record is about 500 characters, so 100 records = ~50,000 characters (exceeds 40,000 default)
large_price_list = []
for i in range(100):
record = f'{{"sku":"SKU{i:03d}","product":{{"productFamily":"Compute Instance","attributes":{{"instanceType":"m5.large","location":"US East (N. Virginia)","tenancy":"Shared","operatingSystem":"Linux"}}}},"terms":{{"OnDemand":{{"SKU{i:03d}.JRTCKXETXF":{{"priceDimensions":{{"SKU{i:03d}.JRTCKXETXF.6YS6EN2CT7":{{"unit":"Hrs","pricePerUnit":{{"USD":"0.096"}}}}}}}}}}}}}}'
large_price_list.append(record)
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_products.return_value = {'PriceList': large_price_list}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing(
mock_context, 'AmazonEC2', 'us-east-1', max_allowed_characters=10000
)
assert result['status'] == 'error'
assert result['error_type'] == 'result_too_large'
assert 'exceeding the limit of 10,000' in result['message']
assert 'output_options={"pricing_terms": ["OnDemand"]}' in result['message']
assert 'significantly reduce response size' in result['suggestion']
assert result['total_count'] == 100
assert result['max_allowed_characters'] == 10000
assert len(result['sample_records']) == 3 # First 3 records as context
assert 'Add more specific filters' in result['suggestion']
mock_context.error.assert_called_once()
@pytest.mark.asyncio
async def test_get_pricing_unlimited_results(self, mock_boto3, mock_context):
"""Test that max_allowed_characters=-1 allows unlimited results."""
# Create a mock response with large records that would normally exceed character limit
large_price_list = []
for i in range(100):
record = f'{{"sku":"SKU{i:03d}","product":{{"productFamily":"Compute Instance","attributes":{{"instanceType":"m5.large","location":"US East (N. Virginia)","tenancy":"Shared","operatingSystem":"Linux"}}}},"terms":{{"OnDemand":{{"SKU{i:03d}.JRTCKXETXF":{{"priceDimensions":{{"SKU{i:03d}.JRTCKXETXF.6YS6EN2CT7":{{"unit":"Hrs","pricePerUnit":{{"USD":"0.096"}}}}}}}}}}}}}}'
large_price_list.append(record)
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_products.return_value = {'PriceList': large_price_list}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing(
mock_context, 'AmazonEC2', 'us-east-1', max_allowed_characters=-1
)
assert result['status'] == 'success'
assert len(result['data']) == 100 # All results should be returned
assert 'Retrieved pricing for AmazonEC2' in result['message']
mock_context.info.assert_called_once()
@pytest.mark.asyncio
async def test_get_pricing_without_region(self, mock_boto3, mock_context):
"""Test get_pricing works without region parameter for global services."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_products.return_value = {
'PriceList': ['{"sku":"ABC123","product":{"productFamily":"Data Transfer"}}']
}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing(mock_context, 'AWSDataTransfer', region=None)
assert result['status'] == 'success'
assert result['service_name'] == 'AWSDataTransfer'
# Verify no region filter was added
pricing_client.get_products.assert_called_once()
call_kwargs = pricing_client.get_products.call_args[1]
assert 'Filters' in call_kwargs
# Should have no filters since region is None and no other filters provided
assert len(call_kwargs['Filters']) == 0
@pytest.mark.asyncio
async def test_get_pricing_region_none_explicit(self, mock_boto3, mock_context):
"""Test get_pricing with explicit region=None."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_products.return_value = {
'PriceList': ['{"sku":"DEF456","product":{"productFamily":"CloudFront"}}']
}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing(mock_context, 'AmazonCloudFront', None)
assert result['status'] == 'success'
assert result['service_name'] == 'AmazonCloudFront'
# Verify API was called without region filter
pricing_client.get_products.assert_called_once()
call_kwargs = pricing_client.get_products.call_args[1]
region_filters = [f for f in call_kwargs['Filters'] if f['Field'] == 'regionCode']
assert len(region_filters) == 0
@pytest.mark.asyncio
async def test_get_pricing_with_filters_no_region(self, mock_boto3, mock_context):
"""Test get_pricing with filters but no region."""
filters = [PricingFilter(Field='operation', Value='DataTransfer-Out-Bytes')]
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_products.return_value = {
'PriceList': ['{"sku":"GHI789","product":{"productFamily":"Data Transfer"}}']
}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing(mock_context, 'AWSDataTransfer', None, filters)
assert result['status'] == 'success'
# Verify only custom filters were added, no region filter
pricing_client.get_products.assert_called_once()
call_kwargs = pricing_client.get_products.call_args[1]
assert len(call_kwargs['Filters']) == 1
assert call_kwargs['Filters'][0]['Field'] == 'operation'
@pytest.mark.asyncio
async def test_get_pricing_custom_threshold(self, mock_context, mock_boto3):
"""Test that custom max_allowed_characters threshold works correctly."""
# Create a mock response with small records that fit within lower thresholds
small_price_list = [f'{{"sku":"SKU{i}","product":{{}}}}' for i in range(10)]
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_products.return_value = {'PriceList': small_price_list}
with patch('boto3.Session', return_value=mock_boto3.Session()):
# Should succeed with threshold of 1000 characters (small records should fit)
result = await get_pricing(
mock_context, 'AmazonEC2', 'us-east-1', None, max_allowed_characters=1000
)
assert result['status'] == 'success'
assert len(result['data']) == 10
# Should fail with threshold of 100 characters (records are too large)
result = await get_pricing(
mock_context, 'AmazonEC2', 'us-east-1', None, max_allowed_characters=100
)
assert result['status'] == 'error'
assert result['error_type'] == 'result_too_large'
assert result['total_count'] == 10
assert result['max_allowed_characters'] == 100
@pytest.mark.asyncio
@pytest.mark.parametrize(
'max_results,next_token,expected_max_results,expect_next_token',
[
(None, None, 100, False), # Default values
(25, None, 25, False), # Custom max_results
(None, 'test-token-123', 100, True), # Custom next_token
(50, 'input-token-abc', 50, True), # Both parameters
],
)
async def test_get_pricing_pagination_parameters(
self,
mock_context,
mock_boto3,
max_results,
next_token,
expected_max_results,
expect_next_token,
):
"""Test various pagination parameter combinations."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_products.return_value = {'PriceList': ['{"sku":"ABC123"}']}
kwargs = {'service_code': 'AmazonEC2', 'region': 'us-east-1'}
if max_results is not None:
kwargs['max_results'] = max_results
if next_token is not None:
kwargs['next_token'] = next_token
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing(mock_context, **kwargs)
assert result['status'] == 'success'
# Verify pagination parameters were passed correctly
pricing_client.get_products.assert_called_once()
call_kwargs = pricing_client.get_products.call_args[1]
assert call_kwargs['MaxResults'] == expected_max_results
if expect_next_token:
assert call_kwargs['NextToken'] == next_token
else:
assert 'NextToken' not in call_kwargs
@pytest.mark.asyncio
@pytest.mark.parametrize(
'api_response,expected_next_token_in_result',
[
(
{'PriceList': ['{"sku":"ABC123"}'], 'NextToken': 'next-page-token-456'},
'next-page-token-456',
), # API returns NextToken
({'PriceList': ['{"sku":"ABC123"}']}, None), # API doesn't return NextToken
(
{
'PriceList': ['{"sku":"ABC123"}', '{"sku":"DEF456"}'],
'NextToken': 'final-token-789',
},
'final-token-789',
), # Multiple records with NextToken
],
)
async def test_get_pricing_response_next_token(
self, mock_context, mock_boto3, api_response, expected_next_token_in_result
):
"""Test next_token handling in response based on API response."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_products.return_value = api_response
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing(mock_context, 'AmazonEC2', 'us-east-1')
assert result['status'] == 'success'
if expected_next_token_in_result:
assert 'next_token' in result
assert result['next_token'] == expected_next_token_in_result
else:
assert 'next_token' not in result
class TestGetBedrockPatterns:
"""Tests for the get_bedrock_patterns function."""
@pytest.mark.asyncio
async def test_get_patterns(self, mock_context):
"""Test getting Bedrock architecture patterns."""
result = await get_bedrock_patterns(mock_context)
assert result is not None
assert isinstance(result, str)
assert 'Bedrock' in result
assert 'Knowledge Base' in result
class TestGenerateCostReport:
"""Tests for the generate_cost_report_wrapper function."""
@pytest.mark.asyncio
async def test_generate_markdown_report(self, mock_context, sample_pricing_data_web):
"""Test generating a markdown cost report."""
result = await generate_cost_report_wrapper(
mock_context,
pricing_data=sample_pricing_data_web,
service_name='AWS Lambda',
related_services=['DynamoDB'],
pricing_model='ON DEMAND',
assumptions=['Standard configuration'],
exclusions=['Custom configurations'],
format='markdown',
)
assert result is not None
assert isinstance(result, str)
@pytest.mark.asyncio
async def test_generate_csv_report(self, mock_context, sample_pricing_data_web):
"""Test generating a CSV cost report."""
result = await generate_cost_report_wrapper(
mock_context,
pricing_data=sample_pricing_data_web,
service_name='AWS Lambda',
format='csv',
pricing_model='ON DEMAND',
related_services=None,
assumptions=None,
exclusions=None,
output_file=None,
detailed_cost_data=None,
recommendations=None,
)
assert result is not None
assert isinstance(result, str)
assert ',' in result # Verify it's CSV format
# Verify basic structure
lines = result.split('\n')
assert len(lines) > 1 # Has header and data
@pytest.mark.asyncio
async def test_generate_report_with_detailed_data(
self, mock_context, sample_pricing_data_web, temp_output_dir
):
"""Test generating a report with detailed cost data."""
detailed_cost_data = {
'services': {
'AWS Lambda': {
'usage': '1M requests per month',
'estimated_cost': '$20.00',
'unit_pricing': {
'requests': '$0.20 per 1M requests',
'compute': '$0.0000166667 per GB-second',
},
}
}
}
result = await generate_cost_report_wrapper(
mock_context,
pricing_data=sample_pricing_data_web,
service_name='AWS Lambda',
detailed_cost_data=detailed_cost_data,
output_file=f'{temp_output_dir}/report.md',
pricing_model='ON DEMAND',
related_services=None,
assumptions=None,
exclusions=None,
recommendations=None,
)
assert result is not None
assert isinstance(result, str)
assert 'AWS Lambda' in result
assert '$20.00' in result
assert '1M requests per month' in result
@pytest.mark.asyncio
async def test_generate_report_error_handling(self, mock_context):
"""Test error handling in report generation."""
result = await generate_cost_report_wrapper(
mock_context,
pricing_data={'status': 'error'},
service_name='Invalid Service',
pricing_model='ON DEMAND',
related_services=None,
assumptions=None,
exclusions=None,
output_file=None,
detailed_cost_data=None,
recommendations=None,
)
assert '# Invalid Service Cost Analysis' in result
class TestGetPricingServiceAttributes:
"""Tests for the get_pricing_service_attributes function."""
@pytest.mark.asyncio
@pytest.mark.parametrize(
'service_code,attributes,expected',
[
(
'AmazonEC2',
['instanceType', 'location', 'tenancy', 'operatingSystem'],
['instanceType', 'location', 'operatingSystem', 'tenancy'],
),
(
'AmazonRDS',
['engineCode', 'instanceType', 'location', 'databaseEngine'],
['databaseEngine', 'engineCode', 'instanceType', 'location'],
),
],
)
async def test_get_pricing_service_attributes(
self, mock_context, mock_boto3, service_code, attributes, expected
):
"""Test getting service attributes for various AWS services."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.describe_services.return_value = {
'Services': [{'ServiceCode': service_code, 'AttributeNames': attributes}]
}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_service_attributes(mock_context, service_code)
assert result == expected
pricing_client.describe_services.assert_called_once_with(ServiceCode=service_code)
mock_context.info.assert_called()
@pytest.mark.asyncio
@pytest.mark.parametrize(
'service_code,attributes,filter_pattern,expected_matches,expected_count,test_description',
[
# Basic filtering tests
(
'AmazonEC2',
['instanceType', 'instanceFamily', 'location', 'memory', 'vcpu'],
'instance',
['instanceFamily', 'instanceType'],
None,
'basic_instance_filter',
),
(
'AmazonRDS',
['engineCode', 'instanceType', 'location', 'databaseEngine', 'storageType'],
'engine',
['databaseEngine', 'engineCode'],
None,
'engine_attributes_filter',
),
(
'AmazonEC2',
['instanceType', 'location', 'tenancy', 'operatingSystem', 'storage'],
'Type',
['instanceType', 'storageType']
if 'storageType'
in ['instanceType', 'location', 'tenancy', 'operatingSystem', 'storage']
else ['instanceType'],
None,
'case_insensitive_type_filter',
),
# Regex pattern tests
(
'AmazonEC2',
[
'instanceType',
'instanceFamily',
'location',
'memory',
'vcpu',
'networkPerformance',
],
'^instance',
['instanceFamily', 'instanceType'],
None,
'starts_with_instance_regex',
),
(
'AmazonRDS',
['engineCode', 'instanceType', 'location', 'databaseEngine', 'deploymentOption'],
'Type$',
['instanceType'],
None,
'ends_with_type_regex',
),
(
'AmazonS3',
['storageClass', 'location', 'durability', 'availability'],
'location|durability',
['durability', 'location'],
None,
'alternation_regex',
),
# No filter cases
(
'AmazonEC2',
['instanceType', 'location', 'tenancy'],
None,
None,
3,
'no_filter_all_attributes',
),
(
'AmazonRDS',
['engineCode', 'instanceType', 'location'],
'',
None,
3,
'empty_filter_all_attributes',
),
# Edge cases - removed filter_no_matches as it's properly tested in error scenarios
(
'AmazonS3',
['storageClass', 'location'],
'Storage',
['storageClass'],
None,
'case_insensitive_partial_match',
),
],
)
async def test_get_pricing_service_attributes_filtering_happy_path(
self,
mock_context,
mock_boto3,
service_code,
attributes,
filter_pattern,
expected_matches,
expected_count,
test_description,
):
"""Test successful filtering of service attributes with various regex patterns."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.describe_services.return_value = {
'Services': [{'ServiceCode': service_code, 'AttributeNames': attributes}]
}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_service_attributes(
mock_context, service_code, filter=filter_pattern
)
assert isinstance(result, list), (
f'Failed {test_description}: expected list, got {type(result)}'
)
if expected_matches is not None:
# Test specific matches
assert len(result) == len(expected_matches), (
f'Failed {test_description}: expected {len(expected_matches)} matches, got {len(result)}'
)
for attr in expected_matches:
assert attr in result, f'Failed {test_description}: missing {attr} in results'
# Verify results are sorted
assert result == sorted(result), (
f'Failed {test_description}: results not sorted properly'
)
elif expected_count is not None:
# Test count-only cases (like no filter)
assert len(result) == expected_count, (
f'Failed {test_description}: expected {expected_count} attributes, got {len(result)}'
)
pricing_client.describe_services.assert_called_once_with(ServiceCode=service_code)
mock_context.info.assert_called()
@pytest.mark.asyncio
@pytest.mark.parametrize(
'service_code,attributes,filter_pattern,expected_error_type,test_description',
[
(
'AmazonEC2',
['instanceType', 'location', 'tenancy'],
'nonexistent',
'no_matches_found',
'filter_no_matches',
),
(
'AmazonRDS',
['engineCode', 'instanceType', 'location'],
'[invalid',
'invalid_regex',
'invalid_regex_pattern',
),
(
'AmazonS3',
['storageClass', 'location'],
'\\',
'invalid_regex',
'invalid_escape_sequence',
),
],
)
async def test_get_pricing_service_attributes_filtering_errors(
self,
mock_context,
mock_boto3,
service_code,
attributes,
filter_pattern,
expected_error_type,
test_description,
):
"""Test error scenarios in service attributes filtering."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.describe_services.return_value = {
'Services': [{'ServiceCode': service_code, 'AttributeNames': attributes}]
}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_service_attributes(
mock_context, service_code, filter=filter_pattern
)
assert isinstance(result, dict), (
f'Failed {test_description}: expected dict (error), got {type(result)}'
)
assert result['status'] == 'error', f'Failed {test_description}: expected error status'
assert result['error_type'] == expected_error_type, (
f'Failed {test_description}: expected error_type {expected_error_type}, got {result.get("error_type")}'
)
assert result['service_code'] == service_code, (
f'Failed {test_description}: service_code not in error response'
)
if expected_error_type == 'invalid_regex':
assert (
filter_pattern in result['message']
or 'Invalid regex pattern' in result['message']
), f'Failed {test_description}: filter pattern or regex error not in error message'
assert 'examples' in result, (
f'Failed {test_description}: examples not provided in error response'
)
elif expected_error_type == 'no_matches_found':
assert 'No service attributes match' in result['message'], (
f'Failed {test_description}: no matches message not in error response'
)
mock_context.error.assert_called()
@pytest.mark.asyncio
@pytest.mark.parametrize(
'error_scenario,service_code,expected_error_type,expected_in_message',
[
('service_not_found', 'InvalidService', 'service_not_found', 'InvalidService'),
('api_error', 'AmazonEC2', 'api_error', 'API Error'),
(
'empty_attributes',
'TestService',
'empty_results',
'no filterable attributes available',
),
],
)
async def test_get_pricing_service_attributes_errors(
self,
mock_context,
mock_boto3,
error_scenario,
service_code,
expected_error_type,
expected_in_message,
):
"""Test various error scenarios for get_pricing_service_attributes."""
if error_scenario == 'service_not_found':
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.describe_services.return_value = {'Services': []}
elif error_scenario == 'api_error':
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.describe_services.side_effect = Exception('API Error')
elif error_scenario == 'empty_attributes':
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.describe_services.return_value = {
'Services': [{'ServiceCode': service_code, 'AttributeNames': []}]
}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_service_attributes(mock_context, service_code)
# Common assertions for all error scenarios
assert isinstance(result, dict)
assert result['status'] == 'error'
assert result['error_type'] == expected_error_type
assert expected_in_message in result['message']
assert result['service_code'] == service_code
assert 'suggestion' in result or 'examples' in result
mock_context.error.assert_called()
@pytest.mark.asyncio
async def test_get_pricing_service_attributes_client_creation_error(self, mock_context):
"""Test handling of client creation errors."""
with patch(
'awslabs.aws_pricing_mcp_server.server.create_pricing_client',
side_effect=Exception('Client creation failed'),
):
result = await get_pricing_service_attributes(mock_context, 'AmazonEC2')
assert isinstance(result, dict)
assert result['status'] == 'error'
assert result['error_type'] == 'client_creation_failed'
assert 'Failed to create AWS Pricing client' in result['message']
assert 'Client creation failed' in result['message']
assert result['service_code'] == 'AmazonEC2'
mock_context.error.assert_called()
@pytest.mark.asyncio
async def test_get_pricing_service_attributes_filter_with_api_errors(
self, mock_context, mock_boto3
):
"""Test that filtering errors are handled properly when combined with API errors."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.describe_services.side_effect = Exception('API Error')
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_service_attributes(
mock_context, 'AmazonEC2', filter='instance'
)
# Should return API error, not filter error
assert isinstance(result, dict)
assert result['status'] == 'error'
assert result['error_type'] == 'api_error'
assert 'API Error' in result['message']
mock_context.error.assert_called()
class TestGetPricingAttributeValues:
"""Tests for the get_pricing_attribute_values function."""
@pytest.mark.asyncio
@pytest.mark.parametrize(
'service_code,attribute_names,raw_values_map,filters,expected,test_description',
[
# Basic success cases without filters
(
'AmazonEC2',
['instanceType'],
{'instanceType': ['t2.micro', 't2.small', 't3.medium', 'm5.large']},
None,
{'instanceType': ['m5.large', 't2.micro', 't2.small', 't3.medium']},
'single_attribute_no_filter',
),
(
'AmazonEC2',
['instanceType', 'location'],
{
'instanceType': ['t2.micro', 't2.small', 't3.medium'],
'location': ['US East (N. Virginia)', 'US West (Oregon)', 'EU (Ireland)'],
},
None,
{
'instanceType': ['t2.micro', 't2.small', 't3.medium'],
'location': ['EU (Ireland)', 'US East (N. Virginia)', 'US West (Oregon)'],
},
'multiple_attributes_no_filter',
),
(
'AmazonRDS',
['engineCode', 'instanceType'],
{
'engineCode': ['mysql', 'postgres', 'aurora-mysql'],
'instanceType': ['db.t3.micro', 'db.t3.small'],
},
None,
{
'engineCode': ['aurora-mysql', 'mysql', 'postgres'],
'instanceType': ['db.t3.micro', 'db.t3.small'],
},
'different_service_no_filter',
),
# Success cases with filters
(
'AmazonEC2',
['instanceType', 'location'],
{
'instanceType': ['t2.micro', 't2.small', 't3.medium', 'm5.large'],
'location': ['US East (N. Virginia)', 'US West (Oregon)', 'EU (Ireland)'],
},
{'instanceType': 't3'},
{
'instanceType': ['t3.medium'], # Filtered
'location': [
'EU (Ireland)',
'US East (N. Virginia)',
'US West (Oregon)',
], # All values
},
'partial_filtering',
),
(
'AmazonEC2',
['instanceType', 'location'],
{
'instanceType': ['t2.micro', 't2.small', 't3.medium', 'm5.large'],
'location': ['US East (N. Virginia)', 'US West (Oregon)', 'EU (Ireland)'],
},
{'instanceType': 't3', 'location': 'US'},
{
'instanceType': ['t3.medium'], # Filtered
'location': ['US East (N. Virginia)', 'US West (Oregon)'], # Filtered
},
'filter_all_attributes',
),
(
'AmazonRDS',
['engineCode', 'instanceType'],
{
'engineCode': ['mysql', 'postgres', 'aurora-mysql', 'aurora-postgres'],
'instanceType': ['db.t3.micro', 'db.t3.small', 'db.m5.large'],
},
{'engineCode': '^aurora', 'instanceType': r'\.t3\.'},
{
'engineCode': ['aurora-mysql', 'aurora-postgres'], # Starts with aurora
'instanceType': ['db.t3.micro', 'db.t3.small'], # Contains .t3.
},
'regex_patterns',
),
(
'AmazonEC2',
['instanceType', 'location'],
{
'instanceType': ['t2.micro', 't2.small', 't3.medium'],
'location': ['US East (N. Virginia)', 'US West (Oregon)'],
},
{'instanceType': 'nonexistent'},
{
'instanceType': [], # No matches
'location': ['US East (N. Virginia)', 'US West (Oregon)'], # All values
},
'filter_no_matches',
),
# Additional filter test cases
(
'AmazonEC2',
['instanceType'],
{'instanceType': ['t2.micro', 't3.medium']},
{},
{'instanceType': ['t2.micro', 't3.medium']},
'empty_filters_dict',
),
(
'AmazonEC2',
['location'],
{'location': ['US East (N. Virginia)', 'US West (Oregon)', 'EU (Ireland)']},
{'location': 'us'},
{'location': ['US East (N. Virginia)', 'US West (Oregon)']},
'case_insensitive_filtering',
),
(
'AmazonEC2',
['instanceType'],
{'instanceType': ['t2.micro', 't3.medium']},
{'instanceType': 't3', 'nonRequestedAttribute': 'someFilter'},
{'instanceType': ['t3.medium']},
'ignore_non_requested_attribute_filter',
),
],
)
async def test_get_pricing_attribute_values_happy_path(
self,
mock_context,
mock_boto3,
service_code,
attribute_names,
raw_values_map,
filters,
expected,
test_description,
):
"""Test successful cases for getting attribute values with and without filtering."""
pricing_client = mock_boto3.Session().client('pricing')
# Set up mock to return different values based on the attribute name
def mock_get_attribute_values(ServiceCode, AttributeName, **kwargs):
if AttributeName in raw_values_map:
return {
'AttributeValues': [{'Value': val} for val in raw_values_map[AttributeName]]
}
return {'AttributeValues': []}
pricing_client.get_attribute_values.side_effect = mock_get_attribute_values
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_attribute_values(
mock_context, service_code, attribute_names, filters
)
assert result == expected, f"Failed test case '{test_description}'"
assert pricing_client.get_attribute_values.call_count == len(attribute_names)
mock_context.info.assert_called()
@pytest.mark.asyncio
async def test_get_pricing_attribute_values_filter_invalid_regex(
self, mock_context, mock_boto3
):
"""Test error handling when invalid regex pattern is provided."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_attribute_values.return_value = {
'AttributeValues': [{'Value': 't2.micro'}, {'Value': 't3.medium'}]
}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_attribute_values(
mock_context, 'AmazonEC2', ['instanceType'], {'instanceType': '[invalid'}
)
# Should return error due to invalid regex
assert isinstance(result, dict)
assert result['status'] == 'error'
assert result['error_type'] == 'invalid_regex'
assert 'Invalid regex pattern "[invalid"' in result['message']
assert result['service_code'] == 'AmazonEC2'
assert result['attribute_name'] == 'instanceType'
assert result['filter_pattern'] == '[invalid'
assert 'examples' in result
mock_context.error.assert_called()
@pytest.mark.asyncio
async def test_get_pricing_attribute_values_filter_for_non_requested_attribute(
self, mock_context, mock_boto3
):
"""Test that filters for non-requested attributes are ignored."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_attribute_values.return_value = {
'AttributeValues': [{'Value': 't2.micro'}, {'Value': 't3.medium'}]
}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_attribute_values(
mock_context,
'AmazonEC2',
['instanceType'],
{'instanceType': 't3', 'nonRequestedAttribute': 'someFilter'},
)
# Should succeed and ignore the filter for non-requested attribute
assert result == {'instanceType': ['t3.medium']}
assert pricing_client.get_attribute_values.call_count == 1
mock_context.info.assert_called()
@pytest.mark.asyncio
async def test_get_pricing_attribute_values_empty_filters_dict(self, mock_context, mock_boto3):
"""Test that empty filters dictionary works like no filters."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_attribute_values.return_value = {
'AttributeValues': [{'Value': 't2.micro'}, {'Value': 't3.medium'}]
}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_attribute_values(
mock_context, 'AmazonEC2', ['instanceType'], {}
)
# Should return all values (no filtering applied)
assert result == {'instanceType': ['t2.micro', 't3.medium']}
assert pricing_client.get_attribute_values.call_count == 1
mock_context.info.assert_called()
@pytest.mark.asyncio
async def test_get_pricing_attribute_values_case_insensitive_filtering(
self, mock_context, mock_boto3
):
"""Test that filtering is case-insensitive."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_attribute_values.return_value = {
'AttributeValues': [
{'Value': 'US East (N. Virginia)'},
{'Value': 'US West (Oregon)'},
{'Value': 'EU (Ireland)'},
]
}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_attribute_values(
mock_context, 'AmazonEC2', ['location'], {'location': 'us'}
)
# Should match both US regions (case-insensitive)
assert result == {'location': ['US East (N. Virginia)', 'US West (Oregon)']}
assert pricing_client.get_attribute_values.call_count == 1
mock_context.info.assert_called()
@pytest.mark.asyncio
async def test_get_pricing_attribute_values_single_attribute_with_pagination(
self, mock_context, mock_boto3
):
"""Test getting attribute values with pagination handling for single attribute."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_attribute_values.side_effect = [
{
'AttributeValues': [{'Value': 't2.micro'}, {'Value': 't2.small'}],
'NextToken': 'token',
},
{'AttributeValues': [{'Value': 't3.medium'}, {'Value': 'm5.large'}]},
]
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_attribute_values(
mock_context, 'AmazonEC2', ['instanceType']
)
expected = {'instanceType': ['m5.large', 't2.micro', 't2.small', 't3.medium']}
assert result == expected
assert pricing_client.get_attribute_values.call_count == 2
assert (
pricing_client.get_attribute_values.call_args_list[1][1].get('NextToken')
== 'token'
)
@pytest.mark.asyncio
async def test_get_pricing_attribute_values_empty_attribute_list(
self, mock_context, mock_boto3
):
"""Test error handling when empty attribute list is provided."""
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_attribute_values(mock_context, 'AmazonEC2', [])
# Verify error response structure
assert isinstance(result, dict)
assert result['status'] == 'error'
assert result['error_type'] == 'empty_attribute_list'
assert 'No attribute names provided' in result['message']
assert result['service_code'] == 'AmazonEC2'
assert result['attribute_names'] == []
assert 'get_pricing_service_attributes()' in result['suggestion']
mock_context.error.assert_called()
@pytest.mark.asyncio
async def test_get_pricing_attribute_values_single_attribute_empty(
self, mock_context, mock_boto3
):
"""Test getting attribute values when no values are returned for single attribute."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.get_attribute_values.return_value = {'AttributeValues': []}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_attribute_values(
mock_context, 'InvalidService', ['invalidAttribute']
)
# Verify error response structure
assert isinstance(result, dict)
assert result['status'] == 'error'
assert result['error_type'] == 'no_attribute_values_found'
assert 'InvalidService' in result['message']
assert 'invalidAttribute' in result['message']
assert result['service_code'] == 'InvalidService'
assert result['attribute_name'] == 'invalidAttribute'
assert result['failed_attribute'] == 'invalidAttribute'
assert result['requested_attributes'] == ['invalidAttribute']
assert 'get_service_codes()' in result['suggestion']
assert 'get_service_attributes()' in result['suggestion']
assert 'examples' in result
assert 'Common service codes' in result['examples']
assert 'Common attributes' in result['examples']
mock_context.error.assert_called()
@pytest.mark.asyncio
async def test_get_pricing_attribute_values_all_or_nothing_failure(
self, mock_context, mock_boto3
):
"""Test all-or-nothing behavior when one attribute fails in multi-attribute request."""
pricing_client = mock_boto3.Session().client('pricing')
# First attribute succeeds, second fails
def mock_get_attribute_values(ServiceCode, AttributeName, **kwargs):
if AttributeName == 'instanceType':
return {'AttributeValues': [{'Value': 't2.micro'}, {'Value': 't3.medium'}]}
elif AttributeName == 'invalidAttribute':
return {'AttributeValues': []} # Empty result causes failure
pricing_client.get_attribute_values.side_effect = mock_get_attribute_values
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_attribute_values(
mock_context, 'AmazonEC2', ['instanceType', 'invalidAttribute']
)
# Should return error because second attribute failed
assert isinstance(result, dict)
assert result['status'] == 'error'
assert result['error_type'] == 'no_attribute_values_found'
assert (
'Failed to retrieve values for attribute "invalidAttribute"' in result['message']
)
assert result['failed_attribute'] == 'invalidAttribute'
assert result['requested_attributes'] == ['instanceType', 'invalidAttribute']
@pytest.mark.asyncio
async def test_get_pricing_attribute_values_api_error_in_multi_attribute(
self, mock_context, mock_boto3
):
"""Test handling of API errors when getting attribute values in multi-attribute request."""
pricing_client = mock_boto3.Session().client('pricing')
# First attribute succeeds, second raises API error
def mock_get_attribute_values(ServiceCode, AttributeName, **kwargs):
if AttributeName == 'instanceType':
return {'AttributeValues': [{'Value': 't2.micro'}, {'Value': 't3.medium'}]}
elif AttributeName == 'location':
raise Exception('API Error')
pricing_client.get_attribute_values.side_effect = mock_get_attribute_values
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_attribute_values(
mock_context, 'AmazonEC2', ['instanceType', 'location']
)
# Should return error because second attribute had API error
assert isinstance(result, dict)
assert result['status'] == 'error'
assert result['error_type'] == 'api_error'
assert 'Failed to retrieve values for attribute "location"' in result['message']
assert 'API Error' in result['message']
assert result['failed_attribute'] == 'location'
assert result['requested_attributes'] == ['instanceType', 'location']
@pytest.mark.asyncio
async def test_get_pricing_attribute_values_client_creation_error(self, mock_context):
"""Test handling of client creation errors."""
with patch(
'awslabs.aws_pricing_mcp_server.server.create_pricing_client',
side_effect=Exception('Client creation failed'),
):
result = await get_pricing_attribute_values(
mock_context, 'AmazonEC2', ['instanceType']
)
assert isinstance(result, dict)
assert result['status'] == 'error'
assert result['error_type'] == 'client_creation_failed'
assert 'Failed to create AWS Pricing client' in result['message']
assert 'Client creation failed' in result['message']
assert result['service_code'] == 'AmazonEC2'
assert result['attribute_names'] == ['instanceType']
mock_context.error.assert_called()
class TestGetPricingServiceCodesFiltering:
"""Tests for regex filtering functionality in get_pricing_service_codes."""
@pytest.fixture
def mock_service_codes_response(self, mock_boto3):
"""Mock service codes response with a variety of AWS services for testing filters."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.describe_services.return_value = {
'Services': [
{'ServiceCode': 'AmazonBedrock'},
{'ServiceCode': 'AmazonBedrockService'},
{'ServiceCode': 'AmazonEC2'},
{'ServiceCode': 'AmazonS3'},
{'ServiceCode': 'AmazonRDS'},
{'ServiceCode': 'AWSLambda'},
{'ServiceCode': 'AmazonDynamoDB'},
{'ServiceCode': 'AmazonElasticSearch'},
{'ServiceCode': 'AmazonKendra'},
{'ServiceCode': 'AmazonSageMaker'},
]
}
return mock_boto3
@pytest.mark.asyncio
@pytest.mark.parametrize(
'filter_pattern,expected_matches,expected_count,test_description',
[
# Case sensitivity tests
('bedrock', ['AmazonBedrock', 'AmazonBedrockService'], None, 'basic_case_insensitive'),
(
'BEDROCK',
['AmazonBedrock', 'AmazonBedrockService'],
None,
'uppercase_case_insensitive',
),
('BeDrOcK', ['AmazonBedrock', 'AmazonBedrockService'], None, 'mixed_case_insensitive'),
# Regex pattern tests
('^AmazonBedrock$', ['AmazonBedrock'], None, 'exact_match_regex'),
(
'^Amazon',
[
'AmazonBedrock',
'AmazonBedrockService',
'AmazonEC2',
'AmazonS3',
'AmazonRDS',
'AmazonDynamoDB',
'AmazonElasticSearch',
'AmazonKendra',
'AmazonSageMaker',
],
None,
'starts_with_regex',
),
('Lambda|S3', ['AWSLambda', 'AmazonS3'], None, 'alternation_regex'),
('Amazon.*DB', ['AmazonDynamoDB'], None, 'wildcard_regex'),
('EC2', ['AmazonEC2'], None, 'simple_substring'),
('AWS', ['AWSLambda'], None, 'aws_prefix'),
(
'Kendra|SageMaker',
['AmazonKendra', 'AmazonSageMaker'],
None,
'multiple_alternation',
),
('Search', ['AmazonElasticSearch'], None, 'partial_match'),
# No filter cases
('', None, 10, 'empty_filter_all_services'),
(None, None, 10, 'none_filter_all_services'),
],
)
async def test_regex_filtering_happy_path(
self,
mock_context,
mock_service_codes_response,
filter_pattern,
expected_matches,
expected_count,
test_description,
):
"""Test successful regex filter patterns and no-filter cases."""
with patch('boto3.Session', return_value=mock_service_codes_response.Session()):
result = await get_pricing_service_codes(mock_context, filter=filter_pattern)
assert isinstance(result, list), (
f'Failed {test_description}: expected list, got {type(result)}'
)
if expected_matches is not None:
# Test specific matches
assert len(result) == len(expected_matches), (
f'Failed {test_description}: expected {len(expected_matches)} matches, got {len(result)}'
)
for service in expected_matches:
assert service in result, (
f'Failed {test_description}: missing {service} in results'
)
elif expected_count is not None:
# Test count-only cases (like no filter)
assert len(result) == expected_count, (
f'Failed {test_description}: expected {expected_count} services, got {len(result)}'
)
@pytest.mark.asyncio
@pytest.mark.parametrize(
'filter_pattern,expected_error_type,test_description',
[
(r'\bEC2\b', 'no_matches_found', 'word_boundary_no_matches'),
(r'\.', 'no_matches_found', 'literal_dot_no_matches'),
('NonExistentService', 'no_matches_found', 'nonexistent_service'),
('[invalid', 'invalid_regex', 'invalid_regex_pattern'),
],
)
async def test_regex_filtering_error_cases(
self,
mock_context,
mock_service_codes_response,
filter_pattern,
expected_error_type,
test_description,
):
"""Test regex filter patterns that result in errors (invalid regex or no matches)."""
with patch('boto3.Session', return_value=mock_service_codes_response.Session()):
result = await get_pricing_service_codes(mock_context, filter=filter_pattern)
assert isinstance(result, dict), (
f'Failed {test_description}: expected dict (error), got {type(result)}'
)
assert result['status'] == 'error', f'Failed {test_description}: expected error status'
assert result['error_type'] == expected_error_type, (
f'Failed {test_description}: expected error_type {expected_error_type}, got {result.get("error_type")}'
)
if expected_error_type == 'invalid_regex':
assert filter_pattern in result['message'], (
f'Failed {test_description}: filter pattern not in error message'
)
elif expected_error_type == 'no_matches_found':
assert (
'No service codes match' in result['message']
or 'no matches' in result['message'].lower()
)
mock_context.error.assert_called()
@pytest.mark.asyncio
@pytest.mark.parametrize(
'error_scenario,setup_error,expected_error_type',
[
('api_error', Exception('API Error'), 'api_error'),
('client_error', 'client_creation', 'client_creation_failed'),
],
)
async def test_filter_error_scenarios(
self, mock_context, mock_boto3, error_scenario, setup_error, expected_error_type
):
"""Test error handling scenarios with filtering enabled."""
if error_scenario == 'api_error':
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.describe_services.side_effect = setup_error
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_service_codes(mock_context, filter='bedrock')
else: # client_error
with patch(
'awslabs.aws_pricing_mcp_server.server.create_pricing_client',
side_effect=Exception('Client creation failed'),
):
result = await get_pricing_service_codes(mock_context, filter='bedrock')
assert isinstance(result, dict)
assert result['status'] == 'error'
assert result['error_type'] == expected_error_type
mock_context.error.assert_called()
@pytest.mark.asyncio
async def test_filter_with_pagination(self, mock_context, mock_boto3):
"""Test that filtering works correctly with paginated API responses."""
pricing_client = mock_boto3.Session().client('pricing')
# Set up mock with pagination
pricing_client.describe_services.side_effect = [
# First page
{
'Services': [
{'ServiceCode': 'AmazonBedrock'},
{'ServiceCode': 'AmazonEC2'},
],
'NextToken': 'page2token',
},
# Second page
{
'Services': [
{'ServiceCode': 'AmazonBedrockService'},
{'ServiceCode': 'AWSLambda'},
]
},
]
with patch('boto3.Session', return_value=mock_boto3.Session()):
# Filter for services containing "bedrock"
result = await get_pricing_service_codes(mock_context, filter='bedrock')
assert isinstance(result, list)
assert len(result) == 2 # Should find matches from both pages
assert 'AmazonBedrock' in result
assert 'AmazonBedrockService' in result
assert 'AmazonEC2' not in result
assert 'AWSLambda' not in result
class TestServerIntegration:
"""Integration tests for the server module."""
@pytest.mark.asyncio
async def test_get_pricing_service_codes_integration(self, mock_context, mock_boto3):
"""Test the get_pricing_service_codes tool returns well-known service codes."""
# Mock the boto3 pricing client response
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.describe_services.return_value = {
'Services': [
{'ServiceCode': 'AmazonEC2'},
{'ServiceCode': 'AmazonS3'},
{'ServiceCode': 'AmazonRDS'},
{'ServiceCode': 'AWSLambda'},
{'ServiceCode': 'AmazonDynamoDB'},
]
}
with patch('boto3.Session', return_value=mock_boto3.Session()):
# Call the get_pricing_service_codes function directly
service_codes = await get_pricing_service_codes(mock_context, filter=None)
# Verify we got a successful response
assert service_codes is not None
assert isinstance(service_codes, list)
# Check for well-known AWS service codes that should be present
expected_codes = ['AmazonEC2', 'AmazonS3', 'AmazonRDS', 'AWSLambda', 'AmazonDynamoDB']
# Assert that the expected codes are present in the response
for code in expected_codes:
assert code in service_codes, f'Expected service code {code} not found in response'
# Verify that the mock was called correctly
pricing_client.describe_services.assert_called()
# Verify context was used correctly
mock_context.info.assert_called()
@pytest.mark.asyncio
@pytest.mark.parametrize(
'error_scenario,side_effect,expected_error_type',
[
('client_creation_failed', 'create_pricing_client', 'client_creation_failed'),
('api_error', 'describe_services', 'api_error'),
('empty_results', None, 'empty_results'),
],
)
async def test_get_pricing_service_codes_errors(
self, mock_context, mock_boto3, error_scenario, side_effect, expected_error_type
):
"""Test error handling scenarios for get_pricing_service_codes."""
if error_scenario == 'client_creation_failed':
with patch(
'awslabs.aws_pricing_mcp_server.server.create_pricing_client',
side_effect=Exception('Client creation failed'),
):
result = await get_pricing_service_codes(mock_context)
elif error_scenario == 'api_error':
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.describe_services.side_effect = Exception('API Error')
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_service_codes(mock_context)
elif error_scenario == 'empty_results':
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.describe_services.return_value = {'Services': []}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_pricing_service_codes(mock_context)
else:
# Should not reach here with current parametrize values
raise ValueError(f'Unknown error scenario: {error_scenario}')
assert isinstance(result, dict)
assert result['status'] == 'error'
assert result['error_type'] == expected_error_type
mock_context.error.assert_called()
@pytest.mark.asyncio
async def test_get_pricing_service_codes_pagination(self, mock_context, mock_boto3):
"""Test that get_pricing_service_codes correctly handles pagination."""
# Mock the boto3 pricing client response for pagination
pricing_client = mock_boto3.Session().client('pricing')
# Set up a mock with pagination
pricing_client.describe_services.side_effect = [
# First call returns first page with NextToken
{
'Services': [
{'ServiceCode': 'AmazonEC2'},
{'ServiceCode': 'AmazonS3'},
],
'NextToken': 'page2token',
},
# Second call with NextToken returns second page
{
'Services': [
{'ServiceCode': 'AmazonRDS'},
{'ServiceCode': 'AWSLambda'},
{'ServiceCode': 'AmazonDynamoDB'},
]
# No NextToken in the response means this is the last page
},
]
with patch('boto3.Session', return_value=mock_boto3.Session()):
# Call the get_pricing_service_codes function directly
service_codes = await get_pricing_service_codes(mock_context, filter=None)
# Verify we got a successful response that combines both pages
assert service_codes is not None
assert isinstance(service_codes, list)
assert len(service_codes) == 5 # Total from both pages
# Verify pagination happened
assert pricing_client.describe_services.call_count == 2
# First call should have no NextToken
first_call_kwargs = pricing_client.describe_services.call_args_list[0][1]
assert 'NextToken' not in first_call_kwargs
# Second call should include the NextToken from the first response
second_call_kwargs = pricing_client.describe_services.call_args_list[1][1]
assert second_call_kwargs.get('NextToken') == 'page2token'
@pytest.mark.asyncio
async def test_pricing_workflow(self, mock_context, mock_boto3):
"""Test the complete pricing analysis workflow."""
# 1. Get pricing from API
with patch('boto3.Session', return_value=mock_boto3.Session()):
api_pricing = await get_pricing(mock_context, 'AWSLambda', 'us-west-2')
assert api_pricing is not None
assert api_pricing['status'] == 'success'
# 2. Generate cost report
report = await generate_cost_report_wrapper(
mock_context,
pricing_data=api_pricing,
service_name='AWS Lambda',
pricing_model='ON DEMAND',
related_services=None,
assumptions=None,
exclusions=None,
output_file=None,
detailed_cost_data=None,
recommendations=None,
)
assert report is not None
assert isinstance(report, str)
assert 'AWS Lambda' in report
class TestIsFreeProduct:
"""Tests for the _is_free_product function with multi-currency support."""
def _create_pricing_data(self, price_per_unit: dict) -> dict:
"""Helper to create test pricing data structure."""
return {
'terms': {
'OnDemand': {
'TEST.TERM.CODE': {
'priceDimensions': {'TEST.TERM.CODE.DIM': {'pricePerUnit': price_per_unit}}
}
}
}
}
@pytest.mark.parametrize(
'price_per_unit,expected_result,test_description',
[
# Test case 1: All currencies zero (truly free)
({'USD': '0.0000', 'CNY': '0.0000'}, True, 'truly_free_all_zero'),
# Test case 2: CNY only, non-zero (should be False)
({'CNY': '5.2000'}, False, 'cny_only_paid'),
# Test case 3: Free in USD, paid in CNY (should be False)
({'USD': '0.0000', 'CNY': '3.5000'}, False, 'usd_free_cny_paid'),
# Test case 4: Invalid CNY price format (should be False)
({'CNY': 'N/A'}, False, 'invalid_cny_format'),
# Test case 5: Multiple currencies with CNY paid
(
{'USD': '0.0000', 'EUR': '0.0000', 'CNY': '8.7500'},
False,
'multi_currency_cny_paid',
),
],
)
def test_is_free_product_multi_currency(
self, price_per_unit, expected_result, test_description
):
"""Test _is_free_product correctly handles CNY and other currencies."""
pricing_data = self._create_pricing_data(price_per_unit)
result = _is_free_product(pricing_data)
assert result == expected_result, (
f"Failed test case '{test_description}': "
f'Expected {expected_result}, got {result} for pricing {price_per_unit}'
)
class TestGetPriceListUrls:
"""Tests for the get_price_list_urls function."""
@pytest.mark.asyncio
async def test_get_price_list_urls_success(self, mock_context, mock_boto3):
"""Test successful retrieval of price list file URLs for all formats."""
pricing_client = mock_boto3.Session().client('pricing')
# Mock list_price_lists response
pricing_client.list_price_lists.return_value = {
'PriceLists': [
{
'PriceListArn': 'arn:aws:pricing::123456789012:price-list/AmazonEC2',
'FileFormats': ['CSV', 'JSON'],
}
]
}
# Mock get_price_list_file_url response - called for each format
pricing_client.get_price_list_file_url.side_effect = [
{'Url': 'https://example.com/pricing.csv'},
{'Url': 'https://example.com/pricing.json'},
]
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_price_list_urls(
mock_context, 'AmazonEC2', 'us-east-1', '2023-06-01 00:00'
)
# Check that we get all available format URLs
assert len(result) == 2 # csv + json
assert result['csv'] == 'https://example.com/pricing.csv'
assert result['json'] == 'https://example.com/pricing.json'
# Verify API calls
pricing_client.list_price_lists.assert_called_once_with(
ServiceCode='AmazonEC2',
EffectiveDate='2023-06-01 00:00',
RegionCode='us-east-1',
CurrencyCode='USD',
)
# Verify get_price_list_file_url was called for each format
assert pricing_client.get_price_list_file_url.call_count == 2
pricing_client.get_price_list_file_url.assert_any_call(
PriceListArn='arn:aws:pricing::123456789012:price-list/AmazonEC2', FileFormat='CSV'
)
pricing_client.get_price_list_file_url.assert_any_call(
PriceListArn='arn:aws:pricing::123456789012:price-list/AmazonEC2', FileFormat='JSON'
)
@pytest.mark.asyncio
async def test_get_price_list_urls_default_date(self, mock_context, mock_boto3):
"""Test that current timestamp is used when effective_date is not provided."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.list_price_lists.return_value = {
'PriceLists': [
{
'PriceListArn': 'arn:aws:pricing::123456789012:price-list/AmazonS3',
'FileFormats': ['CSV'],
}
]
}
pricing_client.get_price_list_file_url.return_value = {
'Url': 'https://example.com/pricing.csv'
}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_price_list_urls(mock_context, 'AmazonS3', 'us-west-2')
# Check that we get all available format URLs
assert len(result) == 1 # csv only
assert result['csv'] == 'https://example.com/pricing.csv'
@pytest.mark.asyncio
async def test_get_price_list_urls_format_failure(self, mock_context, mock_boto3):
"""Test that any format failure results in an error."""
pricing_client = mock_boto3.Session().client('pricing')
# Mock list_price_lists response with both formats
pricing_client.list_price_lists.return_value = {
'PriceLists': [
{
'PriceListArn': 'arn:aws:pricing::123456789012:price-list/AmazonEC2',
'FileFormats': ['CSV', 'JSON'],
}
]
}
# Mock CSV succeeding but JSON failing
pricing_client.get_price_list_file_url.side_effect = [
{'Url': 'https://example.com/pricing.csv'}, # CSV succeeds
Exception('Failed to get JSON URL'), # JSON fails
]
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_price_list_urls(mock_context, 'AmazonEC2', 'us-east-1')
# Should return error when any format fails
assert result['status'] == 'error'
assert result['error_type'] == 'format_url_failed'
assert 'Failed to get download URL for format "JSON"' in result['message']
assert result['price_list_arn'] == 'arn:aws:pricing::123456789012:price-list/AmazonEC2'
assert result['file_format'] == 'json'
# Verify error was logged
mock_context.error.assert_called_once()
@pytest.mark.asyncio
async def test_get_price_list_urls_no_price_lists(self, mock_context, mock_boto3):
"""Test error handling when no price lists are found."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.list_price_lists.return_value = {'PriceLists': []}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_price_list_urls(mock_context, 'InvalidService', 'us-east-1')
assert result['status'] == 'error'
assert result['error_type'] == 'no_price_list_found'
assert 'InvalidService' in result['message']
assert result['service_code'] == 'InvalidService'
assert result['region'] == 'us-east-1'
mock_context.error.assert_called()
@pytest.mark.asyncio
async def test_get_price_list_urls_unsupported_format(self, mock_context, mock_boto3):
"""Test handling when some formats are not supported."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.list_price_lists.return_value = {
'PriceLists': [
{
'PriceListArn': 'arn:aws:pricing::123456789012:price-list/AmazonEC2',
'FileFormats': ['CSV'], # Only CSV supported
}
]
}
pricing_client.get_price_list_file_url.return_value = {
'Url': 'https://example.com/pricing.csv'
}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_price_list_urls(mock_context, 'AmazonEC2', 'us-east-1')
# Should still return successful result with available formats
assert len(result) == 1 # csv only
assert result['csv'] == 'https://example.com/pricing.csv'
assert 'json' not in result # JSON format not supported
@pytest.mark.asyncio
async def test_get_price_list_urls_list_api_error(self, mock_context, mock_boto3):
"""Test error handling when list_price_lists API call fails."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.list_price_lists.side_effect = Exception('API Error')
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_price_list_urls(mock_context, 'AmazonEC2', 'us-east-1')
assert result['status'] == 'error'
assert result['error_type'] == 'list_price_lists_failed'
assert 'API Error' in result['message']
assert result['service_code'] == 'AmazonEC2'
assert result['region'] == 'us-east-1'
mock_context.error.assert_called()
@pytest.mark.asyncio
async def test_get_price_list_urls_get_url_api_error(self, mock_context, mock_boto3):
"""Test error handling when get_price_list_file_url API call fails."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.list_price_lists.return_value = {
'PriceLists': [
{
'PriceListArn': 'arn:aws:pricing::123456789012:price-list/AmazonEC2',
'FileFormats': ['CSV'],
}
]
}
pricing_client.get_price_list_file_url.side_effect = Exception('URL API Error')
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_price_list_urls(mock_context, 'AmazonEC2', 'us-east-1')
assert result['status'] == 'error'
assert result['error_type'] == 'format_url_failed'
assert 'Failed to get download URL for format "CSV"' in result['message']
assert result['price_list_arn'] == 'arn:aws:pricing::123456789012:price-list/AmazonEC2'
assert result['file_format'] == 'csv'
mock_context.error.assert_called()
@pytest.mark.asyncio
async def test_get_price_list_urls_no_download_url(self, mock_context, mock_boto3):
"""Test error handling when no download URL is returned."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.list_price_lists.return_value = {
'PriceLists': [
{
'PriceListArn': 'arn:aws:pricing::123456789012:price-list/AmazonEC2',
'FileFormats': ['CSV'],
}
]
}
pricing_client.get_price_list_file_url.return_value = {} # No URL
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_price_list_urls(mock_context, 'AmazonEC2', 'us-east-1')
assert result['status'] == 'error'
assert result['error_type'] == 'empty_url_response'
assert 'AWS API returned empty URL for format "CSV"' in result['message']
assert result['price_list_arn'] == 'arn:aws:pricing::123456789012:price-list/AmazonEC2'
assert result['file_format'] == 'csv'
mock_context.error.assert_called()
@pytest.mark.asyncio
async def test_get_price_list_urls_unexpected_error(self, mock_context):
"""Test error handling for unexpected errors."""
with patch('boto3.Session', side_effect=Exception('Unexpected Error')):
result = await get_price_list_urls(mock_context, 'AmazonEC2', 'us-east-1')
assert result['status'] == 'error'
assert result['error_type'] == 'client_creation_failed'
assert 'Unexpected Error' in result['message']
assert result['service_code'] == 'AmazonEC2'
assert result['region'] == 'us-east-1'
mock_context.error.assert_called()
@pytest.mark.asyncio
async def test_get_price_list_urls_no_supported_formats(self, mock_context, mock_boto3):
"""Test error handling when price list has no supported formats."""
pricing_client = mock_boto3.Session().client('pricing')
pricing_client.list_price_lists.return_value = {
'PriceLists': [
{
'PriceListArn': 'arn:aws:pricing::123456789012:price-list/AmazonEC2',
'FileFormats': [], # Empty list of formats
}
]
}
with patch('boto3.Session', return_value=mock_boto3.Session()):
result = await get_price_list_urls(mock_context, 'AmazonEC2', 'us-east-1')
assert result['status'] == 'error'
assert result['error_type'] == 'no_formats_available'
assert 'no file formats are available for service "AmazonEC2"' in result['message']
assert result['service_code'] == 'AmazonEC2'
assert result['region'] == 'us-east-1'
assert result['price_list_arn'] == 'arn:aws:pricing::123456789012:price-list/AmazonEC2'
mock_context.error.assert_called()
```