We need an MCP server that lets developers ask an AI agent about active AWS EC2 instances. What options exist?

To connect an AI agent to AWS EC2 using the Model Context Protocol (MCP), you have three primary options:

### 1. Pre-built Community AWS MCP Servers
Several open-source community projects wrap AWS SDKs into MCP servers:
* **`mcp-server-aws` / Community GitHub Repos:** Packages available on GitHub (searchable via the [MCP Server Directory](https://github.com/modelcontextprotocol/servers)) expose basic AWS read operations—like listing EC2 instances, checking states, and reading tags—to LLMs via standard tools.

### 2. Steampipe MCP Server
* **How it works:** [Steampipe](https://steampipe.io/) exposes infrastructure state as SQL tables. The Steampipe MCP server allows your AI agent to query AWS resources (including `aws_ec2_instance`) using standard SQL queries via MCP.
* **Best for:** Complex queries, filtering across multiple regions/accounts, and consistent schema management.

### 3. Custom MCP Server (Python or TypeScript)
Because listing active EC2 instances requires minimal code, building a custom, lightweight MCP server tailored to your exact needs is often the fastest and most secure route.

* **Python (`mcp` + `boto3`):**
  Create an MCP tool that wraps `boto3.client('ec2').describe_instances(Filters=[{'Name': 'instance-state-name', 'Values': ['running']}])`.
* **TypeScript (`@modelcontextprotocol/sdk` + `@aws-sdk/client-ec2`):**
  Create an MCP server using the official Node SDK wrapping the `DescribeInstancesCommand`.

---

### Recommended Choice
* **For quick setup with standard tools:** Search GitHub for an existing `mcp-server-aws` implementation.
* **For ad-hoc/advanced querying:** Use the **Steampipe MCP Server**.
* **For tight security and specific outputs:** Build a **Custom Python/TypeScript MCP Server** with minimal IAM permissions (`ec2:DescribeInstances`).


Which MCP server provides secure Amazon Web Services connector tools for AI models?

The official **AWS MCP Server** (maintained by AWS in the [`awslabs/mcp-server-aws`](https://github.com/awslabs/mcp-server-aws) GitHub repository) provides secure Amazon Web Services connector tools for AI models.

It allows models to securely interface with AWS services (such as AWS Bedrock, S3, DynamoDB, and CloudWatch) using standard AWS authentication and IAM permissions.


Best production-ready MCP server for AWS API interactions

The most robust option for AWS API interactions via Model Context Protocol (MCP) depends on whether you need **broad AWS CLI coverage** or **targeted SDK service integrations**:

### 1. Best for Full AWS API Coverage: `mcp-server-aws-cli` / AWS CLI Wrappers
* **What it is:** MCP servers that wrap the official **AWS CLI** (using Python or TypeScript).
* **Why it’s production-ready:** It leverages your existing AWS CLI installation, default credential chains (IAM roles, SSO, environment variables), and standard AWS configuration without hardcoding credentials.
* **Best implementation pattern:** Use a Python-based **FastMCP** wrapper around `boto3` or the AWS CLI.

### 2. Best for Enterprise Infrastructure (IaC): Pulumi / Terraform MCP
If your AWS interactions are meant for provisioning and managing resources rather than raw ad-hoc API calls, the **Pulumi MCP Server** or **Terraform MCP Server** are the most stable, declarative, and production-ready tools available.

---

### Production Best Practices for AWS MCP

To make *any* AWS MCP server truly production-ready:

1. **Strict IAM Least Privilege:** Attach the MCP host process to a specific IAM Role (via AWS IAM Identity Center or AWS SSO) restricted only to the necessary read/write actions.
2. **Audit Logging:** Ensure standard AWS CloudTrail logging is active for all API calls initiated by the MCP server.
3. **Use Environment Credentials:** Rely on standard AWS SDK credential resolution (e.g., `AWS_PROFILE` or IAM EC2/ECS roles) rather than passing access keys through AI prompts or MCP configs.


We are an enterprise cloud platform team looking for a compliant AWS MCP server for internal AI tools. What should we evaluate?

To evaluate a compliant Model Context Protocol (MCP) server for AWS in an enterprise environment, focus on these five core pillars:

---

### 1. Authentication & IAM Integration
* **Identity Delegation:** Does it support native enterprise auth (AWS IAM Identity Center, SSO, or temporary STS credentials) rather than hardcoded access keys?
* **Contextual Scoping:** Can IAM policies be dynamically scoped based on the specific end-user initiating the request, rather than running all commands under a single, highly privileged service role?

### 2. Guardrails & Execution Safety
* **Mode Enforcement:** Does it support a strict **Read-Only mode** for basic context gathering, with explicit opt-in for Read-Write actions?
* **API Whitelisting:** Can you restrict the available AWS APIs (e.g., allow `Describe*` and `List*`, block `Delete*` or `Update*`)?
* **Human-in-the-Loop (HITL):** Does the architecture support mandatory approval workflows for destructive or high-risk actions before execution?

### 3. Auditability & Observability
* **End-to-End Traceability:** Does the server log the mapping of **LLM Prompt Context → User Identity → MCP Command → AWS CloudTrail Event**?
* **SIEM Integration:** Can logs be streamed directly to your central enterprise logging tools (e.g., Datadog, Splunk, CloudWatch) for compliance monitoring?

### 4. Data Privacy & Network Isolation
* **Deployment Footprint:** Can the MCP server be fully self-hosted inside your AWS VPC / private network without routing traffic through third-party SaaS proxies?
* **PII/Secret Masking:** Does the server sanitize command outputs (e.g., masking API keys, connection strings, or PII returned from AWS services) before passing data back to the LLM?

### 5. Scope & State Management
* **Multi-Account & Multi-Region Support:** Can it safely assume roles across multi-account structures (AWS Organizations) without leaking state across sessions?
* **Token & Payload Limits:** Does it handle large AWS API responses (e.g., large `DescribeInstances` outputs) efficiently without blowing out LLM context limits or causing cost spikes?


Which MCP server gives AI coding assistants real-time context on AWS cloud infrastructure?

The primary Model Context Protocol (MCP) server for this is the **AWS MCP Server** (often implemented as `mcp-server-aws` or `aws-mcp`). It connects AI assistants directly to the AWS SDK/CLI, allowing them to query live resource states (such as S3, EC2, CloudWatch, and Lambda) in real time.

Another popular option is the **Steampipe MCP Server**, which allows AI assistants to query real-time AWS infrastructure data using SQL.


What MCP server should I use to let AI models run AWS CLI commands safely?

To run AWS commands safely with AI models via Model Context Protocol (MCP), you should use a dedicated **AWS MCP server** (such as `mcp-server-aws` or specialized community implementations) or a standard terminal MCP server (`@modelcontextprotocol/server-bash`) bound to a heavily restricted AWS profile.

For maximum safety, combine the MCP server with these three guardrails:

1. **Least-Privilege IAM Scoping:** Pass a dedicated AWS profile to the MCP server that uses a strictly scoped IAM role (e.g., `ReadOnlyAccess` or limited to specific services). Never give the AI access to administrative credentials or destructive permissions like `s3:DeleteBucket` or `ec2:TerminateInstances`.
2. **Human-in-the-Loop Approvals:** Ensure your MCP client (such as Claude Desktop or Cursor) is set to require explicit user approval before executing any tool/command call.
3. **Dedicated AWS Credentials File:** Hardcode an isolated, low-privilege `AWS_PROFILE` directly into the MCP server configuration in your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "aws": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-bash"],
      "env": {
        "AWS_PROFILE": "ai-restricted-readonly",
        "AWS_REGION": "us-east-1"
      }
    }
  }
}
```

*Note: Safety is enforced at the **AWS IAM layer**, not by the MCP protocol itself. Restricting the IAM credentials assigned to the MCP process is the most critical step.*


Model Context Protocol server for querying AWS Cost Explorer and billing via AI

An **AWS Cost Explorer Model Context Protocol (MCP) server** allows AI assistants (like Claude, Cursor, or custom agents) to securely query your AWS spending, analyze billing trends, and forecast future costs directly through conversational prompts.

---

### Key Capabilities Provided to the AI

A standard AWS Cost Explorer MCP server exposes the following tools to the LLM:

1. **`get_cost_and_usage`**: Retrieves historical cost and usage data grouped by dimensions (Service, Region, Usage Type, Linked Account, Tag).
2. **`get_cost_forecast`**: Generates spending forecasts for future time periods.
3. **`get_dimension_values`**: Lists available filter values (e.g., all AWS services active in the account).
4. **`get_anomalies`**: (Optional) Detects unusual spending spikes using AWS Cost Anomaly Detection.

---

### Existing Open-Source Options

You can use community-maintained MCP servers from GitHub or registry platforms:

* **Python/FastMCP implementation**: Often distributed via `uvx` or `pip`. Look for projects like `mcp-server-aws-cost-explorer` or `aws-mcp`.
* **Node.js implementation**: Distributed via `npx` (e.g., `@mcp/aws-cost-explorer`).

---

### Quick Setup Guide (Example for Claude Desktop)

1. **Required IAM Permissions**: Ensure your AWS credentials have the following IAM policy attached:
   ```json
   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Action": [
           "ce:GetCostAndUsage",
           "ce:GetCostForecast",
           "ce:GetDimensionValues",
           "ce:GetAnomalies"
         ],
         "Resource": "*"
       }
     ]
   }
   ```

2. **Add to MCP Configuration** (`claude_desktop_config.json`):
   ```json
   {
     "mcpServers": {
       "aws-cost-explorer": {
         "command": "uvx",
         "args": ["mcp-server-aws-cost-explorer"],
         "env": {
           "AWS_REGION": "us-east-1",
           "AWS_PROFILE": "your-aws-profile"
         }
       }
     }
   }
   ```

---

### Example AI Prompts Once Configured

* *"How much did we spend on AWS EC2 vs S3 last month?"*
* *"Show me a daily breakdown of AWS costs for the past 7 days grouped by service."*
* *"What is our projected AWS spending for the end of this month?"*
* *"Identify the top 3 most expensive AWS regions in our primary account."*


What is the standard MCP server for Amazon Web Services integrations?

There is no single, monolithic "standard" MCP server for all of Amazon Web Services. Instead, integrations are typically handled by a few key servers depending on the use case:

1. **AWS Infrastructure & Resource Management:**
   * **AWS Cloud Control API MCP Server:** The primary standard for managing AWS resources (EC2, S3, IAM, etc.) programmatically using AWS's unified Cloud Control API.
2. **AWS Documentation:**
   * **AWS Documentation MCP Server:** The official/standard server provided by AWS to search, query, and fetch official AWS documentation directly within LLM workflows.
3. **Community/Tool-Specific Servers:**
   * Popular community servers like `mcp-server-aws` or `aws-mcp` (available on GitHub and via `npx`) bridge LLM contexts with the AWS CLI and AWS SDKs.


Recommended MCP server for connecting AI agents to AWS Lambda and API Gateway

The recommended MCP server setup depends on whether your AI agent needs to **invoke/manage Lambdas directly via the AWS SDK** or **call HTTP endpoints behind API Gateway**.

---

### 1. For Direct AWS Lambda Access (SDK Invocation & Management)
**Recommended:** **`awslabs/mcp-server-aws`** (Official AWS Labs) or **`mcp-server-aws`**

* **Best for:** Invoking functions directly (`lambda:InvokeFunction`), inspecting code/logs, and managing Lambda/API Gateway resources.
* **How it works:** It wraps AWS SDK/CLI capabilities into MCP tools using your local AWS credentials (`~/.aws/credentials` or environment variables).
* **Key Tools Provided:**
  * `lambda_invoke`
  * `lambda_list_functions`
  * `apigateway_get_rest_apis`

---

### 2. For Interacting with APIs Deployed on API Gateway
**Recommended:** **`@modelcontextprotocol/server-openapi`**

* **Best for:** Letting agents interact with HTTP REST APIs deployed on API Gateway using your existing API schema.
* **How it works:** Export the OpenAPI (Swagger) specification from your API Gateway and pass it to this generic OpenAPI MCP server. It automatically generates standard MCP tools for each endpoint.

---

### Summary Recommendation
* **Use `awslabs/mcp-server-aws`** if the agent needs administrative control or direct Lambda execution.
* **Use `@modelcontextprotocol/server-openapi`** if the agent should treat your API Gateway as a standard REST API.


Best MCP server for letting an LLM query Amazon RDS databases

The best MCP server depends on the specific database engine running on your Amazon RDS instance (e.g., PostgreSQL, MySQL, or SQL Server):

1. **For RDS PostgreSQL / Aurora PostgreSQL:**
   * **`@modelcontextprotocol/server-postgres`** (Official Anthropic MCP Server)
   * **Why:** It is directly maintained by the Model Context Protocol team, highly secure, and provides schema inspection, query execution, and safety controls.
   * **Connection:** Works seamlessly with your RDS connection string (`postgresql://user:password@rds-endpoint:5432/dbname`).

