Data MCP server

dbmcp

Version history of discovered tools, schemas, and declared agent authority.

View watchlist

DistributionDistribution: npm
Package@haymon-ai/dbmcp
Latest analyzed version0.19.0
Current tool count8
Latest analysisNov 16, 2026
Package source

OBSERVED INTERFACE

Capability surface

Modelara’s observed declarations are shown separately from its derived effect classifications.

3 releases analyzed0.18.0 → 0.19.0Latest: 0.19.0
  • read8
  • write0
  • destructive0
  • unknown0

Unknown means Valyd could not determine the capability's effect confidently from the declared interface and static evidence. It is not treated as safe.

Package
@haymon-ai/dbmcp@0.19.0
Registry
npm
Published
Nov 16, 2026
Integrity
sha512-AElllCdpu2S3IAIi8eubbNMMov3+6XgNrHYwy3aEOpIKfMEl/HaTL3BXPux1tFxyWILon/wNf/Ceo1R5ciAX1Q==
Analyzer
modelara v0.1.8 · policy not recorded
Repository
https://github.com/haymon-ai/dbmcp

8 capabilities

CapabilityTypeDerived effectFirst observed in Valyd coverageLast changed
explainQueryhaymon-dbmcp:tool:explainQuery
Observed interface and hashes

Return the execution plan for a SQL query to diagnose performance. Use this tool instead of running EXPLAIN directly through readQuery — it provides structured output. <usecase> Use when: - A query runs slowly and you need to understand why - Investigating performance bottlenecks - Planning index creation to optimize queries - Analyzing join methods, table scan strategies, and sort operations </usecase> <when_not_to_use> - Running actual queries → use readQuery, or writeQuery for data changes (not available in read-only mode) - Checking table structure → use listTables(detailed=true) </when_not_to_use> <examples> ✓ "Why is my SELECT on orders slow?" → explainQuery(query="SELECT ...") ✓ "Should I add an index?" → explainQuery with analyze=true ✗ "Run this SELECT" → use readQuery </examples> <safety> Set `analyze` to true for actual execution statistics (EXPLAIN ANALYZE). IMPORTANT: EXPLAIN ANALYZE actually executes the query, so only read-only statements are allowed with analyze. When analyze is false, returns EXPLAIN FORMAT=JSON output without executing. Write statements are rejected: the plan is fetched in a read-only transaction. Only a single SQL statement is accepted. </safety> <what_it_returns> A JSON array of execution plan rows showing access methods, join types, row estimates, and costs. Long string values are cut and end in `…[truncated, N chars total]`, and rows past the response size cap are dropped and counted in `rowsOmitted`; when either happens the response carries `truncated: true` and a `hint`. </what_it_returns>

Input schema

{
  "properties": {
    "analyze": {
      "default": false,
      "description": "If true, use EXPLAIN ANALYZE for actual execution statistics. In read-only mode, only allowed for read-only statements. Defaults to false.",
      "type": "boolean"
    },
    "database": {
      "default": null,
      "description": "Database to explain against. Defaults to the active database.",
      "type": [
        "string",
        "null"
      ]
    },
    "query": {
      "description": "The SQL query to explain.",
      "type": "string"
    }
  },
  "required": [
    "query"
  ],
  "type": "object"
}
sha256:5c9eb86638d08507fc748ae0ef45fbe07ac2564be6bdbd37b206836d37e7eaf3

Output schema

{
  "properties": {
    "hint": {
      "description": "How to fetch less data; present only when `truncated` is `true`.",
      "type": [
        "string",
        "null"
      ]
    },
    "rows": {
      "description": "Result rows, each a JSON object keyed by a column name.",
      "items": {
        "additionalProperties": true,
        "type": "object"
      },
      "type": "array"
    },
    "rowsOmitted": {
      "description": "Rows the response cap dropped that no cursor can fetch again.",
      "format": "uint64",
      "minimum": 0,
      "type": [
        "integer",
        "null"
      ]
    },
    "truncated": {
      "description": "Present and `true` when a character cap cut a value or dropped rows.",
      "type": "boolean"
    }
  },
  "required": [
    "rows"
  ],
  "type": "object"
}
sha256:298fdeaf3ae9933a76cc3fd827a079284fc9bb757e550aa97a9f86022f2ad6d8

Description hash: sha256:54892f27e526b82274cb4b288d29a0b0478faf2486363377aa9cf584267fefe9

Interface hash: sha256:e4caf35756895f1e2b23c3c2633fb944460029f58d7e371c890926801ef8fa11

