AWS Cloud Resource Enablers via MCP

Introduction

This repository provides a comprehensive suite of specialized AWS Model Context Protocol (MCP) Servers. These servers integrate critical AWS functionalities, documentation, and operational knowledge directly into applications utilizing the Model Context Protocol (MCP). MCP itself is an open specification established by Anthropic, PBC, ensuring standardized communication between LLM interfaces and external data sources. Integrating these official AWS servers enhances the utility of AI assistants, much like a robust parser generator framework ensures predictable interpretation of complex inputs across different tools.

Related Topics

• Model Context Protocol (MCP) Specification
• Incremental Parsing (Conceptual relation to context updates)
• Amazon Web Services (AWS) Ecosystem
• Cloud Development Kit (CDK) and Infrastructure as Code (IaC)
• Retrieval-Augmented Generation (RAG) Patterns

Server Functionality Overview

AWS MCP Servers act as lightweight intermediaries, translating high-level natural language requests into precise, context-aware cloud operations or data retrievals. This architecture supports official integrations across various development paradigms.

Critical Transport Note: Support for Server Sent Events (SSE) was discontinued in the latest major versions as of May 26th, 2025. Future development focuses on supporting Streamable HTTP transport methods, aligning with evolving MCP specifications.

Why Use AWS MCP Servers?

These tools deliver several key enhancements for AI-assisted cloud development. They significantly reduce model hallucinations by supplying real-time, verified AWS details. Models gain immediate access to the most current service documentation, APIs, and SDK information, overcoming training data latency. Furthermore, they translate common cloud engineering tasks, such as Terraform deployments or CDK stack creation, into executable actions for the connected AI agent, boosting workflow efficiency.

Available MCP Servers: Quick Installation

Direct installation links are provided below for immediate use with popular MCP clients like Cursor and VS Code, utilizing the uvx package runner.

🚀 Initial Configuration

For general AWS interaction, start with the API and Knowledge servers.

Server Name	Description	Install
AWS API MCP Server	Handles general AWS operations, validating commands and accessing most AWS services for resource management.
AWS Knowledge MCP Server	A managed remote server providing current AWS documentation, blogs, and architectural references.

🏗️ Infrastructure & Deployment Tools

Servers facilitating Infrastructure as Code (IaC) and container operations are listed here.

Server Name	Description	Install
AWS CDK MCP Server	Assists with AWS CDK development, enforcing security and best practices.
AWS Terraform MCP Server	Integrates security scanning into Terraform workflow management.
Amazon EKS MCP Server	Facilitates Kubernetes cluster administration and application deployment.

🤖 AI/ML and Data Integration

Servers focused on augmenting AI responses with enterprise data and knowledge.

Server Name	Description	Install
Bedrock KB Retrieval MCP Server	Queries enterprise knowledge bases with required citation support for RAG applications.
Amazon DynamoDB MCP Server	Enables full operational control over DynamoDB tables.
Amazon Aurora PostgreSQL MCP Server	Executes PostgreSQL queries against RDS via the Data API.

🛠️ Workflow and Automation Tools

Servers supporting broader development and operational tasks.

Server Name	Description	Install
AWS Lambda Tool MCP Server	Allows the AI to invoke specific Lambda functions as verifiable tools.
AWS Step Functions Tool MCP Server	Executes and manages complex, multi-step business workflows.
AWS Pricing MCP Server	Provides AWS service costs and estimation capabilities.

MCP AWS Lambda Handler Module

A Python library exists to simplify creating serverless HTTP handlers for the Model Context Protocol using AWS Lambda. This specific component aids in building robust, scalable MCP endpoints within a serverless context. It features pluggable session management, including a native DynamoDB backend, accelerating serverless deployment.

Refer to src/mcp-lambda-handler/README.md for detailed installation and usage guides for this specific module.

Configuration Details: Local vs. Remote Deployment

Users must choose between running servers locally or remotely for optimal workflow integration.

Local MCP Servers

Execute servers directly on your workstation for immediate debugging and low-latency interaction. This is suitable for individual development tasks and environments with restricted network access. You maintain granular control over server state and environment variables.

Remote MCP Servers

Remote execution promotes team consistency and allows intensive background tasks to utilize dedicated cloud resources. Managed services, such as the AWS Knowledge MCP Server, require zero infrastructure setup; you only need client configuration to connect.

Installation and Setup Procedures

General setup involves securing the uv package runner and configuring AWS credentials. Each server documentation specifies unique parameters required for initialization.

1. Acquire the uv toolset via Astral.
2. Install a compatible Python version using the tool, for instance: uv python install 3.10.
3. Verify your AWS credentials grant necessary permissions for the intended services.
4. Integrate the server definition into your client's configuration file.

For global configuration within the Amazon Q Developer CLI, modify ~/.aws/amazonq/mcp.json:

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": [
        "awslabs.core-mcp-server@latest"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

If operating on Windows, the configuration requires explicit details for the standard I/O transport:

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "disabled": false,
      "timeout": 60,
      "type": "stdio",
      "command": "uv",
      "args": [
        "tool",
        "run",
        "--from",
        "awslabs.core-mcp-server@latest",
        "awslabs.core-mcp-server.exe"
      ],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

To confirm argument correctness or troubleshoot timeouts, manual execution with a time limit is useful:

