Skip to main content
Glama
deenesjakoruzh
clidey

whodb-cli

Official
by clidey
OverviewSchemaRelated ServersScoreDiscussions
Go
Remote

WhoDB

MCP Toplist

A lightweight, self-hosted workspace for your databases

Release workflow Release version Release date Total downloads Docker size

Commits per month Last commit Contributors Closed issues Closed PRs

License GitHub stars Go TypeScript

Available on

Docker Windows macOS Snap CLI

Quick start · Documentation · Live demo · Community

WhoDB gives you one place to explore your databases, edit data, run queries, and understand how a schema fits together. It runs in the browser, is easy to self-host, and is available as a desktop app or terminal CLI too.

Use it when you want to inspect a local database, help a teammate explore unfamiliar data, or work without installing a heavyweight database client. AI features are optional: connect Ollama, OpenAI, Anthropic, LM Studio, or another OpenAI-compatible provider if you want to ask questions in plain English.

Related MCP server: supabase-mcp

Quick start

Run WhoDB with Docker:

docker run --rm -it -p 8080:8080 clidey/whodb

Then open http://localhost:8080 and enter your database connection details.

Want to look around first? Try the live demo or watch the video walkthrough.

What you can do

  • Browse and edit data in a spreadsheet-style grid with sorting, filtering, pagination, and inline editing.

  • Understand a schema visually with an interactive graph of tables and relationships.

  • Work through queries in a scratchpad with multiple cells, autocomplete, history, and results kept alongside each query.

  • Move data in and out with imports, exports, and mock-data generation for development and testing.

  • Ask questions in plain English using a local or hosted AI provider that you choose.

  • Work from your terminal through the WhoDB CLI and its MCP server.

Supported databases

WhoDB Community supports:

  • PostgreSQL, CockroachDB, YugabyteDB, and QuestDB

  • MySQL, MariaDB, and TiDB

  • SQLite and DuckDB

  • MongoDB and FerretDB

  • Redis, Valkey, and Dragonfly

  • Elasticsearch and OpenSearch

  • ClickHouse and Memcached

Support varies by database because not every system has the same concepts or capabilities. The connection screen shows the options available for each source.

Installation options

Docker with persistent sessions

The one-line Docker command is ideal for trying WhoDB. To keep encrypted login sessions when the container is replaced, first generate a key and save it somewhere secure:

openssl rand -hex 32

Then mount /data and reuse that key whenever you start the container:

docker run -it -p 8080:8080 \
  -v whodb-data:/data \
  -e WHODB_ENCRYPTION_KEY=your_saved_64_character_hex_key \
  clidey/whodb

Keep that key somewhere safe. Changing it invalidates existing sessions. If WhoDB is served through an HTTPS reverse proxy, also set WHODB_SECURE=true so browsers only send the session cookie over HTTPS.

See the documentation for Docker Compose, connection profiles, SSL, AI providers, and other configuration options.

Desktop

CLI and MCP server

The CLI includes an interactive terminal UI and an MCP server for AI tools:

# macOS and Linux
curl -fsSL https://raw.githubusercontent.com/clidey/whodb/main/cli/install/install.sh | bash

# or install with npm
npm install -g @clidey/whodb
whodb             # open the terminal UI
whodb mcp serve   # start the MCP server

See the CLI guide for connection examples and the full command reference.

AI providers

You can add a hosted AI provider directly from WhoDB—no backend configuration or restart is required. Open Chat, choose Add Provider from the provider menu, then select OpenAI, Anthropic, or Gemini and enter your API key. WhoDB will fetch the available models from that provider.

Ollama and LM Studio are available as local options in WhoDB Community. By default, the backend looks for Ollama at localhost:11434 and LM Studio at localhost:1234/v1, with local addresses adjusted automatically for Docker and WSL. Use WHODB_OLLAMA_HOST, WHODB_OLLAMA_PORT, or WHODB_LMSTUDIO_BASE_URL only when those defaults are not suitable for your setup.

Optional backend provider configuration

Environment variables let deployment administrators declare providers when the server starts. This is useful for preconfiguring OpenAI or Anthropic, changing provider endpoints, or adding an OpenAI-compatible service for everyone using that deployment:

  • WHODB_OPENAI_* for OpenAI

  • WHODB_ANTHROPIC_* for Anthropic

  • WHODB_OLLAMA_* for Ollama connection settings

  • WHODB_LMSTUDIO_* for LM Studio connection settings

  • WHODB_AI_GENERIC_<ID>_* for OpenAI-compatible providers

