AWS Cost Explorer & Bedrock Logs

Recupere dados de gastos da AWS do Cost Explorer e dados de uso do Amazon Bedrock dos logs do CloudWatch.

Documentação

Servidor e Cliente MCP de Logs de Invocação do AWS Cost Explorer e Amazon Bedrock

Um servidor MCP para obter dados de gastos da AWS via Cost Explorer e dados de uso do Amazon Bedrock via Model invocation logs no Amazon Cloud Watch através do MCP (Model Control Protocol) da Anthropic. Consulte a seção sobre "servidor" MCP remoto seguro para ver como você pode executar seu servidor MCP sobre 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

Você pode executar o servidor MCP localmente e acessá-lo via Claude Desktop, ou também pode executar um servidor MCP remoto no Amazon EC2 e acessá-lo via um cliente MCP integrado a um Agente LangGraph.

🚨Você também pode usar este servidor MCP para obter informações de gastos da AWS de outras contas, desde que a função IAM usada pelo servidor MCP possa assumir funções nessas outras contas🚨

Vídeo de demonstração

Visão geral

Esta ferramenta fornece uma maneira conveniente de analisar e visualizar dados de gastos na nuvem da AWS usando o modelo Claude da Anthropic como uma interface interativa. Ela funciona como um servidor MCP que expõe a funcionalidade da API do AWS Cost Explorer ao Claude Desktop, permitindo que você faça perguntas sobre seus gastos na AWS em linguagem natural.

Recursos

Análise de gastos do Amazon EC2: Veja detalhamentos de gastos com EC2 do último dia
Análise de gastos do Amazon Bedrock: Veja detalhamentos por região, usuários e modelos nos últimos 30 dias
Relatórios de gastos por serviço: Analise gastos em todos os serviços da AWS nos últimos 30 dias
Detalhamento de custos: Obtenha dados granulares de custo por dia, região, serviço e tipo de instância
Interface interativa: Use o Claude para consultar seus dados de custo por meio de linguagem natural

Requisitos

Python 3.12
Credenciais AWS com acesso ao Cost Explorer
Acesso à API da Anthropic (para integração com Claude)
[Opcional] Acesso ao Amazon Bedrock (para Agente LangGraph)
[Opcional] Amazon EC2 para executar um servidor MCP remoto

Instalação

Instale o 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"

Opções de instalação adicionais estão documentadas aqui

Clone este repositório: (presumindo que isso será atualizado para apontar para aws-samples?)
```
git clone https://github.com/aarora79/aws-cost-explorer-mcp.git
cd aws-cost-explorer-mcp
```

Configure o ambiente virtual Python e instale as dependências:

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

Configure suas credenciais AWS:
```
mkdir -p ~/.aws
# Set up your credentials in ~/.aws/credentials and ~/.aws/config
```
Se você usa o AWS IAM Identity Center, siga a documentação para configurar suas credenciais de curta duração

Uso

Pré-requisitos

Configure os logs de invocação de modelo no Amazon CloudWatch.
Garanta que o usuário/função IAM usado tenha acesso somente leitura completo ao Amazon Cost Explorer e ao Amazon CloudWatch; isso é necessário para que o servidor MCP recupere dados desses serviços. Consulte aqui e aqui para exemplos de políticas que você pode usar e modificar conforme seus requisitos.
Para permitir que seu servidor MCP acesse informações de gastos da AWS de outras contas, defina o parâmetro CROSS_ACCOUNT_ROLE_NAME ao iniciar o servidor e agora você pode fornecer o ID da conta AWS de outra conta ao interagir com seu agente, e o agente passará o ID da conta para o servidor.

Configuração local

Usa stdio como transporte para MCP; tanto o servidor MCP quanto o cliente estão sendo executados em sua máquina local.

Iniciando o servidor (local)

Execute o servidor usando:

export MCP_TRANSPORT=stdio
export BEDROCK_LOG_GROUP_NAME=YOUR_BEDROCK_CW_LOG_GROUP_NAME
export CROSS_ACCOUNT_ROLE_NAME=ROLE_NAME_FOR_THE_ROLE_TO_ASSUME_IN_OTHER_ACCOUNTS # can be ignored if you do not want AWS spend info from other accounts
python server.py

Configuração do Claude Desktop

Há duas maneiras de configurar esta ferramenta com o Claude Desktop:

Opção 1: Usando Docker

