Return statistics about the local pricing cache (entry counts, DB size), including a per-provider/service breakdown and as_of age of the most recent write.
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 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 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".
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.
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 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 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 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".
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.
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)
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"}
+9 more tools listed on main page