Skip to main content
Glama
yaoxiaolinglong

MCP-MongoDB-MySQL-Server

by yaoxiaolinglong
OverviewSchemaRelated ServersScoreDiscussions
JavaScript
Hybrid

MCP-MongoDB-MySQL-Server

GitHub stars GitHub forks GitHub license

这是一个基于 enemyrr/mcp-mysql-server 项目的二次开发版本，添加了MongoDB支持。

This is a fork of enemyrr/mcp-mysql-server with added MongoDB support.

项目简介 | Introduction

这是一个Model Context Protocol服务器，提供MySQL和MongoDB数据库操作功能。该服务器使AI模型能够通过标准化接口与MySQL和MongoDB数据库交互。

A Model Context Protocol server that provides MySQL and MongoDB database operations. This server enables AI models to interact with MySQL and MongoDB databases through a standardized interface.

Related MCP server: MongoDB MCP Server

二次开发说明 | About This Fork

作者 | Author: yaoxiaolinglong

二次开发原因 | Reason for Fork: 原项目只支持MySQL数据库，但在实际应用中经常需要使用MongoDB。由于找不到现成的MongoDB MCP工具，因此在原项目基础上添加了MongoDB支持，使其成为一个同时支持MySQL和MongoDB的数据库服务器。

The original project only supports MySQL database, but MongoDB is often needed in practical applications. Due to the lack of ready-made MongoDB MCP tools, MongoDB support was added to the original project, making it a database server that supports both MySQL and MongoDB.

安装与设置 | Installation & Setup for Cursor IDE

通过Smithery安装 | Installing via Smithery

通过Smithery为Claude Desktop自动安装MySQL/MongoDB数据库服务器：

To install MySQL/MongoDB Database Server for Claude Desktop automatically via Smithery:

npx -y @smithery/cli install @yaoxiaolinglong/mcp-mongodb-mysql-server --client claude

手动安装 | Installing Manually

  1. 克隆并构建项目 | Clone and build the project:

git clone https://github.com/yaoxiaolinglong/mcp-mongodb-mysql-server.git
cd mcp-mongodb-mysql-server
npm install
npm run build

  1. 在Cursor IDE设置中添加服务器 | Add the server in Cursor IDE settings:

    • 打开命令面板(Cmd/Ctrl + Shift + P) | Open Command Palette (Cmd/Ctrl + Shift + P)

    • 搜索"MCP: Add Server" | Search for "MCP: Add Server"

    • 填写以下字段 | Fill in the fields:

      • 名称 | Name: mysql-mongodb

      • 类型 | Type: command

      • 命令 | Command: node /absolute/path/to/mcp-mongodb-mysql-server/build/index.js

注意 | Note: 将/absolute/path/to/替换为您克隆并构建项目的实际路径。

Replace /absolute/path/to/ with the actual path where you cloned and built the project.

数据库配置 | Database Configuration

MySQL配置 | MySQL Configuration

您可以通过以下三种方式配置MySQL数据库连接：

You can configure the MySQL database connection in three ways:

  1. .env文件中的数据库URL（推荐）| Database URL in .env (Recommended):

DATABASE_URL=mysql://user:password@host:3306/database

  1. .env文件中的单独参数 | Individual Parameters in .env:

DB_HOST=localhost
DB_USER=your_user
DB_PASSWORD=your_password
DB_DATABASE=your_database

  1. 通过工具直接连接 | Direct Connection via Tool:

use_mcp_tool({
  server_name: "mysql-mongodb",
  tool_name: "connect_db",
  arguments: {
    url: "mysql://user:password@host:3306/database"
    // 或者 | OR
    workspace: "/path/to/your/project" // 将使用项目的.env文件 | Will use project's .env
    // 或者 | OR
    host: "localhost",
    user: "your_user",
    password: "your_password",
    database: "your_database"
  }
});

MongoDB配置 | MongoDB Configuration

您可以通过以下三种方式配置MongoDB数据库连接：

You can configure the MongoDB database connection in three ways:

  1. .env文件中的MongoDB URL（推荐）| MongoDB URL in .env (Recommended):