Adicione o seguinte ao arquivo de configuração do Claude Desktop. O arquivo pode ser encontrado nestes caminhos, dependendo do seu sistema operacional.

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_ACCESS_KEY_ID", "-e", "AWS_SECRET_ACCESS_KEY", "-e", "AWS_REGION", "-e", "BEDROCK_LOG_GROUP_NAME", "-e", "MCP_TRANSPORT", "-e", "CROSS_ACCOUNT_ROLE_NAME", "aws-cost-explorer-mcp:latest" ],
      "env": {
        "AWS_ACCESS_KEY_ID": "YOUR_ACCESS_KEY_ID",
        "AWS_SECRET_ACCESS_KEY": "YOUR_SECRET_ACCESS_KEY",
        "AWS_REGION": "us-east-1",
        "BEDROCK_LOG_GROUP_NAME": "YOUR_CLOUDWATCH_BEDROCK_MODEL_INVOCATION_LOG_GROUP_NAME",
        "CROSS_ACCOUNT_ROLE_NAME": "ROLE_NAME_FOR_THE_ROLE_TO_ASSUME_IN_OTHER_ACCOUNTS",
        "MCP_TRANSPORT": "stdio"
      }
    }
  }
}

IMPORTANTE: Substitua YOUR_ACCESS_KEY_ID e YOUR_SECRET_ACCESS_KEY pelas suas credenciais AWS reais. Nunca envie credenciais reais para o controle de versão.

Opção 2: Usando UV (sem Docker)

Se preferir executar o servidor diretamente sem Docker, você pode usar UV:

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

Certifique-se de substituir o caminho do diretório pelo caminho real do seu repositório no seu sistema.

Configuração remota

Usa sse como transporte para MCP; os servidores MCP estão no EC2 e o cliente está sendo executado em sua máquina local. Observe que o Claude Desktop não suporta servidores MCP remotos neste momento (consulte esta issue do GitHub).

Iniciando o servidor (remoto)

Você pode iniciar um servidor MCP remoto no Amazon EC2 seguindo as mesmas instruções acima. Certifique-se de definir o MCP_TRANSPORT como sse (eventos do lado do servidor), conforme mostrado abaixo. Observe que o MCP usa JSON-RPC 2.0 como formato de transmissão; portanto, o protocolo em si não inclui autorização e autenticação (consulte esta issue do GitHub); não envie nem receba dados confidenciais via MCP.

Execute o servidor usando:

export MCP_TRANSPORT=sse
export BEDROCK_LOG_GROUP_NAME=YOUR_BEDROCK_CW_LOG_GROUP_NAME
export CROSS_ACCOUNT_ROLE_NAME=ROLE_NAME_FOR_THE_ROLE_TO_ASSUME_IN_OTHER_ACCOUNTS # can be ignored if you do not want AWS spend info from other accounts
python server.py

O servidor MCP começará a escutar na porta TCP 8000.
Configure uma regra de entrada no grupo de segurança associado à sua instância EC2 para permitir acesso à porta TCP 8000 a partir da sua máquina local (onde você está executando o cliente MCP/aplicativo baseado em LangGraph) para sua instância EC2.

Consulte também a seção sobre execução de um "servidor" MCP remoto seguro, ou seja, um servidor ao qual seus clientes MCP podem se conectar via HTTPS.

Testando com um cliente MCP CLI

Você pode testar seu servidor MCP remoto com o script mcp_sse_client.py. Executar este script imprimirá a lista de ferramentas disponíveis no servidor MCP e uma saída para a ferramenta get_bedrock_daily_usage_stats.

# set the hostname for your MCP server
MCP_SERVER_HOSTNAME=YOUR_MCP_SERVER_EC2_HOSTNAME
# or localhost if your MCP server is running locally
# MCP_SERVER_HOSTNAME=localhost 
AWS_ACCOUNT_ID=AWS_ACCOUNT_ID_TO_GET_INFO_ABOUT # if set to empty or if the --aws-account-id switch is not specified then it gets the info about the AWS account MCP server is running in
python mcp_sse_client.py --host $MCP_SERVER_HOSTNAME --aws-account-id $AWS_ACCOUNT_ID

Testando com o aplicativo Chainlit

O arquivo app.py neste repositório fornece um aplicativo Chainlit (chatbot) que cria um agente LangGraph que usa o LangChain MCP Adapter para importar as ferramentas fornecidas pelo servidor MCP como ferramentas em um Agente LangGraph. O agente pode então usar um LLM para responder às perguntas do usuário e usar as ferramentas disponíveis conforme necessário. Assim, se o usuário fizer uma pergunta como "Como foi meu uso do Bedrock na última semana?", o agente usará as ferramentas disponíveis via servidor MCP remoto para responder a essa pergunta. Usamos o modelo Claude 3.5 Haiku disponível via Amazon Bedrock para alimentar este agente.

Execute o aplicativo Chainlit usando:

chainlit run app.py --port 8080

Uma janela do navegador deve abrir em localhost:8080 e você deve conseguir usar o chatbot para obter detalhes sobre seus gastos na AWS.

Ferramentas disponíveis

O servidor expõe as seguintes ferramentas que o Claude pode usar:

get_ec2_spend_last_day(): Recupera dados de gastos com EC2 do dia anterior
get_detailed_breakdown_by_day(days=7): Entrega uma análise abrangente de custos por região, serviço e tipo de instância
get_bedrock_daily_usage_stats(days=7, region='us-east-1', log_group_name='BedrockModelInvocationLogGroup'): Entrega um detalhamento diário do uso do modelo por região e usuários.
get_bedrock_hourly_usage_stats(days=7, region='us-east-1', log_group_name='BedrockModelInvocationLogGroup'): Entrega um detalhamento diário e por hora do uso do modelo por região e usuários.

Exemplos de consultas

Uma vez conectado ao Claude por meio de uma interface habilitada para MCP, você pode fazer perguntas como:

"Ajude-me a entender meus gastos com Bedrock nas últimas semanas"
"Quanto gastei com EC2 ontem?"
"Mostre-me meus 5 principais serviços da AWS por custo no último mês"
"Analise meus gastos por região nos últimos 14 dias"
"Quais tipos de instância estão me custando mais?"
"Quais serviços tiveram o maior aumento de custo mês a mês?"

Suporte a Docker

Um Dockerfile está incluído para implantação em contêiner:

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

Desenvolvimento

Estrutura do projeto

server.py: Implementação principal do servidor com ferramentas MCP
pyproject.toml: Dependências do projeto e metadados
Dockerfile: Definição do contêiner para implantações

Adicionando novas ferramentas de análise de custos

Para estender a funcionalidade:

Adicione novas funções a server.py
Anote-as com @mcp.tool()
Implemente as chamadas da API do AWS Cost Explorer
Formate os resultados para facilitar a leitura

Servidor MCP "remoto" seguro

Podemos usar nginx como um proxy reverso para fornecer um endpoint HTTPS para conexão ao servidor MCP. Clientes MCP remotos podem se conectar a nginx via HTTPS e, em seguida, ele pode fazer proxy do tráfego internamente para http://localhost:8000. As etapas a seguir descrevem como fazer isso.

Habilite o acesso à porta TCP 443 a partir do endereço IP do seu cliente MCP (seu laptop ou qualquer lugar) nas regras de entrada do grupo de segurança associado à sua instância EC2.
Você precisará de um certificado HTTPS e uma chave privada para continuar. Digamos que você use your-mcp-server-domain-name.com como domínio para seu servidor MCP; então você precisará de um certificado SSL para your-mcp-server-domain-name.com e ele estará acessível aos clientes MCP como https://your-mcp-server-domain-name.com/sse. Embora você possa usar um certificado autoassinado, isso exigiria desabilitar a verificação SSL no cliente MCP; NÃO recomendamos que você faça isso. Se você estiver hospedando seu servidor MCP no EC2, poderá gerar um certificado SSL usando no-ip ou Let' Encrypt ou outros serviços semelhantes. Coloque os arquivos de certificado SSL e chave privada nas pastas /etc/ssl/certs e /etc/ssl/privatekey, respectivamente, em sua máquina EC2.

Instale o nginx em sua máquina EC2 usando os seguintes comandos.

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

Obtenha o nome do host da sua instância EC2; isso será necessário para configurar o proxy reverso nginx.

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

Copie o seguinte conteúdo em um novo arquivo /etc/nginx/conf.d/ec2.conf. Substitua YOUR_EC2_HOSTNAME, /etc/ssl/certs/cert.pem e /etc/ssl/privatekey/privkey.pem por valores apropriados para sua configuração.

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;
     }
 }

Reinicie o nginx.
```
sudo systemctl start nginx
```
Inicie seu servidor MCP normalmente, conforme descrito na seção configuração remota.
Seu servidor MCP agora está acessível via HTTPS como https://your-mcp-server-domain-name.com/sse para seu cliente MCP.

No lado do cliente agora (digamos, no seu laptop ou no seu Agente), configure seu cliente MCP para se comunicar com seu servidor MCP da seguinte forma.

MCP_SERVER_HOSTNAME=YOUR_MCP_SERVER_DOMAIN_NAME
AWS_ACCOUNT_ID=AWS_ACCOUNT_ID_TO_GET_INFO_ABOUT # if set to empty or if the --aws-account-id switch is not specified then it gets the info about the AWS account MCP server is running in
python mcp_sse_client.py --host $MCP_SERVER_HOSTNAME --port 443 --aws-account-id $AWS_ACCOUNT_ID

Da mesma forma, você pode executar o aplicativo Chainlit para falar com o servidor MCP remoto via HTTPS.

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

Da mesma forma, você pode executar o Agente LangGraph para falar com o servidor MCP remoto via HTTPS.

python langgraph_agent_mcp_sse_client.py --host $MCP_SERVER_HOSTNAME --port 443 --aws-account-id $AWS_ACCOUNT_ID

Licença

Licença MIT

Agradecimentos

Esta ferramenta usa o framework MCP da Anthropic
Desenvolvido pela API do AWS Cost Explorer
Construído com FastMCP para implementação do servidor
O README foi gerado fornecendo um despejo de texto do repositório via GitIngest para o Claude