Skip to main content
Glama
aws-samples

AWS Cost Explorer MCP Server

Official
by aws-samples
OverviewSchemaRelated ServersScoreDiscussions
Python
Hybrid

A sample MCP server for understanding cloud spend

An MCP server for getting AWS spend data via Cost Explorer and Amazon Bedrock usage data via Model invocation logs in Amazon Cloud Watch through Anthropic's MCP (Model Control Protocol). See section on "secure" remote MCP server to see how you can run your MCP server over HTTPS.

flowchart LR
    User([User]) --> UserApp[User Application]
    UserApp --> |Queries| Host[Host]
    
    subgraph "Claude Desktop"
        Host --> MCPClient[MCP Client]
    end
    
    MCPClient --> |MCP Protocol over HTTPS| MCPServer[AWS Cost Explorer MCP Server]
    
    subgraph "AWS Services"
        MCPServer --> |API Calls| CostExplorer[(AWS Cost Explorer)]
        MCPServer --> |API Calls| CloudWatchLogs[(AWS CloudWatch Logs)]
    end

You can run the MCP server locally and access it via the Claude Desktop or you could also run a Remote MCP server on Amazon EC2 and access it via a MCP client built into a LangGraph Agent.

Overview

This tool provides a convenient way to analyze and visualize AWS cloud spending data using Anthropic's Claude model as an interactive interface. It functions as an MCP server that exposes AWS Cost Explorer API functionality to Claude Desktop, allowing you to ask questions about your AWS spend in natural language.

Related MCP server: AWS Billing MCP Server

Features

  • Amazon EC2 Spend Analysis: View detailed breakdowns of EC2 spending for the last day

  • Amazon Bedrock Spend Analysis: View breakdown by region, users and models over the last 30 days

  • Service Spend Reports: Analyze spending across all AWS services for the last 30 days

  • Detailed Cost Breakdown: Get granular cost data by day, region, service, and instance type

  • Interactive Interface: Use Claude to query your cost data through natural language

Requirements

  • Python 3.12

  • AWS credentials with Cost Explorer access

  • Anthropic API access (for Claude integration)

  • [Optional] Amazon Bedrock access (for LangGraph Agent)

  • [Optional] Amazon EC2 for running a remote MCP server

Installation

  1. Install uv:

    # On macOS and Linux
curl -LsSf https://astral.sh/uv/install.sh | sh
    # On Windows
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

    Additional installation options are documented here

  2. Clone this repository: (assuming this will be updated to point to aws-samples?)

    git clone https://github.com/aws-samples/sample-cloud-spend-mcp-server
cd aws-cost-explorer-mcp

  3. Set up the Python virtual environment and install dependencies:

    uv venv --python 3.12 && source .venv/bin/activate && uv pip install --requirement pyproject.toml

  4. Configure your AWS credentials:

    mkdir -p ~/.aws
# Set up your credentials in ~/.aws/credentials and ~/.aws/config

    If you use AWS IAM Identity Center, follow the docs to configure your short-term credentials

Usage

Prerequisites

  1. Setup model invocation logs in Amazon CloudWatch.

  2. Ensure that the IAM user/role being used has full read-only access to Amazon Cost Explorer and Amazon CloudWatch, this is required for the MCP server to retrieve data from these services. See here and here for sample policy examples that you can use & modify as per your requirements.

Local setup

Uses stdio as a transport for MCP, both the MCP server and client are running on your local machine.

Starting the Server (local)

Run the server using:

export MCP_TRANSPORT=stdio
export BEDROCK_LOG_GROUP_NAME=YOUR_BEDROCK_CW_LOG_GROUP_NAME
python server.py

Claude Desktop Configuration

There are two ways to configure this tool with Claude Desktop:

Option 1: Using Docker

Add the following to your Claude Desktop configuration file. The file can be found out these paths depending upon you operating system.

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json.

  • Windows: %APPDATA%\Claude\claude_desktop_config.json.

  • Linux: ~/.config/Claude/claude_desktop_config.json.

