Cost Management MCP

Un servidor para la gestión unificada de costos en varios proveedores de nube y servicios API.

Documentación

Cost Management MCP

Un servidor de Protocolo de Contexto de Modelo (MCP) para la gestión unificada de costos en proveedores de nube y servicios de API.

English | 日本語

🚀 Ejemplos rápidos

Una vez integrado con Claude Desktop, puedes preguntar:

📊 "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?"

Características

🔍 Seguimiento unificado de costos en AWS, OpenAI y Anthropic
💾 Caché inteligente para minimizar costos de API
📊 Rangos de fechas flexibles y opciones de granularidad
🔐 Gestión segura de credenciales mediante variables de entorno
🚀 Integración fácil con Claude Desktop y otros clientes MCP
⚡ Escrito en TypeScript con seguridad de tipos completa
🧪 Cobertura de pruebas exhaustiva
🔄 Lógica de reintento automático con retroceso exponencial
🛡️ Escaneo de seguridad con CodeQL y Trufflehog
📦 Actualizaciones automáticas de dependencias con Dependabot

🛠️ Herramientas MCP

Este servidor proporciona tres potentes herramientas para la gestión de costos:

📊 `cost_get`

Obtén desgloses detallados de costos

Consulta costos para cualquier rango de fechas
Filtra por proveedor específico (AWS, OpenAI, Anthropic)
Visualiza costos diarios, mensuales o totales
Consulta desgloses a nivel de servicio

Preguntas de ejemplo en Claude:

"¿Cuáles son mis costos de AWS de este mes?"
"Muéstrame el uso diario de OpenAI de la última semana"
"Desglosa mis costos de nube por servicio"

📋 `provider_list`

Verifica el estado de los proveedores

Consulta qué proveedores están configurados
Verifica que las credenciales de API sean válidas
Verificación rápida de salud para todas las integraciones

Ejemplos de uso:

"Lista todos mis proveedores de nube"
"¿Qué servicios de seguimiento de costos están activos?"

💰 `provider_balance`

Consulta créditos restantes (Próximamente)

Visualiza saldos prepagados
Monitorea el uso de créditos de API
Recibe alertas antes de que los créditos expiren

📊 `openai_costs`

Obtén uso detallado de OpenAI

Desglose por modelo (GPT-4, GPT-3.5, etc.)
Estadísticas de uso de tokens
Recomendaciones de optimización de costos

Ejemplos de uso:

"Muéstrame mis costos de OpenAI agrupados por modelo"
"¿Cuántos tokens usé con GPT-4 esta semana?"

🤖 `anthropic_costs`

Obtén uso detallado de Anthropic

Desglose por modelo (Claude 3.5 Sonnet, Haiku, etc.)
Estadísticas de uso de tokens con detalles de caché de prompt
Recomendaciones de optimización de costos
Soporte para las APIs de informe de costos y de uso

Ejemplos de uso:

"Muéstrame mis costos de Anthropic agrupados por modelo"
"¿Cuánto gasté en Claude 3.5 Sonnet este mes?"
"¿Cuáles son mis costos de Anthropic con detalles a nivel de token?"

☁️ `aws_costs`

Análisis de costos de AWS con información

Desglose a nivel de servicio (EC2, S3, RDS, etc.)
Filtra por servicio específico de AWS
Consejos automáticos de optimización de costos
Advertencias de gasto elevado

Ejemplos de uso:

"¿Cuáles son mis costos de EC2 este mes?"
"Muéstrame los costos de AWS agrupados por servicio"
"Dame consejos de optimización de costos de AWS"

📈 `provider_compare`

Compara costos entre proveedores

Comparación de costos lado a lado
Visualización con gráficos ASCII
Advertencias de bloqueo de proveedor
Información sobre distribución de costos

Ejemplos de uso:

"Compara mis costos en todos los proveedores de nube"
"Muéstrame un gráfico de costos por proveedor"
"¿Qué proveedor es el más caro?"

📊 `cost_trends`

