AWS maintains a whole suite of pre-built MCP servers (“AWS MCP Servers”) under the awslabs/mcp GitHub monorepo. Each server exposes a specific AWS domain (CDK, Cost Analysis, CloudFormation, Lambda, DynamoDB, Serverless, etc.) over the standard MCP JSON-RPC interface.

Below is a sample of the most common ones (full list in the “Available Servers” section of the repo): github.comgithub.com

• Core MCP Server (awslabs.core-mcp-server):

  • Orchestrates multiple AWS MCP servers (planning, guidance, federating)

• AWS Documentation MCP Server (awslabs.aws-documentation-mcp-server):

  • Search and fetch AWS docs/pages, convert to markdown, surface best practices

• Cost Analysis MCP Server (awslabs.cost-analysis-mcp-server):

  • Query AWS Cost Explorer in natural language, generate cost reports/insights

• AWS CDK MCP Server (awslabs.cdk-mcp-server):

  • Provide CDK guidance, construct recommendations, Well-Architected checks

• AWS CloudFormation MCP Server (awslabs.cfn-mcp-server):

  • Create/describe/update/delete CloudFormation stacks and resources via MCP

• AWS Lambda MCP Server (awslabs.lambda-mcp-server):

  • List/invoke Lambda functions, manage function configurations, etc.

• Amazon SNS / SQS MCP Server (awslabs.sns-sqs-mcp-server):

  • Create topics/queues, publish/subscribe, send/receive messages

• AWS Step Functions MCP Server (awslabs.step-functions-mcp-server):

  • Execute or inspect Step Functions state machines as an MCP “tool”

• AWS Serverless MCP Server (awslabs.aws-serverless-mcp-server):

  • Build/deploy/test SAM apps, retrieve logs/metrics for Lambda/API Gateway, guide on serverless best practices

• Amazon DynamoDB MCP Server (awslabs.dynamodb-mcp-server):

  • Create/update tables, and do data-plane operations (put/get/query/scan) via natural language

• Amazon EKS MCP Server (awslabs.eks-mcp-server):

  • Help with cluster creation, deploying workloads, and troubleshooting Kubernetes resources and more (e.g., AWS Diagram, AWS Kendra, Amazon S3, Amazon Aurora, ElastiCache, etc.).

🔗 To see the full list (and click “Learn more” or “Documentation” for each):
https://github.com/awslabs/mcp/tree/main/src

2. Install uvx (the MCP Launcher)

All AWS-published MCP servers are packaged in PyPI (or as Node/Go modules), and the recommended way to run them is via uvx (part of the Astral “uv” toolchain). Essentially, uvx lets you pull down and run a pre-built MCP server with one command.

2.1. Why uvx?

• ”Plug-and-play”: No need to clone/build each server.

• Auto-updates: By default, {"args":["awslabs.cost-analysis-mcp-server@latest"]} always fetches the most recent version from PyPI.

• Consistent: All AWS MCP servers use the same “uvx + PyPI” distribution mechanism.

2.2. Installing uvx

You can install the uv tool (which includes uvx) on macOS, Linux, or Windows. The quickest methods are via Homebrew or pipx.

1. Install or update Homebrew if you haven’t yet:
#    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

brew update
brew install uv   # installs the 'uv' package manager, which includes 'uvx'

# Verify uv and uvx:
uv --version      # should print something like: uv 0.7.x
uvx --version     # should print something like: uvx 0.5.x

# (Recommended if you prefer pipx/immediate Python isolation)
pipx install uv   # this also installs uvx

# OR, if you already use pipx to manage artifactory:
pipx install uvx

# Verify:
uv --version
uvx --version

# 1. Open PowerShell as Administrator
winget install astral-sh.uv -e

# Restart PowerShell (or log out/in)
uv --version      # expect uv 0.7.x
uvx --version     # expect uvx 0.5.x+

Tip: If you see “uvx: command not found”, make sure your PATH was updated, or reinstall using Homebrew/pipx so you get both uv and uvx. docs.astral.shmedium.com