{
  "mcpServers": {
    "aws-cost-explorer": {
      "command": "docker",
      "args": [ "run", "-i", "--rm", "-e", "AWS_PROFILE", "-e", "AWS_REGION", "-e", "BEDROCK_LOG_GROUP_NAME", "-e", "MCP_TRANSPORT", "aws-cost-explorer-mcp:latest" ],
      "env": {
        "AWS_PROFILE": "YOUR_AWS_PROFILE_NAME",
        "AWS_REGION": "us-east-1",
        "BEDROCK_LOG_GROUP_NAME": "YOUR_CLOUDWATCH_BEDROCK_MODEL_INVOCATION_LOG_GROUP_NAME",
        "MCP_TRANSPORT": "stdio"
      }
    }
  }
}

IMPORTANT: Replace YOUR_AWS_PROFILE_NAME with your actual AWS profile name. This profile should be configured in your ~/.aws/credentials and ~/.aws/config files.

Option 2: Using UV (without Docker)

If you prefer to run the server directly without Docker, you can use UV:

{
  "mcpServers": {
    "aws_cost_explorer": {
      "command": "uv",
      "args": [
          "--directory",
          "/path/to/aws-cost-explorer-mcp-server",
          "run",
          "server.py"
      ],
      "env": {
        "AWS_PROFILE": "YOUR_AWS_PROFILE_NAME",
        "AWS_REGION": "us-east-1",
        "BEDROCK_LOG_GROUP_NAME": "YOUR_CLOUDWATCH_BEDROCK_MODEL_INVOCATION_LOG_GROUP_NAME",
        "MCP_TRANSPORT": "stdio"
      }
    }
  }
}

Make sure to replace the directory path with the actual path to your repository on your system.

Remote setup

Uses sse as a transport for MCP, the MCP servers on EC2 and the client is running on your local machine. Note that Claude Desktop does not support remote MCP servers at this time (see this GitHub issue).

Starting the Server (remote)

You can start a remote MCP server on Amazon EC2 by following the same instructions as above. Make sure to set the MCP_TRANSPORT as sse (server side events) as shown below. Note that the MCP uses JSON-RPC 2.0 as its wire format, therefore the protocol itself does not include authorization and authentication (see this GitHub issue), do not send or receive sensitive data over MCP.

Run the server using:

export MCP_TRANSPORT=sse
export BEDROCK_LOG_GROUP_NAME=YOUR_BEDROCK_CW_LOG_GROUP_NAME
python server.py

  1. The MCP server will start listening on TCP port 8000.

  2. Configure an ingress rule in the security group associated with your EC2 instance to allow access to TCP port 8000 from your local machine (where you are running the MCP client/LangGraph based app) to your EC2 instance.

Also see section on running a "secure" remote MCP server i.e. a server to which your MCP clients can connect over HTTPS.

Testing with a CLI MCP client

You can test your remote MCP server with the mcp_sse_client.py script. Running this script will print the list of tools available from the MCP server and an output for the get_bedrock_daily_usage_stats tool.

MCP_SERVER_HOSTNAME=YOUR_MCP_SERVER_EC2_HOSTNAME
python mcp_sse_client.py --host $MCP_SERVER_HOSTNAME

Testing with Chainlit app

The app.py file in this repo provides a Chainlit app (chatbot) which creates a LangGraph agent that uses the LangChain MCP Adapter to import the tools provided by the MCP server as tools in a LangGraph Agent. The Agent is then able to use an LLM to respond to user questions and use the tools available to it as needed. Thus if the user asks a question such as "What was my Bedrock usage like in the last one week?" then the Agent will use the tools available to it via the remote MCP server to answer that question. We use Claude 3.5 Haiku model available via Amazon Bedrock to power this agent.

Run the Chainlit app using:

chainlit run app.py --port 8080

A browser window should open up on localhost:8080 and you should be able to use the chatbot to get details about your AWS spend.

Available Tools

The server exposes the following tools that Claude can use:

  1. get_ec2_spend_last_day(): Retrieves EC2 spending data for the previous day

  2. get_detailed_breakdown_by_day(days=7): Delivers a comprehensive analysis of costs by region, service, and instance type

  3. get_bedrock_daily_usage_stats(days=7, region='us-east-1', log_group_name='BedrockModelInvocationLogGroup'): Delivers a per-day breakdown of model usage by region and users.

  4. get_bedrock_hourly_usage_stats(days=7, region='us-east-1', log_group_name='BedrockModelInvocationLogGroup'): Delivers a per-day per-hour breakdown of model usage by region and users.

