Cost Management MCP

Um servidor para gerenciamento unificado de custos em vários provedores de nuvem e serviços de API.

Documentação

Cost Management MCP

Um servidor Model Context Protocol (MCP) para gerenciamento unificado de custos entre provedores de nuvem e serviços de API.

English | 日本語

🚀 Exemplos Rápidos

Uma vez integrado ao Claude Desktop, você pode perguntar:

📊 "What are my AWS costs for December 2024?"
📈 "Show me OpenAI API usage trends for the last 30 days"
🤖 "What are my Anthropic API costs this month?"
🔍 "Break down my cloud expenses by service"
📋 "Which providers are currently configured?"
💰 "How much have I spent across all services this month?"

Recursos

🔍 Rastreamento unificado de custos entre AWS, OpenAI e Anthropic
💾 Cache inteligente para minimizar custos de API
📊 Intervalos de datas flexíveis e opções de granularidade
🔐 Gerenciamento seguro de credenciais via variáveis de ambiente
🚀 Integração fácil com Claude Desktop e outros clientes MCP
⚡ Escrito em TypeScript com segurança total de tipos
🧪 Cobertura abrangente de testes
🔄 Lógica de nova tentativa automática com backoff exponencial
🛡️ Varredura de segurança com CodeQL e Trufflehog
📦 Atualizações automatizadas de dependências com Dependabot

🛠️ Ferramentas MCP

Este servidor fornece três ferramentas poderosas para gerenciamento de custos:

📊 `cost_get`

Obtenha detalhamentos de custos

Verifique custos para qualquer intervalo de datas
Filtre por provedor específico (AWS, OpenAI, Anthropic)
Veja custos diários, mensais ou totais
Veja detalhamentos por serviço

Exemplos de perguntas no Claude:

"Quais são meus custos da AWS neste mês?"
"Mostre o uso diário da OpenAI na última semana"
"Detalhe meus custos de nuvem por serviço"

📋 `provider_list`

Verifique o status dos provedores

Veja quais provedores estão configurados
Verifique se as credenciais da API são válidas
Verificação rápida de saúde para todas as integrações

Exemplos de uso:

"Liste todos os meus provedores de nuvem"
"Quais serviços de rastreamento de custos estão ativos?"

💰 `provider_balance`

Verifique créditos restantes (Em breve)

Veja saldos pré-pagos
Monitore o uso de créditos da API
Receba alertas antes que os créditos expirem

📊 `openai_costs`

Obtenha uso detalhado da OpenAI

Detalhamento por modelo (GPT-4, GPT-3.5, etc.)
Estatísticas de uso de tokens
Recomendações de otimização de custos

Exemplos de uso:

"Mostre meus custos da OpenAI agrupados por modelo"
"Quantos tokens usei com GPT-4 esta semana?"

🤖 `anthropic_costs`

Obtenha uso detalhado da Anthropic

Detalhamento por modelo (Claude 3.5 Sonnet, Haiku, etc.)
Estatísticas de uso de tokens com detalhes de cache de prompt
Recomendações de otimização de custos
Suporte para APIs de relatório de custos e de uso

Exemplos de uso:

"Mostre meus custos da Anthropic agrupados por modelo"
"Quanto gastei com Claude 3.5 Sonnet neste mês?"
"Quais são meus custos da Anthropic com detalhes em nível de token?"

☁️ `aws_costs`

Análise de custos da AWS com insights

Detalhamento por serviço (EC2, S3, RDS, etc.)
Filtre por serviço específico da AWS
Dicas automáticas de otimização de custos
Alertas de gastos elevados

Exemplos de uso:

"Quais são meus custos de EC2 neste mês?"
"Mostre os custos da AWS agrupados por serviço"
"Dê-me dicas de otimização de custos da AWS"

📈 `provider_compare`

Compare custos entre provedores

Comparação lado a lado de custos
Visualização de gráfico ASCII
Alertas de dependência de fornecedor
Insights de distribuição de custos

Exemplos de uso:

"Compare meus custos entre todos os provedores de nuvem"
"Mostre-me um gráfico dos custos dos provedores"
"Qual provedor é o mais caro?"

📊 `cost_trends`

Analise tendências de custos ao longo do tempo

Análise histórica de custos (30d, 60d, 90d, 6m, 1a)
Detecção de tendências (crescente/decrescente/estável)
Análise de volatilidade
Detecção de picos
Granularidade diária/semanal/mensal

Exemplos de uso:

"Mostre-me tendências de custos dos últimos 30 dias"
"Meus custos da AWS estão aumentando?"
"Detecte quaisquer picos de custos no último mês"

🔍 `cost_breakdown`

Análise detalhada de detalhamento de custos

Detalhamento multidimensional (serviço, região, data, tag)
Principais N direcionadores de custos
Filtragem baseada em porcentagem
Drill-down hierárquico
Análise de concentração de custos

Exemplos de uso:

"Detalhe meus custos por serviço"
"Mostre os 5 principais direcionadores de custos"
"Quais serviços compõem 80% dos meus custos?"

📅 `cost_periods`

Compare custos entre períodos de tempo

Comparação período a período
Mudanças absolutas e percentuais
Rastreamento de mudanças em nível de serviço
Comparação de média diária
Detecção de serviços novos/descontinuados

Exemplos de uso:

"Compare este mês com o mês passado"
"Quanto os custos aumentaram desde o Q1?"
"Quais serviços cresceram mais?"

Instalação

Pré-requisitos

Node.js 18 ou superior
npm ou yarn
Contas ativas com os provedores de nuvem que você deseja monitorar

O CI atualmente verifica Node.js 18.x, 20.x, 22.x e 24.x. Node.js 20.x é a principal via para upload de cobertura e verificações representativas de build.

Passos

Clone o repositório:

git clone https://github.com/knishioka/cost-management-mcp.git
cd cost-management-mcp

Instale as dependências:

npm install

Copie o modelo de ambiente:

cp .env.example .env

Edite .env e adicione suas credenciais (veja Configuração do Provedor)
Compile o projeto:

npm run build

Início Rápido

Executando de Forma Independente

# Development mode (with hot reload)
npm run dev

# Production mode
npm start

Integração com Claude Desktop

Compile o projeto primeiro:

npm run build

Adicione à sua configuração do Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json no macOS):

{
  "mcpServers": {
    "cost-management": {
      "command": "node",
      "args": ["/absolute/path/to/cost-management-mcp/dist/index.js"],
      "env": {
        "AWS_ACCESS_KEY_ID": "your-key",
        "AWS_SECRET_ACCESS_KEY": "your-secret",
        "AWS_REGION": "us-east-1",
        "OPENAI_API_KEY": "your-key",
        "CACHE_TTL": "3600",
        "LOG_LEVEL": "info"
      }
    }
  }
}

Reinicie o Claude Desktop
Use as ferramentas em sua conversa:

Can you check my AWS costs for this month?
What are my OpenAI API costs for the last 7 days?
List all my configured cloud providers.

Integração com Claude Code

O Claude Code suporta servidores MCP através de dois métodos de configuração:

Método 1: Configuração específica do projeto (Recomendado)

Crie um arquivo .mcp.json na raiz do seu projeto:

{
  "mcpServers": {
    "cost-management": {
      "command": "node",
      "args": ["/absolute/path/to/cost-management-mcp/dist/index.js"],
      "env": {
        "AWS_ACCESS_KEY_ID": "your-aws-access-key",
        "AWS_SECRET_ACCESS_KEY": "your-aws-secret-key",
        "AWS_REGION": "us-east-1",
        "OPENAI_API_KEY": "sk-...your-openai-key",
        "ANTHROPIC_API_KEY": "sk-ant-admin-...your-admin-key",
        "CACHE_TTL": "3600",
        "LOG_LEVEL": "info"
      }
    }
  }
}

Esta configuração será carregada automaticamente quando você abrir o projeto no Claude Code.