Analiza tendencias de costos a lo largo del tiempo

Análisis histórico de costos (30d, 60d, 90d, 6m, 1y)
Detección de tendencias (creciente/decreciente/estable)
Análisis de volatilidad
Detección de picos
Granularidad diaria/semanal/mensual

Ejemplos de uso:

"Muéstrame las tendencias de costos de los últimos 30 días"
"¿Están aumentando mis costos de AWS?"
"Detecta picos de costos en el último mes"

🔍 `cost_breakdown`

Análisis detallado de desglose de costos

Desglose multidimensional (servicio, región, fecha, etiqueta)
Principales N impulsores de costos
Filtrado basado en porcentajes
Exploración jerárquica
Análisis de concentración de costos

Ejemplos de uso:

"Desglosa mis costos por servicio"
"Muéstrame los 5 principales impulsores de costos"
"¿Qué servicios representan el 80% de mis costos?"

📅 `cost_periods`

Compara costos entre períodos de tiempo

Comparación período a período
Cambios absolutos y porcentuales
Seguimiento de cambios a nivel de servicio
Comparación de promedios diarios
Detección de servicios nuevos/descontinuados

Ejemplos de uso:

"Compara este mes con el mes pasado"
"¿Cuánto aumentaron los costos desde el primer trimestre?"
"¿Qué servicios crecieron más?"

Instalación

Requisitos previos

Node.js 18 o superior
npm o yarn
Cuentas activas con los proveedores de nube que deseas monitorear

CI actualmente verifica Node.js 18.x, 20.x, 22.x y 24.x. Node.js 20.x es la vía principal para la cobertura de carga y las comprobaciones de compilación representativas.

Pasos

Clona el repositorio:

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

Instala las dependencias:

npm install

Copia la plantilla de entorno:

cp .env.example .env

Edita .env y agrega tus credenciales (consulta Configuración de proveedores)
Compila el proyecto:

npm run build

Inicio rápido

Ejecución independiente

# Development mode (with hot reload)
npm run dev

# Production mode
npm start

Integración con Claude Desktop

Compila el proyecto primero:

npm run build

Agrega a tu configuración de Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json en 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"
      }
    }
  }
}

Reinicia Claude Desktop
Usa las herramientas en tu conversación:

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.

Integración con Claude Code

Claude Code admite servidores MCP mediante dos métodos de configuración:

Método 1: Configuración específica del proyecto (Recomendado)

Crea un archivo .mcp.json en la raíz de tu proyecto:

{
  "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 configuración se cargará automáticamente cuando abras el proyecto en Claude Code.

Método 2: Configuración de VS Code (Configuración global)

Abre la Configuración de VS Code (Cmd/Ctrl + ,)
Busca "Claude Code MCP Servers"
Haz clic en "Editar en settings.json"
Agrega la configuración del servidor de gestión de costos:

{
  "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"
      }
    }
  }
}

Recarga la ventana de VS Code (Cmd/Ctrl + Shift + P → "Developer: Reload Window")

Uso del servidor de gestión de costos

Una vez configurado, puedes preguntar a Claude Code sobre tus costos de nube:

📊 "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 seguridad:

Para .mcp.json específico del proyecto, agrégalo a .gitignore para evitar comprometer claves de API sensibles
Considera usar variables de entorno o un administrador de secretos para producción
La caché es opcional: si no está configurada, el servidor funcionará sin caché

Herramientas disponibles

cost_get

Recupera datos de costos para proveedores y períodos de tiempo especificados.

Parámetros:

provider (opcional): Proveedor específico a consultar ('aws', 'openai', 'anthropic')
startDate (obligatorio): Fecha de inicio en formato YYYY-MM-DD
endDate (obligatorio): Fecha de fin en formato YYYY-MM-DD
granularity (opcional): 'daily', 'monthly' o 'total' (predeterminado: 'total')
groupBy (opcional): Matriz de dimensiones para agrupar (por ejemplo, ['SERVICE', 'REGION'])

Solicitud de ejemplo:

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