Example Queries

Once connected to Claude through an MCP-enabled interface, you can ask questions like:

  • "Help me understand my Bedrock spend over the last few weeks"

  • "What was my EC2 spend yesterday?"

  • "Show me my top 5 AWS services by cost for the last month"

  • "Analyze my spending by region for the past 14 days"

  • "Which instance types are costing me the most money?"

  • "Which services had the highest month-over-month cost increase?"

Docker Support

A Dockerfile is included for containerized deployment:

docker build -t aws-cost-explorer-mcp .
docker run -v ~/.aws:/root/.aws aws-cost-explorer-mcp

Development

Project Structure

  • server.py: Main server implementation with MCP tools

  • pyproject.toml: Project dependencies and metadata

  • Dockerfile: Container definition for deployments

Adding New Cost Analysis Tools

To extend the functionality:

  1. Add new functions to server.py

  2. Annotate them with @mcp.tool()

  3. Implement the AWS Cost Explorer API calls

  4. Format the results for easy readability

Secure "remote" MCP server

We can use nginx as a reverse-proxy so that it can provide an HTTPS endpoint for connecting to the MCP server. Remote MCP clients can connect to nginx over HTTPS and then it can proxy traffic internally to http://localhost:8000. The following steps describe how to do this.

  1. Enable access to TCP port 443 from the IP address of your MCP client (your laptop, or anywhere) in the inbound rules in the security group associated with your EC2 instance.

  2. You would need to have an HTTPS certificate and private key to proceed. Let's say you use your-mcp-server-domain-name.com as the domain for your MCP server then you will need an SSL cert for your-mcp-server-domain-name.com and it will be accessible to MCP clients as https://your-mcp-server-domain-name.com/sse. While you can use a self-signed cert but it would require disabling SSL verification on the MCP client, we DO NOT recommend you do that. If you are hosting your MCP server on EC2 then you could generate an SSL cert using no-ip or Let's Encrypt or other similar services. Place the SSL cert and private key files in /etc/ssl/certs and /etc/ssl/privatekey folders respectively on your EC2 machine.

  3. Install nginx on your EC2 machine using the following commands.

    sudo apt-get install nginx
sudo nginx -t
sudo systemctl reload nginx

  4. Get the hostname for your EC2 instance, this would be needed for configuring the nginx reverse proxy.

    TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600") && curl -H "X-aws-ec2-metadata-token: $TOKEN" -s http://169.254.169.254/latest/meta-data/public-hostname

  5. Copy the following content into a new file /etc/nginx/conf.d/ec2.conf. Replace YOUR_EC2_HOSTNAME, /etc/ssl/certs/cert.pem and /etc/ssl/privatekey/privkey.pem with values appropriate for your setup.

    server {
 listen 80;
 server_name YOUR_EC2_HOSTNAME;

 # Optional: Redirect HTTP to HTTPS
 return 301 https://$host$request_uri;
 }

 server {
     listen 443 ssl;
     server_name YOUR_EC2_HOSTNAME;

     # Self-signed certificate paths
     ssl_certificate     /etc/ssl/certs/cert.pem;
     ssl_certificate_key /etc/ssl/privatekey/privkey.pem; 

     # Optional: Good practice
     ssl_protocols       TLSv1.2 TLSv1.3;
     ssl_ciphers         HIGH:!aNULL:!MD5;

     location / {
         # Reverse proxy to your local app (e.g., port 8000)
         proxy_pass http://127.0.0.1:8000;
         proxy_http_version 1.1;
         proxy_set_header Host $host;
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
     }
 }

  6. Restart nginx.

    sudo systemctl start nginx

  7. Start your MCP server as usual as described in the remote setup section.

  8. Your MCP server is now accessible over HTTPS as https://your-mcp-server-domain-name.com/sse to your MCP client.

  9. On the client side now (say on your laptop or in your Agent) configure your MCP client to communicate to your MCP server as follows.

    MCP_SERVER_HOSTNAME=YOUR_MCP_SERVER_DOMAIN_NAME
python mcp_sse_client.py --host $MCP_SERVER_HOSTNAME --port 443

    Similarly you could run the chainlit app to talk to remote MCP server over HTTPS.

    export MCP_SERVER_URL=YOUR_MCP_SERVER_DOMAIN_NAME