Método 2: Configurações do VS Code (Configuração global)

Abra as Configurações do VS Code (Cmd/Ctrl + ,)
Pesquise por "Claude Code MCP Servers"
Clique em "Editar em settings.json"
Adicione a configuração do servidor de gerenciamento de custos:

{
  "claudeCode.mcpServers": {
    "cost-management": {
      "command": "node",
      "args": ["/absolute/path/to/cost-management-mcp/dist/index.js"],
      "env": {
        "AWS_ACCESS_KEY_ID": "your-aws-access-key",
        "AWS_SECRET_ACCESS_KEY": "your-aws-secret-key",
        "AWS_REGION": "us-east-1",
        "OPENAI_API_KEY": "sk-...your-openai-key",
        "ANTHROPIC_API_KEY": "sk-ant-admin-...your-admin-key",
        "CACHE_TTL": "3600",
        "LOG_LEVEL": "info"
      }
    }
  }
}

Recarregue a janela do VS Code (Cmd/Ctrl + Shift + P → "Developer: Reload Window")

Usando o Servidor de Gerenciamento de Custos

Uma vez configurado, você pode perguntar ao Claude Code sobre seus custos de nuvem:

📊 "What are my AWS costs for this month?"
📈 "Show me OpenAI API usage trends"
🔍 "Break down my cloud expenses by service"
💰 "Compare costs across all providers"

Nota de Segurança:

Para .mcp.json específico do projeto, adicione-o ao .gitignore para evitar o commit de chaves de API sensíveis
Considere usar variáveis de ambiente ou um gerenciador de segredos para uso em produção
O cache é opcional - se não configurado, o servidor funcionará sem cache

Ferramentas Disponíveis

cost_get

Recupere dados de custos para provedores e períodos de tempo especificados.

Parâmetros:

provider (opcional): Provedor específico para consultar ('aws', 'openai', 'anthropic')
startDate (obrigatório): Data de início no formato YYYY-MM-DD
endDate (obrigatório): Data de término no formato YYYY-MM-DD
granularity (opcional): 'daily', 'monthly' ou 'total' (padrão: 'total')
groupBy (opcional): Matriz de dimensões para agrupar (ex.: ['SERVICE', 'REGION'])

Exemplo de Solicitação:

{
  "provider": "aws",
  "startDate": "2024-01-01",
  "endDate": "2024-01-31",
  "granularity": "daily",
  "groupBy": ["SERVICE"]
}

Exemplo de Resposta:

{
  "success": true,
  "data": {
    "provider": "aws",
    "period": {
      "start": "2024-01-01T00:00:00.000Z",
      "end": "2024-01-31T23:59:59.999Z"
    },
    "costs": {
      "total": 1234.56,
      "currency": "USD",
      "breakdown": [
        {
          "service": "Amazon EC2",
          "amount": 800.0,
          "usage": {
            "quantity": 720,
            "unit": "Hours"
          }
        },
        {
          "service": "Amazon S3",
          "amount": 434.56
        }
      ]
    },
    "metadata": {
      "lastUpdated": "2024-01-31T12:00:00.000Z",
      "source": "api"
    }
  }
}

provider_list

Liste todos os provedores configurados e seu status de conexão.

A resposta inclui:

Nome do provedor
Status da configuração
Status da validação de credenciais

Exemplo de Resposta:

{
  "success": true,
  "data": {
    "providers": [
      {
        "name": "aws",
        "status": "active",
        "configured": true
      },
      {
        "name": "openai",
        "status": "active",
        "configured": true
    ],
    "configured": 2,
    "total": 3
  }
}

provider_balance

Verifique saldo ou créditos restantes (específico do provedor). Nota: Atualmente não implementado para a maioria dos provedores

Configuração do Provedor

AWS

Ative o Cost Explorer no Console da AWS
- Navegue até AWS Cost Management → Cost Explorer
- Clique em "Enable Cost Explorer" (⚠️ Esta ação é irreversível)
- Aguarde 24 horas para que os dados estejam disponíveis

Crie um Usuário IAM com permissões mínimas:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["ce:GetCostAndUsage", "ce:GetCostForecast", "ce:GetDimensionValues"],
      "Resource": "*"
    }
  ]
}