# Execute server manually with a 15-second cutoff
$ timeout 15s uv tool run <MCP Name> <args> 2>&1 || echo "Command completed or timed out"

# Example: Checking Aurora MySQL arguments
$ timeout 15s uv tool run awslabs.mysql-mcp-server --resource_arn <Your Resource ARN> --secret_arn <Your Secret ARN> ... 2>&1 || echo "Command completed or timed out"

# A common failure indicates missing required arguments:
usage: awslabs.mysql-mcp-server [-h] --resource_arn RESOURCE_ARN --secret_arn SECRET_ARN --database DATABASE
                                --region REGION --readonly READONLY
awslabs.mysql-mcp-server: error: the following arguments are required: --resource_arn, --secret_arn, --database, --region, --readonly

Running Servers in Containers

AWS MCP Server executables are available as images in the public AWS ECR registry under public.ecr.aws/awslabs-mcp/. Container execution requires explicit mapping of environment variables and persistent storage.

For the awslabs.nova-canvas-mcp-server:

1. Create a .env file locally to store any required AWS temporary credentials securely.

2. Configure the MCP client to use docker run with necessary flags like --env-file and --volume:

json { "mcpServers": { "awslabs.nova-canvas-mcp-server": { "command": "docker", "args": [ "run", "--rm", "--interactive", "--env", "FASTMCP_LOG_LEVEL=ERROR", "--env", "AWS_REGION=us-east-1", "--env-file", "/full/path/to/.env", "--volume", "/full/path/to/.aws:/app/.aws", "public.ecr.aws/awslabs-mcp/awslabs/nova-canvas-mcp-server:latest" ], "env": {} } } }

Local testing of new server builds involves building and tagging the image directly, updating the configuration's image reference accordingly.

Installation Guides for Specific Clients

Specific setup instructions exist for various integrated development environments (IDEs) and CLIs.

Amazon Q Developer CLI Setup

Refer to the official Amazon Q Developer documentation for comprehensive guidance.

Configuration can be managed via the Q Developer UI panel or directly editing ~/.aws/amazonq/mcp.json (global) or .amazonq/mcp.json (project-local).

Kiro Integration

Within the Kiro IDE, access the configuration via Kiro > MCP Servers, then use the + Add button or edit kiro_mcp_settings.json.

Cline and Amazon Bedrock Integration

Utilizing Cline with Amazon Bedrock requires enabling the specific Foundation Models (FMs) in your AWS account under Amazon Bedrock access settings. Costs may apply based on Bedrock usage.

1. Complete the prerequisite uv installation and AWS credential setup.
2. Install the Cline VS Code Extension if using VS Code, selecting the tier that permits Bedrock API usage.
3. Access the MCP Servers section in the Cline panel and open cline_mcp_settings.json.
4. Add server definitions, ensuring the environment variables include configuration paths if necessary:

For macOS/Linux in cline_mcp_settings.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 settings file"
      }
    }
   }
  }
 ```

5. After saving, confirm activation in the Installed tab.
6. Switch Cline's API Provider from its default to **AWS Bedrock**, using the AWS Profile for authentication; this is preferred over static keys for superior security.
7. In Cline settings, configure your AWS Profile details and Region. Enabling cross-region inference is often beneficial.
8. Paste the following directive into the Custom Instructions box to force the use of the `mcp-core` server first:

For every new project, always look at your MCP servers and use mcp-core as the starting point every time. Also after a task completion include the list of MCP servers used in the operation.

9. Test functionality. While the default `Plan` mode provides actionable outputs, the `Act` toggle allows the assistant to execute actions autonomously. It is advised to keep the **Auto-approve** feature disabled during initial validation.

### Cursor Integration

Cursor supports configuration in two scopes: project-specific (`.cursor/mcp.json`) or globally (`~/.cursor/mcp.json`).

Configuration example for global setup:

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

Cursor's Composer Agent will attempt to select relevant tools automatically. Explicit invocation is possible by instructing Cursor: Using the Terraform MCP Server, do....

Windsurf Configuration

Windsurf settings are accessible via the Command Palette or Advanced Settings panel. Custom configuration resides in ~/.codeium/windsurf/mcp_config.json.

Additional Resources

• Official Launch Announcement: Introducing AWS MCP Servers for Code Assistants
• Video Series: Vibe Coding with AWS MCP Servers
• Deep Dive: AI-powered development for AWS Serverless applications
• Guide: Accelerating application development with the Amazon EKS MCP server
• Documentation: Harnessing MCP servers with Amazon Bedrock Agents

Security

Security notifications and vulnerability reporting follow the procedures outlined in the main repository's CONTRIBUTING section.

Contributing

We welcome community contributions of all types. Refer to the standard contributor guide for submission requirements.

Developer Guide

Individuals interested in integrating new AWS services via MCP servers should consult the development guide and adhere to established design guidelines.

Conclusion

These AWS MCP Servers formalize the integration of cloud context into LLM interactions, providing a structured mechanism for developers to manage infrastructure, retrieve current technical data, and execute complex operations reliably. This standardized approach, related conceptually to structured parsing methodologies, ensures that AI-driven interactions with the AWS environment remain accurate, compliant, and efficient, solidifying the utility of these official integrations within modern development pipelines.