See the installation guide for the complete environment variable list and the AI provider guide for setup examples.

WhoDB Community and WhoDB Platform

This repository contains WhoDB Community, the Apache-2.0-licensed database workspace described above. It is free to self-host and is the best place to start if you want to explore and work with databases.

WhoDB Platform is the commercial, self-hosted edition for organizations that need shared projects, more data sources, SSO, fine-grained access controls, audit logs, pipelines, reporting, and internal apps. You can read the WhoDB overview or compare plans on the pricing page.

Development

WhoDB has a Go backend and a React/TypeScript frontend. For local development, run them in separate terminals.

Requirements:

  • Go

  • Node.js and pnpm

Start the backend:

cd core
go run ./cmd/whodb

Start the frontend:

cd frontend
pnpm install
pnpm start

The frontend opens at http://localhost:3000 and talks to the backend on port 8080. See the CE build and run guide for generation and build commands.

Contributing

Bug reports, feature ideas, documentation improvements, and code contributions are all welcome.

More screenshots

Query scratchpad

Add and edit records

Build filters visually

Export data

Support

WhoDB is licensed under the Apache License 2.0.

If WhoDB saves you time, consider giving the project a star.

Available Tools

12 tools
whodb_auditA
Read-onlyIdempotent

Run data-quality checks on one schema or table.

Best for: Finding null-rate spikes, missing primary keys, low-cardinality issues, duplicate rows, and orphaned foreign keys. Not recommended for: Replacing a full observability or data-governance system. Common mistakes: Forgetting to scope the audit to one table when you only need one table.

Usage Example:

{
  "name": "whodb_audit",
  "arguments": {
    "connection": "mydb",
    "schema": "public",
    "table": "orders",
    "null_warning": 15,
    "null_error": 60
  }
}

Returns: Audit results per table, including issue summaries and the underlying table/column findings.

ParametersJSON Schema
NameRequiredDescriptionDefault
tableNoOptional table name
schemaNoSchema or database name override
connectionYesConnection name (optional if only one exists)
null_errorNoError threshold for null percentage
null_warningNoWarning threshold for null percentage

Output Schema

ParametersJSON Schema
NameRequiredDescription
errorNo
resultsYes
summaryYes
request_idNo

TDQS

A4.4/5.0
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.

whodb_columnsA
Read-onlyIdempotent

Describe the columns in a database table.

Best for: Understanding table structure before writing queries; discovering primary keys and foreign key relationships. Not recommended for: When you need actual data (use whodb_query with SELECT). Common mistakes: Forgetting to specify the table name; not using this before writing INSERT/UPDATE queries.

Usage Example:

{
  "name": "whodb_columns",
  "arguments": {
    "connection": "mydb",
    "table": "users",
    "schema": "public"
  }
}

Returns: Array of column objects with:

  • name: Column name

  • type: Data type (varchar, integer, timestamp, etc.)

  • is_primary: Whether this is a primary key

  • is_foreign_key: Whether this references another table

  • referenced_table/referenced_column: Foreign key target (if applicable)

Pro tip: Always call this before writing INSERT queries to ensure correct column names and types.

ParametersJSON Schema
NameRequiredDescriptionDefault
tableYesTable name to describe
schemaNoSchema name (uses default if omitted)
connectionYesConnection name (optional if only one exists)

Output Schema

ParametersJSON Schema
NameRequiredDescription
errorNo
tableYes
schemaYes
columnsYes
request_idNo

TDQS

A4.9/5.0
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.

whodb_confirmA
Destructive

Confirm and execute a pending write operation.

Best for: Executing write queries after user approval in confirm-writes mode. Not recommended for: Read queries (they execute immediately without confirmation). Common mistakes: Using an expired token (tokens expire after 5 minutes); not explaining the query to the user before confirming.

Usage Example:

{
  "name": "whodb_confirm",
  "arguments": {
    "token": "550e8400-e29b-41d4-a716-446655440000"
  }
}

