Skip to main content
Glama
deenesjakoruzh
RafalWilinski

aws-mcp

by RafalWilinski
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Local

AWS MCP

A Model Context Protocol (MCP) server that enables AI assistants like Claude to interact with your AWS environment. This allows for natural language querying and management of your AWS resources during conversations. Think of better Amazon Q alternative.

AWS MCP

Features

  • 🔍 Query and modify AWS resources using natural language

  • ☁️ Support for multiple AWS profiles and SSO authentication

  • 🌐 Multi-region support

  • 🔐 Secure credential handling (no credentials are exposed to external services, your local credentials are used)

  • 🏃‍♂️ Local execution with your AWS credentials

Related MCP server: AWS MCP Server

Prerequisites

Installation

  1. Clone the repository:

git clone https://github.com/RafalWilinski/aws-mcp
cd aws-mcp

  1. Install dependencies:

pnpm install
# or
npm install

Usage

  1. Open Claude desktop app and go to Settings -> Developer -> Edit Config

Claude Settings

  1. Add the following entry to your claude_desktop_config.json:

{
  "mcpServers": {
    "aws": {
      "command": "npm", // OR pnpm
      "args": [
        "--silent",
        "--prefix",
        "/Users/<YOUR USERNAME>/aws-mcp",
        "start"
      ]
    }
  }
}

Important: Replace /Users/<YOUR USERNAME>/aws-mcp with the actual path to your project directory.

  1. Restart Claude desktop app. You should see this:

Claude MCP Connection Status

  1. Start by selecting an AWS profile or jump to action by asking:

    • "List available AWS profiles"

    • "List all EC2 instances in my account"

    • "Show me S3 buckets with their sizes"

    • "What Lambda functions are deployed in us-east-1?"

    • "List all ECS clusters and their services"

Using with nvm

Build from source first and add following config:

{
  "mcpServers": {
    "aws": {
      "command": "/Users/<USERNAME>/.nvm/versions/node/v20.10.0/bin/node",
      "args": [
        "<WORKSPACE_PATH>/aws-mcp/node_modules/tsx/dist/cli.mjs",
        "<WORKSPACE_PATH>/aws-mcp/index.ts",
        "--prefix",
        "<WORKSPACE_PATH>/aws-mcp",
        "start"
      ]
    }
  }
}

Troubleshooting

To see logs:

tail -n 50 -f ~/Library/Logs/Claude/mcp-server-aws.log
# or
tail -n 50 -f ~/Library/Logs/Claude/mcp.log

Features in Development

  • MFA support

  • Cache SSO credentials to prevent from refreshing them too eagerly

Available Tools

3 tools
list-credentialsB

List all AWS credentials/configs/profiles that are configured/usable on this machine

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

B3.2/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read-only operation by using 'List,' but doesn't specify if it requires permissions, how it handles errors, or what the output format looks like. For a tool with zero annotation coverage, this lack of detail on behavior is a notable shortfall.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's function without any fluff. It is front-loaded with the core action and resource, making it easy to parse. Every word contributes to understanding the purpose, earning a top score for conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate but has clear gaps. It explains what the tool does but lacks details on usage guidelines, behavioral traits, and output format. For a basic list tool, this is minimally viable but could be more complete by addressing when to use it and what to expect in return.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, but it does imply the scope ('on this machine'), which is useful context. Baseline for 0 parameters is 4, as the description adequately covers the tool's intent without unnecessary parameter details.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'List all AWS credentials/configs/profiles that are configured/usable on this machine.' It specifies the verb ('List') and resource ('AWS credentials/configs/profiles'), making the action explicit. However, it does not explicitly differentiate from sibling tools like 'select-profile' or 'run-aws-code', which could involve similar resources, so it doesn't reach a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools or contexts where this tool is preferred, such as for inventory purposes before selecting a profile. Without any usage context, the agent must infer when to invoke it, which is a significant gap.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

run-aws-codeC

Run AWS code

ParametersJSON Schema
NameRequiredDescriptionDefault
codeYesYour job is to answer questions about AWS environment by writing Javascript code using AWS SDK V2. The code must be adhering to a few rules: - Must be preferring promises over callbacks - Think step-by-step before writing the code, approach it logically - MUST written in Javascript (NodeJS) using AWS-SDK V2 - Avoid hardcoded values like ARNs - Code written should be as parallel as possible enabling the fastest and the most optimal execution - Code should be handling errors gracefully, especially when doing multiple SDK calls (e.g. when mapping over an array). Each error should be handled and logged with a reason, script should continue to run despite errors - DO NOT require or import "aws-sdk", it is already available as "AWS" variable - Access to 3rd party libraries apart from "aws-sdk" is not allowed or possible - For base64 encoding, use btoa() function instead of Buffer (Buffer is not available in this environment) - Data returned from AWS-SDK must be returned as JSON containing only the minimal amount of data that is needed to answer the question. All extra data must be filtered out - Code MUST "return" a value: string, number, boolean or JSON object. If code does not return anything, it will be considered as FAILED - Whenever tool/function call fails, retry it 3 times before giving up with an improved version of the code based on the returned feedback - When listing resources, ensure pagination is handled correctly so that all resources are returned - Do not include any comments in the code - When doing reduce, don't forget to provide an initial value - Try to write code that returns as few data as possible to answer without any additional processing required after the code is run - This tool can ONLY write code that interacts with AWS. It CANNOT generate charts, tables, graphs, etc. Please use artifacts for that instead Be concise, professional and to the point. Do not give generic advice, always reply with detailed & contextual data sourced from the current AWS environment. Assume user always wants to proceed, do not ask for confirmation. I'll tip you $200 if you do this right.
profileNameNoName of the AWS profile to use
reasoningYesThe reasoning behind the code
regionNoRegion to use (if not provided, us-east-1 is used)