MONGODB_URI=mongodb://user:password@host:27017/database
MONGODB_DATABASE=your_database

  1. 通过工具直接连接 | Direct Connection via Tool:

use_mcp_tool({
  server_name: "mysql-mongodb",
  tool_name: "connect_mongodb",
  arguments: {
    url: "mongodb://user:password@host:27017/database"
    // 或者 | OR
    workspace: "/path/to/your/project" // 将使用项目的.env文件 | Will use project's .env
    // 或者 | OR
    database: "your_database" // 将使用默认连接URI | Will use default connection URI
  }
});

可用工具 | Available Tools

MySQL工具 | MySQL Tools

1. connect_db

连接到MySQL数据库，使用URL、工作区路径或直接凭据。

Connect to MySQL database using URL, workspace path, or direct credentials.

2. query

执行SELECT查询，支持可选的预处理语句参数。

Execute SELECT queries with optional prepared statement parameters.

use_mcp_tool({
  server_name: "mysql-mongodb",
  tool_name: "query",
  arguments: {
    sql: "SELECT * FROM users WHERE id = ?",
    params: [1]
  }
});

3. execute

执行INSERT、UPDATE或DELETE查询，支持可选的预处理语句参数。

Execute INSERT, UPDATE, or DELETE queries with optional prepared statement parameters.

use_mcp_tool({
  server_name: "mysql-mongodb",
  tool_name: "execute",
  arguments: {
    sql: "INSERT INTO users (name, email) VALUES (?, ?)",
    params: ["John Doe", "john@example.com"]
  }
});

4. list_tables

列出连接的数据库中的所有表。

List all tables in the connected database.

use_mcp_tool({
  server_name: "mysql-mongodb",
  tool_name: "list_tables"
});

5. describe_table

获取特定表的结构。

Get the structure of a specific table.

use_mcp_tool({
  server_name: "mysql-mongodb",
  tool_name: "describe_table",
  arguments: {
    table: "users"
  }
});

6. create_table

创建一个新表，指定字段和索引。

Create a new table with specified fields and indexes.

use_mcp_tool({
  server_name: "mysql-mongodb",
  tool_name: "create_table",
  arguments: {
    table: "users",
    fields: [
      {
        name: "id",
        type: "int",
        autoIncrement: true,
        primary: true
      },
      {
        name: "email",
        type: "varchar",
        length: 255,
        nullable: false
      }
    ],
    indexes: [
      {
        name: "email_idx",
        columns: ["email"],
        unique: true
      }
    ]
  }
});

7. add_column

向现有表添加新列。

Add a new column to an existing table.

use_mcp_tool({
  server_name: "mysql-mongodb",
  tool_name: "add_column",
  arguments: {
    table: "users",
    field: {
      name: "phone",
      type: "varchar",
      length: 20,
      nullable: true
    }
  }
});

MongoDB工具 | MongoDB Tools

1. connect_mongodb

连接到MongoDB数据库，使用URL、工作区路径或数据库名称。

Connect to MongoDB database using URL, workspace path, or database name.

use_mcp_tool({
  server_name: "mysql-mongodb",
  tool_name: "connect_mongodb",
  arguments: {
    url: "mongodb://user:password@host:27017/database"
  }
});

2. mongodb_list_collections

列出连接的MongoDB数据库中的所有集合。

List all collections in the connected MongoDB database.

use_mcp_tool({
  server_name: "mysql-mongodb",
  tool_name: "mongodb_list_collections"
});

3. mongodb_find

在MongoDB集合中查找文档，支持可选的过滤器、限制、跳过和排序。

Find documents in a MongoDB collection with optional filter, limit, skip, and sort.

use_mcp_tool({
  server_name: "mysql-mongodb",
  tool_name: "mongodb_find",
  arguments: {
    collection: "users",
    filter: { age: { $gt: 18 } },
    limit: 10,
    skip: 0,
    sort: { name: 1 }
  }
});

4. mongodb_insert

向MongoDB集合中插入文档。

Insert documents into a MongoDB collection.

use_mcp_tool({
  server_name: "mysql-mongodb",
  tool_name: "mongodb_insert",
  arguments: {
    collection: "users",
    documents: [
      { name: "John Doe", email: "john@example.com", age: 30 },
      { name: "Jane Smith", email: "jane@example.com", age: 25 }
    ]
  }
});