Respuesta de ejemplo:

{
  "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

Lista todos los proveedores configurados y su estado de conexión.

La respuesta incluye:

Nombre del proveedor
Estado de configuración
Estado de validación de credenciales

Respuesta de ejemplo:

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

provider_balance

Consulta el saldo o créditos restantes (específico del proveedor). Nota: Actualmente no implementado para la mayoría de los proveedores

Configuración de proveedores

AWS

Habilita Cost Explorer en la consola de AWS
- Navega a AWS Cost Management → Cost Explorer
- Haz clic en "Enable Cost Explorer" (⚠️ Esta acción es irreversible)
- Espera 24 horas para que los datos estén disponibles

Crea un usuario de IAM con permisos mínimos:

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

Configura las variables de entorno:

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: AWS cobra $0.01 por solicitud a la API de Cost Explorer. La caché está habilitada por defecto (1 hora) para minimizar costos.

OpenAI

Obtén una clave de API desde OpenAI Dashboard
Asegúrate de tener:
- Una cuenta de pago con historial de uso
- Acceso a la API habilitado
Configura la variable de entorno:
```
OPENAI_API_KEY=sk-...your-api-key
```

⚠️ Nota: La API de uso es relativamente nueva (diciembre de 2024). Asegúrate de que tu cuenta tenga acceso.

Anthropic

Obtén una clave de API de administrador desde Anthropic Console
Requisitos:
- Cuenta de organización (las cuentas individuales no son compatibles)
- Rol de administrador para aprovisionar claves de API de administrador
- La clave de API de administrador comienza con sk-ant-admin... (diferente de las claves de API regulares)

Configura la variable de entorno:

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

⚠️ Notas importantes:

Solo las claves de API de administrador pueden acceder a datos de costos y uso
Los datos de costos están disponibles a través de dos APIs:
- API de informe de costos: Proporciona datos de facturación reales en USD
- API de informe de uso: Proporciona detalles a nivel de token con costos calculados
Los datos generalmente aparecen dentro de los 5 minutos posteriores a la finalización de la solicitud de API
Admite el seguimiento de costos de caché de prompt

Configuración

Variables de entorno

Variable	Descripción	Predeterminado	Obligatoria
`AWS_ACCESS_KEY_ID`	Clave de acceso de AWS	-	Para AWS
`AWS_SECRET_ACCESS_KEY`	Clave secreta de AWS	-	Para AWS
`AWS_REGION`	Región de AWS	us-east-1	Para AWS
`OPENAI_API_KEY`	Clave de API de OpenAI	-	Para OpenAI
`ANTHROPIC_API_KEY`	Clave de API de administrador de Anthropic	-	Para Anthropic
`CACHE_TTL`	Tiempo de vida de la caché en segundos	3600	No
`CACHE_TYPE`	Backend de caché (memory/redis)	memory	No
`REDIS_URL`	URL de conexión de Redis	-	Si se usa Redis
`LOG_LEVEL`	Verbosidad de registro (debug/info/warn/error)	info	No
`MCP_SERVER_PORT`	Puerto del servidor	3000	No

Configuración de caché

La caché ayuda a reducir los costos de API y mejorar el rendimiento:

Caché de memoria (predeterminada): Rápida, sin configuración necesaria, los datos se pierden al reiniciar
Caché de Redis: Persistente, compartida entre instancias, requiere servidor Redis

Para usar Redis:

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

Registro

Se utiliza registro JSON estructurado para facilitar el análisis:

# 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")'

Desarrollo

Estructura del proyecto

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

Agregar un nuevo proveedor

Crea el directorio del proveedor:

mkdir -p src/providers/newprovider

Implementa los archivos requeridos:

types.ts - Interfaces de TypeScript
transformer.ts - Convierte la respuesta de API al formato unificado
client.ts - Cliente de API que implementa ProviderClient
index.ts - Exportaciones públicas

Actualiza server.ts para incluir el nuevo proveedor
Agrega pruebas en tests/providers/newprovider/

Pruebas

Las pruebas usan Jest con soporte de 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

Arquitectura

Principios de diseño

Interfaz unificada: Todos los proveedores implementan la misma interfaz ProviderClient
Resiliencia ante errores: Reintento automático con retroceso exponencial
Optimización de costos: Caché agresiva para minimizar llamadas de API
Seguridad de tipos: Cobertura completa de TypeScript con modo estricto
Extensibilidad: Fácil de agregar nuevos proveedores o herramientas

Flujo de datos

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

Manejo de errores

El sistema implementa una estrategia de manejo de errores jerárquica:

Errores de Proveedor: Específicos de cada proveedor de nube
Errores de Autenticación: Credenciales inválidas o expiradas
Errores de Límite de Tasa: Reintento automático con retroceso
Errores de Validación: Parámetros de entrada inválidos
Errores de Red: Problemas de conexión reintentables

Solución de Problemas

Problemas Comunes

Error de "Autenticación fallida"

Verifique que sus claves/credenciales de API sean correctas
Compruebe que las credenciales tengan los permisos requeridos
Para AWS, asegúrese de usar la región us-east-1 para Cost Explorer

No se devuelven datos de costos

AWS: Espere 24 horas después de habilitar Cost Explorer
OpenAI: Verifique que tenga una cuenta de pago con uso

Costos altos de AWS

La API de Cost Explorer cobra $0.01 por solicitud
Aumente CACHE_TTL para reducir las llamadas a la API
Use caché de Redis para persistencia entre reinicios

Error de "Límite de tasa excedido"

El sistema reintenta automáticamente con retroceso exponencial
Si persiste, verifique sus cuotas de API
Considere aumentar el TTL de la caché

Modo de Depuración

Habilite el registro de depuración para obtener más información:

LOG_LEVEL=debug npm run dev

Verificación de Salud

Pruebe proveedores individuales:

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

Contribuciones

¡Agradecemos las contribuciones! Consulte nuestra Guía de Contribución para más detalles.

Flujo de Trabajo de Desarrollo

Haga un fork del repositorio
Cree una rama de características: git checkout -b feature/your-feature
Realice sus cambios
Agregue pruebas para la nueva funcionalidad
Asegúrese de que todas las pruebas pasen: npm test
Ejecute el linter en su código: npm run lint
Haga un commit con un mensaje descriptivo
Haga push a su fork y envíe un PR

Estilo de Código

Siga las mejores prácticas de TypeScript
Use nombres de variables significativos
Agregue comentarios JSDoc para APIs públicas
Mantenga las funciones pequeñas y enfocadas
Escriba pruebas para nuevas características

📊 Estado del Proyecto

Compilación y Pruebas

CI/CD: Pruebas automatizadas en push y PR
Soporte de Node: El requisito mínimo de ejecución es Node.js 18+. CI verifica 18.x, 20.x, 22.x y 24.x, con 20.x como la vía principal para la carga de cobertura y verificaciones de compilación representativas.
Cobertura: Suite de pruebas integral con informes de cobertura

Seguridad

Escaneo de Dependencias: Actualizaciones automáticas semanales
Detección de Secretos: Monitoreo continuo de credenciales expuestas
Análisis de Código: Escaneo de seguridad CodeQL

Calidad

Seguridad de Tipos: Configuración estricta de TypeScript
Linting: ESLint con corrección automática al hacer commit
Formato: Formato de código Prettier

Licencia

Licencia MIT: consulte el archivo LICENSE para más detalles

Documentación en Japonés

Resumen

Cost Management MCP es un servidor de Protocolo de Contexto de Modelo (MCP) para gestionar de manera unificada los costos de múltiples proveedores de nube y servicios de API.

Características Principales

🔍 Gestión centralizada de costos de AWS, OpenAI y Anthropic
💾 Caché inteligente para minimizar los costos de API
📊 Opciones flexibles de rango de fechas y agregación
🔐 Gestión segura de credenciales mediante variables de entorno
🚀 Integración sencilla con Claude Desktop
⚡ Seguridad de tipos con TypeScript
🧪 Cobertura de pruebas integral
🔄 Reintento automático con retroceso exponencial
🛡️ Escaneos de seguridad con CodeQL y Trufflehog
📦 Actualizaciones automáticas de dependencias con Dependabot

🛠️ Herramientas MCP Disponibles

Este servidor proporciona tres potentes herramientas para la gestión de costos:

📊 `cost.get`

Obtener desglose detallado de costos

Verifique costos para cualquier período
Filtre por proveedor específico (AWS, OpenAI)
Muestre costos diarios, mensuales o totales
Consulte desgloses a nivel de servicio

Ejemplos de uso con Claude:

"Dime los costos de AWS de este mes"
"Muestra el uso diario de OpenAI de la última semana"
"Desglosa los costos de nube por servicio"

📋 `provider_list`

Verificar el estado de los proveedores

Confirme los proveedores configurados
Valide si las credenciales de API son válidas
Verifique la salud de todas las integraciones

Ejemplos de uso:

"Lista todos los proveedores de nube"
"¿Qué servicios de seguimiento de costos están activos?"

💰 `provider_balance`

Verificar saldos (Próximamente)

Mostrar saldos prepagados
Monitorear el uso de créditos de API
Alertas antes del vencimiento de créditos

Instalación

Requisitos Previos

Node.js 18 o superior
npm o yarn
Cuenta en el proveedor de nube a monitorear

CI actualmente verifica Node.js 18.x / 20.x / 22.x / 24.x, y trata 20.x como la vía principal para la carga de cobertura y verificaciones de compilación 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

Integración con Claude Desktop

Agregue lo siguiente al archivo de configuración de 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"
      }
    }
  }
}