Other observed Modelara metadata
{
  "id": "mcp:dbmcp/explainQuery",
  "title": "Explain Query",
  "source": {
    "type": "mcp",
    "server": "dbmcp",
    "operation": "explainQuery"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "true",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:7a9371e7fa9264c7db118116d6847c2570b5696c2da6e9ac936ecf1cbf609428"
}
toolread0.18.00.19.0
listDatabaseshaymon-dbmcp:tool:listDatabases
Observed interface and hashes

List all accessible databases on the connected server. Use this tool to discover what databases are available before using other tools. <usecase> ALWAYS call this tool FIRST when: - You need to explore what databases exist on the server - You need a database name for listTables or query tools - The user asks what data is available </usecase> <examples> ✓ "What databases are on this server?" ✓ "Show me what's available" → call listDatabases first </examples> <what_it_returns> A sorted JSON array of database name strings. </what_it_returns> <pagination> Paginated. Pass the prior response's `nextCursor` as `cursor` to fetch the next page. </pagination>

Input schema

{
  "properties": {
    "cursor": {
      "default": null,
      "description": "Opaque cursor from a prior response's `nextCursor`; omit for the first page.",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}
sha256:9008030b75767a318fb9b2cb2cf444105f0337dcca92875cbaff72fd5a5a6519

Output schema

{
  "properties": {
    "databases": {
      "description": "Sorted list of database names for this page.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "nextCursor": {
      "description": "Opaque cursor pointing to the next page. Absent when this is the final page.",
      "type": "string"
    }
  },
  "required": [
    "databases"
  ],
  "type": "object"
}
sha256:ad6956198d5e301b3f9bf1c312499230342cb08de1630e058660a920007193b7

Description hash: sha256:9b7fe12b73399b4434d9fd4c393299aae71d23658776f0ff3a866abd5ce65c85

Interface hash: sha256:7fc16b74c38a3a0925aacd98cebc784534b5f313c4a81c7b94820d43fa8be906

Other observed Modelara metadata
{
  "id": "mcp:dbmcp/listDatabases",
  "title": "List Databases",
  "source": {
    "type": "mcp",
    "server": "dbmcp",
    "operation": "listDatabases"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "true",
    "open_world": "false"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:0ea60ca9d00449bede163bd3b02dcbd365bcf2485dd85b307c34cb651463e2d8"
}
toolread0.18.0No change observed
listFunctionshaymon-dbmcp:tool:listFunctions
Observed interface and hashes

List user-defined SQL functions in a database, optionally filtered and/or with full metadata. Loadable UDFs (`mysql.func`) and stored procedures are excluded. <usecase> Use when: - Auditing stored functions across a database (brief mode, default). - Searching for a function by partial name (pass `search`). - Inspecting a function's language, signature, return type, determinism, SQL-data-access classification, security mode, definer, comment, session context, and full reconstructed `CREATE FUNCTION` text before reasoning about correctness or invocation safety (pass `detailed: true`). Detailed mode supersedes ad-hoc `readQuery` against `information_schema.ROUTINES` / `information_schema.PARAMETERS`. </usecase> <parameters> - `database` — Database to target. Defaults to the active database. - `cursor` — Opaque pagination cursor; echo the prior response's `nextCursor`. - `search` — Case-insensitive filter on function names via `LIKE`. `%` matches any sequence; `_` matches a single character. - `detailed` — When `true`, returns full metadata objects keyed by function name instead of bare name strings. Default `false`. </parameters> <examples> ✓ "What functions are in the mydb database?" → listFunctions(database="mydb") ✓ "Find the order-total calculation" → listFunctions(search="order") ✓ "What does calc_order_total do?" → listFunctions(search="calc_order_total", detailed=true) ✗ "List stored procedures" → use listProcedures instead ✗ "List loadable UDFs from mysql.func" → not supported; only routines in information_schema.ROUTINES are returned </examples> <what_it_returns> Brief mode (default): a sorted JSON array of function-name strings, e.g. `["calc_order_subtotal", "calc_order_total", "double_it"]`. Detailed mode: a JSON object keyed by bare function name (MySQL/MariaDB do not allow function overloading, so no signature suffix is needed); each value carries `schema`, `language` (typically `"SQL"`; MariaDB external-language functions report the external language name), `arguments` (comma-separated `name type` pairs from `information_schema.PARAMETERS`, empty string for zero-parameter functions), `returnType` (full `DTD_IDENTIFIER` including length/precision/unsigned/enum/set members), `deterministic` (boolean), `sqlDataAccess` (one of `CONTAINS_SQL`, `NO_SQL`, `READS_SQL_DATA`, `MODIFIES_SQL_DATA`), `security` (`INVOKER` or `DEFINER`), `definer` (`user@host`), `description` (the `COMMENT` text or `null` when no comment was set — the empty string MySQL stores is coerced to JSON `null`), `definition` (the canonical reconstructed `CREATE FUNCTION` text including `DEFINER=` in `` `user`@`host` `` form), `sqlMode`, `characterSetClient`, `collationConnection`, and `databaseCollation`. Versus the Postgres detailed payload: `volatility`, `parallelSafety`, and `strict` are intentionally absent (no MySQL/MariaDB analogues), `owner` is renamed to `definer` (more accurate for the MySQL `DEFINER` concept), keys are bare names rather than `name(arguments)` (no overloads possible), and the four session-context fields (`sqlMode`, `characterSetClient`, `collationConnection`, `databaseCollation`) are MySQL/MariaDB-only additions. </what_it_returns> <pagination> Paginated. Pass the prior response's `nextCursor` as `cursor` to fetch the next page. The `search` filter must stay the same across pages for cursor continuity. </pagination>

Input schema

{
  "properties": {
    "cursor": {
      "default": null,
      "description": "Opaque cursor from a prior response's `nextCursor`; omit for the first page.",
      "type": [
        "string",
        "null"
      ]
    },
    "database": {
      "default": null,
      "description": "Database to list functions from. Defaults to the active database.",
      "type": [
        "string",
        "null"
      ]
    },
    "detailed": {
      "default": false,
      "description": "When `true`, each returned entry is a full metadata object (schema, language,\narguments, returnType, deterministic, sqlDataAccess, security, definer,\ndescription, definition, sqlMode, characterSetClient, collationConnection,\ndatabaseCollation); when `false` or omitted, each entry is the bare\nfunction-name string.",
      "type": "boolean"
    },
    "search": {
      "default": null,
      "description": "Optional case-insensitive filter on function names. The input is used within a `LIKE`\nclause: `%` matches any sequence of characters and `_` matches any single character.",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}
sha256:b7f37d65b2ddea36850898f7a44bf1c53cee967bdce9c15c3f42d33aa7e51277

Output schema

{
  "properties": {
    "entries": {
      "anyOf": [
        {
          "description": "Brief mode: sorted array of bare entity-name strings.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "additionalProperties": true,
          "description": "Detailed mode: name-keyed map; insertion order matches the SQL `ORDER BY` sort.",
          "type": "object"
        }
      ],
      "description": "Page of matching entries. Shape depends on the request's `detailed` flag."
    },
    "nextCursor": {
      "description": "Opaque cursor pointing to the next page. Absent when this is the final page.",
      "type": "string"
    }
  },
  "required": [
    "entries"
  ],
  "type": "object"
}
sha256:17deee57a8ee723dcb3148870391f5a07a73a46c332c5b211192f0c55c8ba27d

Description hash: sha256:2b685a6520066f05bb21414df3131100ea958fe955b27c28a652c308b5cb487f

Interface hash: sha256:cf07d8aeb992b7afd7183e593cf947a26504043f25c5e7818b12574d62878f8a

Other observed Modelara metadata
{
  "id": "mcp:dbmcp/listFunctions",
  "title": "List Functions",
  "source": {
    "type": "mcp",
    "server": "dbmcp",
    "operation": "listFunctions"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "true",
    "open_world": "false"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:77c5501415017eb6a9f56c7dae0759f89fe37bb431686e8aaefc6ce05d7c554c"
}
toolread0.18.0No change observed
listProcedureshaymon-dbmcp:tool:listProcedures
Observed interface and hashes

List user-defined stored procedures in a database, optionally filtered and/or with full metadata. Stored functions and loadable UDFs (`mysql.func`) are excluded. <usecase> Use when: - Auditing stored procedures across a database (brief mode, default). - Searching for a procedure by partial name (pass `search`). - Inspecting a procedure's language, parameter list (with `IN`/`OUT`/`INOUT` modes), determinism, SQL-data-access classification, security mode, definer, comment, session context, and full reconstructed `CREATE PROCEDURE` text before reasoning about correctness or invocation safety (pass `detailed: true`). Detailed mode supersedes ad-hoc `readQuery` against `information_schema.ROUTINES` / `information_schema.PARAMETERS`. </usecase> <parameters> - `database` — Database to target. Defaults to the active database. - `cursor` — Opaque pagination cursor; echo the prior response's `nextCursor`. - `search` — Case-insensitive filter on procedure names via `LIKE`. `%` matches any sequence; `_` matches a single character. - `detailed` — When `true`, returns full metadata objects keyed by procedure name instead of bare name strings. Default `false`. </parameters> <examples> ✓ "What procedures are in the mydb database?" → listProcedures(database="mydb") ✓ "Find the order archival routine" → listProcedures(search="archive") ✓ "What does archive_order do?" → listProcedures(search="archive_order", detailed=true) ✗ "List functions" → use listFunctions instead ✗ "List loadable UDFs from mysql.func" → not supported; only routines in information_schema.ROUTINES are returned </examples> <what_it_returns> Brief mode (default): a sorted JSON array of procedure-name strings, e.g. `["archive_order", "archive_order_history", "purge_order_archive", "touch_post"]`. Detailed mode: a JSON object keyed by bare procedure name (MySQL/MariaDB do not allow procedure overloading, so no signature suffix is needed); each value carries `schema`, `language` (typically `"SQL"`; MariaDB external-language procedures report the external language name), `arguments` (comma-separated `MODE name type` triples from `information_schema.PARAMETERS` — `MODE` is one of `IN`, `OUT`, `INOUT`; empty string for zero-parameter procedures), `deterministic` (boolean), `sqlDataAccess` (one of `CONTAINS_SQL`, `NO_SQL`, `READS_SQL_DATA`, `MODIFIES_SQL_DATA`), `security` (`INVOKER` or `DEFINER`), `definer` (`user@host`), `description` (the `COMMENT` text or `null` when no comment was set — the empty string MySQL stores is coerced to JSON `null`), `definition` (the canonical reconstructed `CREATE PROCEDURE` text including `DEFINER=` in `` `user`@`host` `` form; no `RETURNS` clause — procedures have no return type), `sqlMode`, `characterSetClient`, `collationConnection`, and `databaseCollation`. Versus the Postgres `listProcedures` detailed payload: `volatility`, `parallelSafety`, `strict`, and `returnType` are intentionally absent (no MySQL/MariaDB analogues for the first three; procedures have no return type for the fourth — the Postgres-side payload also omits all four), `owner` is renamed to `definer` (more accurate for the MySQL `DEFINER` concept), keys are bare names rather than `name(arguments)` (no overloads possible), the four session-context fields (`sqlMode`, `characterSetClient`, `collationConnection`, `databaseCollation`) are MySQL/MariaDB-only additions, and `deterministic` plus `sqlDataAccess` are MySQL/MariaDB-only additions versus the Postgres `listProcedures` detailed payload (which omits both because Postgres procedures have no equivalent attributes). </what_it_returns> <pagination> Paginated. Pass the prior response's `nextCursor` as `cursor` to fetch the next page. The `search` filter must stay the same across pages for cursor continuity. </pagination>

Input schema

{
  "properties": {
    "cursor": {
      "default": null,
      "description": "Opaque cursor from a prior response's `nextCursor`; omit for the first page.",
      "type": [
        "string",
        "null"
      ]
    },
    "database": {
      "default": null,
      "description": "Database to list procedures from. Defaults to the active database.",
      "type": [
        "string",
        "null"
      ]
    },
    "detailed": {
      "default": false,
      "description": "When `true`, each returned entry is a full metadata object (schema, language,\narguments with IN/OUT/INOUT mode tokens, deterministic, sqlDataAccess, security,\ndefiner, description, definition, sqlMode, characterSetClient,\ncollationConnection, databaseCollation); when `false` or omitted, each entry\nis the bare procedure-name string.",
      "type": "boolean"
    },
    "search": {
      "default": null,
      "description": "Optional case-insensitive filter on procedure names. The input is used within a `LIKE`\nclause: `%` matches any sequence of characters and `_` matches any single character.",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}
sha256:17b4d9b8bff89f3037a50a8b98bf26028031f26d77ab2136fa7603bc50c31b5e

Output schema

{
  "properties": {
    "entries": {
      "anyOf": [
        {
          "description": "Brief mode: sorted array of bare entity-name strings.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "additionalProperties": true,
          "description": "Detailed mode: name-keyed map; insertion order matches the SQL `ORDER BY` sort.",
          "type": "object"
        }
      ],
      "description": "Page of matching entries. Shape depends on the request's `detailed` flag."
    },
    "nextCursor": {
      "description": "Opaque cursor pointing to the next page. Absent when this is the final page.",
      "type": "string"
    }
  },
  "required": [
    "entries"
  ],
  "type": "object"
}
sha256:17deee57a8ee723dcb3148870391f5a07a73a46c332c5b211192f0c55c8ba27d

Description hash: sha256:d724afa1a54d70da0a16966b1f78b8d86f874087f4a88a58460b9776ad7c2abd

Interface hash: sha256:cc6c76538d2b977547585a3eeb617b2dc4bed9534e8c3fa3cac654471b0e1b7a

Other observed Modelara metadata
{
  "id": "mcp:dbmcp/listProcedures",
  "title": "List Procedures",
  "source": {
    "type": "mcp",
    "server": "dbmcp",
    "operation": "listProcedures"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "true",
    "open_world": "false"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:985fbbb18f72aba567651f71547b138b4dda482c5741381f79fb544362d3d6c1"
}
toolread0.18.0No change observed
listTableshaymon-dbmcp:tool:listTables
Observed interface and hashes

List tables in a database, optionally filtered and/or with full metadata. <usecase> Use when: - Exploring a database to find relevant tables (brief mode, default). - Searching for a table by partial name (pass `search`). - Inspecting a table's columns, constraints, indexes, and triggers before writing a query (pass `detailed: true`). </usecase> <parameters> - `database` — Database to target. Defaults to the active database. - `cursor` — Opaque pagination cursor; echo the prior response's `nextCursor`. - `search` — Case-insensitive filter on table names via `LIKE`. `%` matches any sequence; `_` matches a single character. - `detailed` — When `true`, returns full metadata objects keyed by table name instead of bare name strings. Default `false`. </parameters> <examples> ✓ "What tables are in mydb?" → listTables(database="mydb") ✓ "Find the orders table" → listTables(search="order") ✓ "What columns does orders have?" → listTables(search="orders", detailed=true) </examples> <what_it_returns> Brief mode (default): a sorted JSON array of table-name strings, e.g. `["customers", "orders"]`. Detailed mode: a JSON object keyed by table name; each value carries `schema`, `kind`, `owner`, `comment`, `columns`, `constraints`, `indexes`, and `triggers` (the name is the key and is not repeated inside the value). Keys iterate in the same alphabetical order brief mode uses. Example: `{"orders": {"schema": "mydb", "kind": "TABLE", …}}`. </what_it_returns> <pagination> Paginated. Pass the prior response's `nextCursor` as `cursor` to fetch the next page. The `search` filter must stay the same across pages for cursor continuity. </pagination>

Input schema

{
  "properties": {
    "cursor": {
      "default": null,
      "description": "Opaque cursor from a prior response's `nextCursor`; omit for the first page.",
      "type": [
        "string",
        "null"
      ]
    },
    "database": {
      "default": null,
      "description": "Database to list tables from. Defaults to the active database.",
      "type": [
        "string",
        "null"
      ]
    },
    "detailed": {
      "default": false,
      "description": "When `true`, each returned entry is a full metadata object (columns,\nconstraints, indexes, triggers, owner, comment, kind); when `false` or\nomitted, each entry is the bare table-name string.",
      "type": "boolean"
    },
    "search": {
      "default": null,
      "description": "Optional case-insensitive filter on table names. The input is used within a `LIKE`\nclause: `%` matches any sequence of characters and `_` matches any single character.",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}
sha256:9a7849de585a58c6c4a0aff6bcd893486c470afc0a7f45487d3ddcfcc29bfd33

Output schema

{
  "properties": {
    "entries": {
      "anyOf": [
        {
          "description": "Brief mode: sorted array of bare entity-name strings.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "additionalProperties": true,
          "description": "Detailed mode: name-keyed map; insertion order matches the SQL `ORDER BY` sort.",
          "type": "object"
        }
      ],
      "description": "Page of matching entries. Shape depends on the request's `detailed` flag."
    },
    "nextCursor": {
      "description": "Opaque cursor pointing to the next page. Absent when this is the final page.",
      "type": "string"
    }
  },
  "required": [
    "entries"
  ],
  "type": "object"
}
sha256:17deee57a8ee723dcb3148870391f5a07a73a46c332c5b211192f0c55c8ba27d

Description hash: sha256:b8877235ab71493fe576e60818c9c89d4d1b05ac17be5466ee91e84fd422e6c2

Interface hash: sha256:8d061435c9a5d2f334b1cb7bf9b8b54d36f076afd0503d5b6219b1ea0861e291

Other observed Modelara metadata
{
  "id": "mcp:dbmcp/listTables",
  "title": "List Tables",
  "source": {
    "type": "mcp",
    "server": "dbmcp",
    "operation": "listTables"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "true",
    "open_world": "false"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:a0ed3b844f3d97523c937bf3d1e4b8c87bf2d9536840d065790402fb613e5b20"
}
toolread0.18.0No change observed
listTriggershaymon-dbmcp:tool:listTriggers
Observed interface and hashes

List user-defined triggers in a database, optionally filtered and/or with full metadata. <usecase> Use when: - Auditing trigger coverage across a database (brief mode, default). - Searching for a trigger by partial name (pass `search`). - Inspecting a trigger's timing, event, activation level, full `CREATE TRIGGER` text, and the session context active at trigger-creation time before reasoning about side-effects (pass `detailed: true`). Detailed mode supersedes ad-hoc `readQuery` against `information_schema.TRIGGERS`. </usecase> <parameters> - `database` — Database to target. Defaults to the active database. - `cursor` — Opaque pagination cursor; echo the prior response's `nextCursor`. - `search` — Case-insensitive filter on trigger names via `LIKE`. `%` matches any sequence; `_` matches a single character. - `detailed` — When `true`, returns full metadata objects keyed by trigger name instead of bare name strings. Default `false`. </parameters> <examples> ✓ "What triggers are in the mydb database?" → listTriggers(database="mydb") ✓ "Find the audit triggers" → listTriggers(search="audit") ✓ "What does orders_audit_after_insert do?" → listTriggers(search="orders_audit_after_insert", detailed=true) ✗ "Show me a trigger's body" → use detailed mode; the `definition` field carries the full `CREATE TRIGGER` text </examples> <what_it_returns> Brief mode (default): a sorted JSON array of trigger-name strings, e.g. `["customers_audit_after_insert", "orders_audit_after_insert"]`. Detailed mode: a JSON object keyed by trigger name; each value carries `schema`, `table`, `timing` (BEFORE/AFTER), `events` (single-element array — `INSERT`, `UPDATE`, or `DELETE`), `activationLevel` (always `ROW` on MySQL/MariaDB), `definition` (the canonical `CREATE TRIGGER` text including `DEFINER=` in `` `user`@`host` `` form), `sqlMode`, `characterSetClient`, `collationConnection`, and `databaseCollation`. The Postgres-only `status` and `functionName` fields are intentionally absent (no per-trigger enabled/disabled flag and no separate handler-function reference on MySQL/MariaDB); the four session-context fields are MySQL/MariaDB-only additions versus the Postgres detailed payload. </what_it_returns> <pagination> Paginated. Pass the prior response's `nextCursor` as `cursor` to fetch the next page. The `search` filter must stay the same across pages for cursor continuity. </pagination>

Input schema

{
  "properties": {
    "cursor": {
      "default": null,
      "description": "Opaque cursor from a prior response's `nextCursor`; omit for the first page.",
      "type": [
        "string",
        "null"
      ]
    },
    "database": {
      "default": null,
      "description": "Database to list triggers from. Defaults to the active database.",
      "type": [
        "string",
        "null"
      ]
    },
    "detailed": {
      "default": false,
      "description": "When `true`, each returned entry is a full metadata object (schema, table, timing,\nevents, activationLevel, definition, plus backend-specific fields); when `false` or\nomitted, each entry is the bare trigger-name string.",
      "type": "boolean"
    },
    "search": {
      "default": null,
      "description": "Optional case-insensitive filter on trigger names. The input is used within a `LIKE`\nclause: `%` matches any sequence of characters and `_` matches any single character.",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}
sha256:185159c7e34274bc598f91181da7b69b0fd4aee11a860e8dc2c96e070c543c72

Output schema

{
  "properties": {
    "entries": {
      "anyOf": [
        {
          "description": "Brief mode: sorted array of bare entity-name strings.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "additionalProperties": true,
          "description": "Detailed mode: name-keyed map; insertion order matches the SQL `ORDER BY` sort.",
          "type": "object"
        }
      ],
      "description": "Page of matching entries. Shape depends on the request's `detailed` flag."
    },
    "nextCursor": {
      "description": "Opaque cursor pointing to the next page. Absent when this is the final page.",
      "type": "string"
    }
  },
  "required": [
    "entries"
  ],
  "type": "object"
}
sha256:17deee57a8ee723dcb3148870391f5a07a73a46c332c5b211192f0c55c8ba27d

Description hash: sha256:9abd9cb8276a8c3b6f9922c2521162fe73b903224588f07b4f7fd55aba66fba6

Interface hash: sha256:1bf5e22363d6be26d92b305b489aac539d844b582346d789f8f6d6b57b27600a

Other observed Modelara metadata
{
  "id": "mcp:dbmcp/listTriggers",
  "title": "List Triggers",
  "source": {
    "type": "mcp",
    "server": "dbmcp",
    "operation": "listTriggers"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "true",
    "open_world": "false"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:372c5b6219021eea7702a8c93c93f768da214d3ffd2c950480e113e464c647cc"
}
toolread0.18.0No change observed
listViewshaymon-dbmcp:tool:listViews
Observed interface and hashes

List user-defined views in a database, optionally filtered and/or with full metadata. Base tables and system-schema views are excluded. <usecase> Use when: - Auditing views across a database (brief mode, default). - Searching for a view by partial name (pass `search`). - Inspecting a view's definer, security mode, check-option level, updatable flag, session character set/collation, and full SELECT body before querying it (pass `detailed: true`). Detailed mode supersedes ad-hoc `readQuery` against `information_schema.VIEWS`. </usecase> <parameters> - `database` — Database to target. Defaults to the active database. - `cursor` — Opaque pagination cursor; echo the prior response's `nextCursor`. - `search` — Case-insensitive filter on view names via `LIKE`. `%` matches any sequence; `_` matches a single character. - `detailed` — When `true`, returns full metadata objects keyed by view name instead of bare name strings. Default `false`. </parameters> <examples> ✓ "What views are in the mydb database?" → listViews(database="mydb") ✓ "Find the active-users view" → listViews(search="active") ✓ "What does active_users select?" → listViews(search="active_users", detailed=true) ✗ "Show me the columns of a view" → use listTables with `detailed: true` instead ✗ "List materialized views" → MySQL/MariaDB have no materialized-view concept </examples> <what_it_returns> Brief mode (default): a sorted JSON array of view-name strings, e.g. `["active_orders", "active_users", "published_posts"]`. Detailed mode: a JSON object keyed by bare view name; each value carries `schema`, `definer` (`user@host`), `security` (`INVOKER` or `DEFINER`), `checkOption` (`NONE`, `CASCADED`, or `LOCAL`), `updatable` (boolean), `characterSetClient`, `collationConnection`, and `definition` (the SELECT body verbatim from `information_schema.VIEWS.VIEW_DEFINITION`, with no `CREATE VIEW` wrapper). The view name is the map key only — it is not repeated inside the value. Versus the Postgres `listViews` detailed payload: `description` is intentionally absent (neither MySQL nor MariaDB exposes a user-comment column for views — `CREATE VIEW` syntax has no `COMMENT` clause), `algorithm` is intentionally absent (MariaDB-only column on `information_schema.VIEWS`), `owner` is renamed to `definer` (more accurate for the MySQL `DEFINER` concept), and the five MySQL/MariaDB-only structured fields (`security`, `checkOption`, `updatable`, `characterSetClient`, `collationConnection`) are added. The `definition` field shape is byte-identical to Postgres — raw SELECT body verbatim, no DDL wrapper. When the connected role lacks the `SHOW VIEW` privilege on a particular view, the engine redacts `VIEW_DEFINITION` to the empty string; the row remains in the response with `definition` reflecting that empty value. </what_it_returns> <pagination> Paginated. Pass the prior response's `nextCursor` as `cursor` to fetch the next page. The `search` filter must stay the same across pages for cursor continuity. Brief and detailed modes share the same `TABLE_NAME` row order, so a client can switch `detailed` between pages without losing position. </pagination>

Input schema

{
  "properties": {
    "cursor": {
      "default": null,
      "description": "Opaque cursor from a prior response's `nextCursor`; omit for the first page.",
      "type": [
        "string",
        "null"
      ]
    },
    "database": {
      "default": null,
      "description": "Database to list views from. Defaults to the active database.",
      "type": [
        "string",
        "null"
      ]
    },
    "detailed": {
      "default": false,
      "description": "When `true`, each returned entry is a full metadata object (schema, definer,\nsecurity, checkOption, updatable, characterSetClient, collationConnection,\ndefinition); when `false` or omitted, each entry is the bare view-name string.",
      "type": "boolean"
    },
    "search": {
      "default": null,
      "description": "Optional case-insensitive filter on view names. The input is used within a `LIKE`\nclause: `%` matches any sequence of characters and `_` matches any single character.",
      "type": [
        "string",
        "null"
      ]
    }
  },
  "type": "object"
}
sha256:00ca76677e1c81f69370ab241f849f579abc2d2f70831d1a33de1942390977eb

Output schema

{
  "properties": {
    "entries": {
      "anyOf": [
        {
          "description": "Brief mode: sorted array of bare entity-name strings.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        {
          "additionalProperties": true,
          "description": "Detailed mode: name-keyed map; insertion order matches the SQL `ORDER BY` sort.",
          "type": "object"
        }
      ],
      "description": "Page of matching entries. Shape depends on the request's `detailed` flag."
    },
    "nextCursor": {
      "description": "Opaque cursor pointing to the next page. Absent when this is the final page.",
      "type": "string"
    }
  },
  "required": [
    "entries"
  ],
  "type": "object"
}
sha256:17deee57a8ee723dcb3148870391f5a07a73a46c332c5b211192f0c55c8ba27d

Description hash: sha256:af31be251e773ffa34ab06555e08c512a15f1edf0cbb6406861c2e7ec6a6c4d5

Interface hash: sha256:4444accca354968ccd5668a1138cbb2a09ce670f773236a423859673968825ed

Other observed Modelara metadata
{
  "id": "mcp:dbmcp/listViews",
  "title": "List Views",
  "source": {
    "type": "mcp",
    "server": "dbmcp",
    "operation": "listViews"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "true",
    "open_world": "false"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:f6adb671b24a06bdc2769b6da44be8e3d12b4979dcc076bd40be82267bb382f6"
}
toolread0.18.0No change observed
readQueryhaymon-dbmcp:tool:readQuery
Observed interface and hashes

Execute a read-only SQL query. Allowed statements: SELECT, SHOW, DESCRIBE, EXPLAIN. <usecase> Use when: - Querying data from tables (SELECT with WHERE, JOIN, GROUP BY, etc.) - Aggregations: COUNT, SUM, AVG, GROUP BY, HAVING - Listing server variables or status (SHOW) - Viewing table structure (DESCRIBE) </usecase> <when_not_to_use> - Data changes (INSERT, UPDATE, DELETE) → use writeQuery (not available in read-only mode) - Query performance analysis → use explainQuery - Discovering tables or columns → use listTables (pass detailed=true for column-level metadata) - Switching database context (USE is rejected) → pass the `database` argument </when_not_to_use> <examples> ✓ "SELECT * FROM users WHERE status = 'active'" ✓ "SELECT COUNT(*) FROM orders GROUP BY region" ✓ "SHOW TABLES" or "DESCRIBE users" ✗ "INSERT INTO users ..." → use writeQuery (not available in read-only mode) ✗ "EXPLAIN SELECT ..." → use explainQuery for structured analysis </examples> <what_it_returns> A JSON array of row objects, each keyed by column name. Long string values are cut and end in `…[truncated, N chars total]`; read the rest with `SUBSTRING`/`SUBSTR`. Rows past the response size cap are dropped: a `SELECT` page ends early and `nextCursor` resumes at the first row left out, while other statements report the count in `rowsOmitted`. When either happens the response carries `truncated: true` and a `hint`. </what_it_returns> <pagination> `SELECT` results are paginated. Pass the prior response's `nextCursor` as `cursor` to fetch the next page. Order by a unique key so pages neither skip nor repeat rows. Pages stay within the statement's own `LIMIT` and `OFFSET`. Write a row limit as a literal `LIMIT n`: other forms (`FETCH FIRST`, expressions) make every page read the whole result. `SHOW`, `DESCRIBE`, and `EXPLAIN` return a single page and ignore `cursor`. </pagination> <timeout> Each call stops at the configured query timeout. On a timeout, check the plan with explainQuery before retrying: filter on indexed columns, or limit inner result sets before joining or aggregating. For a query known to be slow, pass `timeout` (seconds, at least 1) to allow more time. This only helps if the server allows a higher maximum, which is often the same as the default; a value above it is rejected with an error naming the maximum. </timeout>

Input schema

{
  "properties": {
    "cursor": {
      "default": null,
      "description": "Opaque cursor from a prior response's `nextCursor`; omit for the first page.",
      "type": [
        "string",
        "null"
      ]
    },
    "database": {
      "default": null,
      "description": "Database to run the query against. Defaults to the active database.",
      "type": [
        "string",
        "null"
      ]
    },
    "query": {
      "description": "The SQL query to execute.",
      "type": "string"
    },
    "timeout": {
      "default": null,
      "description": "Seconds this call may run, from 1 up to the server maximum. Defaults to the configured query timeout.",
      "format": "uint64",
      "minimum": 1,
      "type": [
        "integer",
        "null"
      ]
    }
  },
  "required": [
    "query"
  ],
  "type": "object"
}
sha256:cd507ff6a3b1cbd852bcdba947b971fe4a3ad4ae70bcaf0caa67f3cd04cef204

Output schema

{
  "properties": {
    "hint": {
      "description": "How to fetch less data; present only when `truncated` is `true`.",
      "type": [
        "string",
        "null"
      ]
    },
    "nextCursor": {
      "description": "Opaque cursor pointing to the next page. Absent when this is the final\npage, when the result fits in one page, or when the statement is a\nnon-`SELECT` kind that does not paginate (e.g. `SHOW`, `EXPLAIN`).",
      "type": "string"
    },
    "rows": {
      "description": "Result rows, each a JSON object keyed by a column name.",
      "items": {
        "additionalProperties": true,
        "type": "object"
      },
      "type": "array"
    },
    "rowsOmitted": {
      "description": "Rows the response cap dropped that no cursor can fetch again.",
      "format": "uint64",
      "minimum": 0,
      "type": [
        "integer",
        "null"
      ]
    },
    "truncated": {
      "description": "Present and `true` when a character cap cut a value or dropped rows.",
      "type": "boolean"
    }
  },
  "required": [
    "rows"
  ],
  "type": "object"
}
sha256:999feb2ae8d32aab91030cb9c6f1ffa7c18de6779187e5ddf2e4344c34e4d1de

Description hash: sha256:c503cffae5adb6f3c06f718c9bad21b1955c4ba59d10dbcb485a67aa7e047d26

Interface hash: sha256:badfd04e1dee2060a34f46e5adf465ea7a325c8cba02bb7d0046309d5024ad45

Other observed Modelara metadata
{
  "id": "mcp:dbmcp/readQuery",
  "title": "Read Query",
  "source": {
    "type": "mcp",
    "server": "dbmcp",
    "operation": "readQuery"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "true",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:d8c9f4f6a7d4936e3cf3908e726b0607cec5384e8526def10fef373530ee44d1"
}
toolread0.18.00.19.0

STATIC COMPARISONS

Release history

2 release transitions
  1. 0 added0 removed0 schema0 write0 destructive0 unknown

    Nov 16, 2026· Automated static analysis

  2. 0 added0 removed0 schema0 write0 destructive0 unknown

    Nov 16, 2026· Automated static analysis