5. mongodb_update

更新MongoDB集合中的文档。

Update documents in a MongoDB collection.

use_mcp_tool({
  server_name: "mysql-mongodb",
  tool_name: "mongodb_update",
  arguments: {
    collection: "users",
    filter: { name: "John Doe" },
    update: { $set: { age: 31 } },
    many: false // 只更新一个文档（默认）| Update only one document (default)
  }
});

6. mongodb_delete

从MongoDB集合中删除文档。

Delete documents from a MongoDB collection.

use_mcp_tool({
  server_name: "mysql-mongodb",
  tool_name: "mongodb_delete",
  arguments: {
    collection: "users",
    filter: { name: "John Doe" },
    many: false // 只删除一个文档（默认）| Delete only one document (default)
  }
});

7. mongodb_create_collection

在MongoDB中创建新集合。

Create a new collection in MongoDB.

use_mcp_tool({
  server_name: "mysql-mongodb",
  tool_name: "mongodb_create_collection",
  arguments: {
    collection: "new_collection",
    options: { capped: true, size: 1000000 }
  }
});

功能特点 | Features

  • 多种连接方法（URL、工作区、直接参数）| Multiple connection methods (URL, workspace, direct)

  • 同时支持MySQL和MongoDB数据库 | Support for both MySQL and MongoDB databases

  • 安全的连接处理和自动清理 | Secure connection handling with automatic cleanup

  • MySQL查询参数的预处理语句支持 | Prepared statement support for MySQL query parameters

  • 两种数据库的架构管理工具 | Schema management tools for both databases

  • 全面的错误处理和验证 | Comprehensive error handling and validation

  • TypeScript支持 | TypeScript support

  • 自动工作区检测 | Automatic workspace detection

安全性 | Security

  • 在MySQL中使用预处理语句防止SQL注入 | Uses prepared statements to prevent SQL injection in MySQL

  • 通过环境变量支持安全密码处理 | Supports secure password handling through environment variables

  • 执行前验证查询和操作 | Validates queries and operations before execution

  • 自动关闭连接 | Automatically closes connections when done

错误处理 | Error Handling

服务器提供以下详细错误消息：| The server provides detailed error messages for:

  • 连接失败 | Connection failures

  • 无效的查询或参数 | Invalid queries or parameters

  • 缺少配置 | Missing configuration

  • 数据库错误 | Database errors

  • 架构验证错误 | Schema validation errors

贡献 | Contributing

欢迎贡献！请随时提交Pull Request到 https://github.com/yaoxiaolinglong/mcp-mongodb-mysql-server

Contributions are welcome! Please feel free to submit a Pull Request to https://github.com/yaoxiaolinglong/mcp-mongodb-mysql-server

致谢 | Acknowledgements

本项目基于 enemyrr/mcp-mysql-server 开发，感谢原作者的贡献。

This project is based on enemyrr/mcp-mysql-server. Thanks to the original author for their contribution.

许可证 | License

MIT

Available Tools

14 tools
add_columnC

Add a new column to existing table

ParametersJSON Schema
NameRequiredDescriptionDefault
tableYes
fieldYes

TDQS

C2.8/5.0
Behavior2/5

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. 'Add a new column' implies a write/mutation operation, but the description doesn't cover critical aspects: whether this requires specific permissions, if it's reversible, potential side effects (e.g., locking the table), or error conditions. For a schema-altering tool with zero annotation coverage, 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.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with zero wasted words—it directly states the tool's purpose. Every word earns its place, making it highly efficient and easy to parse. No extraneous details or redundancy are present, which is ideal for conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (schema-altering operation with nested parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't address behavioral traits, parameter meanings, return values, or error handling. For a tool that modifies database schemas, this minimal description leaves too many gaps for safe and effective use by an AI agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, meaning parameters are undocumented in the schema. The description mentions 'table' and 'field' implicitly but adds no semantic details: it doesn't explain what 'table' refers to (e.g., table name), what 'field' encompasses (e.g., column definition with properties like type), or provide examples. With two required parameters and nested objects, the description fails to compensate for the lack of schema documentation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Add') and resource ('new column to existing table'), making the purpose immediately understandable. It distinguishes from siblings like 'create_table' (creates new tables) and 'describe_table' (reads metadata). However, it doesn't specify the database system or context, which could help differentiate from similar tools in other contexts.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 an existing table), exclusions (e.g., not for modifying existing columns), or sibling tools like 'execute' (which might handle SQL directly) or 'create_table' (for initial schema). Without this context, 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.