3. Launching an AWS MCP Server via uvx

Once uvx is available, you can start any of the AWS MCP servers with a single command. In the GitHub README, AWS provides a JSON snippet that shows how all the servers are configured. We’ll copy that pattern for whichever server(s) you need.

3.1. Example: Start the Cost Analysis MCP Server

This server “analyzes and visualizes AWS costs” by wrapping Cost Explorer. To run it locally:

uvx awslabs.cost-analysis-mcp-server@latest \
  --env AWS_PROFILE=your-aws-profile \
  --env FASTMCP_LOG_LEVEL=INFO

• awslabs.cost-analysis-mcp-server@latest

  • Tells uvx to fetch the latest Cost Analysis MCP package from PyPI.

• --env AWS_PROFILE=your-aws-profile

  • (Optional) If you have a named AWS CLI profile, specify it so the server uses those credentials.

• --env FASTMCP_LOG_LEVEL=INFO

  • Controls logging verbosity (ERROR, WARN, INFO, DEBUG).

Once this runs successfully, you’ll see:

Cost Analysis MCP Server listening on port 8000 (default)

By default, most AWS MCP servers listen on http://localhost:8000/ (unless otherwise configured).

🔗 Official config snippet from AWS MCP README github.com

{
  "awslabs.cost-analysis-mcp-server": {
    "command": "uvx",
    "args": ["awslabs.cost-analysis-mcp-server@latest"],
    "env": {
      "AWS_PROFILE": "your-aws-profile",
      "FASTMCP_LOG_LEVEL": "ERROR"
    }
  }
}

3.2. Example: Start the AWS Serverless MCP Server

If you want a single MCP server that covers Serverless Application Model (SAM) lifecycle (init, build, deploy, test), plus retrieving logs/metrics for Lambda and API Gateway, use:

uvx awslabs.aws-serverless-mcp-server@latest \
  --env AWS_PROFILE=your-aws-profile \
  --env AWS_REGION=us-east-1 \
  --env FASTMCP_LOG_LEVEL=INFO

• This launches a server you can query (via MCP JSON-RPC) for any “serverless” task:

  • “Show me logs for my function MyFunction in ap-southeast-2”

  • “Generate a SAM template for a new HTTP API + Lambda + DynamoDB”

  • etc.

3.3. Launch Multiple Servers at Once (Core + Others)

If you want an umbrella setup (Core + CDK + Cost + Documentation + Lambda + CloudFormation + …), you can feed uvx a JSON config file that lists all servers. For example, create mcp-config.json:

{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.aws-documentation-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.aws-documentation-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.cost-analysis-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.cost-analysis-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.aws-serverless-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.aws-serverless-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
    // …add more servers as needed…
  }
}

Then run:

uvx --config ./mcp-config.json

uvx will spin up each server in its own process. By default, each one listens on a different port (starting at 8000, then 8001, 8002, etc.), and the Core MCP server (if you launch it) will “know” how to route calls to the others. github.com

4. Invoking an AWS MCP Server from a Client