Workflow:

  1. Call whodb_query with a write operation (INSERT, UPDATE, DELETE, etc.)

  2. Receive confirmation_required=true, a confirmation_token, and confirmation_expiry

  3. Explain to the user what the query will do in plain language

  4. After user approves, call whodb_confirm with the token

  5. Query executes and returns results

Token behavior: Tokens are valid for 5 minutes (expiry time is in the response). If confirmation fails due to a connection error or timeout, you can retry with the same token — it is only consumed after successful execution. Use whodb_pending to list active tokens if you lose track.

ParametersJSON Schema
NameRequiredDescriptionDefault
tokenYesConfirmation token from a previous whodb_query or hosted platform write response

Output Schema

ParametersJSON Schema
NameRequiredDescription
rowsYes
errorNo
columnsYes
messageNo
commandsNo
next_stepsNo
request_idNo
column_typesNo
setup_statusNo

TDQS

A5/5.0
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.

whodb_connectionsA
Read-onlyIdempotent

List all available database connections.

Best for: Discovering what databases are configured; choosing which connection to use. Not recommended for: When you already know the connection name. Common mistakes: Not calling this first when connection name is unknown.

Usage Example:

{
  "name": "whodb_connections",
  "arguments": {}
}

Returns: Array of connection objects with:

  • name: Connection identifier to use in other tools

  • type: Database type (postgres, mysql, sqlite, duckdb, etc.)

  • host/port/database: Connection details (passwords are never exposed)

  • source: "saved" (from CLI config) or "env" (from environment variables)

Note: If only one connection exists, other tools will use it automatically when connection is omitted.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription
errorNo
request_idNo
connectionsYes

TDQS

A4.9/5.0
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.

whodb_diffA
Read-onlyIdempotent

Compare schema metadata between two database connections.

Best for: Spotting drift between environments; comparing staging vs production; reviewing storage-unit, column, and relationship changes. Not recommended for: Row-level data comparison. Common mistakes: Forgetting to specify both connections; comparing the same connection and schema without overrides.

Usage Example:

{
  "name": "whodb_diff",
  "arguments": {
    "from_connection": "staging",
    "to_connection": "prod",
    "from_schema": "public",
    "to_schema": "public"
  }
}

Returns: A structured schema diff with storage-unit, column, and relationship summaries plus per-object changes.

ParametersJSON Schema
NameRequiredDescriptionDefault
to_schemaNoTarget schema override
from_schemaNoSource schema override
to_connectionYesTarget connection name
from_connectionYesSource connection name

Output Schema

ParametersJSON Schema
NameRequiredDescription
errorNo
resultNo
request_idNo

TDQS

A4.7/5.0
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.

whodb_erdA
Read-onlyIdempotent

Load backend graph metadata for a schema or database.

Best for: Understanding how tables relate before writing joins; inspecting primary/foreign key relationships programmatically. Not recommended for: Query execution. Common mistakes: Expecting row data instead of metadata.

Usage Example:

{
  "name": "whodb_erd",
  "arguments": {
    "connection": "mydb",
    "schema": "public"
  }
}

Returns: Storage units with columns plus normalized relationship edges sourced from backend graph metadata.

ParametersJSON Schema
NameRequiredDescriptionDefault
schemaNoSchema or database name override
connectionYesConnection name (optional if only one exists)

Output Schema

ParametersJSON Schema
NameRequiredDescription
errorNo
schemaNo
request_idNo
relationshipsYes
storage_unitsYes

TDQS

A4.4/5.0
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.

whodb_explainA
Read-onlyIdempotent

Run EXPLAIN for a SQL query using the database's native explain mode.

Best for: Understanding query plans; checking whether a query will scan too much data before you run the real query. Not recommended for: Fetching actual data (use whodb_query for that). Common mistakes: Passing a non-SQL string; forgetting that EXPLAIN output is database-specific.

Usage Example:

{
  "name": "whodb_explain",
  "arguments": {
    "connection": "mydb",
    "query": "SELECT * FROM users WHERE email LIKE '%@example.com' LIMIT 10"
  }
}

Returns: The database-native EXPLAIN output with columns and rows, ready for follow-up analysis.

ParametersJSON Schema
NameRequiredDescriptionDefault
queryYesSQL query to explain
connectionYesConnection name (optional if only one exists)

Output Schema