connect_dbC

Connect to MySQL database using URL or config

ParametersJSON Schema
NameRequiredDescriptionDefault
urlNoDatabase URL (mysql://user:pass@host:port/db)
workspaceNoProject workspace path
hostNo
userNo
passwordNo
databaseNo

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden but only states the basic action. It doesn't disclose whether this establishes a persistent connection, requires authentication, has timeout/rate limits, returns a connection object, or what happens on failure. For a connection tool with zero annotation coverage, this leaves critical behavioral aspects unspecified.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Extremely concise single sentence with zero wasted words. Front-loaded with the core purpose. Every word earns its place in this minimal description.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a connection tool with 6 parameters, 0% required parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what a successful connection yields, error conditions, or how parameters interact. The agent lacks sufficient context to use this tool effectively.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is low (33%), with only 'url' parameter documented. The description adds value by clarifying the two connection methods ('URL or config'), which helps interpret the parameter set, but doesn't explain the relationship between URL and individual config parameters (host, user, etc.) or which approach is preferred.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Connect to MySQL database') and resource ('MySQL database'), specifying the connection method ('using URL or config'). It distinguishes from sibling tools like 'connect_mongodb' by specifying MySQL, but doesn't explicitly contrast with other database tools beyond the name.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 'connect_mongodb' or other database operations. The description implies it's for establishing a connection, but doesn't specify prerequisites, timing, or when to choose URL vs config parameters.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

connect_mongodbC

Connect to MongoDB database using URL or config

ParametersJSON Schema
NameRequiredDescriptionDefault
urlNoMongoDB URL (mongodb://user:pass@host:port/db)
workspaceNoProject workspace path
databaseNoMongoDB database name

TDQS

C2.9/5.0
Behavior2/5

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 the tool establishes a connection but doesn't describe what that connection enables, whether it's persistent, what authentication is needed, error handling, or what happens if connection fails. For a connection tool with zero annotation coverage, this is insufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise - a single sentence that states the core purpose without any unnecessary words. It's front-loaded with the main action and doesn't waste space on redundant information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a connection tool with no annotations and no output schema, the description is inadequate. It doesn't explain what successful connection enables, what the tool returns, error conditions, or how this fits with sibling MongoDB tools. The agent would struggle to use this effectively without additional context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so all parameters are documented in the schema. The description mentions 'URL or config' which aligns with the 'url' parameter but doesn't explain the relationship between parameters or when to use which. It adds minimal value beyond what's already in the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Connect to MongoDB database') and the method ('using URL or config'), which is specific and unambiguous. However, it doesn't explicitly distinguish this from sibling tools like 'connect_db' or other MongoDB tools, leaving some ambiguity about when to choose this specific connection method.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 'connect_db' or other MongoDB operations. There's no mention of prerequisites, when this connection is needed, or what happens after connection. This leaves the agent without context for tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

create_tableC

Create a new table in the database

ParametersJSON Schema
NameRequiredDescriptionDefault
tableYesTable name
fieldsYes
indexesNo

TDQS

C2.8/5.0
Behavior2/5

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 'Create a new table' which implies a write/mutation operation, but doesn't mention permissions required, whether the operation is idempotent, error handling, or what happens on success/failure. For a tool that modifies database structure, this lack of detail 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.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence that gets straight to the point with zero wasted words. It's appropriately sized for a basic tool description and front-loads the essential information. Every word earns its place by communicating the core functionality without unnecessary elaboration.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a database mutation tool with 3 parameters, no annotations, no output schema, and only 33% schema description coverage, the description is incomplete. It doesn't address behavioral aspects like permissions or side effects, provides minimal parameter guidance, and offers no context about the database system or constraints. The agent would need to guess about many important usage aspects.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 33% (only the 'table' parameter has a description), leaving most parameters undocumented. The description adds no parameter semantics beyond what's implied by the tool name - it doesn't explain what 'fields', 'indexes', or their sub-properties mean, nor provide examples or constraints. With 3 parameters and poor schema coverage, the description fails to compensate adequately.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Create') and resource ('new table in the database'), making the purpose immediately understandable. It distinguishes this tool from siblings like 'add_column' or 'describe_table' by focusing on table creation rather than modification or inspection. However, it doesn't specify what kind of database or table characteristics, leaving some ambiguity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 an established database connection via 'connect_db'), nor does it differentiate from similar tools like 'mongodb_create_collection' for MongoDB-specific operations. Without context, an agent might struggle to choose between this and sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