Integración con Claude Code

Claude Code admite servidores MCP de dos maneras de configuración:

Método 1: Configuración específica del proyecto (recomendado)

Cree un archivo .mcp.json en el directorio raíz del proyecto:

{
  "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 configuración se carga automáticamente cuando abre el proyecto con Claude Code.

Método 2: Configuración de VS Code (configuración global)

Abra la configuración de VS Code (Cmd/Ctrl + ,)
Busque "Claude Code MCP Servers"
Haga clic en "Editar en settings.json"
Agregue la configuración del servidor de gestión de costos:

{
  "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"
      }
    }
  }
}

Recargue la ventana de VS Code (Cmd/Ctrl + Shift + P → "Desarrollador: Recargar ventana")

Uso del servidor de gestión de costos

Una vez configurado, puede hacer preguntas sobre costos de nube en Claude Code:

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

Nota de seguridad:

Agregue el .mcp.json específico del proyecto a .gitignore para no hacer commit de las claves de API
Considere usar variables de entorno o herramientas de gestión de secretos en producción
La caché es opcional: si no está configurada, el servidor funciona sin caché

Ejemplos de Uso

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

Configuración de Proveedores

Consulte la documentación en inglés para conocer los métodos de configuración detallados de cada proveedor.

Desarrollo

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

# テストの実行
npm test

# リントチェック
npm run lint

# 型チェック
npm run typecheck

📊 Estado del Proyecto

Compilación y Pruebas

CI/CD: Pruebas automatizadas en push y PR
Soporte de Node: El requisito mínimo de ejecución es Node.js 18+. CI verifica 18.x / 20.x / 22.x / 24.x, y trata 20.x como la vía principal de carga de cobertura y verificación de compilación
Cobertura: Suite de pruebas integral con informes de cobertura

Seguridad

Escaneo de Dependencias: Actualizaciones automáticas semanales
Detección de Secretos: Monitoreo continuo de credenciales expuestas
Análisis de Código: Escaneo de seguridad CodeQL

Calidad

Seguridad de Tipos: Configuración estricta de TypeScript
Linting: ESLint con corrección automática al hacer commit
Formato: Formato de código Prettier

Licencia

Licencia MIT

Construido con ❤️ usando TypeScript y MCP

Cost Management MCP

Documentación