export MCP_SERVER_PORT=443
chainlit run app.py --port 8080

    Similarly you could run the LangGraph Agent to talk to remote MCP server over HTTPS.

    python langgraph_agent_mcp_sse_client.py --host YOUR_MCP_SERVER_DOMAIN_NAME --port 443

License

MIT License

Available Tools

4 tools
get_bedrock_daily_usage_statsC
Get daily usage statistics with detailed breakdowns.

Args:
    params: Parameters specifying the number of days to look back and region

Returns:
    str: Formatted string representation of daily usage statistics
ParametersJSON Schema
NameRequiredDescriptionDefault
paramsYes

TDQS

C2.7/5.0
Behavior2/5

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

No annotations provided, so description must carry full burden. It only states 'Get' and returns a string, but does not disclose read-only nature, required permissions, rate limits, or any side effects. Insufficient for a data retrieval tool.

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

Conciseness4/5

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

Description is very brief with structured Args/Returns. Front-loaded with purpose. However, it sacrifices clarity for brevity by omitting important details.

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

Completeness2/5

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

No output schema, so description must describe return value – it does as 'formatted string'. But nested parameter object is not explained, and sibling differentiation missing. Incomplete for a parameterized tool with no annotations.

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

Parameters2/5

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

Schema coverage is 0% meaning description does not explain parameters. It vaguely mentions 'number of days and region' but omits log_group_name, defaults, and constraints. Schema itself has descriptions, but tool description adds no value.

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?

Description clearly states 'Get daily usage statistics with detailed breakdowns', specifying verb and resource. It distinguishes from hourly stats and EC2 spend siblings through 'daily' in name and description.

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?

No guidance on when to use this tool versus siblings like get_bedrock_hourly_usage_stats or get_detailed_breakdown_by_day. Agent has no context on selection criteria.

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

get_bedrock_hourly_usage_statsC
Get hourly usage statistics with detailed breakdowns.

Args:
    params: Parameters specifying the number of days to look back and region

Returns:
    str: Formatted string representation of hourly usage statistics
ParametersJSON Schema
NameRequiredDescriptionDefault
paramsYes

TDQS

C2.9/5.0
Behavior2/5

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

No annotations exist, so the description carries full burden. It only states it returns a formatted string, with no mention of side effects, permissions, rate limits, or other behavioral traits. The 'detailed breakdowns' is vague.

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

Conciseness4/5

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

The description is concise with a single sentence plus structured Args/Returns. No redundant information. The format is clear and front-loaded.

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?

For a tool with one parameter object (three sub-properties) and no output schema, the description provides minimal context. It specifies the return type as a string but not the content format. The 'detailed breakdowns' hint is insufficient for an agent to fully understand the output.

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?

Schema description coverage is 0% for the top-level 'params' property, so description must compensate. It mentions 'number of days to look back and region', which partially maps to the sub-properties, but omits 'log_group_name'. The summary adds some context but incomplete.

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 it retrieves hourly usage statistics with detailed breakdowns, matching the tool name. It distinguishes from 'get_bedrock_daily_usage_stats' via the 'hourly' qualifier, but does not differentiate from 'get_detailed_breakdown_by_day' or other siblings.

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?

No guidance is provided on when to use this tool versus alternatives like 'get_bedrock_daily_usage_stats' or 'get_detailed_breakdown_by_day'. No usage conditions or exclusions are mentioned.

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

get_detailed_breakdown_by_dayB
Retrieve daily spend breakdown by region, service, and instance type.

Args:
    params: Parameters specifying the number of days to look back

Returns:
    Dict[str, Any]: A tuple containing:
        - A nested dictionary with cost data organized by date, region, and service
        - A string containing the formatted output report
    or (None, error_message) if an error occurs.
ParametersJSON Schema
NameRequiredDescriptionDefault
paramsYes

TDQS

B3.4/5.0
Behavior4/5

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

Despite no annotations, the description discloses the return structure (nested dict and formatted string) and that it takes a days parameter. It reveals the output format fairly well, though it could mention limitations like max days.

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

Conciseness4/5

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

The description is concise and structured with Args and Returns sections. The main purpose is front-loaded. Minor wordiness in Returns could be tightened.

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

Completeness2/5

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