Defina as variáveis de ambiente:

AWS_ACCESS_KEY_ID=your-access-key
AWS_SECRET_ACCESS_KEY=your-secret-key
AWS_REGION=us-east-1  # Cost Explorer only works in us-east-1

⚠️ Importante: A AWS cobra $0,01 por solicitação à API do Cost Explorer. O cache está habilitado por padrão (1 hora) para minimizar custos.

OpenAI

Obtenha a Chave da API no Painel da OpenAI
Certifique-se de ter:
- Uma conta paga com histórico de uso
- Acesso à API habilitado
Defina a variável de ambiente:
```
OPENAI_API_KEY=sk-...your-api-key
```

⚠️ Nota: A API de Uso é relativamente nova (dezembro de 2024). Certifique-se de que sua conta tenha acesso.

Anthropic

Obtenha a Chave de API de Administrador no Console da Anthropic
Requisitos:
- Conta de organização (contas individuais não são suportadas)
- Função de administrador para provisionar chaves de API de administrador
- A chave de API de administrador começa com sk-ant-admin... (diferente das chaves de API regulares)

Defina a variável de ambiente:

ANTHROPIC_API_KEY=sk-ant-admin-...your-admin-api-key

⚠️ Notas Importantes:

Apenas chaves de API de administrador podem acessar dados de custos e uso
Os dados de custos estão disponíveis através de duas APIs:
- API de Relatório de Custos: Fornece dados reais de faturamento em USD
- API de Relatório de Uso: Fornece detalhes em nível de token com custos calculados
Os dados normalmente aparecem dentro de 5 minutos após a conclusão da solicitação da API
Suporta rastreamento de custos de cache de prompt

Configuração

Variáveis de Ambiente

Variável	Descrição	Padrão	Obrigatória
`AWS_ACCESS_KEY_ID`	Chave de acesso da AWS	-	Para AWS
`AWS_SECRET_ACCESS_KEY`	Chave secreta da AWS	-	Para AWS
`AWS_REGION`	Região da AWS	us-east-1	Para AWS
`OPENAI_API_KEY`	Chave da API da OpenAI	-	Para OpenAI
`ANTHROPIC_API_KEY`	Chave de API de administrador da Anthropic	-	Para Anthropic
`CACHE_TTL`	Tempo de vida do cache em segundos	3600	Não
`CACHE_TYPE`	Backend do cache (memory/redis)	memory	Não
`REDIS_URL`	URL de conexão do Redis	-	Se usar Redis
`LOG_LEVEL`	Verbosidade do log (debug/info/warn/error)	info	Não
`MCP_SERVER_PORT`	Porta do servidor	3000	Não

Configuração do Cache

O cache ajuda a reduzir custos de API e melhorar o desempenho:

Cache em Memória (padrão): Rápido, sem necessidade de configuração, dados perdidos ao reiniciar
Cache Redis: Persistente, compartilhado entre instâncias, requer servidor Redis

Para usar Redis:

CACHE_TYPE=redis
REDIS_URL=redis://localhost:6379

Registro de Logs

O registro de logs JSON estruturado é usado para fácil análise:

# View logs in development
npm run dev

# View logs in production with jq
npm start 2>&1 | jq '.'

# Filter errors only
npm start 2>&1 | jq 'select(.level == "error")'

Desenvolvimento

Estrutura do Projeto