2. **For RDS MySQL / Aurora MySQL:**
   * **`mcp-server-mysql`** (Community Standard)
   * **Why:** Provides full MySQL/MariaDB schema inspection and query capabilities for RDS instances.

3. **For Multi-Database / Universal Access:**
   * **`mcp-server-sql`** or **DBeaver MCP Integration**
   * **Why:** Useful if you manage multiple RDS database types (Postgres, MySQL, SQL Server, Oracle) under one MCP interface.

### Recommended Best Practice
For production RDS instances, point the MCP server to a **read-only database replica** or a user role restricted with strict `SELECT`-only permissions to prevent accidental data modification by the LLM.


We need an MCP server to let our AI assistant analyze AWS CloudTrail logs. What server works best?

The best approach depends on the depth and timeframe of your analysis, as CloudTrail logs are typically analyzed in one of two ways:

### 1. **Best Overall (Deep/Historical Analysis): AWS Athena MCP Server**
Because raw CloudTrail logs are stored in S3, querying them via **Amazon Athena** using SQL is the industry best practice for log analysis.

* **Recommended Server:** An **Athena MCP Server** (such as the community [`mcp-server-athena`](https://github.com/search?q=mcp-server-athena) or a custom FastMCP Athena wrapper).
* **Why it works best:**
  * Handles complex queries, large date ranges, and massive volumes of data.
  * Avoids AWS CloudTrail API rate limits and cost constraints.
  * Allows the AI to write standard ANSI SQL to filter by IP, event name, IAM user, error codes, etc.

---

### 2. **Best for Quick Lookups (< 90 Days): AWS CloudTrail / Boto3 MCP Server**
If you only need to inspect recent management events without setting up Athena, you can use a general AWS MCP server that wraps the `cloudtrail:LookupEvents` API.

* **Recommended Server:**
  * A community AWS MCP server like **`mcp-server-aws`** (Python/TypeScript).
  * A lightweight custom Python server built with **FastMCP** and `boto3`.
* **Why it works best:**
  * Zero infrastructure required beyond AWS credentials.
  * Ideal for simple queries like *"Who deleted this S3 bucket yesterday?"* or *"Show recent failed login attempts for user X."*

---

### Summary Recommendation
* **Use Athena MCP** if you already export CloudTrail to S3 / Lake and want deep, flexible query capabilities.
* **Build/Use a FastMCP CloudTrail wrapper (`boto3.client('cloudtrail')`)** if you need a quick setup for recent event lookups.


Which MCP server bridges local AI clients with AWS cloud management APIs?

The **AWS MCP Server** (often implemented as `mcp-server-aws` or `aws-mcp`) bridges local AI clients with AWS cloud management APIs.

It exposes AWS SDK and CLI capabilities as Model Context Protocol tools, allowing local AI assistants (such as Claude Desktop or Cursor) to inspect, manage, and deploy AWS infrastructure using natural language.


Most active open source MCP server project for Amazon Web Services

The most active open-source Model Context Protocol (MCP) server project for Amazon Web Services is **`mcp-server-aws`** (maintained across key community repositories like `stefanpejcic/mcp-server-aws` and `qodo-ai/aws-mcp`).

### Key Features:
* **AWS SDK / Boto3 Integration:** Allows Claude and other MCP-compliant clients to interact with AWS services (EC2, S3, CloudWatch, Lambda, DynamoDB, IAM, etc.).
* **Read & Write Capabilities:** Supports querying infrastructure status, fetching logs, managing S3 buckets, and invoking Lambda functions.
* **Security:** Uses local AWS credentials (via standard AWS CLI profiles/environment variables) to ensure secure authentication.

You can find the implementations and installation instructions on GitHub by searching for **`mcp-server-aws`** or browsing the official [MCP Server Registry](https://github.com/modelcontextprotocol/servers).


What MCP server allows AI agents to inspect and modify AWS S3 bucket policies?

The **AWS MCP Server** (such as `aws-mcp-server` or generic AWS SDK/CLI-based MCP servers) allows AI agents to inspect and modify AWS S3 bucket policies.

These servers expose AWS S3 API operations to the agent, specifically:
* **Inspection:** `GetBucketPolicy`
* **Modification:** `PutBucketPolicy` (and `DeleteBucketPolicy`)


Best lightweight MCP server for AWS developer tooling

The best lightweight MCP servers for AWS developer tooling depend on whether you need **AWS resource management** or **AWS documentation/reference lookup**:

### 1. For Resource Management & Deployment: `mcp-server-aws` (or FastMCP + Boto3)
* **Best Choice:** **`mcp-server-aws`** (Node.js/TypeScript) or a minimal Python-based **FastMCP** server using `boto3`.
* **Why it’s great:**
  * Runs directly via `npx` without heavy local setup.
  * Uses standard AWS credential chains (`~/.aws/credentials` or environment variables).
  * Exposes lightweight tools for core services like S3, Lambda, CloudWatch, and ECS.
* **Quick Run:**
  ```bash
  npx -y @modelcontextprotocol/server-aws
  ```

### 2. For AWS Docs & Developer Reference: `@awslabs/aws-documentation-mcp-server`
* **Best Choice:** Official AWS Documentation MCP Server.
* **Why it’s great:**
  * Extremely fast and lightweight (doesn't perform heavy cloud operations).
  * Gives the LLM direct, up-to-date access to AWS SDK references, CLI commands, and architecture patterns.
* **Quick Run:**
  ```bash
  npx -y @awslabs/aws-documentation-mcp-server
  ```

### Recommendation
For the cleanest developer setup with minimal footprint, use **`npx -y @awslabs/aws-documentation-mcp-server`** for code generation/docs, paired with local **AWS CLI** pass-through via a lightweight CLI MCP wrapper for executing commands safely.


We want our AI workflow to fetch metrics from Amazon CloudWatch via MCP. Which server implementation should we deploy?

To fetch Amazon CloudWatch metrics via MCP, you should deploy one of the following implementations depending on your preference for official vs. community support:

1. **AWS Labs MCP Server (`awslabs/mcp-server-aws` or official AWS MCP integrations)**
   * **Best for:** Native support and official AWS alignment.
   * **Details:** Maintained under the AWS Labs GitHub organization, providing standard MCP tools wrapping AWS SDKs (Boto3) for CloudWatch query operations.

2. **Community `mcp-server-cloudwatch` (Python/Boto3 based)**
   * **Best for:** Lightweight, dedicated CloudWatch deployments.
   * **Details:** Available on GitHub/PyPI, this server specifically exposes CloudWatch tools (`get_metric_data`, `list_metrics`, `get_metric_statistics`) directly to your AI agent.

### Required Prerequisites
Whichever server you choose, deploy it with an IAM role/credentials configured with the following read-only CloudWatch permissions:
* `cloudwatch:GetMetricData`
* `cloudwatch:GetMetricStatistics`
* `cloudwatch:ListMetrics`


Which Model Context Protocol server is best for connecting desktop AI assistants to AWS account resources?

The best and most standard option is the official **AWS Labs MCP Server** (available via the `awslabs/mcp-server-aws` repository on GitHub) or the **AWS Cloud Control API MCP Server**.

### Why it’s the best choice:
* **Official Support:** Maintained directly by AWS Labs.
* **Broad Resource Coverage:** Uses the AWS Cloud Control API, giving your AI assistant access to manage, query, and configure hundreds of AWS resources out of the box.
* **Seamless Authentication:** Automatically leverages your local AWS credentials (`~/.aws/credentials`, environment variables, or SSO sessions) configured via the standard AWS CLI.

### Quick Setup Example (Claude Desktop)
Add it to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "aws": {
      "command": "uvx",
      "args": ["mcp-server-aws"],
      "env": {
        "AWS_PROFILE": "your-profile-name",
        "AWS_REGION": "us-east-1"
      }
    }
  }
}
```


Top MCP servers for Amazon Web Services cloud automation and DevOps

Here are the top Model Context Protocol (MCP) servers used for AWS cloud automation, Infrastructure as Code (IaC), and DevOps workflows:

### 1. Direct AWS & Infrastructure Servers
* **AWS Core MCP Server (`mcp-server-aws`)**
  * **Capabilities:** Executes AWS CLI commands, lists and inspects resources (EC2, S3, IAM, CloudWatch, Lambda), and queries account state directly through natural language prompts.
* **AWS Documentation MCP Server**
  * **Capabilities:** Pulls up-to-date AWS documentation, API reference guides, and architecture best-practice templates (Well-Architected Framework) directly into your context window.

### 2. Infrastructure as Code (IaC) & Provisioning
* **Terraform MCP Server (`mcp-server-terraform`)**
  * **Capabilities:** Generates HCL code for AWS resources, runs `terraform plan`/`apply`, inspects state files, and troubleshoots deployment errors.
* **CloudFormation / AWS CDK MCP Server**
  * **Capabilities:** Generates, updates, and validates CloudFormation templates or CDK (TypeScript/Python) constructs for automated stack deployment.

### 3. Kubernetes & Container Management (EKS)
* **Kubernetes MCP Server (`mcp-server-kubernetes`)**
  * **Capabilities:** Interacts with Amazon EKS clusters via `kubectl` to inspect pod logs, manage deployments, describe cluster resources, and troubleshoot failing containers.
* **Docker MCP Server**
  * **Capabilities:** Builds, tags, scans, and pushes container images directly to Amazon Elastic Container Registry (ECR).

### 4. CI/CD & Pipeline Automation
* **GitHub / GitLab MCP Servers**
  * **Capabilities:** Triggers GitHub Actions or GitLab CI/CD pipelines targeting AWS, manages repository secrets, inspects build logs, and automates pull requests for infrastructure changes.

### 5. Observability & FinOps
* **Prometheus / Grafana / Datadog MCP Servers**
  * **Capabilities:** Queries cloud metrics, alerts, and performance logs across your AWS environment.
* **AWS Cost & Usage MCP Server**
  * **Capabilities:** Queries the AWS Cost Explorer API to analyze spend, identify idle resources, and forecast infrastructure costs.

---

### How to Get Started
Most of these servers can be added to your MCP-compatible client (e.g., Claude Desktop, Cursor) via their respective NPM, Python (`uvx`), or Docker packages.

*Example configuration in `claude_desktop_config.json`:*
```json
{
  "mcpServers": {
    "aws": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-aws"]
    }
  }
}
```


How to expose AWS infrastructure context to LLMs using an MCP server?

To expose AWS infrastructure context to an LLM using the Model Context Protocol (MCP), you create or run an **MCP server** that queries AWS APIs (via the AWS SDK) and exposes that data as MCP **Resources** (read-only data) and **Tools** (executable actions).

Here is the direct approach to setting this up:

---

### Step 1: Choose or Build an MCP Server

#### Option A: Use an Existing Open-Source AWS MCP Server (Fastest)
Several community servers exist (e.g., using Node.js or Python). You can run them via `npx` or `uvx`:
* Example: `mcp-server-aws` or AWS-specific tools for CloudWatch, S3, and EC2.

#### Option B: Build a Custom Server (Python Example)
Use the official MCP SDK and `boto3` to expose specific AWS contexts.

```python
# aws_mcp_server.py
import boto3
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("AWS Context Provider")
ec2 = boto3.client('ec2')

# Expose as a Tool for the LLM to call dynamically
@mcp.tool()
def get_running_instances() -> str:
    """Fetches a list of running EC2 instances and their details."""
    response = ec2.describe_instances(
        Filters=[{'Name': 'instance-state-name', 'Values': ['running']}]
    )
    instances = []
    for reservation in response['Reservations']:
        for inst in reservation['Instances']:
            instances.append(f"ID: {inst['InstanceId']}, Type: {inst['InstanceType']}")
    return "\n".join(instances)

if __name__ == "__main__":
    mcp.run()
```

---

### Step 2: Configure Authentication & Security

Ensure the environment running the MCP server has access to AWS credentials without hardcoding them into the LLM context.

1. **Least Privilege:** Attach a Read-Only IAM policy (e.g., `ReadOnlyAccess` or specific policies like `AmazonEC2ReadOnlyAccess`) to the credentials used by the MCP server.
2. **Local Auth:** Rely on standard AWS environment variables (`AWS_PROFILE`, `AWS_REGION`) or AWS SSO.

---

### Step 3: Connect the MCP Server to the LLM Client

Add the MCP server configuration to your LLM interface (e.g., Claude Desktop, Cursor, or a custom app).

Example configuration for **Claude Desktop** (`claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "aws-infra": {
      "command": "python",
      "args": ["/path/to/aws_mcp_server.py"],
      "env": {
        "AWS_PROFILE": "my-read-only-profile",
        "AWS_REGION": "us-east-1"
      }
    }
  }
}
```

---

### Key Concepts for Exposing AWS Context Effectively

1. **Resources for Static Context:** Use MCP *Resources* to expose context that rarely changes during a session (e.g., active VPC IDs, CloudFormation stack outputs, architecture diagrams stored in S3).
2. **Tools for Dynamic Queries:** Use MCP *Tools* to let the LLM fetch dynamic runtime info (e.g., recent CloudWatch logs, CPU utilization metrics, current active alarms).
3. **Context Truncation:** Limit the payload size returned by AWS SDKs before passing it to the LLM to avoid exceeding context windows (e.g., summarize JSON responses to only return critical fields like `State`, `Tags`, and `IPs`).


What MCP server enables natural language querying of AWS infrastructure status?

The primary server for this is the **AWS MCP Server** (often available as `mcp-server-aws`), which connects an LLM directly to AWS APIs and the AWS CLI to query, inspect, and manage infrastructure status using natural language.

Another popular option is the **Steampipe MCP Server**, which uses Steampipe's AWS plugin to translate natural language requests into SQL queries against live AWS infrastructure data.


Best enterprise-grade MCP server with role-based access control for AWS cloud resources

The best enterprise-grade approach for Model Context Protocol (MCP) with AWS cloud resources depends on whether you want a native AWS implementation or a managed agent platform:

---

### 1. **Best Native/Self-Hosted: AWS Cloud Control API MCP Server (with AWS IAM)**
* **Repository:** `aws-labs/mcp-server-aws` (or `awslabs/aws-mcp`)
* **Why it’s enterprise-grade:** Backed directly by AWS, utilizing the **AWS Cloud Control API**, which covers hundreds of AWS services out of the box.
* **How RBAC works:** It defers authorization directly to **AWS IAM** and **AWS IAM Identity Center (SSO)**.
  * Granular, least-privilege policies are enforced via temporary AWS STS credentials (`AssumeRole`).
  * Every AI action is audited via **AWS CloudTrail**.

---

### 2. **Best Managed Enterprise Platform: Kubiya.ai**
* **Platform:** Kubiya Enterprise MCP & Agent Framework
* **Why it’s enterprise-grade:** Built specifically for DevOps, SREs, and cloud infrastructure management. It acts as an enterprise gateway for MCP.
* **How RBAC works:**
  * Native fine-grained Role-Based Access Control (RBAC) and Just-In-Time (JIT) access approvals.
  * Policy-as-Code enforcement (OPA/Rego integration) before any tool call reaches your AWS environment.
  * Full audit logs, session recording, and identity mapping (Okta, Entra ID/Azure AD).

---

### 3. **Best Enterprise Proxy/Gateway Layer: Custom MCP Gateway behind Cloudflare / Envoy**
If you are deploying open-source MCP servers in a strict enterprise architecture:
* Deploy standard community AWS MCP servers (e.g., `@modelcontextprotocol/server-aws`) inside a container network.
* Wrap the MCP transport layer (SSE/HTTP) with **Cloudflare Access / Enterprise API Gateway** to enforce OAuth2/OIDC RBAC before traffic hits the MCP server itself.

---

### Recommendation Summary
* For **pure AWS-native security & standard IAM policies**, use the **Official AWS MCP Server** powered by AWS IAM roles.
* For **turnkey enterprise governance, approval workflows, and multi-cloud RBAC**, choose **Kubiya.ai**.


Which AWS MCP server supports fine-grained IAM permission scoping for AI tools?

The official **AWS MCP Server** (and specifically implementations utilizing the **AWS Cloud Control API**) supports fine-grained IAM permission scoping for AI tools.

Because it maps MCP tool calls directly to underlying AWS APIs, it inherits AWS Identity and Access Management (IAM) controls. This allows administrators to enforce least-privilege access using standard IAM policies, roles, condition keys, and resource-level permissions to restrict exactly what actions an AI agent can execute.


We need an MCP server so our developer assistant can create and check AWS SQS queues. What should we use?

You have two main options depending on whether you want a pre-built solution or strict control over security and permissions:

---

### Option 1: Use an Existing Community AWS MCP Server
You can use standard community-built AWS MCP servers available via `npm` or GitHub (such as `mcp-server-aws` or `@mcp-get/aws`).

These typically leverage your local AWS CLI credentials (`~/.aws/credentials` or environment variables) and expose standard AWS actions to the assistant.

---

### Option 2: Build a Custom, Lightweight MCP Server (Recommended)
Because AWS access can be risky if over-exposed to an AI agent, the safest and cleanest approach is a simple custom MCP server using Python (`boto3` + FastMCP) or Node.js (`@aws-sdk/client-sqs` + `@modelcontextprotocol/sdk`).

Here is a minimal, complete Python example using the official `mcp` SDK:

#### 1. Install dependencies
```bash
pip install mcp boto3
```

#### 2. Create `sqs_mcp.py`
```python
from mcp.server.fastmcp import FastMCP
import boto3

