AWS Resources Operations

What is mcp-server-aws-resources-python?

mcp-server-aws-resources-python is a Python-based Model Context Protocol (MCP) server that enables AI models like Claude to interact with and manage AWS resources directly by executing boto3 code. It provides a secure and containerized environment for performing powerful AWS operations.

How to use mcp-server-aws-resources-python?

To use mcp-server-aws-resources-python, you need to provide your AWS credentials (access key, secret key, and optionally session token and region) as environment variables. The server can be installed via Smithery or by pulling the Docker image from Docker Hub. Once set up, you can send Python boto3 code snippets to the server, which will execute them against your AWS account. The results are returned in JSON format.

Key Features of mcp-server-aws-resources-python

Python and boto3 based: Leverages the familiar Python ecosystem and the official AWS SDK for Python.
Dockerized: Runs directly from a Docker image, simplifying setup and ensuring portability.
Secure Execution: Includes AST-based code analysis, restricted execution environment, and limited built-in functions for safe code execution.
Containerized and Sandboxed: Provides a clean and isolated environment for running AWS operations.
JSON Output: Automatically converts results to JSON, handling AWS-specific objects and datetime values.
Cross-Platform Publishing: Supports building and pushing Docker images for multiple platforms (linux/amd64, linux/arm64, linux/arm/v7).
Integration with Claude Desktop: Provides clear instructions and examples for integrating with Claude Desktop.

Use Cases of mcp-server-aws-resources-python

Querying AWS Resources: Easily list S3 buckets, get the latest CodePipeline deployments, or query any other AWS resource supported by boto3.
Managing AWS Resources: Perform management operations on AWS resources, such as fixing DynamoDB permission errors (as demonstrated in the project).
Automated AWS Operations: Enable AI models to automate routine AWS tasks and respond to operational needs.
Development and Testing: Provide a sandboxed environment for developers to test boto3 code against real AWS resources.

FAQ from mcp-server-aws-resources-python

Why another AWS MCP Server?
- Existing solutions like AWS Chatbot have limitations (query limits, cost, JSON output restrictions).
- Other MCP implementations (e.g., aws-mcp) might have setup hassles, stability issues, or be based on different technology stacks (e.g., Node.js).
- This project aims to provide a more stable, Python-friendly, Docker-based, and easily contributable solution with proper sandboxing.
Is it safe to use for management operations?
- The project explicitly states "At your own risk" as it doesn't limit operations to ReadOnly. Your AWS user role dictates the permissions for what you can do. It is designed to help cautious Ops people with management operations.
What are the required environment variables?
- AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_DEFAULT_REGION (optional, defaults to 'us-east-1'), and AWS_SESSION_TOKEN (optional, for temporary credentials).
- Alternatively, you can use AWS_PROFILE with credentials stored in ~/.aws/credentials.
What imports are allowed in the code snippets?
- boto3, operator, json, datetime, pytz, dateutil, re, time.
How are results returned?
- All code snippets must set a result variable, which will be automatically converted to JSON format, handling AWS-specific objects and datetime values.

AWS Resources MCP Server

Overview

A Model Context Protocol (MCP) server implementation that provides running generated python code to query any AWS resources through boto3.

At your own risk: I didn't limit the operations to ReadyOnly, so that cautious Ops people can be helped using this tool doing management operations. Your AWS user role will dictate the permissions for what you can do.

Demo: Fix Dynamodb Permission Error

https://github.com/user-attachments/assets/de88688d-d7a0-45e1-94eb-3f5d71e9a7c7

Why Another AWS MCP Server?

I tried AWS Chatbot with Developer Access. Free Tier has a limit of 25 query/month for resources. Next tier is $19/month include 90% of the features I don't use. And the results are in a fashion of JSON and a lot of restrictions.

I tried using aws-mcp but ran into a few issues:

Setup Hassle: Had to clone a git repo and deal with local setup
Stability Issues: Wasn't stable enough on my Mac
Node.js Stack: As a Python developer, I couldn't effectively contribute back to the Node.js codebase

So I created this new approach that:

Runs directly from a Docker image - no git clone needed
Uses Python and boto3 for better stability
Makes it easy for Python folks to contribute
Includes proper sandboxing for code execution
Keeps everything containerized and clean

For more information about the Model Context Protocol and how it works, see Anthropic's MCP documentation.

Components

Resources

The server exposes the following resource:

aws://query_resources: A dynamic resource that provides access to AWS resources through boto3 queries

Example Queries

Here are some example queries you can execute:

List S3 buckets:

s3 = session.client('s3')
result = s3.list_buckets()

Get latest CodePipeline deployment:

def get_latest_deployment(pipeline_name):
    codepipeline = session.client('codepipeline')

    result = codepipeline.list_pipeline_executions(
        pipelineName=pipeline_name,
        maxResults=5
    )

    if result['pipelineExecutionSummaries']:
        latest_execution = max(
            [e for e in result['pipelineExecutionSummaries']
             if e['status'] == 'Succeeded'],
            key=itemgetter('startTime'),
            default=None
        )

        if latest_execution:
            result = codepipeline.get_pipeline_execution(
                pipelineName=pipeline_name,
                pipelineExecutionId=latest_execution['pipelineExecutionId']
            )
        else:
            result = None
    else:
        result = None

    return result

result = get_latest_deployment("your-pipeline-name")

Note: All code snippets must set a result variable that will be returned to the client. The result variable will be automatically converted to JSON format, with proper handling of AWS-specific objects and datetime values.

Tools

The server offers a tool for executing AWS queries:

aws_resources_query_or_modify
- Execute a boto3 code snippet to query or modify AWS resources
- Input:
  - code_snippet (string): Python code using boto3 to query AWS resources
  - The code must set a result variable with the query output
- Allowed imports:
  - boto3
  - operator
  - json
  - datetime
  - pytz
  - dateutil
  - re
  - time
- Available built-in functions:
  - Basic types: dict, list, tuple, set, str, int, float, bool
  - Operations: len, max, min, sorted, filter, map, sum, any, all
  - Object handling: hasattr, getattr, isinstance
  - Other: print, import

Implementation Details

The server includes several safety features:

AST-based code analysis to validate imports and code structure
Restricted execution environment with limited built-in functions
JSON serialization of results with proper handling of AWS-specific objects
Proper error handling and reporting

Setup

Prerequisites

You'll need AWS credentials with appropriate permissions to query AWS resources. You can obtain these by:

Creating an IAM user in your AWS account
Generating access keys for programmatic access
Ensuring the IAM user has necessary permissions for the AWS services you want to query

The following environment variables are required:

AWS_ACCESS_KEY_ID: Your AWS access key
AWS_SECRET_ACCESS_KEY: Your AWS secret key
AWS_SESSION_TOKEN: (Optional) AWS session token if using temporary credentials
AWS_DEFAULT_REGION: AWS region (defaults to 'us-east-1' if not set)

You can also use a profile stored in the ~/.aws/credentials file. To do this, set the AWS_PROFILE environment variable to the profile name.

Note: Keep your AWS credentials secure and never commit them to version control.

Installing via Smithery

To install AWS Resources MCP Server for Claude Desktop automatically via Smithery:

npx -y @smithery/cli install mcp-server-aws-resources-python --client claude

Docker Installation

You can either build the image locally or pull it from Docker Hub. The image is built for the Linux platform.

Supported Platforms

Linux/amd64
Linux/arm64
Linux/arm/v7

Option 1: Pull from Docker Hub

docker pull buryhuang/mcp-server-aws-resources:latest

Option 2: Build Locally

docker build -t mcp-server-aws-resources .

Run the container:

docker run \
  -e AWS_ACCESS_KEY_ID=your_access_key_id_here \
  -e AWS_SECRET_ACCESS_KEY=your_secret_access_key_here \
  -e AWS_DEFAULT_REGION=your_AWS_DEFAULT_REGION \
  buryhuang/mcp-server-aws-resources:latest

Or using stored credentials and a profile:

docker run \
  -e AWS_PROFILE=[AWS_PROFILE_NAME] \
  -v ~/.aws:/root/.aws \
  buryhuang/mcp-server-aws-resources:latest

Cross-Platform Publishing

To publish the Docker image for multiple platforms, you can use the docker buildx command. Follow these steps:

Create a new builder instance (if you haven't already):
```
docker buildx create --use
```

Build and push the image for multiple platforms:

docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 -t buryhuang/mcp-server-aws-resources:latest --push .

Verify the image is available for the specified platforms:

docker buildx imagetools inspect buryhuang/mcp-server-aws-resources:latest

Usage with Claude Desktop

Running with Docker

Example using ACCESS_KEY_ID and SECRET_ACCESS_KEY

{
  "mcpServers": {
    "aws-resources": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "AWS_ACCESS_KEY_ID=your_access_key_id_here",
        "-e",
        "AWS_SECRET_ACCESS_KEY=your_secret_access_key_here",
        "-e",
        "AWS_DEFAULT_REGION=us-east-1",
        "buryhuang/mcp-server-aws-resources:latest"
      ]
    }
  }
}

Example using PROFILE and mounting local AWS credentials

{
  "mcpServers": {
    "aws-resources": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "AWS_PROFILE=default",
        "-v",
        "~/.aws:/root/.aws",
        "buryhuang/mcp-server-aws-resources:latest"
      ]
    }
  }
}

Running with Git clone

Example running with git clone and profile

{
  "mcpServers": {
    "aws": {
      "command": "/Users/gmr/.local/bin/uv",
      "args": [
        "--directory",
        "/<your-path>/mcp-server-aws-resources-python",
        "run",
        "src/mcp_server_aws_resources/server.py",
        "--profile",
        "testing"
      ]
    }
  }
}

AWS Resources Operations