This is page 516 of 536. Use http://codebase.md/awslabs/mcp?lines=true&page={x} to view the full context.
# Directory Structure
```
├── .devcontainer
│ └── devcontainer.json
├── .github
│ ├── actions
│ │ ├── build-and-push-container-image
│ │ │ └── action.yml
│ │ └── clear-space-ubuntu-latest-agressively
│ │ └── action.yml
│ ├── codecov.yml
│ ├── CODEOWNERS
│ ├── dependabot.yml
│ ├── ISSUE_TEMPLATE
│ │ ├── bug_report.yml
│ │ ├── documentation.yml
│ │ ├── feature_request.yml
│ │ ├── rfc.yml
│ │ └── support_awslabs_mcp_servers.yml
│ ├── pull_request_template.md
│ ├── SECURITY
│ ├── SUPPORT
│ └── workflows
│ ├── aws-api-mcp-upgrade-version.yml
│ ├── bandit-requirements.txt
│ ├── bandit.yml
│ ├── cfn_nag.yml
│ ├── check-gh-pages-builds.yml
│ ├── check-license-header-hash.txt
│ ├── check-license-header.json
│ ├── check-license-header.yml
│ ├── checkov.yml
│ ├── codeql.yml
│ ├── dependency-review-action.yml
│ ├── detect-secrets-requirements.txt
│ ├── gh-pages.yml
│ ├── merge-prevention.yml
│ ├── powershell.yml
│ ├── pre-commit-requirements.txt
│ ├── pre-commit.yml
│ ├── pull-request-lint.yml
│ ├── python.yml
│ ├── RELEASE_INSTRUCTIONS.md
│ ├── release-initiate-branch.yml
│ ├── release-merge-tag.yml
│ ├── release.py
│ ├── release.yml
│ ├── scanners.yml
│ ├── scorecard-analysis.yml
│ ├── semgrep-requirements.txt
│ ├── semgrep.yml
│ ├── stale.yml
│ ├── trivy.yml
│ └── typescript.yml
├── .gitignore
├── .pre-commit-config.yaml
├── .python-version
├── .ruff.toml
├── .secrets.baseline
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── DESIGN_GUIDELINES.md
├── DEVELOPER_GUIDE.md
├── docs
│ └── images
│ └── root-readme
│ ├── cline-api-provider-filled.png
│ ├── cline-chat-interface.png
│ ├── cline-custom-instructions.png
│ ├── cline-select-aws-profile.png
│ ├── cline-select-bedrock.png
│ ├── configure-mcp-servers.png
│ ├── install-cline-extension.png
│ ├── mcp-servers-installed.png
│ └── select-mcp-servers.png
├── docusaurus
│ ├── .gitignore
│ ├── docs
│ │ ├── installation.md
│ │ ├── intro.md
│ │ ├── samples
│ │ │ ├── index.md
│ │ │ ├── mcp-integration-with-kb.md
│ │ │ ├── mcp-integration-with-nova-canvas.md
│ │ │ └── stepfunctions-tool-mcp-server.md
│ │ ├── servers
│ │ │ ├── amazon-bedrock-agentcore-mcp-server.md
│ │ │ ├── amazon-keyspaces-mcp-server.md
│ │ │ ├── amazon-mq-mcp-server.md
│ │ │ ├── amazon-neptune-mcp-server.md
│ │ │ ├── amazon-qbusiness-anonymous-mcp-server.md
│ │ │ ├── amazon-qindex-mcp-server.md
│ │ │ ├── amazon-sns-sqs-mcp-server.md
│ │ │ ├── aurora-dsql-mcp-server.md
│ │ │ ├── aws-api-mcp-server.md
│ │ │ ├── aws-appsync-mcp-server.md
│ │ │ ├── aws-bedrock-custom-model-import-mcp-server.md
│ │ │ ├── aws-bedrock-data-automation-mcp-server.md
│ │ │ ├── aws-dataprocessing-mcp-server.md
│ │ │ ├── aws-diagram-mcp-server.md
│ │ │ ├── aws-documentation-mcp-server.md
│ │ │ ├── aws-healthomics-mcp-server.md
│ │ │ ├── aws-iot-sitewise-mcp-server.md
│ │ │ ├── aws-knowledge-mcp-server.md
│ │ │ ├── aws-location-mcp-server.md
│ │ │ ├── aws-msk-mcp-server.md
│ │ │ ├── aws-pricing-mcp-server.md
│ │ │ ├── aws-serverless-mcp-server.md
│ │ │ ├── aws-support-mcp-server.md
│ │ │ ├── bedrock-kb-retrieval-mcp-server.md
│ │ │ ├── billing-cost-management-mcp-server.md
│ │ │ ├── ccapi-mcp-server.md
│ │ │ ├── cdk-mcp-server.md
│ │ │ ├── cfn-mcp-server.md
│ │ │ ├── cloudtrail-mcp-server.md
│ │ │ ├── cloudwatch-appsignals-mcp-server.md
│ │ │ ├── cloudwatch-mcp-server.md
│ │ │ ├── code-doc-gen-mcp-server.md
│ │ │ ├── core-mcp-server.md
│ │ │ ├── cost-explorer-mcp-server.md
│ │ │ ├── documentdb-mcp-server.md
│ │ │ ├── dynamodb-mcp-server.md
│ │ │ ├── ecs-mcp-server.md
│ │ │ ├── eks-mcp-server.md
│ │ │ ├── elasticache-mcp-server.md
│ │ │ ├── finch-mcp-server.md
│ │ │ ├── frontend-mcp-server.md
│ │ │ ├── git-repo-research-mcp-server.md
│ │ │ ├── healthlake-mcp-server.md
│ │ │ ├── iam-mcp-server.md
│ │ │ ├── kendra-index-mcp-server.md
│ │ │ ├── lambda-tool-mcp-server.md
│ │ │ ├── memcached-mcp-server.md
│ │ │ ├── mysql-mcp-server.md
│ │ │ ├── nova-canvas-mcp-server.md
│ │ │ ├── openapi-mcp-server.md
│ │ │ ├── postgres-mcp-server.md
│ │ │ ├── prometheus-mcp-server.md
│ │ │ ├── redshift-mcp-server.md
│ │ │ ├── s3-tables-mcp-server.md
│ │ │ ├── stepfunctions-tool-mcp-server.md
│ │ │ ├── syntheticdata-mcp-server.md
│ │ │ ├── terraform-mcp-server.md
│ │ │ ├── timestream-for-influxdb-mcp-server.md
│ │ │ ├── valkey-mcp-server.md
│ │ │ └── well-architected-security-mcp-server.mdx
│ │ └── vibe_coding.md
│ ├── docusaurus.config.ts
│ ├── package-lock.json
│ ├── package.json
│ ├── README.md
│ ├── sidebars.ts
│ ├── src
│ │ ├── components
│ │ │ ├── HomepageFeatures
│ │ │ │ └── styles.module.css
│ │ │ └── ServerCards
│ │ │ ├── index.tsx
│ │ │ └── styles.module.css
│ │ ├── css
│ │ │ ├── custom.css
│ │ │ └── doc-override.css
│ │ └── pages
│ │ ├── index.module.css
│ │ └── servers.tsx
│ ├── static
│ │ ├── .nojekyll
│ │ ├── assets
│ │ │ ├── icons
│ │ │ │ ├── activity.svg
│ │ │ │ ├── book-open.svg
│ │ │ │ ├── cpu.svg
│ │ │ │ ├── database.svg
│ │ │ │ ├── dollar-sign.svg
│ │ │ │ ├── help-circle.svg
│ │ │ │ ├── key.svg
│ │ │ │ ├── server.svg
│ │ │ │ ├── share-2.svg
│ │ │ │ ├── tool.svg
│ │ │ │ └── zap.svg
│ │ │ └── server-cards.json
│ │ └── img
│ │ ├── aws-logo.svg
│ │ └── logo.png
│ └── tsconfig.json
├── LICENSE
├── NOTICE
├── README.md
├── samples
│ ├── mcp-integration-with-kb
│ │ ├── .env.example
│ │ ├── .python-version
│ │ ├── assets
│ │ │ └── simplified-mcp-flow-diagram.png
│ │ ├── clients
│ │ │ └── client_server.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── user_interfaces
│ │ │ └── chat_bedrock_st.py
│ │ └── uv.lock
│ ├── mcp-integration-with-nova-canvas
│ │ ├── .env.example
│ │ ├── .python-version
│ │ ├── clients
│ │ │ └── client_server.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── user_interfaces
│ │ │ └── image_generator_st.py
│ │ └── uv.lock
│ ├── README.md
│ └── stepfunctions-tool-mcp-server
│ ├── README.md
│ └── sample_state_machines
│ ├── customer-create
│ │ └── app.py
│ ├── customer-id-from-email
│ │ └── app.py
│ ├── customer-info-from-id
│ │ └── app.py
│ └── template.yml
├── scripts
│ ├── README.md
│ └── verify_package_name.py
├── src
│ ├── amazon-bedrock-agentcore-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_bedrock_agentcore_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── config.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── cache.py
│ │ │ ├── doc_fetcher.py
│ │ │ ├── indexer.py
│ │ │ ├── text_processor.py
│ │ │ └── url_validator.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── SECURITY.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_cache.py
│ │ │ ├── test_config.py
│ │ │ ├── test_doc_fetcher.py
│ │ │ ├── test_indexer.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_server.py
│ │ │ ├── test_text_processor.py
│ │ │ └── test_url_validator.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-kendra-index-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_kendra_index_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── util.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-keyspaces-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_keyspaces_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── config.py
│ │ │ ├── consts.py
│ │ │ ├── llm_context.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── services.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_client.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_query_analysis_service.py
│ │ │ ├── test_server.py
│ │ │ └── test_services.py
│ │ └── uv.lock
│ ├── amazon-mq-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_mq_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_service_mcp_generator.py
│ │ │ ├── consts.py
│ │ │ ├── rabbitmq
│ │ │ │ ├── __init__.py
│ │ │ │ ├── admin.py
│ │ │ │ ├── connection.py
│ │ │ │ ├── doc
│ │ │ │ │ ├── rabbitmq_broker_sizing_guide.md
│ │ │ │ │ ├── rabbitmq_performance_optimization_best_practice.md
│ │ │ │ │ ├── rabbitmq_production_deployment_guidelines.md
│ │ │ │ │ ├── rabbitmq_quorum_queue_migration_guide.md
│ │ │ │ │ └── rabbitmq_setup_best_practice.md
│ │ │ │ ├── handlers.py
│ │ │ │ └── module.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── example
│ │ │ └── sample_mcp_q_cli.json
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── rabbitmq
│ │ │ │ ├── __init__.py
│ │ │ │ ├── conftest.py
│ │ │ │ ├── test_admin.py
│ │ │ │ ├── test_connection.py
│ │ │ │ ├── test_handlers.py
│ │ │ │ └── test_module.py
│ │ │ ├── test_aws_service_mcp_generator.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-neptune-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_neptune_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── exceptions.py
│ │ │ ├── graph_store
│ │ │ │ ├── __init__.py
│ │ │ │ ├── analytics.py
│ │ │ │ ├── base.py
│ │ │ │ └── database.py
│ │ │ ├── models.py
│ │ │ ├── neptune.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_analytics.py
│ │ │ ├── test_database.py
│ │ │ ├── test_exceptions.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_neptune.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-qbusiness-anonymous-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_qbusiness_anonymous_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── clients.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── amazon-qindex-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_qindex_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── clients.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_clients.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ └── uv.lock
│ ├── amazon-sns-sqs-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── amazon_sns_sqs_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── consts.py
│ │ │ ├── generator.py
│ │ │ ├── server.py
│ │ │ ├── sns.py
│ │ │ └── sqs.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── print_tools.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── README.md
│ │ │ ├── test_common.py
│ │ │ ├── test_generator.py
│ │ │ ├── test_server.py
│ │ │ ├── test_sns.py
│ │ │ └── test_sqs.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aurora-dsql-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aurora_dsql_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── mutable_sql_detector.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_connection_reuse.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_profile_option.py
│ │ │ ├── test_readonly_enforcement.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-api-mcp-server
│ │ ├── .gitattributes
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_api_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ ├── agent_scripts
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── manager.py
│ │ │ │ │ ├── models.py
│ │ │ │ │ └── registry
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── application-failure-troubleshooting.script.md
│ │ │ │ │ ├── cloudtral-mutli-region-setup.script.md
│ │ │ │ │ ├── create_amazon_aurora_db_cluster_with_instances.script.md
│ │ │ │ │ ├── lambda-timeout-debugging.script.md
│ │ │ │ │ ├── scripts_format.md
│ │ │ │ │ └── troubleshoot-permissions-with-cloudtrail-events.script.md
│ │ │ │ ├── aws
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── driver.py
│ │ │ │ │ ├── pagination.py
│ │ │ │ │ ├── regions.py
│ │ │ │ │ ├── service.py
│ │ │ │ │ └── services.py
│ │ │ │ ├── common
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── command_metadata.py
│ │ │ │ │ ├── command.py
│ │ │ │ │ ├── config.py
│ │ │ │ │ ├── errors.py
│ │ │ │ │ ├── file_operations.py
│ │ │ │ │ ├── file_system_controls.py
│ │ │ │ │ ├── helpers.py
│ │ │ │ │ ├── models.py
│ │ │ │ │ └── py.typed
│ │ │ │ ├── data
│ │ │ │ │ └── api_metadata.json
│ │ │ │ ├── metadata
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── read_only_operations_list.py
│ │ │ │ ├── parser
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── custom_validators
│ │ │ │ │ │ ├── __init__.py
│ │ │ │ │ │ ├── botocore_param_validator.py
│ │ │ │ │ │ ├── ec2_validator.py
│ │ │ │ │ │ └── ssm_validator.py
│ │ │ │ │ ├── interpretation.py
│ │ │ │ │ ├── lexer.py
│ │ │ │ │ └── parser.py
│ │ │ │ ├── py.typed
│ │ │ │ └── security
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_api_customization.json
│ │ │ │ └── policy.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── CONTRIBUTING.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── agent_scripts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_manager.py
│ │ │ │ └── test_registry
│ │ │ │ ├── another_valid_script.script.md
│ │ │ │ ├── test_script.script.md
│ │ │ │ └── valid_script.script.md
│ │ │ ├── aws
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_driver.py
│ │ │ │ ├── test_pagination.py
│ │ │ │ ├── test_service.py
│ │ │ │ └── test_services.py
│ │ │ ├── common
│ │ │ │ ├── test_command.py
│ │ │ │ ├── test_config.py
│ │ │ │ ├── test_file_operations.py
│ │ │ │ ├── test_file_system_controls.py
│ │ │ │ ├── test_file_validation.py
│ │ │ │ └── test_helpers.py
│ │ │ ├── fixtures.py
│ │ │ ├── history_handler.py
│ │ │ ├── metadata
│ │ │ │ ├── __init__.py
│ │ │ │ └── test_read_only_operations_list.py
│ │ │ ├── parser
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_file_path_detection.py
│ │ │ │ ├── test_lexer.py
│ │ │ │ ├── test_parser_customizations.py
│ │ │ │ └── test_parser.py
│ │ │ ├── test_security_policy.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-appsync-mcp-server
│ │ ├── .dockerignore
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_appsync_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── decorators.py
│ │ │ ├── helpers.py
│ │ │ ├── operations
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_api_cache.py
│ │ │ │ ├── create_api_key.py
│ │ │ │ ├── create_api.py
│ │ │ │ ├── create_channel_namespace.py
│ │ │ │ ├── create_datasource.py
│ │ │ │ ├── create_domain_name.py
│ │ │ │ ├── create_function.py
│ │ │ │ ├── create_graphql_api.py
│ │ │ │ ├── create_resolver.py
│ │ │ │ └── create_schema.py
│ │ │ ├── server.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_api_cache.py
│ │ │ │ ├── create_api_key.py
│ │ │ │ ├── create_api.py
│ │ │ │ ├── create_channel_namespace.py
│ │ │ │ ├── create_datasource.py
│ │ │ │ ├── create_domain_name.py
│ │ │ │ ├── create_function.py
│ │ │ │ ├── create_graphql_api.py
│ │ │ │ ├── create_resolver.py
│ │ │ │ └── create_schema.py
│ │ │ └── validators.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_all_create_tools_write_protection.py
│ │ │ ├── test_create_api_cache.py
│ │ │ ├── test_create_api_key.py
│ │ │ ├── test_create_api.py
│ │ │ ├── test_create_channel_namespace.py
│ │ │ ├── test_create_datasource_tool.py
│ │ │ ├── test_create_datasource.py
│ │ │ ├── test_create_domain_name.py
│ │ │ ├── test_create_function.py
│ │ │ ├── test_create_graphql_api.py
│ │ │ ├── test_create_resolver.py
│ │ │ ├── test_create_schema_tool.py
│ │ │ ├── test_create_schema.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_server.py
│ │ │ ├── test_validators.py
│ │ │ └── test_write_operation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-bedrock-custom-model-import-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_bedrock_custom_model_import_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── llm_context.py
│ │ │ ├── models.py
│ │ │ ├── prompts.py
│ │ │ ├── server.py
│ │ │ ├── services
│ │ │ │ ├── __init__.py
│ │ │ │ ├── imported_model_service.py
│ │ │ │ └── model_import_service.py
│ │ │ ├── tools
│ │ │ │ ├── create_model_import_job.py
│ │ │ │ ├── delete_imported_model.py
│ │ │ │ ├── get_imported_model.py
│ │ │ │ ├── get_model_import_job.py
│ │ │ │ ├── list_imported_models.py
│ │ │ │ └── list_model_import_jobs.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws.py
│ │ │ ├── config.py
│ │ │ ├── consts.py
│ │ │ └── matching.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── services
│ │ │ │ ├── test_imported_model_service.py
│ │ │ │ └── test_model_import_service.py
│ │ │ ├── test_client.py
│ │ │ ├── test_init.py
│ │ │ ├── test_llm_context.py
│ │ │ ├── test_prompts.py
│ │ │ ├── test_server.py
│ │ │ ├── tools
│ │ │ │ ├── test_create_model_import_job.py
│ │ │ │ ├── test_delete_imported_model.py
│ │ │ │ ├── test_get_imported_model.py
│ │ │ │ ├── test_get_model_import_job.py
│ │ │ │ ├── test_list_imported_models.py
│ │ │ │ └── test_list_model_import_jobs.py
│ │ │ └── utils
│ │ │ ├── test_aws.py
│ │ │ ├── test_config.py
│ │ │ └── test_matching.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-bedrock-data-automation-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_bedrock_data_automation_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── helpers.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-dataprocessing-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_dataprocessing_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ └── glue_data_catalog
│ │ │ │ ├── __init__.py
│ │ │ │ ├── data_catalog_database_manager.py
│ │ │ │ ├── data_catalog_handler.py
│ │ │ │ └── data_catalog_table_manager.py
│ │ │ ├── handlers
│ │ │ │ ├── __init__.py
│ │ │ │ ├── athena
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── athena_data_catalog_handler.py
│ │ │ │ │ ├── athena_query_handler.py
│ │ │ │ │ └── athena_workgroup_handler.py
│ │ │ │ ├── commons
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── common_resource_handler.py
│ │ │ │ ├── emr
│ │ │ │ │ ├── emr_ec2_cluster_handler.py
│ │ │ │ │ ├── emr_ec2_instance_handler.py
│ │ │ │ │ └── emr_ec2_steps_handler.py
│ │ │ │ └── glue
│ │ │ │ ├── __init__.py
│ │ │ │ ├── crawler_handler.py
│ │ │ │ ├── data_catalog_handler.py
│ │ │ │ ├── glue_commons_handler.py
│ │ │ │ ├── glue_etl_handler.py
│ │ │ │ ├── interactive_sessions_handler.py
│ │ │ │ └── worklows_handler.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ ├── athena_models.py
│ │ │ │ ├── common_resource_models.py
│ │ │ │ ├── data_catalog_models.py
│ │ │ │ ├── emr_models.py
│ │ │ │ └── glue_models.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws_helper.py
│ │ │ ├── consts.py
│ │ │ ├── logging_helper.py
│ │ │ └── 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
│ │ │ ├── models.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── asset_hierarchy.py
│ │ │ │ ├── bulk_import_workflow.py
│ │ │ │ ├── data_exploration.py
│ │ │ │ └── data_ingestion.py
│ │ │ ├── server.py
│ │ │ ├── tool_metadata.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── sitewise_access.py
│ │ │ │ ├── sitewise_asset_models.py
│ │ │ │ ├── sitewise_assets.py
│ │ │ │ ├── sitewise_data.py
│ │ │ │ ├── sitewise_gateways.py
│ │ │ │ └── sitewise_metadata_transfer.py
│ │ │ └── validation.py
│ │ ├── CHANGELOG.md
│ │ ├── DEVELOPMENT.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ └── wind_farm_example.py
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_server.py
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_client.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ ├── test_sitewise_access.py
│ │ │ ├── test_sitewise_asset_models.py
│ │ │ ├── test_sitewise_assets.py
│ │ │ ├── test_sitewise_data.py
│ │ │ ├── test_sitewise_gateways.py
│ │ │ ├── test_sitewise_metadata_transfer.py
│ │ │ └── test_validation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-knowledge-mcp-server
│ │ └── README.md
│ ├── aws-location-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_location_server
│ │ │ ├── __init__.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_server_integration.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-msk-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_msk_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── tools
│ │ │ ├── __init__.py
│ │ │ ├── common_functions
│ │ │ │ ├── __init__.py
│ │ │ │ ├── client_manager.py
│ │ │ │ └── common_functions.py
│ │ │ ├── logs_and_telemetry
│ │ │ │ ├── __init__.py
│ │ │ │ ├── cluster_metrics_tools.py
│ │ │ │ ├── list_customer_iam_access.py
│ │ │ │ └── metric_config.py
│ │ │ ├── mutate_cluster
│ │ │ │ ├── __init__.py
│ │ │ │ ├── batch_associate_scram_secret.py
│ │ │ │ ├── batch_disassociate_scram_secret.py
│ │ │ │ ├── create_cluster_v2.py
│ │ │ │ ├── put_cluster_policy.py
│ │ │ │ ├── reboot_broker.py
│ │ │ │ ├── update_broker_count.py
│ │ │ │ ├── update_broker_storage.py
│ │ │ │ ├── update_broker_type.py
│ │ │ │ ├── update_cluster_configuration.py
│ │ │ │ ├── update_monitoring.py
│ │ │ │ └── update_security.py
│ │ │ ├── mutate_config
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_configuration.py
│ │ │ │ ├── tag_resource.py
│ │ │ │ ├── untag_resource.py
│ │ │ │ └── update_configuration.py
│ │ │ ├── mutate_vpc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_vpc_connection.py
│ │ │ │ ├── delete_vpc_connection.py
│ │ │ │ └── reject_client_vpc_connection.py
│ │ │ ├── read_cluster
│ │ │ │ ├── __init__.py
│ │ │ │ ├── describe_cluster_operation.py
│ │ │ │ ├── describe_cluster.py
│ │ │ │ ├── get_bootstrap_brokers.py
│ │ │ │ ├── get_cluster_policy.py
│ │ │ │ ├── get_compatible_kafka_versions.py
│ │ │ │ ├── list_client_vpc_connections.py
│ │ │ │ ├── list_cluster_operations.py
│ │ │ │ ├── list_nodes.py
│ │ │ │ └── list_scram_secrets.py
│ │ │ ├── read_config
│ │ │ │ ├── __init__.py
│ │ │ │ ├── describe_configuration_revision.py
│ │ │ │ ├── describe_configuration.py
│ │ │ │ ├── list_configuration_revisions.py
│ │ │ │ └── list_tags_for_resource.py
│ │ │ ├── read_global
│ │ │ │ ├── __init__.py
│ │ │ │ ├── list_clusters.py
│ │ │ │ ├── list_configurations.py
│ │ │ │ ├── list_kafka_versions.py
│ │ │ │ └── list_vpc_connections.py
│ │ │ ├── read_vpc
│ │ │ │ ├── __init__.py
│ │ │ │ └── describe_vpc_connection.py
│ │ │ └── static_tools
│ │ │ ├── __init__.py
│ │ │ └── cluster_best_practices.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_client_manager.py
│ │ │ ├── test_cluster_metrics_tools.py
│ │ │ ├── test_common_functions.py
│ │ │ ├── test_create_cluster_v2.py
│ │ │ ├── test_create_configuration.py
│ │ │ ├── test_create_vpc_connection.py
│ │ │ ├── test_delete_vpc_connection.py
│ │ │ ├── test_describe_cluster_operation.py
│ │ │ ├── test_describe_cluster.py
│ │ │ ├── test_describe_configuration_revision.py
│ │ │ ├── test_describe_configuration.py
│ │ │ ├── test_describe_vpc_connection.py
│ │ │ ├── test_get_bootstrap_brokers.py
│ │ │ ├── test_get_cluster_policy.py
│ │ │ ├── test_get_compatible_kafka_versions.py
│ │ │ ├── test_init.py
│ │ │ ├── test_list_client_vpc_connections.py
│ │ │ ├── test_list_cluster_operations.py
│ │ │ ├── test_list_clusters.py
│ │ │ ├── test_list_configuration_revisions.py
│ │ │ ├── test_list_configurations.py
│ │ │ ├── test_list_customer_iam_access.py
│ │ │ ├── test_list_kafka_versions.py
│ │ │ ├── test_list_nodes.py
│ │ │ ├── test_list_scram_secrets.py
│ │ │ ├── test_list_tags_for_resource.py
│ │ │ ├── test_list_vpc_connections.py
│ │ │ ├── test_logs_and_telemetry.py
│ │ │ ├── test_main.py
│ │ │ ├── test_mutate_cluster_init.py
│ │ │ ├── test_mutate_cluster_success_cases.py
│ │ │ ├── test_mutate_cluster.py
│ │ │ ├── test_mutate_config_init.py
│ │ │ ├── test_mutate_vpc_init.py
│ │ │ ├── test_read_cluster_init_updated.py
│ │ │ ├── test_read_cluster_init.py
│ │ │ ├── test_read_config_init.py
│ │ │ ├── test_read_global_init.py
│ │ │ ├── test_read_vpc_init.py
│ │ │ ├── test_reject_client_vpc_connection.py
│ │ │ ├── test_server.py
│ │ │ ├── test_static_tools_init.py
│ │ │ ├── test_tag_resource.py
│ │ │ ├── test_tool_descriptions.py
│ │ │ ├── test_untag_resource.py
│ │ │ └── test_update_configuration.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-pricing-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_pricing_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── cdk_analyzer.py
│ │ │ ├── consts.py
│ │ │ ├── helpers.py
│ │ │ ├── models.py
│ │ │ ├── pricing_client.py
│ │ │ ├── pricing_transformer.py
│ │ │ ├── report_generator.py
│ │ │ ├── server.py
│ │ │ ├── static
│ │ │ │ ├── __init__.py
│ │ │ │ ├── COST_REPORT_TEMPLATE.md
│ │ │ │ └── patterns
│ │ │ │ ├── __init__.py
│ │ │ │ └── BEDROCK.md
│ │ │ └── terraform_analyzer.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_cdk_analyzer.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_pricing_client.py
│ │ │ ├── test_pricing_transformer.py
│ │ │ ├── test_report_generator.py
│ │ │ ├── test_server.py
│ │ │ └── test_terraform_analyzer.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-serverless-mcp-server
│ │ ├── .pre-commit.config.yaml
│ │ ├── .python-version
│ │ ├── .secrets.baseline
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_serverless_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── models.py
│ │ │ ├── resources
│ │ │ │ ├── __init__.py
│ │ │ │ ├── deployment_details.py
│ │ │ │ ├── deployment_list.py
│ │ │ │ ├── template_details.py
│ │ │ │ └── template_list.py
│ │ │ ├── server.py
│ │ │ ├── template
│ │ │ │ ├── __init__.py
│ │ │ │ ├── registry.py
│ │ │ │ ├── renderer.py
│ │ │ │ └── templates
│ │ │ │ ├── backend.j2
│ │ │ │ ├── frontend.j2
│ │ │ │ ├── fullstack.j2
│ │ │ │ └── README.md
│ │ │ ├── templates
│ │ │ │ ├── __init__.py
│ │ │ │ └── iam_policies.py
│ │ │ ├── tools
│ │ │ │ ├── common
│ │ │ │ │ └── base_tool.py
│ │ │ │ ├── esm
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── esm_diagnosis.py
│ │ │ │ │ ├── esm_guidance.py
│ │ │ │ │ ├── esm_recommend.py
│ │ │ │ │ └── secure_esm_guidance.py
│ │ │ │ ├── guidance
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── deploy_serverless_app_help.py
│ │ │ │ │ ├── get_iac_guidance.py
│ │ │ │ │ ├── get_lambda_event_schemas.py
│ │ │ │ │ ├── get_lambda_guidance.py
│ │ │ │ │ └── get_serverless_templates.py
│ │ │ │ ├── poller
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── esm_diagnosis.py
│ │ │ │ │ ├── esm_guidance.py
│ │ │ │ │ └── esm_recommend.py
│ │ │ │ ├── sam
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── sam_build.py
│ │ │ │ │ ├── sam_deploy.py
│ │ │ │ │ ├── sam_init.py
│ │ │ │ │ ├── sam_local_invoke.py
│ │ │ │ │ └── sam_logs.py
│ │ │ │ ├── schemas
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── describe_schema.py
│ │ │ │ │ ├── list_registries.py
│ │ │ │ │ └── search_schema.py
│ │ │ │ └── webapps
│ │ │ │ ├── __init__.py
│ │ │ │ ├── configure_domain.py
│ │ │ │ ├── deploy_webapp.py
│ │ │ │ ├── get_metrics.py
│ │ │ │ ├── update_webapp_frontend.py
│ │ │ │ ├── utils
│ │ │ │ │ ├── deploy_service.py
│ │ │ │ │ ├── frontend_uploader.py
│ │ │ │ │ └── startup_script_generator.py
│ │ │ │ └── webapp_deployment_help.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws_client_helper.py
│ │ │ ├── cloudformation.py
│ │ │ ├── const.py
│ │ │ ├── data_scrubber.py
│ │ │ ├── deployment_manager.py
│ │ │ ├── github.py
│ │ │ └── process.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_cloudformation.py
│ │ │ ├── test_configure_domain.py
│ │ │ ├── test_data_scrubber.py
│ │ │ ├── test_deploy_serverless_app_help.py
│ │ │ ├── test_deploy_service.py
│ │ │ ├── test_deploy_webapp.py
│ │ │ ├── test_deployment_details.py
│ │ │ ├── test_deployment_help.py
│ │ │ ├── test_deployment_list.py
│ │ │ ├── test_deployment_manager.py
│ │ │ ├── test_esm_diagnosis.py
│ │ │ ├── test_esm_guidance.py
│ │ │ ├── test_esm_recommend.py
│ │ │ ├── test_frontend_uploader.py
│ │ │ ├── test_get_iac_guidance.py
│ │ │ ├── test_get_lambda_event_schemas.py
│ │ │ ├── test_get_lambda_guidance.py
│ │ │ ├── test_get_metrics.py
│ │ │ ├── test_get_serverless_templates.py
│ │ │ ├── test_github.py
│ │ │ ├── test_iam_policies.py
│ │ │ ├── test_models.py
│ │ │ ├── test_process.py
│ │ │ ├── test_sam_build.py
│ │ │ ├── test_sam_deploy.py
│ │ │ ├── test_sam_init.py
│ │ │ ├── test_sam_local_invoke.py
│ │ │ ├── test_sam_logs.py
│ │ │ ├── test_schemas.py
│ │ │ ├── test_secure_esm_guidance.py
│ │ │ ├── test_server.py
│ │ │ ├── test_startup_script_generator.py
│ │ │ ├── test_template_details.py
│ │ │ ├── test_template_list.py
│ │ │ ├── test_template_registry.py
│ │ │ ├── test_template_renderer.py
│ │ │ └── test_update_webapp_frontend.py
│ │ └── uv.lock
│ ├── aws-support-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_support_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── consts.py
│ │ │ ├── debug_helper.py
│ │ │ ├── errors.py
│ │ │ ├── formatters.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftests.py
│ │ │ ├── test_aws_support_mcp_server.py
│ │ │ └── test_models.py
│ │ └── uv.lock
│ ├── bedrock-kb-retrieval-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── bedrock_kb_retrieval_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── knowledgebases
│ │ │ │ ├── __init__.py
│ │ │ │ ├── clients.py
│ │ │ │ ├── discovery.py
│ │ │ │ └── retrieval.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_clients.py
│ │ │ ├── test_discovery.py
│ │ │ ├── test_env_config.py
│ │ │ ├── test_models.py
│ │ │ ├── test_retrieval.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── billing-cost-management-mcp-server
│ │ ├── __init__.py
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── billing_cost_management_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── models.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── decorator.py
│ │ │ │ ├── graviton_migration.py
│ │ │ │ ├── README.md
│ │ │ │ ├── savings_plans.py
│ │ │ │ └── types.py
│ │ │ ├── server.py
│ │ │ ├── templates
│ │ │ │ └── recommendation_templates
│ │ │ │ ├── ebs_volume.template
│ │ │ │ ├── ec2_asg.template
│ │ │ │ ├── ec2_instance.template
│ │ │ │ ├── ecs_service.template
│ │ │ │ ├── idle.template
│ │ │ │ ├── lambda_function.template
│ │ │ │ ├── rds_database.template
│ │ │ │ ├── reserved_instances.template
│ │ │ │ └── savings_plans.template
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_pricing_operations.py
│ │ │ │ ├── aws_pricing_tools.py
│ │ │ │ ├── bcm_pricing_calculator_tools.py
│ │ │ │ ├── budget_tools.py
│ │ │ │ ├── compute_optimizer_tools.py
│ │ │ │ ├── cost_anomaly_tools.py
│ │ │ │ ├── cost_comparison_tools.py
│ │ │ │ ├── cost_explorer_operations.py
│ │ │ │ ├── cost_explorer_tools.py
│ │ │ │ ├── cost_optimization_hub_helpers.py
│ │ │ │ ├── cost_optimization_hub_tools.py
│ │ │ │ ├── free_tier_usage_tools.py
│ │ │ │ ├── recommendation_details_tools.py
│ │ │ │ ├── ri_performance_tools.py
│ │ │ │ ├── sp_performance_tools.py
│ │ │ │ ├── storage_lens_tools.py
│ │ │ │ └── unified_sql_tools.py
│ │ │ └── utilities
│ │ │ ├── __init__.py
│ │ │ ├── aws_service_base.py
│ │ │ ├── constants.py
│ │ │ ├── logging_utils.py
│ │ │ └── sql_utils.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── requirements.txt
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ └── test_prompts.py
│ │ │ ├── README.md
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── fixtures.py
│ │ │ │ ├── test_aws_bcm_pricing_calculator_tools.py
│ │ │ │ ├── test_aws_pricing_tools.py
│ │ │ │ ├── test_budget_tools.py
│ │ │ │ ├── test_compute_optimizer_tools.py
│ │ │ │ ├── test_cost_anomaly_tools_enhanced.py
│ │ │ │ ├── test_cost_anomaly_tools.py
│ │ │ │ ├── test_cost_comparison_tools.py
│ │ │ │ ├── test_cost_explorer_operations.py
│ │ │ │ ├── test_cost_explorer_tools.py
│ │ │ │ ├── test_cost_optimization_hub_helpers.py
│ │ │ │ ├── test_cost_optimization_hub_tools.py
│ │ │ │ ├── test_free_tier_usage_tools_new.py
│ │ │ │ ├── test_recommendation_details_tools.py
│ │ │ │ ├── test_ri_performance_tools.py
│ │ │ │ ├── test_sp_performance_tools.py
│ │ │ │ ├── test_storage_lens_tools.py
│ │ │ │ └── test_unified_sql_tools.py
│ │ │ └── utilities
│ │ │ ├── test_aws_service_base.py
│ │ │ └── test_sql_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── ccapi-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── ccapi_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_client.py
│ │ │ ├── cloud_control_utils.py
│ │ │ ├── context.py
│ │ │ ├── errors.py
│ │ │ ├── iac_generator.py
│ │ │ ├── impl
│ │ │ │ ├── __init__.py
│ │ │ │ ├── tools
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── explanation.py
│ │ │ │ │ ├── infrastructure_generation.py
│ │ │ │ │ ├── resource_operations.py
│ │ │ │ │ ├── security_scanning.py
│ │ │ │ │ └── session_management.py
│ │ │ │ └── utils
│ │ │ │ ├── __init__.py
│ │ │ │ └── validation.py
│ │ │ ├── infrastructure_generator.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ └── models.py
│ │ │ ├── schema_manager.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ └── __init__.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_aws_client.py
│ │ │ ├── test_checkov_install.py
│ │ │ ├── test_cloud_control_utils.py
│ │ │ ├── test_context.py
│ │ │ ├── test_errors.py
│ │ │ ├── test_explanation.py
│ │ │ ├── test_iac_generator.py
│ │ │ ├── test_infrastructure_generation.py
│ │ │ ├── test_infrastructure_generator.py
│ │ │ ├── test_models.py
│ │ │ ├── test_resource_operations.py
│ │ │ ├── test_schema_manager.py
│ │ │ ├── test_security_scanning.py
│ │ │ ├── test_server.py
│ │ │ ├── test_session_management.py
│ │ │ └── test_validation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cdk-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cdk_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ ├── resources.py
│ │ │ │ ├── search_utils.py
│ │ │ │ ├── server.py
│ │ │ │ └── tools.py
│ │ │ ├── data
│ │ │ │ ├── __init__.py
│ │ │ │ ├── cdk_nag_parser.py
│ │ │ │ ├── construct_descriptions.py
│ │ │ │ ├── genai_cdk_loader.py
│ │ │ │ ├── lambda_layer_parser.py
│ │ │ │ ├── lambda_powertools_loader.py
│ │ │ │ ├── schema_generator.py
│ │ │ │ └── solutions_constructs_parser.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ ├── __init__.py
│ │ │ ├── CDK_GENERAL_GUIDANCE.md
│ │ │ ├── CDK_NAG_GUIDANCE.md
│ │ │ └── lambda_powertools
│ │ │ ├── bedrock.md
│ │ │ ├── cdk.md
│ │ │ ├── dependencies.md
│ │ │ ├── index.md
│ │ │ ├── insights.md
│ │ │ ├── logging.md
│ │ │ ├── metrics.md
│ │ │ └── tracing.md
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── test_resources_enhanced.py
│ │ │ │ ├── test_resources.py
│ │ │ │ ├── test_search_utils.py
│ │ │ │ ├── test_server.py
│ │ │ │ └── test_tools.py
│ │ │ └── data
│ │ │ ├── test_cdk_nag_parser.py
│ │ │ ├── test_genai_cdk_loader.py
│ │ │ ├── test_lambda_powertools_loader.py
│ │ │ ├── test_schema_generator.py
│ │ │ └── test_solutions_constructs_parser.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cfn-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cfn_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_client.py
│ │ │ ├── cloud_control_utils.py
│ │ │ ├── context.py
│ │ │ ├── errors.py
│ │ │ ├── iac_generator.py
│ │ │ ├── schema_manager.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_aws_client.py
│ │ │ ├── test_cloud_control_utils.py
│ │ │ ├── test_errors.py
│ │ │ ├── test_iac_generator.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_schema_manager.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cloudtrail-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cloudtrail_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── tools.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ └── test_tools.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cloudwatch-appsignals-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cloudwatch_appsignals_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── audit_presentation_utils.py
│ │ │ ├── audit_utils.py
│ │ │ ├── aws_clients.py
│ │ │ ├── canary_utils.py
│ │ │ ├── server.py
│ │ │ ├── service_audit_utils.py
│ │ │ ├── service_tools.py
│ │ │ ├── sli_report_client.py
│ │ │ ├── slo_tools.py
│ │ │ ├── trace_tools.py
│ │ │ └── utils.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_audit_presentation_utils.py
│ │ │ ├── test_audit_utils.py
│ │ │ ├── test_aws_profile.py
│ │ │ ├── test_canary_utils.py
│ │ │ ├── test_initialization.py
│ │ │ ├── test_server_audit_functions.py
│ │ │ ├── test_server_audit_tools.py
│ │ │ ├── test_server.py
│ │ │ ├── test_service_audit_utils.py
│ │ │ ├── test_service_tools_operations.py
│ │ │ ├── test_sli_report_client.py
│ │ │ ├── test_slo_tools.py
│ │ │ └── test_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cloudwatch-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cloudwatch_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── cloudwatch_alarms
│ │ │ │ ├── models.py
│ │ │ │ └── tools.py
│ │ │ ├── cloudwatch_logs
│ │ │ │ ├── models.py
│ │ │ │ └── tools.py
│ │ │ ├── cloudwatch_metrics
│ │ │ │ ├── data
│ │ │ │ │ └── metric_metadata.json
│ │ │ │ ├── models.py
│ │ │ │ └── tools.py
│ │ │ ├── common.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── cloudwatch_alarms
│ │ │ │ ├── test_active_alarms.py
│ │ │ │ ├── test_alarm_history_integration.py
│ │ │ │ ├── test_alarm_history.py
│ │ │ │ └── test_alarms_error_handling.py
│ │ │ ├── cloudwatch_logs
│ │ │ │ ├── test_logs_error_handling.py
│ │ │ │ ├── test_logs_models.py
│ │ │ │ └── test_logs_server.py
│ │ │ ├── cloudwatch_metrics
│ │ │ │ ├── test_metrics_error_handling.py
│ │ │ │ ├── test_metrics_models.py
│ │ │ │ ├── test_metrics_server.py
│ │ │ │ └── test_validation_error.py
│ │ │ ├── test_common_and_server.py
│ │ │ ├── test_init.py
│ │ │ └── test_main.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── code-doc-gen-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── code_doc_gen_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── doc_generator.py
│ │ │ ├── models.py
│ │ │ ├── repomix_manager.py
│ │ │ └── templates.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_doc_generator_edge_cases.py
│ │ │ ├── test_doc_generator.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_repomix_manager_scenarios.py
│ │ │ ├── test_repomix_manager.py
│ │ │ ├── test_repomix_statistics.py
│ │ │ ├── test_server_extended.py
│ │ │ ├── test_server.py
│ │ │ └── test_templates.py
│ │ └── uv.lock
│ ├── core-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── core_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ ├── __init__.py
│ │ │ └── PROMPT_UNDERSTANDING.md
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_response_types.py
│ │ │ ├── test_server.py
│ │ │ └── test_static.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cost-explorer-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cost_explorer_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── comparison_handler.py
│ │ │ ├── constants.py
│ │ │ ├── cost_usage_handler.py
│ │ │ ├── forecasting_handler.py
│ │ │ ├── helpers.py
│ │ │ ├── metadata_handler.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── utility_handler.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_comparison_handler.py
│ │ │ ├── test_cost_usage_handler.py
│ │ │ ├── test_forecasting_handler.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_metadata_handler.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ └── test_utility_handler.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── documentdb-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ └── documentdb_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── analytic_tools.py
│ │ │ ├── config.py
│ │ │ ├── connection_tools.py
│ │ │ ├── db_management_tools.py
│ │ │ ├── query_tools.py
│ │ │ ├── server.py
│ │ │ └── write_tools.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_analytic_tools.py
│ │ │ ├── test_connection_tools.py
│ │ │ ├── test_db_management_tools.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_query_tools.py
│ │ │ └── test_write_tools.py
│ │ └── uv.lock
│ ├── dynamodb-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── dynamodb_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── database_analysis_queries.py
│ │ │ ├── database_analyzers.py
│ │ │ ├── prompts
│ │ │ │ └── dynamodb_architect.md
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── evals
│ │ │ │ ├── dynamic_evaluators.py
│ │ │ │ ├── evaluation_registry.py
│ │ │ │ ├── logging_config.py
│ │ │ │ ├── multiturn_evaluator.py
│ │ │ │ ├── README.md
│ │ │ │ ├── scenarios.py
│ │ │ │ └── test_dspy_evals.py
│ │ │ ├── test_dynamodb_server.py
│ │ │ └── test_source_db_integration.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── ecs-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── ecs_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── api
│ │ │ │ ├── __init__.py
│ │ │ │ ├── containerize.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── ecs_troubleshooting.py
│ │ │ │ ├── infrastructure.py
│ │ │ │ ├── resource_management.py
│ │ │ │ ├── status.py
│ │ │ │ └── troubleshooting_tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── detect_image_pull_failures.py
│ │ │ │ ├── fetch_cloudformation_status.py
│ │ │ │ ├── fetch_network_configuration.py
│ │ │ │ ├── fetch_service_events.py
│ │ │ │ ├── fetch_task_failures.py
│ │ │ │ ├── fetch_task_logs.py
│ │ │ │ ├── get_ecs_troubleshooting_guidance.py
│ │ │ │ └── utils.py
│ │ │ ├── main.py
│ │ │ ├── modules
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_knowledge_proxy.py
│ │ │ │ ├── containerize.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── deployment_status.py
│ │ │ │ ├── infrastructure.py
│ │ │ │ ├── resource_management.py
│ │ │ │ └── troubleshooting.py
│ │ │ ├── templates
│ │ │ │ ├── ecr_infrastructure.json
│ │ │ │ └── ecs_infrastructure.json
│ │ │ └── utils
│ │ │ ├── arn_parser.py
│ │ │ ├── aws.py
│ │ │ ├── config.py
│ │ │ ├── docker.py
│ │ │ ├── security.py
│ │ │ ├── templates.py
│ │ │ └── time_utils.py
│ │ ├── DEVELOPMENT.md
│ │ ├── pyproject.toml
│ │ ├── pyrightconfig.json
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── integ
│ │ │ │ └── mcp-inspector
│ │ │ │ ├── .gitignore
│ │ │ │ ├── README.md
│ │ │ │ ├── run-tests.sh
│ │ │ │ └── scenarios
│ │ │ │ ├── 01_comprehensive_troubleshooting
│ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ ├── 03_cleanup.sh
│ │ │ │ │ ├── description.txt
│ │ │ │ │ └── utils
│ │ │ │ │ ├── mcp_helpers.sh
│ │ │ │ │ └── validation_helpers.sh
│ │ │ │ └── 02_test_knowledge_proxy_tools
│ │ │ │ ├── 01_create.sh
│ │ │ │ ├── 02_validate.sh
│ │ │ │ ├── 03_cleanup.sh
│ │ │ │ ├── description.txt
│ │ │ │ └── utils
│ │ │ │ ├── knowledge_validation_helpers.sh
│ │ │ │ └── mcp_knowledge_helpers.sh
│ │ │ ├── llm_testing
│ │ │ │ ├── invalid_cfn_template.yaml
│ │ │ │ ├── README.md
│ │ │ │ ├── run_tests.sh
│ │ │ │ ├── scenarios
│ │ │ │ │ ├── 01_cloudformation_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 04_evaluation.md
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 02_service_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 04_evaluation.md
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 03_task_exit_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 04_evaluation.md
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 04_network_configuration_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 05_resource_constraint_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ └── 06_load_balancer_failure
│ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ └── description.txt
│ │ │ │ ├── SCRIPT_IMPROVEMENTS.md
│ │ │ │ └── utils
│ │ │ │ ├── aws_helpers.sh
│ │ │ │ └── evaluation_template.md
│ │ │ └── unit
│ │ │ ├── __init__.py
│ │ │ ├── api
│ │ │ │ ├── conftest.py
│ │ │ │ ├── test_delete_api.py
│ │ │ │ ├── test_ecs_troubleshooting.py
│ │ │ │ ├── test_resource_management_api.py
│ │ │ │ └── troubleshooting_tools
│ │ │ │ └── test_fetch_network_configuration.py
│ │ │ ├── conftest.py
│ │ │ ├── modules
│ │ │ │ ├── test_aws_knowledge_proxy.py
│ │ │ │ └── test_resource_management_module.py
│ │ │ ├── test_aws_role_utils.py
│ │ │ ├── test_aws_utils.py
│ │ │ ├── test_containerize.py
│ │ │ ├── test_delete.py
│ │ │ ├── test_docker_utils.py
│ │ │ ├── test_docker_with_role.py
│ │ │ ├── test_image_pull_failure_extended.py
│ │ │ ├── test_image_pull_failure.py
│ │ │ ├── test_infrastructure_role.py
│ │ │ ├── test_infrastructure.py
│ │ │ ├── test_integration.py
│ │ │ ├── test_main.py
│ │ │ ├── test_resource_management_api_operation.py
│ │ │ ├── test_resource_management_tool.py
│ │ │ ├── test_resource_management.py
│ │ │ ├── test_security_integration.py
│ │ │ ├── test_status_pytest.py
│ │ │ ├── test_status.py
│ │ │ ├── troubleshooting_tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── conftest.py
│ │ │ │ ├── test_detect_image_pull_failures.py
│ │ │ │ ├── test_fetch_cloudformation_status.py
│ │ │ │ ├── test_fetch_service_events.py
│ │ │ │ ├── test_fetch_task_failures.py
│ │ │ │ ├── test_fetch_task_logs.py
│ │ │ │ ├── test_get_ecs_troubleshooting_guidance.py
│ │ │ │ ├── test_is_ecr_image_security.py
│ │ │ │ └── test_utils.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── async_test_utils.py
│ │ │ ├── test_arn_parser.py
│ │ │ ├── test_config.py
│ │ │ ├── test_docker.py
│ │ │ ├── test_response_sanitization.py
│ │ │ ├── test_security_extended.py
│ │ │ ├── test_security.py
│ │ │ ├── test_templates.py
│ │ │ └── test_time_utils.py
│ │ └── uv.lock
│ ├── eks-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── eks_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_helper.py
│ │ │ ├── cloudwatch_handler.py
│ │ │ ├── cloudwatch_metrics_guidance_handler.py
│ │ │ ├── consts.py
│ │ │ ├── data
│ │ │ │ └── eks_cloudwatch_metrics_guidance.json
│ │ │ ├── eks_kb_handler.py
│ │ │ ├── eks_stack_handler.py
│ │ │ ├── iam_handler.py
│ │ │ ├── insights_handler.py
│ │ │ ├── k8s_apis.py
│ │ │ ├── k8s_client_cache.py
│ │ │ ├── k8s_handler.py
│ │ │ ├── logging_helper.py
│ │ │ ├── models.py
│ │ │ ├── scripts
│ │ │ │ └── update_eks_cloudwatch_metrics_guidance.py
│ │ │ ├── server.py
│ │ │ ├── templates
│ │ │ │ ├── eks-templates
│ │ │ │ │ └── eks-with-vpc.yaml
│ │ │ │ └── k8s-templates
│ │ │ │ ├── deployment.yaml
│ │ │ │ └── service.yaml
│ │ │ └── vpc_config_handler.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_aws_helper.py
│ │ │ ├── test_cloudwatch_handler.py
│ │ │ ├── test_cloudwatch_metrics_guidance_handler.py
│ │ │ ├── test_eks_kb_handler.py
│ │ │ ├── test_eks_stack_handler.py
│ │ │ ├── test_iam_handler.py
│ │ │ ├── test_init.py
│ │ │ ├── test_insights_handler.py
│ │ │ ├── test_k8s_apis.py
│ │ │ ├── test_k8s_client_cache.py
│ │ │ ├── test_k8s_handler.py
│ │ │ ├── test_logging_helper.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ └── test_vpc_config_handler.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── elasticache-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── elasticache_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common
│ │ │ │ ├── __init__.py
│ │ │ │ ├── connection.py
│ │ │ │ ├── decorators.py
│ │ │ │ └── server.py
│ │ │ ├── context.py
│ │ │ ├── main.py
│ │ │ └── tools
│ │ │ ├── __init__.py
│ │ │ ├── cc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── connect.py
│ │ │ │ ├── create.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── describe.py
│ │ │ │ ├── modify.py
│ │ │ │ ├── parsers.py
│ │ │ │ └── processors.py
│ │ │ ├── ce
│ │ │ │ ├── __init__.py
│ │ │ │ └── get_cost_and_usage.py
│ │ │ ├── cw
│ │ │ │ ├── __init__.py
│ │ │ │ └── get_metric_statistics.py
│ │ │ ├── cwlogs
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_log_group.py
│ │ │ │ ├── describe_log_groups.py
│ │ │ │ ├── describe_log_streams.py
│ │ │ │ ├── filter_log_events.py
│ │ │ │ └── get_log_events.py
│ │ │ ├── firehose
│ │ │ │ ├── __init__.py
│ │ │ │ └── list_delivery_streams.py
│ │ │ ├── misc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── batch_apply_update_action.py
│ │ │ │ ├── batch_stop_update_action.py
│ │ │ │ ├── describe_cache_engine_versions.py
│ │ │ │ ├── describe_engine_default_parameters.py
│ │ │ │ ├── describe_events.py
│ │ │ │ └── describe_service_updates.py
│ │ │ ├── rg
│ │ │ │ ├── __init__.py
│ │ │ │ ├── complete_migration.py
│ │ │ │ ├── connect.py
│ │ │ │ ├── create.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── describe.py
│ │ │ │ ├── modify.py
│ │ │ │ ├── parsers.py
│ │ │ │ ├── processors.py
│ │ │ │ ├── start_migration.py
│ │ │ │ └── test_migration.py
│ │ │ └── serverless
│ │ │ ├── __init__.py
│ │ │ ├── connect.py
│ │ │ ├── create.py
│ │ │ ├── delete.py
│ │ │ ├── describe.py
│ │ │ ├── models.py
│ │ │ └── modify.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_connection.py
│ │ │ ├── test_decorators.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── tools
│ │ │ ├── cc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_connect_additional.py
│ │ │ │ ├── test_connect_coverage_additional.py
│ │ │ │ ├── test_connect_coverage.py
│ │ │ │ ├── test_connect.py
│ │ │ │ ├── test_create_additional.py
│ │ │ │ ├── test_create.py
│ │ │ │ ├── test_delete.py
│ │ │ │ ├── test_describe.py
│ │ │ │ ├── test_modify.py
│ │ │ │ ├── test_parsers.py
│ │ │ │ └── test_processors.py
│ │ │ ├── ce
│ │ │ │ ├── __init__.py
│ │ │ │ └── test_get_cost_and_usage.py
│ │ │ ├── cw
│ │ │ │ └── test_get_metric_statistics.py
│ │ │ ├── cwlogs
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_create_log_group.py
│ │ │ │ ├── test_describe_log_groups.py
│ │ │ │ ├── test_describe_log_streams.py
│ │ │ │ ├── test_filter_log_events.py
│ │ │ │ └── test_get_log_events.py
│ │ │ ├── firehose
│ │ │ │ └── test_list_delivery_streams.py
│ │ │ ├── misc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_batch_apply_update_action.py
│ │ │ │ ├── test_batch_stop_update_action.py
│ │ │ │ ├── test_describe_cache_engine_versions.py
│ │ │ │ ├── test_describe_engine_default_parameters.py
│ │ │ │ ├── test_describe_events.py
│ │ │ │ └── test_describe_service_updates.py
│ │ │ ├── rg
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_complete_migration.py
│ │ │ │ ├── test_connect_additional.py
│ │ │ │ ├── test_connect_coverage_additional.py
│ │ │ │ ├── test_connect_optional_fields.py
│ │ │ │ ├── test_connect_partial_coverage.py
│ │ │ │ ├── test_connect.py
│ │ │ │ ├── test_create.py
│ │ │ │ ├── test_delete.py
│ │ │ │ ├── test_describe.py
│ │ │ │ ├── test_modify.py
│ │ │ │ ├── test_parsers.py
│ │ │ │ ├── test_processors.py
│ │ │ │ ├── test_start_migration.py
│ │ │ │ └── test_test_migration.py
│ │ │ └── serverless
│ │ │ ├── test_connect_additional.py
│ │ │ ├── test_connect_coverage_additional.py
│ │ │ ├── test_connect_optional_fields.py
│ │ │ ├── test_connect.py
│ │ │ ├── test_create.py
│ │ │ ├── test_delete.py
│ │ │ ├── test_describe.py
│ │ │ └── test_modify.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── finch-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── finch_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── build.py
│ │ │ ├── common.py
│ │ │ ├── ecr.py
│ │ │ ├── push.py
│ │ │ └── vm.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_cli_flags.py
│ │ │ ├── test_logging_configuration.py
│ │ │ ├── test_server.py
│ │ │ ├── test_utils_build.py
│ │ │ ├── test_utils_common.py
│ │ │ ├── test_utils_ecr.py
│ │ │ ├── test_utils_push.py
│ │ │ └── test_utils_vm.py
│ │ └── uv.lock
│ ├── frontend-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── frontend_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ ├── static
│ │ │ │ └── react
│ │ │ │ ├── essential-knowledge.md
│ │ │ │ └── troubleshooting.md
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ └── file_utils.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_file_utils.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ └── uv.lock
│ ├── git-repo-research-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── git_repo_research_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── defaults.py
│ │ │ ├── embeddings.py
│ │ │ ├── github_search.py
│ │ │ ├── indexer.py
│ │ │ ├── models.py
│ │ │ ├── repository.py
│ │ │ ├── search.py
│ │ │ ├── server.py
│ │ │ └── utils.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_errors_repository.py
│ │ │ ├── test_github_search_edge_cases.py
│ │ │ ├── test_graphql_github_search.py
│ │ │ ├── test_local_repository.py
│ │ │ ├── test_repository_utils.py
│ │ │ ├── test_rest_github_search.py
│ │ │ ├── test_search.py
│ │ │ ├── test_server.py
│ │ │ └── test_url_repository.py
│ │ └── uv.lock
│ ├── healthlake-mcp-server
│ │ ├── .dockerignore
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── healthlake_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── fhir_operations.py
│ │ │ ├── main.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── CONTRIBUTING.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ ├── mcp_config.json
│ │ │ └── README.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_fhir_client_comprehensive.py
│ │ │ ├── test_fhir_error_scenarios.py
│ │ │ ├── test_fhir_operations.py
│ │ │ ├── test_integration_mock_based.py
│ │ │ ├── test_main_edge_cases.py
│ │ │ ├── test_main.py
│ │ │ ├── test_mcp_integration_coverage.py
│ │ │ ├── test_models_edge_cases.py
│ │ │ ├── test_models.py
│ │ │ ├── test_readonly_mode.py
│ │ │ ├── test_server_core.py
│ │ │ ├── test_server_error_handling.py
│ │ │ ├── test_server_mcp_handlers.py
│ │ │ ├── test_server_toolhandler.py
│ │ │ └── test_server_validation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── iam-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── iam_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_client.py
│ │ │ ├── context.py
│ │ │ ├── errors.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── DESIGN_COMPLIANCE.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ ├── get_policy_document_example.py
│ │ │ └── inline_policy_demo.py
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── test_context.py
│ │ │ ├── test_errors.py
│ │ │ ├── test_inline_policies.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── lambda-tool-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── lambda_tool_mcp_server
│ │ │ ├── __init__.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ ├── README.md
│ │ │ └── sample_functions
│ │ │ ├── customer-create
│ │ │ │ └── app.py
│ │ │ ├── customer-id-from-email
│ │ │ │ └── app.py
│ │ │ ├── customer-info-from-id
│ │ │ │ └── app.py
│ │ │ └── template.yml
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_format_lambda_response.py
│ │ │ ├── test_integration_coverage.py
│ │ │ ├── test_integration.py
│ │ │ ├── test_register_lambda_functions.py
│ │ │ ├── test_schema_integration.py
│ │ │ ├── test_server_coverage_additional.py
│ │ │ ├── test_server_coverage.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── mcp-lambda-handler
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ └── mcp_lambda_handler
│ │ │ ├── __init__.py
│ │ │ ├── mcp_lambda_handler.py
│ │ │ ├── session.py
│ │ │ └── types.py
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ └── test_lambda_handler.py
│ │ └── uv.lock
│ ├── memcached-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── memcached_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common
│ │ │ │ ├── config.py
│ │ │ │ ├── connection.py
│ │ │ │ └── server.py
│ │ │ ├── context.py
│ │ │ ├── main.py
│ │ │ └── tools
│ │ │ └── cache.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── ELASTICACHECONNECT.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_cache_readonly.py
│ │ │ ├── test_cache.py
│ │ │ ├── test_connection.py
│ │ │ ├── test_init.py
│ │ │ └── test_main.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── mysql-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── mysql_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── 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/awslabs/aws_pricing_mcp_server/server.py:
--------------------------------------------------------------------------------
```python
1 | # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
2 | #
3 | # Licensed under the Apache License, Version 2.0 (the "License");
4 | # you may not use this file except in compliance with the License.
5 | # You may obtain a copy of the License at
6 | #
7 | # http://www.apache.org/licenses/LICENSE-2.0
8 | #
9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 |
15 | """awslabs MCP AWS Pricing mcp server implementation.
16 |
17 | This server provides tools for analyzing AWS service costs across different user tiers.
18 | """
19 |
20 | import re
21 | import sys
22 | from awslabs.aws_pricing_mcp_server import consts
23 | from awslabs.aws_pricing_mcp_server.cdk_analyzer import analyze_cdk_project
24 | from awslabs.aws_pricing_mcp_server.models import (
25 | ATTRIBUTE_NAMES_FIELD,
26 | ATTRIBUTE_VALUES_FILTERS_FIELD,
27 | EFFECTIVE_DATE_FIELD,
28 | FILTERS_FIELD,
29 | GET_PRICING_MAX_ALLOWED_CHARACTERS_FIELD,
30 | MAX_RESULTS_FIELD,
31 | NEXT_TOKEN_FIELD,
32 | OUTPUT_OPTIONS_FIELD,
33 | REGION_FIELD,
34 | SERVICE_ATTRIBUTES_FILTER_FIELD,
35 | SERVICE_CODE_FIELD,
36 | SERVICE_CODES_FILTER_FIELD,
37 | ErrorResponse,
38 | OutputOptions,
39 | PricingFilter,
40 | )
41 | from awslabs.aws_pricing_mcp_server.pricing_client import (
42 | create_pricing_client,
43 | get_currency_for_region,
44 | )
45 | from awslabs.aws_pricing_mcp_server.pricing_transformer import transform_pricing_data
46 | from awslabs.aws_pricing_mcp_server.static.patterns import BEDROCK
47 | from awslabs.aws_pricing_mcp_server.terraform_analyzer import analyze_terraform_project
48 | from datetime import datetime, timezone
49 | from loguru import logger
50 | from mcp.server.fastmcp import Context, FastMCP
51 | from pydantic import Field
52 | from pydantic.fields import FieldInfo
53 | from typing import Any, Dict, List, Optional, Union
54 |
55 |
56 | # Set up logging
57 | logger.remove()
58 | logger.add(sys.stderr, level=consts.LOG_LEVEL)
59 |
60 |
61 | async def create_error_response(
62 | ctx: Context,
63 | error_type: str,
64 | message: str,
65 | **kwargs, # Accept any additional fields dynamically
66 | ) -> Dict[str, Any]:
67 | """Create a standardized error response, log it, and notify context."""
68 | logger.error(message)
69 | await ctx.error(message)
70 |
71 | error_response = ErrorResponse(
72 | error_type=error_type,
73 | message=message,
74 | **kwargs,
75 | )
76 |
77 | return error_response.model_dump()
78 |
79 |
80 | mcp = FastMCP(
81 | name='awslabs.aws-pricing-mcp-server',
82 | instructions="""This server provides two primary functionalities:
83 |
84 | # USE CASE 1: AWS SERVICE CATALOG & PRICING DISCOVERY
85 | Access AWS service catalog information and pricing details through a structured workflow:
86 |
87 | 1. Discovery Workflow:
88 | - get_pricing_service_codes: Retrieve all available AWS service codes (starting point)
89 | - get_pricing_service_attributes: Get filterable attributes for a specific service
90 | - get_pricing_attribute_values: Get possible values for a specific attribute
91 | - get_pricing: Get actual pricing data with optional filters
92 | - get_price_list_urls: Get bulk pricing data files in multiple formats (CSV, JSON) for historical pricing analysis
93 |
94 | 2. Example Discovery Flow:
95 | ```
96 | # Get all service codes to find the one you need
97 | service_codes = get_pricing_service_codes()
98 |
99 | # Get available attributes for filtering EC2 pricing
100 | attributes = get_pricing_service_attributes('AmazonEC2')
101 |
102 | # Get all possible instance types for EC2
103 | instance_types = get_pricing_attribute_values('AmazonEC2', 'instanceType')
104 |
105 | # Get pricing for specific instance types in a region
106 | filters = [{"Field": "instanceType", "Value": "t3.medium", "Type": "EQUALS"}]
107 | pricing = get_pricing('AmazonEC2', 'us-east-1', filters)
108 |
109 | # Get bulk pricing data files for historical analysis
110 | price_list = get_price_list_urls('AmazonEC2', 'us-east-1')
111 | # Returns: {'arn': '...', 'urls': {'csv': 'https://...', 'json': 'https://...'}}
112 | ```
113 |
114 | # USE CASE 2: COST ANALYSIS REPORT GENERATION
115 | Generate comprehensive cost reports for AWS services by following these steps:
116 |
117 | 1. Data Gathering: Invoke get_pricing() to fetch data via AWS Pricing API
118 |
119 | 2. Service-Specific Analysis:
120 | - For Bedrock Services: MUST also use get_bedrock_patterns()
121 | - This provides critical architecture patterns, component relationships, and cost considerations
122 | - Especially important for Knowledge Base, Agent, Guardrails, and Data Automation services
123 |
124 | 3. Report Generation:
125 | - MUST generate cost analysis report using retrieved data via generate_cost_report()
126 | - The report includes sections for:
127 | * Service Overview
128 | * Architecture Pattern (for Bedrock services)
129 | * Assumptions
130 | * Limitations and Exclusions
131 | * Cost Breakdown
132 | * Cost Scaling with Usage
133 | * AWS Well-Architected Cost Optimization Recommendations
134 |
135 | 4. Output:
136 | Return to user:
137 | - Detailed cost analysis report in markdown format
138 | - Source of the data (web scraping, API, or websearch)
139 | - List of attempted data retrieval methods
140 |
141 | ACCURACY GUIDELINES:
142 | - When uncertain about service compatibility or pricing details, EXCLUDE them rather than making assumptions
143 | - For database compatibility, only include CONFIRMED supported databases
144 | - For model comparisons, always use the LATEST models rather than specific named ones
145 | - Add clear disclaimers about what is NOT included in calculations
146 | - PROVIDING LESS INFORMATION IS BETTER THAN GIVING WRONG INFORMATION
147 | - For Bedrock Knowledge Base, ALWAYS account for OpenSearch Serverless minimum OCU requirements (2 OCUs, $345.60/month minimum)
148 | - For Bedrock Agent, DO NOT double-count foundation model costs (they're included in agent usage)
149 |
150 | IMPORTANT: For report generation, steps MUST be executed in the exact order specified. Each step must be attempted
151 | before moving to the next fallback mechanism. The report is particularly focused on
152 | serverless services and pay-as-you-go pricing models.""",
153 | dependencies=['pydantic', 'loguru', 'boto3', 'beautifulsoup4', 'websearch'],
154 | )
155 |
156 |
157 | @mcp.tool(
158 | name='analyze_cdk_project',
159 | description='Analyze a CDK project to identify AWS services used. This tool dynamically extracts service information from CDK constructs without relying on hardcoded service mappings.',
160 | )
161 | async def analyze_cdk_project_wrapper(
162 | ctx: Context,
163 | project_path: str = Field(..., description='Path to the project directory'),
164 | ) -> Optional[Dict]:
165 | """Analyze a CDK project to identify AWS services.
166 |
167 | Args:
168 | project_path: The path to the CDK project
169 | ctx: MCP context for logging and state management
170 |
171 | Returns:
172 | Dictionary containing the identified services and their configurations
173 | """
174 | try:
175 | analysis_result = await analyze_cdk_project(project_path)
176 | logger.info(f'Analysis result: {analysis_result}')
177 | if analysis_result and 'services' in analysis_result:
178 | return analysis_result
179 | else:
180 | logger.error(f'Invalid analysis result format: {analysis_result}')
181 | return {
182 | 'status': 'error',
183 | 'services': [],
184 | 'message': f'Failed to analyze CDK project at {project_path}: Invalid result format',
185 | 'details': {'error': 'Invalid result format'},
186 | }
187 | except Exception as e:
188 | await ctx.error(f'Failed to analyze CDK project: {e}')
189 | return None
190 |
191 |
192 | @mcp.tool(
193 | name='analyze_terraform_project',
194 | description='Analyze a Terraform project to identify AWS services used. This tool dynamically extracts service information from Terraform resource declarations.',
195 | )
196 | async def analyze_terraform_project_wrapper(
197 | ctx: Context,
198 | project_path: str = Field(..., description='Path to the project directory'),
199 | ) -> Optional[Dict]:
200 | """Analyze a Terraform project to identify AWS services.
201 |
202 | Args:
203 | project_path: The path to the Terraform project
204 | ctx: MCP context for logging and state management
205 |
206 | Returns:
207 | Dictionary containing the identified services and their configurations
208 | """
209 | try:
210 | analysis_result = await analyze_terraform_project(project_path)
211 | logger.info(f'Analysis result: {analysis_result}')
212 | if analysis_result and 'services' in analysis_result:
213 | return analysis_result
214 | else:
215 | logger.error(f'Invalid analysis result format: {analysis_result}')
216 | return {
217 | 'status': 'error',
218 | 'services': [],
219 | 'message': f'Failed to analyze Terraform project at {project_path}: Invalid result format',
220 | 'details': {'error': 'Invalid result format'},
221 | }
222 | except Exception as e:
223 | await ctx.error(f'Failed to analyze Terraform project: {e}')
224 | return None
225 |
226 |
227 | @mcp.tool(
228 | name='get_pricing',
229 | description="""
230 | Get detailed pricing information from AWS Price List API with optional filters.
231 |
232 | **PARAMETERS:**
233 | - service_code (required): AWS service code (e.g., 'AmazonEC2', 'AmazonS3', 'AmazonES')
234 | - region (optional): AWS region string (e.g., 'us-east-1') OR list for multi-region comparison (e.g., ['us-east-1', 'eu-west-1']). Omit for global services like DataTransfer or CloudFront that don't have region-specific pricing.
235 | - filters (optional): List of filter dictionaries in format {'Field': str, 'Type': str, 'Value': str}
236 | - max_allowed_characters (optional): Response size limit in characters (default: 100,000, use -1 for unlimited)
237 | - output_options (optional): OutputOptions object for response transformation and size reduction
238 | - max_results (optional): Maximum number of results to return per page (default: 100, min: 1, max: 100)
239 | - next_token (optional): Pagination token from previous response to get next page of results
240 |
241 | **MANDATORY WORKFLOW - ALWAYS FOLLOW:**
242 |
243 | **Step 1: Discover Available Options**
244 | ```python
245 | service_codes = get_pricing_service_codes() # Find correct service (skip if known)
246 | attributes = get_pricing_service_attributes('AmazonEC2') # Discover filterable dimensions
247 | attribute_values = get_pricing_attribute_values('AmazonEC2', 'memory') # Get valid values for filtering
248 | ```
249 |
250 | **Step 2: Build Precise Filters**
251 | ```python
252 | # Use ONLY values discovered in Step 1
253 | filters = [
254 | {"Field": "memory", "Value": ["8 GiB", "16 GiB", "32 GiB"], "Type": "ANY_OF"}, # Multiple options
255 | {"Field": "instanceType", "Value": "m5", "Type": "CONTAINS"}, # Pattern matching
256 | {"Field": "instanceType", "Value": ["t2", "m4"], "Type": "NONE_OF"} # Exclude older
257 | ]
258 | ```
259 |
260 | **Step 3: Execute Query**
261 | ```python
262 | pricing = get_pricing('AmazonEC2', 'us-east-1', filters)
263 | ```
264 |
265 | **FILTER TYPES:**
266 | - **EQUALS**: Exact match (default) - `{"Field": "instanceType", "Value": "m5.large"}`
267 | - **ANY_OF**: Multiple options - `{"Field": "memory", "Value": ["8 GiB", "16 GiB"], "Type": "ANY_OF"}`
268 | - **CONTAINS**: Pattern match - `{"Field": "instanceType", "Value": "m5", "Type": "CONTAINS"}`
269 | - **NONE_OF**: Exclusion - `{"Field": "instanceType", "Value": ["t2", "m4"], "Type": "NONE_OF"}`
270 |
271 | **CRITICAL: ANY_OF FILTER VALUE LIMITS:**
272 | - **1024 CHARACTER LIMIT**: Total length of all values in ANY_OF arrays cannot exceed 1024 characters
273 | - **PROGRESSIVE FILTERING**: Start with minimal qualifying options, expand if needed
274 | - **EXAMPLE VIOLATION**: `["8 GiB", "16 GiB", "32 GiB", "64 GiB", "96 GiB", "128 GiB", ...]` (TOO LONG)
275 | - **CORRECT APPROACH**: `["8 GiB", "16 GiB", "32 GiB", "36 GiB", "48 GiB"]` (TARGETED LIST)
276 |
277 | **COMMON USE CASES:**
278 |
279 | **COST OPTIMIZATION - EXHAUSTIVE MINIMUM-FIRST APPROACH:** When users ask for "lowest price", "cheapest", or cost optimization
280 | - **LOWER = CHEAPER ASSUMPTION**: For cost optimization, assume lower capabilities cost less than higher ones
281 | * 32 GB storage is cheaper than 300 GB storage
282 | * 8 GiB RAM is cheaper than 64 GiB RAM
283 | - **CRITICAL FOR COST QUERIES**: Start IMMEDIATELY above minimum requirement and test ALL options incrementally
284 | - **EXHAUSTIVE ENUMERATION REQUIRED**: Each storage/memory tier is MUTUALLY EXCLUSIVE - must list each one explicitly
285 | - **STOP AT REASONABLE UPPER BOUND**: For cost optimization, limit upper bound to 2-3x minimum requirement to avoid expensive options
286 | - **exclude_free_products**: ESSENTIAL for cost analysis - removes $0.00 reservation placeholders, SQL licensing variants, and special pricing entries that obscure actual billable instances when finding cheapest options
287 | - Use ANY_OF for efficient multi-option comparison in single API call
288 | - Multi-attribute capability filtering for minimum requirements
289 | - Combine CONTAINS + NONE_OF for refined discovery
290 |
291 | **OUTPUT OPTIONS (Response Size & Performance Control):**
292 | - **PURPOSE**: Transform and optimize API responses for ALL services, especially critical for large services (EC2, RDS)
293 | - **IMMEDIATE COMBINED APPROACH**: `{"pricing_terms": ["OnDemand"], "product_attributes": ["instanceType", "location", "memory"]}`
294 | - **ATTRIBUTE DISCOVERY**: Use get_pricing_service_attributes() - same names for filters and output_options
295 | - **SIZE REDUCTION**: 80%+ reduction with combined pricing_terms + product_attributes
296 | - **exclude_free_products**: Remove products with $0.00 OnDemand pricing (useful when you know service has paid tiers)
297 | - **WHEN TO USE**: Always for large services, recommended for all services to improve performance
298 |
299 | **CRITICAL REQUIREMENTS:**
300 | - **NEVER GUESS VALUES**: Always use get_pricing_attribute_values() to discover valid options
301 | - **EXHAUSTIVE ENUMERATION**: For cost optimization, list ALL qualifying tiers individually - they are mutually exclusive
302 | - **USE SPECIFIC FILTERS**: Large services (EC2, RDS) require 2-3 filters minimum
303 | - **NEVER USE MULTIPLE CALLS**: When ANY_OF can handle it in one call
304 | - **VERIFY EXISTENCE**: Ensure all filter values exist in the service before querying
305 | - **FOR "CHEAPEST" QUERIES**: Focus on lower-end options that meet minimum requirements, test incrementally
306 |
307 | **CONSTRAINTS:**
308 | - **CURRENT PRICING ONLY**: Use get_price_list_urls for historical data
309 | - **NO SPOT/SAVINGS PLANS**: Only OnDemand and Reserved Instance pricing available
310 | - **CHARACTER LIMIT**: 100,000 characters default response limit (use output_options to reduce)
311 | - **REGION AUTO-FILTER**: Region parameter automatically creates regionCode filter
312 |
313 | **ANTI-PATTERNS:**
314 | - DO NOT make multiple API calls that could be combined with ANY_OF
315 | - DO NOT build cross-products manually when API can handle combinations
316 | - DO NOT call get_pricing_service_codes() when service code is already known (e.g., "AmazonEC2")
317 | - DO NOT use EQUALS without first checking get_pricing_attribute_values()
318 | - DO NOT skip discovery workflow for any use case
319 | - DO NOT use broad queries without specific filters on large services
320 | - DO NOT assume attribute values exist across different services/regions
321 | - DO NOT skip intermediate tiers: Missing 50GB, 59GB options when testing 32GB → 75GB jump
322 | - DO NOT set upper bounds too high: Including 500GB+ storage when user needs ≥30GB (wastes character limit)
323 |
324 | **EXAMPLE USE CASES:**
325 |
326 | **1. Cost-Optimized Multi-Attribute Filtering (CORRECT APPROACH):**
327 | ```python
328 | # Find cheapest EC2 instances meeting minimum requirements (>= 8 GiB memory, >= 30 GB storage)
329 | # EXHAUSTIVE ENUMERATION of qualifying tiers - each is mutually exclusive
330 | filters = [
331 | {"Field": "memory", "Value": ["8 GiB", "16 GiB", "32 GiB"], "Type": "ANY_OF"}, # All tiers ≥8GB up to reasonable limit
332 | {"Field": "storage", "Value": ["1 x 32 SSD", "1 x 60 SSD", "1 x 75 NVMe SSD"], "Type": "ANY_OF"}, # All tiers ≥30GB up to reasonable limit
333 | {"Field": "instanceType", "Value": ["t2", "m4"], "Type": "NONE_OF"}, # Exclude older generations
334 | {"Field": "tenancy", "Value": "Shared", "Type": "EQUALS"} # Exclude more expensive dedicated
335 | ]
336 | pricing = get_pricing('AmazonEC2', 'us-east-1', filters)
337 | ```
338 |
339 | **2. Efficient Multi-Region Comparison:**
340 | ```python
341 | # Compare same configuration across regions - use region parameter for multi-region
342 | filters = [{"Field": "instanceType", "Value": "m5.large", "Type": "EQUALS"}]
343 | pricing = get_pricing('AmazonEC2', ['us-east-1', 'us-west-2', 'eu-west-1'], filters)
344 | ```
345 |
346 | **3. Large service with output optimization (recommended approach):**
347 | ```python
348 | output_options = {"pricing_terms": ["OnDemand"], "product_attributes": ["instanceType", "location"], "exclude_free_products": true}
349 | pricing = get_pricing('AmazonEC2', 'us-east-1', filters, output_options=output_options)
350 | ```
351 |
352 | **4. Pattern-Based Discovery with Refinement:**
353 | ```python
354 | # Find all Standard storage tiers except expensive ones
355 | filters = [
356 | {"Field": "storageClass", "Value": "Standard", "Type": "CONTAINS"},
357 | {"Field": "storageClass", "Value": ["Standard-IA"], "Type": "NONE_OF"}
358 | ]
359 | ```
360 |
361 | **FILTERING STRATEGY:**
362 | - **Large Services (EC2, RDS)**: ALWAYS use 2-3 specific filters to prevent 200+ record responses
363 | - **Small Services**: May work with single filter or no filters
364 | - **Multi-Option Analysis**: Use ANY_OF instead of multiple API calls
365 | - **Pattern Discovery**: Use CONTAINS for finding families or tiers
366 | - **Smart Exclusion**: Use NONE_OF for compliance or cost filtering
367 |
368 | **SUCCESS CRITERIA:**
369 | - Used discovery workflow (skip get_pricing_service_codes() if service known)
370 | - Applied appropriate filters for the service size
371 | - Used exact values from get_pricing_attribute_values()
372 | - Used ANY_OF for multi-option scenarios instead of multiple calls
373 | - For cost optimization: tested ALL qualifying tiers exhaustively (in a reasonable range)
374 | """,
375 | )
376 | async def get_pricing(
377 | ctx: Context,
378 | service_code: str = SERVICE_CODE_FIELD,
379 | region: Optional[Union[str, List[str]]] = REGION_FIELD,
380 | filters: Optional[List[PricingFilter]] = FILTERS_FIELD,
381 | max_allowed_characters: int = GET_PRICING_MAX_ALLOWED_CHARACTERS_FIELD,
382 | output_options: Optional[OutputOptions] = OUTPUT_OPTIONS_FIELD,
383 | max_results: int = MAX_RESULTS_FIELD,
384 | next_token: Optional[str] = NEXT_TOKEN_FIELD,
385 | ) -> Dict[str, Any]:
386 | """Get pricing information from AWS Price List API.
387 |
388 | Args:
389 | service_code: The service code (e.g., 'AmazonES' for OpenSearch, 'AmazonS3' for S3)
390 | region: Optional AWS region(s) - single region string (e.g., 'us-west-2') or list for multi-region comparison (e.g., ['us-east-1', 'us-west-2']). Omit for global services like DataTransfer or CloudFront.
391 | filters: Optional list of filter dictionaries in format {'Field': str, 'Type': str, 'Value': str}
392 | max_allowed_characters: Optional character limit for response (default: 100,000, use -1 for unlimited)
393 | output_options: Optional output filtering options to reduce response size
394 | max_results: Maximum number of results to return per page (default: 100, max: 100)
395 | next_token: Pagination token from previous response to get next page of results
396 | ctx: MCP context for logging and state management
397 |
398 | Returns:
399 | Dictionary containing pricing information from AWS Pricing API. If more results are available,
400 | the response will include a 'next_token' field that can be used for subsequent requests.
401 | """
402 | # Handle Pydantic Field objects when called directly (not through MCP framework)
403 | if isinstance(filters, FieldInfo):
404 | filters = filters.default
405 | if isinstance(max_allowed_characters, FieldInfo):
406 | max_allowed_characters = max_allowed_characters.default
407 | if isinstance(output_options, FieldInfo):
408 | output_options = output_options.default
409 | if isinstance(max_results, FieldInfo):
410 | max_results = max_results.default
411 | if isinstance(next_token, FieldInfo):
412 | next_token = next_token.default
413 |
414 | logger.info(f'Getting pricing for {service_code} in {region}')
415 |
416 | # Create pricing client with error handling
417 | try:
418 | pricing_client = create_pricing_client()
419 | except Exception as e:
420 | return await create_error_response(
421 | ctx=ctx,
422 | error_type='client_creation_failed',
423 | message=f'Failed to create AWS Pricing client: {str(e)}',
424 | service_code=service_code,
425 | region=region,
426 | )
427 |
428 | # Build filters
429 | try:
430 | # Build region filter based on parameter type (only if region is provided)
431 | api_filters = []
432 | if region is not None:
433 | api_filters.append(
434 | {
435 | 'Field': 'regionCode',
436 | 'Type': 'ANY_OF' if isinstance(region, list) else 'EQUALS',
437 | 'Value': ','.join(region) if isinstance(region, list) else region,
438 | }
439 | )
440 |
441 | # Add any additional filters if provided
442 | if filters:
443 | api_filters.extend([f.model_dump(by_alias=True) for f in filters])
444 |
445 | # Make the API request
446 | api_params = {
447 | 'ServiceCode': service_code,
448 | 'Filters': api_filters,
449 | 'MaxResults': max_results,
450 | }
451 |
452 | # Only include NextToken if it's provided
453 | if next_token:
454 | api_params['NextToken'] = next_token
455 |
456 | response = pricing_client.get_products(**api_params)
457 | except Exception as e:
458 | return await create_error_response(
459 | ctx=ctx,
460 | error_type='api_error',
461 | message=f'Failed to retrieve pricing data for service "{service_code}" in region "{region}": {str(e)}',
462 | service_code=service_code,
463 | region=region,
464 | suggestion='Verify that the service code and region combination is valid. Use get_service_codes() to get valid service codes.',
465 | )
466 |
467 | # Check if results are empty
468 | if not response.get('PriceList'):
469 | return await create_error_response(
470 | ctx=ctx,
471 | error_type='empty_results',
472 | message=f'No results found for given filters [{filters}], service: "{service_code}", region "{region}"',
473 | service_code=service_code,
474 | region=region,
475 | suggestion='Try these approaches: (1) Verify that the service code is valid. Use get_service_codes() to get valid service codes. (2) Validate region and filter values using get_pricing_attribute_values(). (3) Test with fewer filters to isolate the issue.',
476 | examples={
477 | 'Example service codes': [
478 | 'AmazonEC2',
479 | 'AmazonS3',
480 | 'AmazonES',
481 | 'AWSLambda',
482 | 'AmazonDynamoDB',
483 | ],
484 | 'Example regions': ['us-east-1', 'eu-west-1', 'ap-south-1'],
485 | },
486 | )
487 |
488 | # Apply filtering with error handling
489 | try:
490 | price_list = transform_pricing_data(response['PriceList'], output_options)
491 | total_count = len(price_list)
492 | except ValueError as e:
493 | return await create_error_response(
494 | ctx=ctx,
495 | error_type='data_processing_error',
496 | message=f'Failed to process pricing data: {str(e)}',
497 | service_code=service_code,
498 | region=region,
499 | )
500 |
501 | # Check if results exceed the character threshold (unless max_characters is -1 for unlimited)
502 | if max_allowed_characters != -1:
503 | # Calculate total character count of the FILTERED response data
504 | total_characters = sum(len(str(item)) for item in price_list)
505 |
506 | if total_characters > max_allowed_characters:
507 | return await create_error_response(
508 | ctx=ctx,
509 | error_type='result_too_large',
510 | message=f'Query returned {total_characters:,} characters, exceeding the limit of {max_allowed_characters:,}. Use more specific filters or try output_options={{"pricing_terms": ["OnDemand"]}} to reduce response size.',
511 | service_code=service_code,
512 | region=region,
513 | total_count=total_count,
514 | total_characters=total_characters,
515 | max_allowed_characters=max_allowed_characters,
516 | sample_records=price_list[:3],
517 | suggestion='Add more specific filters like instanceType, storageClass, deploymentOption, or engineCode to reduce the number of results. For large services like EC2, consider using output_options={"pricing_terms": ["OnDemand"]} to significantly reduce response size by excluding Reserved Instance pricing.',
518 | )
519 |
520 | # Success response
521 | logger.info(f'Successfully retrieved {total_count} pricing items for {service_code}')
522 | await ctx.info(f'Successfully retrieved pricing for {service_code} in {region}')
523 |
524 | result = {
525 | 'status': 'success',
526 | 'service_name': service_code,
527 | 'data': price_list,
528 | 'message': f'Retrieved pricing for {service_code} in {region} from AWS Pricing API',
529 | }
530 |
531 | # Include next_token if present for pagination
532 | if 'NextToken' in response:
533 | result['next_token'] = response['NextToken']
534 |
535 | return result
536 |
537 |
538 | @mcp.tool(
539 | name='get_bedrock_patterns',
540 | description='Get architecture patterns for Amazon Bedrock applications, including component relationships and cost considerations',
541 | )
542 | async def get_bedrock_patterns(ctx: Optional[Context] = None) -> str:
543 | """Get architecture patterns for Amazon Bedrock applications.
544 |
545 | This tool provides architecture patterns, component relationships, and cost considerations
546 | for Amazon Bedrock applications. It does not include specific pricing information, which
547 | should be obtained using get_pricing.
548 |
549 | Returns:
550 | String containing the architecture patterns in markdown format
551 | """
552 | return BEDROCK
553 |
554 |
555 | # Default recommendation prompt template
556 | DEFAULT_RECOMMENDATION_PROMPT = """
557 | Based on the following AWS services and their relationships:
558 | - Services: {services}
559 | - Architecture patterns: {architecture_patterns}
560 | - Pricing model: {pricing_model}
561 |
562 | Generate cost optimization recommendations organized into two categories:
563 |
564 | 1. Immediate Actions: Specific, actionable recommendations that can be implemented quickly to optimize costs.
565 |
566 | 2. Best Practices: Longer-term strategies aligned with the AWS Well-Architected Framework's cost optimization pillar.
567 |
568 | For each recommendation:
569 | - Be specific to the services being used
570 | - Consider service interactions and dependencies
571 | - Include concrete cost impact where possible
572 | - Avoid generic advice unless broadly applicable
573 |
574 | Focus on the most impactful recommendations first. Do not limit yourself to a specific number of recommendations - include as many as are relevant and valuable.
575 | """
576 |
577 |
578 | @mcp.tool(
579 | name='generate_cost_report',
580 | description="""Generate a detailed cost analysis report based on pricing data for one or more AWS services.
581 |
582 | This tool requires AWS pricing data and provides options for adding detailed cost information.
583 |
584 | IMPORTANT REQUIREMENTS:
585 | - ALWAYS include detailed unit pricing information (e.g., "$0.0008 per 1K input tokens")
586 | - ALWAYS show calculation breakdowns (unit price × usage = total cost)
587 | - ALWAYS specify the pricing model (e.g., "ON DEMAND")
588 | - ALWAYS list all assumptions and exclusions explicitly
589 |
590 | Output Format Options:
591 | - 'markdown' (default): Generates a well-formatted markdown report
592 | - 'csv': Generates a CSV format report with sections for service information, unit pricing, cost calculations, etc.
593 |
594 | Example usage:
595 |
596 | ```json
597 | {
598 | // Required parameters
599 | "pricing_data": {
600 | // This should contain pricing data retrieved from get_pricing
601 | "status": "success",
602 | "service_name": "bedrock",
603 | "data": "... pricing information ...",
604 | "message": "Retrieved pricing for bedrock from AWS Pricing url"
605 | },
606 | "service_name": "Amazon Bedrock",
607 |
608 | // Core parameters (commonly used)
609 | "related_services": ["Lambda", "S3"],
610 | "pricing_model": "ON DEMAND",
611 | "assumptions": [
612 | "Standard ON DEMAND pricing model",
613 | "No caching or optimization applied",
614 | "Average request size of 4KB"
615 | ],
616 | "exclusions": [
617 | "Data transfer costs between regions",
618 | "Custom model training costs",
619 | "Development and maintenance costs"
620 | ],
621 | "output_file": "cost_analysis_report.md", // or "cost_analysis_report.csv" for CSV format
622 | "format": "markdown", // or "csv" for CSV format
623 |
624 | // Advanced parameter for complex scenarios
625 | "detailed_cost_data": {
626 | "services": {
627 | "Amazon Bedrock Foundation Models": {
628 | "usage": "Processing 1M input tokens and 500K output tokens with Claude 3.5 Haiku",
629 | "estimated_cost": "$80.00",
630 | "free_tier_info": "No free tier for Bedrock foundation models",
631 | "unit_pricing": {
632 | "input_tokens": "$0.0008 per 1K tokens",
633 | "output_tokens": "$0.0016 per 1K tokens"
634 | },
635 | "usage_quantities": {
636 | "input_tokens": "1,000,000 tokens",
637 | "output_tokens": "500,000 tokens"
638 | },
639 | "calculation_details": "$0.0008/1K × 1,000K input tokens + $0.0016/1K × 500K output tokens = $80.00"
640 | },
641 | "AWS Lambda": {
642 | "usage": "6,000 requests per month with 512 MB memory",
643 | "estimated_cost": "$0.38",
644 | "free_tier_info": "First 12 months: 1M requests/month free",
645 | "unit_pricing": {
646 | "requests": "$0.20 per 1M requests",
647 | "compute": "$0.0000166667 per GB-second"
648 | },
649 | "usage_quantities": {
650 | "requests": "6,000 requests",
651 | "compute": "6,000 requests × 1s × 0.5GB = 3,000 GB-seconds"
652 | },
653 | "calculation_details": "$0.20/1M × 0.006M requests + $0.0000166667 × 3,000 GB-seconds = $0.38"
654 | }
655 | }
656 | },
657 |
658 | // Recommendations parameter - can be provided directly or generated
659 | "recommendations": {
660 | "immediate": [
661 | "Optimize prompt engineering to reduce token usage for Claude 3.5 Haiku",
662 | "Configure Knowledge Base OCUs based on actual query patterns",
663 | "Implement response caching for common queries to reduce token usage"
664 | ],
665 | "best_practices": [
666 | "Monitor OCU utilization metrics and adjust capacity as needed",
667 | "Use prompt caching for repeated context across API calls",
668 | "Consider provisioned throughput for predictable workloads"
669 | ]
670 | }
671 | }
672 | ```
673 | """,
674 | )
675 | async def generate_cost_report_wrapper(
676 | ctx: Context,
677 | pricing_data: Dict[str, Any] = Field(
678 | ..., description='Raw pricing data from AWS pricing tools'
679 | ),
680 | service_name: str = Field(..., description='Name of the AWS service'),
681 | # Core parameters (simple, commonly used)
682 | related_services: Optional[List[str]] = Field(
683 | None, description='List of related AWS services'
684 | ),
685 | pricing_model: str = Field(
686 | 'ON DEMAND', description='Pricing model (e.g., "ON DEMAND", "Reserved")'
687 | ),
688 | assumptions: Optional[List[str]] = Field(
689 | None, description='List of assumptions for cost analysis'
690 | ),
691 | exclusions: Optional[List[str]] = Field(
692 | None, description='List of items excluded from cost analysis'
693 | ),
694 | output_file: Optional[str] = Field(None, description='Path to save the report file'),
695 | format: str = Field('markdown', description='Output format ("markdown" or "csv")'),
696 | # Advanced parameters (grouped in a dictionary for complex use cases)
697 | detailed_cost_data: Optional[Dict[str, Any]] = Field(
698 | None, description='Detailed cost information for complex scenarios'
699 | ),
700 | recommendations: Optional[Dict[str, Any]] = Field(
701 | None, description='Direct recommendations or guidance for generation'
702 | ),
703 | ) -> str:
704 | """Generate a cost analysis report for AWS services.
705 |
706 | IMPORTANT: When uncertain about compatibility or pricing details, exclude them rather than making assumptions.
707 | For example:
708 | - For database compatibility with services like Structured Data Retrieval KB, only include confirmed supported databases
709 | - For model comparisons, always use the latest models rather than specific named ones that may become outdated
710 | - Add clear disclaimers about what is NOT included in calculations
711 | - Providing less information is better than giving WRONG information
712 |
713 | CRITICAL REQUIREMENTS:
714 | - ALWAYS include detailed unit pricing information (e.g., "$0.0008 per 1K input tokens")
715 | - ALWAYS show calculation breakdowns (unit price × usage = total cost)
716 | - ALWAYS specify the pricing model (e.g., "ON DEMAND")
717 | - ALWAYS list all assumptions and exclusions explicitly
718 |
719 | For Amazon Bedrock services, especially Knowledge Base, Agent, Guardrails, and Data Automation:
720 | - Use get_bedrock_patterns() to understand component relationships and cost considerations
721 | - For Knowledge Base, account for OpenSearch Serverless minimum OCU requirements (2 OCUs, $345.60/month minimum)
722 | - For Agent, avoid double-counting foundation model costs (they're included in agent usage)
723 |
724 | Args:
725 | pricing_data: Raw pricing data from AWS pricing tools (required)
726 | service_name: Name of the primary service (required)
727 | related_services: List of related services to include in the analysis
728 | pricing_model: The pricing model used (default: "ON DEMAND")
729 | assumptions: List of assumptions made for the cost analysis
730 | exclusions: List of items excluded from the cost analysis
731 | output_file: Path to save the report to a file
732 | format: Output format for the cost analysis report
733 | - Values: "markdown" (default) or "csv"
734 | - markdown: Generates a well-formatted report with tables and sections
735 | - csv: Generates a structured data format for spreadsheet compatibility
736 | detailed_cost_data: Dictionary containing detailed cost information for complex scenarios
737 | This can include:
738 | - services: Dictionary mapping service names to their detailed cost information
739 | - unit_pricing: Dictionary mapping price types to their values
740 | - usage_quantities: Dictionary mapping usage types to their quantities
741 | - calculation_details: String showing the calculation breakdown
742 | recommendations: Optional dictionary containing recommendations or guidance for generation
743 | ctx: MCP context for logging and error handling
744 |
745 | Returns:
746 | str: The generated document in markdown format
747 | """
748 | # Import and call the implementation from report_generator.py
749 | from awslabs.aws_pricing_mcp_server.report_generator import (
750 | generate_cost_report,
751 | )
752 |
753 | # 1. Extract services from pricing data and parameters
754 | services = service_name
755 | if related_services:
756 | services = f'{service_name}, {", ".join(related_services)}'
757 |
758 | # 2. Get architecture patterns if relevant (e.g., for Bedrock)
759 | architecture_patterns = {}
760 | if 'bedrock' in services.lower():
761 | try:
762 | # Get Bedrock architecture patterns
763 | bedrock_patterns = await get_bedrock_patterns(ctx)
764 | architecture_patterns['bedrock'] = bedrock_patterns
765 | except Exception as e:
766 | if ctx:
767 | await ctx.warning(f'Could not get Bedrock patterns: {e}')
768 |
769 | # 3. Process recommendations
770 | try:
771 | # Initialize detailed_cost_data if it doesn't exist
772 | if not detailed_cost_data:
773 | detailed_cost_data = {}
774 |
775 | # If recommendations are provided directly, use them
776 | if recommendations:
777 | detailed_cost_data['recommendations'] = recommendations
778 | # Otherwise, if no recommendations exist in detailed_cost_data, create a structure for the assistant to fill
779 | elif 'recommendations' not in detailed_cost_data:
780 | # Create a default prompt based on the services and context
781 | architecture_patterns_str = 'Available' if architecture_patterns else 'Not provided'
782 | prompt = DEFAULT_RECOMMENDATION_PROMPT.format(
783 | services=services,
784 | architecture_patterns=architecture_patterns_str,
785 | pricing_model=pricing_model,
786 | )
787 |
788 | detailed_cost_data['recommendations'] = {
789 | '_prompt': prompt, # Include the prompt for reference
790 | 'immediate': [], # assistant will fill these
791 | 'best_practices': [], # assistant will fill these
792 | }
793 | except Exception as e:
794 | if ctx:
795 | await ctx.warning(f'Could not prepare recommendations: {e}')
796 |
797 | # 6. Call the report generator with the enhanced data
798 | return await generate_cost_report(
799 | pricing_data=pricing_data,
800 | service_name=service_name,
801 | related_services=related_services,
802 | pricing_model=pricing_model,
803 | assumptions=assumptions,
804 | exclusions=exclusions,
805 | output_file=output_file,
806 | detailed_cost_data=detailed_cost_data,
807 | ctx=ctx,
808 | format=format,
809 | )
810 |
811 |
812 | @mcp.tool(
813 | name='get_pricing_service_codes',
814 | description="""Get AWS service codes available in the Price List API.
815 |
816 | **PURPOSE:** Discover which AWS services have pricing information available in the AWS Price List API.
817 |
818 | **PARAMETERS:**
819 | - filter (optional): Case-insensitive regex pattern to filter service codes (e.g., "bedrock" matches "AmazonBedrock", "AmazonBedrockService")
820 |
821 | **WORKFLOW:** This is the starting point for any pricing query. Use this first to find the correct service code.
822 |
823 | **RETURNS:** List of service codes (e.g., 'AmazonEC2', 'AmazonS3', 'AWSLambda') that can be used with other pricing tools.
824 |
825 | **NEXT STEPS:**
826 | - Use get_pricing_service_attributes() to see what filters are available for a service
827 | - Use get_pricing() to get actual pricing data for a service
828 |
829 | **NOTE:** Service codes may differ from AWS console names (e.g., 'AmazonES' for OpenSearch, 'AWSLambda' for Lambda).
830 | """,
831 | )
832 | async def get_pricing_service_codes(
833 | ctx: Context, filter: Optional[str] = SERVICE_CODES_FILTER_FIELD
834 | ) -> Union[List[str], Dict[str, Any]]:
835 | """Retrieve all available service codes from AWS Price List API.
836 |
837 | Args:
838 | ctx: MCP context for logging and state management
839 | filter: Optional regex pattern to filter service codes (case-insensitive)
840 |
841 | Returns:
842 | List of sorted service codes on success, or error dictionary on failure
843 | """
844 | logger.info('Retrieving AWS service codes from Price List API')
845 |
846 | # Create pricing client with error handling
847 | try:
848 | pricing_client = create_pricing_client()
849 | except Exception as e:
850 | return await create_error_response(
851 | ctx=ctx,
852 | error_type='client_creation_failed',
853 | message=f'Failed to create AWS Pricing client: {str(e)}',
854 | )
855 |
856 | # Retrieve service codes with error handling
857 | try:
858 | service_codes = []
859 | next_token = None
860 |
861 | # Retrieve all service codes with pagination handling
862 | while True:
863 | response = pricing_client.describe_services(
864 | **({'NextToken': next_token} if next_token else {})
865 | )
866 | service_codes.extend([service['ServiceCode'] for service in response['Services']])
867 |
868 | if 'NextToken' not in response:
869 | break
870 | next_token = response['NextToken']
871 |
872 | except Exception as e:
873 | return await create_error_response(
874 | ctx=ctx,
875 | error_type='api_error',
876 | message=f'Failed to retrieve service codes from AWS API: {str(e)}',
877 | suggestion='Verify AWS credentials and permissions for pricing:DescribeServices action.',
878 | )
879 |
880 | # Check for empty results
881 | if not service_codes:
882 | return await create_error_response(
883 | ctx=ctx,
884 | error_type='empty_results',
885 | message='No service codes returned from AWS Price List API',
886 | )
887 |
888 | # Apply regex filtering if filter is provided
889 | if filter:
890 | try:
891 | regex_pattern = re.compile(filter, re.IGNORECASE)
892 | service_codes = [code for code in service_codes if regex_pattern.search(code)]
893 |
894 | if not service_codes:
895 | return await create_error_response(
896 | ctx=ctx,
897 | error_type='no_matches_found',
898 | message=f'No service codes match the regex pattern: "{filter}"',
899 | filter=filter,
900 | suggestion='Try a broader regex pattern or check the pattern syntax. Use get_pricing_service_codes() without filter to see all available service codes.',
901 | )
902 |
903 | except re.error as e:
904 | return await create_error_response(
905 | ctx=ctx,
906 | error_type='invalid_regex',
907 | message=f'Invalid regex pattern "{filter}": {str(e)}',
908 | filter=filter,
909 | suggestion='Please provide a valid regex pattern. For simple substring matching, just use the text without special regex characters.',
910 | examples={
911 | 'Simple substring': 'bedrock',
912 | 'Case-insensitive exact match': '^AmazonBedrock$',
913 | 'Starts with': '^Amazon',
914 | 'Contains word': '\\bbedrock\\b',
915 | },
916 | )
917 |
918 | sorted_codes = sorted(service_codes)
919 | filter_msg = f' (filtered with pattern: "{filter}")' if filter else ''
920 |
921 | logger.info(f'Successfully retrieved {len(sorted_codes)} service codes{filter_msg}')
922 | await ctx.info(f'Successfully retrieved {len(sorted_codes)} service codes{filter_msg}')
923 |
924 | return sorted_codes
925 |
926 |
927 | @mcp.tool(
928 | name='get_pricing_service_attributes',
929 | description="""Get filterable attributes available for an AWS service in the Pricing API.
930 |
931 | **PURPOSE:** Discover what pricing dimensions (filters) are available for a specific AWS service.
932 |
933 | **WORKFLOW:** Use this after get_pricing_service_codes() to see what filters you can apply to narrow down pricing queries.
934 |
935 | **PARAMETERS:**
936 | - service_code: AWS service code from get_pricing_service_codes() (e.g., 'AmazonEC2', 'AmazonRDS')
937 | - filter (optional): Case-insensitive regex pattern to filter attribute names (e.g., "instance" matches "instanceType", "instanceFamily")
938 |
939 | **RETURNS:** List of attribute names (e.g., 'instanceType', 'location', 'storageClass') that can be used as filters.
940 |
941 | **NEXT STEPS:**
942 | - Use get_pricing_attribute_values() to see valid values for each attribute
943 | - Use these attributes in get_pricing() filters to get specific pricing data
944 |
945 | **EXAMPLE:** For 'AmazonRDS' you might get ['engineCode', 'instanceType', 'deploymentOption', 'location'].
946 | """,
947 | )
948 | async def get_pricing_service_attributes(
949 | ctx: Context,
950 | service_code: str = SERVICE_CODE_FIELD,
951 | filter: Optional[str] = SERVICE_ATTRIBUTES_FILTER_FIELD,
952 | ) -> Union[List[str], Dict[str, Any]]:
953 | """Retrieve all available attributes for a specific AWS service.
954 |
955 | Args:
956 | service_code: The service code to query (e.g., 'AmazonEC2', 'AmazonS3')
957 | filter: Optional regex pattern to filter attribute names (case-insensitive)
958 | ctx: MCP context for logging and state management
959 |
960 | Returns:
961 | List of sorted attribute name strings on success, or error dictionary on failure
962 | """
963 | # Handle Pydantic Field objects when called directly (not through MCP framework)
964 | if isinstance(filter, FieldInfo):
965 | filter = filter.default
966 |
967 | logger.info(f'Retrieving attributes for AWS service: {service_code}')
968 |
969 | # Create pricing client with error handling
970 | try:
971 | pricing_client = create_pricing_client()
972 | except Exception as e:
973 | return await create_error_response(
974 | ctx=ctx,
975 | error_type='client_creation_failed',
976 | message=f'Failed to create AWS Pricing client: {str(e)}',
977 | service_code=service_code,
978 | )
979 |
980 | # Get service attributes with error handling
981 | try:
982 | response = pricing_client.describe_services(ServiceCode=service_code)
983 | except Exception as e:
984 | return await create_error_response(
985 | ctx=ctx,
986 | error_type='api_error',
987 | message=f'Failed to retrieve attributes for service "{service_code}": {str(e)}',
988 | service_code=service_code,
989 | suggestion='Verify that the service code is valid and AWS credentials have the required pricing:DescribeServices permissions. Use get_service_codes() to get valid service codes.',
990 | )
991 |
992 | # Check if service was found
993 | if not response.get('Services'):
994 | return await create_error_response(
995 | ctx=ctx,
996 | error_type='service_not_found',
997 | message=f'Service "{service_code}" was not found. Please verify the service code is correct.',
998 | service_code=service_code,
999 | suggestion='Use get_service_codes() to retrieve a list of all available AWS service codes.',
1000 | examples={
1001 | 'OpenSearch': 'AmazonES',
1002 | 'Lambda': 'AWSLambda',
1003 | 'DynamoDB': 'AmazonDynamoDB',
1004 | 'EC2': 'AmazonEC2',
1005 | 'S3': 'AmazonS3',
1006 | },
1007 | )
1008 |
1009 | # Extract attribute names
1010 | attributes = []
1011 | for attr in response['Services'][0].get('AttributeNames', []):
1012 | attributes.append(attr)
1013 |
1014 | # Check for empty results
1015 | if not attributes:
1016 | return await create_error_response(
1017 | ctx=ctx,
1018 | error_type='empty_results',
1019 | message=f'Service "{service_code}" exists but has no filterable attributes available.',
1020 | service_code=service_code,
1021 | suggestion='This service may not support attribute-based filtering, or there may be a temporary issue. Try using get_pricing() without filters.',
1022 | )
1023 |
1024 | # Apply regex filtering if filter is provided
1025 | if filter:
1026 | try:
1027 | regex_pattern = re.compile(filter, re.IGNORECASE)
1028 | attributes = [attr for attr in attributes if regex_pattern.search(attr)]
1029 |
1030 | if not attributes:
1031 | return await create_error_response(
1032 | ctx=ctx,
1033 | error_type='no_matches_found',
1034 | message=f'No service attributes match the regex pattern: "{filter}"',
1035 | service_code=service_code,
1036 | filter=filter,
1037 | suggestion='Try a broader regex pattern or check the pattern syntax. Use get_pricing_service_attributes() without filter to see all available service attributes.',
1038 | )
1039 |
1040 | except re.error as e:
1041 | return await create_error_response(
1042 | ctx=ctx,
1043 | error_type='invalid_regex',
1044 | message=f'Invalid regex pattern "{filter}": {str(e)}',
1045 | service_code=service_code,
1046 | filter=filter,
1047 | suggestion='Please provide a valid regex pattern. For simple substring matching, just use the text without special regex characters.',
1048 | examples={
1049 | 'Simple substring': 'instance',
1050 | 'Case-insensitive exact match': '^instanceType$',
1051 | 'Starts with': '^instance',
1052 | 'Contains word': '\\binstance\\b',
1053 | },
1054 | )
1055 |
1056 | sorted_attributes = sorted(attributes)
1057 | filter_msg = f' (filtered with pattern: "{filter}")' if filter else ''
1058 |
1059 | logger.info(
1060 | f'Successfully retrieved {len(sorted_attributes)} attributes for {service_code}{filter_msg}'
1061 | )
1062 | await ctx.info(
1063 | f'Successfully retrieved {len(sorted_attributes)} attributes for {service_code}{filter_msg}'
1064 | )
1065 |
1066 | return sorted_attributes
1067 |
1068 |
1069 | class AttributeValuesError(Exception):
1070 | """Custom exception for attribute values retrieval errors."""
1071 |
1072 | def __init__(
1073 | self, error_type: str, message: str, service_code: str, attribute_name: str, **kwargs
1074 | ):
1075 | """Init AttributeValuesError."""
1076 | self.error_type = error_type
1077 | self.message = message
1078 | self.service_code = service_code
1079 | self.attribute_name = attribute_name
1080 | self.extra_fields = kwargs
1081 | super().__init__(message)
1082 |
1083 |
1084 | async def _get_single_attribute_values(
1085 | pricing_client,
1086 | service_code: str,
1087 | attribute_name: str,
1088 | ) -> List[str]:
1089 | """Helper function to retrieve values for a single attribute.
1090 |
1091 | Args:
1092 | pricing_client: AWS pricing client instance
1093 | service_code: The service code to query
1094 | attribute_name: The attribute name to get values for
1095 |
1096 | Returns:
1097 | List of sorted attribute values on success
1098 |
1099 | Raises:
1100 | AttributeValuesError: When API calls fail or no values are found
1101 | """
1102 | try:
1103 | # Get attribute values with pagination handling
1104 | values = []
1105 | next_token = None
1106 |
1107 | while True:
1108 | if next_token:
1109 | response = pricing_client.get_attribute_values(
1110 | ServiceCode=service_code,
1111 | AttributeName=attribute_name,
1112 | MaxResults=5000,
1113 | NextToken=next_token,
1114 | )
1115 | else:
1116 | response = pricing_client.get_attribute_values(
1117 | ServiceCode=service_code, AttributeName=attribute_name, MaxResults=5000
1118 | )
1119 |
1120 | for attr_value in response.get('AttributeValues', []):
1121 | if 'Value' in attr_value:
1122 | values.append(attr_value['Value'])
1123 |
1124 | if 'NextToken' in response:
1125 | next_token = response['NextToken']
1126 | else:
1127 | break
1128 |
1129 | except Exception as e:
1130 | raise AttributeValuesError(
1131 | error_type='api_error',
1132 | message=f'Failed to retrieve values for attribute "{attribute_name}" of service "{service_code}": {str(e)}',
1133 | service_code=service_code,
1134 | attribute_name=attribute_name,
1135 | suggestion='Verify that both the service code and attribute name are valid. Use get_service_codes() to get valid service codes and get_service_attributes() to get valid attributes for a service.',
1136 | )
1137 |
1138 | # Check if no values were found
1139 | if not values:
1140 | raise AttributeValuesError(
1141 | error_type='no_attribute_values_found',
1142 | message=f'No values found for attribute "{attribute_name}" of service "{service_code}". This could be due to an invalid service code or an invalid attribute name for this service.',
1143 | service_code=service_code,
1144 | attribute_name=attribute_name,
1145 | suggestion='Use get_service_codes() to verify the service code and get_service_attributes() to verify the attribute name for this service.',
1146 | examples={
1147 | 'Common service codes': ['AmazonEC2', 'AmazonS3', 'AmazonES', 'AWSLambda'],
1148 | 'Common attributes': [
1149 | 'instanceType',
1150 | 'location',
1151 | 'storageClass',
1152 | 'engineCode',
1153 | ],
1154 | },
1155 | )
1156 |
1157 | return sorted(values)
1158 |
1159 |
1160 | @mcp.tool(
1161 | name='get_pricing_attribute_values',
1162 | description="""Get valid values for pricing filter attributes.
1163 |
1164 | **PURPOSE:** Discover what values are available for specific pricing filter attributes of an AWS service.
1165 |
1166 | **WORKFLOW:** Use this after get_pricing_service_attributes() to see valid values for each filter attribute.
1167 |
1168 | **PARAMETERS:**
1169 | - Service code from get_pricing_service_codes() (e.g., 'AmazonEC2', 'AmazonRDS')
1170 | - List of attribute names from get_pricing_service_attributes() (e.g., ['instanceType', 'location'])
1171 | - filters (optional): Dictionary mapping attribute names to regex patterns (e.g., {'instanceType': 't3'})
1172 |
1173 | **RETURNS:** Dictionary mapping attribute names to their valid values. Filtered attributes return only matching values, unfiltered attributes return all values.
1174 |
1175 | **EXAMPLE RETURN:**
1176 | ```
1177 | {
1178 | 'instanceType': ['t2.micro', 't3.medium', 'm5.large', ...],
1179 | 'location': ['US East (N. Virginia)', 'EU (London)', ...]
1180 | }
1181 | ```
1182 |
1183 | **NEXT STEPS:** Use these values in get_pricing() filters to get specific pricing data.
1184 |
1185 | **ERROR HANDLING:** Uses "all-or-nothing" approach - if any attribute fails, the entire operation fails.
1186 |
1187 | **EXAMPLES:**
1188 | - Single attribute: ['instanceType'] returns {'instanceType': ['t2.micro', 't3.medium', ...]}
1189 | - Multiple attributes: ['instanceType', 'location'] returns both mappings
1190 | - Partial filtering: filters={'instanceType': 't3'} applies only to instanceType, location returns all values
1191 | """,
1192 | )
1193 | async def get_pricing_attribute_values(
1194 | ctx: Context,
1195 | service_code: str = SERVICE_CODE_FIELD,
1196 | attribute_names: List[str] = ATTRIBUTE_NAMES_FIELD,
1197 | filters: Optional[Dict[str, str]] = ATTRIBUTE_VALUES_FILTERS_FIELD,
1198 | ) -> Union[Dict[str, List[str]], Dict[str, Any]]:
1199 | """Retrieve all possible values for specific attributes of an AWS service.
1200 |
1201 | Args:
1202 | service_code: The service code to query (e.g., 'AmazonEC2', 'AmazonS3')
1203 | attribute_names: List of attribute names to get values for (e.g., ['instanceType', 'location'])
1204 | filters: Optional dictionary mapping attribute names to regex patterns for filtering
1205 | ctx: MCP context for logging and state management
1206 |
1207 | Returns:
1208 | Dictionary mapping attribute names to sorted lists of values on success, or error dictionary on failure
1209 | """
1210 | if isinstance(filters, FieldInfo):
1211 | filters = filters.default
1212 |
1213 | if not attribute_names:
1214 | return await create_error_response(
1215 | ctx=ctx,
1216 | error_type='empty_attribute_list',
1217 | message='No attribute names provided. Please provide at least one attribute name.',
1218 | service_code=service_code,
1219 | attribute_names=attribute_names,
1220 | suggestion='Use get_pricing_service_attributes() to get valid attribute names for this service.',
1221 | )
1222 |
1223 | logger.info(
1224 | f'Retrieving values for {len(attribute_names)} attributes of service: {service_code}'
1225 | )
1226 |
1227 | # Create pricing client with error handling
1228 | try:
1229 | pricing_client = create_pricing_client()
1230 | except Exception as e:
1231 | return await create_error_response(
1232 | ctx=ctx,
1233 | error_type='client_creation_failed',
1234 | message=f'Failed to create AWS Pricing client: {str(e)}',
1235 | service_code=service_code,
1236 | attribute_names=attribute_names,
1237 | )
1238 |
1239 | # Process each attribute - all-or-nothing approach
1240 | result = {}
1241 | for attribute_name in attribute_names:
1242 | logger.debug(f'Processing attribute: {attribute_name}')
1243 |
1244 | try:
1245 | values_result = await _get_single_attribute_values(
1246 | pricing_client, service_code, attribute_name
1247 | )
1248 |
1249 | # Apply filtering if a filter is provided for this attribute
1250 | if filters and attribute_name in filters:
1251 | filter_pattern = filters[attribute_name]
1252 | logger.debug(f'Applying filter "{filter_pattern}" to attribute "{attribute_name}"')
1253 |
1254 | try:
1255 | regex_pattern = re.compile(filter_pattern, re.IGNORECASE)
1256 | filtered_values = [
1257 | value for value in values_result if regex_pattern.search(value)
1258 | ]
1259 |
1260 | # Use filtered values (even if empty list)
1261 | values_result = sorted(filtered_values)
1262 |
1263 | except re.error as e:
1264 | # If regex is invalid, return error for entire operation
1265 | return await create_error_response(
1266 | ctx=ctx,
1267 | error_type='invalid_regex',
1268 | message=f'Invalid regex pattern "{filter_pattern}" for attribute "{attribute_name}": {str(e)}',
1269 | service_code=service_code,
1270 | attribute_name=attribute_name,
1271 | filter_pattern=filter_pattern,
1272 | requested_attributes=attribute_names,
1273 | filters=filters,
1274 | suggestion='Please provide a valid regex pattern. For simple substring matching, just use the text without special regex characters.',
1275 | examples={
1276 | 'Simple substring': 't3',
1277 | 'Case-insensitive exact match': '^t3\\.medium$',
1278 | 'Starts with': '^t3',
1279 | 'Contains word': '\\bt3\\b',
1280 | },
1281 | )
1282 |
1283 | # Success - add to result (filtered or unfiltered)
1284 | result[attribute_name] = values_result
1285 | except AttributeValuesError as e:
1286 | # If any attribute fails, return error for entire operation
1287 | return await create_error_response(
1288 | ctx=ctx,
1289 | error_type=e.error_type,
1290 | message=f'Failed to retrieve values for attribute "{attribute_name}": {e.message}',
1291 | service_code=e.service_code,
1292 | attribute_name=e.attribute_name,
1293 | failed_attribute=attribute_name,
1294 | requested_attributes=attribute_names,
1295 | **e.extra_fields,
1296 | )
1297 |
1298 | total_values = sum(len(values) for values in result.values())
1299 | logger.info(
1300 | f'Successfully retrieved {total_values} total values for {len(attribute_names)} attributes of service {service_code}'
1301 | )
1302 | await ctx.info(
1303 | f'Successfully retrieved values for {len(attribute_names)} attributes of service {service_code}'
1304 | )
1305 |
1306 | return result
1307 |
1308 |
1309 | @mcp.tool(
1310 | name='get_price_list_urls',
1311 | description="""Get download URLs for bulk pricing data files.
1312 |
1313 | **PURPOSE:** Access complete AWS pricing datasets as downloadable files for historical analysis and bulk processing.
1314 |
1315 | **WORKFLOW:** Use this for historical pricing analysis or bulk data processing when current pricing from get_pricing() isn't sufficient.
1316 |
1317 | **PARAMETERS:**
1318 | - Service code from get_pricing_service_codes() (e.g., 'AmazonEC2', 'AmazonS3')
1319 | - AWS region (e.g., 'us-east-1', 'eu-west-1')
1320 | - Optional: effective_date for historical pricing (default: current date)
1321 |
1322 | **RETURNS:** Dictionary with download URLs for different formats:
1323 | - 'csv': Direct download URL for CSV format
1324 | - 'json': Direct download URL for JSON format
1325 |
1326 | **USE CASES:**
1327 | - Historical pricing analysis (get_pricing() only provides current pricing)
1328 | - Bulk data processing without repeated API calls
1329 | - Offline analysis of complete pricing datasets
1330 | - Savings Plans analysis across services
1331 |
1332 | **FILE PROCESSING:**
1333 | - CSV files: Lines 1-5 are metadata, Line 6 contains headers, Line 7+ contains pricing data
1334 | - Use `tail -n +7 pricing.csv | grep "t3.medium"` to filter data
1335 | """,
1336 | )
1337 | async def get_price_list_urls(
1338 | ctx: Context,
1339 | service_code: str = SERVICE_CODE_FIELD,
1340 | region: str = Field(..., description='AWS region (e.g., "us-east-1", "eu-west-1")'),
1341 | effective_date: Optional[str] = EFFECTIVE_DATE_FIELD,
1342 | ) -> Dict[str, Any]:
1343 | """Get URLs to download bulk pricing data from AWS Price List API for all available formats.
1344 |
1345 | This tool combines the list-price-lists and get-price-list-file-url API calls
1346 | to provide download URLs for all available file formats.
1347 |
1348 | Args:
1349 | ctx: MCP context for logging and state management
1350 | service_code: AWS service code (e.g., 'AmazonEC2', 'AmazonS3')
1351 | region: AWS region (e.g., 'us-east-1')
1352 | effective_date: Effective date in 'YYYY-MM-DD HH:MM' format (default: current timestamp)
1353 |
1354 | Returns:
1355 | Dictionary containing download URLs for all available formats
1356 | """
1357 | logger.info(f'Getting price list file URLs for {service_code} in {region}')
1358 |
1359 | # Set effective date to current timestamp if not provided
1360 | if not effective_date:
1361 | effective_date = datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M')
1362 | logger.debug(f'Using current timestamp for effective_date: {effective_date}')
1363 |
1364 | # Determine currency based on region
1365 | currency = get_currency_for_region(region)
1366 | logger.debug(f'Using currency {currency} for region {region}')
1367 |
1368 | try:
1369 | # Create pricing client
1370 | pricing_client = create_pricing_client()
1371 | except Exception as e:
1372 | return await create_error_response(
1373 | ctx=ctx,
1374 | error_type='client_creation_failed',
1375 | message=f'Failed to create AWS Pricing client: {str(e)}',
1376 | service_code=service_code,
1377 | region=region,
1378 | )
1379 |
1380 | # Step 1: List price lists to find the appropriate ARN
1381 | logger.info(
1382 | f'Searching for price list: service={service_code}, region={region}, date={effective_date}, currency={currency}'
1383 | )
1384 |
1385 | try:
1386 | list_response = pricing_client.list_price_lists(
1387 | ServiceCode=service_code,
1388 | EffectiveDate=effective_date,
1389 | RegionCode=region,
1390 | CurrencyCode=currency,
1391 | )
1392 | except Exception as e:
1393 | return await create_error_response(
1394 | ctx=ctx,
1395 | error_type='list_price_lists_failed',
1396 | message=f'Failed to list price lists for service "{service_code}" in region "{region}": {str(e)}',
1397 | service_code=service_code,
1398 | region=region,
1399 | effective_date=effective_date,
1400 | currency=currency,
1401 | suggestion='Verify that the service code and region combination is valid. Use get_service_codes() to get valid service codes.',
1402 | )
1403 |
1404 | # Check if any price lists were found
1405 | price_lists = list_response.get('PriceLists', [])
1406 | if not price_lists:
1407 | return await create_error_response(
1408 | ctx=ctx,
1409 | error_type='no_price_list_found',
1410 | message=f'No price lists found for service "{service_code}" in region "{region}" for date "{effective_date}" with currency "{currency}"',
1411 | service_code=service_code,
1412 | region=region,
1413 | effective_date=effective_date,
1414 | currency=currency,
1415 | suggestion='Try using a different effective date or verify the service code and region combination using get_service_codes() and get_attribute_values().',
1416 | )
1417 |
1418 | # Get the first (most recent) price list
1419 | price_list = price_lists[0]
1420 | price_list_arn = price_list['PriceListArn']
1421 | supported_formats = price_list.get('FileFormats', [])
1422 | logger.info(f'Found price list ARN: {price_list_arn} with formats: {supported_formats}')
1423 |
1424 | if not supported_formats:
1425 | return await create_error_response(
1426 | ctx=ctx,
1427 | error_type='no_formats_available',
1428 | message=f'Price list found but no file formats are available for service "{service_code}"',
1429 | service_code=service_code,
1430 | region=region,
1431 | price_list_arn=price_list_arn,
1432 | )
1433 |
1434 | # Step 2: Get URLs for all available formats
1435 | result = {'arn': price_list_arn, 'urls': {}}
1436 |
1437 | for file_format in supported_formats:
1438 | format_key = file_format.lower()
1439 | logger.info(f'Getting file URL for format: {file_format}')
1440 |
1441 | try:
1442 | url_response = pricing_client.get_price_list_file_url(
1443 | PriceListArn=price_list_arn, FileFormat=file_format.upper()
1444 | )
1445 |
1446 | download_url = url_response.get('Url')
1447 | if not download_url:
1448 | return await create_error_response(
1449 | ctx=ctx,
1450 | error_type='empty_url_response',
1451 | message=f'AWS API returned empty URL for format "{file_format}"',
1452 | service_code=service_code,
1453 | region=region,
1454 | price_list_arn=price_list_arn,
1455 | file_format=format_key,
1456 | suggestion='This may be a temporary AWS service issue. Try again in a few minutes.',
1457 | )
1458 |
1459 | result['urls'][format_key] = download_url
1460 | logger.debug(f'Successfully got URL for format {file_format}')
1461 |
1462 | except Exception as e:
1463 | return await create_error_response(
1464 | ctx=ctx,
1465 | error_type='format_url_failed',
1466 | message=f'Failed to get download URL for format "{file_format}": {str(e)}',
1467 | service_code=service_code,
1468 | region=region,
1469 | price_list_arn=price_list_arn,
1470 | file_format=format_key,
1471 | suggestion='This format may not be available for this service. Check supported_formats in the price list response.',
1472 | )
1473 |
1474 | logger.info(
1475 | f'Successfully retrieved {len(result["urls"])} price list file URLs for {service_code}'
1476 | )
1477 | await ctx.info(f'Successfully retrieved price list file URLs for {service_code}')
1478 |
1479 | return result['urls']
1480 |
1481 |
1482 | def main():
1483 | """Run the MCP server with CLI argument support."""
1484 | mcp.run()
1485 |
1486 |
1487 | if __name__ == '__main__':
1488 | main()
1489 |
```