Auxiliar MCP vs Cloudcostsmcp

compare_bom

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, "memory_gb": 32}, "storage": {"type": "storage", "storage_gb": 500, "storage_type": "ssd"} } Multi-disk storage (gp3/io2 vs pd-ssd/pd-extreme): providers:["aws","gcp"], workload:{"p_a":{"type":"storage","storage_gb":10000,"storage_type":"gp3","iops":3000},"p_c":{"type":"storage","storage_gb":500,"storage_type":"io2","iops":64000}}

compare_bom_regions

Compare a Bill of Materials' total monthly cost across multiple regions. v1 scope: PricingSpec-dict items are AWS-only. Each item is an open PricingSpec dict, same shape as estimate_bom's items (provider, domain, resource_type/region/etc, plus quantity/hours_per_month/size_gb/description) — or a raw-SKU dict (sku, region, provider, plus optional service/operation/product_family) for a CUR usage-type/SKU string (provider="aws"), a GCP Cloud Billing Catalog skuId string (provider="gcp"; operation/ product_family are ignored for GCP), or an Azure Retail Prices API meterId string (provider="azure"; operation is ignored, product_family has Azure-specific meaning — see get_price_by_sku). Unlike get_price_by_sku, provider is REQUIRED on raw-SKU items here (no default) — a single call commonly compares items from different providers across the same regions, so a missing provider is reported once under "not_supported" (see below) rather than guessed. The region field on each item is overridden per comparison — pass any region in the item dicts. A region's region_name is only populated from the region-code display maps when every resolvable item in the call shares one provider; a mixed-provider call (e.g. an AWS item and a GCP item together) falls back to the bare region code instead of guessing whose naming applies. Weighting and a providers filter are not supported yet. Unsupported items (a PricingSpec-dict item naming a non-AWS provider, or a raw-SKU item naming a provider other than aws/gcp/azure, or a raw-SKU item with no provider at all) are reported once under "not_supported" rather than guessed or dropped silently; full GCP/Azure PricingSpec-dict support is tracked separately. Returns regions[] sorted cheapest-first, each with total_monthly, the resolved line_items, and any per-item errors. Optionally shows delta vs a baseline region. Args: items: List of PricingSpec dicts (same shape as estimate_bom, AWS-only) — or raw-SKU dicts (sku, region, plus required provider "aws", "gcp", or "azure", plus optional service/operation/product_family). See estimate_bom for full item format. regions: List of region codes to compare, e.g. ["us-east-1", "eu-west-1"]. baseline_region: Optional region for delta comparison, e.g. "us-east-1".

compare_prices

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

describe_catalog

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.

estimate_bom

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). An item may instead be a raw-SKU dict: {"sku": "...", "provider": "aws", "region": "us-east-1", "quantity": 3} — the same raw CUR usage-type/SKU string (provider "aws"), GCP Cloud Billing Catalog skuId string (provider "gcp"), or Azure Retail Prices API meterId string (provider "azure") get_price_by_sku resolves. Unlike get_price_by_sku, provider is REQUIRED here (no default) — a BoM commonly mixes items from different providers in one call, so a missing provider is rejected with a clear error rather than guessed. Optionally add service/operation/product_family hints to disambiguate (operation is AWS-only, ignored for provider "gcp"/"azure"; product_family is AWS-only for the productFamily-matching behavior described in get_price_by_sku, but carries different Azure-specific meaning — see get_price_by_sku — for provider "azure", and is ignored for provider "gcp"). A GCP SKU with usage-volume tiers is costed at the tier matching this item's quantity. 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} ]

estimate_unit_economics

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.

find_available_regions

Find all regions where a specific service/instance type is available, cheapest first. All fields must be nested under "spec" — do not pass provider/domain/resource_type etc. as top-level arguments. Example call: {"spec": {"provider": "aws", "domain": "compute", "resource_type": "m5.xlarge", "region": "us-east-1"}} 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.

find_cheapest_region

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

get_coverage

Report which domains/services this server actually covers, per provider. v1 scope: structural coverage from the catalog only — each domain is reported as "catalog" (with its known services) unless the provider has no entry for it at all. This does NOT fan out a live get_price call per region — whether a specific region's live price is a real catalog rate or a degraded fallback constant is only observable by calling get_price for that spec and checking its "fallback" field, since that is a live fetch outcome rather than a fixed property of the catalog. Use this to answer "what does this server know about" before trial- and-error against describe_catalog and individual get_price calls. Args: provider: Cloud provider — "aws", "gcp", or "azure". Empty = all configured providers.

get_discount_summary

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)

get_price

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", "source_region": "us-east-1", "dest_region": "eu-west-1"} Returns public_prices[] always. When auth exists: contracted_prices[], effective_price, auth_available=true. Call describe_catalog(provider, domain, service) for an example_invocation you can copy directly into this tool. Args: spec: PricingSpec dict — see field descriptions above. Examples: {"provider": "aws", "domain": "compute", "resource_type": "m5.xlarge", "region": "us-east-1"} {"provider": "aws", "domain": "ai", "service": "bedrock", "model": "claude-3-5-sonnet", "region": "us-east-1", "input_tokens": 1000000, "output_tokens": 1000000} {"provider": "gcp", "domain": "compute", "resource_type": "n1-standard-4", "region": "us-central1", "term": "cud_1yr"} {"provider": "gcp", "domain": "analytics", "service": "bigquery", "query_tb": 10.0, "active_storage_gb": 500.0, "region": "us"} {"provider": "azure", "domain": "compute", "resource_type": "Standard_D4s_v3", "region": "eastus"} {"provider": "aws", "domain": "database", "service": "rds", "resource_type": "db.r5.large", "engine": "MySQL", "deployment": "single-az", "region": "us-east-1"}