OpenCloudCosts MCP
OpenCloudCosts MCP provides live, structured access to AWS, GCP, and Azure pricing data through 16 tools, enabling AI assistants to perform accurate cost analysis and FinOps operations with real-time data rather than stale training knowledge.
Core Pricing
get_price— Fetch live pricing for any cloud resource (compute, storage, database, AI models, containers, analytics, networking, observability, egress) across AWS, GCP, and Azureget_prices_batch— Compare multiple instance types in a single region in one concurrent callcompare_prices— Compare pricing for any service across multiple regions, sorted cheapest-first with % deltassearch_pricing— Free-text search across the pricing catalogget_spot_history— Spot price history and stability analysis per AZ
FinOps & Cost Analysis
estimate_bom— Price a full multi-resource stack (compute + storage + database + AI) in one call, returning per-item and total monthly/annual costsestimate_unit_economics— Calculate cost per user, per request, or per transaction given a bill of materials and usage volumecompare_bom— Cross-cloud workload comparison across AWS, GCP, and Azure simultaneously, with on-demand and committed-term breakdowns and savings analysisget_discount_summary— Summarize active AWS Savings Plans, Reserved Instances, GCP CUDs/EDPs for an authenticated account
Discovery
list_regions— List all regions where a cloud service is availablelist_instance_types— Discover compute instance types, filterable by family, vCPU, memory, and GPUfind_cheapest_region— Fan out across up to 32 concurrent goroutines to find the cheapest region for any servicefind_available_regions— Find all regions where a specific service/instance type is available, sorted by pricedescribe_catalog— Explore what each provider supports with ready-to-use invocation examples
Cache Management
refresh_cache— Invalidate or purge the pricing cache to force fresh datacache_stats— View in-memory pricing cache statistics
Key highlights:
Zero credentials needed for AWS EC2/EBS/RDS and all Azure public pricing
Contracted/effective rates (Reserved Instances, Savings Plans, GCP EDPs/CUDs) unlocked with credentials
Covers AI model pricing: Azure OpenAI, GCP Vertex AI/Gemini, AWS Bedrock
Concurrent fan-out (up to 32 goroutines) for fast region searches and cross-cloud comparisons
Provides live pricing and cost estimation for Google Cloud Platform services including Compute Engine, Cloud Storage, Persistent Disk, Cloud SQL, Memorystore, GKE, BigQuery, Vertex AI, Gemini, and networking products.
Includes pricing for Azure Kubernetes Service (AKS) and Google Kubernetes Engine (GKE) clusters.
Provides pricing for Azure Database for MySQL as part of multi-cloud database cost comparisons.
Offers pricing information for Azure OpenAI models such as GPT-4o, GPT-4, GPT-3.5-Turbo, o1, o1-mini, and embeddings.
Provides pricing for Azure Database for PostgreSQL and Cloud SQL PostgreSQL as part of multi-cloud database cost comparisons.
OpenCloudCosts MCP
Anchor AI FinOps to real, live cloud pricing.
Your LLM's cloud pricing knowledge was frozen at training cutoff. Cloud pricing wasn't.
opencloudcosts is an MCP server that gives your AI assistant live, structured access to AWS, GCP, and Azure pricing — 16 tools it can call directly, with results it can reason over rather than guess at. Ask it to compare a full multi-resource workload across all three clouds simultaneously. Ask it for your actual post-discount effective rates from Reserved Instances, Savings Plans, or Enterprise Discount Programs. Ask it to fan out across every region and return the cheapest option. None of that is possible from training data alone, and none of it is possible from a single-cloud pricing calculator.
Related MCP server: CloudCost MCP Server
The Problem
Ask any AI assistant what an m5.2xlarge costs in ap-southeast-2, whether AWS or GCP is cheaper for a three-tier web app, or what your effective hourly rate is after Savings Plans. You will get a confident answer. It will probably be wrong.
Cloud pricing is a poor fit for static model weights: instance families are added and retired, regional pricing diverges (the same instance type can differ 20–40% across regions), spot markets fluctuate, and commitment discounts are by definition unique to each account. A model answering from training data cannot know your negotiated EDP rate. It can barely reliably recall last year's list price. The problem is not that LLMs are bad — it's that real-time, account-specific pricing data is structurally outside what a model can know.
opencloudcosts fixes this by giving your AI assistant 16 MCP tools backed by live provider APIs. Instead of hallucinating numbers, the model calls a tool and gets a precise answer.
A Concrete Scenario
Your team asks: "We're evaluating whether to migrate this workload from AWS to GCP. What does the full stack cost on-demand vs. three-year committed, across all three clouds, so I can make the case to leadership?"
Without this tool, the model interpolates — possibly from pricing that is a year out of date — across three providers, multiple resource types, and at least four pricing tiers. The numbers will be plausible and wrong.
With opencloudcosts, the model calls compare_bom with the workload spec (compute + storage + database). The tool fans out 8 concurrent provider calls across AWS, GCP, and Azure simultaneously, prices each resource category at public and committed rates, and returns a per-provider, per-term breakdown with savings analysis — in a single tool call.
No spreadsheet. No switching between three provider calculators. No manual SKU matching. No training-data approximation.
Why Not the Obvious Alternatives
Asking a model without tools — Training data has a cutoff. Cloud pricing changes constantly, varies 20–40% across regions for the same instance type, and includes account-level commitment discounts that are invisible at inference time. The model will approximate, confabulate, or recall stale numbers. There is no structured output, and the model cannot access your contracted rates under any circumstances.
Cloud pricing calculators (AWS / GCP / Azure) — Each covers exactly one cloud. They are UI-only with no API surface callable from an AI assistant. Cross-cloud comparison requires manually reproducing the same architecture three times across three separate calculators and reconciling exports by hand. They have no concept of unit economics and produce no programmatic output for agentic workflows.
Infracost — Excellent at estimating cost diffs against Terraform plans. It requires IaC files as input — it cannot answer "what does an n2-standard-8 cost in europe-west4?" without a Terraform plan in hand. It is not an MCP server and is not callable from a conversational AI context.
Calling provider APIs directly — AWS bulk pricing files are multi-GB and require targeted API access patterns to avoid downloading them in full. GCP's Cloud Billing Pricing API v1beta requires a multi-source ADC credential chain and provider-specific IAM. Azure's Retail Prices API needs pagination logic and SKU matching. Every provider uses different region naming conventions, SKU formats, and data schemas. opencloudcosts normalizes all of this behind a uniform MCP tool interface and handles credential chains, caching, and retry logic so the model does not have to.
Capabilities at a Glance
Capability | LLM (no tools) | Cloud Calculators | Infracost | opencloudcosts |
Live pricing (not frozen at training cutoff) | No | Manual input only | IaC-bound | Yes — fetched from provider APIs |
Cross-cloud comparison in one call | No | No | No | Yes — |
Effective/contracted rates (RI, SP, EDP, CUD) | No | No | No | Yes — credentials unlock this layer |
Multi-region concurrent fan-out | No | No | No | Yes — up to 32 goroutines |
Unit economics (cost/user, cost/request) | Approximate | No | No | Yes — |
MCP tool surface — callable by model | N/A | No | No | Yes — 16 tools |
AWS + Azure public pricing, zero credentials | N/A | Single-cloud only | Partial | Yes |
HTTP service for shared/Kubernetes deployments | N/A | N/A | No | Yes — bearer auth, rate limiting, probes |
Coverage: Three Clouds, 16 Tools
Fourteen tools are fully functional. Two entries are compatibility stubs: search_pricing (a deprecated redirect from v0.8.x, kept for backward compatibility) and get_spot_history (registered but not implemented in the Go server — returns a structured "not available" response).
Credential requirements by provider
Coverage | Credentials required |
AWS EC2, EBS (gp3/io2/sc1), RDS, inter-region egress | None |
Azure VMs, Managed Disks, Blob Storage, Azure SQL/MySQL/PostgreSQL, Cosmos DB, AKS, Azure Functions, Azure OpenAI (GPT-4o, GPT-4, GPT-3.5-Turbo, o1, o1-mini, embeddings) | None — fully public Retail Prices API |
GCP Compute Engine, Cloud Storage, Persistent Disk, Cloud SQL, Memorystore, GKE, BigQuery, Vertex AI, Gemini, Cloud LB/CDN/NAT/Armor, Cloud Monitoring | Free API key ( |
AWS post-discount rates (Reserved Instances, Savings Plans) + | AWS credentials + |
GCP committed-use discounts (CUDs) and Enterprise Discount Programs (EDPs) | ADC credentials + |
Azure Reserved VM pricing (1-year and 3-year terms) is available via the public Retail Prices API — no credentials needed. compare_bom returns committed-term Azure pricing with no setup beyond the binary.
The 16 tools by category
Category | Tools |
Pricing |
|
FinOps |
|
Discovery |
|
Cache |
|
† Compatibility stub only — not functional for live data. See opencloudcosts-go/README.md for full parameter reference.
Performance and Reliability
Concurrency — The analysis tools are not sequential HTTP wrappers:
find_cheapest_regionandfind_available_regions: errgroup + semaphore, up to 32 goroutines — queries all available regions in parallel, returns results sorted cheapest-firstcompare_bom: 8 concurrent provider calls across AWS, GCP, and Azure simultaneouslycompare_prices: semaphore of 10 concurrent region callsget_prices_batch: parallelized across instance types within a region
Rate limiting and timeouts — Token-bucket rate limiter at 200 req/s on the HTTP transport (OCC_RATE_LIMIT). Per-request deadline: 60s (OCC_REQUEST_TIMEOUT). Per-provider API call: 30s (OCC_PROVIDER_TIMEOUT). Graceful SIGTERM drain: 15s (OCC_SHUTDOWN_TIMEOUT).
Cache — Prices are stored in a concurrent in-memory cache (read-optimised with sync.RWMutex) with atomic JSON persistence at ~/.cache/opencloudcosts/cache.json. TTLs: public prices 24h (OCC_CACHE_TTL_HOURS), region/instance metadata 7 days (OCC_METADATA_TTL_DAYS), effective/contracted rates 1h (OCC_EFFECTIVE_PRICE_TTL_HOURS). Cache survives binary updates. 401/403 responses from billing APIs are never cached, so credential rotation takes effect immediately.
AWS pricing — EC2/EBS/RDS public pricing uses a targeted SKU API path rather than downloading the full multi-GB bulk pricing file, keeping startup fast and avoiding large network payloads.
Error isolation — Raw exception text never reaches LLM context. All tool boundaries emit structured error envelopes; full tracebacks are logged server-side only. GCP contract pricing falls back to public list prices on auth failure rather than surfacing an error into the conversation.
Validated: 234/234
opencloudcosts v1.0.0 achieves 234/234 (100%) on the LLM grounding harness, with zero XML hallucinations across the full suite.
The harness covers 234 realistic pricing questions across all three clouds: instance spot checks, cross-region comparisons, BOM estimates, multi-cloud comparisons, unit economics, AI model pricing, database pricing, storage pricing, discount summaries, egress pricing, availability queries, and network pricing.
Primary validation model: qwen3.6-35b-128k running locally via llama-swap — a self-hosted 35B reasoning model with no external API dependency. The harness has also been exercised against qwen3.6-35b-a3b, qwen3.5-122b-a10b@q6_k, and gemma-4-26b-a4b. Because MCP is a protocol rather than a model feature, accuracy comes from the tool returning correct live data — any MCP-capable AI assistant calls the same tool surface and gets the same structured response.
Harness progression: 109/123 (Python v0.8.x) → 169/169 (v0.9.0) → 199/199 (v0.9.2) → 234/234 (v1.0.0).
643 Go unit tests across all providers and tools verify behavioral correctness and cross-provider API parity, independent of LLM evaluation.
Use Cases
1. Price the same workload across all three clouds at once
"Price the following on AWS, GCP, and Azure simultaneously: 4 instances (8 vCPU, 32 GB RAM), 1 managed PostgreSQL database (4 vCPU, 16 GB RAM), and 500 GB block storage. Return on-demand, 1-year committed, and 3-year committed totals for each cloud with monthly and annual figures, and flag which provider is cheapest at each commitment term."
compare_bom fans out 8 concurrent provider calls and returns a per-provider, per-term breakdown with savings analysis versus on-demand. No pricing calculator does this across cloud boundaries. AWS and Azure public pricing requires no credentials; GCP requires a free API key.
2. Find the cheapest AWS region for a long-running compute workload
"I need to run a c6a.4xlarge continuously. Fan out across all available AWS regions and return the 5 cheapest, sorted by on-demand hourly rate. Show us-east-1 as a baseline."
find_cheapest_region uses a 32-goroutine fan-out across every region where the instance type is available and returns results sorted cheapest-first. Regional price deltas for the same instance type routinely exceed 20%. No credentials needed.
3. Determine your effective AWS rate after commitments
"I have two m5.xlarge Reserved Instances (1-year, no upfront) in us-east-1 and a Compute Savings Plan covering $500/month of EC2 spend. What is my effective blended hourly rate on m5.xlarge right now, and what percentage am I saving versus on-demand?"
get_price with AWS credentials and OCC_AWS_ENABLE_COST_EXPLORER=true returns your actual post-discount rate alongside the public list price, pulling live data from Cost Explorer and Savings Plans APIs.
4. Azure serverless vs. always-on: break-even analysis
"Our batch processing job runs 1.5 million Azure Function executions per month, each consuming 512 MB for 900ms. What is the total monthly cost on the Consumption plan in West Europe, and what is the monthly cost of a Standard_D2s_v5 VM running continuously in the same region? At what monthly execution count do they break even?"
estimate_unit_economics covers the Functions path; get_price covers the VM. Azure pricing is fully public — no credentials, no API key, no subscription required.
5. Unit economics for a SaaS product
"If I run two m5.large app servers, one db.t3.medium RDS MySQL instance, and 200 GB gp3 in us-east-1, and I have 50,000 monthly active users making 1 million requests per day, what is my infrastructure cost per user and per request?"
estimate_bom prices the full stack; estimate_unit_economics computes cost per user and per request at that scale. Output is structured for direct use in a margin model or board-level cost discussion. No credentials needed.
6. AI token cost comparison: Vertex AI vs. Azure OpenAI
"We process 50 million input tokens and 8 million output tokens per month. Compare the total monthly cost of Gemini 1.5 Pro on Vertex AI versus GPT-4o and GPT-4o-mini on Azure OpenAI. Show cost per million tokens and total monthly bill for each."
get_price with domain: ai covers both providers. GCP Vertex AI and Gemini pricing requires a free GCP API key (OCC_GCP_API_KEY); Azure OpenAI pricing is fully public — no credentials needed.
Setup
Option 1 — pip (easiest, cross-platform)
The PyPI package wraps the native Go binary — no Go toolchain needed.
pip install opencloudcosts
opencloudcosts # stdio mode (for local MCP clients)
opencloudcosts --transport http --host 0.0.0.0 --port 8080 # HTTP modeOption 2 — Homebrew (macOS / Linux)
brew tap x7even/opencloudcosts
brew install opencloudcostsOption 3 — binary download
Download the pre-built binary for your platform from the latest release:
# Linux (amd64)
curl -L https://github.com/x7even/cloudcostsmcp/releases/latest/download/opencloudcosts_linux_amd64.tar.gz | tar xz
./opencloudcosts
# macOS (Apple Silicon)
curl -L https://github.com/x7even/cloudcostsmcp/releases/latest/download/opencloudcosts_darwin_arm64.tar.gz | tar xz
./opencloudcostsOption 4 — Docker / container
# Build the image first (no pre-built image is published)
cd opencloudcosts-go
docker build -t opencloudcosts:local .
# Run — HTTP transport, bound to all interfaces
docker run -p 8080:8080 \
-e OCC_GCP_API_KEY=AIza... \
-v ~/.aws:/root/.aws:ro \
opencloudcosts:localThe image is ~15 MB (distroless scratch base, static binary). No credentials are required for AWS and Azure public pricing.
Option 5 — build from source
git clone https://github.com/x7even/cloudcostsmcp
cd cloudcostsmcp/opencloudcosts-go
CGO_ENABLED=0 go build -o opencloudcosts ./cmd/opencloudcosts
./opencloudcostsConnect to Claude Code
Stdio (local process — recommended for single-user)
Add to ~/.claude/settings.json or your project's .mcp.json:
{
"mcpServers": {
"cloudcost": {
"command": "opencloudcosts",
"env": {
"OCC_GCP_API_KEY": "AIza..."
}
}
}
}HTTP (shared/remote server — one server, many clients)
{
"mcpServers": {
"cloudcost": {
"transport": "http",
"url": "http://localhost:8080/"
}
}
}Kubernetes
See deploy/kubernetes/ for manifests. Build and push your own image (see Docker section above), then reference it in deployment.yaml.
Credentials are passed via environment variables or Kubernetes Secrets — same variable
names as the Docker examples above.
Test with MCP Inspector
npx @modelcontextprotocol/inspector opencloudcostsAWS Credentials
Feature | Credentials needed |
Public pricing (EC2, EBS, RDS list prices) | None |
Effective pricing (RI / SP discounts) | AWS credentials + |
Minimal IAM policy for public pricing:
{
"Effect": "Allow",
"Action": ["pricing:GetProducts", "pricing:DescribeServices", "pricing:GetAttributeValues"],
"Resource": "*"
}Add these for effective pricing:
"ce:GetCostAndUsage", "savingsplans:DescribeSavingsPlans", "savingsplans:DescribeSavingsPlanRates"Configuration
All settings via environment variables (prefix OCC_) or .env file:
Variable | Default | Description |
| 24 | Public price cache TTL |
| false | Enable AWS effective pricing (costs $0.01/call) |
| us-east-1,us-west-2 | Default regions |
| (default chain) | AWS credentials profile |
| (none) | GCP billing account ID for contract/effective pricing |
Caching
Prices are stored in a concurrent in-memory cache (read-optimised with sync.RWMutex) with atomic JSON persistence at ~/.cache/opencloudcosts/cache.json. Public list prices are cached for 24 hours — AWS pricing changes infrequently. Use the refresh_cache tool to force a refresh.
GCP Setup
Unlike AWS (which has public bulk pricing endpoints), GCP's pricing API always requires at least a free API key. No credit card or billing account is needed.
Option A — Free API key (recommended, 2 min setup):
Create a Project if you don't have one (free)
Click Create Credentials → API key
Set the key:
export OCC_GCP_API_KEY=AIza...Or add OCC_GCP_API_KEY=AIza... to your .env file.
Option B — Application Default Credentials (if you already use gcloud):
gcloud auth application-default login
# or set GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.jsonGCP instance type format: {family}-{series}-{vcpus} e.g. n2-standard-4, e2-highmem-8, c2-standard-16
GCP Contract / Effective Pricing
If you have a negotiated pricing contract with Google Cloud, you can retrieve your actual discounted rates (EDP, custom pricing) via the Cloud Billing Pricing API v1beta. This requires:
ADC credentials:
gcloud auth application-default loginbilling.billingAccountPrice.getIAM permission on your billing accountYour billing account ID:
export OCC_GCP_BILLING_ACCOUNT_ID=012345-567890-ABCDEFWith this configured, get_price responses for GCP compute will include an effective_price block showing your contract rate and discount percentage. Without it, public list prices are returned unchanged.
Azure Setup
Azure pricing is fully public — no credentials, API key, or subscription needed.
# No configuration needed — works out of the box
uv run opencloudcostsAzure instance type format: ARM SKU names e.g. Standard_D4s_v3, Standard_E8s_v3, Standard_B2ms
Azure pricing terms: on_demand (default), reserved_1yr, reserved_3yr, spot
Azure regions: ARM region names e.g. eastus, westeurope, southeastasia (use list_regions for full list)
Azure supported services:
Domain | Service | Description |
compute | vm | Virtual Machines — all families, Linux/Windows, on-demand/spot/reserved |
storage | managed_disks | Premium SSD, Standard SSD, Standard HDD, Ultra Disk |
storage | blob | Blob Storage |
database | sql | Azure SQL Database, Azure DB for MySQL/PostgreSQL — vCore tiers, HA, reserved |
database | cosmos | Cosmos DB — provisioned (per 100 RU/s), serverless, autoscale |
container | aks | AKS cluster management fee (free tier or $0.10/hr Standard) |
serverless | azure_functions | Functions Consumption plan — per GB-second + per execution |
ai | openai | Azure OpenAI — GPT-4o, GPT-4, GPT-3.5-Turbo, o1, o1-mini, embeddings |
inter_region_egress | — | Outbound data transfer — internet and inter-region, Zone 1 rates, 5 GB/month free |
GCP pricing terms: on_demand (default), spot (preemptible), cud_1yr, cud_3yr
Security
OpenCloudCosts can access sensitive billing data when configured with cloud credentials (AWS Cost Explorer, GCP billing, Azure contract pricing). Follow these guidelines to keep that data safe.
Credential hygiene
Use dedicated, least-privilege credentials — read-only access scoped to pricing and billing APIs only. Never use root, owner, or admin credentials.
AWS: create an IAM user/role with only
ce:GetCostAndUsage,pricing:GetProducts, andsavingsplans:Describe*permissions.Store credentials in
.env(see.env.example) and never commit that file to version control.
Transport security
The default
stdiotransport is safe — the server runs as a local process with no network exposure.If you use
--transport http, never expose it publicly without a reverse proxy and authentication in front of it. Treat it as an internal service.
MCP client trust
Only add this server to MCP client configs you control.
Avoid running it alongside untrusted third-party MCP servers — a malicious server can craft prompts that cause the LLM to call your billing tools and relay the results.
What this server can access With credentials configured: actual spend, contract/negotiated pricing, reservation and savings plan data. Understand this before granting access in shared or multi-user environments.
Server instructions
This is the complete, verbatim Instructions string this server sends to MCP clients (from opencloudcosts-go/internal/server/server.go), reproduced here so it can be checked without reading source:
OpenCloudCosts MCP provides accurate public and effective cloud pricing data. Use it to look up compute, storage, and database pricing on AWS, GCP, and Azure; compare prices across regions and providers; estimate TCO from a Bill of Materials; and calculate unit economics. For effective/bespoke pricing (post-discount), ensure provider credentials are configured. Azure pricing requires no credentials.That's the whole thing: a description of what the tools do and when credentials matter. It contains no directives about the model's behavior, tone, or process, and it never will. We commit to keeping these instructions minimal and strictly pricing-scoped — any future change that adds a "you must...", "always...", or other behavioral directive is a review-blocking change and should be rejected in review unless this section of the README is updated in the same PR to reflect it.
If your MCP client or harness renders instructions from multiple locally-installed servers or plugins adjacent to each other (for example, a separate SessionStart hook from an unrelated plugin), that adjacent output is not produced by this server. Compare what you see against the fenced block above — only that text originates from OpenCloudCosts MCP.
Recent releases
v0.9.1 ✅ GCP egress contract pricing; fix
PricingResult.sourceLiteralv0.9.2 ✅ Azure OpenAI model matching fix; Azure Functions pricing fix;
list_instance_typescap; 199-prompt harness suitev1.0.0 ✅ Go rewrite — static binary, dual stdio/HTTP transport, 16 tools,
compare_bomcross-cloud workload comparison, concurrent region fan-out (32 goroutines), Azure o1-mini SKU fix; 234/234 (100%) LLM grounding harnessv1.0.1 ✅ PyPI package description; CI Trusted Publisher fix;
go installtagv1.0.2 ✅ README accuracy fixes; cache description updated
Available Tools
15 toolscache_statsA
Return statistics about the local pricing cache (entry counts, DB size).
Inputs: no named parameters. Returns: object
compare_pricesA
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".
Inputs: spec (required), regions (required), baseline_region. Returns: object
describe_catalogA
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.
Inputs: domain, service, provider. Returns: object
estimate_bomA
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 hidden costs (egress, load balancers, NAT Gateway, monitoring, backups). IMPORTANT: if not_included is present in the response, you MUST call get_price for each listed item — using the exact command in each item's how_to_price field — before writing your final answer. Do NOT estimate or guess any cost from the not_included list.
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} ]
Inputs: items (required). Returns: object
estimate_unit_economicsA
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.
Inputs: items (required), units_per_month (required), unit_label. Returns: object
find_available_regionsA
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.
Inputs: spec (required), regions, baseline_region. Returns: object
find_cheapest_regionA
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".
Inputs: spec (required), regions, baseline_region. Returns: object
get_discount_summaryA
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)
Inputs: provider. Returns: object
get_priceA
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"/"standard"/"nearline"/"premium-ssd") 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"}
Inputs: spec (required). Returns: object
get_prices_batchA
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"
Inputs: region (required), provider (required), instance_types (required), os, +1 more. Returns: object
get_spot_historyA
Get spot price history and stability analysis for a compute instance type.
Returns per-AZ spot price statistics (current, min, max, avg, sample count), overall volatility ratio, a stability label, and an actionable recommendation. Currently supported by AWS (requires credentials). GCP and Azure return not_supported.
Args: spec: PricingSpec dict with domain="compute", resource_type (instance type), region. Example: {"provider": "aws", "domain": "compute", "resource_type": "m5.xlarge", "region": "us-east-1"} hours: Lookback window in hours (default 24, max 720) availability_zone: Filter to a specific AZ, e.g. "us-east-1a". Empty = all AZs (AWS only).
Inputs: spec (required), hours, availability_zone. Returns: object
list_instance_typesA
List available compute instance types in a region, with optional filters.
Useful for discovering what instances are available before fetching pricing, or for finding instances that meet specific vCPU/memory/GPU requirements.
Args: provider: Cloud provider — "aws", "gcp", or "azure" region: Region code, e.g. "us-east-1" (AWS), "us-central1" (GCP), "eastus" (Azure) family: Optional instance family prefix, e.g. "m5", "c6g" (AWS), "n2", "c2" (GCP), or "Standard_D", "Standard_E" (Azure) min_vcpu: Filter to instances with at least this many vCPUs. min_memory_gb: Filter to instances with at least this much memory (GB). gpu: If true, only return GPU instances max_results: Maximum number of results (default 50)
Inputs: region (required), provider (required), gpu, family, +3 more. Returns: object
list_regionsB
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"
Inputs: provider (required), domain. Returns: object
refresh_cacheA
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.
Inputs: provider. Returns: object
search_pricingA
Free-text search across the pricing catalog.
Useful for exploring what SKUs are available for a service before calling get_price, or for finding pricing for services not yet covered by a specific domain.
Args: provider: Cloud provider — "aws", "gcp", or "azure" query: Search string, e.g. "NAT gateway", "CloudWatch metrics", "Lambda duration" domain: Optional domain filter — "compute", "storage", "database", etc. region: Optional region filter max_results: Maximum results to return (default 20)
Inputs: query (required), provider (required), domain, region, +1 more. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 15 tools
Every tool has a clearly distinct purpose. While several tools deal with pricing (get_price, compare_prices, find_cheapest_region, etc.), their specific functions are well-defined and non-overlapping, preventing confusion.
All tool names follow a consistent verb_noun pattern in snake_case (e.g., compare_prices, describe_catalog, list_instance_types). The naming is predictable and clear, with only minor stylistic variations (get vs list) that are standard.
15 tools is appropriate for a cloud cost server. The set covers core queries, comparisons, batch operations, catalog discovery, and utilities without being overwhelming. Each tool serves a clear purpose and earns its place.
The tool surface is comprehensive for cloud pricing: single and batch price queries, region comparison, instance type discovery, catalog help, unit economics, BOM estimation, and spot history. It covers the full lifecycle of pricing analysis with no obvious gaps.
Maintenance
Related MCP Connectors
Live public cloud GPU rental prices (H100, A100, L40S and more) across 20+ providers.
Published list prices of compute (VPS, GPU hours, LLM tokens, media), archived daily. Read-only.
Published list prices of compute (VPS, GPU hours, LLM tokens, media), archived daily. Read-only.
Verified cloud cost forecasting for AI agents. AWS, GCP, Azure pricing matrix.
Related MCP Servers
- AlicenseAqualityBmaintenanceGlobal price benchmarking for AI inference across 2,600+ SKUs from 47 vendors. Query live pricing, market indexes, and model specs via 8 tools. Free tier available.859 npmMIT
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to parse multi-cloud infrastructure-as-code files, query real-time pricing from AWS, Azure, and GCP, and generate cost estimates and comparison reports.46 npmMIT
- AlicenseAqualityAmaintenanceProvides real-time AI compute pricing and cost analysis across LLM providers, enabling session cost tracking, model price comparisons, and historical data queries.22127 npmMIT

OptimToken MCPofficial
AlicenseNot gradedqualityBmaintenanceEnables AI assistants to fetch live, dated prices for LLM models and cloud compute instances across providers, compare and recommend models, and estimate monthly costs based on workload-specific token shapes and constraints.MIT