Skip to main content
Glama
yaoxiaolinglong

MCP-MongoDB-MySQL-Server

by yaoxiaolinglong
OverviewSchemaSourceRelated ServersDiscussionsAdmin
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. It states this is a mutation ('Add'), implying it modifies database structure, but doesn't cover critical aspects like permissions required, whether changes are reversible, impact on existing data, error handling, or response format. For a tool that alters schema with no 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, efficient sentence with zero wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word ('Add', 'new column', 'existing table') contributes directly to understanding the tool's function.

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 (2 parameters with nested objects, no output schema, and no annotations), the description is incomplete. It doesn't explain the input structure (e.g., that 'field' is an object with specific properties), behavioral traits (e.g., mutation effects), or output expectations. For a schema-altering tool with rich parameters but no supporting documentation, this leaves too much undefined.

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 none of the parameters (table, field with nested properties like name, type, nullable, length, default) are documented in the schema. The description only mentions 'table' and 'column' generically, without explaining what 'field' represents or detailing the nested properties. It fails to compensate for the schema's lack of documentation, leaving key semantics unclear.

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 this tool from siblings like 'create_table' (which creates entire tables) and 'describe_table' (which inspects structure). However, it doesn't specify what kind of database or system it operates on, which could help further differentiate it from generic column-adding tools.

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 from 'create_table' or 'list_tables'), exclusions (e.g., not for modifying columns), or comparisons to siblings like 'execute' (which might handle SQL directly). Without this context, an 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool connects to a database, implying it establishes a session or handle, but doesn't describe what happens after connection (e.g., persistence, timeout, error handling), authentication needs beyond parameters, or side effects. For a 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 extremely concise—a single sentence that directly states the tool's purpose and method without any fluff. It's front-loaded and wastes no words, making it easy for an agent to parse quickly. Every part of the sentence earns its place by conveying 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 the tool's complexity (database connection with 6 parameters), lack of annotations, no output schema, and low schema description coverage, the description is incomplete. It doesn't cover behavioral aspects like connection lifecycle, error cases, or output format, leaving critical gaps for the agent to infer. This is inadequate for a tool that likely has significant operational implications.

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 33% (only 'url' and 'workspace' have descriptions), so the description must compensate but adds minimal value. It mentions 'URL or config', hinting at parameters like 'url' and possibly 'host', 'user', etc., but doesn't explain their semantics, relationships (e.g., mutual exclusivity), or defaults. The description provides some context but doesn't fully bridge the coverage gap, warranting a baseline score.

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 the resource ('MySQL database'), making the purpose evident. It specifies the connection method ('using URL or config'), which helps distinguish it from other database operations. However, it doesn't explicitly differentiate from sibling tools like 'execute' or 'query', which might also involve database interactions, 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 prerequisites (e.g., needing this connection before using other tools like 'query'), exclusions, or contextual cues. With sibling tools like 'execute' and 'query' available, the lack of usage guidelines leaves the agent uncertain about proper sequencing or selection.

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.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 'create' implies a write operation but doesn't cover critical aspects like permissions required, whether the operation is idempotent, error handling (e.g., if the table already exists), or side effects. 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 purpose without unnecessary elaboration, 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?

For a mutation tool with 3 parameters, no annotations, and no output schema, the description is insufficient. It lacks details on behavior, error cases, dependencies (e.g., connection state), and doesn't explain what 'create' entails operationally (e.g., atomicity, rollback). This leaves the agent poorly equipped to use the tool effectively in complex scenarios.

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 at 33%, with only the 'table' parameter having a description. The tool description doesn't add any parameter details beyond the schema, failing to compensate for the coverage gap. However, the schema itself provides clear structure for 'fields' and 'indexes', so a baseline score of 3 is appropriate given the schema's clarity despite missing descriptions.

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. However, it doesn't differentiate from sibling tools like 'add_column' or 'execute', which could also involve table creation operations, so it doesn't reach the highest 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 'execute' (which might create tables via SQL) or 'add_column' (which modifies existing tables). There's no mention of prerequisites, such as needing an established database connection via 'connect_db', leaving the agent without contextual usage cues.

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

describe_tableB

Get table structure

ParametersJSON Schema
NameRequiredDescriptionDefault
tableYesTable name

TDQS

B3.2/5.0
Behavior2/5

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

No annotations are provided, and the description fails to disclose behavioral traits like read-only nature, side effects, or required permissions. It simply states the function without additional context.

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

Conciseness4/5

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