cost-management-mcp/
├── src/
│   ├── common/          # Shared utilities and types
│   │   ├── cache.ts     # Caching implementation
│   │   ├── config.ts    # Configuration management
│   │   ├── errors.ts    # Custom error classes
│   │   ├── types.ts     # TypeScript interfaces
│   │   └── utils.ts     # Helper functions
│   ├── providers/       # Provider implementations
│   │   ├── aws/         # AWS Cost Explorer
│   │   ├── openai/      # OpenAI Usage API
│   │   ├── anthropic/   # Anthropic Admin API
│   ├── tools/           # MCP tool implementations
│   │   ├── getCosts.ts
│   │   ├── listProviders.ts
│   │   └── checkBalance.ts
│   ├── server.ts        # MCP server setup
│   └── index.ts         # Entry point
├── tests/               # Test files
├── docs/                # Additional documentation
└── scripts/             # Utility scripts

Comandos

# Development with hot reload
npm run dev

# Build TypeScript to JavaScript
npm run build

# Run production server
npm start

# Run all tests
npm test

# Run tests with coverage
npm run test:coverage

# Run tests in watch mode
npm run test:watch

# Lint code
npm run lint

# Fix linting issues
npm run lint:fix

# Type check without building
npm run typecheck

# Clean build artifacts
npm run clean

Adicionando um Novo Provedor

Crie o diretório do provedor:

mkdir -p src/providers/newprovider

Implemente os arquivos necessários:

types.ts - Interfaces TypeScript
transformer.ts - Converte a resposta da API para formato unificado
client.ts - Cliente da API implementando ProviderClient
index.ts - Exportações públicas

Atualize o server.ts para incluir o novo provedor
Adicione testes em tests/providers/newprovider/

Testes

Os testes usam Jest com suporte a TypeScript:

# Run all tests
npm test

# Run tests for specific provider
npm test -- aws

# Run with coverage
npm run test:coverage

# Debug tests
node --inspect-brk node_modules/.bin/jest --runInBand

Arquitetura

Princípios de Design

Interface Unificada: Todos os provedores implementam a mesma interface ProviderClient
Resiliência a Erros: Nova tentativa automática com backoff exponencial
Otimização de Custos: Cache agressivo para minimizar chamadas de API
Segurança de Tipos: Cobertura completa de TypeScript com modo estrito
Extensibilidade: Fácil adicionar novos provedores ou ferramentas

Fluxo de Dados

User Request → MCP Tool → Provider Client → Cache Check
                                              ↓ (miss)
                                          External API
                                              ↓
                                          Transformer
                                              ↓
                                          Cache Store
                                              ↓
                                          Response

Tratamento de Erros

O sistema implementa uma estratégia hierárquica de tratamento de erros:

Erros de Provedor: Específicos de cada provedor de nuvem
Erros de Autenticação: Credenciais inválidas ou expiradas
Erros de Limite de Taxa: Nova tentativa automática com backoff
Erros de Validação: Parâmetros de entrada inválidos
Erros de Rede: Problemas de conexão que podem ser repetidos

Solução de Problemas

Problemas Comuns

Erro "Falha na autenticação"

Verifique se suas chaves/credenciais de API estão corretas
Verifique se as credenciais têm as permissões necessárias
Para AWS, certifique-se de estar usando a região us-east-1 para o Cost Explorer

Nenhum dado de custo retornado

AWS: Aguarde 24 horas após habilitar o Cost Explorer
OpenAI: Verifique se você tem uma conta paga com uso

Custos elevados da AWS

A API do Cost Explorer cobra US$ 0,01 por solicitação
Aumente CACHE_TTL para reduzir chamadas de API
Use cache Redis para persistência entre reinicializações

Erro "Limite de taxa excedido"

O sistema tenta novamente automaticamente com backoff exponencial
Se persistir, verifique suas cotas de API
Considere aumentar o TTL do cache

Modo de Depuração

Ative o registro de depuração para obter mais informações:

LOG_LEVEL=debug npm run dev

Verificação de Integridade

Teste provedores individuais:

# In your MCP client
Use the provider_list tool to check all providers

Contribuindo

Aceitamos contribuições! Consulte nosso Guia de Contribuição para obter detalhes.

Fluxo de Trabalho de Desenvolvimento

Faça um fork do repositório
Crie um branch de recurso: git checkout -b feature/your-feature
Faça suas alterações
Adicione testes para novas funcionalidades
Garanta que todos os testes passem: npm test
Execute o lint do seu código: npm run lint
Faça o commit com uma mensagem descritiva
Envie para o seu fork e envie um PR

