Multi-database Model Context Protocol server providing AI assistants with structured database access to MySQL, PostgreSQL, SQLite, Oracle, and TimescaleDB
This server has 17 tools with mixed quality. Strengths: all tools have names starting with verbs, descriptions present, and input schemas visible in code. Critical weaknesses: (1) Parameters across all tools lack type definitions in the visible schema, only bare string descriptions like 'SQL query to execute' without 'type': 'string' declarations; (2) Output schemas are completely undocumented, no agent knows what fields to expect from query(), execute(), or transaction() responses; (3) Descriptions are functional but minimal (avg ~50-100 chars), lacking WHEN to use each tool and recovery guidance; (4) No error handling patterns visible, tools don't guide LLMs on retryability or what to do on failure; (5) Dangerous patterns: transaction() takes 'action' as a free-form string when it should be an enum (begin|commit|rollback|execute); performance() and timescaledb tools expose raw database parameters (iterations, bucket_interval) without validation constraints or min/max guidance; (6) Security: list() exposes arbitrary filesystem access via path parameter with no visible sanitization or permission checks, LLMs could traverse outside intended directories; (7) TimescaleDB tools use string enums in descriptions ('must be time_series_query') rather than formal enum types, inviting hallucination; (8) No pagination on list operations, schema() and filter_tables() could return thousands of items, blowing context windows. Per-tool analysis shows most tools cluster around 40-50 overall due to missing output documentation and weak parameter constraints.
Get table structure and metadata (columns, types, constraints)
Execute a DML statement (INSERT, UPDATE, DELETE) against the database
Get query execution plan and EXPLAIN output
Filter and search tables across the database
Check database connection health and status
List files and directories in a given path
Analyze query performance and execution metrics
Output schemas completely undocumented. Tools like query(), execute(), transaction(), describe(), schema() have no visible documentation of what fields are returned. LLMs cannot plan downstream calls or extract required data.
Input parameter schemas lack formal type definitions. Parameters are described as strings (e.g. 'SQL query to execute') but schema JSON does not include explicit 'type': 'string' or constraint declarations. Parameters like 'iterations', 'bucket_interval', 'limit' have no min/max bounds documented.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-22 | D | 58 | 2026-07-28+ | v2 |
| 2026-03-09 | D | 54 | - | v1 |
Execute a SELECT query against the database
Get database schema information (tables, views, indexes)
Analyze time-series data with advanced aggregation and statistical functions
Get compression settings for TimescaleDB hypertable
Get information about a specific TimescaleDB continuous aggregate
List TimescaleDB continuous aggregates
List TimescaleDB hypertables
Manage TimescaleDB retention policies
Execute time-series queries on TimescaleDB
Execute database operations within a transaction
transaction() 'action' parameter accepts free-form strings when it should declare an enum (begin, commit, rollback, execute). LLMs will hallucinate invalid actions like 'abort', 'save', 'suspend'.
list() tool exposes arbitrary filesystem path access with no visible input validation, permission checks, or sanitization against path traversal (../../etc/passwd). Poses security risk if called by untrusted agents.
TimescaleDB tools use magic string values in parameter descriptions ('must be time_series_query', 'must be one of: add_retention_policy...') instead of formal enum types. Invites hallucination and does not self-document valid choices.
No pagination visible on list-returning tools (schema(), filter_tables(), describe()). Can return thousands of items, blowing context windows. No documented limit or offset/cursor parameters.
No error handling guidance visible. Tools do not document what errors are retryable, what requires user input, or what recovery steps to take. Descriptions lack recovery hints like 'If query fails due to syntax error, check EXPLAIN output with explain() tool.'
Tool descriptions are minimal (~50-100 chars average) and lack WHEN to use guidance. E.g., 'Execute a SELECT query' does not explain when to call query() vs explain() vs performance(). Descriptions should help LLMs disambiguate similar tools.
Destructive tools (execute with DELETE/UPDATE, transaction with rollback) have risk field but no dry-run support or confirmation pattern. Agents can issue DELETE statements without preview or undo capability.
performance() tool allows unbounded 'iterations' parameter (benchmarking query N times). No documented min/max. LLMs could pass iterations=10000, causing denial of service on the database.