The description is extremely concise (two words), front-loaded, and gets straight to the point. However, it could benefit from a bit more detail without sacrificing brevity.

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?

Given the tool is simple with one parameter and no output schema, the description is minimal but adequate for a basic understanding. However, it doesn't specify what 'structure' includes (e.g., columns, types), leaving some ambiguity.

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

Parameters3/5

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

Schema coverage is 100% with the only parameter 'table' described as 'Table name'. The description adds no new meaning beyond the schema, so baseline 3 is appropriate.

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

Purpose5/5

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

The description 'Get table structure' clearly states the verb (Get) and resource (table structure), and distinguishes the tool from siblings like execute, list_tables, and query, which have different purposes.

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 vs alternatives, such as list_tables or query. It lacks context on when not to use it or any prerequisites.

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

executeB

Execute an INSERT, UPDATE, or DELETE query

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

TDQS

B3.3/5.0
Behavior2/5

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

No annotations are provided, so the description must bear the burden of behavioral disclosure. It confirms mutation but fails to detail side effects, permanence, or return behavior.

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

Conciseness4/5

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

The description is a single short sentence with no wasted words, but it could include more detail without sacrificing 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 lack of output schema and annotations, the description does not explain return values or error behavior. It is too minimal for a mutation tool.

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

Parameters3/5

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

Schema coverage is 100%, and the description does not add meaning beyond the schema. The schema already documents 'sql' and 'params' adequately.

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

Purpose5/5

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

The description clearly states the tool executes INSERT, UPDATE, or DELETE queries, which specifies the action and resource. It distinguishes from sibling tools like 'query' which likely handles SELECT statements.

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

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for write operations but does not explicitly guide when to use this tool versus alternatives like 'query'. There is no mention of prerequisites or restrictions.

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/5.0
Behavior2/5

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

There are no annotations, so the description must fully disclose behavior. It merely states 'List all tables', which implies a read operation, but omits details on permissions, output format, or performance implications.

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

Conciseness4/5

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

The description is a single, efficient sentence with no unnecessary words. It is appropriately front-loaded but lacks any structural enhancement like bullet points that could aid readability.

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 no output schema or annotations, the description should explain what 'list' returns (e.g., table names, schemas). Without this, an agent may not know how to use the result. Sibling tools like 'describe_table' suggest additional context might be needed.

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 no parameters, so the description cannot add parameter meaning. Baseline for zero parameters is 4, and the description is sufficient for the parameterless case.

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 lists all tables in the database. While it distinguishes from 'describe_table' by listing instead of describing, it does not explicitly differentiate from potential siblings like 'query' or 'execute'.

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 its siblings (describe_table, execute, query). It is implied that it retrieves table names, but no context on prerequisites or alternatives.

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.

queryB

Execute a SELECT query

ParametersJSON Schema
NameRequiredDescriptionDefault
sqlYesSQL SELECT query
paramsNoQuery parameters (optional)

TDQS

B3.1/5.0
Behavior2/5

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

With no annotations, the description bears full responsibility for behavioral disclosure. It only states the tool executes a SELECT query, but does not explicitly confirm it is read-only, mention permission requirements, error handling, or the effect of malformed queries. The implied read-only nature is not sufficient.

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

Conciseness4/5

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

The description is a single concise sentence that front-loads the main action. It is not verbose, though it could include more context without losing conciseness. The structure is effective but minimal.

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?

There is no output schema, yet the description does not explain what the tool returns (e.g., result set structure, row count, error messages). It also lacks information on pagination, limits, or behavior with large queries, leaving the agent with significant gaps.

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

Parameters3/5

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

Schema description coverage is 100%, so the schema already documents both parameters ('sql' and 'params') adequately. The description adds no additional meaning or context about parameter usage, formatting, or constraints beyond the schema, earning a baseline score of 3.

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

Purpose5/5

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

The description 'Execute a SELECT query' clearly identifies the tool's action (execute) and resource (SELECT query). It distinguishes from sibling tools like 'execute' (which likely handles other SQL statements) and 'describe_table'/'list_tables' (which are informational).

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 does not mention that for non-SELECT queries (e.g., INSERT, UPDATE) one should use the sibling 'execute' tool, nor does it specify any prerequisites or limitations.

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.

  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
Deploy Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

C2.9/5.0

Scored across 14 tools

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

Related MCP Connectors

Related MCP Servers

  • MongoDB MCP Server

    jonfreeland
    A
    license
    A
    quality
    C
    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
    55
    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
    180
    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