Estilo de Código

Siga as melhores práticas de TypeScript
Use nomes de variáveis significativos
Adicione comentários JSDoc para APIs públicas
Mantenha as funções pequenas e focadas
Escreva testes para novos recursos

📊 Status do Projeto

Build e Testes

CI/CD: Testes automatizados em push e PR
Suporte a Node: O requisito mínimo de runtime é Node.js 18+. O CI verifica 18.x, 20.x, 22.x e 24.x, com 20.x como a principal via para upload de cobertura e verificações de build representativas.
Cobertura: Suíte de testes abrangente com relatório de cobertura

Segurança

Verificação de Dependências: Atualizações automatizadas semanais
Detecção de Segredos: Monitoramento contínuo de credenciais expostas
Análise de Código: Verificação de segurança CodeQL

Qualidade

Segurança de Tipos: Configuração estrita de TypeScript
Linting: ESLint com correção automática no commit
Formatação: Formatação de código Prettier

Licença

Licença MIT - consulte o arquivo LICENSE para obter detalhes

Documentação em Japonês

Visão Geral

O Cost Management MCP é um servidor Model Context Protocol (MCP) para gerenciar uniformemente os custos de vários provedores de nuvem e serviços de API.

Principais Recursos

🔍 Gerenciamento unificado de custos para AWS, OpenAI e Anthropic
💾 Cache inteligente para minimizar custos de API
📊 Opções flexíveis de intervalo de datas e agregação
🔐 Gerenciamento seguro de credenciais por meio de variáveis de ambiente
🚀 Integração fácil com o Claude Desktop
⚡ Segurança de tipos com TypeScript
🧪 Cobertura abrangente de testes
🔄 Nova tentativa automática com backoff exponencial
🛡️ Verificações de segurança com CodeQL e Trufflehog
📦 Atualizações automáticas de dependências com Dependabot

🛠️ Ferramentas MCP Disponíveis

Este servidor fornece três ferramentas poderosas para gerenciamento de custos:

📊 `cost.get`

Obter detalhamento detalhado de custos

Verifique os custos de qualquer período
Filtre por provedor específico (AWS, OpenAI)
Exiba custos diários, mensais ou totais
Confira o detalhamento em nível de serviço

Exemplos de uso no Claude:

"Me diga os custos da AWS deste mês"
"Exiba o uso diário da OpenAI na última semana"
"Detalhe os custos de nuvem por serviço"

📋 `provider_list`

Verificar o status do provedor

Confira os provedores configurados
Valide se as credenciais de API são válidas
Verificação de integridade de todas as integrações

Exemplos de uso:

"Liste todos os provedores de nuvem"
"Quais serviços de rastreamento de custos estão ativos?"

💰 `provider_balance`

Verificar saldo (Em breve)

Exibir saldo pré-pago
Monitorar o uso de créditos de API
Alertas antes do vencimento dos créditos

Instalação

Pré-requisitos

Node.js 18 ou superior
npm ou yarn
Conta no provedor de nuvem monitorado

O CI atualmente valida Node.js 18.x / 20.x / 22.x / 24.x, tratando 20.x como a principal via para upload de cobertura e verificações de build representativas.

# リポジトリのクローン
git clone https://github.com/knishioka/cost-management-mcp.git
cd cost-management-mcp

# 依存関係のインストール
npm install

# 環境変数の設定
cp .env.example .env
# .envファイルを編集して認証情報を追加

# ビルド
npm run build

Integração com o Claude Desktop

Adicione o seguinte ao arquivo de configuração do Claude Desktop:

{
  "mcpServers": {
    "cost-management": {
      "command": "node",
      "args": ["/path/to/cost-management-mcp/dist/index.js"],
      "env": {
        "AWS_ACCESS_KEY_ID": "your-key",
        "AWS_SECRET_ACCESS_KEY": "your-secret",
        "OPENAI_API_KEY": "your-key"
      }
    }
  }
}