ParametersJSON Schema
NameRequiredDescription
rowsYes
errorNo
columnsYes
request_idNo
column_typesNo

TDQS

A4.3/5.0
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.

whodb_pendingA
Read-onlyIdempotent

List all pending write confirmations that are waiting for approval.

Best for: Recovering lost confirmation tokens; checking what operations are pending. Not recommended for: Anything else — this is a utility tool for the confirm-writes workflow.

Usage Example:

{
  "name": "whodb_pending",
  "arguments": {}
}

Returns: Array of pending confirmations with token, query, connection, and expiry time.

Important: Tokens are single-use and expire after 60 seconds. If expired, re-submit the original query to get a new token.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription
errorNo
pendingYes
request_idNo

TDQS

A4.9/5.0
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.

whodb_queryA

Execute a SQL query against a database connection.

Best for: Running SQL SELECT, INSERT, UPDATE, DELETE statements when you need to query or modify data. Not recommended for: Schema exploration (use whodb_schemas, whodb_tables, whodb_columns instead for faster, structured results). Common mistakes: Running queries without specifying connection when multiple exist; using SELECT * instead of specific columns; forgetting LIMIT on large tables.

Usage Example (simple query):

{
  "name": "whodb_query",
  "arguments": {
    "connection": "mydb",
    "query": "SELECT id, name, email FROM users WHERE active = true LIMIT 10"
  }
}

Usage Example (parameterized query - RECOMMENDED for user input):

{
  "name": "whodb_query",
  "arguments": {
    "connection": "mydb",
    "query": "SELECT * FROM users WHERE id = $1 AND status = $2",
    "parameters": [123, "active"]
  }
}

Placeholder syntax by database: PostgreSQL uses $1, $2, $3; MySQL/SQLite/DuckDB/ClickHouse use ?

Best practices:

  • Use parameterized queries when incorporating user-provided values - this prevents SQL injection

  • Always use LIMIT for exploratory queries to avoid overwhelming results

  • Prefer specific column selection over SELECT *

  • Check schema structure with whodb_columns before writing complex queries

Security Mode: CONFIRM-WRITES (Default) Write operations (INSERT, UPDATE, DELETE, etc.) require user confirmation. When you submit a write query:

  1. The query is validated but NOT executed

  2. You receive a confirmation_token

  3. Explain to the user what the query will do

  4. Call whodb_confirm with the token after user approves

  5. The query executes and returns results

ParametersJSON Schema
NameRequiredDescriptionDefault
queryYesSQL query to execute
connectionYesConnection name (optional if only one exists)
parametersNoParameterized query values ($1/$2 for Postgres or ? for MySQL/SQLite)

Output Schema

ParametersJSON Schema
NameRequiredDescription
rowsYes
errorNo
columnsYes
warningNo
request_idNo
column_typesNo
confirmation_queryNo
confirmation_tokenNo
confirmation_expiryNo
confirmation_requiredNo

TDQS

A4.8/5.0
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.

whodb_schemasA
Read-onlyIdempotent

List all schemas (namespaces) in a database.

Best for: Discovering what schemas exist in a database; understanding database organization before exploring tables. Not recommended for: When you already know the schema name (proceed directly to whodb_tables). Common mistakes: Calling this repeatedly - schema lists rarely change during a session.

Usage Example:

{
  "name": "whodb_schemas",
  "arguments": {
    "connection": "mydb"
  }
}

Returns: Array of schema names (e.g., ["public", "analytics", "audit"]). Typical workflow: whodb_schemas → whodb_tables(include_columns=true) → whodb_query

Optional parameter: Set "include_tables": true to also return all tables within each schema in a single call. This populates a "details" array with schema names and their tables, saving you a separate whodb_tables call per schema.

ParametersJSON Schema
NameRequiredDescriptionDefault
connectionYesConnection name (optional if only one exists)
include_tablesNoSet true to also return tables within each schema in a single call

Output Schema

ParametersJSON Schema
NameRequiredDescription
errorNo
detailsNo
schemasYes
request_idNo

TDQS

A4.7/5.0
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.

whodb_suggestionsA
Read-onlyIdempotent

Load backend-generated starter queries for a schema or database.

Best for: Quickly orienting yourself in an unfamiliar database; suggesting first queries for exploration. Not recommended for: Exhaustive SQL tutoring. Common mistakes: Treating the suggestions as guaranteed-valid business logic rather than onboarding hints.

