The DBeaver MCP Server provides AI assistants with secure, universal access to 200+ database types through existing DBeaver connections with zero configuration and enterprise-grade safety features.
Connection Management: List and inspect all DBeaver database connections, get detailed connection information, test connectivity, and auto-detect DBeaver workspace (supports legacy XML and modern JSON formats, versions 6.x through 21.x+)
Data Operations: Execute read-only SELECT queries with configurable row limits (default: 1000), perform validated INSERT/UPDATE/DELETE operations, and export up to 10,000 rows to CSV, JSON, XML, or Excel formats
Schema Management: List tables and views with optional schema filtering, get detailed table schemas (columns, data types, indexes), create and alter tables using DDL statements, and drop tables with mandatory safety confirmation
Business Intelligence: Store and retrieve persistent business insights with optional tags and connection associations, get database statistics and metadata, and track analysis findings with query execution performance monitoring
Safety & Security: Built-in query validation with automatic LIMIT protection, confirmation prompts for destructive operations, secure credential management through DBeaver, configurable timeout protection (default: 30 seconds), and comprehensive error handling
Platform Support: Cross-platform compatibility (Windows, macOS, Linux), full Model Context Protocol integration with resource browsing capabilities, and debug mode for troubleshooting
Integrates with DBeaver to provide access to 200+ database types through existing DBeaver connections, allowing database querying, schema exploration, and data export functionality without additional configuration.
Provides access to MySQL databases for schema exploration and query execution through existing DBeaver connections.
Enables running queries on PostgreSQL databases through DBeaver connections, with support for data retrieval and manipulation operations.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@DBeaver MCP Server list all tables in my production PostgreSQL database"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Universal database MCP server — give AI assistants read/write access to your databases using connections already saved in your local DB client workspace (DBeaver-compatible).
Natively supported (direct driver, fast):
PostgreSQL (via pg)
MySQL / MariaDB (via mysql2)
SQL Server / MSSQL (via mssql)
SQLite (via sqlite3 CLI)
Postgres-compatible (routed through pg driver automatically):
CockroachDB, TimescaleDB, Amazon Redshift, YugabyteDB, AlloyDB, Supabase, Neon, Citus
Other databases: Fall back to an external CLI configured via OMNISQL_CLI_PATH. Results vary by CLI.
Custom drivers wrapping any of the above are detected automatically — see Custom and IAM-Authenticated Drivers.
Related MCP server: DuckDB MCP Server
Reuses connections already configured in your local DB client workspace — no duplicate setup
Native query execution for PostgreSQL, MySQL/MariaDB, SQLite, SQL Server
AWS RDS IAM authentication, including custom drivers built on the AWS Advanced JDBC Wrapper
Connection pooling with configurable pool size and timeouts
Transaction support (BEGIN/COMMIT/ROLLBACK)
Query execution plan analysis (EXPLAIN)
Schema comparison between connections with migration script generation
Read-only mode with enforced SELECT-only on execute_query
Connection whitelist to restrict which databases are accessible
Tool filtering to disable specific operations
Query validation to block dangerous operations (DROP DATABASE, TRUNCATE, DELETE/UPDATE without WHERE)
Data export to CSV/JSON
Graceful shutdown with connection pool cleanup
Node.js 18+
A local DB client (DBeaver-compatible) with at least one configured connection
npm install -g omnisql-mcpAdd to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS):
{
"mcpServers": {
"omnisql": {
"command": "omnisql-mcp"
}
}
}Add to ~/.claude/settings.json:
{
"mcpServers": {
"omnisql": {
"command": "omnisql-mcp"
}
}
}Add to Cursor Settings > MCP Servers:
{
"mcpServers": {
"omnisql": {
"command": "omnisql-mcp"
}
}
}Variable | Description | Default |
| Path to external DB client CLI (used for unsupported-driver fallback) | Unset |
| Path to local DB client workspace directory | OS default |
| Name of the DB client project/workspace folder (e.g. custom-named DBeaver project) |
|
| Query timeout (ms) |
|
| Enable debug logging |
|
| Disable all write operations |
|
| Comma-separated whitelist of connection IDs or names | All |
| Comma-separated tools to disable | None |
| Minimum connections per pool |
|
| Maximum connections per pool |
|
| Idle connection timeout (ms) |
|
| Connection acquire timeout (ms) |
|
| Path to the AWS CLI (used for RDS IAM authentication) |
|
| Timeout for minting an RDS IAM auth token (ms) |
|
| known_hosts file used to verify SSH tunnel hosts |
|
| Refuse SSH tunnel hosts with no |
|
Blocks all write operations. The execute_query tool only allows SELECT, EXPLAIN, SHOW, and DESCRIBE statements. Transaction tools are disabled entirely.
{
"mcpServers": {
"omnisql": {
"command": "omnisql-mcp",
"env": {
"OMNISQL_READ_ONLY": "true"
}
}
}
}Restrict which workspace connections are visible. Accepts connection IDs or display names, comma-separated:
{
"mcpServers": {
"omnisql": {
"command": "omnisql-mcp",
"env": {
"OMNISQL_ALLOWED_CONNECTIONS": "dev-postgres,staging-mysql"
}
}
}
}{
"mcpServers": {
"omnisql": {
"command": "omnisql-mcp",
"env": {
"OMNISQL_DISABLED_TOOLS": "drop_table,alter_table,write_query"
}
}
}
}list_connections - List all database connections
get_connection_info - Get connection details
test_connection - Test connectivity
execute_query - Run read-only queries (SELECT, EXPLAIN, SHOW, DESCRIBE only)
write_query - Run INSERT/UPDATE/DELETE
export_data - Export to CSV/JSON
list_tables - List tables and views
get_table_schema - Get table structure
create_table - Create tables
alter_table - Modify tables
drop_table - Drop tables (requires confirmation)
begin_transaction - Start a new transaction
execute_in_transaction - Execute query within a transaction
commit_transaction - Commit a transaction
rollback_transaction - Roll back a transaction
explain_query - Analyze query execution plan
compare_schemas - Compare schemas between two connections
get_pool_stats - Get connection pool statistics
get_database_stats - Database statistics
append_insight - Store analysis notes
list_insights - Retrieve stored notes
Read-only enforcement: execute_query only accepts read-only statements (SELECT, EXPLAIN, SHOW, DESCRIBE, PRAGMA). Write operations must use write_query.
Query validation: Blocks DROP DATABASE, DROP SCHEMA, TRUNCATE, DELETE/UPDATE without WHERE, GRANT, REVOKE, and user management statements.
Connection whitelist: Restrict which connections are exposed via OMNISQL_ALLOWED_CONNECTIONS.
Tool filtering: Disable any tool via OMNISQL_DISABLED_TOOLS.
Input sanitization: Connection IDs and SQL identifiers are sanitized to prevent injection.
Recommendation: For production use, also use a database-level read-only user for defense in depth.
Supports both configuration formats written by DBeaver-compatible DB clients:
Legacy: XML config in .metadata/.plugins/org.jkiss.dbeaver.core/
Modern: JSON config in General/.dbeaver/
The project/workspace folder name (General by default) is configurable via OMNISQL_PROJECT,
so workspaces using a custom or renamed DBeaver project (e.g. DataPlatform) are discovered
without needing to rename the project or symlink the folder.
DBeaver connections are configured either manually (host, port, database fields) or by
URL (a JDBC URL). Both work. In URL mode DBeaver leaves the host/port fields at placeholder
values — usually localhost — and reads only the URL, so the URL is what is used here too.
Connections that DBeaver reaches through an SSH tunnel are tunneled here as well. The tunnel is opened on first use and reused for the lifetime of the server, with a loopback-only local forward, and the connection's host/port are treated the way DBeaver treats them: as the database as seen from the SSH server.
Agent, password and public-key authentication are supported, taken from the connection's SSH tab. Credentials saved in the workspace (including the tunnel's own, stored separately from the database credentials) are decrypted and used.
Agent authentication needs SSH_AUTH_SOCK set in the MCP server's environment. MCP clients
usually do not inherit your shell, so set it explicitly in the client's server config if you
use an agent.
The SSH host key is checked against known_hosts. A host recorded there must match, or the
tunnel is refused; a host that is not recorded is accepted, unless
OMNISQL_SSH_STRICT_HOST_KEY=true.
If a tunnel cannot be opened the connection fails with that reason. It never falls back to connecting directly to the recorded host, which would reach an unrelated local database.
A connection id may carry a database override — my-connection/analytics — to run against a
different database on the same server without adding a second connection in DBeaver. This does
not apply to file-backed engines such as SQLite, where the "database" is a file path.
With OMNISQL_ALLOWED_CONNECTIONS set, whitelisting a connection allows the databases its
credentials can reach. To pin it to specific databases, list connection/database entries
instead of the bare connection.
Credentials are automatically decrypted from the workspace credentials-config.json.
Native routing normally keys off the driver id (postgres-jdbc, mysql8). Custom drivers often use an
opaque id instead — a UUID, say — which names no engine. Those connections are resolved by falling back
to the connection's provider (postgresql, mysql, …) and then to the JDBC URL's sub-protocol,
including wrapped ones such as jdbc:aws-wrapper:postgresql://…. A custom driver wrapping a supported
engine therefore works with no extra configuration.
If an engine still cannot be identified, the resulting error names both the driver id and the provider so you can see what was missing.
Connections that authenticate with an RDS IAM token instead of a stored password are detected and handled automatically. Both shapes are recognised:
AWS Advanced JDBC Wrapper drivers, which record wrapperPlugins: "iam" alongside awsProfile
and iamRegion.
The DB client's own AWS IAM auth models.
For these connections OmniSQL:
Mints a token with aws rds generate-db-auth-token (via the AWS CLI, so SSO and role-chained
profiles work as configured) and uses it as the password.
Caches each token for 13 minutes, under its 15-minute lifetime, and re-mints per physical connection so long-lived pools keep working.
Forces TLS, which RDS requires for IAM tokens.
Resolves the database username from the connection when present. Where it is absent, the username is
derived from your AWS identity: either the per-developer role name (<profile>-<user>) or the
assumed SSO session name.
Requirements: the AWS CLI on PATH (or OMNISQL_AWS_CLI_PATH), a valid session for the
connection's profile (aws sso login --profile <profile>), and network reachability to the endpoint.
An expired SSO session produces an error naming the profile to re-authenticate.
git clone https://github.com/srthkdev/omnisql-mcp.git
cd omnisql-mcp
npm install
npm run build
npm test
npm run lintMIT
Modify existing table schema (add columns, rename tables, etc.)
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | Yes | The ID or name of the DBeaver connection | |
| query | Yes | ALTER TABLE statement |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but only states what the tool does, not behavioral traits. It doesn't disclose that this is a destructive/mutative operation (modifying schemas can break applications), permission requirements, whether changes are reversible, or any rate limits/constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise single sentence with zero waste. Front-loaded with the core purpose and includes helpful examples. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive schema modification tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens on success/failure, return values, error conditions, or safety considerations despite the high-stakes nature of ALTER TABLE operations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters fully. The description adds no additional meaning about parameters beyond implying the query parameter should contain ALTER TABLE statements, which is already clear from the schema's description of 'ALTER TABLE statement'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Modify') and resource ('existing table schema') with specific examples ('add columns, rename tables, etc.'). It distinguishes from siblings like create_table (creates new) and drop_table (deletes), but doesn't explicitly contrast with execute_query which could also modify schemas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like execute_query (which could also run ALTER TABLE statements) or create_table/drop_table for other schema changes. The description implies usage for schema modifications but provides no exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Add a business insight or analysis note to the memo
| Name | Required | Description | Default |
|---|---|---|---|
| connection | No | Optional connection ID to associate with this insight | |
| insight | Yes | The business insight or analysis note to store | |
| tags | No | Optional tags to categorize the insight |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool adds insights but doesn't mention permissions needed, whether this is a write operation (implied but not explicit), potential side effects, or response format. This leaves significant gaps for a tool that likely modifies data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded with the core action, making it easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a data addition tool with no annotations and no output schema, the description is insufficient. It lacks details on behavioral traits (e.g., mutation effects, error handling) and doesn't explain what 'memo' means in this database context, leaving the agent with incomplete guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the input schema already documents all parameters (connection, insight, tags) with descriptions. The tool description doesn't add any additional meaning beyond what's in the schema, such as examples or constraints, but it doesn't need to since the schema is comprehensive.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Add') and the resource ('business insight or analysis note to the memo'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'list_insights' or 'write_query', which would require more specificity about what 'memo' refers to in this context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. For example, it doesn't clarify if this is for adding insights to an existing memo versus creating a new one, or how it differs from 'write_query' or other data manipulation tools in the sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create new tables in the database
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | Yes | The ID or name of the DBeaver connection | |
| query | Yes | CREATE TABLE statement |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Create new tables' which implies a write/mutation operation, but fails to disclose critical traits like required permissions, whether it's idempotent, error handling, or what happens on success (e.g., returns confirmation or table details). For a mutation tool with zero annotation coverage, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core purpose and appropriately sized for the tool's complexity, earning its place without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given this is a mutation tool (creating tables) with no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns, error conditions, or behavioral nuances like side effects. For a database write operation, more context is needed to guide safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema already fully documents both parameters (connectionId and query). The description adds no additional meaning beyond what's in the schema, such as query format examples or connectionId constraints. Baseline 3 is appropriate when the schema does all the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Create') and resource ('new tables in the database'), making the purpose immediately understandable. However, it doesn't distinguish this tool from its sibling 'write_query' (which might also create tables) or 'execute_query' (which could execute CREATE TABLE statements), missing full sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'execute_query' or 'write_query', nor does it mention prerequisites such as needing an existing connection. It lacks explicit when/when-not instructions or named alternatives, leaving usage context implied at best.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Remove a table from the database with safety confirmation
| Name | Required | Description | Default |
|---|---|---|---|
| confirm | Yes | Safety confirmation flag (must be true) | |
| connectionId | Yes | The ID or name of the DBeaver connection | |
| tableName | Yes | Name of the table to drop |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses the destructive nature ('Remove') and safety confirmation requirement, which is valuable. However, it doesn't mention permissions needed, whether the operation is reversible, or what happens to dependent objects, leaving behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. Every word earns its place - 'Remove' (action), 'table from the database' (resource), 'with safety confirmation' (key constraint). No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive operation with no annotations and no output schema, the description is adequate but incomplete. It covers the safety confirmation requirement but doesn't address what happens after table removal, error conditions, or return values. Given the high-stakes nature of table deletion, more context would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are well-documented in the schema. The description adds marginal value by emphasizing the safety confirmation aspect, but doesn't provide additional semantic context beyond what's already in the parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Remove') and target resource ('a table from the database'), distinguishing it from sibling tools like create_table or alter_table. It goes beyond the tool name by specifying the safety confirmation aspect.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this tool should be used for table deletion operations, but doesn't explicitly state when to use it versus alternatives like execute_query (which might also drop tables). It provides clear context about safety confirmation but lacks explicit exclusions or comparison to siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute a SQL query on a specific DBeaver connection (read-only queries)
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | Yes | The ID or name of the DBeaver connection to use | |
| maxRows | No | Maximum number of rows to return (default: 1000) | |
| query | Yes | The SQL query to execute (SELECT statements only) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses the read-only constraint and connection-specific execution, but doesn't mention authentication needs, rate limits, error handling, or what happens with large result sets beyond the maxRows parameter. It provides basic behavioral context but lacks depth for a mutation-like operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose and key constraint. Every word earns its place with zero waste, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a query execution tool with no annotations and no output schema, the description provides basic purpose and constraints but lacks information about return format, error cases, or execution limits beyond maxRows. Given the complexity of database operations and absence of structured safety hints, more context would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds marginal value by reinforcing the 'SELECT statements only' constraint for the query parameter, but doesn't provide additional semantic context beyond what's in the schema. Baseline 3 is appropriate when schema does heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Execute a SQL query'), the target resource ('on a specific DBeaver connection'), and distinguishes it from siblings by specifying 'read-only queries' (vs. write operations like create_table or drop_table). It provides verb+resource+scope differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('read-only queries'), which implicitly distinguishes it from write operations like alter_table or drop_table. However, it doesn't explicitly name alternatives or state when-not-to-use scenarios beyond the read-only constraint.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Export query results to various formats (CSV, JSON, etc.)
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | Yes | The ID or name of the DBeaver connection | |
| format | No | Export format | csv |
| includeHeaders | No | Include column headers in export | |
| maxRows | No | Maximum number of rows to export | |
| query | Yes | The SQL query to execute for export (SELECT only) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions exporting to formats but lacks critical behavioral details: whether this is a read-only operation (implied by 'export' but not confirmed), permission requirements, rate limits, file output handling, or error conditions. For a tool with 5 parameters and no annotations, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Export query results to various formats'). It avoids redundancy and wastes no words, though it could be slightly more structured (e.g., separating format examples).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (5 parameters, no annotations, no output schema), the description is incomplete. It doesn't address behavioral aspects like what happens after export (e.g., file generation, download), error handling, or integration with siblings (e.g., using execute_query first). For a data export tool with significant parameters, more context is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all 5 parameters (e.g., connectionId, format with enum, includeHeaders, maxRows, query with SELECT restriction). The description adds minimal value beyond the schema—it implies format options but doesn't elaborate on semantics. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Export') and resource ('query results'), specifying the target (various formats like CSV, JSON). It distinguishes from siblings like execute_query or write_query by focusing on export rather than execution or writing. However, it doesn't explicitly differentiate from all siblings (e.g., append_insight might also involve data handling).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid connection), exclusions (e.g., not for non-SELECT queries beyond the schema hint), or comparisons to siblings like execute_query (which might return results without export). Usage is implied but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed information about a specific DBeaver connection
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | Yes | The ID or name of the DBeaver connection |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves 'detailed information' but does not specify what that includes (e.g., configuration, status, metadata), whether it's a read-only operation, requires authentication, or has rate limits. This leaves significant gaps for a tool that likely interacts with database connections.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded with the core action and resource, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It does not explain what 'detailed information' entails, the format of the response, or potential errors, which is insufficient for a tool that likely returns structured data about database connections.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'connectionId' clearly documented as 'The ID or name of the DBeaver connection'. The description adds no additional meaning beyond this, such as format examples or constraints, but the schema provides adequate baseline information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('detailed information about a specific DBeaver connection'), making the purpose unambiguous. However, it does not explicitly differentiate from sibling tools like 'list_connections' (which likely lists all connections) or 'test_connection' (which might test connectivity), missing full sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention when to prefer 'get_connection_info' over 'list_connections' for detailed data or 'test_connection' for status checks, nor does it specify prerequisites or exclusions for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get statistics and information about a database
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | Yes | The ID or name of the DBeaver connection |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the tool retrieves statistics and information, lacking details on permissions required, rate limits, response format, or whether it's a read-only operation (though implied by 'get'). This leaves significant gaps for a tool that likely interacts with databases.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. It is front-loaded with the core purpose ('Get statistics and information about a database'), making it easy to scan and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of database operations and the lack of annotations and output schema, the description is insufficient. It doesn't explain what specific statistics are retrieved, the format of the information, or potential side effects. For a tool that likely returns structured data, more context is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'connectionId' documented as 'The ID or name of the DBeaver connection'. The description adds no additional meaning beyond this, such as explaining what statistics are returned or how the connection is used. Baseline 3 is appropriate since the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get statistics and information') and resource ('about a database'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get_connection_info' or 'get_table_schema' that also retrieve database-related information, preventing a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'get_connection_info' or 'list_tables', nor does it mention prerequisites or context for usage. It merely states what the tool does without indicating appropriate scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get schema information for a specific table
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | Yes | The ID or name of the DBeaver connection | |
| includeIndexes | No | Include index information | |
| tableName | Yes | The name of the table to describe |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. The description states it 'gets' schema information, implying a read-only operation, but doesn't specify whether this requires specific permissions, what format the output returns (e.g., JSON, structured data), or any rate limits or side effects. For a tool with no annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with zero wasted words. It's front-loaded with the core purpose ('Get schema information') and specifies the target ('for a specific table'). Every word earns its place, making it highly efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on output format, error handling, or integration with sibling tools. Without annotations or an output schema, the description should ideally provide more context about the returned schema information, but it meets the bare minimum for understanding the tool's purpose.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with all parameters well-documented in the input schema (connectionId, includeIndexes, tableName). The description doesn't add any additional semantic context beyond what the schema provides, such as explaining relationships between parameters or usage nuances. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but also doesn't detract.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'Get schema information for a specific table', which includes a specific verb ('Get') and resource ('schema information for a specific table'). It distinguishes from siblings like 'list_tables' (which lists tables) and 'create_table' (which creates tables), but doesn't explicitly differentiate from tools like 'get_connection_info' or 'get_database_stats' that also retrieve metadata.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when this tool is appropriate compared to 'list_tables' (for table enumeration) or 'execute_query' (for custom schema queries), nor does it specify prerequisites or exclusions. The agent must infer usage from the tool name and parameters alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all available DBeaver database connections
| Name | Required | Description | Default |
|---|---|---|---|
| includeDetails | No | Include detailed connection information |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. While 'List all available' implies a read-only operation, it doesn't specify whether this requires authentication, what format the output takes (e.g., list of names vs. full objects), or if there are any rate limits or performance considerations. For a tool with zero annotation coverage, this leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose with zero wasted words. It's appropriately sized for a simple listing tool and front-loaded with the essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (single optional parameter, no output schema, no annotations), the description is minimally complete. It states what the tool does but lacks behavioral details (like output format or authentication needs) and usage guidance relative to siblings. For a simple read operation, this is adequate but with clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'includeDetails' clearly documented in the schema. The description doesn't add any parameter information beyond what the schema provides, which is acceptable given the high schema coverage. The baseline score of 3 reflects adequate parameter documentation through the schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('all available DBeaver database connections'), making the purpose immediately understandable. However, it doesn't distinguish this tool from sibling tools like 'get_connection_info' or 'test_connection' that also deal with connections, missing an opportunity for sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'get_connection_info' (which might retrieve details for a specific connection) and 'test_connection' (which might verify connectivity), there's no indication of when 'list_connections' is appropriate versus these other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all stored business insights and analysis notes
| Name | Required | Description | Default |
|---|---|---|---|
| connection | No | Filter insights by connection ID (optional) | |
| tags | No | Filter insights by tags (optional) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. While 'List all' implies a read-only operation, it doesn't address important behavioral aspects like pagination, sorting, default ordering, rate limits, authentication requirements, or what 'stored' means in this context. The description is too minimal for a tool that presumably returns multiple items.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that gets straight to the point without unnecessary words. It's appropriately sized for a listing tool, though it could potentially benefit from slightly more context given the lack of annotations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a listing tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what format the insights are returned in, whether there's pagination, what fields are included, or how 'business insights and analysis notes' differ from other data types. The agent lacks crucial information to effectively use this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with both parameters clearly documented in the input schema. The description doesn't add any parameter-specific information beyond what's already in the schema. This meets the baseline of 3 when the schema does the heavy lifting for parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List') and resource ('all stored business insights and analysis notes'), making the tool's purpose immediately understandable. However, it doesn't differentiate this listing tool from other list_* siblings like list_connections or list_tables, which would require specifying what makes insights distinct from those other resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites, when this listing is appropriate versus other list_* tools, or any exclusions. The agent must infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all tables in a database
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | Yes | The ID or name of the DBeaver connection | |
| includeViews | No | Include views in the results | |
| schema | No | Specific schema to list tables from (optional) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states it's a list operation, implying read-only behavior, but doesn't mention potential side effects, authentication needs, rate limits, or what the output format looks like (e.g., pagination, error handling). This is a significant gap for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded with the core action and resource, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (a database query tool with 3 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't address what the output contains (e.g., table names, metadata), error conditions, or dependencies on other tools like 'list_connections', leaving the agent with insufficient context for reliable use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description doesn't add any meaning beyond what's in the schema (e.g., it doesn't explain why 'connectionId' is required or how 'schema' interacts with database structure), meeting the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List') and resource ('all tables in a database'), making the purpose immediately understandable. It doesn't distinguish from siblings like 'get_table_schema' or 'list_connections', but it's specific enough to avoid confusion with unrelated tools like 'execute_query' or 'create_table'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. For example, it doesn't mention how this differs from 'get_table_schema' (which might provide detailed metadata) or 'list_connections' (which lists connections rather than tables), leaving the agent to infer usage from context alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Test connectivity to a DBeaver connection
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | Yes | The ID or name of the DBeaver connection to test |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool tests connectivity but doesn't describe what 'testing' entails (e.g., whether it performs a ping, authentication check, or network test), what the expected output or error responses are, or any side effects like logging. This is inadequate for a tool that could involve network operations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence that efficiently conveys the core purpose without any wasted words. It is appropriately sized and front-loaded, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of testing connectivity (which may involve network calls, authentication, or error handling), the description is insufficient. With no annotations, no output schema, and minimal behavioral details, it doesn't provide enough context for an agent to understand how to interpret results or handle failures, making it incomplete for this type of operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the parameter 'connectionId' clearly documented as 'The ID or name of the DBeaver connection to test.' The description doesn't add any additional meaning beyond this, such as format examples or constraints, so it meets the baseline score of 3 where the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'Test connectivity to a DBeaver connection,' which is a specific verb ('test') applied to a resource ('DBeaver connection'). However, it doesn't explicitly differentiate from sibling tools like 'get_connection_info' or 'list_connections,' which might provide related but distinct functionality, preventing a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. For example, it doesn't specify if this is for diagnostic purposes, pre-operation checks, or how it differs from tools like 'get_connection_info' that might retrieve connection details without testing. This lack of context leaves the agent without clear usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute INSERT, UPDATE, or DELETE queries on a specific DBeaver connection
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | Yes | The ID or name of the DBeaver connection to use | |
| query | Yes | The SQL query to execute (INSERT, UPDATE, DELETE) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While it indicates this is a write operation, it doesn't describe important behavioral traits like transaction handling, error behavior, permission requirements, or whether changes are reversible. For a tool that can execute destructive SQL operations, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the essential information without any wasted words. It's appropriately sized and front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool that can execute potentially destructive SQL operations with no annotations and no output schema, the description is insufficient. It doesn't address critical context like what happens on execution failure, whether transactions are supported, what permissions are required, or what the return value contains.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description adds minimal value beyond what the schema provides - it mentions the query must be INSERT, UPDATE, or DELETE, which slightly clarifies the 'query' parameter's semantic constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Execute' and specifies the exact SQL operations (INSERT, UPDATE, DELETE) on a specific resource (DBeaver connection). It distinguishes from siblings like 'execute_query' by explicitly limiting to write operations rather than general query execution.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context by specifying it's for INSERT, UPDATE, or DELETE queries, which implicitly guides usage toward write operations. However, it doesn't explicitly state when NOT to use this tool or name specific alternatives like 'execute_query' for read operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Most tools have distinct purposes, but 'execute_query' and 'write_query' could cause confusion as both execute SQL queries, with the distinction being read-only vs. write operations. Other tools like 'create_table', 'alter_table', and 'drop_table' are clearly differentiated for table management.
All tools follow a consistent verb_noun naming pattern (e.g., 'create_table', 'list_connections', 'execute_query'), with no mixing of conventions like camelCase or snake_case variations. This predictability makes the tool set easy to navigate and understand.
With 14 tools, the count is well-scoped for a database management server, covering core operations like connection handling, query execution, table management, and data export. Each tool serves a specific function without redundancy, fitting the domain appropriately.
The tool set provides comprehensive coverage for database operations, including CRUD for tables, connection management, and query execution. A minor gap exists in data manipulation beyond basic queries, such as bulk operations or transaction handling, but core workflows are well-supported.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
GibsonAI MCP server: manage your databases with natural language
The BigQuery remote MCP server is a fully managed service that uses the Model Context Protocol to connect AI applications and LLMs to BigQuery data sources. It provides secure, standardized tools for AI agents to list datasets and tables, retrieve schemas, generate and execute SQL queries through natural language, and analyze data—enabling direct access to enterprise analytics data without requiring manual SQL coding.
Driflyte MCP server which lets AI assistants query topic-specific knowledge from web and GitHub.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/srthkdev/omnisql-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