Integração com o Claude Code

O Claude Code suporta servidores MCP de duas maneiras:

Método 1: Configuração específica do projeto (recomendado)

Crie um arquivo .mcp.json no diretório raiz do projeto:

{
  "mcpServers": {
    "cost-management": {
      "command": "node",
      "args": ["/absolute/path/to/cost-management-mcp/dist/index.js"],
      "env": {
        "AWS_ACCESS_KEY_ID": "your-aws-access-key",
        "AWS_SECRET_ACCESS_KEY": "your-aws-secret-key",
        "AWS_REGION": "us-east-1",
        "OPENAI_API_KEY": "sk-...your-openai-key",
        "ANTHROPIC_API_KEY": "sk-ant-admin-...your-admin-key",
        "CACHE_TTL": "3600",
        "LOG_LEVEL": "info"
      }
    }
  }
}

Esta configuração é carregada automaticamente quando o projeto é aberto no Claude Code.

Método 2: Configuração do VS Code (configuração global)

Abra as configurações do VS Code (Cmd/Ctrl + ,)
Pesquise por "Claude Code MCP Servers"
Clique em "Editar em settings.json"
Adicione a configuração do servidor de gerenciamento de custos:

{
  "claudeCode.mcpServers": {
    "cost-management": {
      "command": "node",
      "args": ["/absolute/path/to/cost-management-mcp/dist/index.js"],
      "env": {
        "AWS_ACCESS_KEY_ID": "your-aws-access-key",
        "AWS_SECRET_ACCESS_KEY": "your-aws-secret-key",
        "AWS_REGION": "us-east-1",
        "OPENAI_API_KEY": "sk-...your-openai-key",
        "GOOGLE_APPLICATION_CREDENTIALS": "/path/to/gcp-service-account.json",
        "GCP_BILLING_ACCOUNT_ID": "your-billing-account-id"
      }
    }
  }
}

Recarregue a janela do VS Code (Cmd/Ctrl + Shift + P → "Desenvolvedor: Recarregar janela")

Usando o servidor de gerenciamento de custos

Após a configuração, você pode fazer perguntas sobre custos de nuvem no Claude Code:

📊 「今月のAWSコストを教えて」
📈 「OpenAI APIの使用傾向を表示」
🔍 「サービス別にクラウド費用を分析」
💰 「全プロバイダーのコストを比較」

Nota de segurança:

Adicione o .mcp.json específico do projeto ao .gitignore para não commitar chaves de API
Considere usar variáveis de ambiente ou ferramentas de gerenciamento de segredos em produção
O cache é opcional - se não configurado, o servidor opera sem cache

Exemplos de Uso

今月のAWSのコストを教えて
過去7日間のOpenAI APIの使用料金は？
設定されているクラウドプロバイダーを一覧表示して

Configuração do Provedor

Consulte a documentação em inglês para obter instruções detalhadas de configuração de cada provedor.

Desenvolvimento

# 開発モード（ホットリロード付き）
npm run dev

# テストの実行
npm test

# リントチェック
npm run lint

# 型チェック
npm run typecheck

📊 Status do Projeto

Build e Testes

CI/CD: Testes automatizados em push e PR
Suporte a Node: O requisito mínimo de runtime é Node.js 18+. O CI valida 18.x / 20.x / 22.x / 24.x, tratando 20.x como a principal via para upload de cobertura e verificações de build
Cobertura: Suíte de testes abrangente com relatório de cobertura

Segurança

Verificação de Dependências: Atualizações automatizadas semanais
Detecção de Segredos: Monitoramento contínuo de credenciais expostas
Análise de Código: Verificação de segurança CodeQL

Qualidade

Segurança de Tipos: Configuração estrita de TypeScript
Linting: ESLint com correção automática no commit
Formatação: Formatação de código Prettier

Licença

Licença MIT

Construído com ❤️ usando TypeScript e MCP

Cost Management MCP

Documentação