kenpom-mcp

Server Quality Checklist

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

Latest release: v0.2.0
Disambiguation4/5
Most tools target a distinct resource (ratings, efficiency, four factors, player stats, arenas, schedule, etc.). However, several team-level stat tools (get_ratings, get_efficiency, get_four_factors, get_team_stats, get_scouting_report) overlap in content, though descriptions clarify their specific focuses.
Naming Consistency5/5
All tool names follow a consistent 'get_<noun>' pattern in snake_case, making them highly predictable. Examples include get_ratings, get_schedule, get_scouting_report, and get_conference_standings.
Tool Count4/5
With 18 tools, the server is comprehensive but slightly heavy for a niche stats domain. The count is justifiable given the breadth of KenPom data, but it edges into the upper range of ideal scope.
Completeness4/5
The surface covers a wide range of college basketball analytics: ratings, efficiency, player stats, schedule, conference stats, and more. Minor gaps exist (e.g., no direct box score or team roster details beyond height), but core use cases are well covered.
Average 4.2/5 across 18 of 18 tools scored. Lowest: 3.4/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 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 failing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
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

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden for behavioral disclosure. It only states the return type (JSON array) and the general content, but does not mention data source, time range, potential side effects, or any rate limits. For a read operation this might be tolerable, but the description omits important context about what 'home court advantage' entails statistically.
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 short and front-loaded with the main purpose. However, the last line 'Returns: JSON array of home court advantage data' is redundant with the previous sentence, which diminishes conciseness slightly. Still, it avoids fluff and is easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that there is an output schema (though not shown) and no parameters, the description is minimally viable. It clearly states the tool returns data for all teams. However, it lacks detail on what specific statistics are included or any seasonal context, which limits completeness for an agent trying to understand the result's nature.
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?
There are zero parameters, so the baseline is 4. The description adds semantic context about the data ('historical... for all teams'), which is useful beyond the empty schema. No parameter explanation is needed.
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 specific verb 'Get' with the resource 'home court advantage data', and further clarifies 'historical home court advantage statistics for all teams', which distinguishes it from sibling tools like get_team_stats or get_efficiency. It is unambiguous about what the tool returns and its scope.
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 guidance on when to use this tool versus alternatives, no mention of prerequisites or exclusions. The description simply states what it does without any contextual direction or comparison to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It does disclose the offense/defense toggle, season default, earliest available year, and JSON array return type. But it omits potential caveats like data freshness, error behavior, or whether any filtering applies, which are relevant for a stats-retrieval tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with Args and Returns sections, making it easy to parse. Each line provides useful information, though there is minor redundancy in mentioning 'Returns detailed team stats' and then a separate Returns block.
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 presence of an output schema, the description need not enumerate return fields. It covers all parameters and their semantics, plus the defensive/offensive selection. It could add edge cases like invalid season values, but overall it is sufficient for correct invocation.
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 has zero description coverage, so the description entirely compensates. It clearly explains the 'defense' boolean behavior and the 'season' parameter including format, default, and minimum year. This is exemplary parameter documentation.
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 verb 'Get' and resource 'team statistics', and gives examples of metrics (shooting percentages, blocks, steals, assists). However, the word 'miscellaneous' makes it sound like a catch-all, and it does not explicitly differentiate from sibling tools like get_conference_offense or get_player_stats beyond the 'team' scope.
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 provided on when to use this tool versus the many sibling tools. It does not mention alternatives or exclusions, leaving the agent to infer usage solely from the tool name and description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of behavioral disclosure. It does add context by clarifying that results are 'all-time' and 'across all available seasons,' implying aggregation across the full dataset. However, it does not explicitly state whether the operation is read-only, if authentication is needed, or any potential side effects or limitations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, front-loaded with the primary purpose, and uses two short sentences plus a 'Returns' label. Every sentence adds value without redundancy or filler. It is well-structured for quick scanning by an AI agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (zero parameters) and the presence of an output schema, the description provides sufficient context. It states the return type ('JSON array of program ratings') and the scope ('all-time... across all available seasons'). It could have clarified what constitutes a 'program rating,' but for a zero-parameter tool with an output schema, this is adequate.
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, and the schema coverage is 100% (empty schema). Per calibration, a zero-parameter tool receives a baseline of 4. The description adds no parameter-specific details because none exist, and the schema already fully covers the parameter surface.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('Get') and resource ('historical program ratings'), and elaborates with 'Returns the all-time program rankings based on historical performance across all available seasons.' This distinguishes it from sibling tools like 'get_ratings' by specifying the program-level scope.
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 use this tool versus alternatives. It does not mention any exclusions, prerequisites, or situations where another tool (e.g., get_ratings) would be more appropriate. It is purely descriptive with no usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of disclosing behavior. It states the return format (JSON array) and listed stats, but does not mention potential side effects, rate limits, authorization, or data source nuances. It is adequate for a simple retrieval tool but lacks depth.
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 well-organized with clear Args and Returns sections. It is succinct, with every sentence contributing useful information, and avoids reduncancy with the schema.
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 moderate complexity (2 params, one required) and presence of an output schema, the description gives enough context for correct invocation. It could mention error behavior or data source caveats, but for a straightforward stats lookup it is sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, yet the description compensates by explaining both parameters: conference with concrete examples ('B12', 'SEC') and season as optional with a default. This adds meaning beyond the bare schema and helps the agent construct valid calls.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves conference offensive stats for all teams in a conference, using a specific verb ('Get') and resource ('conference offensive stats'). It lists the specific metrics returned, which distinguishes it from siblings like get_conference_defense.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for conference-level offensive analysis but does not explicitly mention alternatives or when not to use it. It provides context (all teams, conference code examples) but lacks direct guidance on tool selection versus 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?
With no annotations, the description carries the burden. It discloses the return format (JSON array) and lists the specific data fields, which is useful. However, it does not mention any side effects, rate limits, or data update behavior, though the tool is inherently read-only.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured, with a clear opening sentence, a field list, and a straightforward Args/Returns layout. Every sentence contributes essential 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 tool with one optional parameter and an output schema present (per context signals), the description is complete. It covers the purpose, parameter semantics, return type, and data fields, leaving no significant gaps for an agent to understand correct usage.
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 single parameter 'season' is thoroughly explained in the description: optional, format example ('2024'), default behavior (current season), and earliest available year (1999). The schema only lists type/default, so the description adds significant value beyond it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get Pomeroy College Basketball Ratings for all teams' with a specific verb and resource. It distinguishes itself from sibling tools by focusing on overall team ratings and explicitly listing the returned fields (rank, team, conference, record, efficiency metrics).
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 does not provide explicit guidance on when to use this tool versus alternatives like get_efficiency or get_team_stats. It implies a broad overview use case but lacks any 'use this instead of...' or edge-case recommendations.
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 the return format (JSON array), defaults for metric and season, and the earliest available season (2004). However, it does not clarify sort order (ascending/descending) or player qualification thresholds, which are important for a leaderboard tool. With no annotations, these gaps are notable.
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 uses a compact docstring format with a clear purpose sentence, then Args/Returns sections. The metric list is lengthy but necessary; 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.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers purpose, all parameters, return type, and an important constraint (earliest season). An output schema exists, so return details need not be fully spelled out. Minor omissions like qualification criteria and sort direction prevent a perfect score.
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 zero description coverage, so this description carries the full burden. It enumerates all metric options, defines season default and earliest year, and gives conference examples – adding substantial meaning beyond the raw type/default fields in the 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 opens with 'Get player leaders by statistical metric,' which is a specific verb+resource statement. It clearly differentiates this tool from sibling tools like get_team_stats or get_ratings by focusing on player leaderboards rather than team-level metrics.
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?
No explicit guidance is given for when to use this tool versus alternatives like get_efficiency or get_ratings. The description implies usage through the metric list but does not mention exclusions or alternative tools for similar stats.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the exact statistics returned, the return format (JSON array), and the default season behavior. It implies a read-only operation via 'Get' and adds context beyond a simple call, though it does not explicitly state side effects or prerequisites.
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 well-structured with Args and Returns sections, front-loaded with the main purpose. The list of statistics is necessary and not wasteful. It is slightly longer than minimal but each sentence adds value.
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 simplicity of the tool (2 params, 1 required) and the descriptive output, the description covers purpose, parameters, return format, and the specific metrics. It lacks details about error conditions or data source caveats, but these are not critical for a straightforward read endpoint.
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. It provides conference code examples ('B12', 'SEC'), marks conference as required, and explains that season defaults to the current season. This is far richer than 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 clearly states the verb (Get), resource (conference defensive stats), and scope (all teams in a conference). It naturally distinguishes itself from the sibling tool get_conference_offense by explicitly mentioning 'defensive' stats.
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 clear context for when to use the tool (for conference-level defensive stats), but it does not explicitly mention alternatives or exclusions. An agent could infer that offensive stats belong to get_conference_offense, but the description does not state this, leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description adds that the response is a JSON array possibly containing multiple tables and that Game MVP data starts from 2013, which are useful behavioral traits beyond what the name suggests. It doesn't address auth or rate limits, but for a read-oriented stats tool, the provided context is reasonable.
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 brief and front-loaded with the purpose, followed by return type and parameter semantics. Every sentence contributes essential 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?
The tool is simple with one optional parameter; the description covers purpose, return format, and parameter behavior, sufficient for selection and invocation. The existing output schema further reduces the need for detailed return explanations.
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 only lists 'season' with no description, but the description fully explains the format ('2024'), default current season, earliest year 2011, and MVP table restriction, completely compensating for zero schema coverage.
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 ('Get KenPom Player of the Year standings') and clarifies it returns both KPOY leaderboard and Game MVP leaders, which clearly distinguishes it from sibling stats 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?
No explicit alternatives or when-not-to-use instructions are provided, but the description implies this tool is for KPOY data. The parameter notes on season defaults and earliest availability offer some usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of behavioral transparency. It discloses that the tool returns a JSON array of scheduled/completed games, indicating that it handles both future and past games. It also reveals the scope of the data (full schedule) but doesn't discuss potential errors or edge cases, which is acceptable for a simple read-only operation.
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 well-structured with an intro, Args section, and Returns section. It's concise and every sentence adds value. A slight redundancy exists between the first sentence and the first Returns sentence, but overall it's efficient and readable.
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 provides enough context for an agent to understand the tool's purpose, parameters, and return format. It includes important details about the season range and examples, but doesn't mention any alternative tools or potential limitations (e.g., what happens if the team has no games). Given the presence of an output schema, the description sufficiently covers the key aspects.
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 has zero description coverage, but the description fully compensates. It explains 'team' is required, provides examples ('BYU', 'Duke', 'North Carolina'), and clarifies that 'season' is optional, defaults to current season, and earliest available is 1999. This adds significant meaning beyond the raw schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get') and resource ('a team's game schedule and results'), clearly distinguishing itself from sibling tools like get_ratings or get_team_stats. It also lists the specific data returned (dates, opponents, results, rankings, locations, records), making the tool's purpose unmistakable.
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 (when you need a team's schedule or results) but does not explicitly mention alternatives or exclusions. There is no direct comparison to sibling tools, so guidance is only 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.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the disclosure burden. It does mention the return object and the default date behavior, which is useful. However, it does not explicitly state that the operation is read-only or describe any side effects or error conditions. For a simple data retrieval tool, this is a moderate gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured, starting with a one-sentence purpose, then an explanatory line, and then a clean Args/Returns section. Every sentence adds value, and the parameter documentation is placed efficiently in the Args section.
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 tool is simple with one optional parameter, and the description covers purpose, parameter, and return value. Given that an output schema exists (indicated by context signals), the description does not need to detail the return structure further. A brief note about potential error cases (e.g., no games on the date) would have made it fully complete, but it is otherwise sufficient.
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 has zero coverage, but the description fully compensates by specifying the 'date' parameter format ('YYYY-MM-DD'), giving an example, and explaining the default value ('today's date'). This completely resolves any ambiguity about parameter usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the function retrieves FanMatch game predictions for a specific date, including scores, spreads, and game information. It explicitly distinguishes itself from sibling tools by focusing on FanMatch predictions and all games for a date, making it specific and unambiguous.
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: when you need FanMatch predictions for a given date. It also notes that the date defaults to today, which is practical. However, it does not explicitly mention alternatives or when not to use it, but the clarity of the domain makes the intended usage obvious.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It reveals important traits: the season parameter defaults to the current season, earliest available data is 2007, and continuity data starts from 2008. It also indicates the return format as a JSON array, providing useful context beyond just the tool's name.
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 well-structured and front-loaded with the core purpose in the first sentence. It avoids redundancy by using concise sections for Args and Returns, and every sentence contributes to understanding the tool. No filler or unnecessary detail is present.
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 optional parameter and an existing output schema, the description is largely complete. It explains the parameter's behavior, default, and data availability, and gives a high-level return type. It could be slightly more comprehensive by explaining what 'continuity metrics' entails, but the output schema likely covers that.
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 only specifies 'season' as a nullable string with a null default, providing no meaning. The description compensates fully by explaining the parameter's format ('e.g., "2024"'), default behavior, and historical data boundaries. This adds significant semantic value beyond the 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 clearly states the tool's function with a specific verb ('Get') and resource ('height and experience data for all teams'). It distinguishes from sibling tools by enumerating unique metrics like average height, experience, bench minutes, and continuity metrics, making its purpose unambiguous.
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 context by detailing what data is returned, but it does not explicitly state when to use this tool over alternatives or provide exclusions. The sibling list offers context, yet no direct comparison is made, leaving usage guidance to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It explains key behavior: returns arena data for a season, defaults to current season, earliest available is 2010, and outputs a JSON array. It does not mention potential rate limits or authorization, but for a simple read-only data retrieval tool, this is adequate.
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-organized, with an initial summary sentence followed by 'Args' and 'Returns' sections. Every sentence adds value, and 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 tool with one optional parameter and a simple array return, the description covers all necessary aspects: purpose, parameter details, constraints (earliest year), and return format. The output schema further clarifies the structure, so no critical information 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 single 'season' parameter is thoroughly described with a format example, default behavior, and minimum year, far exceeding the schema which only says 'anyOf string/null'. This gives the agent complete guidance on how to specify the parameter correctly.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as retrieving arena information for all teams and lists specific data types (arena names, capacities, attendance). This distinguishes it from sibling tools like get_ratings or get_team_stats, which focus on other statistics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for arena-related queries but does not explicitly state when to use this tool versus alternatives. There are no exclusions or references to sibling tools, so the agent must infer the appropriate context from the tool name and first sentence.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It adds useful context about the four factors and the season parameter (earliest 1999, optional, default current) and return format (JSON array). However, it doesn't explicitly state side effects (e.g., read-only), error behavior, or data freshness, which are relevant for a stats API. Adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with a clear opening line, a bullet list of the Four Factors, and separate Args/Returns sections. Each sentence adds value, no fluff, and the front-loaded purpose makes it easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple one-parameter tool and the presence of an output schema, the description is complete. It covers what the tool returns, the only parameter, and the statistical meaning. It also notes the all-teams scope, which is a key limitation. No significant gaps.
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 has 0% description coverage for the season parameter, but the description fully compensates by explaining it is optional, defaults to the current season, accepts a string like '2024', and notes the earliest available year (1999). This adds significant meaning beyond the raw schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves 'Four Factors stats for all teams' and enumerates the specific stats (eFG%, TO%, OR%, FTRate), which distinguishes it from sibling stats tools like get_efficiency or get_team_stats. The verb 'Get' and resource are explicit, leaving no ambiguity.
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: it's for team-level four factors across all teams, no filtering. While it doesn't explicitly mention alternatives or exclusions, the scope ('all teams') and the listing of stats imply its use case. It doesn't say when not to use it, but the context is sufficient for a simple lookup tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It does well by specifying that it returns a JSON array of point distribution data for all teams, and details the season parameter's default and earliest available year. This adds useful context about output and parameter behavior beyond 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 compact, well-structured with clear 'Args' and 'Returns' sections, and contains no fluff. Every sentence earns its place, making it appropriately sized for a tool with one optional parameter.
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 tool with one optional parameter and an existing output schema, the description covers the purpose, parameter behavior, and output type sufficiently. It is self-contained and gives an agent all necessary information to decide when and how to use it.
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 only the parameter name/type with no description (0% coverage). The description fully compensates by explaining the season parameter's format ('2024'), default to current season, and valid range (earliest 1999), which is essential for correct invocation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: retrieving team point distribution breakdown, specifying how teams score (2-pointers, 3-pointers, free throws) and where points allowed come from. This is a specific verb+resource that distinguishes it from sibling tools like get_efficiency or get_four_factors, which focus on other metrics.
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 explains what the tool does but does not explicitly state when to use it relative to sibling tools. It implies usage for point distribution queries, but lacks direct references to alternatives or exclusions, leaving the agent to infer selection from the tool name and description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It explains the return format (JSON mapping names to {value, rank} objects) and parameter behavior (season default, conference_only flag). It doesn't discuss errors or rate limits, but for a read-only data getter, this is sufficient.
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 well-organized with a summary line, a clear Args section, and a Returns section. It is concise, with every sentence serving a purpose, and the most important information is front-loaded.
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?
The description is complete for a tool of this complexity: purpose, parameters, and return format are all covered thoroughly. An output schema exists, but the description reinforces it with additional detail, making it self-sufficient.
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 has 0% description coverage, but the description fully compensates by explaining each parameter with examples, defaults, and conditional behavior. Team examples ('BYU', 'Duke'), season default, and conference_only semantics are explicitly detailed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool gets a detailed scouting report for a team with 37 stats and ranks, covering offensive and defensive categories. This distinguishes it from more specific sibling tools like get_four_factors or get_efficiency by offering a comprehensive, all-in-one report.
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 when a broad overview of team stats is needed, but it never explicitly mentions alternatives or when to prefer this over the more specialized sibling tools. No when-not-to-use guidance is 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?
With no annotations, the description carries the full burden. It transparently lists the returned fields (overall/conference records, projected records, net rating, offensive/defensive ratings, tempo, SOS) and states the return type as 'JSON array of conference standings.' It does not explicitly mention read-only behavior, but 'get' implies it; no side-effect warnings are needed for a read-only tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and well-structured, with a clear Args section and Returns section. Every sentence provides value, and the purpose is front-loaded. No filler or 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?
Given the tool's simplicity (2 params, 1 required) and the presence of an output schema, the description fully covers the necessary usage context, argument semantics, and return type. An agent can confidently select and invoke this tool based on the description alone.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate. It provides conference code examples (B12, SEC, B10, ACC, BE), clarifies that conference is required, and explains season is optional with a default of the current season. This adds significant meaning beyond 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 clearly states 'Get conference standings' and specifies the resource ('conference standings') along with the data categories (team records, ratings). This distinguishes it from sibling tools like get_conference_offense/defense, which focus on specific stats rather than overall standings.
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: use this tool when you need conference standings with records and ratings. It does not explicitly mention alternatives or exclusions, but the distinct return fields imply its specific place among the sibling tools. Clear context with no explicit exclusions earns a 4.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It explains that the season parameter is optional, defaults to the current season, and notes data availability limitations (earliest 1999, possession length from 2010). This adds useful context beyond the schema, though it doesn't mention side effects or error behavior, which are less relevant for a read-only stats query.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, opening with a clear summary then providing parameter details and return type. Every sentence adds value with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one optional, well-documented parameter) and the presence of an output schema, the description adequately covers the purpose, parameter semantics, and data availability. It is complete enough for an agent to select and invoke the tool correctly without additional information.
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 has zero property descriptions, but the description fully compensates by explaining the 'season' parameter: optional, defaults to current season, with earliest available year and separate availability for possession length. This gives complete semantic meaning for the only parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states 'Get efficiency and tempo stats for all teams' with a specific verb and resource, and further details offensive/defensive efficiency, tempo, and possession length. This distinguishes it from sibling tools like get_ratings and get_four_factors, which focus on different metrics.
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 that this tool is for retrieving efficiency and tempo data for all teams, making it easy to decide when to use it. It does not explicitly name alternative tools or exclusions, but the 'for all teams' scope is clear enough to avoid confusion with per-team or conference-specific tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses important behavioral constraints (metric availability, earliest season) and return type (JSON array). This is valuable, though it omits potential error cases or pagination, which is acceptable for a simple query tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a one-line purpose, then organized 'Args' and 'Returns' sections. It is concise, front-loaded, and 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 tool with two simple parameters and no nested objects, the description fully covers the necessary context: metric semantics, availability, and return format. An output schema exists but is not needed to understand the tool's 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?
The description adds substantial meaning beyond the schema: it explains the 'metric' options, default values, and temporal restrictions, and clarifies 'season' defaults and earliest year. The schema only provides titles and defaults, so this description is essential.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Get top games ranked by game attributes.' It uses a specific verb and resource, and the focus on 'game attributes' distinguishes it from sibling tools like get_ratings or get_efficiency.
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 usage context by detailing parameter options, defaults, and availability constraints (e.g., 'FanMatch', 'Upsets', 'Busts' only after 2010). It does not explicitly mention when to use this over siblings, but the attribute-focused nature makes the intended use clear.
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:

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

Score Badge

Copy to your README.md:

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

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