describe_tableC

Get table structure

ParametersJSON Schema
NameRequiredDescriptionDefault
tableYesTable name

TDQS

C2.7/5.0
Behavior2/5

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. 'Get table structure' implies a read-only operation, but it doesn't specify what 'structure' includes (e.g., columns, data types, constraints), whether it requires specific permissions, or how errors are handled (e.g., if the table doesn't exist). This leaves significant gaps 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.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise at three words, with zero wasted language. It's front-loaded with the core action ('Get'), making it easy to scan and understand quickly. Every word earns its place by contributing to the tool's purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

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 incomplete. It doesn't explain what 'structure' entails (e.g., schema details), potential outputs, or error conditions, which are critical for an agent to use this tool effectively in context with siblings like 'query' or 'create_table'.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the 'table' parameter clearly documented as 'Table name'. The description adds no additional meaning beyond this, as it doesn't elaborate on parameter syntax, format, or examples. With high schema coverage, the baseline score of 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.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Get table structure' clearly indicates the tool retrieves metadata about a database table, which is a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'list_tables' (which likely lists table names) or 'query' (which might return data from tables), leaving room for ambiguity about its exact scope compared to alternatives.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 connected database), exclusions (e.g., not for querying data), or comparisons to siblings like 'list_tables' or 'query', leaving the agent to infer usage context 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.

executeC

Execute an INSERT, UPDATE, or DELETE query

ParametersJSON Schema
NameRequiredDescriptionDefault
sqlYesSQL query (INSERT, UPDATE, DELETE)
paramsNoQuery parameters (optional)

TDQS

C2.9/5.0
Behavior2/5

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 the tool executes data manipulation queries (INSERT, UPDATE, DELETE), implying mutation operations, but doesn't cover critical aspects like permissions required, transaction handling, error behavior, or output format. 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.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise—a single sentence with zero waste. It's front-loaded with the core purpose and uses clear, direct language. Every word earns its place, 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.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (executing mutable SQL queries), lack of annotations, and no output schema, the description is incomplete. It doesn't address safety concerns, error handling, or what the tool returns (e.g., row counts, success/failure). For a mutation tool in a database context, this leaves critical gaps for an agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents both parameters ('sql' and 'params') adequately. The description adds no additional parameter semantics beyond what's in the schema (e.g., no examples of SQL syntax or param usage). Baseline 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Execute an INSERT, UPDATE, or DELETE query.' It specifies the verb ('execute') and the resource/action type (SQL queries for data manipulation). However, it doesn't explicitly differentiate from sibling tools like 'query' (which likely handles SELECT queries) or 'add_column'/'create_table' (DDL operations), so it's not a perfect 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 sibling tools like 'query' for SELECT operations or DDL tools for schema changes, nor does it specify prerequisites (e.g., database connection). This leaves the agent with minimal context for tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_tablesB

List all tables in the database

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

