# io.github.x7even/cloudcostsmcp (pypi · opencloudcosts)

Anchor AI FinOps to real, live cloud pricing — AWS, GCP & Azure public and enterprise rates.

- Trust score: 20/100 (low)
- Change this week: −22
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- pypi · `opencloudcosts`: 20/100 (this document), [markdown](https://verifymcp.io/servers/x7even-cloudcostsmcp/opencloudcosts.md), [page](https://verifymcp.io/servers/x7even-cloudcostsmcp/opencloudcosts)

## Channel facts

- Registry: `pypi`
- Package: `opencloudcosts`
- Version: `1.0.2`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Supply Chain Security**: 38/100
  - Malware scan not yet available for this package.
  - No known CVEs affecting this package version or its production dependencies.
  - Install-script risk not yet assessed.
  - No production dependencies, so there is no dependency health to assess.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 24 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 0/100
  - Schema quality not yet verified: our sandbox run of this package did not complete, so we have no schema to assess.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: our sandbox run of this package did not complete, so we have no schema to compare.
- **Tool Coverage**: 0/100
  - Tool coverage not yet verified: our sandbox run of this package did not complete, so we have no tool definitions to assess.
- **Capabilities**: 0/100
  - Protocol version not yet verified: our sandbox run of this package did not complete, so we never saw its MCP handshake.

**Unverified: 4 categories.** Categories scored 0 because our sandbox run of this package has not given us the schema these checks need to read. That is a gap on our side rather than a finding about the package, and we only credit what we can confirm, so the score stands at 0 until the capture succeeds. We are working through the fleet, so this normally clears without any action from you.

## Install

### Claude

```bash
claude mcp add x7even-cloudcostsmcp -- uvx opencloudcosts
```

### Codex

```bash
codex mcp add x7even-cloudcostsmcp -- uvx opencloudcosts
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "x7even-cloudcostsmcp": {
      "type": "local",
      "command": [
        "uvx",
        "opencloudcosts"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add x7even-cloudcostsmcp --command uvx --arg opencloudcosts
```

### Hermes

```yaml
mcp_servers:
  x7even-cloudcostsmcp:
    command: "uvx"
    args: ["opencloudcosts"]
```

### Other

```json
{
  "mcpServers": {
    "x7even-cloudcostsmcp": {
      "command": "uvx",
      "args": [
        "opencloudcosts"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-07-31 (score 20, −4)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 24, −18)

- [security regression] Malware scan: pass → unverified

### 2026-07-28 (score 42, 0)

- [functional] Tool coverage: Tool coverage not yet verified: our sandbox run of this package did not complete, so we have no tool definitions to assess.
- [functional] Schema quality: Schema quality not yet verified: our sandbox run of this package did not complete, so we have no schema to assess.

### 2026-07-26 (score 42)

First indexed and scored.

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

## MCP tools (16)

### `cache_stats` (~22 tokens)

Return statistics about the local pricing cache (entry counts, DB size).

### `compare_bom` (~718 tokens)

Price a multi-service workload across multiple cloud providers simultaneously and return a side-by-side cost comparison. Use this when the user wants to compare total costs across AWS, GCP, and/or Azure for the same infrastructure.

OUTPUT FORMAT — aggregate totals only: for each workload key, storage capacity, provisioned IOPS, and provisioned throughput costs are summed into ONE number in the breakdown map. This tool does NOT return separate line items for storage $, IOPS $, and throughput $. If the user asks for a cost breakdown with storage capacity, provisioned IOPS, and provisioned throughput as separate line items per disk, use estimate_bom instead — it returns one row per price component.

Storage: accepts abstract tiers ("ssd" → gp3/pd-ssd/premium-ssd, "hdd" → sc1/pd-standard/standard-hdd) or provider-specific types (gp3, io2, sc1, pd-ssd, pd-extreme, hyperdisk-extreme, etc.) with iops and throughput_mbps for IOPS pricing. Use compare_bom when a provider-vs-provider total-cost summary is sufficient.

Returns per-provider totals keyed by pricing term, a breakdown map (workload_key → aggregate monthly $), committed vs on-demand savings, and any supplementary costs not included in the estimate.

The workload is described in cloud-agnostic terms (vcpus, memory_gb, storage_gb) — the tool selects the closest equivalent instance type per provider automatically.

Args:
    providers: Which providers to compare — ["aws", "gcp", "azure"] (default: all three).
    region_preference: Region tier — "us" (default), "eu", "apac".
    workload: Map of logical name → resource spec. Each spec needs 'type' (compute/storage/database/cache) plus vcpus, memory_gb, quantity, etc.
    terms: Pricing terms — default ["on_demand", "reserved_1yr"]. Term translation is automatic: reserved_1yr maps to cud_1yr for GCP.

Example:
    workload: {
      "web_servers": {"type": "compute", "vcpus": 4, "memory_gb": 16, "quantity": 3},
      "database":    {"type": "database", "vcpus": 8, "me…

Input parameters:

- `providers` (array): Which providers to compare. Defaults to all three.
- `region_preference` (string): Preferred region tier: 'us' (US regions), 'eu' (Europe), 'apac' (Asia-Pacific).
- `terms` (array): Pricing terms to include. Common values: on_demand, reserved_1yr, cud_1yr. Default: ['on_demand', 'reserved_1yr'].
- `workload` (object, required): Cloud-agnostic workload description. Each key is a logical service name.

### `compare_prices` (~159 tokens)

Compare pricing for any service across multiple regions.

        Fetches concurrently. Returns results sorted cheapest first, with % delta between
        cheapest and most expensive. Optionally shows delta vs a baseline region.

        Args:
            spec: PricingSpec dict (same as get_price). The region field is overridden
                  per comparison — you can pass any region in the spec.
            regions: List of region codes to compare, e.g. ["us-east-1", "eu-west-1", "ap-northeast-1"]
            baseline_region: Optional region for delta comparison, e.g. "us-east-1".

Input parameters:

- `baseline_region` (string)
- `regions` (array, required)
- `spec` (object, required)

### `describe_catalog` (~217 tokens)

Discover what each provider supports and how to call get_price.

        - No args → full support matrix across all configured providers.
        - provider only → all domains/services for that provider.
        - provider + domain [+ service] → targeted guidance with required_fields,
          supported_terms, filter_hints, and a ready-to-use example_invocation
          you can pass directly to get_price.

        Use this before get_price when unsure of exact field names or values.

        Args:
            provider: Cloud provider — "aws", "gcp", or "azure". Empty = all providers.
            domain: Domain — "compute", "storage", "database", "ai", "container",
                    "serverless", "analytics", "network", "observability". Empty = all.
            service: Service — e.g. "bedrock", "rds", "gke", "bigquery". Empty = all.

Input parameters:

- `domain` (string)
- `provider` (string)
- `service` (string)

### `estimate_bom` (~495 tokens)

Use this tool for total infrastructure cost, TCO, monthly spend for a multi-resource
        stack, or cost comparison between architectures.

        Handles compute + storage + database + AI together in a single call — do NOT call
        get_price individually for multi-resource questions; use this tool instead.

        Returns per-item and total monthly/annual costs with real public pricing data,
        plus a not_included list of supplementary costs (egress, load balancers, monitoring).
        These are SUPPLEMENTARY — only price them if the user asked for TCO; for most
        questions just note 'additional costs may apply'.

        Each item should be a PricingSpec dict PLUS a quantity field:
          - provider: "aws" | "gcp" | "azure"
          - domain: "compute" | "storage" | "database" | "ai" | ...
          - region: region code
          - quantity: number of units (default 1)
          - hours_per_month: hours/month for compute (default 730 = always-on)
          - description: optional label for this line item
          Plus domain-specific fields (see get_price or describe_catalog for details).

        Examples:
          Compute + database + storage on AWS:
          [
            {"provider": "aws", "domain": "compute", "resource_type": "m5.xlarge",   "region": "us-east-1", "quantity": 3},
            {"provider": "aws", "domain": "database", "service": "rds", "resource_type": "db.r6g.large", "engine": "MySQL", "deployment": "single-az", "region": "us-east-1"},
            {"provider": "aws", "domain": "storage",  "storage_type": "gp3", "size_gb": 500, "region": "us-east-1"}
          ]

          Mixed cloud:
          [
            {"provider": "gcp",   "domain": "compute", "resource_type": "n1-standard-4", "region": "us-central1", "quantity": 2},
            {"provider": "azure", "domain": "compute", "resource_type": "Standard_D4s_v3", "region": "eastus", "quantity": 1}
          ]

Input parameters:

- `items` (array, required)

### `estimate_unit_economics` (~140 tokens)

Estimate per-unit economics (cost per user, per request, per transaction) given
        a Bill of Materials and expected monthly usage volume.

        Args:
            items: Same format as estimate_bom — list of cloud resource PricingSpec dicts
                   plus quantity field. See estimate_bom for full item format.
            units_per_month: Monthly volume being measured (e.g. 10000 users)
            unit_label: What the unit represents — "user", "request", "transaction", etc.

Input parameters:

- `items` (array, required)
- `unit_label` (string)
- `units_per_month` (number, required)

### `find_available_regions` (~115 tokens)

Find all regions where a specific service/instance type is available, cheapest first.

        Args:
            spec: PricingSpec dict (same as get_price). The region field is overridden
                  per comparison — pass any region in the spec.
            regions: Region codes to check. Omit for major regions.
                     Pass ["all"] to search every available region.
            baseline_region: Optional region for delta comparison.

Input parameters:

- `baseline_region` (string)
- `regions`
- `spec` (object, required)

### `find_cheapest_region` (~157 tokens)

Find the cheapest region for any cloud service.

        Queries pricing concurrently across regions and returns results sorted cheapest
        first, with the price delta between cheapest and most expensive regions.

        Args:
            spec: PricingSpec dict (same as get_price). The region field is overridden
                  for each comparison — pass any region in the spec.
            regions: List of region codes to compare. Omit for major regions (faster).
                     Pass ["all"] to search every available region (slow on first run without cache).
            baseline_region: Optional region for delta comparison, e.g. "us-east-1".

Input parameters:

- `baseline_region` (string)
- `regions`
- `spec` (object, required)

### `get_discount_summary` (~115 tokens)

Return a summary of all active cloud discounts for the authenticated account.

        For AWS: active Savings Plans (type, commitment $/hr, utilization %) and
        active Reserved Instances (instance type, count, payment type, days remaining),
        plus Cost Explorer utilization for the previous month.

        Requires credentials and OCC_AWS_ENABLE_COST_EXPLORER=true for AWS.

        Args:
            provider: Cloud provider — "aws" (GCP CUD support coming later)

Input parameters:

- `provider` (string)

### `get_price` (~899 tokens)

Unified pricing tool — returns public catalog rates plus contracted/effective prices
        where credentials are available.

        Pass a spec dict with at minimum: provider, domain, region.
        Domain-specific required fields (call describe_catalog for the complete list):

          COMPUTE  : resource_type ("m5.xlarge" / "n1-standard-4" / "Standard_D4s_v3")
                     os ("Linux" or "Windows"), term ("on_demand"/"spot"/"cud_1yr")
                     Fargate: vcpu (e.g. 2.0), memory_gb (e.g. 4.0), service="fargate"
          STORAGE  : storage_type ("gp3"/"io2"/"sc1"/"standard"/"nearline"/"pd-extreme"/"hyperdisk-extreme"/"premium-ssd")
                     size_gb — disk size for monthly estimate
                     iops — provisioned IOPS for io1/io2 (AWS) or pd-extreme/hyperdisk-extreme (GCP)
                     throughput_mbps — provisioned throughput MB/s for gp3 (AWS); charge above 125 MB/s baseline
          DATABASE : resource_type ("db.r5.large"/"db-n1-standard-4"), engine ("MySQL"),
                     deployment ("single-az"/"ha"/"multi-az"), service ("rds"/"cloud_sql"/"memorystore")
          AI       : model ("claude-3-5-sonnet"/"gemini-1.5-flash"), service ("bedrock"/"gemini"/"vertex"),
                     input_tokens, output_tokens  |  machine_type + task for Vertex
          CONTAINER: service ("gke"/"eks"), mode ("standard"/"autopilot"), node_count, vcpu, memory_gb
          ANALYTICS: service ("bigquery"), query_tb, active_storage_gb, longterm_storage_gb, streaming_gb
          NETWORK  : service ("cloud_lb"/"cloud_cdn"/"cloud_nat"/"cloud_armor"),
                     lb_type, rule_count, data_gb, gateway_count, egress_gb, policy_count
          OBSERVABILITY: service ("cloudwatch"/"cloud_monitoring"), ingestion_mib, log_gb
          INTER_REGION_EGRESS: source_region, dest_region (empty = internet), data_gb
                     Example: {"provider": "aws", "domain": "inter_region_egress",…

Input parameters:

- `spec` (object, required)

### `get_prices_batch` (~220 tokens)

Get prices for multiple compute instance types in a single region in one call.

        Fetches all prices concurrently. Useful for comparing a shortlist of candidate
        instance types (e.g. m5.xlarge vs c5.xlarge vs r5.xlarge) without separate calls.

        Args:
            provider: Cloud provider — "aws", "gcp", or "azure"
            instance_types: List of instance types, e.g. ["m5.xlarge", "c5.xlarge", "r5.large"]
            region: Region code, e.g. "us-east-1" or "us-central1"
            os: Operating system — "Linux" (default) or "Windows"
            term: Pricing term — "on_demand" (default), "spot", "reserved_1yr", "cud_1yr"

Input parameters:

- `instance_types` (array, required)
- `os` (string)
- `provider` (string, required)
- `region` (string, required)
- `term` (string)

### `get_spot_history` (~52 tokens)

get_spot_history is not available. For spot pricing, use get_price with term="spot" to look up current spot prices, or use list_instance_types to browse instance families and their spot price ranges.

### `list_instance_types` (~181 tokens)

List available compute instance types matching the given filters.

        Args:
            provider: Cloud provider — "aws", "gcp", or "azure"
            region: Region code, e.g. "us-east-1" (AWS), "us-central1" (GCP), "eastus" (Azure)
            family: Instance family prefix filter, e.g. "m5" (AWS), "n2" (GCP)
            min_vcpu: Minimum vCPU count filter
            min_memory_gb: Minimum memory in GB filter
            gpu: If True, only return GPU-enabled instance types

Input parameters:

- `family` (string)
- `gpu` (boolean)
- `min_memory_gb`
- `min_vcpu`
- `provider` (string, required)
- `region` (string, required)

### `list_regions` (~77 tokens)

List all regions where a cloud service is available for the given provider.

        Args:
            provider: Cloud provider — "aws", "gcp", or "azure"
            domain: Domain filter — "compute" (default), "storage", "database"

Input parameters:

- `domain` (string)
- `provider` (string, required)

### `refresh_cache` (~58 tokens)

Invalidate the pricing cache to force fresh data on next request.

        Args:
            provider: Provider to clear ("aws", "gcp", "azure"), or empty string to purge expired entries.

Input parameters:

- `provider` (string)

### `search_pricing` (~37 tokens)

Deprecated helper that redirects to the correct tools. Use describe_catalog to browse available services by domain/provider, or get_price with a known spec.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/x7even-cloudcostsmcp/opencloudcosts#diagnostics

## Score history

- 2026-08-03: 20
- 2026-08-02: 20
- 2026-08-01: 20
- 2026-07-31: 20
- 2026-07-30: 24
- 2026-07-28: 42
- 2026-07-27: 42
- 2026-07-26: 42

## Links

- PyPI project: https://pypi.org/project/opencloudcosts/
- Socket report: https://socket.dev/pypi/package/opencloudcosts
- Repository: https://github.com/x7even/cloudcostsmcp
- Changelog RSS feed: https://verifymcp.io/servers/x7even-cloudcostsmcp/opencloudcosts/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/x7even-cloudcostsmcp/opencloudcosts/changelog.json
- HTML version of this page: https://verifymcp.io/servers/x7even-cloudcostsmcp/opencloudcosts