cloudprice-mcp
cloudprice-mcp is an MCP server that gives AI assistants multi-cloud pricing, FinOps decision support, and local bill/deployment analysis across AWS, Azure, GCP, OCI, and LLM providers.
Look up on-demand VM prices for AWS, Azure, and GCP, and compare equivalent VMs across four clouds.
Price and compare workloads: compute inventory, block/object storage, managed PostgreSQL, egress, spot, GPU, and carbon footprint.
Support FinOps decisions: migration assessment, commitment optimization, TCO projection, egress arbitrage, decision reports, and workload cost-drift watching.
Track price history: query historical SKU prices, list tracked SKUs, and detect price anomalies.
Compare LLM token pricing across providers, search ~2,300 extended model/provider prices, see LLM price changes, and check model retirements.
Estimate AI agent costs, compare agent hosting platforms, and compare LLM API spend vs self-hosting GPUs.
Analyze local FOCUS bill exports: spend drivers, commitment gaps, anomalies, cost allocation/tags, forecasts, unit costs, reprice compute, and AI spend.
Review local AgentCore Terraform plans for security/cost best practices.
Export pricing comparisons as FOCUS 1.3 JSON/CSV.
Keep file-based bill and deployment tools local-only; no cloud account or API keys required.
Compares compute and storage pricing across AWS, providing tools to look up EC2 instance prices, compare costs, and estimate monthly bills for workloads.
Compares compute and storage pricing across GCP, providing tools to look up GCE machine type prices, compare costs, and estimate monthly bills for workloads.
cloudprice-mcp
Ask your AI assistant what the cloud will cost — and get real list prices back.
cloudprice-mcp gives Claude, Cursor, GitHub Copilot and any other MCP client pricing and FinOps tools across AWS, Azure, GCP and OCI, plus LLM token prices for ~2,300 model/provider combinations. No cloud account, no API keys: it works from a catalogue refreshed every week from the providers' public pricing APIs.
Four clouds in one answer, including OCI and its 10 TB free egress — which most tools leave out.
Cloud and AI costs side by side: price a VM, a GPU and the LLM calls running on it in the same conversation.
Price history: every weekly catalogue is archived, so you can ask what changed, not just what it costs today.
Decisions, not just lookups: RI / Savings Plan break-even, 3-year TCO, migration payback, egress arbitrage, carbon (kg CO2e), FOCUS 1.3 export.