B3.1/5.0
Behavior2/5

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. While 'List all tables' implies a read-only operation, it doesn't specify whether this requires database permissions, how results are formatted, if there are pagination limits, or what happens with empty databases. 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.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's function with zero wasted words. It's appropriately front-loaded and earns its place by clearly conveying the core purpose without unnecessary elaboration.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

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 insufficient for a database tool. It doesn't explain what the output looks like (e.g., table names, metadata), whether it works across different database types, or any error conditions. For a tool that likely returns structured data, this leaves too much undefined.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters with 100% schema description coverage, so the schema already fully documents the lack of inputs. The description doesn't need to add parameter information, and it correctly implies no filtering or options are available ('all tables'). This meets the baseline expectation for parameterless tools.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

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 tables in the database'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'describe_table' or 'query', but the action is specific enough to avoid confusion with most siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 siblings like 'describe_table' (for table details) and 'query' (for executing SQL), there's no indication of when listing tables is appropriate versus other database operations.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

mongodb_create_collectionC

Create a new collection in MongoDB

ParametersJSON Schema
NameRequiredDescriptionDefault
collectionYesCollection name
optionsNoCollection options

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states it creates a collection but doesn't disclose permissions needed, whether it overwrites existing collections, error conditions, or typical response format. For a mutation tool with zero annotation coverage, this is inadequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with zero waste. 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.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations, no output schema, and complex nested parameters (the 'options' object), the description is incomplete. It doesn't explain what 'options' might include, potential side effects, or what success/failure looks like, leaving significant gaps for an AI agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents both parameters ('collection' and 'options'). The description adds no additional meaning beyond implying the tool creates something, which is obvious from the name. Baseline 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Create') and resource ('new collection in MongoDB'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'create_table' or 'mongodb_list_collections', which would require mentioning it's specifically for MongoDB collections rather than general database tables.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 an established MongoDB connection via 'connect_mongodb'), nor does it clarify when to choose this over similar tools like 'create_table' for relational databases.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

mongodb_deleteC

Delete documents from a MongoDB collection

ParametersJSON Schema
NameRequiredDescriptionDefault
collectionYesCollection name
filterYesMongoDB query filter
manyNoDelete multiple documents if true

TDQS

C2.9/5.0
Behavior2/5

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 deletes documents, implying a destructive mutation, but doesn't cover critical aspects like permissions required, whether deletions are permanent or reversible, rate limits, or what happens on success/failure. This is inadequate for a mutation tool with zero 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.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with zero waste—it directly states the tool's purpose without unnecessary words. It's 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.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of a destructive database operation with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits (e.g., safety, permissions), output format, or error handling, which are crucial for an agent to use this tool correctly in context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with clear descriptions for all parameters (collection, filter, many). The description doesn't add any meaning beyond what the schema provides (e.g., it doesn't explain filter syntax or 'many' implications), so it meets the baseline 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.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Delete documents') and resource ('from a MongoDB collection'), providing a specific verb+resource combination. However, it doesn't distinguish this tool from sibling tools like 'mongodb_update' or 'execute' which might also modify data, leaving room for improvement in sibling differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 connection first), exclusions, or comparisons to siblings like 'mongodb_update' for modifications or 'execute' for general queries, leaving the agent with no usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

mongodb_findC

Find documents in a MongoDB collection

ParametersJSON Schema
NameRequiredDescriptionDefault
collectionYesCollection name
filterNoMongoDB query filter
limitNoMaximum number of documents to return
skipNoNumber of documents to skip
sortNoSort criteria

TDQS

C2.9/5.0
Behavior2/5

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 'find' implies a read operation, it doesn't specify whether this requires specific permissions, what happens with large result sets, whether it's paginated, or what the return format looks like. For a database query tool with zero annotation coverage, this leaves significant behavioral questions unanswered.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a basic find operation and front-loads the essential information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given this is a database query tool with no annotations, no output schema, and complex parameters (including nested objects for filter and sort), the description is insufficient. It doesn't explain what the tool returns, how errors are handled, or provide any context about MongoDB-specific behavior. The description should do more to compensate for the lack of structured metadata.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so all parameters are documented in the schema. The description doesn't add any parameter semantics beyond what the schema already provides - it doesn't explain MongoDB query syntax, sort format, or provide examples. The baseline of 3 is appropriate when the schema does all the parameter documentation work.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'find' and resource 'documents in a MongoDB collection', making the purpose immediately understandable. It distinguishes from obvious siblings like mongodb_insert, mongodb_update, and mongodb_delete by specifying a read operation. However, it doesn't explicitly differentiate from query or execute tools that might also retrieve data.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 when to choose mongodb_find over query, execute, or other data retrieval methods. It also doesn't indicate prerequisites like needing an established connection first.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