Usage Example:

{
  "name": "whodb_suggestions",
  "arguments": {
    "connection": "mydb",
    "schema": "public"
  }
}

Returns: A short list of backend-generated query suggestions derived from the actual storage units in the resolved schema.

ParametersJSON Schema
NameRequiredDescriptionDefault
schemaNoSchema or database name override
connectionYesConnection name (optional if only one exists)

Output Schema

ParametersJSON Schema
NameRequiredDescription
errorNo
request_idNo
suggestionsYes

TDQS

A4.7/5.0
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.

whodb_tablesA
Read-onlyIdempotent

List all tables in a database schema.

Best for: Discovering what tables exist in a schema; getting table metadata like row counts. Not recommended for: When you already know the table name (proceed directly to whodb_columns or whodb_query). Common mistakes: Not specifying schema when the database has multiple schemas with same-named tables.

Usage Example:

{
  "name": "whodb_tables",
  "arguments": {
    "connection": "mydb",
    "schema": "public"
  }
}

Returns: Array of table objects with name and attributes (row count, size, etc.). Note: If schema is omitted, uses the connection's default schema or the first available schema.

Optional parameter: Set "include_columns": true to also return column details (name, type, primary key, foreign keys) for each table. This saves you separate whodb_columns calls and gives you everything needed to write queries in a single round-trip.

ParametersJSON Schema
NameRequiredDescriptionDefault
schemaNoSchema name (uses default if omitted)
connectionYesConnection name (optional if only one exists)
include_columnsNoSet true to also return column details for each table in a single call

Output Schema

ParametersJSON Schema
NameRequiredDescription
errorNo
schemaYes
tablesYes
request_idNo

TDQS

A4.5/5.0
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.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 1 tool updatev0.120.0
    • Changedwhodb_confirm3 fields changed
      • addedOutput schema / properties / commands
        Added value: +{
+  "items": {
+    "type": "string"
+  },
+  "type": [
+    "null",
+    "array"
+  ]
+}
      • addedOutput schema / properties / next_steps
        Added value: +{
+  "items": {
+    "type": "string"
+  },
+  "type": [
+    "null",
+    "array"
+  ]
+}
      • addedOutput schema / properties / setup_status
        Added value: +{
+  "type": "string"
+}
  2. 2 tool updatesv0.115.0
    • Changedwhodb_confirm1 field changed
      • changedInput schema / properties / token / description
        Previous value: -"Confirmation token from a previous whodb_query response"New value: +"Confirmation token from a previous whodb_query or hosted platform write response"
    • Changedwhodb_pending1 field changed
      • changedOutput schema / properties / pending / items / required
        Previous value: -[
-  "token",
-  "query",
-  "connection",
-  "expires_at"
-]New value: +[
+  "token",
+  "expires_at"
+]
  3. 12 tool updatesv0.112.0
    • Addedwhodb_audit
    • Addedwhodb_columns
    • Addedwhodb_confirm
    • Addedwhodb_connections
    • Addedwhodb_diff
    • Addedwhodb_erd
    • Addedwhodb_explain
    • Addedwhodb_pending
    • Addedwhodb_query
    • Addedwhodb_schemas
    • Addedwhodb_suggestions
    • Addedwhodb_tables
  4. 12 tool updatesv0.108.0
    • Removedwhodb_audit
    • Removedwhodb_columns
    • Removedwhodb_confirm
    • Removedwhodb_connections
    • Removedwhodb_diff
    • Removedwhodb_erd
    • Removedwhodb_explain
    • Removedwhodb_pending
    • Removedwhodb_query
    • Removedwhodb_schemas
    • Removedwhodb_suggestions
    • Removedwhodb_tables
  5. 12 tool updatesv0.107.0
    • First observedwhodb_audit
    • First observedwhodb_columns
    • First observedwhodb_confirm
    • First observedwhodb_connections
    • First observedwhodb_diff
    • First observedwhodb_erd
    • First observedwhodb_explain
    • First observedwhodb_pending
    • First observedwhodb_query
    • First observedwhodb_schemas
    • First observedwhodb_suggestions
    • First observedwhodb_tables
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.6/5.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.

Maintenance

ActivityActive
ResponsivenessWithin a week

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

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