There is an internal contradiction: the purpose mentions 'instance type' but Returns only mention 'date, region, and service'. Also, Returns states 'Dict[str, Any]' then says it's a tuple. The description lacks structural details of the nested dictionary. Given no output schema and no annotations, completeness is insufficient.

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

Parameters2/5

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

The description adds minimal value over the schema: it says 'Parameters specifying the number of days to look back,' but the schema already states that for DaysParam. It does not mention the default of 7, optionality, or constraints. With 0% schema coverage, the description should compensate more.

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 it retrieves daily spend breakdown by region, service, and instance type. This specific verb and resource differentiate it from sibling tools about bedrock usage and EC2 spend.

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?

No guidance on when to use this tool versus siblings. It does not mention prerequisites, alternatives, or context for selection.

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

get_ec2_spend_last_dayB
Retrieve EC2 spend for the last day using standard AWS Cost Explorer API.

Returns:
    Dict[str, Any]: The raw response from the AWS Cost Explorer API, or None if an error occurs.
ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

B3.4/5.0
Behavior2/5

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

No annotations provided, and description only states it returns raw response or None. Does not disclose read-only nature, potential delays, or error conditions beyond basic None return.

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

Conciseness4/5

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

Extremely concise, two sentences. Could optionally include usage example or note on API limits, but no excess.

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?

For a simple parameterless tool, description covers return value. However, lacking output schema, it could mention typical response structure or error handling.

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?

No parameters exist, so baseline is 4. Description does not add parameter info, but none is needed.

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?

Description clearly states verb 'Retrieve' and resource 'EC2 spend for the last day', distinguishing it from sibling tools focusing on Bedrock usage or daily breakdowns. No ambiguity.

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?

No guidance on when to use this tool versus alternatives (e.g., get_detailed_breakdown_by_day). Does not specify prerequisites or context.

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

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 4 tool updatesv0.1.0
    • First observedget_bedrock_daily_usage_stats
    • First observedget_bedrock_hourly_usage_stats
    • First observedget_detailed_breakdown_by_day
    • First observedget_ec2_spend_last_day
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

C2.8/5.0
Disambiguation3/5

The tools have some overlap: get_bedrock_daily_usage_stats and get_detailed_breakdown_by_day both provide daily data, with the former being Bedrock-specific and the latter general. This could cause confusion about which tool to use for daily Bedrock costs. The hourly Bedrock tool and EC2 spend tool are distinct.

Naming Consistency2/5

Naming is inconsistent: 'get_bedrock_daily_usage_stats' and 'get_bedrock_hourly_usage_stats' follow one pattern, while 'get_detailed_breakdown_by_day' and 'get_ec2_spend_last_day' use different structures (e.g., 'by_day' vs 'last_day', 'usage_stats' vs 'breakdown' vs 'spend').

Tool Count3/5

With only 4 tools, the server feels under-scoped for a general 'AWS Cost Explorer' service. It covers only Bedrock and EC2, missing many other services and cost dimensions. However, for a focused subset, 4 tools could be reasonable.

Completeness2/5

The tooling covers only Bedrock daily/hourly stats, a generic daily breakdown, and EC2 daily spend. Missing other AWS services, monthly/forecast data, cost anomalies, tag-based queries, and broader exploration features. Significant gaps for a cost explorer tool.

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

  • AWS Cost Explorer MCP Server

    aarora79
    A
    license
    C
    quality
    F
    maintenance
    A command-line interface and API that allows users to analyze and visualize AWS cloud spending data by enabling Claude to query AWS Cost Explorer through natural language conversations.
    4
    126
    MIT

  • AWS Billing MCP Server

    ankit8volt
    F
    license
    Not graded
    quality
    D
    maintenance
    Enables users to analyze AWS costs, track spending trends, and detect anomalies directly within Claude Desktop using the AWS Cost Explorer API. It provides tools to identify major cost drivers and compare usage across different time periods through natural language queries.
    -

  • Cloud FinOps Analyst MCP

    mihirkadam19
    A
    license
    A
    quality
    B
    maintenance
    Enables analyzing AWS cloud costs through natural language queries, providing cost summaries, anomaly detection, idle resource identification, rightsizing recommendations, and tagging compliance via Claude.
    10
    41
    MIT

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/aws-samples/sample-cloud-spend-mcp-server'

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