CockroachDB MCP Server

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes targeting specific database operations like schema management, query execution, or monitoring. However, some overlap exists between 'analyze_performance' and 'show_running_queries' (both related to query performance), and 'connect' vs 'connect_database' (both for establishing connections) could cause confusion, though descriptions help differentiate them.
Naming Consistency5/5
Tool names follow a highly consistent verb_noun pattern throughout, such as 'create_table', 'drop_index', 'list_databases', and 'get_cluster_status'. All tools use snake_case with clear action-object naming, making them predictable and easy to understand.
Tool Count3/5
With 29 tools, the count is borderline high for a database server, potentially overwhelming for agents. While it covers many aspects of CockroachDB, it might benefit from consolidation or categorization, as some tools like 'connect' and 'connect_database' could be merged to reduce redundancy.
Completeness5/5
The tool set provides comprehensive coverage for database operations, including CRUD for tables, views, indexes, and databases, along with query execution, performance analysis, monitoring, and administrative tasks. No obvious gaps are present; agents can perform full lifecycle management and troubleshooting.
Average 3.3/5 across 29 of 29 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- 2 of 2 community issues answered or closed in the last 6 months
- 5 commits in the last 12 weeks
- Last stable release on June 15, 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.
This server has been verified by its author.
View related servers

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the tool returns statistics like P50 and P99, which gives some insight into output format. However, it doesn't disclose critical behavioral traits: whether this is a read-only operation, if it requires specific permissions, potential performance impact on the database, rate limits, or whether it analyzes historical vs real-time data. The description is minimal beyond basic functionality.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, args, returns) and front-loaded with the core functionality. Every sentence adds value: the first states purpose, the args section documents parameters, and returns indicates output type. It could be slightly more concise by integrating the default values into the main description rather than separate args section.
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 2 parameters with 0% schema coverage and no output schema, the description provides basic purpose and parameter information but lacks comprehensive context. It doesn't explain the relationship between query and time_range parameters, doesn't specify output format details beyond example metrics, and omits behavioral considerations. For a performance analysis tool with no annotations, this is minimally adequate but has clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the schema provides no parameter documentation. The description adds meaningful context: 'query' filters analysis, 'time_range' specifies analysis period with format 'minutes:seconds' and default '1:0'. This compensates partially but doesn't explain what '1:0' means (presumably 1 minute 0 seconds), valid time range formats, or whether both parameters can be used together. Baseline 3 reflects adequate but incomplete parameter semantics.
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 analyzes query performance statistics for a given query or time range, providing a specific verb ('analyze') and resource ('query performance statistics'). It distinguishes from siblings like 'execute_query' or 'explain_query' by focusing on performance metrics rather than execution or optimization. However, it doesn't explicitly differentiate from all possible alternatives like 'get_query_history' which might overlap in time-range analysis.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over 'get_query_history' for historical analysis, 'explain_query' for optimization insights, or 'show_running_queries' for current performance. There's no context about prerequisites, typical use cases, 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?
With no annotations provided, the description carries full burden for behavioral disclosure. It states the tool drops an index (implying a destructive mutation), but doesn't cover critical aspects like permissions required, whether the operation is reversible, potential side effects on database performance, or error conditions beyond generic 'error message'. This is inadequate for a destructive operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with a clear main statement followed by structured Args and Returns sections. The formatting helps readability, though the Returns section is vague ('A success message or an error message'). Every sentence serves a purpose with minimal waste.
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 destructive mutation tool with no annotations, no output schema, and minimal parameter documentation, the description is incomplete. It doesn't explain what 'dropping' entails (e.g., immediate removal vs. background process), what happens to dependent objects, or what format the return messages take. The agent lacks sufficient context to use this tool safely and effectively.
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 description adds minimal parameter semantics beyond the schema. It specifies that 'index_name' is the 'Name of the index to drop', which slightly clarifies the parameter's purpose but doesn't provide format requirements, naming conventions, or validation rules. With 0% schema description coverage and only one parameter, this meets the baseline but doesn't compensate for the coverage gap.
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 ('Drop') and the resource ('an existing index'), which is specific and unambiguous. However, it doesn't differentiate from sibling tools like 'drop_database', 'drop_table', or 'drop_view', which all perform similar deletion operations on different resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., the index must exist), consequences (e.g., performance impact on queries), or when to choose other drop operations like 'drop_table' instead. This leaves the agent without context for proper tool selection.
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 states the tool is for 'getting' information, implying a read-only operation, but doesn't disclose behavioral traits such as whether it requires specific permissions, how it handles large schemas, potential rate limits, or the format of the returned data. This leaves significant gaps in understanding the tool's behavior beyond its 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately sized: it starts with a clear purpose statement, followed by separate 'Args' and 'Returns' sections. Each sentence adds value without redundancy. However, the 'Returns' section is somewhat vague ('List all relationships...'), and there's minor room for tightening, but overall it's efficient and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (1 parameter, no output schema, no annotations), the description is minimally adequate. It covers the purpose, parameter usage, and output scope, but lacks details on behavioral aspects like permissions or data format. Without annotations or output schema, more context on what the return data looks like would improve completeness, but it meets basic requirements for a read operation.
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 description includes an 'Args' section that documents the single parameter 'table_name' as optional, with a default of None, and a 'Returns' section that clarifies the output scope. However, schema description coverage is 0%, so the description compensates by providing this parameter info. It adds meaning by explaining the optional nature and effect on output, but doesn't detail data types or constraints beyond what's implied, earning a baseline score.
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 purpose: 'Get foreign key relationships for a table or all tables.' It specifies the verb ('Get') and resource ('foreign key relationships'), and distinguishes the scope (specific table vs. all tables). However, it doesn't explicitly differentiate from sibling tools like 'describe_table' or 'analyze_schema', which might also provide relationship information, so it's not a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides minimal guidance: it mentions that the tool can be used for a specific table or all tables, but offers no explicit advice on when to use it versus alternatives like 'describe_table' or 'analyze_schema'. There's no mention of prerequisites, performance implications, or typical use cases, leaving the agent with little contextual direction.
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 provided, the description carries the full burden of behavioral disclosure. It states this is a 'List' operation which implies read-only behavior, but doesn't disclose important behavioral traits like whether this requires specific permissions, what happens if the schema doesn't exist, whether results are paginated, or what format the output takes. For a database tool with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.
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 appropriately sized and well-structured with clear sections for the main description, arguments, and returns. The first sentence states the core purpose clearly. However, the 'Args' and 'Returns' sections could be more efficiently integrated, and the returns statement is somewhat redundant with the main 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?
Given this is a database metadata tool with no annotations, no output schema, and incomplete parameter documentation, the description is insufficient. It doesn't explain what information is returned about each view, how results are formatted, whether there are permission requirements, or what happens with non-existent schemas. For a tool that interacts with database system catalogs, more context is needed.
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 description adds minimal value beyond what the input schema provides. The schema shows db_schema is a string with default 'public', and the description merely restates this with 'Schema name (default: "public")'. With 0% schema description coverage, the description doesn't compensate by explaining what a schema is, what valid values are, or providing examples. However, with only one parameter, the baseline is higher than for multi-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('all views in a schema'), making the purpose immediately understandable. It distinguishes itself from siblings like list_tables or list_databases by specifying 'views' rather than other database objects. However, it doesn't explicitly differentiate from other view-related tools like create_view or drop_view, which keeps it from a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when you'd want to list views versus tables, or how this differs from other metadata tools like analyze_schema or describe_table. There's no context about prerequisites or when this operation is appropriate.
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 full burden. It mentions switching connections but doesn't disclose critical behavioral traits: whether this requires specific permissions, if it affects ongoing transactions/queries, what happens to the previous connection, rate limits, or error conditions beyond generic 'error message'. For a mutation tool with zero annotation coverage, this is inadequate.
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 appropriately sized and front-loaded with the core purpose in the first sentence. The Args/Returns sections are structured but slightly verbose for a single parameter; the 'Returns' line could be more concise. Overall, it's efficient with minimal waste.
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 the tool's complexity (mutating connection state), lack of annotations, no output schema, and low schema coverage, the description is incomplete. It misses essential context: side effects, permissions, error details, and relationship to sibling tools. The return value description is vague ('success message or an error message'), failing to compensate for the missing output schema.
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. It adds the parameter name 'database' and clarifies it's the 'Name of the database to switch to', providing basic semantics. However, it doesn't explain format constraints (e.g., case sensitivity, allowed characters), whether the database must exist, or provide examples—leaving gaps despite the low schema coverage.
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 purpose with a specific verb ('switch') and resource ('connection to a different database'). It distinguishes from siblings like 'connect' or 'connect_database' by focusing on changing an existing connection rather than establishing a new one. However, it doesn't explicitly differentiate from all possible alternatives like 'get_connection_status'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., must have an active connection first), when-not-to-use scenarios, or comparisons with siblings like 'connect_database' or 'list_databases'. The agent must infer usage from context alone.
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 provided, the description carries the full burden of behavioral disclosure. It mentions the action ('create a connection pool') and return values ('success message or error message'), but lacks critical details: whether this is a one-time setup, if it requires authentication, potential side effects (e.g., resource allocation), or error conditions. For a connection tool with zero annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: the first sentence states the purpose, and the second clarifies the return values. Both sentences earn their place by providing essential information without redundancy. It could be slightly more front-loaded by integrating the return info, but it's efficient overall.
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 the tool's complexity (establishing a database connection) and lack of annotations and output schema, the description is incomplete. It doesn't explain what 'default CockroachDB database' means, how the connection pool behaves, or what the success/error messages contain. For a foundational tool in a database management context, more detail is needed to ensure safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, focusing on the tool's action. A baseline of 4 is applied for zero-parameter tools, as there's nothing to compensate 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 clearly states the tool's purpose: 'Connect to the default CockroachDB database and create a connection pool.' It specifies the verb ('connect'), resource ('default CockroachDB database'), and action ('create a connection pool'). However, it doesn't explicitly differentiate from sibling 'connect_database', which appears to be a similar connection tool, leaving some ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., whether a connection must be established before other operations), compare it to 'connect_database', or specify when not to use it (e.g., for non-default databases). This lack of context makes it unclear how this tool 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 full burden. It states the tool creates a view and returns a success/error message, but lacks critical behavioral details such as permissions required, whether it's idempotent, if it overwrites existing views, or any rate limits. This is inadequate for a mutation tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a brief purpose statement followed by clear sections for Args and Returns. It's front-loaded and avoids unnecessary details, though the Returns section could be more specific (e.g., mentioning what the success message contains).
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 a mutation tool with behavioral gaps, the description is incomplete. It covers parameters well but fails to address critical context like error conditions, side effects, or integration with sibling tools (e.g., connect_database prerequisite), making it insufficient for safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It clearly explains both parameters: view_name as the name of the view and query as the SQL query for the view definition, adding meaningful semantics beyond the bare schema. With 0% coverage and 2 parameters, this is strong compensation.
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 creates a view from a SQL query, specifying both the verb ('create') and resource ('view'). It distinguishes from siblings like create_table or create_database by focusing on views, though it doesn't explicitly differentiate from drop_view or list_views beyond the action type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites like needing an existing database connection, nor does it clarify when to use create_view versus execute_query for similar operations, leaving usage context implied but unspecified.
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 provided, the description carries full burden for behavioral disclosure. It states the action is 'Drop' (implying destructive mutation) but doesn't describe critical behaviors: whether this is irreversible, what permissions are required, if it affects dependent objects, or what happens on success/failure beyond generic 'message' returns. This leaves significant gaps for a destructive operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately brief and front-loaded with the core purpose in the first sentence. The Args/Returns sections are structured but somewhat redundant with the schema (though helpful given 0% schema coverage). No unnecessary verbiage, though the Returns section could be more specific.
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 destructive mutation tool with no annotations, 0% schema description coverage, and no output schema, the description is insufficient. It doesn't explain the irreversible nature, permission requirements, error conditions, or what 'success message' contains. Given the complexity and risk of dropping database objects, more behavioral context is needed.
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 meaningful context for the single parameter 'view_name' by specifying it's 'Name of the view to drop', which clarifies the parameter's role beyond the schema's basic 'View Name' title. With 0% schema description coverage and only one parameter, this adequately compensates, though it doesn't explain format constraints (e.g., case sensitivity, naming conventions).
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 ('Drop') and target resource ('an existing view'), providing specific verb+resource pairing. It distinguishes from siblings like 'drop_table' and 'drop_database' by specifying the view resource type. However, it doesn't explicitly differentiate from all siblings (e.g., doesn't mention when to use vs 'drop_table').
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. The description doesn't mention prerequisites (e.g., view must exist), when-not scenarios (e.g., irreversible destruction), or explicit alternatives among siblings like 'drop_table' or 'drop_database'. The agent receives no contextual usage instructions.
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 provided, the description carries full burden but provides minimal behavioral information. It mentions 'execute a SQL query' which implies a write operation could occur, but doesn't clarify if this tool can perform DML/DDL operations, what permissions are required, whether transactions are managed, or if there are rate limits. The return format is mentioned but not the structure 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.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably concise with clear sections for Args and Returns, but includes redundant information ('Execute a SQL query' then repeats in Args). The formatting could be more front-loaded with critical information about what types of queries can be executed and safety considerations.
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 4-parameter tool with no annotations and no output schema, the description provides basic parameter semantics and return format information. However, it lacks critical context about what happens when queries fail, whether DDL/DML operations are supported, transaction behavior, and how results are structured beyond format type.
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 significant value beyond the 0% schema description coverage by explaining all 4 parameters: query (SQL to execute), params (optional query parameters), format (output format with enum values), and limit (optional row limit). This compensates well for the schema's lack of descriptions, though it doesn't provide examples or format details for the params array.
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 executes SQL queries with optional parameters and formatting, providing a specific verb ('execute') and resource ('SQL query'). However, it doesn't explicitly differentiate from sibling tools like 'execute_transaction' or 'explain_query' which suggests similar query-related functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'execute_transaction' for transactional operations or 'explain_query' for query analysis. It mentions optional parameters but doesn't explain when they should be used or what alternatives exist among the many sibling database tools.
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 mentions the tool 'analyze' and 'provide a summary', but does not specify whether this is a read-only operation, its performance impact, authentication requirements, or output format. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior and constraints.
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 appropriately sized and front-loaded, with the core purpose stated first, followed by a clear 'Args' and 'Returns' section. Every sentence adds value, and there is no redundant information. However, the formatting with separate sections could be slightly more integrated for optimal readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (analyzing schema relationships), no annotations, no output schema, and low schema description coverage, the description is minimally adequate. It covers the basic purpose and parameter semantics but lacks details on behavioral traits, usage guidelines, and output specifics, leaving the agent with incomplete context for effective invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for the single parameter 'db_schema' by stating it is the 'Schema name (default: "public")', which clarifies its purpose beyond the schema's title 'Db Schema'. With 0% schema description coverage and only one parameter, this compensation is effective, though it could elaborate on schema naming conventions or restrictions.
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 purpose: 'Analyze the schema and provide a summary of tables, views, and relationships.' It uses specific verbs ('analyze', 'provide') and resources ('schema', 'tables, views, and relationships'), making the intent unambiguous. However, it does not explicitly differentiate from siblings like 'describe_table' or 'get_table_relationships', which might offer overlapping functionality, so it falls short of a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings such as 'describe_table', 'get_table_relationships', 'list_tables', and 'list_views', there is no indication of context, prerequisites, or exclusions. The agent must infer usage based on the tool name and description alone, which is insufficient for optimal selection.
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 states the tool 'creates' new databases, implying a write/mutation operation, but doesn't disclose critical behavioral traits such as required permissions, whether the operation is idempotent, what happens if the database already exists, or any rate limits. The mention of returning 'A success message or an error message' adds minimal value beyond the obvious.
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 appropriately sized and well-structured. It starts with a clear purpose statement, followed by dedicated sections for 'Args' and 'Returns' that are easy to parse. There's no unnecessary verbosity, and every sentence adds value (e.g., the returns section clarifies output expectations).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a write operation with no annotations and no output schema), the description is minimally adequate. It covers the purpose and parameter semantics but lacks behavioral details (e.g., permissions, idempotency) and doesn't fully explain the return values beyond generic 'success/error message.' For a mutation tool, this leaves significant gaps for the agent to navigate.
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 meaningful semantics for the single parameter: 'database_name (str): Name of the database to create.' This clarifies the parameter's purpose beyond what the schema provides (which has 0% description coverage and only shows the parameter name and type). With only one parameter, the description adequately compensates for the schema's lack of 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 clearly states the tool's purpose: 'Enable the creation of new databases.' It specifies the verb ('creation') and resource ('databases'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from siblings like 'connect_database' or 'list_databases' beyond the obvious creation vs. connection/listing distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing admin permissions), when not to use it (e.g., if a database already exists), or refer to sibling tools like 'connect_database' for existing databases. The agent must infer usage from the tool name alone.
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 provided, the description carries the full burden of behavioral disclosure. It states the action ('Drop') which implies a destructive mutation, but fails to mention critical behaviors: irreversible data loss, permission requirements, or impact on dependent objects. This is inadequate for a high-risk 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 front-loaded with the core purpose in the first sentence, followed by structured Args and Returns sections. Every sentence earns its place with no redundant information, making it highly efficient and easy to parse.
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 destructive tool with no annotations and no output schema, the description is insufficient. It doesn't explain the irreversible consequences, error conditions, or return format beyond 'success or error message'. Given the high risk and lack of structured safety hints, more context is needed.
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 meaningful context for the single parameter by specifying it's the 'Name of the database to drop', which clarifies the semantics beyond the schema's generic 'Database Name' title. With 0% schema description coverage and only one parameter, this compensates adequately, though it doesn't detail format constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Drop') and resource ('an existing database'), making the purpose unambiguous. It distinguishes from siblings like 'drop_table' or 'drop_view' by specifying database-level deletion. However, it doesn't explicitly differentiate from 'create_database' in terms of destructive nature, which would require a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'drop_table' or 'list_databases'. The description lacks context about prerequisites (e.g., database must exist, no active connections) or exclusions, leaving the agent to infer usage from the name alone.
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 full burden. It mentions transactional execution but fails to disclose critical behavioral traits: whether it requires specific permissions, if it's read-only or mutative, how errors are handled (rollback on failure?), rate limits, or what 'success message' entails. This is inadequate for a tool with potential data modification.
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 appropriately sized and front-loaded, with the core purpose stated first. The Args and Returns sections are structured but could be more integrated; overall, it avoids unnecessary verbosity while covering key aspects efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (transactional SQL execution), lack of annotations, and no output schema, the description is incomplete. It misses essential context: behavioral details (e.g., rollback, permissions), parameter constraints, and output specifics beyond 'success or error message.' This leaves significant gaps for safe and effective tool use.
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. It adds meaning by specifying 'queries' as a 'List of SQL queries to execute,' clarifying the parameter's purpose beyond the schema's basic type definition. However, it does not detail query syntax, validation rules, or constraints (e.g., supported SQL dialects), leaving gaps in parameter understanding.
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 'Execute a list of SQL queries as a single transaction,' specifying the verb (execute) and resource (SQL queries). It distinguishes from sibling 'execute_query' by emphasizing transactionality, but does not explicitly contrast with other siblings like 'bulk_import' or 'connect_database.'
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 executing multiple queries atomically, suggesting when to use it over single-query tools. However, it lacks explicit guidance on alternatives (e.g., vs. 'execute_query' for single queries or 'bulk_import' for data loads) and does not mention prerequisites like database connection or transaction contexts.
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 provided, the description carries the full burden of behavioral disclosure. It mentions that the tool returns 'the connection status or an error message', which hints at read-only behavior but doesn't explicitly state it. It fails to address critical aspects like whether this requires authentication, potential rate limits, or what specific details are included in the status, making it insufficient for a mutation-free 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 brief and front-loaded, with the core purpose stated in the first sentence and additional return information in the second. There's no wasted text, though the structure could be slightly improved by integrating the return details more seamlessly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does and what it returns, but lacks depth on behavioral context (e.g., error conditions, format of status details) that would be helpful for an agent, especially with no annotations to fill gaps.
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 0 parameters, and the schema description coverage is 100%, so there's no need for parameter details in the description. The description appropriately avoids redundant information, earning a high baseline score for this dimension.
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 purpose with a specific verb ('Get') and resource ('current connection status and details'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_active_connections' or 'get_cluster_status', which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'get_active_connections' or 'get_cluster_status'. It lacks any context about prerequisites, timing, or exclusions, leaving the agent to infer usage based on the tool name alone.
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 states the tool retrieves settings and returns 'All cluster settings', but lacks details on permissions required, rate limits, error conditions, or whether the operation is read-only (implied but not explicit). For a tool with zero annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, with the core purpose stated in the first sentence and additional return information in the second. There's no wasted text, though the structure could be slightly improved by integrating the return details more seamlessly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is minimally adequate. It explains what the tool does and what it returns, but for a tool that might involve system-level access, more context on behavioral aspects would be beneficial to compensate for the lack of annotations.
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 0 parameters, and the schema description coverage is 100% (though empty). The description doesn't need to add parameter semantics, so it meets the baseline of 4 for having no parameters to document, avoiding any gaps in this area.
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 purpose with a specific verb ('Retrieve') and resource ('current database or cluster settings'), making it easy to understand what it does. However, it doesn't explicitly distinguish itself from potential sibling tools like 'get_cluster_status' or 'get_active_connections', which might also retrieve related settings or status information.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'get_cluster_status' and 'get_active_connections' present, there's no indication of how this tool differs or when it should be preferred over those options, leaving the agent without context for selection.
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 provided, the description carries the full burden of behavioral disclosure. While 'Get' implies a read operation, the description doesn't mention important behavioral aspects like whether this requires specific permissions, what format the history is returned in, whether results are paginated, or if there are any rate limits. The return statement is minimal and lacks detail.
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 efficiently structured with a clear purpose statement followed by Args and Returns sections. Each sentence serves a purpose, though the return statement could be more informative. The formatting helps with readability without unnecessary verbosity.
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 single-parameter read tool with no annotations and no output schema, the description provides basic but incomplete coverage. It explains the parameter adequately and states the return type, but lacks details about the query history format, permissions needed, or how results are ordered. Given the simplicity of the tool, it's minimally adequate but leaves important questions unanswered.
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?
With 0% schema description coverage (the schema only shows 'limit' with type integer and default), the description adds meaningful context by explaining that 'limit' represents 'Number of recent queries to return' and specifying the default value. This compensates well for the schema's lack of description, though it doesn't elaborate on constraints like minimum/maximum values.
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 purpose: 'Get the history of executed queries.' This specifies the verb ('Get') and resource ('history of executed queries'), making it immediately understandable. However, it doesn't differentiate from potential sibling tools like 'show_running_queries' or 'execute_query' beyond the obvious historical vs current distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. There's no mention of when this tool is appropriate versus 'show_running_queries' (for current queries) or 'execute_query' (for running new queries), nor any prerequisites or context for usage.
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 states the action ('List') and return value ('Active sessions on the cluster'), but lacks details on permissions required, rate limits, whether it's read-only or has side effects, or how the data is formatted. For a tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, with the main purpose stated clearly in the first sentence and a brief return value note. There is no wasted text, and every sentence earns its place by providing essential information without 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?
Given the tool's low complexity (0 parameters, no output schema) and lack of annotations, the description is minimally adequate. It explains what the tool does and what it returns, but for a monitoring tool with potential behavioral nuances (e.g., permissions, side effects), it should provide more context. Without annotations or output schema, the description does the bare minimum to be functional.
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 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description does not need to add parameter semantics, and it appropriately avoids unnecessary details. Baseline is 4 for zero parameters, as it efficiently handles the lack of 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 states the tool's purpose with 'List active connections/sessions to the current database,' which includes a specific verb ('List') and resource ('active connections/sessions'). It distinguishes from siblings like 'get_connection_status' (which might check a single connection) and 'show_running_queries' (which focuses on queries rather than sessions). However, it doesn't explicitly differentiate from all siblings, such as 'get_cluster_status' which might overlap in scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It lacks explicit instructions on prerequisites, timing, or comparisons to siblings like 'get_connection_status' or 'show_running_queries.' The context is implied (monitoring active sessions), but no exclusions or specific use cases 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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool shows running queries but lacks details on permissions needed, rate limits, whether it's read-only or has side effects, or how results are formatted. This is inadequate for a tool that interacts with cluster data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately sized, with a clear purpose statement followed by parameter details and return information. Every sentence adds value, and it's front-loaded with the main functionality, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no annotations, no output schema), the description is partially complete. It covers parameters well but lacks behavioral context and output details. It's adequate as a minimum viable description but has clear gaps in usage and transparency.
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 significant value beyond the input schema, which has 0% description coverage. It explains each parameter's purpose, default values, and format for 'min_duration,' compensating well for the schema's lack of documentation. However, it doesn't clarify edge cases or parameter interactions.
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 purpose with 'Show currently running queries on the cluster,' which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'get_query_history' or 'analyze_performance,' which might also involve query monitoring, so it doesn't fully distinguish from alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_query_history' for past queries or 'analyze_performance' for deeper analysis, leaving the agent to infer usage context without explicit direction.
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 mentions the tool returns 'Details about range replication' but doesn't specify what those details include (e.g., replication lag, distribution metrics), whether it's a read-only operation, potential performance impacts, or error conditions. This leaves significant gaps for a tool with no annotation coverage.
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 appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by structured Args and Returns sections. There's minimal waste, though the Returns section could be slightly more informative. The structure aids readability without unnecessary verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (1 parameter, no output schema, no annotations), the description is partially complete. It covers the purpose and parameter usage adequately but lacks details on return values (beyond vague 'Details'), behavioral traits, and error handling. For a status-checking tool with no structured output, more context on what to expect would improve completeness.
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 description coverage is 0%, so the description must compensate. It adds meaningful semantics: it explains that table_name is a filter (default: '' for all tables) and clarifies its role in scoping the query to a specific table or the entire database. This goes beyond the bare schema, providing essential context for the single parameter.
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 purpose: 'Get replication and distribution status for a table or the whole database.' It uses specific verbs ('Get', 'filter') and identifies the resource ('table', 'database'), distinguishing it from siblings like get_cluster_status or get_connection_status. However, it doesn't explicitly differentiate from all siblings, such as get_table_relationships, which might also involve table metadata.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage through the Args section, stating that table_name filters results (default: '' for all tables). It provides some context for when to use the tool (to check replication status) but lacks explicit guidance on when to choose this over alternatives like get_cluster_status or get_active_connections, and doesn't mention prerequisites 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 mentions that the tool returns 'Details about the cluster's status and how nodes/ranges are distributed or an error message,' which adds some context about output and error handling. However, it lacks details on permissions, rate limits, or side effects, leaving gaps for a mutation-free but potentially complex 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 well-structured and front-loaded, with the core purpose stated first, followed by clear sections for 'Args' and 'Returns.' Every sentence adds value without redundancy, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (1 parameter, no output schema, no annotations), the description is adequate but has gaps. It covers the purpose and parameter semantics well, but lacks usage guidelines and full behavioral context (e.g., error conditions, output format details). This makes it minimally viable but not fully comprehensive.
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 significant meaning beyond the input schema, which has 0% description coverage. It explains the 'detailed' parameter's effect: 'If True, returns all node details. If False, returns summary info.' This clarifies the parameter's purpose and impact on output, compensating well for the schema's lack of descriptions.
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 purpose: 'Get cluster health and node distribution.' It uses specific verbs ('get') and identifies the resource ('cluster health and node distribution'), making the function unambiguous. However, it doesn't explicitly differentiate from siblings like 'get_replication_status' or 'get_active_connections,' which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context for use, or compare it to sibling tools like 'get_replication_status' or 'get_active_connections.' Without such guidance, users must infer usage from the purpose alone.
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 provided, the description carries full burden for behavioral disclosure. While it mentions creating a connection pool (implying a persistent resource), it doesn't describe authentication requirements, error handling, connection limits, whether the pool is shared or per-invocation, or what happens on subsequent calls. For a tool with 9 required parameters and no annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear purpose statement followed by organized parameter documentation. While comprehensive, every sentence serves a purpose - the first establishes the tool's function, and the parameter documentation is essential given the poor schema coverage. Some behavioral context could be added without sacrificing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (9 required parameters, no annotations, no output schema), the description does an excellent job with parameter semantics but lacks behavioral context about connection pooling, authentication, error handling, and relationship to sibling tools. The absence of output schema means the description should ideally explain return values more thoroughly than just 'A success message or an error message.'
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by providing detailed parameter documentation including data types, defaults, and explanations for all 9 parameters. It adds crucial context like default values, SSL mode options, and file path requirements that aren't in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Connect to a CockroachDB database and create a connection pool'), identifies the resource (CockroachDB database), and distinguishes it from sibling tools like 'connect' (which appears to be a different connection tool) and 'switch_database' (which changes an existing connection rather than creating one).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'connect' or 'switch_database', nor does it mention prerequisites or appropriate contexts for establishing a database connection. It simply states what the tool does without usage context.
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 states the tool creates tables, implying a write operation, but doesn't disclose behavioral traits like permissions needed, whether it's idempotent, if it affects existing data, or error handling specifics. The mention of 'success message or an error message' adds minimal context, but key details are missing for a mutation 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 appropriately sized and front-loaded, starting with the purpose, followed by structured sections for Args, Returns, and Example. Each sentence adds value, such as clarifying natural language use. Minor verbosity in the first paragraph slightly reduces efficiency, but overall it's well-organized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (a mutation tool with 2 parameters, no annotations, and no output schema), the description is partially complete. It covers purpose and parameters well but lacks behavioral context like side effects or error details. The absence of output schema means the description should ideally explain return values more thoroughly, which it does minimally with 'success message or an error message.'
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate. It provides detailed parameter semantics: 'table_name' is explained as the table name, and 'columns' is described with a list of dicts including required keys ('name', 'datatype') and optional ones ('constraint'), along with an example. This adds significant meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 purpose: 'Enable the creation of new tables in the current database.' It specifies the verb ('create') and resource ('tables'), and distinguishes it from siblings like 'create_database' or 'create_view' by focusing on tables. However, it doesn't explicitly differentiate from 'create_index' or 'create_view' in the same sentence, which prevents a perfect score.
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 'database setup and schema evolution' and mentions 'streamlining... through natural language,' which suggests when to use it. However, it lacks explicit guidance on when to choose this over alternatives like 'create_database' or 'create_view,' and doesn't mention prerequisites or exclusions, such as requiring an active database connection.
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 that the tool 'always with the necessary confirmations for security,' indicating a safety mechanism, and mentions it's for deletion, implying destructive behavior. However, it lacks details on permissions required, whether deletions are reversible, rate limits, or error handling specifics, leaving gaps for a mutation 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 appropriately sized with three sentences: purpose, usage context, and parameter/return info. It is front-loaded with the core action. The Args and Returns sections are structured but slightly verbose; every sentence adds value, though 'always with the necessary confirmations' could be more concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (destructive mutation), no annotations, no output schema, and low schema coverage, the description is moderately complete. It covers purpose, usage context, and parameter semantics but lacks details on behavioral aspects like error messages, confirmation processes, or integration with other tools. For a high-risk operation, more context would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 0% description coverage, so the description must compensate. It adds meaning by specifying 'table_name (str): Name of the table to drop,' which clarifies the parameter's purpose beyond the schema's basic type. Since there are no other parameters, this is sufficient, but it doesn't detail constraints like table existence or naming rules.
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 purpose as 'deletion of existing tables from the database' with a specific verb (deletion/facilitate deletion) and resource (tables). It distinguishes from siblings like drop_database, drop_index, and drop_view by specifying tables. However, it doesn't explicitly contrast with other table-related tools like create_table or describe_table, keeping it from a perfect score.
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 implied usage guidance by mentioning 'useful for cleaning up test environments or managing schema changes,' which suggests contexts for use. However, it does not explicitly state when to use this tool versus alternatives (e.g., drop_database for databases, drop_view for views) or list prerequisites like needing table existence. No explicit exclusions 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?
With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions the tool's purpose and benefits, it doesn't disclose critical behavioral traits like whether this operation requires specific permissions, if it locks the table during creation, potential performance impact during index building, or whether indexes are automatically used by queries. For a mutation tool with zero annotation coverage, this leaves significant gaps.
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 appropriately sized with a clear purpose statement followed by parameter documentation. The first sentence efficiently conveys the core functionality, and the Args/Returns sections are well-structured. While slightly longer than minimal, every section adds value given the lack of schema descriptions.
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 3 parameters with 0% schema coverage and no annotations or output schema, the description provides adequate but incomplete coverage. It documents all parameters and the general purpose, but lacks details about behavioral implications, error conditions, performance characteristics, and relationship to sibling tools. For a database mutation tool, more context about side effects and constraints would be beneficial.
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?
With 0% schema description coverage, the description compensates well by providing a parameter section that explains all three parameters: 'table_name', 'index_name', and 'columns'. It adds meaning beyond the bare schema by specifying that columns is a 'List of column names to include in the index' and clarifying the purpose of each parameter. However, it doesn't provide format examples or constraints.
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 specific action ('Create a new index'), target resource ('on a specified table'), and primary benefit ('to improve query performance'). It distinguishes this tool from siblings like 'create_table' or 'drop_index' by focusing on index creation for performance optimization rather than table/view operations or index removal.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context ('for read-heavy workloads') and mentions the purpose ('faster data retrieval and optimized execution plans'), but doesn't explicitly state when to use this tool versus alternatives like 'analyze_performance' or 'explain_query' for performance tuning. No explicit exclusions or prerequisites 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 full burden. It describes the tool's function but lacks behavioral details such as whether it's read-only, potential error conditions (e.g., if table doesn't exist), authentication needs, or rate limits. The description doesn't contradict annotations, but it's insufficient for a mutation-free tool with zero annotation coverage.
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 appropriately sized and front-loaded, starting with the core purpose. The Args and Returns sections are structured but slightly verbose; every sentence earns its place by adding value, though it could be more concise by integrating the explanatory sentence into the main description.
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 2 parameters with 0% schema coverage and no output schema, the description provides basic parameter semantics and return value overview but lacks details on output structure, error handling, or behavioral traits. It's minimally adequate for a read-only metadata tool but has clear gaps in completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds meaning by explaining table_name ('Name of the table') and db_schema ('Schema name (default: "public")'), which clarifies parameter roles beyond the schema's basic titles. However, it doesn't detail format constraints or examples for these 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 clearly states the tool's purpose with specific verbs ('provide detailed schema information') and resources ('for a specified table'), distinguishing it from siblings like list_tables (which lists tables) or get_table_relationships (which focuses on relationships). It explicitly mentions what metadata is provided (column definitions, data types, constraints, indexes).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context ('allows the AI to accurately interpret table structures and formulate precise queries'), suggesting when this tool is useful, but doesn't explicitly state when to use it versus alternatives like analyze_schema or get_table_relationships. No explicit exclusions or prerequisites 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 burden. It mentions that the tool 'bulk import data' and returns a 'success message or an error message', but does not disclose critical behavioral traits such as whether it overwrites existing data, requires specific permissions, handles errors gracefully, or has rate limits. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding its 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 well-structured and appropriately sized, with a concise opening sentence stating the purpose, followed by organized sections for Args, Returns, and Example. Every sentence adds value without redundancy, and the example illustrates usage clearly, making it easy to understand at a glance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (data import with multiple parameters) and lack of annotations or output schema, the description is moderately complete. It covers parameters well and includes an example, but lacks details on behavioral aspects (e.g., data overwrite policy, error handling) and does not explain the return value beyond 'success or error message'. For a mutation tool, this leaves room for improvement in contextual understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It provides clear semantics for all 5 parameters in the 'Args' section, explaining each parameter's purpose (e.g., 'URL to the data file', 'CSV delimiter') and default values. This adds substantial meaning beyond the bare schema, though it could include more details like URL format examples or delimiter constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('bulk import data into a table') and resources ('from a file'), distinguishing it from sibling tools like create_table or execute_query by focusing on data ingestion rather than schema manipulation or query execution. It specifies supported file formats (CSV/Avro) and storage sources (S3, Azure Blob, etc.), making the scope explicit.
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 importing data from external files into tables, but does not explicitly state when to use this tool versus alternatives (e.g., manual inserts or other import methods). It mentions supported formats and storage types, providing some context, but lacks guidance on prerequisites, limitations, or comparisons with sibling tools like execute_query for data manipulation.
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 return format ('A list of databases with row count or an error message'), which is helpful behavioral context. However, it doesn't mention potential side effects, permissions required, rate limits, or pagination behavior, leaving gaps for a tool with no annotation coverage.
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 extremely concise and front-loaded: the first sentence states the core purpose, and the second clarifies the return value. Every sentence adds value without any wasted words, making it easy for an AI agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate but minimal. It covers the basic purpose and return format, but for a tool with no structured behavioral hints, it could benefit from more context like error conditions or usage examples to be fully 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 tool has 0 parameters, and the schema description coverage is 100%, so there's no need for parameter details in the description. The description appropriately focuses on the tool's purpose and output without redundant parameter information, earning a baseline score of 4 for zero-parameter tools.
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 specific action ('List all databases') and resource ('in the CockroachDB cluster'), making the purpose immediately understandable. It distinguishes this tool from siblings like 'list_tables' or 'list_views' by specifying it returns databases rather than tables or views.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context through 'List all databases in the CockroachDB cluster,' suggesting it's for inventory purposes. However, it doesn't explicitly state when to use this tool versus alternatives like 'get_database_settings' or 'connect_database,' nor does it mention prerequisites 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 explains that the tool returns a statement plan and can execute the query with 'analyze' for statistics, covering key behavioral aspects. However, it lacks details on potential side effects (e.g., if 'analyze' affects database state), error handling, or performance implications, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a purpose statement, usage guidance, and parameter explanations in separate sections. It is appropriately sized and front-loaded, but the 'Returns' section is somewhat vague ('A success message or an error message'), slightly reducing efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a database explanation tool with 2 parameters, no annotations, and no output schema, the description is moderately complete. It covers purpose, usage, and parameters but lacks details on output format, error cases, or integration with sibling tools, which would enhance completeness for this context.
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 description coverage is 0%, so the description must compensate. It explicitly documents both parameters ('query' and 'analyze') with clear semantics: 'SQL query to explain' and 'If True, run EXPLAIN ANALYZE'. This adds significant value beyond the bare schema, though it could provide more detail on query format or analyze effects for a higher score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Return CockroachDB's statement plan for a preparable statement' and 'use this information to optimize the query'. It specifies the verb ('return'), resource ('statement plan'), and target system ('CockroachDB'), distinguishing it from siblings like execute_query or analyze_performance by focusing on query explanation rather than execution or performance analysis.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool ('to optimize the query') and mentions the 'analyze' parameter for execution statistics. However, it does not explicitly state when not to use it or name specific alternatives among the sibling tools (e.g., execute_query for actual query execution), which prevents a perfect score.
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 states the tool lists tables, implying a read-only operation, but does not mention potential side effects, permissions needed, rate limits, or error handling. It adds some context about being 'invaluable for AI' but lacks operational details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the core purpose in the first sentence. The 'Args' and 'Returns' sections are structured but slightly verbose; the second sentence ('This is invaluable...') adds value but could be more concise. Overall, it earns its place with minimal waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no output schema, no annotations), the description is fairly complete. It explains the purpose, parameter, and return value adequately. However, it lacks details on output format (e.g., structure of the list) and error cases, which would enhance completeness for a database tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate. It fully documents the single parameter (db_schema), including its type (str), default value ('public'), and purpose ('Schema name'), adding essential meaning beyond the bare input schema. This effectively covers the parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('List all tables') and resource ('connected Cockroach database instance'), distinguishing it from sibling tools like list_databases, list_views, describe_table, and get_table_relationships. It explicitly mentions the database type and scope, providing precise differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('to understand the database's landscape and identify relevant data sources'), but it does not explicitly state when not to use it or name specific alternatives. It implies usage for exploration without detailing exclusions or comparisons to similar tools like list_views.
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:

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

Score Badge

Copy to your README.md:

[![mcp-cockroachdb MCP server](https://glama.ai/mcp/servers/amineelkouhen/mcp-cockroachdb/badges/score.svg)](https://glama.ai/mcp/servers/amineelkouhen/mcp-cockroachdb)

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/amineelkouhen/mcp-cockroachdb'

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