cloudprice-mcp

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.6.0
Disambiguation4/5
Most tools have clearly distinct purposes: compare_clouds for single VM, compare_compute_inventory for bulk compute, compare_workload for combined compute+storage, etc. However, assess_migration and compare_total_cost_of_ownership overlap in projecting workload costs, and compare_workload overlaps with separate inventory tools, causing minor ambiguity.
Naming Consistency4/5
Names follow a mostly consistent pattern: 'compare_' for multi-cloud comparisons, 'get_' for single-cloud lookups, and specialized verbs like 'assess_', 'find_', 'optimize_'. Minor variations exist (e.g., compare_total_cost_of_ownership vs compare_clouds) but overall readable and predictable.
Tool Count5/5
14 tools is well-scoped for a cloud pricing server. Each tool covers a distinct pricing scenario (single VM, bulk compute, storage, egress, databases, migration, TCO, commitment), avoiding redundancy without missing critical functionality.
Completeness4/5
The tool set covers core compute, storage, egress, database, migration, and TCO scenarios. Notable gaps include non-PostgreSQL databases, serverless compute, and advanced networking costs (e.g., VPC peering, load balancers). Descriptions acknowledge missing features, which agents can work around.
Average 4.2/5 across 14 of 14 tools scored. Lowest: 3.6/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 1 commit in the last 12 weeks
- Last stable release on May 9, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is failing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
This repository includes a glama.json configuration file.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the two directions, free-tier credits, and an example pricing comparison. It also notes that VPC peering is not accounted for. However, it does not describe the output format or any error handling expectations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is verbose and includes promotional language ('a real competitive moat') that is unnecessary for tool selection. While front-loaded with purpose, the detailed pricing example adds length without improving clarity for the agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description adequately covers behavior and limitations (VPC peering not modeled). However, it lacks information on expected output structure, error scenarios, or how to interpret the comparison results, leaving some gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one parameter (transfers) with property descriptions, but the tool description adds context on the meaning of directions and free tiers (e.g., AWS/Azure 100 GB free, OCI 10 TB). The description coverage of parameters is 0% from the tool text, but the schema provides some detail, resulting in a moderate score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool compares data-transfer costs across four major cloud providers for a given volume. It specifies the two supported directions (out_to_internet and inter_region) with context on pricing tiers, distinguishing it from sibling tools like find_egress_arbitrage and compare_clouds.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for comparing egress costs but does not explicitly state when to use this tool versus alternatives like assess_migration or find_egress_arbitrage. It mentions that VPC peering is not modeled, which is a limitation, but lacks direct guidance on scenarios or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but description details return values (per-target cost, savings, payback months, recommendation) and gives concrete pricing example. Does not disclose side effects or limitations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Contains verbose example (OCI pricing) that is informative but could be more concise. First sentence is clear; rest adds context but lengthens description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite nested objects and 4 parameters, description lacks explanation of parameter structure (e.g., egress array format, direction enum). No output schema; behavior partially explained but input details missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%; description does not explain parameters (egress, targets, one_time, source_cloud). Only indirectly references output, not input fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly defines it as a specialized version of assess_migration focused on egress, with specific use cases (CDN, video streaming). Distinguishes from sibling tools like assess_migration and compare_egress.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use: when data transfer is the largest cost line. Provides context but does not mention when not to use or cite alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the region (us-east1), OS (Linux), and pricing type (on-demand), but does not mention that the machine type list is limited to the enum values or any caching/real-time behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, consisting of two sentences that front-load the action and context, then list the returned fields. No redundant information is present.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple lookup tool with one parameter and no output schema, the description covers the return fields adequately. However, it does not mention the restriction to us-east1 and Linux, which could mislead users expecting other regions or OS options.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the single parameter, so the schema fully documents it. The description adds no further meaning beyond stating 'machine type'; the schema's enum provides the specific allowed values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'look up', the specific resource 'GCP Compute Engine machine type', and context 'on-demand Linux hourly + monthly price in us-east1'. It also lists the return fields, differentiating it from sibling tools like get_aws_price and get_azure_price.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving GCP VM pricing but does not explicitly state when to use this tool versus alternatives like assess_migration or compare_clouds. It offers no guidance on exclusions such as other regions or OS types.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses key behavioral traits: compute-only evaluation, no discounts for storage/database/egress, returns recommended scenario by lowest 3-year TCO. Also notes versioning (v0.6.0 uses cloud-level averages, per-family tiers in v0.6.x). No annotation contradiction. Could mention input validation or error states, but overall transparent for a non-destructive tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is a single informative paragraph that efficiently covers purpose, scope, scenarios, output, and limitations. No wasted sentences. Could be split into bullet points for readability, but current structure is acceptable and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 10 parameters, nested objects, and no output schema, the description provides essential context but lacks complete guidance. It explains output and scope but does not clarify required parameters (only compute) or the structure of nested inputs. Missing details on return format beyond text. Adequate but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 30%, so description must compensate. The description adds context about scenarios and output, but does not explain individual parameters beyond listing scenario options. For example, it does not clarify that 'compute' array requires vcpus and memory_gb or that 'cloud' defaults to source_cloud then 'aws' (though schema has some descriptions). Partial compensation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it computes per-scenario cost/savings/payback for compute commitment options, lists specific scenarios and return fields (monthly cost, upfront, 3-year total, savings %, payback months, recommended scenario). Distinct from sibling tools like compare_total_cost_of_ownership by focusing specifically on commitment options for compute.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies use for commitment decision-making but does not explicitly state when to use this tool versus alternatives like compare_total_cost_of_ownership. Mentions compute-only scope and that per-family RI tiers are not yet available, which gives some guidance on limitations but lacks direct comparison guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It explicitly states the tool uses linear YoY growth assumptions, a configurable horizon (default 3 years), and returns cumulative TCO, year-by-year breakdown, and sensitivity analysis. It also notes it computes from a public catalog, but does not mention if it modifies data or requires authentication.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (three sentences), front-loaded with the primary action ('Project per-cloud per-year cost'), and efficiently conveys key outputs and use case. It could be slightly tighter but is well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (11 parameters, nested objects, no output schema), the description provides adequate context for purpose and outputs but lacks details on default behavior (e.g., what happens with empty inputs) and output structure beyond brief mentions. It meets minimum viability but has gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is very low (18%), and the description does not compensate by explaining individual parameters. It provides high-level context about growth assumptions and horizon but does not describe the meaning of arrays like compute, storage, egress, or their nested fields. The agent would need to infer from parameter names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Project per-cloud per-year cost over a configurable horizon' and details the outputs (cumulative TCO, breakdown, sensitivity analysis). It distinguishes itself from sibling tools like compare_clouds (likely static) and assess_migration (likely migration-focused) by focusing on future cost projection with growth assumptions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions the use case: 'The kind of number that goes into board decks and budget conversations,' providing clear context for when to use this tool. However, it does not explicitly exclude alternative tools or state when not to use it, so it falls short of a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden. It discloses important behavioral traits: returns per-target costs, savings, payback, and caveats (e.g., 'OCI A1.Flex is ARM — verify your AMIs'). This is transparent about the output including warnings, but doesn't explicitly state that it is read-only or idempotent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, front-loaded with the main purpose, and uses short sentences to list inputs and outputs. It includes a memorable analogy ('half-built spreadsheet') without wasting words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (10 parameters, nested objects, no output schema), the description covers the main purpose, key inputs, and important outputs like caveats. It lacks details on output structure and default behavior for the 'targets' parameter, but is generally complete enough for an agent to understand the tool's utility.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is low at 20%. The description lists broad input categories (compute, storage, etc.) and gives a high-level overview of output dimensions, but does not explain specific parameters like snapshot_incremental_factor or the structure of egress items. It adds some context but not enough to fully compensate for the schema gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Project cross-cloud cost + payback for moving a workload away from its source cloud.' It lists specific inputs and outputs, and distinguishes itself from sibling tools by positioning it as an integrated FinOps assessment that replaces a spreadsheet.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for cost comparison scenarios but does not explicitly state when to use this tool over alternatives like compare_workload or total_cost_of_ownership. There are no exclusion criteria or guidance on prerequisite data preparation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Explains independent sizing, cost multiplication, optional storage, and output structure. Lacks details on pricing freshness or rate limits but is sufficiently transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences; first defines purpose, second details behavior and use case. No redundant or irrelevant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Good coverage of behavior and outputs given complexity. Mentions per-row, per-cloud, and cheapest cloud results. No output schema, so description compensates well, though could clarify output format details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions cover many parameters (e.g., name, tier, os_disk_gb). Description adds limited extra value beyond mentioning os_disk_gb's effect. No additional parameter-specific guidance.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it bulk-compares compute workloads across four clouds, with specific verbs and resource. Distinguishes from siblings like 'compare_workload' (single workload) and 'compare_clouds' (generic).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies usage for 'sizing-sheet style inputs' but does not explicitly state when to use vs alternatives or when not to use. No exclusions or alternative tool names mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses key behaviors: cheapest SKU matching by disk_type, pricing formula, ignored fields (IOPS/throughput), and snapshot pricing being upper-bound. Returns per-row, per-cloud totals, and cheapest cloud. No annotations present, so description carries full burden; it meets it well.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted words. First sentence states purpose, second adds critical behavioral details. Front-loaded and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given complexity (multi-cloud, many nested parameters, no output schema), the description covers purpose, pricing logic, ignored fields, and output structure. Missing explicit output format details but sufficient for an agent to understand usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Adds meaning beyond schema: explains IOPS and throughput are metadata only, snapshot pricing details (upper-bound, incremental factor). Schema has 0% coverage on outer param, but inner properties have descriptions. Description compensates by clarifying behavioral aspects.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it bulk-compares block-storage volumes across four clouds, specifying verb and resource. It distinguishes from siblings like compare_compute_inventory which focuses on compute.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implied usage for block-storage pricing comparison, but no explicit when-to-use or alternatives given. Does not mention when not to use or differentiate from related tools like compare_object_storage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description discloses that the tool picks the cheapest SKU per cloud, highlights OCI free tier, and warns about missing costs and preview status. This is comprehensive for a pricing comparison tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured: purpose first, then inputs, then a critical limitation note. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description lacks details on result format (e.g., table of prices). However, it covers core behavior, inputs, and limitations adequately for the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description explains the tier parameter (hot/cool/archive) and adds context about OCI free tier based on capacity. Schema descriptions also cover tier, but the description provides additional behavioral semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the tool compares object-storage pricing across AWS S3, Azure Blob, GCP Cloud Storage, and OCI Object Storage, and mentions key inputs. This clearly distinguishes it from sibling tools like compare_egress.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description specifies when to use the tool (comparing pricing for a given capacity and tier) and notes limitations (egress not modeled). However, it does not explicitly name alternative tools for excluded costs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It explains the return structure (nested breakdowns, per-cloud totals, cheapest cloud) and the effect of commitment parameter. While it does not explicitly state it's read-only, it implies a query operation. Almost fully transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single paragraph of five sentences, each adding necessary information. Front-loaded with purpose, then usage, then exclusions. No filler, no repetition of schema details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given complexity (nested arrays, no output schema), the description explains return structure and distinguishes sibling tools. It covers the main use case but lacks details on response format or error handling. Almost complete, minor gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 50%, baseline 3. The description adds semantics for the commitment parameter (explaining discount percentages) but does not delve into the array parameters' sub-fields beyond stating they expect compute and storage lists. Adequate but minimal additional value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Combined compute + block-storage compare across AWS, Azure, GCP, and OCI', providing a specific verb-resource pair. It distinguishes itself from siblings by naming alternative tools for object storage and databases.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Pass a compute list and a storage list (either may be empty)' and provides exclusions: 'For object storage, use compare_object_storage. For managed databases, use compare_postgres_database.' This gives clear when-to-use and when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description fully bears the transparency burden. It discloses that pricing is bundled placeholder data, advises verification, and explains the tool's logic (picks cheapest SKU per cloud, totals compute+storage). This is transparent about limitations and behavior, though it omits details like rate limits or authentication needs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, with a clear first sentence stating purpose, a second sentence explaining how it works, and a third sentence providing an important caveat. Every sentence is essential and front-loaded for quick understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (multi-cloud comparison), the lack of output schema, and the placeholder data warning, the description provides sufficient context for an agent to use the tool correctly. It covers input requirements, tool behavior, and a crucial limitation. It is complete for the task.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has descriptions for some nested properties, but the context reports 0% schema description coverage. The tool description adds value by explaining how the parameters (vCPUs, memory, storage_gb) are used to select and total SKUs. This goes beyond what the raw schema provides, even though the schema has some self-documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool compares managed PostgreSQL pricing across four major clouds. It uses specific verbs (Compare) and resource (managed PostgreSQL pricing), distinguishing it from sibling tools that compare other resources like compute or storage.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains that each request must specify vCPUs, memory, and storage_gb, and that the tool picks the cheapest matching SKU per cloud. It also warns that the pricing is placeholder data and should be verified. However, it does not explicitly state when to use this tool over alternatives, though the context from sibling names implies it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but the description discloses that it returns specific fields (vCPUs, memory, hourly/monthly USD) for on-demand Linux pricing. It is transparent about the read-only nature of a lookup.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with the action, and includes all essential details without waste. Every word adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite no output schema, the description fully specifies return values. The tool is simple with one enumerated parameter, and the description covers all necessary context for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the single parameter. The description adds meaning by specifying region (eastus), OS (Linux), and pricing model (on-demand), which are not in the schema but are critical for correct usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool looks up Azure VM pricing for a specific VM size in the eastus region, returning vCPUs, memory, and costs. It distinguishes from sibling tools by specifying Azure and the region.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use (need Azure VM pricing in eastus) and the siblings include other cloud providers for context. It does not explicitly list exclusions or alternatives but the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, but the description reveals key behaviors: best-fit SKU per cloud sorted by cost, savings calculation, and OCI free tier inclusion. It is transparent about what the tool returns.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no redundancies. The first sentence states purpose and outputs, the second adds an important caveat. Front-loaded with key information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Excellent for a simple tool with two parameters: explains outputs (SKUs, costs, savings) and OCI edge case. Lacks details on return format or error handling, but adequate given no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, yet the description explicitly associates vcpus and memory_gb with the target spec, providing necessary meaning beyond the raw schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the tool finds the cheapest equivalent VM across four cloud providers for a single target spec (vCPUs and memory). It distinguishes itself from siblings like compare_compute_inventory by focusing on a single spec comparison.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for single spec comparisons via 'single target spec' but does not explicitly state when to use it over siblings or provide exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes return values (vCPUs, memory, hourly USD, monthly USD) and constraints (on-demand Linux, us-east-1). Lacks explicit mention of read-only nature or any side effects, but no annotations to contradict; behavior is well disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no wasted words. First sentence conveys purpose and output, second gives alternative. Front-loaded with key action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given simple tool with one parameter and no output schema, description fully covers purpose, return fields, constraints, and alternative. No gaps for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers 100% of parameter, but description adds context that the instance_type is for on-demand Linux in us-east-1, enhancing meaning beyond the schema's type listing.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the verb 'Look up' and specific resource: on-demand Linux hourly and monthly price for AWS EC2 instance type in us-east-1. Distinguishes from sibling compare_clouds by focusing on single AWS instance pricing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly specifies when to use (on-demand Linux, us-east-1) and provides an alternative (use compare_clouds for multi-cloud comparisons). Clear context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![cloudprice-mcp MCP server](https://glama.ai/mcp/servers/Albaker-Group/cloudprice-mcp/badges/card.svg)](https://glama.ai/mcp/servers/Albaker-Group/cloudprice-mcp)

Score Badge

Copy to your README.md:

[![cloudprice-mcp MCP server](https://glama.ai/mcp/servers/Albaker-Group/cloudprice-mcp/badges/score.svg)](https://glama.ai/mcp/servers/Albaker-Group/cloudprice-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Albaker-Group/cloudprice-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server