universal-db-mcp

Server Quality Checklist

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

Latest release: v5.0.2
Disambiguation4/5
Most tools have clearly distinct purposes, and the descriptions effectively separate the many execute_* variants and schema/profile tools. A few pairs (e.g., explain_query vs. explain_query_with_advice, get_schema vs. get_table_info) could be confused at a glance, but the descriptions provide enough boundary.
Naming Consistency5/5
The tool set consistently follows a snake_case verb_noun pattern throughout (execute_query, get_schema, list_templates, create_profile). Minor exceptions like audit_log are negligible; the naming convention is highly predictable.
Tool Count2/5
42 tools is well beyond the 25+ threshold for a coherent tool surface. While the universal DB scope explains some breadth, many tools (e.g., execute_query/script/file/batch/templace and multiple export/import variants) could be consolidated without losing functionality.
Completeness4/5
The tool surface covers core database operations, schema inspection, profile lifecycle, templates, PII config, import/export, backup, audit, and query planning. Minor gaps include no explicit transaction-control tool and no dedicated schema-modification operations beyond generic execute_query.
Average 3.4/5 across 42 of 42 tools scored. Lowest: 1.7/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 403 commits in the last 12 weeks
- Last stable release on August 20, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior1/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, but it provides none. 'Enable profile' does not explain side effects, persistence, whether a profile must already exist, or how this differs from setting an active profile.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short, but this is under-specification rather than effective conciseness. It contains no information beyond the tool name and fails to earn its place as a useful definition.
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 is simple with only one parameter, but the description is still incomplete. Without annotations or an output schema, an agent needs at least some explanation of what enabling does, when it applies, and what the expected result is. None of that is present.
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?
The schema has one required 'name' parameter with no description, and schema description coverage is 0%. The tool description does not mention the parameter or explain what name refers to, leaving the agent with no semantic guidance beyond the parameter key itself.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description is '启用 profile。', which directly translates to 'Enable profile.' This simply restates the tool name with no additional detail, making it a tautology. It does not clarify what enabling a profile entails or how it differs from sibling tools like use_profile or disable_profile.
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 about when to use this tool versus alternatives. With many profile-related siblings such as use_profile, create_profile, and disable_profile, the description offers no context to help an agent choose correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 implies a read-only operation via 'query', but does not mention pagination, filtering behavior, authorization requirements, or response format, leaving significant ambiguity.
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, clear, and fluff-free sentence. It is concise and readable, though its brevity sacrifices potentially valuable context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has six undocumented parameters, no annotations, and no output schema. A one-sentence description is grossly insufficient for an agent to invoke this tool correctly or interpret its results.
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 offers no explanation for any of the six parameters (actor, limit, since, until, severity, profileName). An agent cannot determine what values are valid or how they influence the audit log query.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the core function with a specific verb and resource: '查询审计日志' (query audit logs). This is clear and actionable, though it does not differentiate itself from siblings like get_query_history or get_metrics, and it largely restates the tool name.
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 on when to use this tool versus alternatives. The sibling list includes related query/history tools, but the description provides no selection criteria, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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. It only says 'Export DB to file' and does not disclose side effects such as whether outputPath is overwritten, whether tables filters the backup, whether schemaOnly affects behavior, or if this operation requires an active profile. The non-destructive nature of export is inferred but not stated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence with no wasted words, but it is under-specified for a tool with four parameters and many siblings. It is concise but not informative enough to fully earn its place.
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?
With four parameters, no annotations, no output schema, and a complex sibling set, the description is insufficient. It does not explain the required profileName, what tables does, or the output format. An agent cannot reliably invoke this tool correctly based on the current definition.
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 adds no meaning for any of the four parameters (tables, outputPath, schemaOnly, profileName). An agent gets no help understanding what values to provide or how the parameters interact.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('export') and resource ('DB') with a destination ('to file'). This conveys the core action and loosely distinguishes it from profile or table-specific exports like export_profiles and export_table_csv, though 'DB' could be more precise regarding 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 the many sibling export tools (export_profiles, export_table_csv, export_sql_file). No alternatives, no conditions, no prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 only says 'set' without explaining whether this overwrites existing rules, whether it affects currently active profiles, or what side effects might occur.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is only one short sentence with no redundancy, but it is under-specified rather than appropriately concise. It lacks necessary explanatory structure for a tool with nested rules and multiple strategies.
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?
Given there is no output schema and no annotations, the description should provide substantially more context. It omits the meaning of the strategy values, the relationship between profileName and rules, and the behavior of the operation on existing configurations.
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 adds no meaning for either parameter. The rules structure and strategy enum are only visible in the schema; the description does not help the agent understand what profileName or rules mean in practice.
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 ('设置' / set) and a clear resource ('PII 脱敏规则' / PII masking rules), which distinguishes it from siblings like get_pii_config. It does not elaborate on what the rules entail, but the core action is understandable.
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 call this tool versus alternatives, such as create_profile or use_profile, or whether the profile must already exist. The description gives no context about prerequisites or expected flow.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, and the description carries the full burden of behavioral disclosure. It only says 'disable profile' and gives no information about side effects, reversibility, prerequisites, or what happens to an active profile, so the agent cannot anticipate the operation's impact.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short and free of fluff, but it is under-specified rather than appropriately concise. It reads almost as a translation of the tool name and omits useful structural information such as parameter context and expected effects.
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?
With one required parameter, no annotations, no output schema, and many sibling profile tools, this description is too sparse to fully orient an agent. It does not explain the state change, how to re-enable a profile, or how disabling relates to deleting or disconnecting a profile.
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 mention the 'name' parameter at all. The parameter's purpose is inferable from context, but the description adds no clarification about what name refers to or whether the profile must exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear action ('禁用', disable) applied to a profile, which is a specific verb and resource. It is understandable on its own, though it does not explain how 'disable' differs from deleting or disconnecting a profile.
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 about when to use this tool instead of enable_profile, delete_profile, use_profile, or disconnect_profile. The agent is left to infer the appropriate context from the tool name and sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description must disclose side effects and state changes. It only restates the operation ('disconnect... connection') and does not say whether this affects the active profile, whether it is reversible, persists, or requires permissions. This is a meaningful gap for a mutation-like 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 one short sentence with no filler and the key action is front-loaded. It is concise, though it achieves conciseness by omitting context that other dimensions penalize.
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?
For a tool with no annotations and no output schema, the description is too sparse. An agent cannot tell what happens after disconnecting, how it interacts with get_active_profile/use_profile, or what errors can occur. More context is needed for safe invocation.
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 coverage is 0% and the description only adds that 'profile' is the target of the operation. It does not explain what name format is expected, whether it is a profile identifier or display name, or any constraints beyond type string.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear action ('断开...连接' / disconnect the connection) and names the resource ('specified profile'). It is not vague, but it does not distinguish itself from siblings like use_profile, disable_profile, or get_active_profile.
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 information about when to call this tool or when to prefer an alternative is provided. With siblings like use_profile, enable_profile, disable_profile, and get_active_profile, the description gives no guidance on how disconnect_profile fits into the workflow.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden of behavioral disclosure. It only restates the core action and formats, without revealing whether the export includes secrets, whether it is read-only, what the output destination is, or any side effects.
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 concise sentence with no filler, and the core action and formats are front-loaded. However, it is so brief that it sacrifices useful detail; the conciseness is good but not exemplary.
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?
With no annotations, no output schema, and 0% schema description coverage, the description leaves important gaps: the meaning of includeSecrets, the scope of exported profiles, and output behavior are all unspecified. The tool is simple, but the definition is not complete enough for reliable tool selection and invocation.
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 mentions only the YAML/JSON formats, loosely mapping to the 'format' parameter. The 'includeSecrets' parameter is completely unexplained, so an agent cannot infer its meaning or default behavior from the description.
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 action ('导出' / export), the resource ('profiles'), and the output formats (YAML/JSON). This distinguishes it from sibling tools like export_table_csv and export_backup, though it does not specify whether all profiles or a selected subset are exported.
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 about when to use this tool instead of alternatives such as export_backup or export_table_csv. The description implies a simple export action but offers no context, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 of behavioral disclosure. It only says 'list saved execution plans' and gives no information about ordering, pagination, filtering behavior, whether it reflects the current profile, or what the response shape is. This is minimal and insufficient for a tool with no annotation context.
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, focused sentence with no wasted words. It is concise and front-loaded, though it achieves conciseness by omitting important context.
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?
For a simple tool with two optional parameters and no output schema, the description provides only the most basic action. It lacks details about return values, filtering semantics, pagination, or relationship to other query-plan tools, leaving an agent to guess at important operational context.
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?
The input schema has 0% description coverage, and the description does not mention either parameter. Although 'limit' and 'queryHash' are somewhat self-explanatory from their names, the description adds no meaning beyond the schema and does not compensate for the lack of 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 tool's function: listing saved execution plans. It identifies the resource ('execution plans') and the operation ('list'), which is enough to distinguish it from siblings like explain_query or compare_query_plans, though it doesn't explicitly contrast with them.
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 about when to use this tool versus alternatives such as get_query_history or compare_query_plans. The description implies a simple listing use case but does not state prerequisites, typical scenarios, or 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose the write-oriented nature (generate and insert), the required insert+batch permissions, and that permission control is enforced by CallToolRequest — meaningful context beyond the schema. However, it fails to disclose the potentially destructive behavior of the overwrite option, effects on existing rows, or transaction/rollback behavior, which matters for a data-mutating tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short and front-loads the purpose in the first sentence, which is good. However, the third sentence ("完整 inputSchema 同上(Permission 控制由 CallToolRequest 强制执行)") is largely redundant: it restates that the schema is available and partially repeats the permission requirement already given in sentence two. One or two of the three sentences earn their place; the third does not.
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 — three parameters, one of which is a deeply nested options object with a rule-matching engine — yet the description is only three short sentences. With 0% schema publication coverage, no output schema, and no annotations, the agent is left without information about how rules work, what overwrite does, what the return value looks like, or how generation is scoped. The description is not complete enough for an agent to call this tool confidently without opening the raw schema and guessing at semantics.
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 semantics, but it only hints at tableName via "根据表结构." The complex nested options object — including rules with match conditions (tableName, columnName, columnType, columnNamePattern), seed, columns, overwrite, and columnOverrides — is left entirely unexplained by both the schema and the description. The line "完整 inputSchema 同上" merely points back to the schema and adds no semantic value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action and resource: "根据表结构自动生成并插入样例数据" (automatically generate and insert sample data based on table structure). The verb (generate + insert) and the resource (sample data for a table) clearly convey what the tool does and distinguish it from read-only siblings like get_sample_data. However, it does not name any sibling explicitly, so differentiation is implicit rather than stated.
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 on when to use this tool versus alternatives such as get_sample_data, execute_batch, or execute_query. The only contextual hint is the permission requirement (insert+batch), which reads as a precondition rather than usage direction. There are no exclusions, alternatives, or recommended scenarios provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the full burden for behavioral disclosure. It states that deletion occurs but does not mention whether the action is permanent, whether it cascades to dependent resources, what permissions are needed, or what happens after deletion.
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, front-loaded sentence with no redundant words. It is efficient, though the terseness contributes to the lack of behavioral context.
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?
With no annotations and no output schema, the description leaves critical context unstated for a destructive operation: irreversibility, side effects, error behavior, and whether the id must reference an existing template. The description is too sparse to be considered 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. It adds only that deletion is done 'by id,' which barely expands on the schema's 'id' string field. It does not explain where the id comes from, what format it should be, or how it relates to listing or fetching templates.
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 ('Delete') and a specific resource ('template by id'). This clearly distinguishes it from sibling tools like get_template, list_templates, and save_template.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance about when to use this tool versus alternatives, no prerequisites, and no warning about destruction. It only states the action, leaving usage context entirely to the agent's 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?
No annotations are provided, so the description carries the behavioral disclosure burden. It does disclose the permission requirement and whitelist restriction, which is useful, but it does not mention side effects, transaction behavior, dry-run behavior, or failure modes for a tool that executes SQL files.
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 action. However, the whitelist constraint is stated twice, which is mildly redundant and weakens the otherwise tight structure.
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?
For an execution tool with no output schema and no annotations, this description is under-specified. It omits return values, error behavior, transaction default behavior, dry-run behavior, and clear differentiation from execute_script/execute_batch.
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 only 50%. The description adds meaning for filePath (whitelist) and maxStatements (1000 statement limit), but dryRun and useTransaction receive no description-level semantics, and useTransaction is undocumented in the schema as well.
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 action ('执行 .sql 文件') and identifies the resource type with a meaningful constraint (max 1000 statements). It is specific enough to distinguish from the many query/list siblings, though it does not explicitly name a competing tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives preconditions (permissions and whitelisted path) but no guidance on when to use this tool versus execute_query, execute_script, or execute_batch. There is no alternative-selection 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?
The description usefully discloses that ${} placeholders are passed literally to EXPLAIN and cause syntax errors, and it suggests using literals or a params array. However, with no annotations present, it does not clarify whether the operation is read-only, whether it modifies anything, or what the returned advice/plan looks like.
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 core purpose, and the critical placeholder warning is included without excess words. The fragment structure and abrupt transition from purpose to warning slightly reduce readability, but every word is functional.
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?
With no annotations, no output schema, and a minimal description, an agent lacks essential context about return values, side effects, active-profile requirements, and how to provide parameters. The discrepancy between the mentioned 'params array' and the actual schema further undermines completeness.
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 only 33%, so the description must compensate. It does add meaningful guidance for the sql parameter (no ${}, use literals or params), but it references a 'params array' that does not exist in the input schema, creating confusion. The profileName parameter is left completely undocumented.
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 'EXPLAIN + 索引建议' clearly identifies the tool as an EXPLAIN operation with an added index-advice feature, which distinguishes it from the sibling explain_query. However, it is a fragment rather than a full sentence, and it does not explicitly state the resource (e.g., 'on a SQL query').
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool versus explain_query, execute_query, or lint_sql. The only instruction is a formatting constraint about ${} placeholders, which is a how-to detail rather than a when-to-use recommendation or exclusion of alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 behavioral burden. It implies a read-only operation but does not disclose return format, error behavior, whether the profile must exist, or any side effects. This is minimal transparency beyond the obvious getter semantics.
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 one short, direct sentence with no filler. It front-loads the verb and resource and earns every word.
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 one-parameter read tool, the description is minimally adequate: an agent can infer to pass a profile name and expect config back. However, with no annotations, no output schema, and no usage context, it leaves alternative routing and behavioral details unspecified.
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 adds only that a 'specified' profile's config is returned, without explaining the name parameter's format, valid values, or whether it is a profile name versus an ID. This barely exceeds the bare schema property definition.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource: it gets a profile's configuration. The word '指定' (specified) loosely distinguishes it from sibling get_active_profile, but it does not explicitly clarify that the profile is identified by name or explicitly contrast it with related siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool versus get_active_profile, list_profiles, or use_profile. The description simply states what the tool does without mentioning alternatives, exclusions, or selection criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the full burden of disclosing side effects. It indicates an import operation but does not explain merge vs. replace behavior, dry-run capability, whether existing profiles are overwritten, or any other behavioral consequences.
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 concise sentence with no filler or redundancy. It is efficiently front-loaded with the action and resource, though it sacrifices information for brevity.
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?
For a mutating import tool with no annotations, no output schema, and four under-documented parameters, the description is far too sparse. It omits essential details about the required input, mode semantics, dryRun behavior, and what happens during import.
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 0% schema description coverage, the description needed to compensate for the four parameters. It only hints at YAML/JSON as the format, leaving the input parameter unclear (raw content vs. path) and failing to explain mode and dryRun.
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 a specific verb and resource: import profiles, and identifies the supported source formats (YAML/JSON). This distinguishes it from sibling tools like import_csv (CSV) and export_profiles (the opposite direction). An agent can discern the tool's core function immediately.
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 guidance is given about when to use this tool versus alternatives such as import_csv, create_profile, or update_profile. The source format is implied, but there are no conditions, exclusions, or references 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 burden of behavioral disclosure. It does state the return components ('plan + raw output + duration'), which is useful, but it does not mention side effects, read-only guarantees, or what 'raw output' means. This is 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 one front-loaded sentence with no filler. Every phrase adds information: the action, the target, and the return payload.
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?
Given no annotations, no output schema, and an undocumented `params` parameter, the description is too thin to fully support correct invocation and interpretation. It covers the basic purpose and return high-level information, but misses parameter semantics and routing guidance.
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 provides no detail about the `params` array, which is likely used for query binding, and only loosely describes `sql` as a SQL query. This leaves the optional parameter's semantics unclear.
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 identifies the action ('Get EXPLAIN plan') and the resource ('a SQL query'), and it states the key outputs. It is concise and distinguishable from siblings like execute_query, though it does not explicitly differentiate itself from explain_query_with_advice or compare_query_plans.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool versus explain_query_with_advice or compare_query_plans. The description implies its use for obtaining an EXPLAIN plan, but it does not state prerequisites, exclusions, or 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?
With no annotations, the description carries the full burden. It adds useful behavioral details like the default limit of 50, the versioned profileName null semantics, and aggregation via groupBy. However, it does not disclose return format, pagination behavior, or whether this is strictly 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded: purpose first, then filters, then version-specific additions. It wastes no words, though cramming eight parameters into one line makes it slightly dense.
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?
Given eight parameters, no annotations, and no output schema, the description is incomplete. It omits output shape, parameter formats, and any guidance relative to sibling tools, leaving agents to guess at critical details for correct invocation.
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 coverage is only 25% (2 of 8 parameters have descriptions), so the description must compensate. It lists all parameter names and provides the limit default, but db, kind, since, until, and onlyErrors are left semantically vague—no formats, allowed values, or defaults beyond the list.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action and resource: 'Get recent query history.' This distinguishes it from execution, explanation, and linting siblings, though it does not explicitly name any alternative.
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?
Usage is implied through the verb 'Get' and the listed filters, but there is no explicit guidance on when to prefer this over sibling tools like audit_log or get_metrics, nor any 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.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the full behavioral disclosure burden. It does add one meaningful behavioral gate: INSERT/UPDATE/DELETE require write mode. However, it does not state whether the tool is read-only by default, what a query returns, or what side effects or permissions are involved, so the disclosure is partial.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences: the first states the core purpose, and the second adds the critical write-mode caveat. There is no filler, repetition, or unnecessary detail.
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?
For a generic SQL executor with no annotations and no output schema, this description is too thin. It omits expected result shape, default read-only behavior, and any explanation of how it differs from the many SQL-related siblings such as execute_batch, execute_sql_file, and explain_query. An agent does not have enough context to invoke it safely or predict outcomes.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters. The description adds operation-level context about query types but no parameter-level meaning beyond the schema. It also does not clarify the schema mismatch where 'query' is required but only 'sql' is defined as a property.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('执行') and resource ('SQL 查询或数据库命令'), and enumerates supported operations such as SELECT, JOIN, aggregation, and conditional writes. It clearly defines what the tool does, but it does not differentiate it from sibling tools like execute_script, execute_sql_file, and execute_batch, which could plausibly execute SQL in different forms.
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 implies that read queries are supported and that write statements depend on write mode being enabled, but it provides no explicit guidance on when to choose execute_query over sibling tools. It does not name alternatives, exclusions, or conditions under which another tool should be used.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 of behavioral disclosure. It only states 'Get one template by id' and does not mention that the operation is read-only, does not execute the template, what happens if the id does not exist, or what the response contains. The verb 'get' weakly implies retrieval, but the description does not explicitly rule out side effects or distinguish behavioral safety from execute_template.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. Every word contributes to the core meaning, and the most important scoping detail ('one template by id') appears clearly.
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 one-parameter schema keeps complexity low, but there is no output schema and no explanation of what a 'template' contains or returns. The presence of execute_template among siblings makes the missing distinction between retrieving and executing a template a meaningful gap; the description does not fully equip an agent to use this tool correctly in context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. 'by id' adds the semantic that the required id parameter is the lookup key for the template, which is useful but minimal; it does not provide format, source, or examples. The parameter name and schema already communicate that id is a required string.
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 'Get one template by id' uses a specific verb and resource, clearly indicating a single-template retrieval operation. The singular scope ('one') and the 'by id' qualifier distinguish it from siblings like list_templates, delete_template, save_template, and execute_template without needing to inspect schemas.
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 about when to use this tool versus alternatives such as list_templates or execute_template. An agent is not told to use get_template for retrieving a saved definition, list_templates for enumerating templates, or execute_template for running a template.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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. It discloses that templates are reusable across the team and use ${param} placeholders, and it mentions the optional profile_name. However, it does not explain whether saving with an existing name overwrites, whether validation occurs, what permissions are required, or what the tool returns, which are important for a mutation-style 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 short and front-loaded: the core action and resource appear first, followed by team reuse, placeholder syntax, and the version note. It is efficient, though the version marker 'v2.19' adds minor clutter without strong value for tool selection.
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?
With no output schema, no annotations, and very low schema description coverage, the description is not complete enough for an agent to invoke the tool confidently. Missing details include overwrite behavior, expected return value, validation rules, and the exact format expected for the 'parameters' array. The description covers the high-level purpose but leaves several operational aspects undisclosed.
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 only 17%, so the description must compensate for the undocumented parameters. It adds meaning for ${param} placeholders and mentions profile_name, but it does not clarify the semantics of the 'parameters' array, 'tags', or 'description' fields. The relationship between the 'parameters' property and the ${param} placeholders is only hinted at, not 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?
The description states a specific verb ('Save') and resource ('parameterized SQL template'), and 'Reusable across team' plus 'Use ${param} placeholders' clearly distinguishes it from sibling operations like execute_template, get_template, list_templates, and delete_template. The resource and core behavior are immediately identifiable.
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 a reusable, team-shareable parameterized SQL template is needed. However, it does not explicitly state when not to use it or compare it to alternatives such as execute_template or get_template, leaving the selection guidance mostly implicit.
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 full behavioral burden. '获取' clearly signals a read-only retrieval operation, which is useful, but the description does not disclose what the returned configuration contains, whether it depends on the active profile, or what format the response takes.
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 short sentence that is front-loaded and free of filler. It is appropriately compact for a no-parameter getter, though it is terse enough that it leaves usage and behavioral details to inference.
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?
Invocation is simple because there are no parameters, but with no output schema and no annotations, the description is thin. An agent can call the tool correctly but will not know what shape or scope of PII configuration to expect in the response.
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 has 100% coverage with an empty properties object, so parameter semantics are trivially clear. The description does not need to add parameter-level detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('获取') and a specific resource ('PII 脱敏配置'), making it clear this tool retrieves PII masking configuration. It is distinguishable from the sibling 'set_pii_config' by the get/set contrast, though it does not explicitly delimit scope such as current, global, or profile-specific config.
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 the sibling 'set_pii_config', and no prerequisites such as an active profile. The agent must infer the usage context from the tool name and the getter semantics.
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?
There are no annotations, so the description must carry behavioral disclosure entirely. It correctly implies a read-only listing operation and discloses the supported filtering dimensions (role, tag, enabled), but it does not explain result ordering, pagination, or whether disabled profiles are included by default. This is minimal but not misleading.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence, front-loaded with the primary action and followed by the key filtering behavior. The [group: profiles] tag is extra metadata but does not bloat the description; every element 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 list tool with no required parameters and no output schema, the description covers the core operation but leaves gaps around expected return shape and exact filter behavior. The sibling get_enum_values could help discover valid values, but the description does not point to it, so the agent must infer some details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description partially compensates by naming all three parameters as filter dimensions (role, tag, enabled). It does not define valid values or matching semantics (exact vs partial), but it at least tells the agent what each parameter is for.
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 '列出' (list) with a clear resource ('profile') and adds filtering capabilities, making the core action unmistakable. It does not explicitly contrast with sibling tools like get_profile or export_profiles, but the plural 'profiles' and the focused action are enough to differentiate it from single-profile tools.
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 offers no guidance on when to prefer list_profiles over sibling tools such as get_profile, export_profiles, or get_active_profile. The mention of filtering is about parameter usage, not tool selection, so an agent gets no explicit when-to-use or alternatives guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the burden of behavioral disclosure. 'Get' implies read-only behavior and 'Returns JSON' tells the caller the response format, but it does not disclose auth requirements, latency, or any operational caveats.
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 short sentences, front-loaded with the core purpose, then a compact summary of the key parameter and return type. There is no filler or redundant explanation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional parameter and a rich schema, the description plus schema are sufficient to invoke it correctly. It could be more complete by explaining when to prefer this tool over sibling tools, but nothing essential is missing for a basic read-only metrics call.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the single parameter is fully documented with an enum, default value, and per-value meanings. The description only repeats the category values without adding meaning beyond what the schema already provides.
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?
Description uses a specific verb and resource: 'Get server observability metrics' and enumerates the categories. It clearly states what the tool returns, but it does not explicitly differentiate it from siblings like get_query_history or audit_log.
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 on when to use get_metrics versus alternatives. The category list hints at use cases, but there is no explicit context, prerequisites, or exclusions to help an agent choose between this and related observability or query-history 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 provided, the description carries the full burden. It does disclose important behavior: append mode (not overwrite), write permission requirement, and current active connection fallback for profileName. However, it does not explain side effects, atomicity, error behavior, or return values, which are significant for an importing/mutating 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 short and front-loaded with the core action, followed by permission and profile behavior. All sentences contribute information, though the trailing [group: data-governance] tag adds little for an agent interpreting the tool.
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?
For an 8-parameter data import tool with no annotations and no output schema, the description is too thin. It omits guidance on key parameters like dryRun, columns, hasHeader, nullStrings, and batchSize, and does not describe expected results or failure modes.
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 only 13%, so the description needed to compensate. It only provides context for profileName, which is already described in the schema, and says nothing meaningful about table, filePath, dryRun, columns, batchSize, hasHeader, or nullStrings.
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 action (import), source (CSV file), target (existing table), and mode (APPEND). This distinguishes it from sibling tools like export_table_csv and import_profiles by specifying resource and operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides useful context: it appends to an existing table, requires write permission, and profileName is optional. However, it does not explicitly state when to use this tool versus alternatives, such as import_profiles or other import mechanisms, leaving that 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?
With no annotations, the description carries the behavioral disclosure burden. It usefully discloses the key edge case: when no profile is active, it returns null plus a prompt message. It also enumerates the returned data categories, but it does not explain the meaning or format of 'connection status' or 'schema cache', nor discuss any other error or side-effect behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The substantive description is a single, compact sentence and is mostly front-loaded with the core purpose. However, the leading 'v5.0.0 (renamed from get_connection_status)' is historical/version metadata that does not help an agent select or invoke the tool, adding minor 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 zero-parameter status tool with no output schema and no annotations, the description covers the essential information: what is returned and the outcome when no profile is active. The main gap is that the exact meaning or shape of 'connection status' and 'schema cache' is not elaborated, but this is a minor omission for a simple getter.
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 an empty schema, so there is no parameter documentation burden. The description appropriately focuses on return content and edge-case behavior, which is all that is needed for a parameterless getter.
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's action and resource: returning the currently active profile's name, full profile metadata, connection status, and schema cache. It distinguishes itself through the word 'active' from profile CRUD siblings, but it does not explicitly contrast with get_profile or list_profiles, so it stops short of full sibling differentiation.
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 intended use is implied by the phrase 'current active profile' and by the explicit null case when no profile is active. However, there is no direct guidance about when to choose this tool instead of get_profile, list_profiles, or use_profile, and no exclusions or alternative routing are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 behavioral disclosure burden. However, it does not mention the limit/truncation behavior (default 50, max 100) despite claiming 'all unique values', and does not mention includeCount effects. This is a notable gap and mildly misleading without the schema's qualification.
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 filler: purpose first, followed by use case and a concrete example. Every sentence contributes.
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?
The tool is simple and the schema covers all parameters, so the description's use-case and example are mostly sufficient. However, with no output schema and no annotations, it omits the return format and the important caveat that results are truncated at the limit, which prevents a fully complete picture.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds helpful context for columnName by giving enum-type examples, but it does not meaningfully elaborate on tableName, limit, or includeCount 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 opens with a specific verb ('获取' – get) and resource ('指定列的所有唯一值' – all unique values of the specified column), and elaborates with the use case (enum columns like status/type/category) and a concrete example (orders.status → pending, shipped, delivered). This clearly differentiates it from query/sample tools among the 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 Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly states when to use it: to understand all possible values of enum-type columns and to craft accurate WHERE conditions. It does not name alternatives or exclusions, but the context is unambiguous enough for an agent to select it over execute_query or get_sample_data.
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 behavioral burden. It discloses the 1000-statement limit, permission requirement, return behavior (lastResult with affectedRows), and advises verifying side effects via SELECT. This goes well beyond a minimal description, though it does not cover transaction behavior or error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded: the core purpose appears first, followed by the most critical constraints (permission, limit, return behavior, side-effect guidance). Every sentence earns its place with no redundancy.
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 tool with no annotations and no output schema, the description covers permission, statement count, return shape, and side-effect verification. However, it omits transaction semantics, behavior when 'useTransaction' is false, and how errors or PL/SQL output are handled, leaving notable gaps for correct invocation.
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 implies the nature of 'sql' and confirms the 'maxStatements' default limit, but it does not explain 'useTransaction' or describe how the parameters interact. Significant param semantics remain undocumented.
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 a specific verb and resource: '执行多语句 SQL 脚本或 PL/SQL 块' (execute multi-statement SQL scripts or PL/SQL blocks). This distinguishes it from sibling tools like execute_query by emphasizing multi-statement and PL/SQL support.
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 multi-statement scripts and PL/SQL blocks, and it gives a permission prerequisite ('需要 permissions 包含 script'). However, it does not explicitly mention alternative tools or when not to use this tool, so an agent must infer boundary cases from sibling names.
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 and explicitly discloses both the return value ('Returns query result') and the side effect ('increments use_count'). It does not mention prerequisites or error conditions, but it goes beyond a bare mutation statement.
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 short sentences with no filler. It front-loads the core action and immediately follows with the key return and side-effect behavior.
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?
The description gives the essential execution behavior and return/side-effect information, which is serviceable. It is incomplete in guiding how params should be structured and when this tool should be preferred over execute_query, especially given there is no output schema or annotations to fill those gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description only says 'with params' without explaining the shape, meaning, or requiredness of the params object. It slightly clarifies that id identifies the saved template, but it does not compensate for the complete lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: execute a saved template. It clearly differentiates from siblings like execute_query, save_template, get_template, and list_templates by emphasizing the saved template resource and the execution action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this tool should be used when a saved template needs to be executed with parameters, which is enough for basic routing. However, it does not explicitly contrast with execute_query or provide when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the burden of explaining behavior. It conveys that this is a read-only metadata operation ('获取'), but it does not disclose caching behavior despite the forceRefresh parameter implying a cache. Edge cases such as cache staleness are not mentioned.
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, front-loaded with the core action, and contains no filler. Every sentence adds useful information about the tool's purpose and typical usage.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple metadata-lookup tool, the description is reasonably complete. The schema fully documents both parameters, and the description conveys what the returned information covers. It lacks explicit mention of caching behavior, but overall the agent has enough to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% parameter description coverage, so the baseline is 3. The description does not add meaningful information about the parameters beyond what the schema already explains; it mainly describes the tool's output rather than its inputs.
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 specifies a verb ('获取') and a resource ('指定表的详细信息'), and lists the concrete contents: column definitions, indexes, and estimated row count. It does not explicitly differentiate itself from sibling tools like execute_query or get_global_schema, 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 Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description states its intended use: to gain an in-depth understanding of a table's structure. This gives the agent clear context for when to use it, though it does not explicitly explain when to avoid it or which sibling tool to choose instead.
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 available, the description carries the full behavioral disclosure burden. It discloses the permission requirement, the row limit, the returned affectedRowsPerStatement array, and the recommended verification pattern for writes. It does not, however, mention transaction failure semantics or all side-effect behaviors, so it is strong but not exhaustive.
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 compact and front-loaded, with three sentences covering purpose, permission, and return/verification guidance. The parenthetical version/process reference adds little actionable value, so it is concise but not perfectly lean.
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?
The description covers core behavior well but omits important operational details: no mention of the useTransaction default or its implications, no failure/rollback behavior, and no explanation of maxBatchSize. Given the absence of both annotations and an output schema, these gaps make the context only moderately 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, but it only adds limited meaning for paramsList and sql. It does not explain maxBatchSize or useTransaction, and the stated row limit duplicates schema maxItems info. Key parameters remain unclear.
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 a specific action: batch-execute the same SQL with multiple parameter sets, with an explicit upper bound of 1000 rows. This differentiates it from the sibling execute_query tool, which handles single-query execution.
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 useful context: it requires the 'batch' permission, and recommends using SELECT to verify side effects for write operations. However, it does not explicitly name alternatives or state when not to use this tool, so it falls short of full explicit guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the behavioral disclosure burden. It explicitly surfaces the non-obvious behavior that sensitive data is automatically masked, which is critical for an agent to know. It also implies a read-only sample-preview behavior, though it does not explicitly state side-effect safety or ordering/error behavior.
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 compact and front-loaded with the core action and masking caveat. The only minor weakness is a slight redundancy between '已自动脱敏' and the later sentence about sensitive fields being automatically masked.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple three-parameter tool, the description covers the main purpose, example use cases, and the critical privacy behavior. It does not describe return shape or error cases, but this is not a serious gap given the simplicity of the operation and the schema's parameter coverage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3 and the schema already documents tableName, limit, and columns. The description does not add parameter-specific guidance beyond the general purpose of returning sample rows.
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 specific action ('获取表的示例数据') and the intended purpose: understanding data formats such as date format, ID format, and amount precision. It distinguishes the tool as a row-preview operation, but it does not explicitly contrast it with sibling tools like get_table_info or generate_sample_data.
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 gives clear usage context: use it when you need to understand data format through actual sample rows. It provides concrete examples of what to look for. However, it does not state exclusions or name alternative tools, such as using get_table_info for schema-only details or execute_query for arbitrary queries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the disclosure burden. It does reveal that schemas are merged and the operation runs in parallel, but it does not explicitly state that this is a read-only aggregation or describe how conflicts between profile schemas are resolved. Still, nothing contradicts the tool's apparent behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that packs the action, scope, execution mode, and a grouping tag. Every word earns its place and nothing is redundant.
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 zero-parameter, low-complexity tool, the description is nearly sufficient to invoke correctly. It could be slightly more explicit about the return value's structure and that the operation is read-only, but those are minor gaps given the simple interface.
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 the baseline is 4. The description adds useful context by defining what gets merged, but no parameter details are 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?
Description uses a specific verb ('merge') and a clear resource ('all enabled profiles' schemas into a global schema). It also mentions parallel execution, and the scope of 'all enabled profiles' distinguishes it from sibling tools like get_schema, which target a single profile.
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 intended use is implied: call this when you need the combined schema across all enabled profiles. However, it does not explicitly say when not to use it or name alternatives like get_schema or compare_profile_schemas, so the agent must infer the routing.
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 present, so the description carries the full burden. It usefully discloses caching behavior and the availability of forceRefresh to get latest data, and it notes user-accessible scope. It does not explicitly state 'read-only' or discuss permissions, but the wording '获取' strongly implies a non-mutating metadata operation.
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 filler. It front-loads the core purpose and metadata contents, then adds usage guidance and caching behavior. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only introspection tool with one optional parameter and no output schema, the description is largely complete: it states what metadata is returned, when to use it, and how caching behaves. The main gap is not explaining the return format or explicitly routing between similar schema-related tools, but this is minor given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the forceRefresh parameter is already fully described in the schema with default and effect. The description adds context by mentioning caching, which explains why forceRefresh exists, but it does not add significant meaning beyond the schema. Baseline 3 is appropriate.
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 database structure metadata including tables, columns, data types, primary keys, and indexes, scoped to user-accessible schemas. It is a specific verb+resource pair and is easy to distinguish from query-execution tools, though it does not explicitly differentiate itself from close siblings like get_table_info or get_global_schema.
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 gives a clear usage context: call before executing queries to understand the database structure. It does not, however, state when NOT to use it or which alternative tool to pick when only a single table's info is needed, which would strengthen routing among the many 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 behavioral burden. It communicates that this is a listing operation and clarifies the profileName filtering behavior (null=global, name=local, omit=all), which adds value. However, it does not disclose the return format, pagination, sorting, or confirm that calling with no parameters returns all templates.
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?
Three short sentences, each earning its place. The main purpose is front-loaded ('List saved templates'), followed by filter details and the versioned parameter nuance. No wasted words or irrelevant context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-optional-parameter list tool, the description covers the essentials: what it does and how to filter using tag and profileName. It does not explain the return shape, and with no output schema that gap is notable, but the tool's simplicity keeps the description reasonably 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 only 50% (tag lacks a description). The description compensates by stating 'Optional tag filter,' giving tag its purpose and optionality, and by adding the 'omit=all' behavior for profileName, which goes beyond the schema's 'null = global-only; string = that profile.' This meaningfully helps an agent understand both parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'List saved templates.' It clearly distinguishes from sibling tools like get_template, delete_template, and execute_template by the list action alone. The optional tag and profileName filters further specify the scope of the operation.
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 it by mentioning 'saved templates' and the optional filters, but it never explicitly contrasts it with alternatives like get_template for a single template or save_template for creation. The profileName semantics (global/local/all) give useful context for how to invoke it, but no when-to-use vs. when-not-to-use guidance is present.
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 tool disconnects the old adapter and creates a new connection using profile.config, notes the historical bug fix, and states that the returned connection field reflects the new state. This is meaningful behavioral context beyond the basic purpose.
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: two sentences that state the primary purpose, describe the actual behavior, and mention the return field. The bug-history note adds useful context without unnecessary padding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with no output schema and no annotations, the description covers the main action, the underlying behavior, and the return value. It does not discuss error cases or prerequisites, but the core information needed to invoke the tool successfully is present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% and the only parameter 'name' is just a string. The description indicates that the name refers to an already-saved profile, which adds some semantic meaning, but it does not clarify naming rules, behavior when the profile is missing, or whether the name is case-sensitive.
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: '切换活跃连接到已存 profile' (switch active connection to a saved profile). It clearly identifies the tool's action and distinguishes it from sibling tools like create_profile or enable_profile by focusing on switching the active connection.
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 the tool is for switching to an existing profile, but it does not explicitly state when to use it versus alternatives such as enable_profile, disconnect_profile, or get_active_profile. No when-not-to-use conditions or 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?
With no annotations provided, the description carries the full behavioral burden. It discloses a useful and non-obvious trait: large profiles can produce output larger than 1MB and may be truncated unless limited by maxTablesPerProfile. It does not mention auth or read-only status, but the compare semantics make destructive side effects unlikely.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded: purpose first, then an actionable warning about output size. Every clause earns its place with no filler or repetition.
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?
There is no output schema and no description of the comparison result format. The agent knows what the tool does, but not what the returned diff looks like or how truncation manifests. For a 3-parameter tool with no annotations, this 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.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 33%, so the description must compensate for the two undocumented parameters. It clarifies that two profiles are compared, which maps to nameA and nameB, and reinforces the purpose of maxTablesPerProfile. However, it adds little beyond the schema's own description of maxTablesPerProfile and does not specify what form profile names should take.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description states a specific action: '比较两个 profile 的 schema 差异' (compare schema differences between two profiles). This clearly distinguishes it from siblings like compare_query_plans and get_schema by naming the exact resource being compared.
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 gives clear context: use this tool to compare schema differences across two profiles. It also provides practical guidance for large databases by warning about >1MB output and recommending maxTablesPerProfile to avoid truncation. It stops short of a 5 because it does not explicitly name alternatives or exclusion conditions.
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 present, the description carries the full burden of behavioral disclosure. It does disclose the required precondition and the resulting error message, which is useful. However, it does not describe what the comparison output looks like, whether the operation has side effects, or any read-only guarantees, so behavioral transparency is only partial.
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 just two short sentences. The warning and prerequisite are front-loaded, and every sentence earns its place without repetition or filler.
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?
The description covers the core action, the precondition, and the failure case, which is important context. However, there is no output schema and the description does not explain what the comparison result will be, leaving a gap for an agent trying to interpret the tool's return value.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description does add contextual meaning to queryHash by linking it to the prerequisite and error condition, but entryA and entryB are only described as entry ids in the schema and the description adds no extra semantics for them.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool compares two saved execution plans, using a specific verb and resource. It is naturally distinguished from sibling tools like explain_query, list_query_plans, and explain_query_with_advice because it focuses on comparing previously saved plans.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states the prerequisite of running explain_query_with_advice({persist:true}) at least twice with the same queryHash before using this tool. It also names the exact error that occurs when this condition is not met, which is strong practical guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does disclose meaningful behaviors: INSERT-only write semantics, UNIQUE constraint error on duplicate names, and a SQLite type caveat for config.filePath. It does not mention auth requirements or return behavior, but the disclosed traits go well beyond 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?
Three terse sentences with no filler: purpose, error/alternative, and a parameter caveat are all front-loaded. The trailing [group: profiles] tag adds navigational context without bloating the description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite being concise, the tool has 8 parameters, required nested config, and no output schema. The description covers uniqueness and one config caveat, but an agent would still lack enough detail to correctly construct config, assign role/permissionMode, or understand the result of the insert.
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 only 13%, yet the description adds only one parameter-level hint about config.filePath. It does not clarify the meaning or expected shape of the required name, type, and config parameters, nor the behavioral impact of fields like role, permissionMode, enabled, or tags. Low schema coverage demands far more compensation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action—creating a new profile row in profiles.db—and explicitly marks it as INSERT-only. It also distinguishes itself from update_profile for existing profiles, making the tool's 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 Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly tells the agent to switch to update_profile when a profile with the same name already exists, and clarifies that this tool is only for inserts. This provides clear when-to-use and when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/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 the default output path and active-connection fallback, which is useful. However, it does not state whether existing files are overwritten, what permissions are needed, or what the tool returns on success/failure.
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?
Three compact sentences with no wasted words. The primary action and constraints are front-loaded, and the optional/fallback behavior is packed efficiently.
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 seven parameters, zero annotations, and no output schema, the description is not fully complete: where/columns semantics, overwrite behavior, and return shape are missing. The schema fills in some details (SQL executed as-is, path whitelist), but important gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaning beyond the schema by stating table/sql exclusivity and the default output naming convention, and it notes profileName fallback. Schema coverage is moderate (57%), so this compensation matters; however, where and columns remain largely unexplained.
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 and resource: exports a single table or custom SQL result to a CSV file. This clearly distinguishes it from siblings like execute_query (query only), import_csv (import), and export_profiles/export_backup (other export targets).
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?
Gives explicit usage context: table and sql are mutually exclusive, sql is intended for Oracle/DM dialects or paginated queries, and outputPath/profileName have clear fallback behavior. It does not name alternatives from the sibling list, but the internal routing guidance is strong.
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?
There are no annotations, so the description carries the full burden of behavioral disclosure. It states that the tool clears the Schema cache and ties that action to schema updates, but it goes little beyond the tool's name and does not describe side effects, scope (global vs. per-schema), or whether the cache is automatically rebuilt. This is adequate for a simple no-parameter operation but not richly transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences with no filler. The core action is front-loaded ('清除 Schema 缓存'), and the use-case context follows immediately in a second concise sentence. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter utility with no output schema and no annotations, the description covers the essential 'what' and 'when.' It could additionally state what happens after clearing (e.g., cache is rebuilt on next schema access), but that is implied and not a significant gap for this simple tool.
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 schema description coverage is 100%, so there are no parameters to clarify. Per the rubric, a zero-parameter tool gets a baseline of 4, and the description adds no misleading parameter information.
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-resource pair: '清除 Schema 缓存' (clear Schema cache), which precisely names the operation. It is immediately distinguishable from all 40 sibling tools, none of which target cache clearing, and the title/name are not merely restated.
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 gives a clear trigger condition: use this tool when the database structure changes, such as when tables are added or columns are modified. It does not explicitly mention when not to use it or name alternatives, but none of the sibling tools offer a cache-clearing function, so the guidance is sufficient.
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 disclosure burden. It does state the tool is 'Advisory, never blocks,' disclosing that it is non-blocking and safe, and it specifies the return shape as an issues array. It does not go into further detail about whether it uses a database connection or a specific SQL dialect, but the core behavioral traits are covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no filler, and the key action is front-loaded. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter, no-output-schema tool, the description covers the essential contract: what input it takes, what it returns, and how it behaves (advisory, non-blocking). It doesn't detail the issue object structure or prerequisites like an active profile, but given the low complexity, the description 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?
The schema has zero description coverage, and the description must compensate. It mentions 'a SQL query,' directly mapping to the single 'sql' parameter. While it adds no format constraints or dialect details, the parameter's purpose is clearly conveyed by both its name and the description.
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: 'Lint a SQL query.' It immediately states what the tool operates on and clarifies the output as an issues array with severity levels. This clearly distinguishes it from sibling tools like execute_query or explain_query, which have different purposes.
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 says 'Advisory, never blocks,' implying the tool is for safe, non-executing checks and giving some context on when to use it. However, it does not explicitly name alternatives such as explain_query or execute_query, nor does it state when not to use it. The usage guidance is 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?
With no annotations provided, the description carries the full behavioral burden and delivers: it flags the mutation semantics ('UPDATE-only'), discloses the failure mode (error if profile absent), lists immutable fields (use_count/created_at/created_by/id stay unchanged), and warns about a type-specific config constraint (SQLite: don't pass config.filePath). It does not cover return shape or permissions, but the disclosed behaviors go well beyond baseline.
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?
Four terse sentences, each earning its place: purpose, error behavior, immutable fields, and a platform-specific gotcha. The core purpose is front-loaded first and the '[group: profiles]' tag is bracketed at the end. No filler or repetition of schema 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?
For a complex tool with 8 parameters, nested config, two enums, no output schema, and no annotations, the description covers the essential contract: update-only semantics, error behavior, immutable fields, and a critical config constraint. Gaps remain — how the target profile is identified (name is required but never stated as the key), what the tool returns, and per-field semantics — but the description is well above minimum viable for this complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate, and it partially does: it adds the only parameter-level guidance available ('SQLite 类型不要传 config.filePath'), implying config is type-sensitive, and reveals that use_count/created_at/created_by/id are not updatable. However, seven of the eight schema properties (name, role, tags, enabled, description, permissionMode, and general config contents) receive no semantic explanation, leaving a significant gap.
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+resource+scope: '修改已存在的 profile(UPDATE-only)' (modify an existing profile, update-only), which unambiguously identifies the operation. The error condition ('profile 不存在抛错') reinforces that it targets existing records, cleanly separating it from the sibling create_profile without needing schema inspection.
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?
It clearly states this is for modifying existing profiles and that a missing profile causes an error, which implicitly tells the agent to use create_profile for new records. However, it never names the alternative tool explicitly or states a when-not-to-use condition, so the routing is inferred rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility and does so thoroughly. It explicitly flags the operation as destructive, explains the default preview path, states the confirmation requirement, and names the exact deletion targets: the profiles.db row and the ~/.universal-db-mcp/<name>/ subdirectory.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded with the core action, followed by a warning and essential safety details. Every clause carries useful information; there is no redundant filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the critical aspects: destructive nature, preview behavior, confirmation flag, and exact delete scope. It does not state what happens after a confirmed deletion or how errors are surfaced, but for a profile deletion tool the key behavioral contract is well specified.
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 50%, with only confirm documented. The description adds meaning for name by implying it selects the target profile, and for confirm by specifying the actual side effects of deletion and the preview result. This goes beyond the schema's terse '二次确认' description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description opens with '删除指定 profile', a specific verb and resource that exactly identifies the tool's function. It is clearly distinguishable from sibling profile tools like create_profile, update_profile, and get_profile, as well as from delete_template.
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 conveys clear context: this tool deletes a profile and requires confirm=true for actual deletion. However, it provides no explicit guidance about when to prefer this tool over alternatives or when not to use it, leaving usage selection mostly implied.
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:

[![universal-db-mcp MCP server](https://glama.ai/mcp/servers/joyous-coder/universal-db-mcp/badges/card.svg)](https://glama.ai/mcp/servers/joyous-coder/universal-db-mcp)

Score Badge

Copy to your README.md:

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

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