Once your AWS MCP server is running locally (e.g., on http://localhost:8000), you can call it exactly like any other MCP server over JSON-RPC 2.0. Below are two common approaches:

1. Use a minimal MCP client script (Node.js or Python)

2. Use Amazon Bedrock Inline Agents (e.g., with Spring AI or Amazon Bedrock Converse API)

4.1. Example: Node.js MCP Client for Cost Analysis

Here’s a quick Node.js script that calls the Cost Analysis MCP server (running on localhost:8000) to retrieve May 2025 AWS blended costs.

# 1. Create a new folder for your client:
mkdir mcp-client && cd mcp-client
npm init -y
npm install axios uuid

Create index.js:

// index.js
import axios from 'axios';
import { v4 as uuidv4 } from 'uuid';

// URL of the Cost Analysis MCP Server
const MCP_URL = 'http://localhost:8000/';  

async function getCostAndUsage(startDate, endDate) {
  const requestBody = {
    jsonrpc: '2.0',
    id: uuidv4(),
    method: 'GetCostAndUsage',       // MCP method name
    params: {
      TimePeriod: { Start: startDate, End: endDate },
      Granularity: 'MONTHLY',
      Metrics: ['BlendedCost']
    }
  };

  try {
    const resp = await axios.post(MCP_URL, requestBody, {
      headers: { 'Content-Type': 'application/json' }
    });

    if (resp.data.error) {
      console.error('MCP Error:', resp.data.error);
    } else {
      console.log(
        'Cost Explorer Response:',
        JSON.stringify(resp.data.result, null, 2)
      );
    }
  } catch (err) {
    console.error('HTTP Error:', err.message);
  }
}

(async () => {
  // Example: query May 1–31, 2025
  await getCostAndUsage('2025-05-01', '2025-05-31');
})();

Run it:

node index.js

If your uvx awslabs.cost-analysis-mcp-server@latest is up and your AWS credentials allow Cost Explorer read, you’ll see something like:

Cost Explorer Response: {
  "ResultsByTime": [
    {
      "TimePeriod": { "Start": "2025-05-01", "End": "2025-05-31" },
      "Total": { "BlendedCost": { "Amount": "123.45", "Unit": "USD" } },
      …
    }
  ]
}

confirming that the AWS MCP server forwarded your JSON-RPC call all the way to CostExplorer.getCostAndUsage()

4.2. Example: Python MCP Client (using mcp-client-for-testing)

If you prefer Python, the mcp-client-for-testing package can simplify calling an MCP server. First, install it:

# Inside a virtualenv (recommended)
pip install mcp-client-for-testing

Then create a simple script call_cost.py:

# call_cost.py
import asyncio
from mcp_client_for_testing.client import execute_tool

async def main():
    # Configuration for Cost Analysis MCP (point to uvx-launched server)
    config = [
        {
            "name": "cost-analysis",
            "command": "http",
            "args": ["localhost:8000"],  
            "env": {}
        }
    ]

    # Build the JSON-RPC CallToolRequest
    tool_call = {
        "name": "GetCostAndUsage",
        "arguments": {
            "TimePeriod": { "Start": "2025-05-01", "End": "2025-05-31" },
            "Granularity": "MONTHLY",
            "Metrics": ["BlendedCost"]
        }
    }

    result = await execute_tool(config, tool_call)
    print("MCP Result:", result)

if __name__ == "__main__":
    asyncio.run(main())

Run it:

python call_cost.py

You’ll see the JSON that includes AWS Cost Explorer’s output.

Python client script (call_cost.py) will send and receive when the MCP server is up:

Request Body:
{
  "jsonrpc": "2.0",
  "id": "123e4567-e89b-12d3-a456-426614174000",
  "method": "GetCostAndUsage",
  "params": {
    "TimePeriod": {
      "Start": "2025-05-01",
      "End": "2025-05-31"
    },
    "Granularity": "MONTHLY",
    "Metrics": [
      "BlendedCost"
    ]
  }
}

Response:
{
  "jsonrpc": "2.0",
  "id": "123e4567-e89b-12d3-a456-426614174000",
  "result": {
    "ResultsByTime": [
      {
        "TimePeriod": {
          "Start": "2025-05-01",
          "End": "2025-05-31"
        },
        "Total": {
          "BlendedCost": {
            "Amount": "123.45",
            "Unit": "USD"
          }
        }
      }
    ]
  }
}

This mirrors the Node.js example confirming that your Python client can send the JSON-RPC request to the MCP server and receive the cost data in the same format.

4.3. Example: Integrating with Amazon Bedrock Inline Agents

If you’re using an LLM (e.g., Claude Desktop, Q Developer, or Amazon Bedrock Agents), you can register your locally running AWS MCP servers as action groups. Then, when your model needs AWS context, it simply calls the MCP server.

Below is a pseudocode snippet (adapted from AWS’s “Harness the power of MCP servers with Amazon Bedrock Agents” guide): aws.amazon.comcommunity.aws

// sample agent configuration (e.g., in your Bedrock inline Agent settings)
{
  "ActionGroups": [
    {
      "Name": "CostExplorerGroup",
      "Type": "MCP",
      "Endpoint": "http://localhost:8000",        // your cost-analysis server
      "Description": "Query AWS Cost Explorer data"
    },
    {
      "Name": "ServerlessGroup",
      "Type": "MCP",
      "Endpoint": "http://localhost:8001",        // your aws-serverless server
      "Description": "Deploy and manage SAM apps"
    }
    // …add more MCP action groups as needed
  ]
}

When your Bedrock Agent runs, it can do:

User (prompt): “Show me the monthly cost for my prod account last month.”
Bedrock Agent → MCP Client → MCP Server “CostAnalysis” → AWS Cost Explorer → return JSON → Agent synthesizes a friendly response.

5. Environment & Permissions

Regardless of which AWS MCP server you run, it needs AWS credentials with the right IAM permissions. For example:

• Cost Analysis MCP server requires:

  • ce:GetCostAndUsage

  • ce:GetDimensionValues

  • ce:GetTags

  • (You can bundle these in a managed policy called CostAnalysisMCPPolicy).

• CloudFormation MCP server needs:

  • cloudformation:CreateStack, DescribeStacks, UpdateStack, DeleteStack, etc.

• Lambda MCP server needs:

  • lambda:ListFunctions, lambda:InvokeFunction, lambda:GetFunctionConfiguration, etc.

Tip: When you launch via uvx awslabs.<server>@latest, you can inject:

--env AWS_PROFILE=my-profile \
--env AWS_REGION=us-east-1

as long as ~/.aws/credentials or AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY are set accordingly.

6. Summary Checklist

1. Choose which AWS MCP server(s) you need.

   • See the “Available Servers” list on the AWS Labs MCP GitHub: github.com

2. Install the uvx launcher tool.

   • brew install uv (macOS/Linux) or pipx install uv or winget install astral-sh.uv (Windows).

3. Launch the server(s) you need.

    uvx awslabs.cost-analysis-mcp-server@latest \
      --env AWS_PROFILE=your-profile \
      --env AWS_REGION=us-west-2 \
      --env FASTMCP_LOG_LEVEL=INFO
   

   • Each server will start on localhost:8000, :8001, etc. github.com

4. Point your MCP client (script or Bedrock agent) to the server’s HTTP endpoint.

   • Example using Node.js + Axios or Python + mcp-client-for-testing.

5. Verify IAM permissions for whichever AWS APIs the selected MCP server uses.

   • Cost Analysis → ce:GetCostAndUsage, GetDimensionValues, GetTags

   • CloudFormation → cloudformation:*

   • Lambda → lambda:*, etc.

6. Interact!

   • Send JSON-RPC 2.0 requests like:

       {
         "jsonrpc":"2.0",
         "id":"some-uuid",
         "method":"GetCostAndUsage",
         "params":{
           "TimePeriod":{"Start":"2025-05-01","End":"2025-05-31"},
           "Granularity":"MONTHLY",
           "Metrics":["BlendedCost"]
         }
       }
     

   • Read the JSON response and surface it (or let your LLM/Bedrock Agent format a human-friendly answer).

Further Reading & References

• AWS Labs MCP GitHub (full “Available Servers” list + individual READMEs):
  https://github.com/awslabs/mcp/tree/main/src github.comgithub.com

• Installing uvx: Astral docs (Homebrew, pipx, winget) docs.astral.shmedium.com

• MCP Client for Testing (Python example): https://pypi.org/project/mcp-client-for-testing/ pypi.org

• “Harness the power of MCP servers with Amazon Bedrock Agents”:
  https://aws.amazon.com/blogs/machine-learning/harness-the-power-of-mcp-servers-with-amazon-bedrock-agents/ aws.amazon.comcommunity.aws

With this setup, you can immediately use AWS’s expert-maintained MCP servers for cost analysis, CloudFormation, serverless, CDK, and more, no need to write or maintain your own server logic. Enjoy plugging your LLM or custom client directly into AWS best practices!