whodb-cli

Official

by clidey

Overview Schema Related Servers Score Discussions

Remote

Server Quality Checklist

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

Latest release: v0.124.0
Disambiguation4/5
Most tools have clearly distinct purposes, but there is minor overlap: whodb_tables with include_columns can return column details similar to whodb_columns, and whodb_erd also provides column metadata. Descriptions clarify the intended use case for each, preventing significant confusion.
Naming Consistency5/5
All tools follow a consistent whodb_<noun> pattern using snake_case. The naming is uniform and predictable, making it easy to infer the function of each tool.
Tool Count5/5
With 12 tools, the set is well-scoped for a database CLI. Each tool addresses a distinct need in database exploration, querying, and maintenance, without being excessive or sparse.
Completeness5/5
The toolset covers a comprehensive range: connection discovery, schema/table/column introspection, query execution with write confirmation, query explanation, schema diff, relationship mapping, data quality auditing, and starter suggestions. No significant gaps are evident for the intended domain.
Average 4.7/5 across 12 of 12 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- 8 of 8 community issues answered or closed in the last 6 months
- 593 commits in the last 12 weeks
- Last stable release on August 10, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under Apache 2.0.
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.
This repository includes a glama.json configuration file.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
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

Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true and idempotentHint=true, so the description does not need to repeat those. However, it adds valuable context: EXPLAIN output is database-specific, and the tool returns the database-native EXPLAIN output with columns and rows. This goes beyond annotations and helps the agent understand the behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is structured with clear headings (Best for, Not recommended for, Common mistakes, Usage Example, Returns). It is informative but could be slightly more concise; however, the structure aids readability and every section serves a purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the tool's purpose, usage guidelines, common mistakes, an example, and the return format. Given that an output schema exists, the description does not need to detail return values, but it still mentions the output is database-specific with columns and rows. The tool is simple and the description is sufficiently complete for an agent to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (both parameters fully described in the schema). The description does not add new semantic meaning for the parameters beyond the schema, but it provides a usage example that illustrates how to format the arguments. This is adequate but not exceptional, warranting a baseline score of 3.
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 runs EXPLAIN for a SQL query using the database's native explain mode, which is a specific verb+resource combination. It also explicitly distinguishes itself from the sibling tool whodb_query by stating that fetching actual data is not recommended and that whodb_query should be used instead.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit when-to-use guidance (best for understanding query plans, checking before running real query) and when-not-to-use guidance (not for fetching actual data, use whodb_query). It also lists common mistakes like passing non-SQL strings or forgetting database-specific output, which helps the agent avoid errors.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true and idempotentHint=true. The description adds behavioral context by listing the types of issues detected and mentioning the return format, but does not contradict annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured with clear sections (Best for, Not recommended, Common mistakes, Usage example). Concise but includes valuable example; could be slightly more compact.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (5 parameters, no nested objects, output schema exists), the description is thorough: covers purpose, usage guidelines, common mistakes, and an example. No 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 coverage is 100% (all parameters described). The description adds a usage example that illustrates parameter usage, but the schema itself already provides adequate meaning. Baseline of 3 is appropriate.
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 it runs data-quality checks on one schema or table and lists specific issues (null-rate spikes, missing primary keys, etc.). This distinguishes it from sibling tools like whodb_query or whodb_suggestions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit 'Best for' and 'Not recommended for' sections, common mistakes, and a usage example. This gives clear guidance on when and how to use the tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint and idempotentHint. The description adds value by stating it returns metadata, not row data, and describes the output as 'storage units with columns plus normalized relationship edges'. This provides behavioral context beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections and a usage example. It is front-loaded with the main purpose. However, the 'Common mistakes' section could be considered slightly redundant given the guidelines, but overall it is efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema, the description appropriately does not need to detail return values. It provides sufficient context about the nature of the output (metadata, not row data) and the tool's role in relationship discovery, making it complete for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage for both parameters, so the baseline is 3. The description includes a usage example that reinforces parameter usage, but does not add significant new semantics beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool loads backend graph metadata for a schema or database. It specifies the action (load) and resource (graph metadata), and distinguishes from siblings by stating its best use is understanding table relationships before writing joins.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly provides 'Best for' and 'Not recommended for' sections, giving clear guidance on when to use this tool versus alternatives. It also mentions common mistakes, further aiding the agent in correct invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and idempotentHint=true, so the description's behavioral burden is lighter. The description adds that the tool returns an 'Array of table objects with name and attributes' and that the optional include_columns parameter returns column details to save separate calls. However, it could mention if include_columns affects performance or cost.
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 headings ('Best for', 'Not recommended for', 'Common mistakes', 'Usage Example', 'Returns', 'Note', 'Optional parameter'). It is front-loaded with key information. However, the usage example and note could be slightly more concise; still, it is not overly verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has a moderate complexity (3 parameters, 1 required), and there is an output schema (context signal: 'Has output schema: true'), the description adequately covers return values ('Array of table objects with name and attributes') and the behavior of include_columns. It could mention edge cases (e.g., empty schema) but is sufficiently complete for an AI agent.
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 100% description coverage for all three parameters. The description adds extra context: explains that schema uses default if omitted, and that include_columns 'saves you separate whodb_columns calls and gives you everything needed to write queries in a single round-trip.' This goes beyond schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'List all tables in a database schema.' The verb 'list' and resource 'tables' are specific. It distinguishes from siblings by mentioning when to use whodb_columns or whodb_query instead, e.g., 'Not recommended for: When you already know the table name (proceed directly to whodb_columns or whodb_query).'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit when-to-use ('Best for: Discovering what tables exist...'), when-not-to-use ('Not recommended for: When you already know the table name'), and common mistakes ('Not specifying schema when the database has multiple schemas'). A usage example is included, showing the JSON structure.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint and idempotentHint. The description adds that it returns a structured schema diff with specific categories, and does not contradict annotations. No further behavioral details needed.
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?
Well-organized with clear sections (purpose, best for, not recommended, common mistakes, usage example, returns). Every sentence adds value; no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 4 parameters and existing output schema, the description fully covers usage context, including pitfalls and expected return format. No gaps identified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but the description adds value by showing a usage example and clarifying parameter roles in common mistakes, beyond the schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool compares schema metadata between two connections, with specific verb and resource. It distinguishes from siblings by specifying it's for schema-level comparison, not row-level data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly provides best-for scenarios (drift detection, staging vs prod), not-recommended (row-level data), and common mistakes (forgetting both connections, comparing same connection without overrides).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only and idempotent behavior. Description adds useful context about schema list stability and the effect of the optional include_tables parameter, but the core behavioral traits are captured by annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured with clear sections (best for, not recommended, common mistakes, example, returns, workflow). Every sentence is informative and not redundant.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple nature of the tool (2 params, list result), the description fully covers usage, alternatives, and behavioral notes. Output format is described, and annotations plus schema fill remaining 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?
Schema coverage is 100%, so baseline is 3. The description adds workflow context, example, and clarifies the optional parameter's effect, providing extra value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List all schemas (namespaces) in a database' with a specific verb and resource. It distinguishes from sibling tools by recommending whodb_tables when schema name is known.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit 'Best for', 'Not recommended for', and 'Common mistakes' sections. Names direct alternative (whodb_tables) and outlines a typical workflow.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint. Description adds context about suggestions being derived from actual storage units, returning a short list, and warns against treating them as guaranteed-valid business logic.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with clear structure: bullet points, headings, and a usage example. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given full parameter coverage, annotations, and known output schema, the description covers purpose, usage, return type, and pitfalls, making it complete for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already explains the two parameters. The description provides a usage example but no additional semantic detail beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it loads backend-generated starter queries, includes a specific verb ('Load') and resource, and distinguishes from siblings via 'Best for' and 'Not recommended for' sections.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit 'Best for' and 'Not recommended for' sections provide clear guidance on when to use (orienting in unfamiliar database) and when not to use (exhaustive SQL tutoring), plus a 'Common mistakes' caution.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the CONFIRM-WRITES security mode, explaining that write operations are not executed immediately, require a confirmation_token, and must go through whodb_confirm. It also clarifies that even write queries return results after confirmation. This adds substantial behavioral context beyond the basic readOnlyHint/destructiveHint annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is quite long but well-organized into labeled sections with code examples. Key information is front-loaded (purpose, best-for, not-recommended). While somewhat verbose, the length is justified given the tool's complexity (SQL execution, write confirmation, parameterization).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the tool's purpose, usage guidance, security mode, parameterization, common pitfalls, and alternatives. An output schema exists, so detailed return-value descriptions are unnecessary. It provides complete operational context 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?
The input schema already has 100% coverage with descriptions for all three parameters. The description enhances this with usage examples for both simple and parameterized queries, placeholder syntax per database (PostgreSQL vs. MySQL/SQLite), and best practices around parameterization. This adds practical semantics beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a clear action: 'Execute a SQL query against a database connection.' It explicitly lists supported statement types (SELECT, INSERT, UPDATE, DELETE) and differentiates from siblings by directing schema exploration to whodb_schemas, whodb_tables, and whodb_columns. This is a specific verb+resource with clear scoping.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The 'Best for' and 'Not recommended for' sections provide explicit guidance on when to use this tool versus sibling tools, naming alternatives directly. 'Common mistakes' further clarifies safe usage (e.g., specifying connection, using LIMIT). This is exemplary usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint. Description adds return structure details (array of column objects with fields like name, type, is_primary) and best practices beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured with clear sections, front-loaded purpose, every sentence adds value, no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Output schema is present but description explains it fully. Covers purpose, parameters, return format, and use cases thoroughly for a read-only metadata tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but description adds value through usage example, pro tip about connection optionality, schema default, and common mistake about forgetting table name.
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?
Clearly states 'Describe the columns in a database table' with specific verb and resource. Distinct from siblings: not for actual data (whodb_query) nor listing tables (whodb_tables).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly provides best-for, not-recommended-for, and common mistakes sections. Gives clear context for when to use and when alternatives are better.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint and idempotentHint, but the description adds valuable behavioral details: passwords are never exposed, return structure includes source ('saved' vs 'env'), and automatic fallback when only one connection. No contradictions with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with sections (Best for, Not recommended, Common mistakes, Usage Example, Returns, Note). It is concise with no unnecessary words, and the main purpose is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 0 parameters, strong annotations, and a detailed output description, the description covers all necessary information: purpose, usage guidance, return format, and edge cases. No 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?
With 0 parameters and 100% schema coverage, the description adds a usage example showing empty arguments, which is helpful. No further parameter information needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List all available database connections.' with explicit verb and resource. It distinguishes itself from sibling tools by specifying it's for discovering connections, which is unique among the listed tools like whodb_query or whodb_schemas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit 'Best for:', 'Not recommended for:', and 'Common mistakes:' sections, guiding the agent on when to use this tool (first, when connection name unknown) and when not to. Also explains automatic fallback behavior for single-connection scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond annotations (readOnlyHint, idempotentHint), description adds critical details: tokens are single-use, expire after 60 seconds, and advice to re-submit query if expired. No contradictions.
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?
Well-structured with first sentence stating purpose, bullet points for best/not recommended, usage example, return info, and important note. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no parameters, rich annotations, and existence of output schema, the description fully covers tool behavior, usage guidance, and important note on token expiry. Complete for its complexity.
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?
No parameters in input schema, so schema coverage is 100%. Description doesn't need to add param info but provides a usage example confirming no arguments, which is helpful. Baseline 4 for zero 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?
Description clearly states 'List all pending write confirmations that are waiting for approval.' It uses a specific verb 'list' and resource 'pending write confirmations', distinguishing it from siblings like whodb_confirm or whodb_query.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly provides best-for ('recovering lost confirmation tokens; checking what operations are pending') and not-recommended-for ('Anything else'), offering clear usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses critical non-obvious behaviors: tokens expire after 5 minutes, tokens are consumed only after successful execution, and retry is allowed on connection errors. This goes well beyond the annotations (which only indicate destructive/read-only hints) and provides actionable operational knowledge.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-organized with clear sections (Best for, Not recommended, Common mistakes, Example, Workflow, Token behavior) and front-loaded with purpose. Every sentence earns its place, and the structured format aids quick comprehension without unnecessary fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's role in a confirm-write workflow, the description covers the full lifecycle: initiation via whodb_query, approval explanation, token usage, expiry, and error handling. It also mentions the output schema indirectly by stating 'returns results' and provides enough context for an agent to execute correctly without missing steps.
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?
While the schema already describes token as a confirmation token, the description enriches it with lifecycle details (single-use, expiry, retry), a concrete JSON example, and workflow integration. This adds significant meaning beyond the schema's simple description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Confirm and execute a pending write operation,' which clearly identifies both the action and resource. It distinguishes itself from siblings like whodb_query (which initiates operations) and whodb_pending (which lists tokens), making it unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Contains explicit 'Best for' and 'Not recommended for' sections, stating when to use (write operations after user approval) and when not to (read queries). It also references whodb_pending as an alternative for managing tokens, giving clear decision guidance.
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:

[![whodb MCP server](https://glama.ai/mcp/servers/clidey/whodb/badges/card.svg)](https://glama.ai/mcp/servers/clidey/whodb)

Score Badge

Copy to your README.md:

[![whodb MCP server](https://glama.ai/mcp/servers/clidey/whodb/badges/score.svg)](https://glama.ai/mcp/servers/clidey/whodb)

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/clidey/whodb'

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