VGCHelper

by ychen022

Overview Schema Related Servers Score Discussions

TypeScript

Local

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation5/5
Each tool targets a distinct resource or action: status, meta refresh/query, replay analysis/retrieval/turn inspection/trends, team evaluation/detail, and damage calculation. There is no meaningful overlap among the tools even though several operate on replays or evaluations.
Naming Consistency3/5
All tools share the vgc_ prefix and use lowercase snake_case, but the verb/noun ordering is inconsistent: refresh_meta and meta_query flip the pattern, while replay_analyze, replay_get, team_evaluate, and damage_calculate place the object before the verb. The names remain readable, but the convention is not uniform.
Tool Count5/5
With 10 tools, the server is well-scoped for a VGC helper covering metagame data, replay coaching, team evaluation, and damage calculation. Each tool addresses a meaningful part of the workflow without unnecessary redundancy.
Completeness4/5
The tool surface covers the main lifecycle needs: refreshing and querying meta data, analyzing and retrieving replay coaching details, aggregating trends, evaluating teams, and calculating damage. Minor gaps exist, such as no listing or deletion of persisted replay reports/evaluations, but these are workable and do not break core workflows.
Average 3.5/5 across 10 of 10 tools scored.
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
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
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?
The readOnlyHint annotation already establishes the read-only safety profile, and the description doesn't contradict it. It adds context by saying the data is bounded and persisted, which distinguishes this from live evaluation or replay-based data, but it doesn't describe pagination/offset behavior or any other operational details.
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?
One short, front-loaded sentence with no redundant filler. It earns its keep by stating verb, resource, and provenance in a compact form.
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 the output schema and read-only annotation covering return and safety aspects, the tool has nine parameters with no param-level descriptions and no usage guidance. An agent would still need to infer which identifiers/options to supply and what 'bounded' means in practice.
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%, so the description needed to compensate for nine undocumented parameters, but it only loosely hints at them with 'lead-state' and 'bounded'. Analysis_id, user_lead, opponent_lead, offsets, and limit are never explained or mapped to the retrieval 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 uses a specific verb ('Retrieve') and identifies the resource ('bounded lead-state details') and source ('persisted team evaluation'), so an agent can tell this is a read-style lookup rather than an analyze/evaluate operation. It is not fully explicit about what 'bounded lead-state details' means, and it doesn't name a sibling alternative, 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?
No guidance is given about when to use this tool instead of siblings like vgc_team_evaluate, vgc_replay_get, or vgc_meta_query. A mention that this is for inspecting previously persisted evaluations would have been useful, but the description leaves the routing decision to inference.
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 description discloses meaningful behavior beyond the annotations: it parses and persists the replay, and returns turn-cited coaching evidence. However, it does not clarify what persistence means, whether existing data is overwritten, or what prerequisites exist, and the annotations only cover destructiveHint, so coverage is limited.
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?
One focused sentence with no filler. The action verbs are front-loaded, and the sentence earns its place by conveying the core parse-persist-return flow efficiently.
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 having an output schema, the description leaves significant gaps: five parameters are essentially undocumented, no sibling-routing guidance exists, and the persistence side effect is vague. This is too thin for a tool with zero schema parameter descriptions and many near-neighbor siblings.
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%, so the description must compensate. It only maps 'exact user team' to team_export and 'replay' generically to a replay source; profile_id, player_name, replay_path, and replay_content are left entirely unexplained.
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 specific verbs — 'Parse and persist' and 'return turn-cited coaching evidence' — tied to a clear resource: a Champions VGC doubles replay with the user's exact team. It implies a distinguishably analytical purpose versus siblings like vgc_replay_get or vgc_replay_turn, though it does not explicitly name an alternative.
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 explicit when-to-use or when-not-to-use guidance is provided. The phrase 'using the supplied exact user team' hints that this tool requires a team export for coaching analysis, but it does not contrast with siblings such as vgc_team_evaluate, vgc_replay_trends, or vgc_matchup_detail, leaving selection to inference.
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 only declare destructiveHint=false, leaving the description to carry the behavioral burden. It adds genuinely useful disclosure: scores are 'pressure heuristics' (so the agent should not treat them as exact win probabilities) and comparisons run on 'identical sources and conditions' (controlling for confounding variables). It could go further — e.g., whether profile_id is needed, whether evaluation_context is required for meaningful results — but it adds real context beyond the single annotation.
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?
Two sentences and roughly 30 words, with the primary function front-loaded and the comparison option and heuristic caveat placed second. There is no wasted text, but the density of unexplained jargon means each sentence does not earn its place in clarity as well as it could.
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?
This is a complex tool — 4 parameters, nested evaluation_context object with modes/roles/priorityThreats, zero schema description coverage, and only destructiveHint in annotations — yet it gets just two sentences. The description never explains what team_export should contain (e.g., Pokemon Showdown format), what profile_id is for, or how modes with bringFour/lead/mega/targets are structured. The output schema mitigates the return-value side, but input construction is critically under-specified.
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?
With schema description coverage at 0%, the description must compensate by mapping to parameters, and it does so only obliquely: 'Mega alternatives' hints at modes[].mega, 'threat-aware cohort' hints at priorityThreats, and 'compare an edited team' maps to comparison_team_export. The required team_export, profile_id, and the roles object are never mentioned, so the agent gets no help constructing the most important input or the evaluation_context structure.
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 clear verb+resource: the tool evaluates a VGC team, specifically 'legal Mega alternatives' and 'fixed matchup modes', and adds an optional comparison mode. It is distinguishable from sibling tools (none of which evaluate teams — they analyze replays, query meta, calculate damage). However, the heavy jargon ('legal Mega alternatives', 'fixed matchup modes', 'threat-aware cohort') is never unpacked, so an agent without VGC domain knowledge gets only a fuzzy picture of what actually happens.
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 second sentence gives one concrete usage scenario — comparing an edited team on 'identical sources and conditions' — which implies the tool's role as a controlled evaluator rather than an open-ended analyzer. But there is no explicit routing among the nine siblings: no 'use this instead of vgc_matchup_detail when...' or 'not for replay-level analysis' type 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=true, so the description does not need to restate safety. The 'locally persisted' wording adds useful context that the tool reads stored analyses rather than triggering new replay processing, but it says nothing about freshness, computation, or how results are derived.
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 a single efficient sentence with the core operation front-loaded and no filler. It is concise, though the brevity contributes to the lack of parameter and usage detail handled in other dimensions.
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?
The core purpose and data source are clear, and the output schema presumably covers return shape, but three optional parameters are completely undocumented and no usage guidance is offered. For a tool with a bare schema, this leaves important operational context missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, yet the description gives no explanation of limit, profile_id, or team_version. An agent cannot tell whether profile_id and team_version scope the aggregation, how limit affects the output, or which parameters are relevant to a given request.
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, 'aggregate', and clearly names the resource: recurring strengths, improvement findings, and results across locally persisted replay analyses. This distinguishes it from single-replay tools like vgc_replay_analyze and vgc_replay_get.
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 phrase 'across locally persisted replay analyses' implies this is for summarizing existing stored analyses rather than analyzing a single replay. However, there is no explicit statement about when to use this tool over alternatives like vgc_replay_get or vgc_replay_turn, and no exclusions are provided.
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?
Beyond the idempotentHint and destructiveHint annotations, the description discloses non-obvious behavior: validation, caching, and atomic activation. This gives an agent a realistic model of the refresh process without contradicting the annotations.
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?
A single dense sentence with no filler; the operation stages are front-loaded and readable. It earns its place, though it is not broken into usage or parameter guidance.
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 annotations and an output schema covering safety and return shape, the description omits parameter roles and gives no usage condition. For a tool with four optional flags and a dry-run mode, this is a notable completeness gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description does not explain any of the four parameters. The agent cannot tell from the description what force, dry_run, profile_id, or relevant_pokemon control, so the definition fails to compensate for the bare 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 states a precise operation chain — fetch, validate, cache, and atomically activate — over a concrete resource (VGC Pastes teams and Champions Battle Data usage) scoped to the active regulation. This clearly distinguishes the tool from query-focused siblings like vgc_meta_query.
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?
Use is implied: this is the refresh/update counterpart to metagame query tools, and it is scoped to the active regulation. However, there is no explicit statement of when to call it, when not to, or which sibling alternatives exist.
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 readOnlyHint annotation already discloses that this is a safe read operation. The description adds the meaningful trait 'auditable' and specifies the doubles format, but it does not explain what auditable means in practice, such as whether a calculation trace is returned or how modifiers are applied. 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?
Single sentence, front-loaded verb, no filler. Every phrase adds distinguishing context: auditable, generation-zero, Pokemon Champions, doubles, damage calculation, Showdown-format set.
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?
The tool has 15 parameters, nested position objects, and zero schema-based parameter descriptions, yet the description provides only input format and mode. It does not explain the effect of the many optional modifiers, what 'auditable' entails, or what the output contains. Too sparse given the tool's complexity.
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%, so the description carries the burden of explaining 15 parameters. It usefully identifies 'two Showdown-format sets', mapping to attacker_set and defender_set, but it does not clarify move, terrain, weather, reflect, position objects, or the many boolean modifiers. This leaves substantial ambiguity.
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 ('Run') and resource ('damage calculation'), and narrows scope with 'generation-zero Pokemon Champions doubles' and 'two Showdown-format sets'. This clearly distinguishes it from the sibling replay, meta, and team-evaluation tools.
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 phrase 'from two Showdown-format sets' implies the intended input and use case, but the description gives no explicit when-to-use guidance or exclusions. It does not name alternatives or explain when a damage calc is preferable to team evaluation or matchup analysis.
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?
The readOnlyHint annotation already covers the safety profile. The description adds meaningful behavioral context by warning that afterEvents contains later revelations, which is critical for correct interpretation and could prevent incorrect reasoning. This goes beyond what annotations provide.
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 two sentences with no wasted words. It front-loads the core retrieval purpose and then supplies a critical usage warning. Every sentence contributes necessary 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?
Given the tool has only two required parameters, an output schema, and a readOnlyHint annotation, the description is mostly complete. It explains what is retrieved and warns about a subtle data interpretation issue. It could be slightly stronger by explicitly interpreting analysis_id and turn, but it is adequate for a tool of this simplicity.
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%, and the description does not explain analysis_id or turn beyond the general phrase 'a turn.' The parameter names are somewhat self-explanatory, but the description fails to compensate for the absence of schema-level parameter documentation, especially for analysis_id.
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 retrieves stored state before and after a turn plus battle events, which specifies the verb and resource. It does not explicitly differentiate from siblings like vgc_replay_get, but the turn-scoped resource is implied by the name and description.
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 includes practical guidance: 'Judge decisions using beforeEvents only; afterEvents contains later revelations.' However, it does not state when to use this tool versus alternatives such as vgc_replay_get or vgc_replay_analyze, so usage context is mostly implied rather than explicit.
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?
The readOnlyHint annotation already establishes safety, and the description adds meaningful behavioral context: data is cached, includes source dates, and is regulation-verified. The caveat 'Unverified usage is contextual only' is a valuable transparency signal beyond the annotation.
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 deliver the core purpose, scoping, and an important caveat without any filler. The main action is front-loaded and every clause earns its place.
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 read-only query tool with an output schema, the description covers the essence. The main gaps are undocumented parameters and the absence of explicit guidance about refreshing cached data, so it is adequate but not fully complete.
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%, so the description must compensate for parameter meaning. It hints that 'pokemon' is the core entity via 'per-Pokemon usage,' but it does not explain 'limit' or 'profile_id' at all, leaving agents to guess their roles.
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 action ('Query') and a distinct resource ('cached team sets and per-Pokemon usage') with additional detail about source dates and regulation verification. This clearly separates it from the replay, team evaluation, and damage calculation 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 clearly frames this as a read-only cached evidence lookup, which implies when it should be used. However, it does not explicitly say when to prefer vgc_refresh_meta or vgc_status, so there is no explicit alternative routing.
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 provide readOnlyHint=true, establishing that this is a safe read operation. The description adds the 'persisted' qualifier, which signals that no new analysis computation occurs—just retrieval. It does not cover error cases, rate limits, or prerequisites, but for a simple get-by-ID operation these are minor 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?
One tight sentence that front-loads the action and object, with no filler or repetition. Every word earns its place, and the qualifier 'persisted' is useful context rather than noise.
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 tool with one required parameter, an output schema, and a readOnly annotation, the description is sufficient to invoke correctly. It lacks an explicit pointer to sibling tools for creating analyses or obtaining an analysis_id, but the low complexity and output schema cover most contextual needs.
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's 'by analysis ID' is the only semantic explanation of analysis_id. It clearly ties the parameter to the retrieval key. It does not mention where the ID comes from (e.g., from vgc_replay_analyze), but the single required string parameter is adequately explained.
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?
States a specific verb ('Retrieve'), a specific resource ('persisted replay coaching report'), and the selection key ('analysis ID'). This clearly distinguishes it from siblings like vgc_replay_analyze, which would create a new analysis rather than fetch an existing one.
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 through the words 'persisted' and 'prior,' suggesting this tool fetches existing reports rather than creating them. However, it never explicitly names alternatives or states when to use this tool versus vgc_replay_analyze, vgc_replay_turn, or vgc_replay_trends.
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 readOnlyHint annotation matches the read-only 'Show' behavior. The description adds the specific status categories, but not extra behavioral details such as network checks or caching. This is acceptable because the output schema and read-only annotation cover the main expectations.
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?
A single, front-loaded sentence names the action and the exact returned information with no filler. Every word 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?
For a parameterless, read-only status tool with an output schema, this description is complete. It states the key status dimensions and requires no additional context to invoke safely.
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 tool has zero parameters, so there is no semantic burden on the description. Baseline 4 applies because there are no parameter details an agent could need.
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 the verb 'Show' and enumerates exactly what status info is returned (active regulation, calculator version, local database, metagame source freshness). This clearly distinguishes it from replay/calculation/refresh sibling tools.
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 status-oriented wording implies it is used to inspect current state, but there is no explicit guidance about when to prefer it over siblings. The description does not mention alternatives or when-not-to-use conditions.
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

VGCHelper MCP server — quality and maintenance score on Glama

Copy to your README.md:

[![VGCHelper MCP server — quality and maintenance score on Glama](https://glama.ai/mcp/servers/ychen022/VGCHelper/badges/card.svg)](https://glama.ai/mcp/servers/ychen022/VGCHelper)

Score Badge

Copy to your README.md:

[![VGCHelper MCP server — quality and maintenance score on Glama](https://glama.ai/mcp/servers/ychen022/VGCHelper/badges/score.svg)](https://glama.ai/mcp/servers/ychen022/VGCHelper)

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/ychen022/VGCHelper'

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