This is page 505 of 542. 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
│ │ │ └── sql_analyzer.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ └── glue_data_catalog
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_data_catalog_database_manager.py
│ │ │ │ ├── test_data_catalog_handler.py
│ │ │ │ └── test_data_catalog_table_manager.py
│ │ │ ├── handlers
│ │ │ │ ├── __init__.py
│ │ │ │ ├── athena
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── test_athena_data_catalog_handler.py
│ │ │ │ │ ├── test_athena_query_handler.py
│ │ │ │ │ ├── test_athena_workgroup_handler.py
│ │ │ │ │ └── test_custom_tags_athena.py
│ │ │ │ ├── commons
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ └── test_common_resource_handler.py
│ │ │ │ ├── emr
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── test_custom_tags_emr.py
│ │ │ │ │ ├── test_emr_ec2_cluster_handler.py
│ │ │ │ │ ├── test_emr_ec2_instance_handler.py
│ │ │ │ │ └── test_emr_ec2_steps_handler.py
│ │ │ │ └── glue
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_crawler_handler.py
│ │ │ │ ├── test_custom_tags_glue.py
│ │ │ │ ├── test_data_catalog_handler.py
│ │ │ │ ├── test_glue_commons_handler.py
│ │ │ │ ├── test_glue_etl_handler.py
│ │ │ │ ├── test_glue_interactive_sessions_handler.py
│ │ │ │ └── test_glue_workflows_handler.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_athena_models.py
│ │ │ │ ├── test_common_resource_models.py
│ │ │ │ ├── test_data_catalog_models.py
│ │ │ │ ├── test_emr_models.py
│ │ │ │ ├── test_glue_models.py
│ │ │ │ ├── test_interactive_sessions_models.py
│ │ │ │ └── test_workflows_models.py
│ │ │ ├── test_init.py
│ │ │ ├── test_server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── test_aws_helper.py
│ │ │ ├── test_custom_tags.py
│ │ │ ├── test_logging_helper.py
│ │ │ └── test_sql_analyzer.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-diagram-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_diagram_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── diagrams_tools.py
│ │ │ ├── models.py
│ │ │ ├── scanner.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── resources
│ │ │ │ ├── __init__.py
│ │ │ │ └── example_diagrams
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_example.py
│ │ │ │ ├── flow_example.py
│ │ │ │ └── sequence_example.py
│ │ │ ├── test_diagrams.py
│ │ │ ├── test_models.py
│ │ │ ├── test_sarif_fix.py
│ │ │ ├── test_scanner.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-documentation-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_documentation_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── models.py
│ │ │ ├── server_aws_cn.py
│ │ │ ├── server_aws.py
│ │ │ ├── server_utils.py
│ │ │ ├── server.py
│ │ │ └── util.py
│ │ ├── basic-usage.gif
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── constants.py
│ │ │ ├── resources
│ │ │ │ └── lambda_sns_raw.html
│ │ │ ├── test_aws_cn_get_available_services_live.py
│ │ │ ├── test_aws_cn_read_documentation_live.py
│ │ │ ├── test_aws_read_documentation_live.py
│ │ │ ├── test_aws_recommend_live.py
│ │ │ ├── test_aws_search_live.py
│ │ │ ├── test_metadata_handling.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server_aws_cn.py
│ │ │ ├── test_server_aws.py
│ │ │ ├── test_server_utils.py
│ │ │ ├── test_server.py
│ │ │ └── test_util.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-healthomics-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_healthomics_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── helper_tools.py
│ │ │ │ ├── run_analysis.py
│ │ │ │ ├── troubleshooting.py
│ │ │ │ ├── workflow_analysis.py
│ │ │ │ ├── workflow_execution.py
│ │ │ │ ├── workflow_linting.py
│ │ │ │ └── workflow_management.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws_utils.py
│ │ │ ├── s3_utils.py
│ │ │ └── validation_utils.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── docs
│ │ │ └── workflow_linting.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_aws_utils.py
│ │ │ ├── test_consts.py
│ │ │ ├── test_helper_tools.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_run_analysis.py
│ │ │ ├── test_s3_utils.py
│ │ │ ├── test_server.py
│ │ │ ├── test_troubleshooting.py
│ │ │ ├── test_workflow_analysis.py
│ │ │ ├── test_workflow_execution.py
│ │ │ ├── test_workflow_linting.py
│ │ │ ├── test_workflow_management.py
│ │ │ └── test_workflow_tools.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-iot-sitewise-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_iot_sitewise_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── models.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── asset_hierarchy.py
│ │ │ │ ├── bulk_import_workflow.py
│ │ │ │ ├── data_exploration.py
│ │ │ │ └── data_ingestion.py
│ │ │ ├── server.py
│ │ │ ├── tool_metadata.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── sitewise_access.py
│ │ │ │ ├── sitewise_asset_models.py
│ │ │ │ ├── sitewise_assets.py
│ │ │ │ ├── sitewise_data.py
│ │ │ │ ├── sitewise_gateways.py
│ │ │ │ └── sitewise_metadata_transfer.py
│ │ │ └── validation.py
│ │ ├── CHANGELOG.md
│ │ ├── DEVELOPMENT.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ └── wind_farm_example.py
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_server.py
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_client.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ ├── test_sitewise_access.py
│ │ │ ├── test_sitewise_asset_models.py
│ │ │ ├── test_sitewise_assets.py
│ │ │ ├── test_sitewise_data.py
│ │ │ ├── test_sitewise_gateways.py
│ │ │ ├── test_sitewise_metadata_transfer.py
│ │ │ └── test_validation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-knowledge-mcp-server
│ │ └── README.md
│ ├── aws-location-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_location_server
│ │ │ ├── __init__.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_server_integration.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-msk-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_msk_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── tools
│ │ │ ├── __init__.py
│ │ │ ├── common_functions
│ │ │ │ ├── __init__.py
│ │ │ │ ├── client_manager.py
│ │ │ │ └── common_functions.py
│ │ │ ├── logs_and_telemetry
│ │ │ │ ├── __init__.py
│ │ │ │ ├── cluster_metrics_tools.py
│ │ │ │ ├── list_customer_iam_access.py
│ │ │ │ └── metric_config.py
│ │ │ ├── mutate_cluster
│ │ │ │ ├── __init__.py
│ │ │ │ ├── batch_associate_scram_secret.py
│ │ │ │ ├── batch_disassociate_scram_secret.py
│ │ │ │ ├── create_cluster_v2.py
│ │ │ │ ├── put_cluster_policy.py
│ │ │ │ ├── reboot_broker.py
│ │ │ │ ├── update_broker_count.py
│ │ │ │ ├── update_broker_storage.py
│ │ │ │ ├── update_broker_type.py
│ │ │ │ ├── update_cluster_configuration.py
│ │ │ │ ├── update_monitoring.py
│ │ │ │ └── update_security.py
│ │ │ ├── mutate_config
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_configuration.py
│ │ │ │ ├── tag_resource.py
│ │ │ │ ├── untag_resource.py
│ │ │ │ └── update_configuration.py
│ │ │ ├── mutate_vpc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_vpc_connection.py
│ │ │ │ ├── delete_vpc_connection.py
│ │ │ │ └── reject_client_vpc_connection.py
│ │ │ ├── read_cluster
│ │ │ │ ├── __init__.py
│ │ │ │ ├── describe_cluster_operation.py
│ │ │ │ ├── describe_cluster.py
│ │ │ │ ├── get_bootstrap_brokers.py
│ │ │ │ ├── get_cluster_policy.py
│ │ │ │ ├── get_compatible_kafka_versions.py
│ │ │ │ ├── list_client_vpc_connections.py
│ │ │ │ ├── list_cluster_operations.py
│ │ │ │ ├── list_nodes.py
│ │ │ │ └── list_scram_secrets.py
│ │ │ ├── read_config
│ │ │ │ ├── __init__.py
│ │ │ │ ├── describe_configuration_revision.py
│ │ │ │ ├── describe_configuration.py
│ │ │ │ ├── list_configuration_revisions.py
│ │ │ │ └── list_tags_for_resource.py
│ │ │ ├── read_global
│ │ │ │ ├── __init__.py
│ │ │ │ ├── list_clusters.py
│ │ │ │ ├── list_configurations.py
│ │ │ │ ├── list_kafka_versions.py
│ │ │ │ └── list_vpc_connections.py
│ │ │ ├── read_vpc
│ │ │ │ ├── __init__.py
│ │ │ │ └── describe_vpc_connection.py
│ │ │ └── static_tools
│ │ │ ├── __init__.py
│ │ │ └── cluster_best_practices.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_client_manager.py
│ │ │ ├── test_cluster_metrics_tools.py
│ │ │ ├── test_common_functions.py
│ │ │ ├── test_create_cluster_v2.py
│ │ │ ├── test_create_configuration.py
│ │ │ ├── test_create_vpc_connection.py
│ │ │ ├── test_delete_vpc_connection.py
│ │ │ ├── test_describe_cluster_operation.py
│ │ │ ├── test_describe_cluster.py
│ │ │ ├── test_describe_configuration_revision.py
│ │ │ ├── test_describe_configuration.py
│ │ │ ├── test_describe_vpc_connection.py
│ │ │ ├── test_get_bootstrap_brokers.py
│ │ │ ├── test_get_cluster_policy.py
│ │ │ ├── test_get_compatible_kafka_versions.py
│ │ │ ├── test_init.py
│ │ │ ├── test_list_client_vpc_connections.py
│ │ │ ├── test_list_cluster_operations.py
│ │ │ ├── test_list_clusters.py
│ │ │ ├── test_list_configuration_revisions.py
│ │ │ ├── test_list_configurations.py
│ │ │ ├── test_list_customer_iam_access.py
│ │ │ ├── test_list_kafka_versions.py
│ │ │ ├── test_list_nodes.py
│ │ │ ├── test_list_scram_secrets.py
│ │ │ ├── test_list_tags_for_resource.py
│ │ │ ├── test_list_vpc_connections.py
│ │ │ ├── test_logs_and_telemetry.py
│ │ │ ├── test_main.py
│ │ │ ├── test_mutate_cluster_init.py
│ │ │ ├── test_mutate_cluster_success_cases.py
│ │ │ ├── test_mutate_cluster.py
│ │ │ ├── test_mutate_config_init.py
│ │ │ ├── test_mutate_vpc_init.py
│ │ │ ├── test_read_cluster_init_updated.py
│ │ │ ├── test_read_cluster_init.py
│ │ │ ├── test_read_config_init.py
│ │ │ ├── test_read_global_init.py
│ │ │ ├── test_read_vpc_init.py
│ │ │ ├── test_reject_client_vpc_connection.py
│ │ │ ├── test_server.py
│ │ │ ├── test_static_tools_init.py
│ │ │ ├── test_tag_resource.py
│ │ │ ├── test_tool_descriptions.py
│ │ │ ├── test_untag_resource.py
│ │ │ └── test_update_configuration.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-pricing-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_pricing_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── cdk_analyzer.py
│ │ │ ├── consts.py
│ │ │ ├── helpers.py
│ │ │ ├── models.py
│ │ │ ├── pricing_client.py
│ │ │ ├── pricing_transformer.py
│ │ │ ├── report_generator.py
│ │ │ ├── server.py
│ │ │ ├── static
│ │ │ │ ├── __init__.py
│ │ │ │ ├── COST_REPORT_TEMPLATE.md
│ │ │ │ └── patterns
│ │ │ │ ├── __init__.py
│ │ │ │ └── BEDROCK.md
│ │ │ └── terraform_analyzer.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_cdk_analyzer.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_pricing_client.py
│ │ │ ├── test_pricing_transformer.py
│ │ │ ├── test_report_generator.py
│ │ │ ├── test_server.py
│ │ │ └── test_terraform_analyzer.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── aws-serverless-mcp-server
│ │ ├── .pre-commit.config.yaml
│ │ ├── .python-version
│ │ ├── .secrets.baseline
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_serverless_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── models.py
│ │ │ ├── resources
│ │ │ │ ├── __init__.py
│ │ │ │ ├── deployment_details.py
│ │ │ │ ├── deployment_list.py
│ │ │ │ ├── template_details.py
│ │ │ │ └── template_list.py
│ │ │ ├── server.py
│ │ │ ├── template
│ │ │ │ ├── __init__.py
│ │ │ │ ├── registry.py
│ │ │ │ ├── renderer.py
│ │ │ │ └── templates
│ │ │ │ ├── backend.j2
│ │ │ │ ├── frontend.j2
│ │ │ │ ├── fullstack.j2
│ │ │ │ └── README.md
│ │ │ ├── templates
│ │ │ │ ├── __init__.py
│ │ │ │ └── iam_policies.py
│ │ │ ├── tools
│ │ │ │ ├── common
│ │ │ │ │ └── base_tool.py
│ │ │ │ ├── esm
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── esm_diagnosis.py
│ │ │ │ │ ├── esm_guidance.py
│ │ │ │ │ ├── esm_recommend.py
│ │ │ │ │ └── secure_esm_guidance.py
│ │ │ │ ├── guidance
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── deploy_serverless_app_help.py
│ │ │ │ │ ├── get_iac_guidance.py
│ │ │ │ │ ├── get_lambda_event_schemas.py
│ │ │ │ │ ├── get_lambda_guidance.py
│ │ │ │ │ └── get_serverless_templates.py
│ │ │ │ ├── poller
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── esm_diagnosis.py
│ │ │ │ │ ├── esm_guidance.py
│ │ │ │ │ └── esm_recommend.py
│ │ │ │ ├── sam
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── sam_build.py
│ │ │ │ │ ├── sam_deploy.py
│ │ │ │ │ ├── sam_init.py
│ │ │ │ │ ├── sam_local_invoke.py
│ │ │ │ │ └── sam_logs.py
│ │ │ │ ├── schemas
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── describe_schema.py
│ │ │ │ │ ├── list_registries.py
│ │ │ │ │ └── search_schema.py
│ │ │ │ └── webapps
│ │ │ │ ├── __init__.py
│ │ │ │ ├── configure_domain.py
│ │ │ │ ├── deploy_webapp.py
│ │ │ │ ├── get_metrics.py
│ │ │ │ ├── update_webapp_frontend.py
│ │ │ │ ├── utils
│ │ │ │ │ ├── deploy_service.py
│ │ │ │ │ ├── frontend_uploader.py
│ │ │ │ │ └── startup_script_generator.py
│ │ │ │ └── webapp_deployment_help.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── aws_client_helper.py
│ │ │ ├── cloudformation.py
│ │ │ ├── const.py
│ │ │ ├── data_scrubber.py
│ │ │ ├── deployment_manager.py
│ │ │ ├── github.py
│ │ │ └── process.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_cloudformation.py
│ │ │ ├── test_configure_domain.py
│ │ │ ├── test_data_scrubber.py
│ │ │ ├── test_deploy_serverless_app_help.py
│ │ │ ├── test_deploy_service.py
│ │ │ ├── test_deploy_webapp.py
│ │ │ ├── test_deployment_details.py
│ │ │ ├── test_deployment_help.py
│ │ │ ├── test_deployment_list.py
│ │ │ ├── test_deployment_manager.py
│ │ │ ├── test_esm_diagnosis.py
│ │ │ ├── test_esm_guidance.py
│ │ │ ├── test_esm_recommend.py
│ │ │ ├── test_frontend_uploader.py
│ │ │ ├── test_get_iac_guidance.py
│ │ │ ├── test_get_lambda_event_schemas.py
│ │ │ ├── test_get_lambda_guidance.py
│ │ │ ├── test_get_metrics.py
│ │ │ ├── test_get_serverless_templates.py
│ │ │ ├── test_github.py
│ │ │ ├── test_iam_policies.py
│ │ │ ├── test_models.py
│ │ │ ├── test_process.py
│ │ │ ├── test_sam_build.py
│ │ │ ├── test_sam_deploy.py
│ │ │ ├── test_sam_init.py
│ │ │ ├── test_sam_local_invoke.py
│ │ │ ├── test_sam_logs.py
│ │ │ ├── test_schemas.py
│ │ │ ├── test_secure_esm_guidance.py
│ │ │ ├── test_server.py
│ │ │ ├── test_startup_script_generator.py
│ │ │ ├── test_template_details.py
│ │ │ ├── test_template_list.py
│ │ │ ├── test_template_registry.py
│ │ │ ├── test_template_renderer.py
│ │ │ └── test_update_webapp_frontend.py
│ │ └── uv.lock
│ ├── aws-support-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── aws_support_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── client.py
│ │ │ ├── consts.py
│ │ │ ├── debug_helper.py
│ │ │ ├── errors.py
│ │ │ ├── formatters.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftests.py
│ │ │ ├── test_aws_support_mcp_server.py
│ │ │ └── test_models.py
│ │ └── uv.lock
│ ├── bedrock-kb-retrieval-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── bedrock_kb_retrieval_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── knowledgebases
│ │ │ │ ├── __init__.py
│ │ │ │ ├── clients.py
│ │ │ │ ├── discovery.py
│ │ │ │ └── retrieval.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_clients.py
│ │ │ ├── test_discovery.py
│ │ │ ├── test_env_config.py
│ │ │ ├── test_models.py
│ │ │ ├── test_retrieval.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── billing-cost-management-mcp-server
│ │ ├── __init__.py
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── billing_cost_management_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── models.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── decorator.py
│ │ │ │ ├── graviton_migration.py
│ │ │ │ ├── README.md
│ │ │ │ ├── savings_plans.py
│ │ │ │ └── types.py
│ │ │ ├── server.py
│ │ │ ├── templates
│ │ │ │ └── recommendation_templates
│ │ │ │ ├── ebs_volume.template
│ │ │ │ ├── ec2_asg.template
│ │ │ │ ├── ec2_instance.template
│ │ │ │ ├── ecs_service.template
│ │ │ │ ├── idle.template
│ │ │ │ ├── lambda_function.template
│ │ │ │ ├── rds_database.template
│ │ │ │ ├── reserved_instances.template
│ │ │ │ └── savings_plans.template
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_pricing_operations.py
│ │ │ │ ├── aws_pricing_tools.py
│ │ │ │ ├── bcm_pricing_calculator_tools.py
│ │ │ │ ├── budget_tools.py
│ │ │ │ ├── compute_optimizer_tools.py
│ │ │ │ ├── cost_anomaly_tools.py
│ │ │ │ ├── cost_comparison_tools.py
│ │ │ │ ├── cost_explorer_operations.py
│ │ │ │ ├── cost_explorer_tools.py
│ │ │ │ ├── cost_optimization_hub_helpers.py
│ │ │ │ ├── cost_optimization_hub_tools.py
│ │ │ │ ├── free_tier_usage_tools.py
│ │ │ │ ├── recommendation_details_tools.py
│ │ │ │ ├── ri_performance_tools.py
│ │ │ │ ├── sp_performance_tools.py
│ │ │ │ ├── storage_lens_tools.py
│ │ │ │ └── unified_sql_tools.py
│ │ │ └── utilities
│ │ │ ├── __init__.py
│ │ │ ├── aws_service_base.py
│ │ │ ├── constants.py
│ │ │ ├── logging_utils.py
│ │ │ └── sql_utils.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── requirements.txt
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ └── test_prompts.py
│ │ │ ├── README.md
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── fixtures.py
│ │ │ │ ├── test_aws_bcm_pricing_calculator_tools.py
│ │ │ │ ├── test_aws_pricing_tools.py
│ │ │ │ ├── test_budget_tools.py
│ │ │ │ ├── test_compute_optimizer_tools.py
│ │ │ │ ├── test_cost_anomaly_tools_enhanced.py
│ │ │ │ ├── test_cost_anomaly_tools.py
│ │ │ │ ├── test_cost_comparison_tools.py
│ │ │ │ ├── test_cost_explorer_operations.py
│ │ │ │ ├── test_cost_explorer_tools.py
│ │ │ │ ├── test_cost_optimization_hub_helpers.py
│ │ │ │ ├── test_cost_optimization_hub_tools.py
│ │ │ │ ├── test_free_tier_usage_tools_new.py
│ │ │ │ ├── test_recommendation_details_tools.py
│ │ │ │ ├── test_ri_performance_tools.py
│ │ │ │ ├── test_sp_performance_tools.py
│ │ │ │ ├── test_storage_lens_tools.py
│ │ │ │ └── test_unified_sql_tools.py
│ │ │ └── utilities
│ │ │ ├── test_aws_service_base.py
│ │ │ └── test_sql_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── ccapi-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── ccapi_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_client.py
│ │ │ ├── cloud_control_utils.py
│ │ │ ├── context.py
│ │ │ ├── errors.py
│ │ │ ├── iac_generator.py
│ │ │ ├── impl
│ │ │ │ ├── __init__.py
│ │ │ │ ├── tools
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── explanation.py
│ │ │ │ │ ├── infrastructure_generation.py
│ │ │ │ │ ├── resource_operations.py
│ │ │ │ │ ├── security_scanning.py
│ │ │ │ │ └── session_management.py
│ │ │ │ └── utils
│ │ │ │ ├── __init__.py
│ │ │ │ └── validation.py
│ │ │ ├── infrastructure_generator.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ └── models.py
│ │ │ ├── schema_manager.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ └── __init__.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_aws_client.py
│ │ │ ├── test_checkov_install.py
│ │ │ ├── test_cloud_control_utils.py
│ │ │ ├── test_context.py
│ │ │ ├── test_errors.py
│ │ │ ├── test_explanation.py
│ │ │ ├── test_iac_generator.py
│ │ │ ├── test_infrastructure_generation.py
│ │ │ ├── test_infrastructure_generator.py
│ │ │ ├── test_models.py
│ │ │ ├── test_resource_operations.py
│ │ │ ├── test_schema_manager.py
│ │ │ ├── test_security_scanning.py
│ │ │ ├── test_server.py
│ │ │ ├── test_session_management.py
│ │ │ └── test_validation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cdk-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cdk_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── __init__.py
│ │ │ │ ├── resources.py
│ │ │ │ ├── search_utils.py
│ │ │ │ ├── server.py
│ │ │ │ └── tools.py
│ │ │ ├── data
│ │ │ │ ├── __init__.py
│ │ │ │ ├── cdk_nag_parser.py
│ │ │ │ ├── construct_descriptions.py
│ │ │ │ ├── genai_cdk_loader.py
│ │ │ │ ├── lambda_layer_parser.py
│ │ │ │ ├── lambda_powertools_loader.py
│ │ │ │ ├── schema_generator.py
│ │ │ │ └── solutions_constructs_parser.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ ├── __init__.py
│ │ │ ├── CDK_GENERAL_GUIDANCE.md
│ │ │ ├── CDK_NAG_GUIDANCE.md
│ │ │ └── lambda_powertools
│ │ │ ├── bedrock.md
│ │ │ ├── cdk.md
│ │ │ ├── dependencies.md
│ │ │ ├── index.md
│ │ │ ├── insights.md
│ │ │ ├── logging.md
│ │ │ ├── metrics.md
│ │ │ └── tracing.md
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── core
│ │ │ │ ├── test_resources_enhanced.py
│ │ │ │ ├── test_resources.py
│ │ │ │ ├── test_search_utils.py
│ │ │ │ ├── test_server.py
│ │ │ │ └── test_tools.py
│ │ │ └── data
│ │ │ ├── test_cdk_nag_parser.py
│ │ │ ├── test_genai_cdk_loader.py
│ │ │ ├── test_lambda_powertools_loader.py
│ │ │ ├── test_schema_generator.py
│ │ │ └── test_solutions_constructs_parser.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cfn-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cfn_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_client.py
│ │ │ ├── cloud_control_utils.py
│ │ │ ├── context.py
│ │ │ ├── errors.py
│ │ │ ├── iac_generator.py
│ │ │ ├── schema_manager.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_aws_client.py
│ │ │ ├── test_cloud_control_utils.py
│ │ │ ├── test_errors.py
│ │ │ ├── test_iac_generator.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_schema_manager.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cloudtrail-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cloudtrail_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── tools.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ └── test_tools.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cloudwatch-appsignals-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cloudwatch_appsignals_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── audit_presentation_utils.py
│ │ │ ├── audit_utils.py
│ │ │ ├── aws_clients.py
│ │ │ ├── canary_utils.py
│ │ │ ├── server.py
│ │ │ ├── service_audit_utils.py
│ │ │ ├── service_tools.py
│ │ │ ├── sli_report_client.py
│ │ │ ├── slo_tools.py
│ │ │ ├── trace_tools.py
│ │ │ └── utils.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_audit_presentation_utils.py
│ │ │ ├── test_audit_utils.py
│ │ │ ├── test_aws_profile.py
│ │ │ ├── test_canary_utils.py
│ │ │ ├── test_initialization.py
│ │ │ ├── test_server_audit_functions.py
│ │ │ ├── test_server_audit_tools.py
│ │ │ ├── test_server.py
│ │ │ ├── test_service_audit_utils.py
│ │ │ ├── test_service_tools_operations.py
│ │ │ ├── test_sli_report_client.py
│ │ │ ├── test_slo_tools.py
│ │ │ └── test_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cloudwatch-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cloudwatch_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── cloudwatch_alarms
│ │ │ │ ├── models.py
│ │ │ │ └── tools.py
│ │ │ ├── cloudwatch_logs
│ │ │ │ ├── models.py
│ │ │ │ └── tools.py
│ │ │ ├── cloudwatch_metrics
│ │ │ │ ├── data
│ │ │ │ │ └── metric_metadata.json
│ │ │ │ ├── models.py
│ │ │ │ └── tools.py
│ │ │ ├── common.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── cloudwatch_alarms
│ │ │ │ ├── test_active_alarms.py
│ │ │ │ ├── test_alarm_history_integration.py
│ │ │ │ ├── test_alarm_history.py
│ │ │ │ └── test_alarms_error_handling.py
│ │ │ ├── cloudwatch_logs
│ │ │ │ ├── test_logs_error_handling.py
│ │ │ │ ├── test_logs_models.py
│ │ │ │ └── test_logs_server.py
│ │ │ ├── cloudwatch_metrics
│ │ │ │ ├── test_metrics_error_handling.py
│ │ │ │ ├── test_metrics_models.py
│ │ │ │ ├── test_metrics_server.py
│ │ │ │ └── test_validation_error.py
│ │ │ ├── test_common_and_server.py
│ │ │ ├── test_init.py
│ │ │ └── test_main.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── code-doc-gen-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── code_doc_gen_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── doc_generator.py
│ │ │ ├── models.py
│ │ │ ├── repomix_manager.py
│ │ │ └── templates.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_doc_generator_edge_cases.py
│ │ │ ├── test_doc_generator.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_repomix_manager_scenarios.py
│ │ │ ├── test_repomix_manager.py
│ │ │ ├── test_repomix_statistics.py
│ │ │ ├── test_server_extended.py
│ │ │ ├── test_server.py
│ │ │ └── test_templates.py
│ │ └── uv.lock
│ ├── core-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── core_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ ├── __init__.py
│ │ │ └── PROMPT_UNDERSTANDING.md
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_response_types.py
│ │ │ ├── test_server.py
│ │ │ └── test_static.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── cost-explorer-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── cost_explorer_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── comparison_handler.py
│ │ │ ├── constants.py
│ │ │ ├── cost_usage_handler.py
│ │ │ ├── forecasting_handler.py
│ │ │ ├── helpers.py
│ │ │ ├── metadata_handler.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── utility_handler.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_comparison_handler.py
│ │ │ ├── test_cost_usage_handler.py
│ │ │ ├── test_forecasting_handler.py
│ │ │ ├── test_helpers.py
│ │ │ ├── test_metadata_handler.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ └── test_utility_handler.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── documentdb-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ └── documentdb_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── analytic_tools.py
│ │ │ ├── config.py
│ │ │ ├── connection_tools.py
│ │ │ ├── db_management_tools.py
│ │ │ ├── query_tools.py
│ │ │ ├── server.py
│ │ │ └── write_tools.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_analytic_tools.py
│ │ │ ├── test_connection_tools.py
│ │ │ ├── test_db_management_tools.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_query_tools.py
│ │ │ └── test_write_tools.py
│ │ └── uv.lock
│ ├── dynamodb-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── dynamodb_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common.py
│ │ │ ├── database_analysis_queries.py
│ │ │ ├── database_analyzers.py
│ │ │ ├── prompts
│ │ │ │ └── dynamodb_architect.md
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── evals
│ │ │ │ ├── dynamic_evaluators.py
│ │ │ │ ├── evaluation_registry.py
│ │ │ │ ├── logging_config.py
│ │ │ │ ├── multiturn_evaluator.py
│ │ │ │ ├── README.md
│ │ │ │ ├── scenarios.py
│ │ │ │ └── test_dspy_evals.py
│ │ │ ├── test_dynamodb_server.py
│ │ │ └── test_source_db_integration.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── ecs-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── ecs_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── api
│ │ │ │ ├── __init__.py
│ │ │ │ ├── containerize.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── ecs_troubleshooting.py
│ │ │ │ ├── infrastructure.py
│ │ │ │ ├── resource_management.py
│ │ │ │ ├── status.py
│ │ │ │ └── troubleshooting_tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── detect_image_pull_failures.py
│ │ │ │ ├── fetch_cloudformation_status.py
│ │ │ │ ├── fetch_network_configuration.py
│ │ │ │ ├── fetch_service_events.py
│ │ │ │ ├── fetch_task_failures.py
│ │ │ │ ├── fetch_task_logs.py
│ │ │ │ ├── get_ecs_troubleshooting_guidance.py
│ │ │ │ └── utils.py
│ │ │ ├── main.py
│ │ │ ├── modules
│ │ │ │ ├── __init__.py
│ │ │ │ ├── aws_knowledge_proxy.py
│ │ │ │ ├── containerize.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── deployment_status.py
│ │ │ │ ├── infrastructure.py
│ │ │ │ ├── resource_management.py
│ │ │ │ └── troubleshooting.py
│ │ │ ├── templates
│ │ │ │ ├── ecr_infrastructure.json
│ │ │ │ └── ecs_infrastructure.json
│ │ │ └── utils
│ │ │ ├── arn_parser.py
│ │ │ ├── aws.py
│ │ │ ├── config.py
│ │ │ ├── docker.py
│ │ │ ├── security.py
│ │ │ ├── templates.py
│ │ │ └── time_utils.py
│ │ ├── DEVELOPMENT.md
│ │ ├── pyproject.toml
│ │ ├── pyrightconfig.json
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── integ
│ │ │ │ └── mcp-inspector
│ │ │ │ ├── .gitignore
│ │ │ │ ├── README.md
│ │ │ │ ├── run-tests.sh
│ │ │ │ └── scenarios
│ │ │ │ ├── 01_comprehensive_troubleshooting
│ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ ├── 03_cleanup.sh
│ │ │ │ │ ├── description.txt
│ │ │ │ │ └── utils
│ │ │ │ │ ├── mcp_helpers.sh
│ │ │ │ │ └── validation_helpers.sh
│ │ │ │ └── 02_test_knowledge_proxy_tools
│ │ │ │ ├── 01_create.sh
│ │ │ │ ├── 02_validate.sh
│ │ │ │ ├── 03_cleanup.sh
│ │ │ │ ├── description.txt
│ │ │ │ └── utils
│ │ │ │ ├── knowledge_validation_helpers.sh
│ │ │ │ └── mcp_knowledge_helpers.sh
│ │ │ ├── llm_testing
│ │ │ │ ├── invalid_cfn_template.yaml
│ │ │ │ ├── README.md
│ │ │ │ ├── run_tests.sh
│ │ │ │ ├── scenarios
│ │ │ │ │ ├── 01_cloudformation_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 04_evaluation.md
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 02_service_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 04_evaluation.md
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 03_task_exit_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 04_evaluation.md
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 04_network_configuration_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ ├── 05_resource_constraint_failure
│ │ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ │ └── description.txt
│ │ │ │ │ └── 06_load_balancer_failure
│ │ │ │ │ ├── 01_create.sh
│ │ │ │ │ ├── 02_validate.sh
│ │ │ │ │ ├── 03_prompts.txt
│ │ │ │ │ ├── 05_cleanup.sh
│ │ │ │ │ └── description.txt
│ │ │ │ ├── SCRIPT_IMPROVEMENTS.md
│ │ │ │ └── utils
│ │ │ │ ├── aws_helpers.sh
│ │ │ │ └── evaluation_template.md
│ │ │ └── unit
│ │ │ ├── __init__.py
│ │ │ ├── api
│ │ │ │ ├── conftest.py
│ │ │ │ ├── test_delete_api.py
│ │ │ │ ├── test_ecs_troubleshooting.py
│ │ │ │ ├── test_resource_management_api.py
│ │ │ │ └── troubleshooting_tools
│ │ │ │ └── test_fetch_network_configuration.py
│ │ │ ├── conftest.py
│ │ │ ├── modules
│ │ │ │ ├── test_aws_knowledge_proxy.py
│ │ │ │ └── test_resource_management_module.py
│ │ │ ├── test_aws_role_utils.py
│ │ │ ├── test_aws_utils.py
│ │ │ ├── test_containerize.py
│ │ │ ├── test_delete.py
│ │ │ ├── test_docker_utils.py
│ │ │ ├── test_docker_with_role.py
│ │ │ ├── test_image_pull_failure_extended.py
│ │ │ ├── test_image_pull_failure.py
│ │ │ ├── test_infrastructure_role.py
│ │ │ ├── test_infrastructure.py
│ │ │ ├── test_integration.py
│ │ │ ├── test_main.py
│ │ │ ├── test_resource_management_api_operation.py
│ │ │ ├── test_resource_management_tool.py
│ │ │ ├── test_resource_management.py
│ │ │ ├── test_security_integration.py
│ │ │ ├── test_status_pytest.py
│ │ │ ├── test_status.py
│ │ │ ├── troubleshooting_tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── conftest.py
│ │ │ │ ├── test_detect_image_pull_failures.py
│ │ │ │ ├── test_fetch_cloudformation_status.py
│ │ │ │ ├── test_fetch_service_events.py
│ │ │ │ ├── test_fetch_task_failures.py
│ │ │ │ ├── test_fetch_task_logs.py
│ │ │ │ ├── test_get_ecs_troubleshooting_guidance.py
│ │ │ │ ├── test_is_ecr_image_security.py
│ │ │ │ └── test_utils.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── async_test_utils.py
│ │ │ ├── test_arn_parser.py
│ │ │ ├── test_config.py
│ │ │ ├── test_docker.py
│ │ │ ├── test_response_sanitization.py
│ │ │ ├── test_security_extended.py
│ │ │ ├── test_security.py
│ │ │ ├── test_templates.py
│ │ │ └── test_time_utils.py
│ │ └── uv.lock
│ ├── eks-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── eks_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_helper.py
│ │ │ ├── cloudwatch_handler.py
│ │ │ ├── cloudwatch_metrics_guidance_handler.py
│ │ │ ├── consts.py
│ │ │ ├── data
│ │ │ │ └── eks_cloudwatch_metrics_guidance.json
│ │ │ ├── eks_kb_handler.py
│ │ │ ├── eks_stack_handler.py
│ │ │ ├── iam_handler.py
│ │ │ ├── insights_handler.py
│ │ │ ├── k8s_apis.py
│ │ │ ├── k8s_client_cache.py
│ │ │ ├── k8s_handler.py
│ │ │ ├── logging_helper.py
│ │ │ ├── models.py
│ │ │ ├── scripts
│ │ │ │ └── update_eks_cloudwatch_metrics_guidance.py
│ │ │ ├── server.py
│ │ │ ├── templates
│ │ │ │ ├── eks-templates
│ │ │ │ │ └── eks-with-vpc.yaml
│ │ │ │ └── k8s-templates
│ │ │ │ ├── deployment.yaml
│ │ │ │ └── service.yaml
│ │ │ └── vpc_config_handler.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_aws_helper.py
│ │ │ ├── test_cloudwatch_handler.py
│ │ │ ├── test_cloudwatch_metrics_guidance_handler.py
│ │ │ ├── test_eks_kb_handler.py
│ │ │ ├── test_eks_stack_handler.py
│ │ │ ├── test_iam_handler.py
│ │ │ ├── test_init.py
│ │ │ ├── test_insights_handler.py
│ │ │ ├── test_k8s_apis.py
│ │ │ ├── test_k8s_client_cache.py
│ │ │ ├── test_k8s_handler.py
│ │ │ ├── test_logging_helper.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_server.py
│ │ │ └── test_vpc_config_handler.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── elasticache-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── elasticache_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common
│ │ │ │ ├── __init__.py
│ │ │ │ ├── connection.py
│ │ │ │ ├── decorators.py
│ │ │ │ └── server.py
│ │ │ ├── context.py
│ │ │ ├── main.py
│ │ │ └── tools
│ │ │ ├── __init__.py
│ │ │ ├── cc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── connect.py
│ │ │ │ ├── create.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── describe.py
│ │ │ │ ├── modify.py
│ │ │ │ ├── parsers.py
│ │ │ │ └── processors.py
│ │ │ ├── ce
│ │ │ │ ├── __init__.py
│ │ │ │ └── get_cost_and_usage.py
│ │ │ ├── cw
│ │ │ │ ├── __init__.py
│ │ │ │ └── get_metric_statistics.py
│ │ │ ├── cwlogs
│ │ │ │ ├── __init__.py
│ │ │ │ ├── create_log_group.py
│ │ │ │ ├── describe_log_groups.py
│ │ │ │ ├── describe_log_streams.py
│ │ │ │ ├── filter_log_events.py
│ │ │ │ └── get_log_events.py
│ │ │ ├── firehose
│ │ │ │ ├── __init__.py
│ │ │ │ └── list_delivery_streams.py
│ │ │ ├── misc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── batch_apply_update_action.py
│ │ │ │ ├── batch_stop_update_action.py
│ │ │ │ ├── describe_cache_engine_versions.py
│ │ │ │ ├── describe_engine_default_parameters.py
│ │ │ │ ├── describe_events.py
│ │ │ │ └── describe_service_updates.py
│ │ │ ├── rg
│ │ │ │ ├── __init__.py
│ │ │ │ ├── complete_migration.py
│ │ │ │ ├── connect.py
│ │ │ │ ├── create.py
│ │ │ │ ├── delete.py
│ │ │ │ ├── describe.py
│ │ │ │ ├── modify.py
│ │ │ │ ├── parsers.py
│ │ │ │ ├── processors.py
│ │ │ │ ├── start_migration.py
│ │ │ │ └── test_migration.py
│ │ │ └── serverless
│ │ │ ├── __init__.py
│ │ │ ├── connect.py
│ │ │ ├── create.py
│ │ │ ├── delete.py
│ │ │ ├── describe.py
│ │ │ ├── models.py
│ │ │ └── modify.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_connection.py
│ │ │ ├── test_decorators.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── tools
│ │ │ ├── cc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_connect_additional.py
│ │ │ │ ├── test_connect_coverage_additional.py
│ │ │ │ ├── test_connect_coverage.py
│ │ │ │ ├── test_connect.py
│ │ │ │ ├── test_create_additional.py
│ │ │ │ ├── test_create.py
│ │ │ │ ├── test_delete.py
│ │ │ │ ├── test_describe.py
│ │ │ │ ├── test_modify.py
│ │ │ │ ├── test_parsers.py
│ │ │ │ └── test_processors.py
│ │ │ ├── ce
│ │ │ │ ├── __init__.py
│ │ │ │ └── test_get_cost_and_usage.py
│ │ │ ├── cw
│ │ │ │ └── test_get_metric_statistics.py
│ │ │ ├── cwlogs
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_create_log_group.py
│ │ │ │ ├── test_describe_log_groups.py
│ │ │ │ ├── test_describe_log_streams.py
│ │ │ │ ├── test_filter_log_events.py
│ │ │ │ └── test_get_log_events.py
│ │ │ ├── firehose
│ │ │ │ └── test_list_delivery_streams.py
│ │ │ ├── misc
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_batch_apply_update_action.py
│ │ │ │ ├── test_batch_stop_update_action.py
│ │ │ │ ├── test_describe_cache_engine_versions.py
│ │ │ │ ├── test_describe_engine_default_parameters.py
│ │ │ │ ├── test_describe_events.py
│ │ │ │ └── test_describe_service_updates.py
│ │ │ ├── rg
│ │ │ │ ├── __init__.py
│ │ │ │ ├── test_complete_migration.py
│ │ │ │ ├── test_connect_additional.py
│ │ │ │ ├── test_connect_coverage_additional.py
│ │ │ │ ├── test_connect_optional_fields.py
│ │ │ │ ├── test_connect_partial_coverage.py
│ │ │ │ ├── test_connect.py
│ │ │ │ ├── test_create.py
│ │ │ │ ├── test_delete.py
│ │ │ │ ├── test_describe.py
│ │ │ │ ├── test_modify.py
│ │ │ │ ├── test_parsers.py
│ │ │ │ ├── test_processors.py
│ │ │ │ ├── test_start_migration.py
│ │ │ │ └── test_test_migration.py
│ │ │ └── serverless
│ │ │ ├── test_connect_additional.py
│ │ │ ├── test_connect_coverage_additional.py
│ │ │ ├── test_connect_optional_fields.py
│ │ │ ├── test_connect.py
│ │ │ ├── test_create.py
│ │ │ ├── test_delete.py
│ │ │ ├── test_describe.py
│ │ │ └── test_modify.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── finch-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── finch_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── build.py
│ │ │ ├── common.py
│ │ │ ├── ecr.py
│ │ │ ├── push.py
│ │ │ └── vm.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── test_cli_flags.py
│ │ │ ├── test_logging_configuration.py
│ │ │ ├── test_server.py
│ │ │ ├── test_utils_build.py
│ │ │ ├── test_utils_common.py
│ │ │ ├── test_utils_ecr.py
│ │ │ ├── test_utils_push.py
│ │ │ └── test_utils_vm.py
│ │ └── uv.lock
│ ├── frontend-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── frontend_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── server.py
│ │ │ ├── static
│ │ │ │ └── react
│ │ │ │ ├── essential-knowledge.md
│ │ │ │ └── troubleshooting.md
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ └── file_utils.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_file_utils.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ └── uv.lock
│ ├── git-repo-research-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── git_repo_research_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── defaults.py
│ │ │ ├── embeddings.py
│ │ │ ├── github_search.py
│ │ │ ├── indexer.py
│ │ │ ├── models.py
│ │ │ ├── repository.py
│ │ │ ├── search.py
│ │ │ ├── server.py
│ │ │ └── utils.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_errors_repository.py
│ │ │ ├── test_github_search_edge_cases.py
│ │ │ ├── test_graphql_github_search.py
│ │ │ ├── test_local_repository.py
│ │ │ ├── test_repository_utils.py
│ │ │ ├── test_rest_github_search.py
│ │ │ ├── test_search.py
│ │ │ ├── test_server.py
│ │ │ └── test_url_repository.py
│ │ └── uv.lock
│ ├── healthlake-mcp-server
│ │ ├── .dockerignore
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── healthlake_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── fhir_operations.py
│ │ │ ├── main.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── CONTRIBUTING.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ ├── mcp_config.json
│ │ │ └── README.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_fhir_client_comprehensive.py
│ │ │ ├── test_fhir_error_scenarios.py
│ │ │ ├── test_fhir_operations.py
│ │ │ ├── test_integration_mock_based.py
│ │ │ ├── test_main_edge_cases.py
│ │ │ ├── test_main.py
│ │ │ ├── test_mcp_integration_coverage.py
│ │ │ ├── test_models_edge_cases.py
│ │ │ ├── test_models.py
│ │ │ ├── test_readonly_mode.py
│ │ │ ├── test_server_core.py
│ │ │ ├── test_server_error_handling.py
│ │ │ ├── test_server_mcp_handlers.py
│ │ │ ├── test_server_toolhandler.py
│ │ │ └── test_server_validation.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── iam-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── iam_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_client.py
│ │ │ ├── context.py
│ │ │ ├── errors.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── DESIGN_COMPLIANCE.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ ├── get_policy_document_example.py
│ │ │ └── inline_policy_demo.py
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── run_tests.sh
│ │ ├── tests
│ │ │ ├── test_context.py
│ │ │ ├── test_errors.py
│ │ │ ├── test_inline_policies.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── lambda-tool-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── lambda_tool_mcp_server
│ │ │ ├── __init__.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── examples
│ │ │ ├── README.md
│ │ │ └── sample_functions
│ │ │ ├── customer-create
│ │ │ │ └── app.py
│ │ │ ├── customer-id-from-email
│ │ │ │ └── app.py
│ │ │ ├── customer-info-from-id
│ │ │ │ └── app.py
│ │ │ └── template.yml
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_format_lambda_response.py
│ │ │ ├── test_integration_coverage.py
│ │ │ ├── test_integration.py
│ │ │ ├── test_register_lambda_functions.py
│ │ │ ├── test_schema_integration.py
│ │ │ ├── test_server_coverage_additional.py
│ │ │ ├── test_server_coverage.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── mcp-lambda-handler
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ └── mcp_lambda_handler
│ │ │ ├── __init__.py
│ │ │ ├── mcp_lambda_handler.py
│ │ │ ├── session.py
│ │ │ └── types.py
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ └── test_lambda_handler.py
│ │ └── uv.lock
│ ├── memcached-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── memcached_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common
│ │ │ │ ├── config.py
│ │ │ │ ├── connection.py
│ │ │ │ └── server.py
│ │ │ ├── context.py
│ │ │ ├── main.py
│ │ │ └── tools
│ │ │ └── cache.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── ELASTICACHECONNECT.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_cache_readonly.py
│ │ │ ├── test_cache.py
│ │ │ ├── test_connection.py
│ │ │ ├── test_init.py
│ │ │ └── test_main.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── mysql-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── mysql_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── connection
│ │ │ │ ├── __init__.py
│ │ │ │ ├── abstract_db_connection.py
│ │ │ │ ├── asyncmy_pool_connection.py
│ │ │ │ ├── db_connection_singleton.py
│ │ │ │ └── rds_data_api_connection.py
│ │ │ ├── mutable_sql_detector.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_abstract_db_connection.py
│ │ │ ├── test_asyncmy_pool_connection.py
│ │ │ ├── test_db_connection_singleton.py
│ │ │ ├── test_rds_data_api_connection.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── nova-canvas-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── nova_canvas_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── novacanvas.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_models.py
│ │ │ ├── test_novacanvas.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── openapi-mcp-server
│ │ ├── .coveragerc
│ │ ├── .dockerignore
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── AUTHENTICATION.md
│ │ ├── AWS_BEST_PRACTICES.md
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── openapi_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── api
│ │ │ │ ├── __init__.py
│ │ │ │ └── config.py
│ │ │ ├── auth
│ │ │ │ ├── __init__.py
│ │ │ │ ├── api_key_auth.py
│ │ │ │ ├── auth_cache.py
│ │ │ │ ├── auth_errors.py
│ │ │ │ ├── auth_factory.py
│ │ │ │ ├── auth_protocol.py
│ │ │ │ ├── auth_provider.py
│ │ │ │ ├── base_auth.py
│ │ │ │ ├── basic_auth.py
│ │ │ │ ├── bearer_auth.py
│ │ │ │ ├── cognito_auth.py
│ │ │ │ └── register.py
│ │ │ ├── patch
│ │ │ │ └── __init__.py
│ │ │ ├── prompts
│ │ │ │ ├── __init__.py
│ │ │ │ ├── generators
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── operation_prompts.py
│ │ │ │ │ └── workflow_prompts.py
│ │ │ │ ├── models.py
│ │ │ │ └── prompt_manager.py
│ │ │ ├── server.py
│ │ │ └── utils
│ │ │ ├── __init__.py
│ │ │ ├── cache_provider.py
│ │ │ ├── config.py
│ │ │ ├── error_handler.py
│ │ │ ├── http_client.py
│ │ │ ├── metrics_provider.py
│ │ │ ├── openapi_validator.py
│ │ │ └── openapi.py
│ │ ├── CHANGELOG.md
│ │ ├── DEPLOYMENT.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── OBSERVABILITY.md
│ │ ├── pyproject.toml
│ │ ├── pyrightconfig.json
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── api
│ │ │ │ └── test_config.py
│ │ │ ├── auth
│ │ │ │ ├── test_api_key_auth.py
│ │ │ │ ├── test_auth_cache.py
│ │ │ │ ├── test_auth_errors.py
│ │ │ │ ├── test_auth_factory_caching.py
│ │ │ │ ├── test_auth_factory_coverage.py
│ │ │ │ ├── test_auth_factory.py
│ │ │ │ ├── test_auth_protocol_additional.py
│ │ │ │ ├── test_auth_protocol_boost.py
│ │ │ │ ├── test_auth_protocol_coverage.py
│ │ │ │ ├── test_auth_protocol_extended.py
│ │ │ │ ├── test_auth_protocol_improved.py
│ │ │ │ ├── test_auth_protocol.py
│ │ │ │ ├── test_auth_provider_additional.py
│ │ │ │ ├── test_base_auth_coverage.py
│ │ │ │ ├── test_base_auth.py
│ │ │ │ ├── test_basic_auth.py
│ │ │ │ ├── test_bearer_auth.py
│ │ │ │ ├── test_cognito_auth_additional_coverage.py
│ │ │ │ ├── test_cognito_auth_boost_coverage.py
│ │ │ │ ├── test_cognito_auth_client_credentials.py
│ │ │ │ ├── test_cognito_auth_coverage_boost.py
│ │ │ │ ├── test_cognito_auth_exceptions.py
│ │ │ │ ├── test_cognito_auth.py
│ │ │ │ ├── test_register_coverage.py
│ │ │ │ └── test_register.py
│ │ │ ├── prompts
│ │ │ │ ├── standalone
│ │ │ │ │ ├── test_operation_prompt.py
│ │ │ │ │ ├── test_prompt_arguments.py
│ │ │ │ │ └── test_secure_operation_prompt.py
│ │ │ │ ├── test_mcp_prompt_manager_integration.py
│ │ │ │ ├── test_mcp_prompt_manager.py
│ │ │ │ ├── test_models_dict_method.py
│ │ │ │ ├── test_operation_prompts_extended.py
│ │ │ │ ├── test_prompt_manager_additional.py
│ │ │ │ ├── test_prompt_manager_comprehensive.py
│ │ │ │ ├── test_prompt_manager_coverage.py
│ │ │ │ └── test_prompt_registration.py
│ │ │ ├── README.md
│ │ │ ├── test_api_name.py
│ │ │ ├── test_cache_coverage_89.py
│ │ │ ├── test_client.py
│ │ │ ├── test_coverage_boost.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main_extended.py
│ │ │ ├── test_main.py
│ │ │ ├── test_openapi_coverage_89.py
│ │ │ ├── test_server_auth_errors.py
│ │ │ ├── test_server_coverage_boost_2.py
│ │ │ ├── test_server_coverage_boost.py
│ │ │ ├── test_server_exception_handling.py
│ │ │ ├── test_server_extended.py
│ │ │ ├── test_server_httpx_version.py
│ │ │ ├── test_server_part1.py
│ │ │ ├── test_server_route_logging.py
│ │ │ ├── test_server_signal_handlers.py
│ │ │ ├── test_server.py
│ │ │ └── utils
│ │ │ ├── test_cache_provider.py
│ │ │ ├── test_error_handler_boost.py
│ │ │ ├── test_error_handler_extended.py
│ │ │ ├── test_error_handler_fix.py
│ │ │ ├── test_error_handler.py
│ │ │ ├── test_http_client_comprehensive.py
│ │ │ ├── test_http_client_extended.py
│ │ │ ├── test_http_client_extended2.py
│ │ │ ├── test_http_client_import_error.py
│ │ │ ├── test_http_client.py
│ │ │ ├── test_metrics_provider_decorators.py
│ │ │ ├── test_metrics_provider_extended2.py
│ │ │ ├── test_metrics_provider_prometheus.py
│ │ │ ├── test_metrics_provider.py
│ │ │ ├── test_openapi_validator.py
│ │ │ └── test_openapi.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── postgres-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── postgres_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── connection
│ │ │ │ ├── __init__.py
│ │ │ │ ├── abstract_db_connection.py
│ │ │ │ ├── db_connection_singleton.py
│ │ │ │ ├── psycopg_pool_connection.py
│ │ │ │ └── rds_api_connection.py
│ │ │ ├── mutable_sql_detector.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_psycopg_connector.py
│ │ │ ├── test_server.py
│ │ │ └── test_singleton.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── prometheus-mcp-server
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── prometheus_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── conftest.py
│ │ │ ├── test_aws_credentials.py
│ │ │ ├── test_config_manager.py
│ │ │ ├── test_consts.py
│ │ │ ├── test_coverage_gaps.py
│ │ │ ├── test_coverage_improvement.py
│ │ │ ├── test_final_coverage.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_models.py
│ │ │ ├── test_prometheus_client.py
│ │ │ ├── test_prometheus_connection.py
│ │ │ ├── test_security_validator.py
│ │ │ ├── test_server_coverage.py
│ │ │ ├── test_tools.py
│ │ │ └── test_workspace_config.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── redshift-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── redshift_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── consts.py
│ │ │ ├── models.py
│ │ │ ├── redshift.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_redshift.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── s3-tables-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── s3_tables_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── constants.py
│ │ │ ├── database.py
│ │ │ ├── engines
│ │ │ │ ├── __init__.py
│ │ │ │ └── pyiceberg.py
│ │ │ ├── file_processor
│ │ │ │ ├── __init__.py
│ │ │ │ ├── csv.py
│ │ │ │ ├── parquet.py
│ │ │ │ └── utils.py
│ │ │ ├── models.py
│ │ │ ├── namespaces.py
│ │ │ ├── resources.py
│ │ │ ├── s3_operations.py
│ │ │ ├── server.py
│ │ │ ├── table_buckets.py
│ │ │ ├── tables.py
│ │ │ └── utils.py
│ │ ├── CHANGELOG.md
│ │ ├── CONTEXT.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_csv.py
│ │ │ ├── test_database.py
│ │ │ ├── test_file_processor_utils.py
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ ├── test_namespaces.py
│ │ │ ├── test_parquet.py
│ │ │ ├── test_pyiceberg.py
│ │ │ ├── test_resources.py
│ │ │ ├── test_s3_operations.py
│ │ │ ├── test_server.py
│ │ │ ├── test_table_buckets.py
│ │ │ ├── test_tables.py
│ │ │ └── test_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── stepfunctions-tool-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── stepfunctions_tool_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── aws_helper.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── README.md
│ │ │ ├── test_aws_helper.py
│ │ │ ├── test_create_state_machine_tool.py
│ │ │ ├── test_filter_state_machines_by_tag.py
│ │ │ ├── test_format_state_machine_response.py
│ │ │ ├── test_get_schema_arn_from_state_machine_arn.py
│ │ │ ├── test_get_schema_from_registry.py
│ │ │ ├── test_invoke_express_state_machine_impl.py
│ │ │ ├── test_invoke_standard_state_machine_impl.py
│ │ │ ├── test_main.py
│ │ │ ├── test_register_state_machines.py
│ │ │ ├── test_sanitize_tool_name.py
│ │ │ ├── test_server.py
│ │ │ └── test_validate_state_machine_name.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── syntheticdata-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── syntheticdata_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── pandas_interpreter.py
│ │ │ ├── server.py
│ │ │ └── storage
│ │ │ ├── __init__.py
│ │ │ ├── base.py
│ │ │ ├── loader.py
│ │ │ └── s3.py
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── conftest.py
│ │ │ ├── test_constants.py
│ │ │ ├── test_pandas_interpreter.py
│ │ │ ├── test_server.py
│ │ │ └── test_storage
│ │ │ ├── __init__.py
│ │ │ ├── test_loader.py
│ │ │ └── test_s3.py
│ │ └── uv.lock
│ ├── terraform-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── terraform_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── impl
│ │ │ │ ├── resources
│ │ │ │ │ ├── __init__.py
│ │ │ │ │ ├── terraform_aws_provider_resources_listing.py
│ │ │ │ │ └── terraform_awscc_provider_resources_listing.py
│ │ │ │ └── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── execute_terraform_command.py
│ │ │ │ ├── execute_terragrunt_command.py
│ │ │ │ ├── run_checkov_scan.py
│ │ │ │ ├── search_aws_provider_docs.py
│ │ │ │ ├── search_awscc_provider_docs.py
│ │ │ │ ├── search_specific_aws_ia_modules.py
│ │ │ │ ├── search_user_provided_module.py
│ │ │ │ └── utils.py
│ │ │ ├── models
│ │ │ │ ├── __init__.py
│ │ │ │ └── models.py
│ │ │ ├── scripts
│ │ │ │ ├── generate_aws_provider_resources.py
│ │ │ │ ├── generate_awscc_provider_resources.py
│ │ │ │ └── scrape_aws_terraform_best_practices.py
│ │ │ ├── server.py
│ │ │ └── static
│ │ │ ├── __init__.py
│ │ │ ├── AWS_PROVIDER_RESOURCES.md
│ │ │ ├── AWS_TERRAFORM_BEST_PRACTICES.md
│ │ │ ├── AWSCC_PROVIDER_RESOURCES.md
│ │ │ ├── MCP_INSTRUCTIONS.md
│ │ │ └── TERRAFORM_WORKFLOW_GUIDE.md
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── __init__.py
│ │ │ ├── .gitignore
│ │ │ ├── conftest.py
│ │ │ ├── README.md
│ │ │ ├── test_command_impl.py
│ │ │ ├── test_execute_terraform_command.py
│ │ │ ├── test_execute_terragrunt_command.py
│ │ │ ├── test_models.py
│ │ │ ├── test_parameter_annotations.py
│ │ │ ├── test_resources.py
│ │ │ ├── test_run_checkov_scan.py
│ │ │ ├── test_search_user_provided_module.py
│ │ │ ├── test_server.py
│ │ │ ├── test_tool_implementations.py
│ │ │ ├── test_utils_additional.py
│ │ │ └── test_utils.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── timestream-for-influxdb-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── timestream_for_influxdb_mcp_server
│ │ │ ├── __init__.py
│ │ │ └── server.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_init.py
│ │ │ ├── test_main.py
│ │ │ └── test_server.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ ├── valkey-mcp-server
│ │ ├── .gitignore
│ │ ├── .python-version
│ │ ├── awslabs
│ │ │ ├── __init__.py
│ │ │ └── valkey_mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── common
│ │ │ │ ├── __init__.py
│ │ │ │ ├── config.py
│ │ │ │ ├── connection.py
│ │ │ │ └── server.py
│ │ │ ├── context.py
│ │ │ ├── main.py
│ │ │ ├── tools
│ │ │ │ ├── __init__.py
│ │ │ │ ├── bitmap.py
│ │ │ │ ├── hash.py
│ │ │ │ ├── hyperloglog.py
│ │ │ │ ├── json.py
│ │ │ │ ├── list.py
│ │ │ │ ├── misc.py
│ │ │ │ ├── server_management.py
│ │ │ │ ├── set.py
│ │ │ │ ├── sorted_set.py
│ │ │ │ ├── stream.py
│ │ │ │ └── string.py
│ │ │ └── version.py
│ │ ├── CHANGELOG.md
│ │ ├── docker-healthcheck.sh
│ │ ├── Dockerfile
│ │ ├── ELASTICACHECONNECT.md
│ │ ├── LICENSE
│ │ ├── NOTICE
│ │ ├── pyproject.toml
│ │ ├── README.md
│ │ ├── tests
│ │ │ ├── test_bitmap.py
│ │ │ ├── test_config.py
│ │ │ ├── test_connection.py
│ │ │ ├── test_hash.py
│ │ │ ├── test_hyperloglog.py
│ │ │ ├── test_init.py
│ │ │ ├── test_json_additional.py
│ │ │ ├── test_json_readonly.py
│ │ │ ├── test_json.py
│ │ │ ├── test_list_additional.py
│ │ │ ├── test_list_readonly.py
│ │ │ ├── test_list.py
│ │ │ ├── test_main.py
│ │ │ ├── test_misc.py
│ │ │ ├── test_server_management.py
│ │ │ ├── test_set_readonly.py
│ │ │ ├── test_set.py
│ │ │ ├── test_sorted_set_additional.py
│ │ │ ├── test_sorted_set_readonly.py
│ │ │ ├── test_sorted_set.py
│ │ │ ├── test_stream_additional.py
│ │ │ ├── test_stream_readonly.py
│ │ │ ├── test_stream.py
│ │ │ └── test_string.py
│ │ ├── uv-requirements.txt
│ │ └── uv.lock
│ └── well-architected-security-mcp-server
│ ├── .python-version
│ ├── awslabs
│ │ └── well_architected_security_mcp_server
│ │ ├── __init__.py
│ │ ├── consts.py
│ │ ├── server.py
│ │ └── util
│ │ ├── __init__.py
│ │ ├── network_security.py
│ │ ├── prompt_utils.py
│ │ ├── resource_utils.py
│ │ ├── security_services.py
│ │ └── storage_security.py
│ ├── PROMPT_TEMPLATE.md
│ ├── pyproject.toml
│ ├── README.md
│ ├── tests
│ │ ├── __init__.py
│ │ ├── conftest.py
│ │ ├── README.md
│ │ ├── test_access_analyzer_fix.py
│ │ ├── test_network_security_additional.py
│ │ ├── test_network_security.py
│ │ ├── test_prompt_utils_coverage.py
│ │ ├── test_prompt_utils.py
│ │ ├── test_resource_utils_fix.py
│ │ ├── test_resource_utils.py
│ │ ├── test_security_services_additional.py
│ │ ├── test_security_services_coverage.py
│ │ ├── test_security_services.py
│ │ ├── test_server_additional.py
│ │ ├── test_server_coverage.py
│ │ ├── test_server_prompts.py
│ │ ├── test_server_security_findings.py
│ │ ├── test_server.py
│ │ ├── test_storage_security_additional.py
│ │ ├── test_storage_security_comprehensive.py
│ │ ├── test_storage_security_edge_cases.py
│ │ ├── test_storage_security_recommendations.py
│ │ ├── test_storage_security.py
│ │ └── test_user_agent_config.py
│ └── uv.lock
└── VIBE_CODING_TIPS_TRICKS.md
```
# Files
--------------------------------------------------------------------------------
/src/iam-mcp-server/tests/test_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 | """Tests for the AWS IAM MCP Server."""
16 |
17 | import pytest
18 | from awslabs.iam_mcp_server.aws_client import get_iam_client
19 | from awslabs.iam_mcp_server.context import Context
20 | from awslabs.iam_mcp_server.errors import (
21 | IamClientError,
22 | IamMcpError,
23 | IamPermissionError,
24 | IamResourceNotFoundError,
25 | IamValidationError,
26 | handle_iam_error,
27 | )
28 | from awslabs.iam_mcp_server.models import UsersListResponse
29 | from botocore.exceptions import ClientError as BotoClientError
30 | from datetime import datetime
31 | from unittest.mock import AsyncMock, Mock, patch
32 |
33 |
34 | def test_get_iam_client():
35 | """Test IAM client creation."""
36 | with patch('boto3.client') as mock_client:
37 | mock_client.return_value = Mock()
38 | client = get_iam_client()
39 | assert client is not None
40 | # Verify that boto3.client was called with 'iam' and a config object
41 | mock_client.assert_called_once()
42 | args, kwargs = mock_client.call_args
43 | assert args[0] == 'iam'
44 | assert 'config' in kwargs
45 | assert kwargs['config'].user_agent_extra == 'awslabs-iam-mcp-server/1.0.0'
46 |
47 |
48 | def test_get_iam_client_with_region():
49 | """Test IAM client creation with region."""
50 | with patch('boto3.client') as mock_client:
51 | mock_client.return_value = Mock()
52 | client = get_iam_client(region='us-west-2')
53 | assert client is not None
54 | # Verify that boto3.client was called with 'iam', region, and config
55 | mock_client.assert_called_once()
56 | args, kwargs = mock_client.call_args
57 | assert args[0] == 'iam'
58 | assert kwargs['region_name'] == 'us-west-2'
59 | assert 'config' in kwargs
60 | assert kwargs['config'].user_agent_extra == 'awslabs-iam-mcp-server/1.0.0'
61 |
62 |
63 | def test_handle_iam_error_access_denied():
64 | """Test handling of AccessDenied error."""
65 | error_response = {
66 | 'Error': {
67 | 'Code': 'AccessDenied',
68 | 'Message': 'User is not authorized to perform this action',
69 | }
70 | }
71 | boto_error = BotoClientError(error_response, 'GetUser')
72 |
73 | handled_error = handle_iam_error(boto_error)
74 |
75 | assert isinstance(handled_error, IamPermissionError)
76 | assert 'Access denied' in str(handled_error)
77 |
78 |
79 | def test_handle_iam_error_no_such_entity():
80 | """Test handling of NoSuchEntity error."""
81 | error_response = {'Error': {'Code': 'NoSuchEntity', 'Message': 'The user does not exist'}}
82 | boto_error = BotoClientError(error_response, 'GetUser')
83 |
84 | handled_error = handle_iam_error(boto_error)
85 |
86 | assert isinstance(handled_error, IamResourceNotFoundError)
87 | assert 'Resource not found' in str(handled_error)
88 |
89 |
90 | def test_context_initialization():
91 | """Test Context initialization."""
92 | Context.initialize(readonly=True, region='us-east-1')
93 |
94 | assert Context.is_readonly() is True
95 | assert Context.get_region() == 'us-east-1'
96 |
97 |
98 | def test_context_readonly_mode():
99 | """Test Context readonly mode."""
100 | Context.initialize(readonly=False)
101 | assert Context.is_readonly() is False
102 |
103 | Context.initialize(readonly=True)
104 | assert Context.is_readonly() is True
105 |
106 |
107 | @pytest.mark.asyncio
108 | async def test_list_users_mock():
109 | """Test list_users function with mocked IAM client."""
110 | from awslabs.iam_mcp_server.server import list_users
111 |
112 | mock_response = {
113 | 'Users': [
114 | {
115 | 'UserName': 'test-user',
116 | 'UserId': 'AIDACKCEVSQ6C2EXAMPLE',
117 | 'Arn': 'arn:aws:iam::123456789012:user/test-user',
118 | 'Path': '/',
119 | 'CreateDate': datetime(2023, 1, 1),
120 | }
121 | ],
122 | 'IsTruncated': False,
123 | }
124 |
125 | mock_ctx = AsyncMock()
126 |
127 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
128 | mock_client = Mock()
129 | mock_client.list_users.return_value = mock_response
130 | mock_get_client.return_value = mock_client
131 |
132 | result = await list_users(mock_ctx)
133 |
134 | assert isinstance(result, UsersListResponse)
135 | assert len(result.users) == 1
136 | assert result.users[0].user_name == 'test-user'
137 | assert result.count == 1
138 | assert result.is_truncated is False
139 |
140 |
141 | @pytest.mark.asyncio
142 | async def test_create_user_readonly_mode():
143 | """Test create_user function in readonly mode."""
144 | from awslabs.iam_mcp_server.server import create_user
145 |
146 | # Set readonly mode
147 | Context.initialize(readonly=True)
148 |
149 | mock_ctx = AsyncMock()
150 |
151 | with pytest.raises(IamClientError) as exc_info:
152 | await create_user(mock_ctx, user_name='test-user')
153 |
154 | assert 'read-only mode' in str(exc_info.value)
155 |
156 |
157 | @pytest.mark.asyncio
158 | async def test_create_user_success():
159 | """Test successful user creation."""
160 | from awslabs.iam_mcp_server.models import CreateUserResponse
161 | from awslabs.iam_mcp_server.server import create_user
162 |
163 | # Disable readonly mode
164 | Context.initialize(readonly=False)
165 |
166 | mock_response = {
167 | 'User': {
168 | 'UserName': 'new-user',
169 | 'UserId': 'AIDACKCEVSQ6C2EXAMPLE',
170 | 'Arn': 'arn:aws:iam::123456789012:user/new-user',
171 | 'Path': '/',
172 | 'CreateDate': datetime(2023, 1, 1),
173 | }
174 | }
175 |
176 | mock_ctx = AsyncMock()
177 |
178 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
179 | mock_client = Mock()
180 | mock_client.create_user.return_value = mock_response
181 | mock_get_client.return_value = mock_client
182 |
183 | result = await create_user(mock_ctx, user_name='new-user')
184 |
185 | assert isinstance(result, CreateUserResponse)
186 | assert result.user.user_name == 'new-user'
187 | assert 'Successfully created user: new-user' in result.message
188 |
189 |
190 | # Additional tests for better coverage
191 |
192 |
193 | def test_get_iam_client_error():
194 | """Test IAM client creation error handling."""
195 | with patch('boto3.client') as mock_client:
196 | mock_client.side_effect = Exception('AWS credentials not found')
197 |
198 | with pytest.raises(Exception) as exc_info:
199 | get_iam_client()
200 |
201 | assert 'Failed to create IAM client' in str(exc_info.value)
202 |
203 |
204 | def test_get_aws_client():
205 | """Test generic AWS client creation."""
206 | from awslabs.iam_mcp_server.aws_client import get_aws_client
207 |
208 | with patch('boto3.client') as mock_client:
209 | mock_client.return_value = Mock()
210 | client = get_aws_client('s3')
211 | assert client is not None
212 | # Verify that boto3.client was called with 's3' and a config object
213 | mock_client.assert_called_once()
214 | args, kwargs = mock_client.call_args
215 | assert args[0] == 's3'
216 | assert 'config' in kwargs
217 | assert kwargs['config'].user_agent_extra == 'awslabs-iam-mcp-server/1.0.0'
218 |
219 |
220 | def test_get_aws_client_with_region():
221 | """Test generic AWS client creation with region."""
222 | from awslabs.iam_mcp_server.aws_client import get_aws_client
223 |
224 | with patch('boto3.client') as mock_client:
225 | mock_client.return_value = Mock()
226 | client = get_aws_client('ec2', region='eu-west-1')
227 | assert client is not None
228 | # Verify that boto3.client was called with correct arguments
229 | mock_client.assert_called_once()
230 | args, kwargs = mock_client.call_args
231 | assert args[0] == 'ec2'
232 | assert kwargs['region_name'] == 'eu-west-1'
233 | assert 'config' in kwargs
234 |
235 |
236 | def test_get_aws_client_error():
237 | """Test generic AWS client creation error handling."""
238 | from awslabs.iam_mcp_server.aws_client import get_aws_client
239 |
240 | with patch('boto3.client') as mock_client:
241 | mock_client.side_effect = Exception('Service not available')
242 |
243 | with pytest.raises(Exception) as exc_info:
244 | get_aws_client('invalid-service')
245 |
246 | assert 'Failed to create invalid-service client' in str(exc_info.value)
247 |
248 |
249 | def test_context_get_region():
250 | """Test Context.get_region method."""
251 | # Test when no region is set
252 | Context._region = None
253 | assert Context.get_region() is None
254 |
255 | # Test when region is set
256 | Context._region = 'us-east-1'
257 | assert Context.get_region() == 'us-east-1'
258 |
259 |
260 | def test_handle_iam_error_throttling():
261 | """Test handling of throttling errors."""
262 | from awslabs.iam_mcp_server.errors import IamMcpError
263 |
264 | error = BotoClientError(
265 | error_response={'Error': {'Code': 'Throttling', 'Message': 'Rate exceeded'}},
266 | operation_name='ListUsers',
267 | )
268 |
269 | result = handle_iam_error(error)
270 | assert isinstance(result, IamMcpError)
271 | assert 'Rate exceeded' in str(result)
272 |
273 |
274 | def test_handle_iam_error_invalid_user_type():
275 | """Test handling of InvalidUserType errors."""
276 | from awslabs.iam_mcp_server.errors import IamMcpError
277 |
278 | error = BotoClientError(
279 | error_response={'Error': {'Code': 'InvalidUserType', 'Message': 'Invalid user type'}},
280 | operation_name='CreateUser',
281 | )
282 |
283 | result = handle_iam_error(error)
284 | assert isinstance(result, IamMcpError)
285 | assert 'Invalid user type' in str(result)
286 |
287 |
288 | def test_handle_iam_error_generic():
289 | """Test handling of generic errors."""
290 | from awslabs.iam_mcp_server.errors import IamMcpError
291 |
292 | error = Exception('Generic error')
293 |
294 | result = handle_iam_error(error)
295 | assert isinstance(result, IamMcpError)
296 | assert 'Generic error' in str(result)
297 |
298 |
299 | @pytest.mark.asyncio
300 | async def test_list_roles():
301 | """Test list_roles function."""
302 | from awslabs.iam_mcp_server.server import list_roles
303 |
304 | mock_response = {
305 | 'Roles': [
306 | {
307 | 'RoleName': 'test-role',
308 | 'RoleId': 'AROA123456789EXAMPLE',
309 | 'Arn': 'arn:aws:iam::123456789012:role/test-role',
310 | 'Path': '/',
311 | 'CreateDate': datetime(2023, 1, 1),
312 | 'AssumeRolePolicyDocument': '%7B%22Version%22%3A%222012-10-17%22%7D',
313 | }
314 | ]
315 | }
316 |
317 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
318 | mock_client = Mock()
319 | mock_client.list_roles.return_value = mock_response
320 | mock_get_client.return_value = mock_client
321 |
322 | result = await list_roles()
323 |
324 | assert len(result['Roles']) == 1
325 | assert result['Roles'][0]['RoleName'] == 'test-role'
326 |
327 |
328 | @pytest.mark.asyncio
329 | async def test_list_policies():
330 | """Test list_policies function."""
331 | from awslabs.iam_mcp_server.server import list_policies
332 |
333 | mock_response = {
334 | 'Policies': [
335 | {
336 | 'PolicyName': 'test-policy',
337 | 'PolicyId': 'ANPA123456789EXAMPLE',
338 | 'Arn': 'arn:aws:iam::123456789012:policy/test-policy',
339 | 'Path': '/',
340 | 'DefaultVersionId': 'v1',
341 | 'AttachmentCount': 0,
342 | 'PermissionsBoundaryUsageCount': 0,
343 | 'IsAttachable': True,
344 | 'Description': 'Test policy',
345 | 'CreateDate': datetime(2023, 1, 1),
346 | 'UpdateDate': datetime(2023, 1, 1),
347 | }
348 | ]
349 | }
350 |
351 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
352 | mock_client = Mock()
353 | mock_client.list_policies.return_value = mock_response
354 | mock_get_client.return_value = mock_client
355 |
356 | result = await list_policies()
357 |
358 | assert len(result['Policies']) == 1
359 | assert result['Policies'][0]['PolicyName'] == 'test-policy'
360 |
361 |
362 | @pytest.mark.asyncio
363 | async def test_get_managed_policy_document():
364 | """Test get_managed_policy_document function."""
365 | from awslabs.iam_mcp_server.server import get_managed_policy_document
366 |
367 | mock_policy_document = {
368 | 'Version': '2012-10-17',
369 | 'Statement': [{'Effect': 'Allow', 'Action': 's3:*', 'Resource': '*'}],
370 | }
371 |
372 | mock_response = {
373 | 'PolicyVersion': {
374 | 'Document': mock_policy_document,
375 | 'VersionId': 'v1',
376 | 'IsDefaultVersion': True,
377 | 'CreateDate': datetime(2023, 1, 1),
378 | }
379 | }
380 |
381 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
382 | mock_client = Mock()
383 | mock_client.get_policy_version.return_value = mock_response
384 | mock_get_client.return_value = mock_client
385 |
386 | result = await get_managed_policy_document(
387 | policy_arn='arn:aws:iam::123456789012:policy/test-policy'
388 | )
389 |
390 | assert result.policy_arn == 'arn:aws:iam::123456789012:policy/test-policy'
391 | assert result.policy_name == 'test-policy'
392 | assert result.version_id == 'v1'
393 | assert result.is_default_version is True
394 | assert '"Action": "s3:*"' in result.policy_document
395 | assert '"Resource": "*"' in result.policy_document
396 |
397 |
398 | @pytest.mark.asyncio
399 | async def test_create_role():
400 | """Test create_role function."""
401 | from awslabs.iam_mcp_server.server import create_role
402 |
403 | trust_policy = {
404 | 'Version': '2012-10-17',
405 | 'Statement': [
406 | {
407 | 'Effect': 'Allow',
408 | 'Principal': {'Service': 'ec2.amazonaws.com'},
409 | 'Action': 'sts:AssumeRole',
410 | }
411 | ],
412 | }
413 |
414 | mock_response = {
415 | 'Role': {
416 | 'RoleName': 'test-role',
417 | 'RoleId': 'AROA123456789EXAMPLE',
418 | 'Arn': 'arn:aws:iam::123456789012:role/test-role',
419 | 'Path': '/',
420 | 'CreateDate': datetime(2023, 1, 1),
421 | 'AssumeRolePolicyDocument': '%7B%22Version%22%3A%222012-10-17%22%7D',
422 | }
423 | }
424 |
425 | # Disable readonly mode
426 | Context.initialize(readonly=False)
427 |
428 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
429 | mock_client = Mock()
430 | mock_client.create_role.return_value = mock_response
431 | mock_get_client.return_value = mock_client
432 |
433 | result = await create_role(role_name='test-role', assume_role_policy_document=trust_policy)
434 |
435 | assert 'Successfully created role: test-role' in result['Message']
436 | assert result['Role']['RoleName'] == 'test-role'
437 |
438 |
439 | @pytest.mark.asyncio
440 | async def test_create_role_invalid_json():
441 | """Test create_role function with invalid JSON policy document."""
442 | from awslabs.iam_mcp_server.server import create_role
443 |
444 | # Disable readonly mode
445 | Context.initialize(readonly=False)
446 |
447 | with pytest.raises(Exception) as exc_info:
448 | await create_role(role_name='test-role', assume_role_policy_document='invalid json')
449 |
450 | assert 'Invalid JSON' in str(exc_info.value)
451 |
452 |
453 | @pytest.mark.asyncio
454 | async def test_create_role_readonly():
455 | """Test create_role function in readonly mode."""
456 | from awslabs.iam_mcp_server.server import create_role
457 |
458 | # Set readonly mode
459 | Context.initialize(readonly=True)
460 |
461 | with pytest.raises(IamClientError) as exc_info:
462 | await create_role(
463 | role_name='test-role', assume_role_policy_document={'Version': '2012-10-17'}
464 | )
465 |
466 | assert 'read-only mode' in str(exc_info.value)
467 |
468 |
469 | # Additional comprehensive tests for server.py coverage
470 |
471 |
472 | @pytest.mark.asyncio
473 | async def test_get_user():
474 | """Test get_user function."""
475 | from awslabs.iam_mcp_server.server import get_user
476 |
477 | mock_user_response = {
478 | 'User': {
479 | 'UserName': 'test-user',
480 | 'UserId': 'AIDACKCEVSQ6C2EXAMPLE',
481 | 'Arn': 'arn:aws:iam::123456789012:user/test-user',
482 | 'Path': '/',
483 | 'CreateDate': datetime(2023, 1, 1),
484 | }
485 | }
486 |
487 | mock_policies_response = {
488 | 'AttachedPolicies': [
489 | {
490 | 'PolicyName': 'TestPolicy',
491 | 'PolicyArn': 'arn:aws:iam::123456789012:policy/TestPolicy',
492 | }
493 | ]
494 | }
495 |
496 | mock_groups_response = {
497 | 'Groups': [{'GroupName': 'TestGroup', 'Arn': 'arn:aws:iam::123456789012:group/TestGroup'}]
498 | }
499 |
500 | mock_keys_response = {
501 | 'AccessKeyMetadata': [
502 | {
503 | 'AccessKeyId': 'AKIAIOSFODNN7EXAMPLE', # pragma: allowlist secret
504 | 'Status': 'Active',
505 | 'CreateDate': datetime(2023, 1, 1),
506 | }
507 | ]
508 | }
509 |
510 | mock_ctx = AsyncMock()
511 |
512 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
513 | mock_client = Mock()
514 | mock_client.get_user.return_value = mock_user_response
515 | mock_client.list_attached_user_policies.return_value = mock_policies_response
516 | mock_client.list_user_policies.return_value = {'PolicyNames': ['InlinePolicy1']}
517 | mock_client.list_groups_for_user.return_value = mock_groups_response
518 | mock_client.list_access_keys.return_value = mock_keys_response
519 | mock_get_client.return_value = mock_client
520 |
521 | result = await get_user(mock_ctx, user_name='test-user')
522 |
523 | assert result.user.user_name == 'test-user'
524 | assert len(result.attached_policies) == 1
525 | assert result.attached_policies[0].policy_name == 'TestPolicy'
526 |
527 |
528 | @pytest.mark.asyncio
529 | async def test_get_user_not_found():
530 | """Test get_user function when user not found."""
531 | from awslabs.iam_mcp_server.server import get_user
532 | from botocore.exceptions import ClientError
533 |
534 | error = ClientError(
535 | error_response={'Error': {'Code': 'NoSuchEntity', 'Message': 'User not found'}},
536 | operation_name='GetUser',
537 | )
538 |
539 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
540 | mock_client = Mock()
541 | mock_client.get_user.side_effect = error
542 | mock_get_client.return_value = mock_client
543 |
544 | with pytest.raises(Exception):
545 | await get_user(user_name='nonexistent-user')
546 |
547 |
548 | @pytest.mark.asyncio
549 | async def test_delete_user():
550 | """Test delete_user function."""
551 |
552 |
553 | # Additional tests for better error handling coverage
554 |
555 |
556 | @pytest.mark.asyncio
557 | async def test_list_users_with_exception():
558 | """Test list_users function with generic exception."""
559 | from awslabs.iam_mcp_server.server import list_users
560 |
561 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
562 | mock_client = Mock()
563 | mock_client.list_users.side_effect = Exception('Generic error')
564 | mock_get_client.return_value = mock_client
565 |
566 | with pytest.raises(Exception):
567 | await list_users()
568 |
569 |
570 | @pytest.mark.asyncio
571 | async def test_get_user_with_exception():
572 | """Test get_user function with generic exception."""
573 | from awslabs.iam_mcp_server.server import get_user
574 |
575 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
576 | mock_client = Mock()
577 | mock_client.get_user.side_effect = Exception('Generic error')
578 | mock_get_client.return_value = mock_client
579 |
580 | with pytest.raises(Exception):
581 | await get_user(user_name='test-user')
582 |
583 |
584 | @pytest.mark.asyncio
585 | async def test_create_user_with_exception():
586 | """Test create_user function with generic exception."""
587 | from awslabs.iam_mcp_server.server import create_user
588 |
589 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
590 | mock_client = Mock()
591 | mock_client.create_user.side_effect = Exception('Generic error')
592 | mock_get_client.return_value = mock_client
593 |
594 | with pytest.raises(Exception):
595 | await create_user(user_name='test-user')
596 |
597 |
598 | @pytest.mark.asyncio
599 | async def test_delete_user_with_exception():
600 | """Test delete_user function with generic exception."""
601 | from awslabs.iam_mcp_server.server import delete_user
602 |
603 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
604 | mock_client = Mock()
605 | mock_client.delete_user.side_effect = Exception('Generic error')
606 | mock_get_client.return_value = mock_client
607 |
608 | with pytest.raises(Exception):
609 | await delete_user(user_name='test-user')
610 |
611 |
612 | @pytest.mark.asyncio
613 | async def test_list_roles_with_exception():
614 | """Test list_roles function with generic exception."""
615 | from awslabs.iam_mcp_server.server import list_roles
616 |
617 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
618 | mock_client = Mock()
619 | mock_client.list_roles.side_effect = Exception('Generic error')
620 | mock_get_client.return_value = mock_client
621 |
622 | with pytest.raises(Exception):
623 | await list_roles()
624 |
625 |
626 | @pytest.mark.asyncio
627 | async def test_create_role_with_exception():
628 | """Test create_role function with generic exception."""
629 | from awslabs.iam_mcp_server.server import create_role
630 |
631 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
632 | mock_client = Mock()
633 | mock_client.create_role.side_effect = Exception('Generic error')
634 | mock_get_client.return_value = mock_client
635 |
636 | with pytest.raises(Exception):
637 | await create_role(
638 | role_name='test-role', assume_role_policy_document={'Version': '2012-10-17'}
639 | )
640 |
641 |
642 | @pytest.mark.asyncio
643 | async def test_list_policies_with_exception():
644 | """Test list_policies function with generic exception."""
645 | from awslabs.iam_mcp_server.server import list_policies
646 |
647 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
648 | mock_client = Mock()
649 | mock_client.list_policies.side_effect = Exception('Generic error')
650 | mock_get_client.return_value = mock_client
651 |
652 | with pytest.raises(Exception):
653 | await list_policies()
654 |
655 |
656 | @pytest.mark.asyncio
657 | async def test_attach_user_policy_with_exception():
658 | """Test attach_user_policy function with generic exception."""
659 | from awslabs.iam_mcp_server.server import attach_user_policy
660 |
661 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
662 | mock_client = Mock()
663 | mock_client.attach_user_policy.side_effect = Exception('Generic error')
664 | mock_get_client.return_value = mock_client
665 |
666 | with pytest.raises(Exception):
667 | await attach_user_policy(
668 | user_name='test-user', policy_arn='arn:aws:iam::123456789012:policy/TestPolicy'
669 | )
670 |
671 |
672 | @pytest.mark.asyncio
673 | async def test_detach_user_policy_with_exception():
674 | """Test detach_user_policy function with generic exception."""
675 | from awslabs.iam_mcp_server.server import detach_user_policy
676 |
677 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
678 | mock_client = Mock()
679 | mock_client.detach_user_policy.side_effect = Exception('Generic error')
680 | mock_get_client.return_value = mock_client
681 |
682 | with pytest.raises(Exception):
683 | await detach_user_policy(
684 | user_name='test-user', policy_arn='arn:aws:iam::123456789012:policy/TestPolicy'
685 | )
686 |
687 |
688 | @pytest.mark.asyncio
689 | async def test_create_access_key_with_exception():
690 | """Test create_access_key function with generic exception."""
691 | from awslabs.iam_mcp_server.server import create_access_key
692 |
693 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
694 | mock_client = Mock()
695 | mock_client.create_access_key.side_effect = Exception('Generic error')
696 | mock_get_client.return_value = mock_client
697 |
698 | with pytest.raises(Exception):
699 | await create_access_key(user_name='test-user')
700 |
701 |
702 | @pytest.mark.asyncio
703 | async def test_delete_access_key_with_exception():
704 | """Test delete_access_key function with generic exception."""
705 | from awslabs.iam_mcp_server.server import delete_access_key
706 |
707 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
708 | mock_client = Mock()
709 | mock_client.delete_access_key.side_effect = Exception('Generic error')
710 | mock_get_client.return_value = mock_client
711 |
712 | with pytest.raises(Exception):
713 | await delete_access_key(
714 | user_name='test-user',
715 | access_key_id='AKIAIOSFODNN7EXAMPLE', # pragma: allowlist secret
716 | )
717 |
718 |
719 | @pytest.mark.asyncio
720 | async def test_simulate_principal_policy_success():
721 | """Test simulate_principal_policy function success case."""
722 | from awslabs.iam_mcp_server.server import simulate_principal_policy
723 |
724 | mock_response = {
725 | 'EvaluationResults': [
726 | {
727 | 'EvalActionName': 's3:GetObject',
728 | 'EvalResourceName': 'arn:aws:s3:::my-bucket/*',
729 | 'EvalDecision': 'allowed',
730 | 'MatchedStatements': [{'SourcePolicyId': 'policy1'}],
731 | 'MissingContextValues': [],
732 | }
733 | ],
734 | 'IsTruncated': False,
735 | 'Marker': 'marker123',
736 | }
737 |
738 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
739 | mock_client = Mock()
740 | mock_client.simulate_principal_policy.return_value = mock_response
741 | mock_get_client.return_value = mock_client
742 |
743 | result = await simulate_principal_policy(
744 | policy_source_arn='arn:aws:iam::123456789012:user/test-user',
745 | action_names=['s3:GetObject'],
746 | resource_arns=['arn:aws:s3:::my-bucket/*'],
747 | context_entries={'aws:RequestedRegion': 'us-east-1'},
748 | )
749 |
750 | assert len(result['EvaluationResults']) == 1
751 | assert result['EvaluationResults'][0]['EvalActionName'] == 's3:GetObject'
752 | assert result['EvaluationResults'][0]['EvalResourceName'] == 'arn:aws:s3:::my-bucket/*'
753 | assert result['EvaluationResults'][0]['EvalDecision'] == 'allowed'
754 | assert result['IsTruncated'] is False
755 | assert result['Marker'] == 'marker123'
756 | assert result['PolicySourceArn'] == 'arn:aws:iam::123456789012:user/test-user'
757 |
758 |
759 | @pytest.mark.asyncio
760 | async def test_simulate_principal_policy_with_exception():
761 | """Test simulate_principal_policy function with generic exception."""
762 | from awslabs.iam_mcp_server.server import simulate_principal_policy
763 |
764 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
765 | mock_client = Mock()
766 | mock_client.simulate_principal_policy.side_effect = Exception('Generic error')
767 | mock_get_client.return_value = mock_client
768 |
769 | with pytest.raises(Exception):
770 | await simulate_principal_policy(
771 | policy_source_arn='arn:aws:iam::123456789012:user/test-user',
772 | action_names=['s3:GetObject'],
773 | )
774 |
775 |
776 | @pytest.mark.asyncio
777 | async def test_delete_user_success():
778 | """Test delete_user function success case."""
779 | from awslabs.iam_mcp_server.server import delete_user
780 |
781 | # Disable readonly mode
782 | Context.initialize(readonly=False)
783 |
784 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
785 | mock_client = Mock()
786 | mock_client.list_groups_for_user.return_value = {'Groups': []}
787 | mock_client.list_attached_user_policies.return_value = {'AttachedPolicies': []}
788 | mock_client.list_user_policies.return_value = {'PolicyNames': []}
789 | mock_client.list_access_keys.return_value = {'AccessKeyMetadata': []}
790 | mock_client.delete_user.return_value = {}
791 | mock_get_client.return_value = mock_client
792 |
793 | result = await delete_user(user_name='test-user')
794 |
795 | assert 'Successfully deleted user: test-user' in result['Message']
796 | mock_client.delete_user.assert_called_once_with(UserName='test-user')
797 |
798 |
799 | @pytest.mark.asyncio
800 | async def test_delete_user_readonly():
801 | """Test delete_user function in readonly mode."""
802 | from awslabs.iam_mcp_server.server import delete_user
803 |
804 | # Set readonly mode
805 | Context.initialize(readonly=True)
806 |
807 | with pytest.raises(IamClientError) as exc_info:
808 | await delete_user(user_name='test-user')
809 |
810 | assert 'read-only mode' in str(exc_info.value)
811 |
812 |
813 | @pytest.mark.asyncio
814 | async def test_delete_user_force():
815 | """Test delete_user function with force option."""
816 | from awslabs.iam_mcp_server.server import delete_user
817 |
818 | # Disable readonly mode
819 | Context.initialize(readonly=False)
820 |
821 | mock_policies_response = {
822 | 'AttachedPolicies': [{'PolicyArn': 'arn:aws:iam::123456789012:policy/TestPolicy'}]
823 | }
824 |
825 | mock_groups_response = {'Groups': [{'GroupName': 'TestGroup'}]}
826 |
827 | mock_keys_response = {
828 | 'AccessKeyMetadata': [{'AccessKeyId': 'AKIAIOSFODNN7EXAMPLE'}] # pragma: allowlist secret
829 | }
830 |
831 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
832 | mock_client = Mock()
833 | mock_client.list_attached_user_policies.return_value = mock_policies_response
834 | mock_client.list_groups_for_user.return_value = mock_groups_response
835 | mock_client.list_access_keys.return_value = mock_keys_response
836 | mock_client.list_user_policies.return_value = {'PolicyNames': []}
837 | mock_client.delete_user.return_value = {}
838 | mock_get_client.return_value = mock_client
839 |
840 | result = await delete_user(user_name='test-user', force=True)
841 |
842 | assert 'Successfully deleted user: test-user' in result['Message']
843 | mock_client.detach_user_policy.assert_called_once()
844 | mock_client.remove_user_from_group.assert_called_once()
845 | mock_client.delete_access_key.assert_called_once()
846 |
847 |
848 | @pytest.mark.asyncio
849 | async def test_attach_user_policy():
850 | """Test attach_user_policy function."""
851 | from awslabs.iam_mcp_server.server import attach_user_policy
852 |
853 | # Disable readonly mode
854 | Context.initialize(readonly=False)
855 |
856 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
857 | mock_client = Mock()
858 | mock_client.attach_user_policy.return_value = {}
859 | mock_get_client.return_value = mock_client
860 |
861 | result = await attach_user_policy(
862 | user_name='test-user', policy_arn='arn:aws:iam::123456789012:policy/TestPolicy'
863 | )
864 |
865 | assert 'Successfully attached policy' in result['Message']
866 | mock_client.attach_user_policy.assert_called_once()
867 |
868 |
869 | @pytest.mark.asyncio
870 | async def test_attach_user_policy_readonly():
871 | """Test attach_user_policy function in readonly mode."""
872 | from awslabs.iam_mcp_server.server import attach_user_policy
873 |
874 | # Set readonly mode
875 | Context.initialize(readonly=True)
876 |
877 | with pytest.raises(IamClientError) as exc_info:
878 | await attach_user_policy(
879 | user_name='test-user', policy_arn='arn:aws:iam::123456789012:policy/TestPolicy'
880 | )
881 |
882 | assert 'read-only mode' in str(exc_info.value)
883 |
884 |
885 | @pytest.mark.asyncio
886 | async def test_detach_user_policy():
887 | """Test detach_user_policy function."""
888 | from awslabs.iam_mcp_server.server import detach_user_policy
889 |
890 | # Disable readonly mode
891 | Context.initialize(readonly=False)
892 |
893 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
894 | mock_client = Mock()
895 | mock_client.detach_user_policy.return_value = {}
896 | mock_get_client.return_value = mock_client
897 |
898 | result = await detach_user_policy(
899 | user_name='test-user', policy_arn='arn:aws:iam::123456789012:policy/TestPolicy'
900 | )
901 |
902 | assert 'Successfully detached policy' in result['Message']
903 | mock_client.detach_user_policy.assert_called_once()
904 |
905 |
906 | @pytest.mark.asyncio
907 | async def test_detach_user_policy_readonly():
908 | """Test detach_user_policy function in readonly mode."""
909 | from awslabs.iam_mcp_server.server import detach_user_policy
910 |
911 | # Set readonly mode
912 | Context.initialize(readonly=True)
913 |
914 | with pytest.raises(IamClientError) as exc_info:
915 | await detach_user_policy(
916 | user_name='test-user', policy_arn='arn:aws:iam::123456789012:policy/TestPolicy'
917 | )
918 |
919 | assert 'read-only mode' in str(exc_info.value)
920 |
921 |
922 | @pytest.mark.asyncio
923 | async def test_create_access_key():
924 | """Test create_access_key function."""
925 | from awslabs.iam_mcp_server.server import create_access_key
926 |
927 | # Disable readonly mode
928 | Context.initialize(readonly=False)
929 |
930 | mock_response = {
931 | 'AccessKey': {
932 | 'AccessKeyId': 'AKIAIOSFODNN7EXAMPLE', # pragma: allowlist secret
933 | 'SecretAccessKey': 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY', # pragma: allowlist secret
934 | 'Status': 'Active',
935 | 'UserName': 'test-user',
936 | 'CreateDate': datetime(2023, 1, 1),
937 | }
938 | }
939 |
940 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
941 | mock_client = Mock()
942 | mock_client.create_access_key.return_value = mock_response
943 | mock_get_client.return_value = mock_client
944 |
945 | result = await create_access_key(user_name='test-user')
946 |
947 | assert 'Successfully created access key' in result['Message']
948 | assert (
949 | result['AccessKey']['AccessKeyId']
950 | == 'AKIAIOSFODNN7EXAMPLE' # pragma: allowlist secret
951 | )
952 | mock_client.create_access_key.assert_called_once()
953 |
954 |
955 | @pytest.mark.asyncio
956 | async def test_create_access_key_readonly():
957 | """Test create_access_key function in readonly mode."""
958 | from awslabs.iam_mcp_server.server import create_access_key
959 |
960 | # Set readonly mode
961 | Context.initialize(readonly=True)
962 |
963 | with pytest.raises(IamClientError) as exc_info:
964 | await create_access_key(user_name='test-user')
965 |
966 | assert 'read-only mode' in str(exc_info.value)
967 |
968 |
969 | @pytest.mark.asyncio
970 | async def test_delete_access_key():
971 | """Test delete_access_key function."""
972 | from awslabs.iam_mcp_server.server import delete_access_key
973 |
974 | # Disable readonly mode
975 | Context.initialize(readonly=False)
976 |
977 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
978 | mock_client = Mock()
979 | mock_client.delete_access_key.return_value = {}
980 | mock_get_client.return_value = mock_client
981 |
982 | result = await delete_access_key(
983 | user_name='test-user',
984 | access_key_id='AKIAIOSFODNN7EXAMPLE', # pragma: allowlist secret
985 | )
986 |
987 | assert 'Successfully deleted access key' in result['Message']
988 | mock_client.delete_access_key.assert_called_once()
989 |
990 |
991 | @pytest.mark.asyncio
992 | async def test_delete_access_key_readonly():
993 | """Test delete_access_key function in readonly mode."""
994 | from awslabs.iam_mcp_server.server import delete_access_key
995 |
996 | # Set readonly mode
997 | Context.initialize(readonly=True)
998 |
999 | with pytest.raises(IamClientError) as exc_info:
1000 | await delete_access_key(
1001 | user_name='test-user',
1002 | access_key_id='AKIAIOSFODNN7EXAMPLE', # pragma: allowlist secret
1003 | )
1004 |
1005 | assert 'read-only mode' in str(exc_info.value)
1006 |
1007 |
1008 | # Test main function and server initialization
1009 |
1010 |
1011 | def test_main_function():
1012 | """Test main function argument parsing."""
1013 | from awslabs.iam_mcp_server.server import main
1014 |
1015 | # Test with readonly flag
1016 | with patch('sys.argv', ['server.py', '--readonly']):
1017 | with patch('awslabs.iam_mcp_server.server.mcp.run') as mock_run:
1018 | main()
1019 | mock_run.assert_called_once()
1020 | # Verify readonly mode was set
1021 | assert Context.is_readonly()
1022 |
1023 | # Test without readonly flag
1024 | with patch('sys.argv', ['server.py']):
1025 | with patch('awslabs.iam_mcp_server.server.mcp.run') as mock_run:
1026 | main()
1027 | mock_run.assert_called_once()
1028 |
1029 |
1030 | # Group Management Tests
1031 |
1032 |
1033 | @pytest.mark.asyncio
1034 | async def test_list_groups():
1035 | """Test listing IAM groups."""
1036 | from awslabs.iam_mcp_server.server import list_groups
1037 |
1038 | mock_response = {
1039 | 'Groups': [
1040 | {
1041 | 'GroupName': 'TestGroup1',
1042 | 'GroupId': 'AGPAI23HZ27SI6FQMGNQ2',
1043 | 'Arn': 'arn:aws:iam::123456789012:group/TestGroup1',
1044 | 'Path': '/',
1045 | 'CreateDate': datetime(2023, 1, 1),
1046 | },
1047 | {
1048 | 'GroupName': 'TestGroup2',
1049 | 'GroupId': 'AGPAI23HZ27SI6FQMGNQ3',
1050 | 'Arn': 'arn:aws:iam::123456789012:group/TestGroup2',
1051 | 'Path': '/teams/',
1052 | 'CreateDate': datetime(2023, 1, 2),
1053 | },
1054 | ],
1055 | 'IsTruncated': False,
1056 | }
1057 |
1058 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
1059 | mock_client = Mock()
1060 | mock_client.list_groups.return_value = mock_response
1061 | mock_get_client.return_value = mock_client
1062 |
1063 | result = await list_groups()
1064 |
1065 | assert len(result.groups) == 2
1066 | assert result.groups[0].group_name == 'TestGroup1'
1067 | assert result.groups[1].group_name == 'TestGroup2'
1068 | assert result.groups[1].path == '/teams/'
1069 | assert result.count == 2
1070 | assert not result.is_truncated
1071 |
1072 |
1073 | @pytest.mark.asyncio
1074 | async def test_list_groups_with_path_prefix():
1075 | """Test listing IAM groups with path prefix filter."""
1076 | from awslabs.iam_mcp_server.server import list_groups
1077 |
1078 | mock_response = {
1079 | 'Groups': [
1080 | {
1081 | 'GroupName': 'TeamGroup',
1082 | 'GroupId': 'AGPAI23HZ27SI6FQMGNQ4',
1083 | 'Arn': 'arn:aws:iam::123456789012:group/teams/TeamGroup',
1084 | 'Path': '/teams/',
1085 | 'CreateDate': datetime(2023, 1, 1),
1086 | }
1087 | ],
1088 | 'IsTruncated': False,
1089 | }
1090 |
1091 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
1092 | mock_client = Mock()
1093 | mock_client.list_groups.return_value = mock_response
1094 | mock_get_client.return_value = mock_client
1095 |
1096 | result = await list_groups(path_prefix='/teams/', max_items=100)
1097 |
1098 | mock_client.list_groups.assert_called_once_with(MaxItems=100, PathPrefix='/teams/')
1099 | assert len(result.groups) == 1
1100 | assert result.groups[0].group_name == 'TeamGroup'
1101 |
1102 |
1103 | @pytest.mark.asyncio
1104 | async def test_get_group():
1105 | """Test getting detailed group information."""
1106 | from awslabs.iam_mcp_server.server import get_group
1107 |
1108 | mock_group_response = {
1109 | 'Group': {
1110 | 'GroupName': 'TestGroup',
1111 | 'GroupId': 'AGPAI23HZ27SI6FQMGNQ2',
1112 | 'Arn': 'arn:aws:iam::123456789012:group/TestGroup',
1113 | 'Path': '/',
1114 | 'CreateDate': datetime(2023, 1, 1),
1115 | },
1116 | 'Users': [
1117 | {'UserName': 'user1'},
1118 | {'UserName': 'user2'},
1119 | ],
1120 | }
1121 |
1122 | mock_policies_response = {
1123 | 'AttachedPolicies': [
1124 | {
1125 | 'PolicyName': 'TestPolicy',
1126 | 'PolicyArn': 'arn:aws:iam::123456789012:policy/TestPolicy',
1127 | }
1128 | ]
1129 | }
1130 |
1131 | mock_inline_policies_response = {'PolicyNames': ['InlinePolicy1']}
1132 |
1133 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
1134 | mock_client = Mock()
1135 | mock_client.get_group.return_value = mock_group_response
1136 | mock_client.list_attached_group_policies.return_value = mock_policies_response
1137 | mock_client.list_group_policies.return_value = mock_inline_policies_response
1138 | mock_get_client.return_value = mock_client
1139 |
1140 | result = await get_group(group_name='TestGroup')
1141 |
1142 | assert result.group.group_name == 'TestGroup'
1143 | assert len(result.users) == 2
1144 | assert 'user1' in result.users
1145 | assert 'user2' in result.users
1146 | assert len(result.attached_policies) == 1
1147 | assert result.attached_policies[0].policy_name == 'TestPolicy'
1148 | assert len(result.inline_policies) == 1
1149 | assert 'InlinePolicy1' in result.inline_policies
1150 |
1151 |
1152 | @pytest.mark.asyncio
1153 | async def test_create_group():
1154 | """Test creating a new IAM group."""
1155 | from awslabs.iam_mcp_server.server import create_group
1156 |
1157 | # Disable readonly mode
1158 | Context.initialize(readonly=False)
1159 |
1160 | mock_response = {
1161 | 'Group': {
1162 | 'GroupName': 'NewGroup',
1163 | 'GroupId': 'AGPAI23HZ27SI6FQMGNQ5',
1164 | 'Arn': 'arn:aws:iam::123456789012:group/NewGroup',
1165 | 'Path': '/',
1166 | 'CreateDate': datetime(2023, 1, 1),
1167 | }
1168 | }
1169 |
1170 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
1171 | mock_client = Mock()
1172 | mock_client.create_group.return_value = mock_response
1173 | mock_get_client.return_value = mock_client
1174 |
1175 | result = await create_group(group_name='NewGroup', path='/')
1176 |
1177 | mock_client.create_group.assert_called_once_with(GroupName='NewGroup', Path='/')
1178 | assert result.group.group_name == 'NewGroup'
1179 | assert 'Successfully created IAM group: NewGroup' in result.message
1180 |
1181 |
1182 | @pytest.mark.asyncio
1183 | async def test_create_group_readonly():
1184 | """Test creating group in readonly mode raises error."""
1185 | from awslabs.iam_mcp_server.server import create_group
1186 |
1187 | with patch('awslabs.iam_mcp_server.context.Context.is_readonly', return_value=True):
1188 | with pytest.raises(Exception) as exc_info:
1189 | await create_group(group_name='NewGroup')
1190 | assert 'Cannot create group in read-only mode' in str(exc_info.value)
1191 |
1192 |
1193 | @pytest.mark.asyncio
1194 | async def test_delete_group():
1195 | """Test deleting an IAM group."""
1196 | from awslabs.iam_mcp_server.server import delete_group
1197 |
1198 | # Disable readonly mode
1199 | Context.initialize(readonly=False)
1200 |
1201 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
1202 | mock_client = Mock()
1203 | mock_get_client.return_value = mock_client
1204 |
1205 | result = await delete_group(group_name='TestGroup', force=False)
1206 |
1207 | mock_client.delete_group.assert_called_once_with(GroupName='TestGroup')
1208 | assert 'Successfully deleted IAM group: TestGroup' in result['message']
1209 |
1210 |
1211 | @pytest.mark.asyncio
1212 | async def test_delete_group_force():
1213 | """Test force deleting an IAM group with cleanup."""
1214 | from awslabs.iam_mcp_server.server import delete_group
1215 |
1216 | # Disable readonly mode
1217 | Context.initialize(readonly=False)
1218 |
1219 | mock_group_response = {
1220 | 'Users': [
1221 | {'UserName': 'user1'},
1222 | {'UserName': 'user2'},
1223 | ]
1224 | }
1225 |
1226 | mock_attached_policies = {
1227 | 'AttachedPolicies': [{'PolicyArn': 'arn:aws:iam::123456789012:policy/TestPolicy'}]
1228 | }
1229 |
1230 | mock_inline_policies = {'PolicyNames': ['InlinePolicy1']}
1231 |
1232 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
1233 | mock_client = Mock()
1234 | mock_client.get_group.return_value = mock_group_response
1235 | mock_client.list_attached_group_policies.return_value = mock_attached_policies
1236 | mock_client.list_group_policies.return_value = mock_inline_policies
1237 | mock_get_client.return_value = mock_client
1238 |
1239 | result = await delete_group(group_name='TestGroup', force=True)
1240 |
1241 | # Verify cleanup operations
1242 | assert mock_client.remove_user_from_group.call_count == 2
1243 | mock_client.detach_group_policy.assert_called_once()
1244 | mock_client.delete_group_policy.assert_called_once()
1245 | mock_client.delete_group.assert_called_once_with(GroupName='TestGroup')
1246 | assert 'Successfully deleted IAM group: TestGroup' in result['message']
1247 |
1248 |
1249 | @pytest.mark.asyncio
1250 | async def test_delete_group_readonly():
1251 | """Test deleting group in readonly mode raises error."""
1252 | from awslabs.iam_mcp_server.server import delete_group
1253 |
1254 | with patch('awslabs.iam_mcp_server.context.Context.is_readonly', return_value=True):
1255 | with pytest.raises(Exception) as exc_info:
1256 | await delete_group(group_name='TestGroup')
1257 | assert 'Cannot delete group in read-only mode' in str(exc_info.value)
1258 |
1259 |
1260 | @pytest.mark.asyncio
1261 | async def test_add_user_to_group():
1262 | """Test adding a user to a group."""
1263 | from awslabs.iam_mcp_server.server import add_user_to_group
1264 |
1265 | # Disable readonly mode
1266 | Context.initialize(readonly=False)
1267 |
1268 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
1269 | mock_client = Mock()
1270 | mock_get_client.return_value = mock_client
1271 |
1272 | result = await add_user_to_group(group_name='TestGroup', user_name='testuser')
1273 |
1274 | mock_client.add_user_to_group.assert_called_once_with(
1275 | GroupName='TestGroup', UserName='testuser'
1276 | )
1277 | assert result.group_name == 'TestGroup'
1278 | assert result.user_name == 'testuser'
1279 | assert 'Successfully added user testuser to group TestGroup' in result.message
1280 |
1281 |
1282 | @pytest.mark.asyncio
1283 | async def test_add_user_to_group_readonly():
1284 | """Test adding user to group in readonly mode raises error."""
1285 | from awslabs.iam_mcp_server.server import add_user_to_group
1286 |
1287 | with patch('awslabs.iam_mcp_server.context.Context.is_readonly', return_value=True):
1288 | with pytest.raises(Exception) as exc_info:
1289 | await add_user_to_group(group_name='TestGroup', user_name='testuser')
1290 | assert 'Cannot add user to group in read-only mode' in str(exc_info.value)
1291 |
1292 |
1293 | @pytest.mark.asyncio
1294 | async def test_remove_user_from_group():
1295 | """Test removing a user from a group."""
1296 | from awslabs.iam_mcp_server.server import remove_user_from_group
1297 |
1298 | # Disable readonly mode
1299 | Context.initialize(readonly=False)
1300 |
1301 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
1302 | mock_client = Mock()
1303 | mock_get_client.return_value = mock_client
1304 |
1305 | result = await remove_user_from_group(group_name='TestGroup', user_name='testuser')
1306 |
1307 | mock_client.remove_user_from_group.assert_called_once_with(
1308 | GroupName='TestGroup', UserName='testuser'
1309 | )
1310 | assert result.group_name == 'TestGroup'
1311 | assert result.user_name == 'testuser'
1312 | assert 'Successfully removed user testuser from group TestGroup' in result.message
1313 |
1314 |
1315 | @pytest.mark.asyncio
1316 | async def test_remove_user_from_group_readonly():
1317 | """Test removing user from group in readonly mode raises error."""
1318 | from awslabs.iam_mcp_server.server import remove_user_from_group
1319 |
1320 | with patch('awslabs.iam_mcp_server.context.Context.is_readonly', return_value=True):
1321 | with pytest.raises(Exception) as exc_info:
1322 | await remove_user_from_group(group_name='TestGroup', user_name='testuser')
1323 | assert 'Cannot remove user from group in read-only mode' in str(exc_info.value)
1324 |
1325 |
1326 | @pytest.mark.asyncio
1327 | async def test_attach_group_policy():
1328 | """Test attaching a policy to a group."""
1329 | from awslabs.iam_mcp_server.server import attach_group_policy
1330 |
1331 | # Disable readonly mode
1332 | Context.initialize(readonly=False)
1333 |
1334 | policy_arn = 'arn:aws:iam::123456789012:policy/TestPolicy'
1335 |
1336 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
1337 | mock_client = Mock()
1338 | mock_get_client.return_value = mock_client
1339 |
1340 | result = await attach_group_policy(group_name='TestGroup', policy_arn=policy_arn)
1341 |
1342 | mock_client.attach_group_policy.assert_called_once_with(
1343 | GroupName='TestGroup', PolicyArn=policy_arn
1344 | )
1345 | assert result.group_name == 'TestGroup'
1346 | assert result.policy_arn == policy_arn
1347 | assert (
1348 | 'Successfully attached policy arn:aws:iam::123456789012:policy/TestPolicy to group TestGroup'
1349 | in result.message
1350 | )
1351 |
1352 |
1353 | @pytest.mark.asyncio
1354 | async def test_attach_group_policy_readonly():
1355 | """Test attaching policy to group in readonly mode raises error."""
1356 | from awslabs.iam_mcp_server.server import attach_group_policy
1357 |
1358 | with patch('awslabs.iam_mcp_server.context.Context.is_readonly', return_value=True):
1359 | with pytest.raises(Exception) as exc_info:
1360 | await attach_group_policy(
1361 | group_name='TestGroup', policy_arn='arn:aws:iam::123456789012:policy/TestPolicy'
1362 | )
1363 | assert 'Cannot attach policy to group in read-only mode' in str(exc_info.value)
1364 |
1365 |
1366 | @pytest.mark.asyncio
1367 | async def test_detach_group_policy():
1368 | """Test detaching a policy from a group."""
1369 | from awslabs.iam_mcp_server.server import detach_group_policy
1370 |
1371 | # Disable readonly mode
1372 | Context.initialize(readonly=False)
1373 |
1374 | policy_arn = 'arn:aws:iam::123456789012:policy/TestPolicy'
1375 |
1376 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
1377 | mock_client = Mock()
1378 | mock_get_client.return_value = mock_client
1379 |
1380 | result = await detach_group_policy(group_name='TestGroup', policy_arn=policy_arn)
1381 |
1382 | mock_client.detach_group_policy.assert_called_once_with(
1383 | GroupName='TestGroup', PolicyArn=policy_arn
1384 | )
1385 | assert result.group_name == 'TestGroup'
1386 | assert result.policy_arn == policy_arn
1387 | assert (
1388 | 'Successfully detached policy arn:aws:iam::123456789012:policy/TestPolicy from group TestGroup'
1389 | in result.message
1390 | )
1391 |
1392 |
1393 | @pytest.mark.asyncio
1394 | async def test_detach_group_policy_readonly():
1395 | """Test detaching policy from group in readonly mode raises error."""
1396 | from awslabs.iam_mcp_server.server import detach_group_policy
1397 |
1398 | with patch('awslabs.iam_mcp_server.context.Context.is_readonly', return_value=True):
1399 | with pytest.raises(Exception) as exc_info:
1400 | await detach_group_policy(
1401 | group_name='TestGroup', policy_arn='arn:aws:iam::123456789012:policy/TestPolicy'
1402 | )
1403 | assert 'Cannot detach policy from group in read-only mode' in str(exc_info.value)
1404 |
1405 |
1406 | # Group Management Exception Tests
1407 |
1408 |
1409 | @pytest.mark.asyncio
1410 | async def test_list_groups_with_exception():
1411 | """Test list_groups with exception handling."""
1412 | from awslabs.iam_mcp_server.server import list_groups
1413 |
1414 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
1415 | mock_client = Mock()
1416 | mock_client.list_groups.side_effect = BotoClientError(
1417 | error_response={'Error': {'Code': 'AccessDenied', 'Message': 'Access denied'}},
1418 | operation_name='ListGroups',
1419 | )
1420 | mock_get_client.return_value = mock_client
1421 |
1422 | with pytest.raises(IamPermissionError):
1423 | await list_groups()
1424 |
1425 |
1426 | @pytest.mark.asyncio
1427 | async def test_get_group_with_exception():
1428 | """Test get_group with exception handling."""
1429 | from awslabs.iam_mcp_server.server import get_group
1430 |
1431 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
1432 | mock_client = Mock()
1433 | mock_client.get_group.side_effect = BotoClientError(
1434 | error_response={'Error': {'Code': 'NoSuchEntity', 'Message': 'Group does not exist'}},
1435 | operation_name='GetGroup',
1436 | )
1437 | mock_get_client.return_value = mock_client
1438 |
1439 | with pytest.raises(IamResourceNotFoundError):
1440 | await get_group(group_name='NonExistentGroup')
1441 |
1442 |
1443 | @pytest.mark.asyncio
1444 | async def test_create_group_with_exception():
1445 | """Test create_group with exception handling."""
1446 | from awslabs.iam_mcp_server.server import create_group
1447 |
1448 | # Disable readonly mode
1449 | Context.initialize(readonly=False)
1450 |
1451 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
1452 | mock_client = Mock()
1453 | mock_client.create_group.side_effect = BotoClientError(
1454 | error_response={
1455 | 'Error': {'Code': 'EntityAlreadyExists', 'Message': 'Group already exists'}
1456 | },
1457 | operation_name='CreateGroup',
1458 | )
1459 | mock_get_client.return_value = mock_client
1460 |
1461 | with pytest.raises(IamClientError):
1462 | await create_group(group_name='ExistingGroup')
1463 |
1464 |
1465 | @pytest.mark.asyncio
1466 | async def test_delete_group_with_exception():
1467 | """Test delete_group with exception handling."""
1468 | from awslabs.iam_mcp_server.server import delete_group
1469 |
1470 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
1471 | mock_client = Mock()
1472 | mock_client.delete_group.side_effect = BotoClientError(
1473 | error_response={'Error': {'Code': 'DeleteConflict', 'Message': 'Cannot delete group'}},
1474 | operation_name='DeleteGroup',
1475 | )
1476 | mock_get_client.return_value = mock_client
1477 |
1478 | with pytest.raises(IamMcpError):
1479 | await delete_group(group_name='GroupWithDependencies', force=False)
1480 |
1481 |
1482 | @pytest.mark.asyncio
1483 | async def test_add_user_to_group_with_exception():
1484 | """Test add_user_to_group with exception handling."""
1485 | from awslabs.iam_mcp_server.server import add_user_to_group
1486 |
1487 | # Disable readonly mode
1488 | Context.initialize(readonly=False)
1489 |
1490 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
1491 | mock_client = Mock()
1492 | mock_client.add_user_to_group.side_effect = BotoClientError(
1493 | error_response={'Error': {'Code': 'NoSuchEntity', 'Message': 'User does not exist'}},
1494 | operation_name='AddUserToGroup',
1495 | )
1496 | mock_get_client.return_value = mock_client
1497 |
1498 | with pytest.raises(IamResourceNotFoundError):
1499 | await add_user_to_group(group_name='TestGroup', user_name='NonExistentUser')
1500 |
1501 |
1502 | @pytest.mark.asyncio
1503 | async def test_attach_group_policy_with_exception():
1504 | """Test attach_group_policy with exception handling."""
1505 | from awslabs.iam_mcp_server.server import attach_group_policy
1506 |
1507 | with patch('awslabs.iam_mcp_server.server.get_iam_client') as mock_get_client:
1508 | mock_client = Mock()
1509 | mock_client.attach_group_policy.side_effect = BotoClientError(
1510 | error_response={
1511 | 'Error': {'Code': 'InvalidInput', 'Message': 'Policy is not attachable'}
1512 | },
1513 | operation_name='AttachGroupPolicy',
1514 | )
1515 | mock_get_client.return_value = mock_client
1516 |
1517 | with pytest.raises(IamValidationError):
1518 | await attach_group_policy(
1519 | group_name='TestGroup', policy_arn='arn:aws:iam::123456789012:policy/TestPolicy'
1520 | )
1521 |
```