Opencloudcosts Mcp

MCP运维云端

提供方 x7even

运维云端 未标注 API Key 社区 / 第三方 Claude DesktopClaudeCursorGemini CLI

Anchor AI FinOps to real, live cloud pricing. Multi-cloud MCP server for AWS, GCP & Azure — public list prices and enterprise negotiated rates (Reserved Instances, Savings Plans, CUDs, EDPs). No credentials needed to get started.

一句话选型结论

按资料字段整理

Opencloudcosts Mcp 属于运维云端类 MCP 服务器,传输方式未标注,API Key,可直接接入 Claude Desktop、Claude、Cursor 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类运维云端 传输方式未标注 鉴权API Key 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

运维云端
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

cloud aws azure gcp cost optimization finops ai tools

支持客户端

适用场景

cloudawsazure

安装与配置

未标注 API Key
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
云资源查询

查实例、存储、账单等云上资源状态。

部署与发布

把部署、重启、回滚这类操作接进对话。

监控与告警

拉取监控指标,异常时让模型帮你判断。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在运维云端场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Opencloudcosts Mcp当前 未标注 未标注 未标注 无 未标注
lobehub 未标注 stdio · 本地进程 本地部署 有 2026-04-11
TrendRadar 未标注 stdio · 本地进程 本地部署 有 2026-04-13
Ui Tars Desktop 8a825770 未标注 stdio · 本地进程 本地部署 有 2026-05-17
ruflo 未标注 stdio · 本地进程 本地部署 有 2026-04-13
FastGPT 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

运维云端
字段来自项目仓库与公开索引,中文说明由本站标注
提供方x7even上游标注的维护方 x7even
分类运维云端本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式API Key远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Cross-platform本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

23.3 KB
来自项目仓库与上游目录的原文,未做删改

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.

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 — compare_bom, 8 concurrent provider calls
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 — estimate_unit_economics
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 (OCC_GCP_API_KEY) — no billing account, no credit card
AWS post-discount rates (Reserved Instances, Savings Plans) + get_discount_summary AWS credentials + OCC_AWS_ENABLE_COST_EXPLORER=true ($0.01/call to Cost Explorer, opt-in only)
GCP committed-use discounts (CUDs) and Enterprise Discount Programs (EDPs) ADC credentials + billing.billingAccountPrice.get IAM + OCC_GCP_BILLING_ACCOUNT_ID

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 get_price, get_prices_batch, compare_prices, describe_catalog, search_pricing†, get_spot_history†
FinOps estimate_bom, estimate_unit_economics, compare_bom, get_discount_summary
Discovery list_regions, list_instance_types, find_cheapest_region, find_available_regions
Cache refresh_cache, cache_stats

† 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_region and find_available_regions: errgroup + semaphore, up to 32 goroutines — queries all available regions in parallel, returns results sorted cheapest-first
  • compare_bom: 8 concurrent provider calls across AWS, GCP, and Azure simultaneously
  • compare_prices: semaphore of 10 concurrent region calls
  • get_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.```bash
pip install opencloudcosts
opencloudcosts # stdio mode (for local MCP clients)
opencloudcosts --transport http --host 0.0.0.0 --port 8080 # HTTP mode


### Option 2 — Homebrew (macOS / Linux)```bash
brew tap x7even/opencloudcosts
brew install opencloudcosts

Option 3 — binary download

Download the pre-built binary for your platform from the latest release:```bash

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
./opencloudcosts


### Option 4 — Docker / container```bash
# 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:local

The image is ~15 MB (distroless scratch base, static binary). No credentials are
required for AWS and Azure public pricing.

Option 5 — build from source```bash

git clone https://github.com/x7even/cloudcostsmcp
cd cloudcostsmcp/opencloudcosts-go
CGO_ENABLED=0 go build -o opencloudcosts ./cmd/opencloudcosts
./opencloudcosts


### Connect to Claude Code

**Stdio (local process — recommended for single-user)**

Add to `~/.claude/settings.json` or your project's `.mcp.json`:```json
{
  "mcpServers": {
    "cloudcost": {
      "command": "opencloudcosts",
      "env": {
        "OCC_GCP_API_KEY": "AIza..."
      }
    }
  }
}

HTTP (shared/remote server — one server, many clients)```json
{
"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```bash
npx @modelcontextprotocol/inspector opencloudcosts

AWS Credentials

Feature Credentials needed
Public pricing (EC2, EBS, RDS list prices) None
Effective pricing (RI / SP discounts) AWS credentials + OCC_AWS_ENABLE_COST_EXPLORER=true

Minimal IAM policy for public pricing:```json
{
"Effect": "Allow",
"Action": ["pricing:GetProducts", "pricing:DescribeServices", "pricing:GetAttributeValues"],
"Resource": "*"
}


Add these for effective pricing:```json
"ce:GetCostAndUsage", "savingsplans:DescribeSavingsPlans", "savingsplans:DescribeSavingsPlanRates"

Configuration

All settings via environment variables (prefix OCC_) or .env file:

Variable Default Description
OCC_CACHE_TTL_HOURS 24 Public price cache TTL
OCC_AWS_ENABLE_COST_EXPLORER false Enable AWS effective pricing (costs $0.01/call)
OCC_DEFAULT_REGIONS us-east-1,us-west-2 Default regions
AWS_PROFILE (default chain) AWS credentials profile
OCC_GCP_BILLING_ACCOUNT_ID (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):
1. Go to console.cloud.google.com/apis/credentials
2. Create a Project if you don't have one (free)
3. Click Create Credentials → API key
4. Set the key:```bash
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`):```bash
gcloud auth application-default login
# or set GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json

GCP 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:

  1. ADC credentials: gcloud auth application-default login
  2. billing.billingAccountPrice.get IAM permission on your billing account
  3. Your billing account ID:```bash
    export OCC_GCP_BILLING_ACCOUNT_ID=012345-567890-ABCDEF

With 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.```bash
# No configuration needed — works out of the box
uv run opencloudcosts

Azure 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, and savingsplans:Describe* permissions.
- Store credentials in .env (see .env.example) and never commit that file to version control.

Transport security
- The default stdio transport 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.source Literal
  • v0.9.2 ✅ Azure OpenAI model matching fix; Azure Functions pricing fix; list_instance_types cap; 199-prompt harness suite
  • v1.0.0 ✅ Go rewrite — static binary, dual stdio/HTTP transport, 16 tools, compare_bom cross-cloud workload comparison, concurrent region fan-out (32 goroutines), Azure o1-mini SKU fix; 234/234 (100%) LLM grounding harness
  • v1.0.1 ✅ PyPI package description; CI Trusted Publisher fix; go install tag
  • v1.0.2 ✅ README accuracy fixes; cache description updated

常见问题

7 问
答案由本站依据条目字段整理,不引用上游原文
Opencloudcosts Mcp 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

Opencloudcosts Mcp 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Opencloudcosts Mcp 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Opencloudcosts Mcp 需要 API Key 吗?

资料标注需要API Key认证,使用前准备好对应凭据,并按最小权限配置。

Opencloudcosts Mcp 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、Gemini CLI、Codex、Zed;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Opencloudcosts Mcp 能提供哪些能力?

资料显示能力标签包括 cloud、aws、azure、gcp、cost optimization、finops。具体工具清单以官方文档为准。

Opencloudcosts Mcp 需要什么运行环境?

运行时为 Cross-platform。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。