mongodb_insertC

Insert documents into a MongoDB collection

ParametersJSON Schema
NameRequiredDescriptionDefault
collectionYesCollection name
documentsYesDocuments to insert

TDQS

C2.9/5.0
Behavior2/5

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 the tool inserts documents, implying a write operation, but lacks details on permissions required, whether it's idempotent, error handling (e.g., duplicate keys), or response format. This leaves significant gaps for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, direct sentence with zero wasted words, making it highly efficient and front-loaded. It immediately conveys the core function without unnecessary elaboration, earning full marks for conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a write operation tool with no annotations and no output schema, the description is insufficient. It lacks critical details like expected return values, error conditions, or behavioral traits (e.g., atomicity, performance implications), leaving the agent with incomplete operational context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with clear descriptions for both parameters ('collection' and 'documents'). The description adds no additional semantic context beyond what the schema provides, such as format examples or constraints, so it meets the baseline for adequate but unenhanced coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Insert') and target resource ('documents into a MongoDB collection'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'mongodb_create_collection' or 'mongodb_update', which prevents 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.

Usage Guidelines2/5

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 'mongodb_update' for modifying existing documents or 'mongodb_create_collection' for creating collections. There's no mention of prerequisites, such as needing an existing collection, or contextual advice for selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

mongodb_list_collectionsB

List all collections in the MongoDB database

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

B3.2/5.0
Behavior2/5

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 but offers minimal information. It states it's a list operation (implying read-only), but doesn't cover important aspects like whether it requires authentication, returns paginated results, includes system collections, or what format the output takes. This leaves significant gaps for an agent to understand the tool's behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that communicates the core purpose without any wasted words. It's appropriately sized for a simple listing operation and is front-loaded with the essential information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter listing tool with no output schema, the description is minimally complete - it tells the agent what the tool does. However, without annotations and with sibling tools that perform similar functions in different contexts, more guidance would be helpful. The description doesn't address how this differs from 'list_tables' or when to use MongoDB-specific versus generic database tools.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters with 100% schema description coverage, so the schema already fully documents the parameter situation. The description doesn't need to add parameter information, and it appropriately doesn't mention any parameters. This meets the baseline expectation for a zero-parameter tool.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('List all collections') and target resource ('in the MongoDB database'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'list_tables' or 'describe_table', which reduces its score from a perfect 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 (e.g., needing a connection first), comparison to similar tools like 'list_tables' for SQL databases, or context about when listing collections is appropriate versus other MongoDB operations.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

mongodb_updateC

Update documents in a MongoDB collection

ParametersJSON Schema
NameRequiredDescriptionDefault
collectionYesCollection name
filterYesMongoDB query filter
updateYesMongoDB update operations
manyNoUpdate multiple documents if true

TDQS

C2.9/5.0
Behavior2/5

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 updates documents but fails to mention critical details like required permissions, whether updates are atomic or reversible, potential side effects on data integrity, or error handling. This leaves significant gaps for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core purpose and appropriately sized for the tool's complexity, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (a mutation operation with nested objects and no output schema) and lack of annotations, the description is incomplete. It doesn't cover behavioral aspects like safety, permissions, or return values, which are crucial for an update tool in a database context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, so the schema already documents all parameters ('collection', 'filter', 'update', 'many') adequately. The description adds no additional meaning beyond what the schema provides, such as examples or usage context, which aligns with the baseline score for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Update') and resource ('documents in a MongoDB collection'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'mongodb_delete' or 'mongodb_insert' beyond the verb, which prevents 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.

Usage Guidelines2/5

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 sibling tools like 'mongodb_insert' for creating documents or 'mongodb_delete' for removing them, nor does it specify prerequisites such as needing a connection first.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

queryC

Execute a SELECT query

ParametersJSON Schema
NameRequiredDescriptionDefault
sqlYesSQL SELECT query
paramsNoQuery parameters (optional)

TDQS

C2.7/5.0
Behavior2/5

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. 'Execute a SELECT query' implies a read-only operation, but it doesn't specify permissions needed, potential side effects (e.g., read locks), error handling, or return format. For a database query tool with zero annotation coverage, this is insufficient to inform safe and effective use.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise at three words, with zero wasted language. It's front-loaded with the core action and resource, making it easy to parse quickly. This efficiency is appropriate for a simple tool, though it may sacrifice completeness for brevity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of database queries, lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like safety, performance implications, or result formatting. While the schema handles parameters well, the overall context for reliable tool invocation is inadequate, especially compared to siblings that might overlap in functionality.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with clear documentation for 'sql' (SQL SELECT query) and 'params' (query parameters). The description adds no additional parameter semantics beyond what the schema provides, such as SQL dialect constraints or parameter binding details. Given high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but doesn't detract either.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Execute a SELECT query' clearly states the action (execute) and resource (SELECT query), making the purpose understandable. However, it doesn't distinguish this tool from sibling tools like 'execute' or 'mongodb_find' that might also perform query operations, leaving ambiguity about when to use this specific SQL query tool versus alternatives.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 siblings like 'execute' (which might handle broader SQL operations) and 'mongodb_find' (for NoSQL queries), there's no indication of context, prerequisites, or exclusions. This lack of differentiation could lead to incorrect tool selection by an AI agent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

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

  1. 1 tool updatev1.0.0
    • Addedmongodb_update
  2. 13 tool updates
    • First observedadd_column
    • First observedconnect_db
    • First observedconnect_mongodb
    • First observedcreate_table
    • First observeddescribe_table
    • First observedexecute
    • First observedlist_tables
    • First observedmongodb_create_collection
    • First observedmongodb_delete
    • First observedmongodb_find
    • First observedmongodb_insert
    • First observedmongodb_list_collections
    • First observedquery
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

C2.9/5.0
Disambiguation3/5

The tools are clearly separated between MySQL and MongoDB operations, but within each database type there is some overlap. For example, 'execute' handles INSERT/UPDATE/DELETE for MySQL while 'query' handles SELECT, but these could potentially be confused with the more specific MongoDB equivalents like 'mongodb_insert' and 'mongodb_find'. The descriptions help clarify, but the boundaries aren't perfectly distinct.

Naming Consistency2/5

The naming is inconsistent across the set. MySQL tools use simple verb_noun patterns (e.g., 'add_column', 'create_table'), while MongoDB tools use a 'mongodb_' prefix followed by verb_noun (e.g., 'mongodb_create_collection', 'mongodb_find'). This mixing of conventions makes the set less predictable and harder to navigate at a glance.

Tool Count4/5

With 14 tools, the count is reasonable for a server covering two database systems (MySQL and MongoDB). It provides core operations for both, though it might be slightly heavy if considered as a single domain. Each tool appears to serve a distinct function, so the count feels appropriate for the scope.

Completeness4/5

For MySQL, the tools cover key operations like table management (create, describe, list), column addition, and query execution (SELECT, INSERT/UPDATE/DELETE). For MongoDB, they cover collection management (create, list) and CRUD operations (insert, find, update, delete). Minor gaps include missing operations like dropping tables/collections or more advanced queries, but core workflows are well-covered.

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

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

Related MCP Connectors

Related MCP Servers

  • MongoDB MCP Server

    jonfreeland
    A
    license
    A
    quality
    D
    maintenance
    A Model Context Protocol server that provides read-only access to MongoDB databases, enabling AI assistants to directly query and analyze MongoDB data while maintaining data safety.
    14
    63
    9
    MIT

  • MCP MySQL Server

    Atomzzm
    A
    license
    B
    quality
    D
    maintenance
    A Model Context Protocol server that enables AI models to interact with MySQL databases, providing tools for querying, executing statements, listing tables, and describing table structures.
    5
    342
    MIT

  • MCP MySQL Server

    kevinbin
    F
    license
    B
    quality
    D
    maintenance
    A Model Context Protocol server that enables AI models to interact with MySQL databases through a standardized interface, providing tools for querying, executing commands, and managing database schemas.
    7
    -

Appeared in Searches

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/yaoxiaolinglong/mcp-mongodb-mysql-server'

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