Quick start
Add this to your MCP client's config (Claude Desktop, Cursor, VS Code, …).
uvx downloads and runs it — nothing to install
first:
{
"mcpServers": {
"cloudprice": { "command": "uvx", "args": ["cloudprice-mcp"] }
}
}Claude Code: claude mcp add cloudprice -- uvx cloudprice-mcp
Or install with pip and let it configure every client it finds (asks before writing each one):
pip install cloudprice-mcp
cloudprice-mcp setupRestart the client and the 39 tools appear. Problems? cloudprice-mcp doctor
says what is wrong; INSTALL.md has per-client steps for Windows,
macOS and Linux. Python 3.10+.
What's new in each release: CHANGELOG.md.
Related MCP server: Cloud Cost MCP
Things to ask
"I run 6× t3.2xlarge on AWS. On-demand vs 1-year Savings Plan vs 3-year RI — what's the break-even month?" →
optimize_commitment
"At 50 TB/month internet egress, which cloud is cheapest, and what would moving save over 3 years?" →
compare_egress,find_egress_arbitrage(OCI ≈ $340/mo vs ≈ $4,000/mo on the hyperscalers)
"Size this 3-tier app on all four clouds: 8 web (4 vCPU/16 GB), 12 app (8/32), 4 DB (16/64), 5 TB SSD, 10 TB/month egress, multi-AZ." →
compare_workload,compare_total_cost_of_ownership
"Cheapest way to run 50M input / 10M output tokens a month — and is Claude Sonnet the same price on Bedrock and Vertex?" →
compare_token_pricing
"Which H100 instance is cheapest per GPU-hour across the four clouds?" →
compare_gpu_workload
"We send 2B input / 500M output tokens a month to an API. Would renting 8×H100 and serving Llama ourselves be cheaper, and at what volume?" →
compare_llm_vs_selfhost
"My support agent averages 8 steps with a 2k system prompt and 3k of tool definitions. What does 50,000 runs a month cost on Sonnet vs Haiku, and how much does prompt caching save — and hosted on AgentCore or Lambda?" →
estimate_agent_cost(tokens + AgentCore Runtime/Gateway/Memory vs Lambda)
"We'll run this agent 50,000 times a month, 30 seconds a run, on Claude Sonnet. AgentCore, Azure Foundry or Vertex Agent Engine, or just Lambda?" →
compare_agent_platforms(hosting, tools, memory and tokens on each)
"What changed in LLM pricing this week — anything cheaper on Bedrock or Groq?" →
llm_price_changes(weekly archive of ~3,600 model/provider prices)
"Which models on Bedrock and Azure OpenAI retire in the next six months, and what replaces them?" →
model_retirements(also flagged automatically byanalyze_ai_spendandreview_agentcore)
"How has OCI E5.Flex pricing moved since May?" →
get_price_history
"Here's our FOCUS export (~/Downloads/focus-2026-10.csv). Where is the money going, what jumped last month, and how much of our usage do Savings Plans cover?" →
analyze_bill— reads the file on your machine; nothing is sent anywhere, and hosted deployments cannot call it.
"Using the same export: are we under-committed, what spiked last week, and how much of our spend is missing a
teamtag?" →find_commitment_gaps,detect_bill_anomalies,analyze_cost_allocation
"What will this month's bill be, and what's our cost per customer? We had 41,000 customers in September and 44,500 in October." →
forecast_spend,calculate_unit_cost
"What would the compute on this bill cost on Azure, GCP or OCI?" →
reprice_bill: the vCPU and memory you actually used, priced on all four clouds, next to what you paid
"What are we spending on Bedrock and Azure OpenAI, are we paying list price, and would prompt caching help?" →
analyze_ai_spend
"Review our AgentCore deployment: is it secure, what does the agent cost, and what should we fix first?" →
review_agentcoreonterraform show -jsonoutput, plus the bill
Every answer carries the catalogue date and an honest_gaps list of what the
tool does not model, so the AI can tell you where the number stops being exact.
Use it on your own bill and deployment
Nine tools read files on your machine: your cloud bill (a FOCUS export) and your AgentCore deployment (Terraform JSON). The file never leaves your machine; only the tool's summary goes back to your AI assistant. Hosted deployments of this server cannot call these tools at all.
1. Download your bill as a FOCUS CSV. Every major cloud exports it:
Cloud | Where | Guide |
AWS | Billing and Cost Management → Data Exports → Create → a FOCUS export, CSV → download from the S3 bucket | |
Azure | Cost Management → Exports → Create → Cost and usage details (FOCUS), CSV → download from the storage account. Big exports arrive in parts; analyse one part or join them first | |
GCP | Billing → FOCUS export to BigQuery → query the month you want → save the result as CSV | |
OCI | Billing → Cost and Usage Reports → FOCUS reports → Download |
.csv and .csv.gz up to 500 MB are read.
2. Ask, with the file path in the question:
"Here's our bill: ~/Downloads/focus-2026-10.csv. Where is the money going, what would it cost on the other clouds, and what are we spending on AI?"
Question | Tool |
Where does the money go? |
|
Are we under-committed? What are idle commitments costing? |
|
What spiked, and since when? |
|
How much spend is missing our |
|
What will this month cost? Cost per customer? |
|
What would our compute cost on the other clouds? |
|
What do our AI models cost, and are we paying list price? |
|
3. Review an AgentCore deployment (Terraform):
terraform plan -out=tfplan
terraform show -json tfplan > plan.json"Review our AgentCore deployment in ~/plan.json. Our bill is ~/Downloads/focus.csv and the agent is tagged agent=support."
You get findings ranked by severity: public network, unauthenticated gateways, model permissions, secrets in environment variables, idle-session cost, missing alarms and tags, and with the bill, what the agent costs and what caching would save. Each one names the resource, the Terraform fix and the AWS page behind the rule. To accept a finding on purpose, say so: "skip S1 on aws_bedrockagentcore_agent_runtime.demo, it is a public demo". It is then listed as skipped, with your reason.
plan.json holds every value Terraform knows, secrets included. The review
never repeats them, but keep the file out of git and delete it when you are done.
Tools
39 tools, grouped by job. Full descriptions and arguments: docs/TOOLS.md (generated from the server, so it is always current).
Job | Tools |
Look up one price |
|
Price a workload |
|
FinOps decisions |
|
Spot, GPU, carbon |
|
Price history |
|
AI / LLM costs |
|
Your actual bill (local only) |
|
Review a deployment (local only) |
|
Export |
|
FinOps Framework coverage
How the tools map to the FinOps Foundation capabilities. "Your bill" tools read a FOCUS export locally; the rest work from list prices and the weekly price archive.
Capability | Tools |
Data ingestion |
|
Reporting & analytics |
|
Allocation |
|
Anomaly management |
|
Rate optimization |
|
Workload optimization |
|
Planning & estimating |
|
Architecting for cloud |
|
Benchmarking |
|
Cloud sustainability |
|
Forecasting |
|
Unit economics |
|
FinOps for AI |
|
Example: compare_workload input
{
"compute": [
{ "name": "web", "vcpus": 4, "memory_gb": 16, "quantity": 8, "os_disk_gb": 100, "os_disk_type": "ssd" },
{ "name": "app", "vcpus": 8, "memory_gb": 32, "quantity": 12, "os_disk_gb": 200, "os_disk_type": "ssd" },
{ "name": "db", "vcpus": 16, "memory_gb": 64, "quantity": 4, "os_disk_gb": 500, "os_disk_type": "ssd" }
],
"storage": [
{ "name": "shared-fast", "capacity_gb": 5000, "disk_type": "ssd" },
{ "name": "shared-bulk", "capacity_gb": 50000, "disk_type": "hdd" }
],
"commitment": "1yr_no_upfront",
"multi_az": true
}Modelling notes. Commitments apply a conservative compute discount (1-year
≈ 30%, 3-year ≈ 50%); storage is not discounted. Snapshots are priced as full
copies by default — set snapshot_incremental_factor (e.g. 0.3) for
real-world incremental snapshots. multi_az doubles compute, not storage.
Pricing data
Prices are bundled as a curated dataset of common SKUs across 4 clouds:
Compute (~50 VM SKUs across AWS / Azure / GCP / OCI, including OCI A1 Always Free + A2 Arm Ampere + E5 Flex)
Block storage (SSD + HDD per cloud)
Object storage (Hot / Cool / Archive tiers per cloud, including OCI Always Free 20 GB)
Managed PostgreSQL (RDS / Azure DB / Cloud SQL / OCI Database with PostgreSQL)
Auto-refreshed weekly
The bundled catalog is refreshed every Sunday by a GitHub Action that hits each cloud's public pricing API:
AWS — Pricing API (via boto3, OIDC-authenticated)
Azure — Retail Prices API (public, no auth)
OCI — Public pricing API (public, no auth)
GCP — Cloud Billing Catalog API (via API key —
GCP_API_KEYenv var). Added in v0.8.0Bedrock LLM token prices — AWS Pricing API
AmazonBedrockservice code (via boto3, same OIDC role). Added in v0.15.0 — refreshes input/output token rates for every Bedrock-hosted model we track (Claude 4 Opus/Sonnet, Claude 3/3.5 Haiku, Llama 3.1/3.3, Mistral Large 2, DeepSeek R1)Extended LLM catalog — LiteLLM's
model_prices_and_context_window.json(MIT-licensed, community-maintained, unauthenticated). Added in v0.16.0 — ingests ~2000 (model, provider) combinations covering Together AI, Fireworks, Groq, Replicate, Perplexity, regional Bedrock/Azure variants, older model versions. Powers thelookup_extended_model_pricingtool. Curated hand-vetted prices (compare_token_pricing) and extended (lookup_extended_model_pricing) are deliberately separate so users always know which catalog they're hitting.
Each refresh writes a dated snapshot to src/cloudprice_mcp/data/prices/YYYY-MM-DD.json and src/cloudprice_mcp/data/token_prices/YYYY-MM-DD.json — every JSON ever published lives in the repo. The history archive is MIT-licensed and grows with every release.
Every tool result includes the catalog's as_of field so you know exactly which prices were used.
Public price history dataset
cloudprice-mcp is the only FinOps tool we know of that preserves every weekly snapshot. You can query "what did m5.xlarge cost in May?" — neither AWS Calculator nor GCP Estimator can answer that because their pages always show today.
Query the history from the CLI:
cloudprice-mcp history --cloud oci --sku VM.Standard.E5.Flex.4OCPU
# oci/VM.Standard.E5.Flex.4OCPU (us-ashburn-1) — 2 data point(s)
#
# AS_OF HOURLY USD
# --------------------------
# 2026-04-26 $ 0.67600
# 2026-05-12 $ 0.18400
#
# Change: -72.78% ($-0.49200/h)The -72.78% drop is the v0.7.0 auto-refresh fixing a hand-curated inaccuracy in the prior OCI catalog — proof that the auto-refresh story works.
Query the history from AI assistants via two new MCP tools:
get_price_history(cloud, sku, since?)— full timeseries + change statslist_tracked_skus(cloud?, since?)— every (cloud, sku) pair we have history for
Real questions this unlocks:
"Has AWS m5.xlarge changed price in the last quarter?" → AI calls
get_price_history, returns timeseries with start/end prices and % change.
"Show me every multi-cloud price mover since January." → AI calls
list_tracked_skus(since="2026-01-01"), returns every SKU + its latest price + change.
Cross-provider LLM token pricing
Token costs are the fastest-growing FinOps line item in 2026 — and nobody compares them cross-provider openly. The same model is often available on multiple providers at different prices (Claude on Anthropic / Bedrock / Vertex; GPT on OpenAI / Azure OpenAI; Llama on Bedrock).
from cloudprice_mcp.finops.tokens import compare_token_pricing
# Cheapest model overall for a 50M-in / 10M-out monthly workload
r = compare_token_pricing(
monthly_input_tokens=50_000_000,
monthly_output_tokens=10_000_000,
)
# gemini-1.5-flash on google is cheapest at $6.75/mo for 50M in / 10M out tokens.
# gemini-1.5-flash on google $ 6.75/mo
# gemini-1.5-flash on vertex $ 6.75/mo
# gemini-2.0-flash on google $ 9.00/mo
# llama-3.1-8b on bedrock $ 13.20/mo
# gpt-4o-mini on openai $ 13.50/mo
# deepseek-v3 on deepseek $ 24.50/mo# Same model across all hosts — proves Claude 4 Sonnet provider parity
# (and surfaces that only Anthropic API publishes the 90%-off cache_read rate)
r = compare_token_pricing(model_id="claude-4-sonnet")
# anthropic in=$3/1M out=$15/1M cache_read=$0.30/1M cache_write=$3.75/1M
# bedrock in=$3/1M out=$15/1M
# vertex in=$3/1M out=$15/1MCovers 19 models across 8 providers: Claude (4 Opus / 4 Sonnet / 3.5 Haiku / 3 Haiku), GPT (5, 5 mini, 4o, 4o-mini, o1), Gemini (2.0 Flash, 1.5 Pro/Flash), Llama (3.1 8B/70B/405B, 3.3 70B), Mistral Large 2, DeepSeek V3/R1.
Real questions this unlocks:
"Cheapest model that handles 200K context for output-heavy chat at 10M/mo output volume?" → AI calls
compare_token_pricingwith the volume + an optional model_family filter, returns ranked monthly cost across every viable model+provider combo.
"Should I use Anthropic API or Bedrock for Claude?" →
compare_token_pricing(model_id="claude-4-sonnet")shows price parity on per-token rates, but Anthropic API exposes a 10x cheaper cache_read rate that Bedrock doesn't publish. For caching-heavy workloads, Anthropic wins.
Multi-cloud GPU pricing
The fastest-growing cloud cost category — and nobody compares it cross-cloud openly.
from cloudprice_mcp.finops.gpu import compare_gpu_workload
from cloudprice_mcp.pricing import load_catalog
r = compare_gpu_workload(load_catalog(), gpu_type="H100", gpu_count=8)
# OCI BM.GPU.H100.8 is cheapest at $80.0000/h for 8x H100.
# oci BM.GPU.H100.8 $ 80.0000/h $10.0000/GPU/h
# gcp a3-highgpu-8g $ 84.4000/h $10.5500/GPU/h
# aws p5.48xlarge $ 98.3200/h $12.2900/GPU/h
# azure ND96isr_H100_v5 $ 98.3200/h $12.2900/GPU/hCovers NVIDIA T4, A10, A10G, L4, L40S, V100, A100, H100 across all 4 clouds. Returns:
Absolute hourly winner — the cheapest matching SKU per cloud
Per-GPU efficiency winner — sometimes a different cloud (e.g., OCI's BM.GPU4.8 is cheapest per GPU but only sold as 8x, so for
gpu_count=1Azure/GCP win the absolute ranking)Over-provisioning flags — when the only matching SKU bundles more GPUs than asked for
GPU memory — differentiates A100 40GB vs 80GB (same
gpu_typefield)
The OCI H100 finding is real: at 8x H100 it's ~19% cheaper than AWS/Azure for identical hardware.
Cost Drift Sentinel
The shift from query tool to agent capability. Most FinOps tools answer "what does this cost?" — this one answers "is this still what it cost when I signed off on it?"
from cloudprice_mcp.finops.sentinel import watch_workload
from cloudprice_mcp.inventory import parse_dict
from cloudprice_mcp.pricing import load_catalog
# First call — captures a baseline. Persist the returned baseline JSON.
result = watch_workload(load_catalog(), parse_dict(workload_spec))
save(result["baseline"])
# Later — pass the baseline back to detect drift.
report = watch_workload(load_catalog(), parse_dict(workload_spec), baseline=load_baseline())
if report["alert_triggered"]:
notify_humans(report["headline"])Stateless by design — no server, no database. The baseline JSON lives wherever you want: a file in your IaC repo, S3, Slack DM, anywhere. Each call is a pure function of (catalog, workload, baseline).
Key properties:
Workload-hash protected — if you change the workload spec, the hash mismatches and you get a fresh baseline rather than a misleading drift report
SKU-level attribution — the drift report consults the price-history dataset and surfaces which SKUs moved the most between baseline and now
Configurable threshold — default 5%; pass
alert_threshold_pct=Nto tune
Plug-and-play GitHub Action template at examples/cloudprice-watch.yml — drop it in any IaC repo with a workload.json, get auto-opened GitHub issues when costs drift. Baseline is committed to your repo so the history is auditable.
Carbon-aware FinOps — kg CO2e per workload, alongside USD
The only FinOps MCP tool that returns both cost AND carbon footprint on the same query. AWS / Azure / GCP each publish their own customer dashboards (Customer Carbon Footprint Tool, Emissions Impact Dashboard, Carbon Footprint) — but none compare across providers. cloudprice does.
from cloudprice_mcp.finops.carbon import compare_carbon_footprint
from cloudprice_mcp.pricing import load_catalog
result = compare_carbon_footprint(load_catalog(), vcpus=8, memory_gb=32, quantity=6)
# Returns per-cloud SKU + cost + power class (x86/ARM) + monthly kWh +
# grid-based kg CO2e + market-based residual kg CO2e (after renewable matching),
# ranked cheapest-carbon-first.What's modeled (and disclosed in every response):
PUE per cloud from each provider's public sustainability report
Grid carbon intensity per region from public emissions data (EPA eGRID for US, similar baselines elsewhere)
Renewable matching per provider (AWS/Azure 100%, GCP ~64% CFE, OCI unmatched outside EU)
ARM vs x86 power class — ARM SKUs (Graviton, Ampere, Axion) modeled at ~30% lower per-vCPU power
Two carbon numbers per cloud: location-based (grid) AND market-based (residual after renewable matching) — both surfaced so auditors can see both perspectives
What's NOT modeled (always disclosed via honest_gaps[]):
Embodied carbon (server manufacturing) — operational only
GPU / network / storage power — compute + memory only
Time-of-use grid variation — annual averages only
Real-time 24/7 CFE matching — GCP publishes annual CFE %; cloudprice uses that
Real questions this unlocks:
"What's the lowest-carbon cloud for 4 vCPU / 16 GB at 6 instances?" → AI calls
compare_carbon_footprint, returns per-cloud kg CO2e/mo ranked.
"How much carbon do I save running on ARM vs x86?" → AI calls it twice with the same shape but different target SKUs.
What's NOT modeled (real-world TCO killers)
✅
Egress / data transfer— modeled in v0.5 (compare_egress)✅
Multi-AZ / HA replicas— modeled in v0.5 (multi_az: trueoncompare_workload)✅
Snapshots upper-bound only— fixed in v0.5 (snapshot_incremental_factor)Reserved/Savings Plan SKU detail (we apply a flat tier discount, not per-region/per-family detail) — roadmap
Multi-region pricing (currently us-east only; us-west / eu-west planned for v0.5.1) — roadmap
IOPS-based storage matching (capacity-only) — roadmap
Backup storage charges (some clouds free, others billed) — roadmap
Request costs (PUT/GET pricing for object storage) — roadmap
Retrieval costs for archive tiers (Glacier-style retrieval can be 10× the storage cost) — roadmap
VPC peering / interconnect costs — roadmap
These are tracked roadmap items. Use cloudprice-mcp for the on-demand list-price baseline; do final TCO analysis with each cloud's own calculator before relying on numbers for big decisions.
Live runtime pricing (not just weekly refresh) is being considered for v0.8 — would fetch prices directly at MCP tool invocation time instead of from the bundled catalog. Trade-offs: slower (network call per tool use), adds GCP auth requirement, breaks offline mode. The v0.7 weekly auto-refresh covers ~95% of the credibility win at zero runtime cost; live mode is opt-in territory.
Develop locally
git clone https://github.com/Albaker-Group/cloudprice-mcp.git
cd cloudprice-mcp
uv sync # Python + dev tools at the versions in uv.lock (see mise.toml)
uv run pytest # CI also runs: ruff check, ruff format --check, coverage floor
uv run python scripts/gen_tools_md.py # after changing a tool's descriptionTo point Claude Desktop at your dev copy, swap the command in the config:
{
"mcpServers": {
"cloudprice": {
"command": "python",
"args": ["-m", "cloudprice_mcp.server"]
}
}
}License
MIT — see LICENSE.
Credits
Built by Ali Albaker, multi-cloud architect — runs a live three-cloud portfolio at ~$1.80/month across AWS, Azure, and GCP, with OCI joining as the 4th cloud in 2026.
Available Tools
39 toolsanalyze_ai_spendA
FinOps for AI on the user's actual bill (a local FOCUS 1.x CSV export; nothing is sent anywhere). Finds the generative-AI lines (Amazon Bedrock, Azure OpenAI / AI Foundry, Vertex AI, OCI Generative AI) and gives spend per model split into input, output, cache-read and cache-write tokens; what was paid against list price; the same model's cost on other providers for the same tokens; how much input comes from prompt cache and what more would save; and list price changes for those models from the weekly LLM price archive. Use for: 'what is our LLM spend', 'are we overpaying for this model', 'would caching help'.
Inputs: file_path (required), top_n.
analyze_billA
Analyse the user's actual cloud bill from a FOCUS 1.x CSV export (AWS Data Exports, Azure Cost Management, GCP BigQuery FOCUS view, OCI). Read from local disk only; nothing is sent anywhere. Returns total cost, top cost drivers grouped by service / category / provider / region / SKU / resource, cost by month, the biggest month-over-month movers, list vs effective cost (what discounts saved), and commitment coverage of usage when the export carries commitment columns. Use for: 'where is our cloud money going', 'what jumped last month', 'how much of our usage is covered by RIs / Savings Plans'. Ask the user for the path to their export file.
Inputs: file_path (required), top_n, group_by.
analyze_cost_allocationA
FinOps allocation on the user's actual bill (a local FOCUS 1.x CSV export; nothing is sent anywhere). Measures how much allocatable cost carries the tags used for showback / chargeback, coverage per required tag, cost by the values of one tag (e.g. team), cost by sub-account, and the biggest untagged services and resources. Use for: 'how much of our spend is tagged', 'cost per team', 'what is missing a cost-center tag'.
Inputs: file_path (required), top_n, tag_key, required_tags.
assess_migrationA
Project cross-cloud cost + payback for moving a workload away from its source cloud. Inputs: source_cloud + workload inventory (compute / storage / object_storage / databases / egress) + optional one_time data to migrate. Returns per-target monthly cost, savings %, exit egress cost, payback months, ranked recommendation by 3-year TCO, and triggered caveats (e.g., 'OCI A1.Flex is ARM — verify your AMIs'). The kind of FinOps decision that normally lives in a half-built spreadsheet — now one tool call.
Inputs: source_cloud (required), egress, compute, storage, +6 more.
calculate_unit_costA
FinOps unit economics on the user's actual bill (a local FOCUS 1.x CSV export; nothing is sent anywhere). Divides monthly recurring spend by business volumes the user supplies (customers, requests, orders) to give cost per unit by month, and whether spend is growing faster or slower than the business. Optionally scoped to one product or team by tag. Use for: 'cost per customer', 'are we scaling efficiently'. Ask the user for the monthly volumes.
Inputs: units (required), file_path (required), tag_key, tag_value, +1 more.
compare_agent_platformsA
Where to host an AI agent, and what a month of it costs: the same agent priced on Amazon Bedrock AgentCore Runtime, Azure AI Foundry Agent Service (prompt agents and hosted agents), Google Vertex AI Agent Engine, and plain serverless (AWS Lambda, Azure Container Apps). Each platform is split into hosting, tools, memory and model tokens, with the model priced on that cloud's own model service (or marked unavailable), and the busy share of a run below which AgentCore costs less than each alternative. Use for: 'AgentCore vs Foundry vs Vertex for our agent', 'should this agent run on Lambda or AgentCore', 'what will hosting 50,000 agent runs a month cost'. For token counts per run, use estimate_agent_cost first.
Inputs: vcpu, model, memory_gb, run_seconds, +6 more.
compare_carbon_footprintA
Multi-cloud carbon footprint comparison — the only FinOps tool that returns both USD cost AND kg CO2e/month side-by-side. For a given vCPU + memory shape (and optional quantity), returns per-cloud best-matching SKU + monthly cost + grid-based kg CO2e + market-based residual kg CO2e (after the cloud's published renewable matching) + power class (x86 vs ARM). Ranked cheapest-carbon-first. Surfaces tradeoffs (AWS/Azure 100% renewable matched, GCP ~64% CFE, OCI unmatched outside EU). Use when the user cares about sustainability, Green FinOps, or carbon-cost dual optimization.
Inputs: vcpus (required), memory_gb (required), targets, quantity.
compare_cloudsA
Find the cheapest equivalent VM across AWS, Azure, GCP, and OCI for a single target spec (vCPUs and memory). Returns the best-fit SKU per cloud sorted by monthly cost, plus the absolute and percent savings of the cheapest vs the most expensive option. OCI A1 Always Free is included — for specs that fit within 4 OCPU + 24 GB Arm, OCI returns $0/mo (real perpetual free tier, not a quirk).
Inputs: vcpus (required), memory_gb (required).
compare_compute_inventoryA
Bulk-compare a list of compute workloads across AWS, Azure, GCP, and OCI. Each row is independently sized to the cheapest VM that meets its vCPU/memory spec on each cloud, multiplied by quantity and hours_per_month. Optional os_disk_gb adds attached storage cost. Returns per-row matches, per-cloud totals, and the cheapest cloud overall. Useful for sizing-sheet style inputs.
Inputs: workloads (required).
compare_egressA
Compare data-transfer costs across AWS, Azure, GCP, and OCI for a given monthly volume. Two directions supported: 'out_to_internet' (tiered pricing with free-tier credits — AWS/Azure 100 GB, OCI 10 TB free) and 'inter_region' (flat rate for cross-region transfer within the same cloud). At 50 TB/mo of internet egress OCI is ~12× cheaper than the hyperscalers — a real competitive moat for content/CDN workloads. VPC peering is NOT yet modeled.
Inputs: transfers (required).
compare_gpu_workloadA
Cross-cloud GPU pricing comparison — finds the cheapest matching SKU per cloud for a (gpu_type, gpu_count) request. Supports NVIDIA T4 / A10 / A10G / L4 / L40S / V100 / A100 / H100 across AWS / Azure / GCP / OCI. Returns absolute hourly cost AND $/GPU/h so users can see both the absolute winner and the per-GPU packaging-efficiency winner (they're often different clouds). Surfaces over-provisioning when the only matching SKU has more GPUs than requested (e.g., asking for 1 H100 but only bare-metal 8x SKUs are available). Use for AI/ML workload pricing decisions — training, inference, fine-tuning.
Inputs: gpu_type (required), targets, gpu_count.
compare_llm_vs_selfhostA
Pay per token or rent GPUs and serve the model yourself? Prices a monthly token volume on an LLM API, then the GPU servers needed to serve the same volume on AWS, Azure, GCP and OCI, and the break-even volume. Needs the measured generation throughput of one server (output tokens/second, e.g. from a vLLM benchmark): it decides the answer and is never guessed. Use for: 'should we self-host Llama 3.3 70B instead of paying Together', 'at what volume do H100s beat the DeepSeek API', 'cheapest cloud to serve our open model'. Self-host cost is GPU rental only; see honest_gaps.
Inputs: model (required), gpu_type (required), output_tokens_per_second (required), targets, +6 more.
compare_object_storageA
Compare object-storage pricing across AWS S3, Azure Blob, GCP Cloud Storage, and OCI Object Storage. Each request specifies capacity_gb and access tier (hot/cool/archive); the tool picks the cheapest SKU per cloud at that tier. OCI offers 20 GB Always Free in the 'hot' tier — surfaced when capacity fits. NOTE: egress, request, and retrieval costs are not modeled (often the actual hidden killer). Prices are hand-entered list prices (as of 2026-05-04), not part of the weekly refresh — verify against the provider's page before deciding.
Inputs: volumes (required).
compare_postgres_databaseA
Compare managed PostgreSQL pricing across AWS RDS, Azure Database for PostgreSQL, GCP Cloud SQL, and OCI Database with PostgreSQL. Each request specifies vCPUs, memory, and storage_gb; the tool picks the cheapest matching SKU per cloud and totals compute + storage. Prices are hand-entered estimates (as of 2026-05-04), not part of the weekly refresh — verify against the provider's page before deciding.
Inputs: databases (required).
compare_spotA
Compare spot / preemptible pricing for a vCPU + memory shape across AWS, Azure, GCP, and OCI. Returns per-cloud best-matching SKU + on-demand cost + spot cost + savings + eviction characteristics, ranked cheapest-first. The only multi-cloud spot comparison anyone publishes openly — AWS Spot vs Azure Spot vs GCP Spot VMs vs OCI Preemptible all use different pricing + eviction models, and this tool surfaces every one of them with their tradeoffs.
Inputs: vcpus (required), memory_gb (required), targets.
compare_storage_inventoryA
Bulk-compare a list of block-storage volumes across AWS, Azure, GCP, and OCI. Each row picks the cheapest SKU matching its disk_type (ssd or hdd) on each cloud, then prices it at capacity_gb × quantity. Returns per-row matches, per-cloud totals, and cheapest cloud. IOPS and throughput are accepted but not used for SKU matching. Snapshot pricing is upper-bound (real-world incremental snapshots cost less).
Inputs: volumes (required).
compare_token_pricingA
Cross-provider LLM token pricing comparison — the only FinOps tool that returns per-1M input/output rates AND monthly cost for the same model on each provider that hosts it (Claude on Anthropic vs Bedrock vs Vertex; GPT on OpenAI vs Azure OpenAI; Llama on Bedrock; Gemini on Google vs Vertex; Mistral / DeepSeek direct). Filter by model_family ('claude', 'gpt', 'gemini', 'llama', 'mistral', 'deepseek'), exact model_id, or provider list. If monthly_input_tokens + monthly_output_tokens are provided, ranks by total monthly USD. Otherwise ranks by per-1M output cost (output tokens dominate most workloads). Surfaces cache_read / cache_write rates when published — most workloads see 30-90% input cost reduction with proper prompt caching.
Inputs: model_id, providers, model_family, monthly_input_tokens, +1 more.
compare_total_cost_of_ownershipA
Project per-cloud per-year cost over a configurable horizon (default 3 years), with linear YoY growth assumptions for compute / storage / egress. Returns cumulative TCO per cloud, year-by-year breakdown by category, and sensitivity analysis identifying the most impactful growth variable. The kind of number that goes into board decks and budget conversations — now computed from a public catalog instead of a spreadsheet.
Inputs: egress, growth, compute, storage, +7 more.
compare_workloadA
Combined compute + block-storage compare across AWS, Azure, GCP, and OCI. Pass a compute list and a storage list (either may be empty). Returns nested per-row breakdowns plus combined per-cloud totals and the overall cheapest cloud. Mirrors the structure of a two-sheet sizing workbook (compute BoM + storage BoM). Optional commitment parameter estimates 1-year or 3-year Reserved Instance / Savings Plan / Committed Use discount on compute (storage stays at on-demand). For object storage, use compare_object_storage. For managed databases, use compare_postgres_database.
Inputs: compute, storage, multi_az, commitment.
detect_bill_anomaliesA
FinOps anomaly management on the user's actual bill (a local FOCUS 1.x CSV export; nothing is sent anywhere). Compares each service's daily (or monthly) cost with its own recent normal and reports spikes, drops and new spend as events, ranked by excess cost, flagging events still going in the latest period. Use for: 'what blew up our bill', 'did anything unusual happen last week', 'what new spend appeared'.
Inputs: file_path (required), limit, group_by, min_impact, +1 more.
detect_price_anomaliesA
Statistical anomaly detection over the bundled price-history dataset. Compounds the v0.7.1 history archive: as snapshots accumulate weekly, this tool auto-flags unusual price moves without you having to manually inspect every SKU. Two methods, auto-selected by dataset density: percent_change (for <5 snapshots) and z_score (>=5). Sensitivities: strict (10% / z>=2.5), moderate (5% / z>=2.0, default), permissive (2% / z>=1.5). Use for 'what changed this week?' and 'anything weird across any cloud since {date}?' queries. Excellent source for weekly LinkedIn / blog content auto-generation.
Inputs: cloud, limit, since, method, +1 more.
estimate_agent_costA
Estimate what one run of an AI agent costs, and a month of runs. Models what per-call math misses: each agent step re-sends the whole conversation (system prompt, tool definitions, earlier outputs and tool results), so input tokens grow every step. Returns cost per run and per month, the per-step token breakdown, how much of the input is context growth, what prompt caching saves, and the same run priced on other current models (Claude, GPT, Gemini, DeepSeek by default). Use for: 'what will my agent cost at 50k runs a month', 'is Sonnet or Haiku cheaper for this agent', 'how much does caching save', 'budget for an AgentCore / LangGraph / Agents SDK agent'. Defaults describe a typical 8-step tool-using agent; pass measured token counts for a real figure.
Inputs: model (required), steps, hosting, provider, +7 more.
export_focusA
Emit FOCUS 1.3-shaped rows from any pricing query, ready to import into Vantage Custom Providers / Microsoft Cost Mgmt / OpenCost / Apptio / any FinOps tool that consumes the FinOps Foundation's open billing schema (ratified Dec 2025). The rows populate the list-price columns (ListCost, ListUnitPrice, PricingQuantity, etc.) and leave billed/contracted/effective columns NULL since cloudprice produces projections, not real bills — that's explicitly documented in the result's notes field. Use this when the user says 'export my comparison to FOCUS', 'send this to Vantage', 'plug this into our FinOps stack'. Supports query_kind: compute_workload (calls assess_migration), token_pricing (compare_token_pricing), extended_model_lookup (lookup_extended_model_pricing). Format is 'json' (default) or 'csv'.
Inputs: query_kind (required), mode, query, egress, +17 more.
find_commitment_gapsA
FinOps rate optimisation on the user's actual bill (a local FOCUS 1.x CSV export; nothing is sent anywhere). Returns commitment coverage of eligible compute and database usage, utilisation of existing Savings Plans / RIs / CUDs (and what unused commitment cost), and per cloud the steady on-demand spend that could be committed, with the $/hour commitment and annual saving for 1-year and 3-year no-upfront terms. Use for: 'are we under-committed', 'how much would a Savings Plan save us', 'are our reservations being used'.
Inputs: file_path (required).
find_egress_arbitrageA
Specialized assess_migration scoped to egress patterns. Useful when a team's largest cost line is data transfer (CDN workloads, video streaming, content distribution). Returns per-target egress cost, monthly + annual savings, payback months on any one-time exit cost, and recommendation. The OCI 12× moat is the headline finding: at 50 TB/month internet egress, OCI is roughly $340 vs $4,000+ on the hyperscalers because of OCI's 10 TB/month free tier + $0.0085/GB beyond.
Inputs: egress (required), source_cloud (required), targets, one_time.
forecast_spendA
FinOps forecasting on the user's actual bill (a local FOCUS 1.x CSV export; nothing is sent anywhere). Projects month-end spend and the next months from the trend in recurring spend, each with a 95% range, and lists the services whose spend is growing fastest. Daily exports (28+ days) give a daily trend and a month-end estimate. Use for: 'what will this month's bill be', 'where is spend heading next quarter', 'what is driving growth'.
Inputs: file_path (required), horizon_months.
generate_decision_reportA
Generate a CFO-grade FinOps decision report in markdown. Combines assess_migration + compare_carbon_footprint into a single structured artifact the user can paste into a wiki / PR / Slack / email. Sections: executive summary, per-cloud cost table, carbon comparison (optional), the workload spec, aggregated honest_gaps, and an audit trail (package version, catalog as_of, requester, reproduce command). The 'trust' angle commercial FinOps tools can't easily replicate because their reports live in their UI; this one is markdown the user owns. Use when the question is 'we need a decision artifact a CFO can sign off on'.
Inputs: source_cloud (required), egress, compute, storage, +8 more.
get_aws_priceA
Look up the on-demand Linux hourly + monthly price for an AWS EC2 instance type in us-east-1. Returns vCPUs, memory, hourly USD, and monthly USD (730 hours). For multi-cloud comparisons including OCI, Azure, and GCP, use compare_clouds instead.
Inputs: instance_type (required).
get_azure_priceA
Look up the on-demand Linux hourly + monthly price for an Azure VM size in eastus. Returns vCPUs, memory, hourly USD, and monthly USD.
Inputs: vm_size (required).
get_gcp_priceA
Look up the on-demand Linux hourly + monthly price for a GCP Compute Engine machine type in us-east1. Returns vCPUs, memory, hourly USD, and monthly USD.
Inputs: machine_type (required).
get_price_historyA
Return the multi-cloud price history for a specific (cloud, sku). cloudprice-mcp persists every weekly auto-refresh as a dated snapshot, so this is the only FinOps tool that can answer 'what did m5.xlarge cost in May?' — neither AWS Calculator nor GCP Estimator preserves historical pricing. Returns the timeseries, total change %, and the earliest/latest data points. Useful for: validating commitment timing, spotting quiet price increases, citing audit-traceable historical numbers to a CFO.
Inputs: sku (required), cloud (required), since.
list_tracked_skusA
List every (cloud, sku) pair present in the bundled price-history dataset, with how many weekly snapshots exist for each. Use this to discover which SKUs you can call get_price_history on, or to find the biggest-mover SKUs since a given date. Filter by cloud to scope.
Inputs: cloud, since.
llm_price_changesA
What changed in LLM token pricing between two weeks: models that were repriced (with old and new $/1M input and output, and % move), models added, and models removed, across ~3,600 model/provider rows from LiteLLM (direct provider prices) and OpenRouter (routed prices). Backed by a weekly archive kept since 2026-05-23. Use for: 'what got cheaper this week', 'did Anthropic or Bedrock change prices since October', 'new models on Groq this month', 'has Mistral Large's price moved'. Defaults to the latest week vs the week before.
Inputs: limit, query, since, until, +2 more.
lookup_extended_model_pricingA
Search the extended LLM catalog (~2300 model/provider combinations auto-ingested weekly from two upstreams: LiteLLM's public JSON (direct-provider retail prices for Together AI, Fireworks, Replicate, Groq, Cerebras, Perplexity, regional Bedrock/Azure variants, etc.) and OpenRouter's /api/v1/models (routed prices including OpenRouter's margin). Every row tagged source='litellm' or source='openrouter' so callers can compare direct vs routed pricing for the same model. Complements compare_token_pricing (hand-curated, 19 vetted models). Use this when the user asks about: (a) a model or provider compare_token_pricing doesn't know — 'cheapest place to host Llama 3.1 405B', 'Together AI pricing', 'what Groq charges for Mixtral' — or (b) whether OpenRouter routing is cheaper or more expensive than going direct to Bedrock/Anthropic/OpenAI ('does OpenRouter add margin for Claude 3 Haiku?').
Inputs: mode, limit, query, source, +4 more.
model_retirementsA
Which LLMs providers are retiring: models whose retirement date (from LiteLLM's feed, refreshed weekly) falls within the window, across Bedrock, Azure OpenAI / AI Foundry, Vertex AI, OpenAI, Anthropic and others, plus those retired in the last 90 days. For each: the date, days left, and the newest same-family model on the same provider that is not retiring, with its list price change. Use for: 'which of our models are being retired', 'is Claude 3.5 Sonnet on Bedrock going away', 'what replaces gpt-4o on Azure'. analyze_ai_spend and review_agentcore flag retiring models on your bill and in your deployment automatically.
Inputs: model, top_n, provider, within_days.
optimize_commitmentA
Compute per-scenario cost / savings / payback for compute commitment options (none, 1yr_no_upfront, 1yr_all_upfront, 3yr_no_upfront, 3yr_partial_upfront, 3yr_all_upfront). Returns each scenario's monthly cost, upfront, 3-year total, savings %, and payback months — plus the recommended scenario by lowest 3-year TCO. Compute-only (storage / database / object / egress are not discounted because most clouds don't offer meaningful commitments on these). Per-family RI tiers come in v0.6.x; v0.6.0 uses cloud-level conservative averages.
Inputs: compute (required), cloud, egress, storage, +6 more.
reprice_billA
FinOps benchmarking on the user's actual bill (a local FOCUS 1.x CSV export; nothing is sent anywhere). Works out the vCPU-hours and memory the bill's compute actually used and prices that same capacity at list price on AWS, Azure, GCP and OCI, per instance type and in total, next to what the user really paid. Reports what it could not reprice (GPUs, licensed OS, unknown types) with its cost. Use for: 'what would our bill cost on another cloud', 'are we on the cheapest cloud for this compute', 'is a migration worth looking at'.
Inputs: file_path (required), top_n.
review_agentcoreA
Well-Architected review of an Amazon Bedrock AgentCore deployment, run locally on terraform show -json output (a saved plan or state; nothing is sent anywhere, no AWS credentials). Coded rules check every Runtime, Harness and Gateway and the IAM, logs and alarms around them: public network, unauthenticated or debug gateways, InvokeModel on every model, secrets in environment variables, idle and lifetime settings, harness caps, log retention, alarms and cost tags. Each finding has severity, pillar, resource address, a Terraform fix and the AWS doc it rests on. Given a FOCUS bill (and a tag such as agent=genie) it adds what the agent costs by component and the prompt-caching and over-list-price savings. Use for: 'review our AgentCore setup', 'is this agent production-ready', 'what does this agent cost and what should we fix'.
Inputs: plan_path (required), tag, skips, bill_path.
watch_workloadA
Cost Drift Sentinel — turns cloudprice from query tool into agent capability. First call (no baseline): captures the current per-cloud monthly cost for the workload as a baseline JSON the caller persists. Subsequent calls (with the saved baseline): compute today's cost, compare to baseline, return a structured drift report with per-cloud delta + SKU-level attribution from the price-history dataset. Stateless — no database, no server-side storage. Drop the baseline JSON into a git repo or any durable location. Designed for scheduled agents (GitHub Actions cron, Claude Code's autonomous mode, etc.) to detect 'has this cost moved since I signed off?' between runs.
Inputs: source_cloud (required), egress, compute, storage, +7 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 39 tools
Several clusters overlap: compare_clouds, compare_workload, and compare_compute_inventory all price multi-cloud compute, compare_egress and find_egress_arbitrage both address egress savings, and detect_price_anomalies and detect_bill_anomalies differ mainly by data source. Descriptions and explicit cross-references reduce confusion, but the number of near-neighbor compare/analyze tools means an agent can still misselect without careful reading.
Names are overwhelmingly snake_case with descriptive verb_noun forms such as compare_*, get_*, analyze_*, and detect_*, making the suite predictable. A few noun-only names like model_retirements and llm_price_changes, plus a broad verb vocabulary, keep it from perfect consistency.
39 tools is well above the 15-tool guideline and sits in the rubric's 25+ 'too many' band. The scope is broad, but many niche FinOps, AI, and cloud pricing capabilities make discovery and selection costly.
The surface covers compute, storage, object storage, Postgres, GPU, spot, egress, carbon, TCO, migration, commitments, bill analysis, LLM pricing, agent costing, exports, and history/anomalies. Minor gaps remain, such as no dedicated OCI single-price lookup and explicitly unmodeled dimensions like VPC peering, but agents can work around them.
Maintenance
Related MCP Connectors
Hosted MCP server for LLM cost estimation, model comparison, and budget-aware routing.
Hosted Amazon Seller and Vendor MCP server for Claude, ChatGPT, Cursor, Codex, Gemini, Copilot.
Hosted MCP server for AWS cloud spend: service breakdowns, anomalies, savings and forecasts.
Cloud-hosted MCP server for durable AI memory
Related MCP Servers
- AlicenseBqualityCmaintenanceAn MCP server for unified cost tracking and analysis across AWS, OpenAI, and Anthropic. It enables users to query expenditures, compare costs across providers, and analyze usage trends through natural language.10MIT
- AlicenseAqualityCmaintenanceMulti-cloud pricing comparison MCP server that enables natural language queries to compare compute, storage, egress, and Kubernetes costs across AWS, Azure, GCP, and OCI.3189 npm4Apache 2.0
- AlicenseNot gradedqualityDmaintenanceLive LLM pricing as an MCP server. Ask Claude or any MCP client 'how much does this prompt cost?' and get real numbers from a hand-checked pricing table for every major LLM.MIT
- FlicenseBqualityDmaintenanceAn MCP server that gives Claude live access to Azure pricing and cost data — retail prices, VM comparisons, reservation analysis, architecture estimates, and actual subscription spend.91-