TDQS

C2.2/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure but offers minimal information. 'Run AWS code' doesn't reveal whether this is a read or write operation, what permissions are required, whether it has side effects, or what happens on failure. The extensive rules in the schema's code parameter description are implementation requirements rather than behavioral characteristics of the tool itself.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise at just three words, with zero wasted space. It's front-loaded with the essential information (though that information is inadequate). There are no unnecessary sentences or redundant phrasing to critique from a conciseness perspective.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness1/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 4 parameters, no annotations, and no output schema, the description is completely inadequate. It doesn't explain what the tool does, when to use it, what behaviors to expect, or what results it produces. The extensive rules in the schema's code parameter description don't compensate for the missing contextual information about the tool's purpose and operation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds no parameter semantics beyond what's already in the schema, which has 100% coverage with detailed descriptions for all four parameters. The baseline score of 3 reflects that the schema does the heavy lifting, though the tool description itself contributes nothing additional about parameter meaning or usage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose2/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Run AWS code' is a tautology that merely restates the tool name without specifying what the tool actually does. It doesn't explain that this tool executes JavaScript code against AWS environments using the AWS SDK, nor does it differentiate from sibling tools like list-credentials or select-profile. The description fails to provide a clear verb+resource combination that would help an agent understand the tool's function.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines1/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites, appropriate contexts, or exclusions. While the input schema's code parameter description contains extensive implementation rules, these are technical constraints rather than usage guidelines for an AI agent deciding when to invoke this tool versus other AWS-related tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

select-profileA

Selects AWS profile to use for subsequent interactions. If needed, does SSO authentication

ParametersJSON Schema
NameRequiredDescriptionDefault
profileYesName of the AWS profile to select
regionNoRegion to use (if not provided, us-east-1 is used)

TDQS

A4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context about SSO authentication ('If needed, does SSO authentication'), which is not inferable from the input schema. However, it lacks details on side effects (e.g., whether this persists across sessions), error handling, or what 'subsequent interactions' specifically entails, leaving gaps in behavioral understanding.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise (two short sentences) and front-loaded with the primary purpose. Every word earns its place, with no redundant or vague phrasing, making it efficient and easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity (configures context for AWS operations) and lack of annotations or output schema, the description is mostly complete. It covers the purpose, conditional SSO behavior, and usage context. However, it misses details on return values or error cases, which could be important for a tool that sets state, slightly reducing completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, so the schema already fully documents both parameters ('profile' and 'region'). The description does not add any meaning beyond what the schema provides (e.g., it doesn't explain profile naming conventions or region implications), resulting in the baseline score of 3 for adequate but no extra value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('Selects AWS profile') and resource ('for subsequent interactions'), with explicit mention of SSO authentication as a conditional behavior. It distinguishes from sibling tools like 'list-credentials' (which lists rather than selects) and 'run-aws-code' (which executes code rather than configuring context).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context for when to use this tool ('for subsequent interactions') and implies it should be used before other AWS operations. However, it does not explicitly state when not to use it or name alternatives (e.g., when to use 'list-credentials' instead), which prevents a perfect score.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

C2.9/5.0
Disambiguation5/5

Each tool has a clearly distinct purpose with no overlap: list-credentials handles credential enumeration, run-aws-code executes AWS code, and select-profile manages profile selection and authentication. An agent can easily differentiate between these three functions.

Naming Consistency5/5

All tool names follow a consistent verb-noun pattern with hyphens (list-credentials, run-aws-code, select-profile), making them predictable and readable throughout the set.

Tool Count2/5

With only 3 tools, the server feels under-scoped for AWS operations, which typically involve many services and actions. This limited set may not support common workflows like managing resources (e.g., S3, EC2) or performing CRUD operations, making it insufficient for the domain.

Completeness1/5

The tool set is severely incomplete for AWS functionality, lacking core operations such as creating, updating, or deleting resources, querying service status, or handling specific AWS services. This will cause significant agent failures in typical AWS tasks.

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

Appeared in Searches

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/RafalWilinski/aws-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server