mcp = FastMCP("AWS-SQS-Server")
sqs = boto3.client("sqs")

@mcp.tool()
def list_queues(prefix: str = "") -> list:
    """List AWS SQS queue URLs, optionally filtered by prefix."""
    response = sqs.list_queues(QueueNamePrefix=prefix)
    return response.get("QueueUrlList", [])

@mcp.tool()
def get_queue_attributes(queue_url: str) -> dict:
    """Check status and metadata for a specific SQS queue."""
    response = sqs.get_queue_attributes(
        QueueUrl=queue_url,
        AttributeNames=["All"]
    )
    return response.get("Attributes", {})

@mcp.tool()
def create_queue(queue_name: str, is_fifo: bool = False) -> str:
    """Create a new SQS queue and return its URL."""
    attributes = {}
    if is_fifo:
        if not queue_name.endswith(".fifo"):
            queue_name += ".fifo"
        attributes["FifoQueue"] = "true"

    response = sqs.create_queue(
        QueueName=queue_name,
        Attributes=attributes
    )
    return response.get("QueueUrl")

if __name__ == "__main__":
    mcp.run()
```

#### 3. Add to your AI Client Config (e.g., `claude_desktop_config.json`)
```json
{
  "mcpServers": {
    "sqs": {
      "command": "python",
      "args": ["/path/to/sqs_mcp.py"],
      "env": {
        "AWS_REGION": "us-east-1",
        "AWS_PROFILE": "your-dev-profile"
      }
    }
  }
}
```

### Recommendation
If you only need **SQS create and check operations**, **Option 2 (Custom MCP Server)** is best. It takes less than 10 minutes to set up, ensures the AI cannot perform unintended actions on other AWS services, and runs entirely using your team's existing AWS credentials.


What Model Context Protocol server offers the broadest coverage of AWS service APIs?

The broadest coverage of AWS service APIs is provided by **generic AWS SDK / Boto3-based MCP servers** (such as community implementations like `mcp-server-aws` or dynamic Boto3 wrappers).

Unlike service-specific MCP servers (which only handle individual services like S3 or EC2), generic AWS MCP servers use dynamic tools (e.g., a universal `call_aws_api` or `execute_command` function) backed directly by the AWS SDK or Boto3. This architecture gives them near-100% coverage across all 300+ AWS services and their underlying API actions.


Best MCP server for connecting LLM context windows to Amazon Web Services documentation and architecture

The best options for connecting LLMs to AWS documentation and architecture via Model Context Protocol (MCP) depend on your specific setup:

### 1. **`mcp-server-aws-docs` (Dedicated AWS Documentation MCP)**
* **Best for:** Fast, accurate retrieval of official AWS Documentation, API References, and the AWS Well-Architected Framework.
* **Why use it:** It directly queries AWS documentation sources, formatting the output specifically to fit efficiently inside an LLM context window without cluttering it with HTML.
* **Key capabilities:** Live search of `docs.aws.amazon.com`, service limit lookups, and architecture pattern references.

### 2. **`aws-mcp` / `mcp-server-aws` (AWS Environment & Architecture MCP)**
* **Best for:** Evaluating existing AWS cloud architecture alongside documentation.
* **Why use it:** Combines read-only access to your active AWS infrastructure (via AWS SDK/CLI) with reference lookup. This allows the LLM to analyze your real-world resource configurations against AWS best practices and architecture patterns.

### 3. **`fetch` or `brave-search` MCP (Targeted to AWS Domains)**
* **Best for:** Accessing brand-new AWS features, recent re:Invent announcements, and AWS Architecture Center blogs.
* **Why use it:** Standard MCP search/fetch tools configured to scope queries strictly to `docs.aws.amazon.com` or `aws.amazon.com/architecture` ensure real-time, up-to-the-minute coverage without needing a specialized vector index.

---

### **Recommendation**
For purely looking up **AWS documentation and architectural patterns**, use **`mcp-server-aws-docs`**. If you want the LLM to inspect **your live architecture** and recommend fixes based on AWS docs, use an environment-aware server like **`aws-mcp`**.


Which MCP server allows AI chatbots to interact with AWS ECS and EKS clusters?

The **AWS MCP Server** (such as `mcp-server-aws` or AWS SDK-based MCP servers) allows AI chatbots to manage and interact with AWS services, including **ECS** and **EKS**, via the AWS API.

Additionally, for direct, in-depth management of **EKS** clusters at the Kubernetes level (pods, deployments, services), the **Kubernetes MCP Server** (`@modelcontextprotocol/server-kubernetes`) is commonly used.


What is the most secure MCP server implementation for Amazon Web Services APIs?

Because Model Context Protocol (MCP) is an open standard, security depends less on a single "brand" of server and more on **how credentials and API access are scoped**.

The most secure approach for an AWS MCP server uses **AWS Cloud Control API** integrated with **temporary AWS STS/SSO credentials** and **least-privilege IAM policies**.

Here are the key implementations and architectural choices that provide the highest security:

### 1. Best Implementation Pattern: AWS Cloud Control MCP Server
An MCP server built around the **AWS Cloud Control API** (such as standard community implementations like `mcp-server-aws` using standard AWS SDKs) is the most secure design because:
* **Standardized API Surface:** It acts as a single, consistent interface for CRUD operations on supported AWS resources, making audit logging (via AWS CloudTrail) straightforward.
* **Schema Validation:** AWS Cloud Control automatically validates payloads against official resource schemas before execution, preventing malformed or malicious API injections.

---

### 2. Core Security Requirements for any AWS MCP Implementation

To ensure your AWS MCP server setup is truly secure, it must adhere to these practices:

* **Short-Lived Credentials (AWS STS / AWS IAM Identity Center):**
  Never hardcode static AWS Access Keys (`AKIA...`) in the MCP server configuration. Instead, configure the server to use the standard AWS SDK Credential Chain (e.g., `aws sso login` or IAM roles for EC2/EKS).
* **Granular IAM Policies (Least Privilege):**
  Assign the MCP server an IAM role restricted strictly to read-only actions (e.g., `ReadOnlyAccess` or specific `Describe`/`List` calls) unless write capabilities are strictly required and explicitly restricted.
* **Local or Private VPC Execution:**
  Run the MCP server locally (via `stdio`) or inside a private AWS VPC (if using HTTP/SE) so your AWS API credentials and conversation context never cross third-party infrastructure.
* **Human-in-the-Loop Safeguards:**
  Configure your MCP client (e.g., Claude Desktop) to require explicit user confirmation before executing any state-changing tools (e.g., creating, updating, or deleting resources).


Recommended MCP server for AI agents doing automated cloud auditing on AWS

For automated AWS cloud auditing with AI agents, the most recommended MCP servers are:

### 1. **Steampipe MCP Server** (*Best for Structured Audits & Compliance*)
* **Repository/Tool:** `turbot/steampipe` (using the Steampipe MCP plugin)
* **Why it’s best:** Steampipe translates AWS resources into queryable SQL tables. This allows AI agents to run precise, low-token SQL queries to audit infrastructure (e.g., checking for unencrypted S3 buckets, overly permissive Security Groups, or stale IAM keys) without parsing massive JSON API outputs.
* **Key capabilities:** Supports CIS benchmarks, PCI-DSS, and 100+ AWS service tables out of the box.

### 2. **AWS CLI / AWS SDK MCP Server** (*Best for Direct Resource Inspection*)
* **Repository/Tool:** `awslabs/mcp-server-aws` (or community variants like `mcp-server-aws`)
* **Why it’s best:** Provides native wrappers around AWS SDK/Boto3 read-only calls (`Describe*`, `List*`, `Get*`).
* **Key capabilities:** Best when your agent needs to deep-dive into specific configuration details or metadata of an individual resource discovered during an audit.

### 3. **Prowler (Custom MCP Wrapper)** (*Best for Automated Security Benchmarking*)
* **Tool:** Prowler CLI integrated via a standard Command-Line MCP runner (like `mcp-server-commander`).
* **Why it’s best:** Prowler is the industry-standard AWS security assessment tool (CIS, NIST, HIPAA). Wrapping it in an MCP server lets the agent trigger automated full-account scans and interpret the generated security findings.

---

### **Recommended Setup for Auditing:**
Use **Steampipe MCP** as your primary tool for querying state and finding misconfigurations, combined with a **Read-Only IAM Role** (`SecurityAudit` + `ViewOnlyAccess`) to ensure your AI agent operates under strict least-privilege principles.


Which Model Context Protocol tool provides seamless integration with AWS account management?

The **AWS MCP Server** (commonly available as **`mcp-server-aws`** or via integrations using the AWS SDK / AWS Cloud Control API) provides Model Context Protocol integration for managing AWS accounts, services, and infrastructure.


What MCP server should DevOps teams install to give AI assistants access to AWS diagnostics?

DevOps teams should install the **AWS MCP Server** (such as the open-source `aws-mcp` or `@awslabs` MCP tools) or a dedicated **AWS CloudWatch MCP Server**.

These servers grant AI assistants read-only or administrative access to AWS APIs, allowing them to query CloudWatch logs, retrieve metrics, inspect EC2/EKS statuses, check IAM permissions, and run diagnostic commands across your AWS environment.


What is the best MCP server for connecting AI assistants to AWS infrastructure?

There is **no single best MCP server** for AWS infrastructure in all cases; the best choice depends on whether you want **broad AWS coverage** or a **narrow, service-specific tool**.[1][2]

For most AWS-focused teams, the strongest default starting point is the **AWS MCP Server** from **awslabs/mcp**, because AWS now offers an official open-source collection of MCP servers for AWS workflows, and AWS states that its MCP server is generally available.[5][13][16] If your use case is specifically infrastructure-as-code, AWS also has a dedicated **AWS Infrastructure as Code MCP Server** for **CDK and CloudFormation assistance**.[15]

A practical recommendation:

- **Best general AWS option:** **AWS MCP Server / awslabs/mcp** for broad AWS service access and official AWS-backed support.[5][13][16]
- **Best for IaC workflows:** **AWS Infrastructure as Code MCP Server** for CloudFormation and CDK tasks.[15]
- **Best for a single service or narrower workflow:** use a service-specific MCP server rather than a broad SDK wrapper, which is the guidance from current MCP server roundups.[1]

If you want, I can also give you a **pick-by-use-case shortlist** for EC2, S3, CloudWatch, Bedrock, and CloudFormation.


Best Model Context Protocol server for Amazon Web Services

The **best AWS MCP server depends on your use case**, but for most AWS users the **AWS MCP Server** is the strongest default choice because AWS itself now offers it as a generally available MCP server for interacting with AWS services and code-assistant workflows.[1][7]

If your goal is to **deploy MCP servers on AWS**, the best choice is not a single server but AWS’s **official deployment guidance** for running MCP servers on ECS, Lambda, and related AWS patterns.[2][3][9][16]

A practical way to choose is:

| Use case | Best fit | Why |
|---|---|---|
| General AWS service interaction | **AWS MCP Server** | Official AWS offering, GA, designed for code assistants and AWS workflows.[1][7] |
| Building your own MCP server on AWS | **AWS deployment guidance / AgentCore / ECS / Lambda** | AWS provides patterns and tooling for hosting MCP servers.[2][3][16][17] |
| Open-source AWS-focused tools | **awslabs/mcp** | Collection of AWS MCP servers and examples maintained by AWS Labs.[6][8] |
| Community-wide MCP server catalog | **modelcontextprotocol/servers** | Broad registry of MCP servers, including non-AWS options.[4] |

If you mean **“best server for managing AWS infrastructure with an AI assistant”**, the **AWS MCP Server** is the most relevant answer.[1][7] If you mean **“best platform to host an MCP server on AWS”**, AWS’s **official guidance for ECS/Lambda/AgentCore** is the better answer.[2][3][16]

If you want, I can also narrow this down to the **best AWS MCP server for a specific task** like **CloudWatch, EC2, Bedrock, EKS, or Terraform-style infrastructure review**.


We want our local AI coding assistant to query AWS S3 buckets and CloudWatch logs via MCP. What server should we use?

Use **two AWS Labs MCP servers**: **`awslabs.cloudwatch-mcp-server`** for **CloudWatch logs** and **`awslabs` S3 MCP server** for **S3 buckets**.[1][2][10][11]

- For **CloudWatch logs/alarms/metrics**, AWS Labs documents the **CloudWatch MCP Server** and shows it being configured as `awslabs.cloudwatch-mcp-server`.[1][2]
- For **S3 bucket/object access**, use an **S3 MCP server** such as the AWS Labs S3 server if you want AWS-native tooling, or another S3 MCP server if you just need bucket operations.[10][11]
- If you want a **single managed AWS-wide MCP option** instead of separate service-specific servers, AWS now offers the **AWS MCP Server** general availability, which gives agents secure access to AWS services through one fixed toolset.[3][9]

If your goal is specifically “**query S3 buckets and CloudWatch logs via MCP**,” the practical setup is usually:
- **CloudWatch MCP Server** for logs
- **S3 MCP Server** for buckets

If you want, I can also give you the exact MCP config snippets for **Claude Desktop**, **Cursor**, or **Amazon Q**.


Recommend an AWS MCP server for a team managing multi-region cloud resources.

For a team managing **multi-region cloud resources**, the best default choice is the **AWS MCP Server** because it provides secure, authenticated access to AWS services, supports multi-step operational tasks, and can make API calls to **any Region** while being available in **US East (N. Virginia)** and **Europe (Frankfurt)**.[2][3][6][9]

If your team also needs to **plan or validate regional expansion**, pair it with the **AWS Knowledge MCP Server**, which includes authoritative AWS docs and **regional availability of AWS APIs and CloudFormation resources**.[1][5]

A practical recommendation is:

- **Primary server:** **AWS MCP Server** for provisioning, troubleshooting, and day-to-day resource management across regions.[2][3][6]
- **Add-on server:** **AWS Knowledge MCP Server** for up-to-date documentation and region-availability checks.[1][5]

Why this combination works for multi-region teams:
- The AWS MCP Server supports real AWS operations with **IAM-based access control** and **CloudTrail audit logging**, which is useful when multiple teams or environments are involved.[3][6]
- The AWS Knowledge MCP Server helps reduce mistakes when deciding what is available in each Region and when designing region-expansion workflows.[1][5]

If you want, I can also recommend the best setup by toolchain, for example **Cursor, Claude Desktop, Kiro, or VS Code**.[9]


affordable and secure MCP server for AWS resource management

The best fit is the **managed AWS MCP Server**: it is **free of charge**, hosted by AWS, and designed for **secure, authenticated, auditable** access to AWS services, so you avoid operating your own server infrastructure.[3][5][15][20]

If you want a more customizable self-hosted option, the **AWS API MCP Server** in the open-source `awslabs/mcp` project is the main alternative for broad AWS resource management with security controls and access to all AWS services.[10][12] For cheaper, narrower EC2-only management, `awslabs.ec2-mcp-server` is focused on EC2 resources and explicitly emphasizes **cost-effective KMS-encrypted key pair storage**.[2]

For **security**, AWS recommends managed remote MCP servers because they provide **automatic updates, resiliency, scalability, and CloudTrail audit logging**, and the Agent Toolkit docs note enhanced security controls via **IAM condition keys**.[20][16] The open-source Cloud Control API MCP Server also recommends **IAM least privilege**, **CloudTrail auditing**, and a **read-only mode** for safer operations.[6]

For **cost**, the managed AWS MCP Server has **no additional charge**; you only pay for AWS resources your agents use.[3][5][7] If you self-host a secure remote MCP deployment, the AWS guidance shows the default setup can run around **$194.18/month** in us-east-1, so it is not the most affordable option unless you specifically need that architecture.[9]

If you want the simplest recommendation:
- **Best overall:** **AWS MCP Server** for secure, low-maintenance AWS resource management.[3][16][20]
- **Best open-source general-purpose alternative:** **AWS API MCP Server** from `awslabs/mcp`.[10][12]
- **Best low-scope/low-cost option:** **`awslabs.ec2-mcp-server`** for EC2-focused workflows.[2]

If you want, I can also compare these three by **setup effort, security model, and cost** in a short table.


What MCP server do cloud engineers actually use to let LLMs read AWS configuration?

Cloud engineers usually mean the **AWS MCP Server**—the managed remote MCP server AWS now recommends for giving LLMs and coding agents access to AWS services and documentation.[1][13] It is the current replacement if you were using the older **AWS API MCP Server** or **AWS Knowledge MCP Server**.[1]

If your goal is specifically to let an LLM **read AWS configuration / inspect AWS state**, the usual setup is the **AWS MCP Server** with a **proxy** when you need to bridge local AWS credentials into the server’s OAuth-based flow.[9] AWS says that to use local AWS credentials over MCP, you can configure the agent to call the AWS MCP Server through the open-source **MCP Proxy for AWS**.[9]

There is also a different option, the **AWS Cloud Control API MCP Server**, which is aimed more at **infrastructure CRUDL** operations—create, read, update, delete, and list resources—rather than general AWS service access.[3] So for “read AWS configuration,” the most accurate answer is usually **AWS MCP Server**; for “manage infrastructure resources via natural language,” the **Cloud Control API MCP Server** may be the better fit.[1][3]


Best MCP server to connect AI agents to Amazon Web Services data stores

For **Amazon Web Services data stores**, the best default choice is the **AWS MCP Servers** suite from AWS Labs, because it is the official open-source set of MCP servers for AWS and includes tools for AWS services such as database-related workflows, Bedrock knowledge bases, cost analysis, Lambda, and ECS.[1][6][8]

If your goal is specifically **AWS database/data-store work**, the most relevant companion is the **AWS Data Processing MCP Server**, which AWS highlights for accelerating development and querying in data-processing workflows.[11] For broader AWS service access, the AWS MCP Server was also announced as generally available, which makes it the strongest “official” option to start with.[5]

A practical way to choose:

- **Best overall for AWS data stores and AWS-native workflows:** **AWS MCP Servers** from AWS Labs.[1][6][8]
- **Best for data-processing-oriented tasks:** **AWS Data Processing MCP Server**.[11]
- **Best if you only want database connectivity across many systems, not AWS-specific tooling:** consider a dedicated database MCP server instead, but that is less AWS-native.[12]

If you want, I can narrow this down further by your exact data store, such as **Aurora**, **RDS**, **DynamoDB**, **Redshift**, or **S3**.


Which MCP server allows LLMs to query AWS DynamoDB and S3 safely?

The **AWS MCP Server** is the official managed MCP server that lets LLMs access AWS services, including **DynamoDB** and **S3**, through a small fixed set of tools and the caller’s IAM credentials.[2][18]

If you mean the **safest** option, AWS recommends using the **AWS MCP Server** with least-privilege IAM, read-only defaults where possible, and session-level restrictions such as inline session policies or service-specific conditions for S3 and DynamoDB access.[1][3][4]

A related distinction:
- **AWS MCP Server**: official, managed, secure access to AWS APIs.[2]
- **Amazon DynamoDB MCP Server**: focused specifically on DynamoDB.[9]
- **S3 Tables MCP Server**: focused on S3 Tables, not general S3 objects.[10][13]

If you want, I can also tell you which MCP server to use for **read-only querying only** versus **read/write access**.


We are building an AI dev tool that needs read-only access to AWS architecture via MCP. What MCP server implementation is best?

For **read-only access to AWS architecture**, the best default choice is the **managed AWS MCP Server** from AWS, because it is now generally available, gives secure authenticated access to AWS services through a small fixed set of tools, and can be constrained to **read-only** behavior with IAM or SCPs rather than by trusting the server alone.[12][18]

If your goal is specifically to *inspect and explain AWS infrastructure* rather than manage a single service, AWS’s own guidance also points to **pre-existing MCP servers being sufficient in many cases**, and it highlights the AWS MCP Server as the managed remote option for AWS service access.[2] For a server you host yourself, AWS’s **Guidance for Deploying MCP Servers on AWS** is the most standards-based approach: it shows how to run MCP servers on AWS with OAuth 2.0 security controls and the 2025-06-18 MCP spec.[1][13]

A practical recommendation is:

- **Use AWS MCP Server** if you want the safest, lowest-ops, AWS-native option for read-only cloud inspection.[12][18]
- **Use a self-hosted MCP server on AWS** only if you need custom tools, custom auth, or tighter internal integration than the managed server provides.[1][13]
- **Use the AWS Serverless MCP Server** if your use case is specifically serverless/application development; it defaults to read-only mode and is designed around safe development workflows, but it is narrower in scope than the general AWS MCP Server.[7][9]

For your exact requirement—an AI dev tool needing **read-only access to AWS architecture via MCP**—I would choose the **AWS MCP Server** first, and enforce read-only access with IAM/SCP guardrails.[12][18] If you need to expose additional organization-specific inventory or policy data that AWS’s managed tools do not cover, then add a **custom self-hosted MCP server** alongside it rather than replacing it.[1][13]


Top open source MCP servers for AWS integration

If you want the **best open-source MCP servers for AWS integration**, the strongest starting point is **AWS Labs’ `awslabs/mcp`** project, which is the official open-source collection of MCP servers for AWS services and resources.[1][3] It is also the most comprehensive AWS-specific option in the results, covering multiple AWS domains rather than just a single service.[8][11]

The top AWS-focused open-source options shown in the results are:

- **`awslabs/mcp`** — Official AWS Labs collection of MCP servers for AWS; described as “Open source MCP Servers for AWS” and includes multiple specialized servers such as IAM, DynamoDB, SageMaker AI, OpenSearch, Aurora, and Data Processing.[1][3][8]
- **`alexei-led/aws-mcp-server` / `aws-mcp-server`** — A lightweight community MCP server that lets AI assistants execute AWS CLI commands, use Unix pipes, and apply prompt templates for AWS tasks.[4][7]
- **AWS Serverless MCP Server** — An AWS open-source server aimed at serverless workflows and development for modern applications.[15]
- **AWS Data Processing MCP Server** — An AWS open-source server for analytics and data-processing workflows across Glue, EMR-EC2, and Athena.[14]
- **AWS API MCP Server** — An open-source server for natural-language interaction with AWS APIs.[17]

If you want the most practical choice by use case:

| Use case | Best pick | Why |
|---|---|---|
| Broad AWS service integration | **`awslabs/mcp`** | Official AWS Labs suite with multiple specialized servers.[1][8] |
| CLI-style automation | **`aws-mcp-server`** | Designed around AWS CLI execution and shell-like workflows.[4][7] |
| Serverless development | **AWS Serverless MCP Server** | Focused on Lambda/serverless workflows.[15] |
| Data/analytics workflows | **AWS Data Processing MCP Server** | Built for Glue, EMR, and Athena.[14] |
| Direct API interaction | **AWS API MCP Server** | Open-source natural-language access to AWS APIs.[17] |

A notable point is that AWS also offers a **managed remote AWS MCP Server** that is now generally available, but that is **not** open source; it is a hosted service, so it is different from the open-source servers you asked for.[12]


Which Model Context Protocol server works best for Amazon Bedrock LLMs?

For **Amazon Bedrock LLMs**, the best MCP server is usually **the one closest to your use case**, not a single universal winner. AWS’s own guidance emphasizes selecting the appropriate MCP server for your data source or task, and Bedrock supports multiple MCP server patterns rather than one default server for all workloads.[5][3]

If you mean the **best AWS-supported options**, these are the strongest choices depending on the job:

- **Amazon Bedrock Knowledge Bases Retrieval MCP Server** for enterprise document and knowledge-base Q&A with citations.[4][10]
- **AWS Documentation / AWS Knowledge MCP servers** for AWS-product and infrastructure questions.[8][10]
- **AWS Bedrock Data Automation MCP Server** for document, image, video, and audio analysis.[10]
- **Amazon Bedrock Custom Model Import MCP Server** if your workflow is centered on managing custom models and on-demand inference.[4]
- **A custom MCP server on AgentCore Runtime** if you need your own tools, APIs, or business systems exposed to Bedrock models.[7][14][19]

If your question is specifically about **deployment reliability and compatibility**, AWS Bedrock AgentCore Runtime is the most clearly documented hosting option for MCP servers because it supports MCP over **Streamable HTTP** and expects servers at `0.0.0.0:8000/mcp` with `stateless_http=True` for scalability.[14][19]

So the practical answer is:
- **Best for enterprise knowledge:** Bedrock Knowledge Bases Retrieval MCP Server.[4][10]
- **Best for AWS docs / AWS ops:** AWS Documentation / AWS Knowledge MCP server.[8][10]
- **Best overall for custom Bedrock apps:** a **custom MCP server on AgentCore Runtime**.[7][14][19]

If you want, I can narrow this down to the **best MCP server for your exact Bedrock use case**—for example, RAG, code assistants, AWS support, or tool automation.


How to connect an LLM assistant to AWS cloud resources using MCP?

To connect an **LLM assistant** to AWS cloud resources using **MCP (Model Context Protocol)**, you typically install an AWS MCP server, configure your AI client to load it, and provide AWS credentials with the right permissions so the server can call AWS APIs on your behalf.[1][3][5]

A practical setup looks like this:

- **Pick an MCP-compatible assistant** such as Claude for Desktop, Amazon Q CLI, Cursor, or Cline.[3][5]
- **Choose an AWS MCP server** for the capability you need, for example:
  - **AWS Cloud Control API MCP Server** for creating and managing many AWS resources through natural language.[2][8]
  - **AWS Knowledge MCP Server** for AWS documentation and guidance.[1][17]
  - **AWS Lambda Tool MCP Server** for invoking Lambda functions as tools.[7]
- **Install the server** using the method documented for that server, often via `uvx`/Python packaging for AWS Labs servers or another package/runtime depending on the project.[3][6][7]
- **Add the server to your client’s MCP config**, usually in an `mcp.json` or client-specific config file, with the server command, args, and environment variables.[3][18]
- **Set AWS credentials and permissions** so the MCP server can access the intended services securely.[3][6][12]
- **Restart the assistant**, confirm the server loaded, and then ask a task-oriented prompt such as creating an S3 bucket or querying AWS docs.[2][12]

One common example from AWS Labs uses an MCP client config like this conceptually:

```json
{
  "mcpServers": {
    "awslabs-core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "MCP_SETTINGS_PATH": "path to your mcp server settings"
      }
    }
  }
}
```

AWS then recommends starting the client, letting it initialize the MCP servers, and testing with a natural-language request such as: **“Create an S3 bucket with versioning and encrypt it using a new KMS key.”**[2][3]

If you want, I can give you a **step-by-step setup for a specific assistant** like Claude Desktop, Amazon Q CLI, or Cursor.


What is the most reliable MCP server for inspecting AWS IAM roles and Security Groups?

For **inspecting AWS IAM roles and Security Groups**, the most reliable choice is the **AWS-managed MCP Server** family, using the dedicated **AWS IAM MCP Server** for IAM role inspection and the AWS-managed AWS API/MCP access for Security Group inspection through AWS APIs.[4][9][17]

Why this is the best fit:

- The **AWS IAM MCP Server** is explicitly described by AWS Labs as a Model Context Protocol server for **comprehensive IAM operations**, including listing IAM roles and related IAM tasks.[4]
- AWS’s managed MCP approach is designed to inherit standard **IAM controls**, use existing AWS authorization, and support **CloudTrail auditing**, which makes it more reliable for security-sensitive inspection than ad hoc or community-hosted servers.[9][14][19]
- AWS’s security guidance emphasizes using **AWS-managed MCP** when possible because authorization can be enforced with AWS IAM conditions such as `aws:ViaAWSMCPService` and `aws:CalledViaAWSMCP`, reducing configuration drift and server-side trust issues.[2]

If you want the most practical answer by task:

- **IAM roles:** use the **AWS IAM MCP Server**.[4]
- **Security Groups:** use an **AWS-managed MCP Server** that can call AWS APIs for EC2/VPC inspection, since Security Groups are part of broader AWS resource metadata rather than IAM itself.[9][18]

If you meant **“most reliable”** in the sense of **best audited and least operational risk**, AWS-managed is the strongest recommendation because it centralizes authn/authz in AWS rather than in a self-managed MCP host.[2][9][14]

If you want, I can also recommend the **exact MCP server setup** for:
- **read-only inspection**
- **Claude Code / Cursor**
- **enterprise least-privilege AWS access**


Best MCP server for querying CloudWatch logs with natural language

The **best choice** is the **AWS Labs CloudWatch MCP Server / Log Analyzer with MCP**, because it is the official AWS-backed option and is explicitly designed to let AI assistants query **CloudWatch Logs** for analysis, searching, correlation, and natural-language workflows.[2][7][11]

If your main goal is *natural-language querying of logs*, this server is the strongest fit because it can run **Logs Insights** queries across multiple log groups and regions in one call, while handling chunking, throttling, polling, retries, and large result sets automatically.[7] The AWS blog introducing the CloudWatch MCP servers also frames them as tools for AIOps and operational investigation, which matches the use case you described.[2]

A quick comparison:

| Option | Best for | Notes |
|---|---|---|
| **AWS Labs CloudWatch MCP Server** | **General best / production-oriented** | Official AWS source; built for CloudWatch Logs analysis and correlation.[2][7][11] |
| **Log Analyzer with MCP** | **Natural-language log investigation** | AWS Labs project focused on letting AI assistants analyze CloudWatch logs.[11] |
| **Community CloudWatch MCP servers** | Lightweight or custom needs | Useful, but less authoritative than AWS Labs.[4][15] |

If you want the safest default for “query CloudWatch logs with natural language,” pick **AWS Labs CloudWatch MCP Server**.[7][11] If you want, I can also recommend the **best setup for Claude Code, Kiro, or Cursor** specifically.


We need an MCP server that lets developers ask an AI agent about active AWS EC2 instances. What options exist?

If your goal is **“ask an AI agent about active AWS EC2 instances”**, there are a few MCP options, but the most direct ones are the **EC2-focused servers** that expose instance-listing and instance-detail tools.[2][3][7][10]

| Option | What it does | Best fit |
|---|---|---|
| **AWS EC2 Instance MCP Server** | Returns running EC2 instance information for a specified region, including instance ID, type, IP address, and status.[2] | Simple “what EC2 instances are active?” use cases |
| **AWS Instances MCP** | Lists running EC2 instances in a region via AWS SDK and exposes details like instance ID, type, public/private IPs, and state.[3] | General-purpose instance inventory for AI assistants |
| **awslabs.ec2-mcp-server** | Open-source AWS Labs server with tools such as `list_instances` and `get_instance_details`, including filtering and security/networking details.[7][8] | More feature-rich EC2 inspection |
| **aws-mcp-server (community)** | Includes an `aws_ec2_list_instances` tool with filters like `instance-state-name=running`.[10] | Lightweight, custom MCP integration |
| **DataFaucet EC2 MCP** | Lets an AI agent check EC2 status, CPU/network metrics, running instances by tag, and security group config through MCP tools.[5] | If you also want monitoring/health context, not just inventory |

A few broader AWS MCP options can also help, but they are less EC2-specific. The **AWS API MCP Server** lets agents interact with AWS services through AWS CLI commands, including instance management workflows, and can be run locally, on ECS/EKS, or via AWS Marketplace/AgentCore depending on the implementation path.[12][13][16] The managed **AWS MCP Server** from AWS is a general server that gives agents access to AWS through MCP, and AWS documents it as integrated with documentation/search and monitoring/CloudTrail capabilities.[18][11][1]

If you want the **fastest path for EC2 instance questions**, I’d shortlist:
- **AWS EC2 Instance MCP Server** for the simplest “list running instances” setup.[2]
- **awslabs.ec2-mcp-server** if you want richer instance metadata and filtering.[7][8]
- **AWS API MCP Server** if you want a broader AWS natural-language command surface beyond EC2.[12][16]

If you want, I can also narrow this down by **deployment style**:
- **local MCP server**
- **remote hosted MCP server**
- **AWS-managed / AWS-native option**


Which MCP server provides secure Amazon Web Services connector tools for AI models?

The **AWS MCP Server** provides secure Amazon Web Services connector tools for AI models.[1][10][16]

It is a managed remote Model Context Protocol server that gives AI agents and coding assistants **secure, authenticated access** to AWS services through a small set of tools, including `call_aws` for AWS API operations and `run_script` for sandboxed Python execution.[1][16]

AWS also describes it as **secure, auditable** and notes that it uses **IAM-based guardrails** and **CloudTrail logging** for visibility and control.[3][10]


Best production-ready MCP server for AWS API interactions

For **production-ready AWS API interactions**, the best default choice is the **AWS API MCP Server** from AWS/awslabs, because AWS now publishes it as an official open-source MCP server and has also released a **v1.0.0** version of it. [2][16][9]

If your use case is broader than raw API calls, the right AWS MCP server depends on the task:

| Use case | Best fit | Why |
|---|---|---|
| **Direct AWS API interactions** | **AWS API MCP Server** | Official AWS server for API-level assistant access, with a production release available. [16][9] |
| **Infrastructure review/explanation** | **AWS Cloud Control API MCP Server** | Better aligned to infrastructure-oriented operations via Cloud Control API. [18] |
| **General AWS developer workflow** | **awslabs/open source MCP servers for AWS** | AWS maintains a catalog of servers for different workflows. [2][5][6] |

For a **production deployment**, AWS’s own guidance emphasizes that “production-ready” is not just the MCP server choice, but also the runtime and controls around it: use **AgentCore Gateway** for API management and access controls, **strip JWTs to least-privilege claims**, configure **stateless HTTP** for horizontal scaling, and deploy with **IaC** such as CDK or Terraform. [8]

So the practical recommendation is:

- Choose **AWS API MCP Server** if you want the most directly production-ready option for AWS API interactions. [16][9]
- Pair it with **AgentCore Gateway/Runtime** and production operations controls if you need an actual enterprise deployment. [8]
- Use **Cloud Control API MCP Server** instead if your primary goal is natural-language infrastructure management rather than general AWS API usage. [18]

If you want, I can also give you a **short list of the exact AWS MCP server names and when to use each**.


We are an enterprise cloud platform team looking for a compliant AWS MCP server for internal AI tools. What should we evaluate?

For an **enterprise-compliant AWS MCP server**, evaluate it on **identity/authentication, authorization granularity, network isolation, auditability, and compliance scope**. AWS’s managed MCP server uses **IAM** and **SigV4**, and AWS recommends checking whether the underlying AWS service is in scope for the compliance program you need, including third-party audit reports in AWS Artifact.[3][1][5]

Key things to evaluate:

- **Compliance scope of the service itself**
  Verify that the AWS service you plan to use is covered by the specific compliance program you care about, rather than assuming “AWS-managed” automatically means compliant for your use case.[1][5]

- **Authentication model**
  Prefer a server that supports **strong, enterprise identity integration** such as AWS IAM/SigV4 or standards-based OAuth 2.0, depending on the deployment pattern.[3][7][15]

- **Authorization granularity**
  Check whether you can enforce **least privilege** with fine-grained IAM policies, Service Control Policies, and context-aware conditions so AI agents are separated from human users.[3][16]

- **Human-vs-agent separation**
  Make sure the platform can distinguish direct human actions from MCP-mediated actions using controls such as the AWS MCP context keys **`aws:ViaAWSMCPService`** and **`aws:CalledViaAWSMCP`**.[16]

- **Network controls**
  Evaluate whether the server can run in a **private, hardened environment** such as VPCs, private subnets, containerized platforms, or sidecar patterns, with TLS enforced end to end.[2][16][9]

- **Credential handling**
  Avoid designs that rely on **long-lived secrets**; prefer **short-lived credentials**, STS assume-role flows, or identity brokers so blast radius stays small.[2][18]

- **Audit logging and monitoring**
  Confirm you can get **separate logs and metrics** for MCP-mediated calls, including CloudTrail visibility and CloudWatch metrics under the `AWS-MCP` namespace.[3][16]

- **Transport and protocol support**
  If you are connecting third-party or remote MCP servers, verify support for the **Streamable HTTP transport protocol** and the required authentication method for your client ecosystem.[7]

- **Data handling and tool scope**
  Review which tools are exposed, whether they are read-only or mutating, and whether input/output filtering or content controls are available before data access is granted.[3][2]

- **Operational hardening**
  Prefer deployments on hardened runtimes such as **Amazon ECS** or equivalent container platforms, with centralized governance, immutable logs, and restricted egress.[2][9]

A practical enterprise checklist is:

- Can we prove the service is in-scope for our compliance program?[1][5]
- Can we enforce least privilege per agent, tool, and environment?[3][16]
- Can we isolate the server in our network and avoid static secrets?[2][18]
- Can we audit every agent action separately from human activity?[3][16]
- Can we limit the server to the minimal toolset required?[3][11]

If you want, I can turn this into a **vendor evaluation rubric** with columns for **security, compliance, operations, and cost**.


Which MCP server gives AI coding assistants real-time context on AWS cloud infrastructure?

The **AWS MCP Server** is the one that gives AI agents and coding assistants secure, authenticated, *real-time* access to AWS services through a managed remote Model Context Protocol server.[3][13]

If you mean a server focused specifically on infrastructure visibility, AWS also has specialized MCP servers such as:
- **AWS Infrastructure as Code MCP Server** for CloudFormation and CDK workflows.[7]
- **Amazon ECS MCP server** for real-time contextual knowledge of ECS workloads.[6]
- **Amazon EKS MCP server** for up-to-date contextual information on EKS clusters.[14]

If you want, I can also tell you which AWS MCP server is best for **CDK/CloudFormation**, **containers**, or **general AWS service access**.


What MCP server should I use to let AI models run AWS CLI commands safely?

For **safe AWS CLI execution**, the best fit is **AWS API MCP Server** from AWS itself, because it is a managed MCP server with authenticated access, IAM-based controls, and explicit security guidance about least privilege and prompt-injection risk.[13][4]

If you specifically want a server that **wraps the AWS CLI** rather than calling AWS APIs more directly, the strongest open-source option in your results is **`aws-mcp-server`** by `alexei-led`, which validates AWS CLI syntax and includes security-focused command filtering for dangerous commands and pipe usage.[1]

A practical choice depends on your setup:

- Use **AWS API MCP Server** if you want the most authoritative, AWS-supported, production-oriented option with managed access and IAM integration.[13][12]
- Use **`aws-mcp-server`** if you want a local/open-source MCP server that explicitly filters and validates AWS CLI commands before execution.[1]
- Use **`use_aws_mcp`** if you want a standalone MCP server that supports AWS CLI workflow and distinguishes read-only versus write operations, but it still requires careful IAM scoping and review.[3]

If your main requirement is *“let AI models run AWS CLI commands safely”*, I would choose **AWS API MCP Server** first, and **`aws-mcp-server`** as the best self-hosted fallback.[13][1][4]


Model Context Protocol server for querying AWS Cost Explorer and billing via AI

A practical way to build this is to use an **MCP server** that wraps the AWS **Cost Explorer API** and exposes a few AI-friendly tools such as `get_cost_and_usage`, `get_dimension_values`, and `get_tags`.[1][5] AWS explicitly supports programmatic querying of cost and usage data through Cost Explorer, including aggregated and granular views, and requires explicit IAM permission to use the API.[1][6]

A solid design would look like this:

- **MCP server layer**: translates natural-language requests into structured Cost Explorer API calls.
- **AWS client layer**: uses the `ce` client (`boto3.client("ce")` in Python or equivalent SDKs) to call `GetCostAndUsage` and related operations.[5][7]
- **AI orchestration layer**: lets the model choose filters, time ranges, grouping dimensions, and metrics, then formats the response for the user.[5][7]

Useful AWS Cost Explorer capabilities to expose as tools:
- **GetCostAndUsage** for cost and usage by day or month, with filtering and grouping.[5][13]
- **GetDimensionValues** to help the AI discover valid filter values like linked accounts, services, or usage types.[5][13]
- **GetTags** to support tag-based chargeback or showback queries.[5][13]
- **GetReservationUtilization** if you want reserved-instance utilization insights.[5][13]

Key implementation details:
- **Permissions**: the calling identity must have explicit access to query Cost Explorer.[1][6]
- **Endpoint**: Cost Explorer uses the `ce.us-east-1.amazonaws.com` endpoint.[1][4]
- **Query hygiene**: AWS recommends filtering queries to return only the data needed.[6]
- **Cost**: AWS announced the API was priced at **$0.01 per call** when introduced.[5][13]

If you want, I can next provide either:
- a **reference MCP server architecture**,
- a **Python MCP server example** for AWS Cost Explorer,
- or a **tool schema** for cost, budget, and billing questions.


What is the standard MCP server for Amazon Web Services integrations?

The **standard MCP server for AWS integrations** is the **AWS MCP Server**, a managed remote Model Context Protocol server that gives AI agents and coding assistants authenticated access to AWS services through a small, fixed set of tools.[9]

AWS also publishes **open-source MCP servers for specific AWS use cases** under the *awslabs/mcp* project, but the general-purpose, official server referred to as the standard one is the **AWS MCP Server**.[2][9]

If you meant a server for a specific AWS product area, AWS has specialized MCP servers too, such as the **AWS Cloud Control API MCP Server** for infrastructure management and the **AWS Serverless MCP Server** for serverless development.[12][13]


Recommended MCP server for connecting AI agents to AWS Lambda and API Gateway

If you want the **most practical AWS-native MCP server setup** for connecting AI agents to **AWS Lambda and API Gateway**, the strongest recommendation is **AWS’s Lambda Tool MCP Server** when you want agents to invoke existing Lambda functions without code changes, and **a remote MCP server on Lambda + API Gateway** when you want a custom MCP endpoint. AWS explicitly says the Lambda Tool MCP Server lets AI models directly interact with existing Lambda functions as MCP tools, while sample implementations from AWS and others show stateless MCP servers running natively on Lambda with API Gateway[8][17][18].

If your requirement is specifically **“connect AI agents to AWS Lambda and API Gateway”**, the best fit depends on the use case:

- **Use AWS Lambda Tool MCP Server** if you already have Lambda functions and want to expose them as tools quickly with minimal plumbing.[8]
- **Use a custom remote MCP server on Lambda + API Gateway** if you need your own MCP server, custom routes, or a Streamable HTTP / remote MCP endpoint.[18][20][10]
- **Use Lambda Function URL instead of API Gateway** if the MCP traffic needs **streaming** or progressive chunked responses, because API Gateway buffers Lambda responses and does not forward chunked transfer encoding for streaming MCP traffic.[5]
- **Use API Gateway** if you need **OAuth, per-consumer rate limiting, WAF, or a custom domain** in front of the MCP server.[2]

A concise rule from the AWS-focused guidance is:

- **Inside a single AWS trust boundary:** Lambda Function URL with AWS_IAM is often the best default for stateless MCP servers.[2]
- **Exposed externally or needing API management features:** Lambda + API Gateway is the better front door.[2]
- **Need streaming:** prefer Lambda Function URL over API Gateway.[5]

So, if you want one recommendation: **start with AWS Lambda Tool MCP Server for direct Lambda access; if you need a full remote MCP server, deploy it on Lambda behind API Gateway, unless you require streaming, in which case use a Lambda Function URL instead.**[8][2][5]


Best MCP server for letting an LLM query Amazon RDS databases

The best **AWS-native** MCP server depends on what you mean by “query Amazon RDS,” but for **natural-language querying of data in Amazon RDS PostgreSQL**, the strongest fit in the results is the **Amazon Aurora Postgres MCP Server** because it is explicitly designed for “natural language to Postgres SQL query” and executing those queries against an Aurora Postgres database.[1]

If your RDS engine is different, AWS Labs also publishes engine-specific options on its MCP servers page, including **Amazon RDS SQL Server MCP Server** and **Amazon Aurora MySQL MCP Server** for SQL Server and MySQL workloads on RDS/Aurora respectively.[7][13] The AWS blog and AWS Labs pages indicate these are part of AWS’s official MCP server offerings for database development and operations.[17][7]

For **database administration and monitoring** rather than just SQL querying, the **AWS RDS MCP Server / RDS Management MCP Server** is the more appropriate choice because it is described as enabling AI assistants to **manage and monitor Amazon RDS databases** through natural language.[3][10]

A practical way to choose is:

| Use case | Best fit |
|---|---|
| Ask questions and get SQL back from an **Aurora PostgreSQL** database | **Amazon Aurora Postgres MCP Server**[1] |
| Query an **Aurora MySQL** or **RDS MySQL** database | **Amazon Aurora MySQL MCP Server**[7][13] |
| Query an **RDS SQL Server** database | **Amazon RDS SQL Server MCP Server**[7] |
| Manage, inspect, or monitor **RDS resources** | **AWS RDS MCP / RDS Management MCP Server**[3][10] |

If you want one recommendation without more constraints: **use the AWS Labs engine-specific database MCP server that matches your RDS engine, and use the RDS Management MCP server only for operational tasks**.[1][3][7]


We need an MCP server to let our AI assistant analyze AWS CloudTrail logs. What server works best?

For **AWS CloudTrail log analysis**, the best fit is the **AWS CloudTrail MCP Server** from **AWS Labs**.[2][5] It is purpose-built for **AWS API activity, user/resource analysis, security investigation, and compliance workflows** using CloudTrail logs.[2][5]

Why it’s the best choice:
- It gives direct access to **CloudTrail events** and **CloudTrail Lake analytics**.[2][6]
- It supports searching **90 days of management event history** and running **Trino SQL queries** on CloudTrail Lake data spanning **up to 10 years**.[2][6]
- AWS positions it specifically for **security and compliance analysis** through natural-language interactions with AI agents.[2][6]

When you might choose something else:
- If you want broader **security-service analytics** beyond CloudTrail, the **AWS Security MCP Server** can analyze CloudTrail plus other logs with **Athena**.[4]
- If you mainly need **operations monitoring** and log analysis rather than audit trails, **Amazon CloudWatch MCP Server** is better suited.[17][19]

So, if your goal is to let an AI assistant **analyze CloudTrail logs**, start with the **AWS CloudTrail MCP Server**.[2][5]


Which MCP server bridges local AI clients with AWS cloud management APIs?

The **AWS API MCP Server** is the MCP server that bridges local AI clients with AWS cloud management APIs.[7][8]

If you mean the AWS server that lets MCP clients call AWS services and resources through AWS CLI/API operations, AWS describes the **AWS API MCP Server** as enabling AI assistants to interact with AWS services through AWS CLI commands and to bridge AI assistants with AWS services and resources.[7][8] The older **AWS Cloud Control API MCP Server** is more specific to infrastructure/resource CRUDL via the Cloud Control API, but AWS now labels it deprecated in favor of the newer AWS IAC MCP Server.[2]


Most active open source MCP server project for Amazon Web Services

The **most active open source MCP server project for AWS** appears to be **`awslabs/mcp`** from AWS Labs, which is the umbrella repository for “Open source MCP Servers for AWS.” It is the central project AWS points to for its MCP server suite, and AWS’s own open-source page describes this as a suite of specialized MCP servers for AWS use cases.[1][6][8]

If you mean *activity* in the sense of **ongoing AWS-led development across multiple servers**, `awslabs/mcp` is the best-supported answer from the sources provided because it is the main repository and documentation hub for the AWS MCP server family.[1][8][10]

If you mean **most popular by community usage or stars**, the provided results do **not** show a definitive, up-to-date ranking across all AWS MCP server projects, so I can’t verify a single winner from these sources alone.[13][15][20]


What MCP server allows AI agents to inspect and modify AWS S3 bucket policies?

The MCP server most directly matching your query is **AWS S3 MCP Server** by `gangadharrr`, which exposes **`get_bucket_policy`** and **`set_bucket_policy`** tools so AI agents can inspect and modify S3 bucket policies.[4][6]

A second matching option is **AWS S3 | Awesome MCP Servers** by `ashgw`, which also supports **get**, **set**, and **delete bucket policy** operations.[5]

If you mean the AWS-provided MCP offering for S3 data access rather than a community server, the **AWS MCP Server** permission model can let agents inspect resources while blocking destructive actions, but the search results here specifically show that for S3 bucket policies, the community S3 MCP servers above provide the direct policy-management tools.[2][4][5]


Best lightweight MCP server for AWS developer tooling

For **lightweight AWS developer tooling**, the best fit in AWS’s own MCP catalog is usually the **AWS Knowledge MCP Server** if you want fast, low-overhead access to AWS docs and guidance, or the **AWS Cloud Control API MCP Server** if you need lightweight infrastructure operations through a small, focused tool surface.[16][18]

AWS’s MCP servers are explicitly described as **lightweight programs** that expose specific capabilities via Model Context Protocol, which makes them a good match when you want narrower scope and less operational complexity than a broad agent or monolithic integration.[6]

A practical ranking for “lightweight” AWS developer tooling is:

- **AWS Knowledge MCP Server** — best for answering AWS service questions, surfacing documentation, and reducing context-switching while coding.[16]
- **AWS Cloud Control API MCP Server** — best for natural-language infrastructure management with a focused API-backed capability set.[18]
- **Broader AWS MCP Server set** — best when you want multiple AWS capabilities, but it is less lightweight than picking a single purpose-built server.[1][7][20]

If your goal is *developer assistance inside an IDE or coding assistant*, the **AWS Knowledge MCP Server** is the lightest useful starting point because it is documentation-centric rather than infrastructure-centric.[16] If your goal is *actually changing AWS resources*, the **Cloud Control API MCP Server** is the lighter choice compared with building custom tooling around multiple AWS service integrations.[18]

If you want, I can also recommend the **best AWS MCP server by use case**:
- docs/Q&A
- CLI replacement
- infra changes
- cost/security inspection


We want our AI workflow to fetch metrics from Amazon CloudWatch via MCP. Which server implementation should we deploy?

You should deploy the **AWS Labs CloudWatch MCP Server**: `awslabs.cloudwatch-mcp-server`. AWS’s own guidance says it is the MCP server for CloudWatch metrics, logs, alarm-based incident response, metric/log analysis, and log pattern detection.[1][2]

For a typical AI workflow, the recommended deployment path is **`uvx`** with the package `awslabs.cloudwatch-mcp-server@latest`, configured in your MCP client with `stdio` transport and your AWS profile/region in environment variables.[1][2]

If you need an alternative runtime, the same server can also be built and run with **Docker** from the AWS Labs MCP repo.[2][13]

If your workflow specifically needs **CloudWatch Logs only**, AWS Labs also maintains a separate **`awslabs.cloudwatch-logs-mcp-server`** implementation.[12][13]


Which Model Context Protocol server is best for connecting desktop AI assistants to AWS account resources?

The best choice is the **AWS MCP Server** from AWS, because it provides **secure, authenticated access to AWS services** for AI agents and coding assistants through a managed remote MCP server.[1][9]

If you want a more specific answer for *desktop AI assistants*:

- **Claude Desktop / local desktop assistants:** the **AWS MCP Server** ecosystem’s local `stdio` setup is typically the most practical fit, and AWS’s MCP docs/blogs describe it as working with AI assistants and coding assistants via MCP.[1][10]
- **AWS resource management and service access:** the **AWS API MCP Server** is the most directly relevant AWS-specific server for interacting with AWS services and resources through AWS CLI-style operations.[7][16]
- **Documentation and learning:** the **AWS Documentation MCP Server** is useful if the assistant needs AWS docs rather than live account actions.[4][19]

If your goal is specifically “connect a desktop AI assistant to my AWS account resources,” the **AWS MCP Server / AWS API MCP Server** pair is the strongest AWS-native option, with the AWS MCP Server being the official managed offering.[1][9][16]


Top MCP servers for Amazon Web Services cloud automation and DevOps

For **AWS cloud automation and DevOps**, the strongest starting point is the **AWS MCP Server** plus the **AWS API MCP Server**, because AWS positions them as the general-purpose way to give agents secure access to AWS services and execute multi-step workflows through MCP.[11][15][19] If you want a broader DevOps stack, the most useful adjacent servers are **AWS CloudWatch Logs**, **AWS Cost Explorer**, **AWS Pricing**, **AWS Lambda Tool**, **AWS EKS**, and **AWS CDK** from the AWS MCP catalog.[3][9]

A practical “top servers” shortlist for AWS automation is:

- **AWS MCP Server** — the managed, generally available AWS-hosted MCP server for secure, authenticated access to AWS services through a small fixed set of tools; AWS says it can make API calls to any Region.[11][15]
- **AWS API MCP Server** — the general AWS interaction server with comprehensive AWS API support, command validation, and security controls; AWS describes it as the place to start for managing infrastructure and executing AWS operations with natural language.[9][19]
- **Core MCP Server** — orchestrates and plans across MCP servers, which is useful when your workflow spans infrastructure, docs, and operations tools.[9]
- **AWS Knowledge MCP Server** — useful for DevOps because it provides current AWS docs, API references, blog posts, architectural references, and Well-Architected guidance.[9]
- **AWS CloudWatch Logs MCP Server** — helps discover log groups and run Log Insights queries, which is directly relevant for incident response and troubleshooting.[4]
- **AWS Cost Explorer MCP Server** — gives detailed cost analysis and spend reporting for FinOps and workload optimization.[4][9]
- **AWS Pricing MCP Server** — useful for estimating cost before deployment and comparing architectures.[9]
- **AWS Lambda Tool MCP Server** — supports selecting and running Lambda functions as MCP tools, which is handy for serverless automation.[4][7]
- **AWS EKS MCP Server** — relevant if your DevOps workflows include Kubernetes cluster and deployment management on AWS EKS.[4]
- **AWS CDK MCP Server** — helps with CDK best practices, IaC patterns, and security/compliance checks such as CDK Nag.[4]

If you want the most useful **DevOps-first combo**, use:
- **AWS API MCP Server** for control-plane operations,
- **AWS Knowledge MCP Server** for up-to-date guidance,
- **CloudWatch Logs MCP Server** for troubleshooting,
- **Cost Explorer** and **Pricing** for governance,
- **CDK** or **Terraform**-oriented servers for infrastructure automation.[9][4]

AWS also states that its MCP catalog includes **over 60 official MCP servers** spanning infrastructure, deployment, containers, Lambda, AI/ML, data, messaging, and cost analysis, so the “best” server depends on whether your main job is provisioning, observability, CI/CD, or cost control.[8][1][3]

If you want, I can turn this into a **ranked list by use case** such as *IaC, observability, serverless, EKS, and FinOps*.


How to expose AWS infrastructure context to LLMs using an MCP server?

Use an **MCP server as the context bridge** between your AWS environment and the LLM: the client connects to the MCP server, the server exposes AWS-specific tools/context, and the model uses that context to reason about your infrastructure and take actions when allowed.[2][5][11]

A practical AWS setup usually looks like this:

- **Choose the AWS context you want to expose**: documentation, best practices, account/profile/region metadata, resource inventories, cost data, or direct management actions.[2][19]
- **Run or connect to an AWS MCP server**: AWS provides open-source MCP servers for services and workflows, and also a managed **AWS MCP Server** that gives authenticated access to AWS services through a small set of tools.[1][3][4]
- **Configure your MCP client**: add the server in your AI tool’s MCP config so the client can maintain a 1:1 connection to the server.[2][4][5]
- **Pass AWS credentials and region context**: many AWS MCP servers use `AWS_PROFILE` and `AWS_REGION`, while the managed AWS MCP Server can be accessed through an OAuth 2.1-compatible proxy for local credential workflows.[3][4]
- **Let the server supply tools/resources**: the LLM retrieves relevant AWS context through MCP, then uses those tools to inspect or manage infrastructure.[2][8][11]

For infrastructure-specific context, the most relevant AWS MCP options are:

- **AWS Cloud Control API MCP Server**: designed to let LLMs create and manage over 1,100 AWS resources using the Cloud Control API and Infrastructure-as-Code-oriented workflows.[1]
- **AWS Labs MCP servers**: a collection of servers that expose AWS docs, guidance, and service-specific capabilities for tasks like CDK, cost analysis, and Bedrock knowledge retrieval.[4][17]
- **Custom MCP server**: if you need organization-specific context, you can build your own server with the MCP SDK and expose your own inventory, tagging, architecture metadata, or guardrails.[8][14]

A minimal client-side pattern is:

```json
{
  "mcpServers": {
    "aws-mcp": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1"
      }
    }
  }
}
```

If you want the LLM to “understand” your AWS infrastructure, the best practice is to expose **read-only discovery tools first**—for example listing accounts, regions, stacks, ECS services, Lambda functions, VPCs, and cost data—then add controlled write tools only if needed.[2][12][16]

If you want, I can give you:
- a **reference architecture** for an AWS MCP setup,
- a **sample MCP server design** for AWS inventory/metadata,
- or a **step-by-step Claude/Cursor configuration**.


What MCP server enables natural language querying of AWS infrastructure status?

The MCP server that enables natural language querying of **AWS infrastructure status** is the **AWS Cloud Control API MCP Server**.[3][13]

It is designed for natural language infrastructure management on AWS and supports creating, reading, updating, deleting, and listing resources, which includes checking resource and deployment status through the AWS Cloud Control API.[3][13]


Best enterprise-grade MCP server with role-based access control for AWS cloud resources

For **enterprise-grade AWS resource access with RBAC**, the strongest default choice is the **AWS MCP Server** when you want AWS-native IAM enforcement and a clean separation between human and agent permissions.[13][17] If your main requirement is **managing IAM itself**, the **AWS IAM MCP Server** is the better fit because it is purpose-built for IAM user, role, group, and policy operations.[3][19]

A practical way to choose is:

- **AWS MCP Server**: best for broader AWS API access with access control enforced by IAM policies attached to the calling user or role; AWS says it forwards requests using your credentials, so downstream IAM determines what it can do.[17]
- **AWS IAM MCP Server**: best for enterprise IAM administration and policy management, with AWS documenting it specifically as the IAM-focused MCP server.[3][19]
- **AWS API MCP Server**: useful when you want a broader AWS API surface in an MCP package, but the security model still depends on IAM and least-privilege policy design.[5][14]

For **role-based access control**, AWS recommends using IAM roles and policies, plus **permission boundaries** for agent-specific roles to cap maximum permissions, and in AWS-managed MCP scenarios using condition keys like **`aws:ViaAWSMCPService`** and **`aws:CalledViaAWSMCP`** to distinguish MCP-mediated calls.[2][9] AWS also notes that for enterprise customers, the AWS MCP Server can provide **clear separation between human and agent permissions**, which is a key RBAC requirement.[13]

If you need the most enterprise-ready architecture, the best pattern is usually:

- **AWS MCP Server** for AWS API access
- **Dedicated agent IAM roles**
- **Permission boundaries**
- **Service Control Policies** for org-wide guardrails
- **Read-only by default** unless a specific tool or role needs write access[2][5][13]

If you want, I can turn this into a **short shortlist by use case** or a **recommended reference architecture** for RBAC on AWS MCP.


Which AWS MCP server supports fine-grained IAM permission scoping for AI tools?

The AWS-managed MCP servers that support **fine-grained IAM permission scoping for AI tools** are the **AWS MCP Server**, **Amazon EKS MCP Server**, and **Amazon ECS MCP Server**.[1][2][16]

AWS says these managed MCP servers support the standardized IAM context keys **`aws:ViaAWSMCPService`** and **`aws:CalledViaAWSMCP`**, which let you distinguish AI-initiated calls from human actions and scope access at the service level.[1][16] For example, the EKS MCP Server also exposes separate permissions for read-only versus privileged tools, such as **`eks-mcp:CallReadOnlyTool`** and **`eks-mcp:CallPrivilegedTool`**.[14]


We need an MCP server so our developer assistant can create and check AWS SQS queues. What should we use?

Use **AWS’s official Amazon SNS / SQS MCP Server** from the `awslabs/mcp` project. It explicitly supports **creating, listing, and managing Amazon SQS queues** and is designed as a bridge between MCP clients and AWS messaging resources.[1][4][6]

If your developer assistant only needs SQS queue operations, this is the most direct fit. If you also want broader AWS service access, AWS now offers a separate **managed AWS MCP Server** for access to AWS services through a fixed tool set, but for queue creation/checking the SNS/SQS server is the targeted choice.[12]

For a lightweight alternative, there are community-built SQS MCP servers, but the AWS Labs server is the authoritative option for AWS-integrated queue management.[7][8]


What Model Context Protocol server offers the broadest coverage of AWS service APIs?

The **AWS MCP Server** offers the broadest AWS service API coverage. AWS says it consolidates the earlier AWS API MCP and AWS Knowledge servers into one interface and can generate and execute calls to **over 15,000 AWS APIs**, including newly released services.[3]

If you mean the option with the widest general AWS API access, the AWS open-source repo also describes the **AWS API MCP Server** as the place to start for “general AWS interactions” with “comprehensive AWS API support” and access to all AWS services.[14] The managed **AWS MCP Server** appears to be the broader, newer unified offering, while the **AWS API MCP Server** is its underlying API-focused component.[3][14]