platform-mcp

Server Quality Checklist

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

Latest release: v0.4.0
Disambiguation4/5
Most tools target clearly distinct GCP resources or actions, but query_logs and get_recent_errors overlap as general vs. error-filtered log queries, and list_cost_recommendations vs. list_recommendations could cause some selection uncertainty despite their aggregate/specific distinction.
Naming Consistency5/5
All tools follow a consistent verb_noun pattern: list_* for enumeration, query_* for log/metric queries, get_* for specific lookups, and search_assets for asset discovery. There are no mixed naming conventions or unpredictable verbs.
Tool Count4/5
At 16 tools, the server is slightly above the ideal 3-15 range, but the count is justified by the broad GCP read-only scope covering logs, errors, metrics, alerts, costs, billing, and multiple resource types. No tool feels redundant enough to remove.
Completeness4/5
The toolset covers core platform observability, cost, billing, and resource discovery well, with no obvious dead ends for typical read-only queries. Minor gaps exist such as lacking detailed single-resource fetches and specific listings for services like Cloud Storage or BigQuery, though search_assets partially mitigates these.
Average 4.2/5 across 16 of 16 tools scored. Lowest: 3.5/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 12 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
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.
Add a glama.json file to provide metadata about your server.
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

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context about the 'default environment' behavior, but it does not disclose pagination, return format, or permission requirements, leaving some behavioral gaps.
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 compact and front-loaded with the core purpose. The parameter explanations are brief, directly useful, and do not repeat schema information unnecessarily beyond what is needed for clarity.
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?
For a simple read-only list tool with no required parameters, the description is nearly complete. It explains both parameters and the default environment behavior, which is enough for an agent to select and invoke the tool. A return-value or permission note would make it fully complete, but the absence is not critical at this complexity level.
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 description coverage is 0%, so the description carries the burden of explaining parameters. It does this well: 'limit' is defined as the maximum number of services to return, and 'environment' is explained with examples and default behavior. It could add a pointer to list_environments for valid environment values, but it is already effective.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear verb and resource: 'List Cloud Run services.' It is specific enough to distinguish from sibling tools that list other GCP resources like compute instances or GKE clusters, though it does not explicitly differentiate itself from those siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to use this tool versus alternatives. It explains how to use the environment parameter but does not mention when an agent should prefer this over list_compute_instances, list_gke_clusters, or list_environments.
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?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context like environment selection and location being dependent on the recommender, but it does not disclose pagination behavior, return shape, or default environment resolution.
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 summary sentence is front-loaded and the Args list is clean and scannable. It is slightly longer than strictly necessary but every parameter explanation earns its place, especially the examples.
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?
For a read-only list tool with no output schema, the description covers the essential invocation details: required and optional parameters, defaults, and examples. It is not fully complete because it does not differentiate from sibling recommendation tools or describe what the returned recommendations look like, but these are minor gaps given the low complexity.
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 description coverage is 0%, and the description fully compensates by explaining all four parameters. It gives concrete recommender_id examples, zone/region/global values for location, the meaning of limit, and the environment parameter with examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource: 'List recommendations from a specific recommender at a specific location.' This clearly states the tool's function. However, it does not distinguish itself from the sibling tool list_cost_recommendations, so an agent must infer that this is the general-purpose recommender tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit guidance about when to use this tool versus list_cost_recommendations or other sibling tools. The parameter examples imply a general recommender context, but no alternatives, exclusions, or selection conditions are stated.
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?
Annotations already declare readOnlyHint, idempotentHint, openWorldHint true and destructiveHint false, covering the safety profile. The description adds the fact that it returns both the account and its status and that environment inspection is parameterized, but it does not disclose potential error cases, auth requirements, or what 'status' means. This is acceptable because annotations carry the main behavioral burden.
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 efficient sentences with the core purpose first and parameter documentation second. No filler, no repetition of annotation fields, and all content earns its place.
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?
For a one-parameter, read-only tool with rich annotations and no output schema, the description is nearly complete: it states purpose, return subject, and parameter usage. It does not specify possible status values or behavior when no billing account exists, but these are minor gaps for an optional-parameter read tool.
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?
Despite 0% schema description coverage, the description fully explains the sole parameter: what environment represents, examples ('staging', 'production'), and the default behavior when omitted. This is more than the schema provides and leaves no ambiguity about how to invoke the tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and object: 'Return the billing account linked to the project and its status.' This clearly conveys functionality and, by focusing on billing account rather than costs or logs, distinguishes it from siblings like get_cost_breakdown and query_logs. However, it does not explicitly name a sibling or draw a contrast, so it stops short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides no when-to-use guidance or exclusions relative to sibling tools. The only usage instruction concerns the optional environment parameter ('Omit to use the default environment'), which is parameter behavior, not tool-selection guidance. An agent must infer from the name and purpose when this tool is appropriate.
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?
Annotations already cover the safety profile with readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds a small behavioral detail about environment selection and defaulting, but otherwise discloses no additional behavior such as pagination, scoping, or output shape.
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 compact and front-loaded with the core purpose, followed by a concise parameter breakdown. Every sentence adds useful information without redundancy.
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?
For a simple read-only two-parameter list tool, the description fully covers what the agent needs to invoke it correctly: the resource type, the meaning of each parameter, and environment defaulting behavior. No output schema exists, so return details are not required.
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 description coverage is 0%, so the description carries the full burden. It clearly explains both parameters: 'limit' as the maximum number of clusters returned, and 'environment' with example values and explicit default behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'List GKE (Kubernetes Engine) clusters.' It is clear and unambiguous, but it does not differentiate this tool from sibling listing tools beyond the resource name itself.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to prefer this tool over alternatives such as list_compute_instances or list_cloud_run_services. It explains the environment parameter, but not tool-selection context or 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?
Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds useful behavioral context beyond annotations: hours are 'snapped to the nearest supported period', results are ordered by frequency, and environment selection is configurable.
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 front-loaded with a one-sentence purpose followed by a tight, well-organized argument list. Every sentence adds meaning without repetition or filler.
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?
The description covers all parameters, defaults, ordering, and environment behavior, which is sufficient for calling the tool correctly. It does not describe the return structure, but the absence of an output schema makes a brief note about counts and ordering a reasonable partial response.
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?
With 0% schema description coverage, the description fully compensates by explaining all four parameters: lookback window and snapping behavior, service label filtering, maximum result limit, and environment selection with an example. No parameter is left underdocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The first sentence states a specific action, 'List grouped application errors from Error Reporting with counts', which clearly identifies the resource and output. It is clear but does not explicitly distinguish itself from sibling tools like get_recent_errors or query_logs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains parameters and defaults but offers no guidance on when to use this tool versus alternatives such as get_recent_errors or query_logs. There are no explicit exclusions or conditions that would help an agent select among the siblings.
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?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds some context by scoping the query to a configured GCP environment and noting the default behavior when environment is omitted, but it does not disclose other behavioral details such as response shape or pagination.
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 compact and front-loaded with the core purpose, followed by a minimal Args section. Every sentence earns its place, with no redundant filler or repetition of schema defaults.
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?
For a simple read-only list tool with two optional parameters, the description covers the essential invocation details and the environment-scoping concept. It does not describe the return format, but since there is no output schema and this is a straightforward list operation, the gap is minor rather than blocking.
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 description coverage is 0%, so the description carries full responsibility for explaining parameters. It does so clearly for both: limit is 'Maximum number of uptime checks to return' and environment is explained with concrete examples ('staging', 'production') and guidance to omit for the default. This adds real meaning beyond the bare schema types and defaults.
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 opens with a specific verb and resource: 'List Cloud Monitoring uptime check configurations.' This clearly distinguishes the tool from sibling tools that handle logs, metrics, alerts, cost, or compute resources, so an agent can confidently identify its purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool versus alternatives, and no exclusions are stated. The environment parameter is explained for selecting an environment, but the description does not help an agent decide between this and sibling tools such as list_alert_policies or query_metric.
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?
Annotations already establish read-only, idempotent, non-destructive behavior. The description adds meaningful behavioral context: only severity ERROR or higher is returned, results are ordered newest first, and service matching applies to both resource.labels.service_name and logName. No contradiction with annotations.
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 one-line purpose statement is followed by a compact, alphabetized Args list covering all four parameters with no filler. Every sentence adds useful 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?
For a read-only log retrieval tool with no required parameters and no output schema, the description covers invocation and behavior well. It lacks an explicit description of the returned entry fields or pagination, but the parameter semantics plus annotations make calling the tool correctly feasible.
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 description coverage is 0%, so the description carries the full burden, and it delivers. Every parameter is explained: service matching semantics, hours-back with default, maximum limit with ordering, and environment selection with default behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb and resource: 'Return recent log entries at severity ERROR or higher.' It differentiates by severity and recency, which separates it from broader tools like query_logs, though it does not explicitly name or contrast any siblings.
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 when to use this tool—when recent error-level logs are needed—and explains optional narrowing by service and environment. However, it gives no explicit guidance about when to prefer a sibling tool such as query_logs or list_error_groups, nor any exclusions.
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?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the description does not need to restate safety. It adds useful context about environment selection and default behavior, but it does not disclose pagination, ordering, or response shape beyond the listed location and status fields.
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 opens with a one-sentence summary and then provides a compact Args block. There is no filler, and every sentence either clarifies scope or parameter behavior.
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?
For a simple read-only list tool with two optional parameters and strong annotations, the description is nearly complete. It covers the resource, key output attributes, and environment handling, though it stops short of fully specifying the return shape or pagination behavior.
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 description coverage is 0%, and the description fully compensates by documenting both parameters: limit as the maximum number of instances, and environment with concrete examples ('staging', 'production') and default behavior. This goes beyond the bare schema types and defaults.
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 states a specific verb and resource: 'List Compute Engine VM instances', and adds output scope with 'location and status'. This distinguishes it clearly from sibling list tools such as list_gke_clusters and list_sql_instances.
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 when to use the tool by naming Compute Engine VM instances, but it does not explicitly route around alternatives or state when not to use it. There is no mention of sibling tools like list_gke_clusters, so an agent must infer the boundary from the resource name alone.
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?
Annotations already declare readOnlyHint and idempotentHint, and the description adds useful behavioral detail: an empty filter matches all logs, results are returned newest first, and freshness controls the lookback window. This complements the annotations without contradicting them.
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 compact and well-structured, leading with the core purpose before listing parameter details. Every line provides useful guidance without repeating schema defaults unnecessarily.
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?
For a read-only query tool with no required parameters, it covers invocation essentials: filter syntax, time window, result ordering, and environment selection. The return shape is not described, but that is a minor gap given the tool name and read-only annotations.
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 description coverage is 0%, so the description carries full responsibility for parameter meaning. It thoroughly explains all four parameters with examples, defaults, and edge-case behavior such as empty filter and default environment.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool queries Cloud Logging using an advanced-filter expression. It identifies the resource and action specifically, though it does not explicitly differentiate itself from sibling tools like get_recent_errors or query_metric.
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 this is the tool for flexible Cloud Logging queries by explaining filter, freshness, limit, and environment. It does not explicitly state when to prefer sibling tools like get_recent_errors or list_error_groups for error-focused queries.
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?
The annotations already cover the safety profile with readOnlyHint, idempotentHint, and destructiveHint, lowering the bar. The description adds a note about environment scoping but does not disclose return format, pagination, or default-environment details. It neither contradicts the annotations nor provides substantial additional behavioral context.
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 compact and front-loaded: one direct purpose sentence followed by terse, meaningful parameter explanations. There is no filler or redundant restatement of the schema.
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?
For a simple list operation with two optional parameters, strong annotations, and no nested schema, the description is sufficient. It documents both parameters and their defaults, and the safety profile is already carried by the annotations, so nothing needed to invoke the tool correctly is missing.
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?
The input schema provides no parameter descriptions, so the description carries full responsibility. It compensates well: 'limit' is defined as the maximum number of instances, and 'environment' is explained with concrete examples and explicit default behavior.
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 opens with a specific verb and resource, 'List Cloud SQL instances,' which clearly identifies the operation. It is readily distinguishable from sibling list tools such as list_compute_instances and list_gke_clusters because the resource is explicitly named.
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 usage context is implied by the verb-resource pairing: this is the tool to call when enumerating Cloud SQL instances. However, it does not explicitly state when to prefer this tool over alternatives or when not to use it, so it earns only an implied-usage 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?
Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds useful behavioral context: default environment handling, default window/alignment, and aligner semantics. It doesn't mention pagination or output shape, but those are not critical for safe invocation.
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 structure is a single purpose sentence followed by a tight Args block. Each line provides format, default, or allowed values without filler. The length is justified by the need to document seven parameters.
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?
All required inputs and defaults are specified, and the annotations cover safety, so the tool can be called correctly. The only gap is that there is no output schema and the description doesn't describe the shape of the returned time series or how multiple series are returned, but this is a minor omission for a read-only query tool.
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 description coverage is 0%, so the description carries the full burden, and it succeeds. Every parameter is explained with concrete examples or valid values: metric_type, resource_filter, window, aligner options, alignment_period, limit, and environment. This fully compensates for the empty schema descriptions.
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 opens with a specific verb and resource: 'Query a Cloud Monitoring metric time series.' This clearly distinguishes the tool from siblings such as query_logs and list_alert_policies, and the metric_type examples make the target concrete.
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 parameter docs explain how to configure the query but never state when to use query_metric instead of sibling tools like query_logs or list_cost_recommendations. Usage is implied by the purpose statement and parameter details, but there is no explicit when-to-use or 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.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the description need not repeat that this is a safe read operation. The description adds useful context by noting the output includes whether policies are enabled and by explaining the environment selection behavior. It does not disclose pagination or return structure details, but the annotations and simple tool nature keep the burden low.
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 short, front-loaded with the core purpose, and each sentence in the Args section earns its place by clarifying a parameter. There is no redundant or filler content.
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?
For a low-complexity tool with no required parameters, no output schema, and annotations covering the safety profile, the description is complete. It covers what the tool does, what the parameters mean, and the behavior when 'environment' is omitted. Nothing essential for invoking the tool correctly is missing.
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?
The schema provides no descriptions for the parameters, but the description fully compensates. It explains 'limit' as the maximum number of policies to return and explains 'environment' with concrete examples and the default-omission behavior. This is exactly the semantic clarity an agent needs 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?
The description uses a specific verb and resource: 'List Cloud Monitoring alert policies and whether they are enabled.' This clearly identifies the tool's function and distinguishes it from sibling tools that list other resource types such as compute instances, GKE clusters, or uptime checks.
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 clearly frames the tool as listing Cloud Monitoring alert policies, which is enough to infer when it should be used. It does not explicitly state when to prefer alternatives or when not to use it, but the resource-specific language provides clear context among the sibling tools.
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?
Beyond the annotations, the description reveals important behavioral traits: it fans out across locations, skips empty or disabled recommenders, and auto-discovers locations via Asset Inventory when locations are omitted, including a dependency on the Cloud Asset API. These details materially help an agent predict execution 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 summary sentence fronts the core purpose, followed by a short behavior note and a compact Args section. Every sentence carries distinct information, and there is no filler or repetition of schema defaults.
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?
The description covers the main operational concerns: what is aggregated, how locations are handled, the Cloud Asset API requirement, the per-call limit, and environment selection. It does not describe the shape or pagination of the returned recommendations, but given the read-only and idempotent annotations plus the strong parameter detail, it is nearly complete.
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 description coverage is 0%, but the description fully compensates by explaining every parameter: locations as comma-separated zones/regions with auto-discovery behavior, limit_per_call as a per recommender+location cap, and environment as a configured GCP environment selector with a default behavior. This is exactly the semantic enrichment the schema lacks.
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 opens with a specific verb and resource: 'Aggregate GCP cost-optimization recommendations (idle/rightsizing/etc).' This clearly distinguishes the tool from the sibling list_recommendations by narrowing scope to cost-optimization, and the behavior is further clarified with the fan-out and skip semantics.
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 provides useful context about locations, auto-discovery, and environment selection, but it never explicitly states when to choose this tool over alternatives such as list_recommendations or get_cost_breakdown. Usage is implied by the purpose rather than explicitly contrasted with sibling tools.
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?
Annotations already mark this as read-only and idempotent, and the description adds substantial behavioral context beyond that: shared billing tables cause unfiltered queries to return identical account-wide totals, only the environment holding the export needs billing_export_table set, and other environments return an error naming the proper one. This explains real operational behavior rather than restating the schema.
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 front-loaded with the main purpose, then explains the critical billing-export caveat, then lists parameters. Every sentence adds necessary information; none is filler or redundant with the schema.
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?
For a five-parameter read-only tool with no output schema, this description covers everything needed to call it correctly: defaults, parameter semantics, configuration prerequisites, cross-environment behavior, and error handling. It also warns about the all_projects total being non-environment-specific, preventing a likely misuse.
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 description coverage is 0%, so the description carries the full burden, and it succeeds. It documents every parameter with meaningful details: group_by's allowed values, days' lookback basis, limit's ordering by highest net cost, all_projects' account-wide behavior and pairing advice, and environment's role and default.
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 opening sentence states a specific verb and resource: 'Summarize recent spend from the BigQuery billing export.' The description further clarifies scope by contrasting environment-project-only reporting with account-wide reporting, distinguishing this tool from nearby billing and recommendation siblings.
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 provides clear context for when to use the tool and how to behave in common configurations: by default it reports only the selected environment's project, all_projects switches to account-wide totals, and non-exporting environments error with the name of the exporting one. It does not explicitly name sibling tools as alternatives, so it stops short of a 5.
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?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context beyond annotations: the server's queryable environment set, the notion of a default, and acceptance of shorthands or bare project IDs.
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 three sentences with no filler. The primary purpose is front-loaded, and the usage details follow in a logical order. Every sentence earns its place.
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 the lack of an output schema, the description tells the agent exactly what will be returned (environment names and the default) and how to consume those values. Nothing necessary for correct use is missing.
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?
This tool has zero parameters, so there is nothing for the schema to document. The description goes further by explaining the semantics of the `environment` argument used in sibling tools, which is the real value the agent needs.
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 uses a specific verb and resource: 'List the GCP environments this server can query and which is the default.' This clearly differentiates the tool from sibling query/list tools by framing it as the environment-discovery entry point.
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?
The description explicitly tells the agent how and when to use the output: pass returned names as the `environment` argument of any other tool, and omit the argument to use the default. It also documents accepted shorthands, leaving no ambiguity about invocation behavior.
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?
Annotations already mark this as read-only, idempotent, and non-destructive, and the description adds valuable behavioral context beyond that: limit defaults and context cost, why include_labels is off, and how environment selection behaves. This helps an agent make informed invocation decisions.
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 front-loaded with the core purpose and then uses a compact args list where every line earns its place. No filler or redundant restatement of the schema exists.
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?
For a tool with five optional parameters and no output schema, the description covers all invocation-relevant aspects: filter syntax, defaults, context-cost trade-offs, and environment handling. It gives enough information for an agent to select and call the tool correctly without additional lookup.
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 description coverage is 0%, and the description compensates fully by explaining every parameter with concrete examples, defaults, and rationale. It adds meaning far beyond the bare schema properties, especially around limit and include_labels.
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 first sentence states a specific verb ('Search'), a clear resource scope ('all cloud resources'), and the mechanism ('Cloud Asset Inventory'), which immediately distinguishes it from sibling list_* tools that target specific GCP resources. It is unambiguous and not a tautology.
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 clearly communicates when to use the tool: for broad searches across all cloud resources, with optional filtering by asset type and query. It does not explicitly contrast with sibling tools or state when not to use it, but the scope and parameter guidance imply the appropriate context, and it directs users to list_environments for environment setup.
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:

[![platform-mcp MCP server](https://glama.ai/mcp/servers/deBilla/platform-mcp/badges/card.svg)](https://glama.ai/mcp/servers/deBilla/platform-mcp)

Score Badge

Copy to your README.md:

[![platform-mcp MCP server](https://glama.ai/mcp/servers/deBilla/platform-mcp/badges/score.svg)](https://glama.ai/mcp/servers/deBilla/platform-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/deBilla/platform-mcp'

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