MySQL MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation5/5
Every tool has a clearly distinct purpose with no ambiguity. Each tool targets a specific MySQL operation (e.g., connect/disconnect, create/drop databases/tables, CRUD operations, import/export, listing), and there is no overlap in functionality that would cause misselection.
Naming Consistency5/5
All tool names follow a consistent 'mysql_' prefix with a verb_noun pattern (e.g., mysql_connect, mysql_create_database, mysql_list_tables). This predictable naming convention makes it easy for agents to understand and use the tools without confusion.
Tool Count5/5
With 15 tools, the server is well-scoped for MySQL database management. Each tool earns its place by covering essential operations like connection handling, database/table lifecycle, data manipulation, and import/export, without being overly heavy or thin for the domain.
Completeness5/5
The tool set provides complete CRUD and lifecycle coverage for MySQL operations. It includes connection management, database/table creation/deletion, data insertion/update/delete/query, structure inspection, and import/export functionalities, leaving no obvious gaps for typical database workflows.
Average 2.7/5 across 15 of 15 tools scored. Lowest: 1.7/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior1/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 but fails to do so. It does not mention that this is a mutation operation (creating a database), potential permissions required, side effects, or any behavioral traits like rate limits or error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
While concise with a single phrase, the description is under-specified rather than efficiently structured. It lacks front-loaded critical information and fails to earn its place by adding value beyond the tool name, making it ineffective despite its brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a database creation tool with no annotations and no output schema, the description is severely incomplete. It does not address behavioral aspects, usage context, or output expectations, leaving significant gaps for the agent to understand the tool's full scope.
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 all parameters documented in the schema itself (name, charset, collation). The description adds no additional meaning beyond what the schema provides, such as explaining parameter interactions or constraints, so it meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description '创建数据库' (create database) is a tautology that restates the tool name 'mysql_create_database' in Chinese, providing no additional specificity or differentiation from siblings like 'mysql_drop_database'. It lacks a clear verb+resource combination or scope details that would help distinguish its exact function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'mysql_list_databases' for checking existing databases or 'mysql_drop_database' for deletion. The description offers no context, prerequisites, or exclusions, leaving the agent with no usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/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. '创建表' (create table) implies a write/mutation operation, but it doesn't disclose any behavioral traits such as permissions required, whether it's idempotent, error handling, or effects on the database (e.g., schema changes). This leaves critical gaps for an AI agent to understand how to invoke it safely and effectively.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is overly concise at just two characters ('创建表'), leading to under-specification rather than effective brevity. It lacks structure (e.g., no front-loaded key details) and fails to earn its place by omitting essential context, making it inefficient for guiding an AI agent despite its short length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a database mutation tool with no annotations and no output schema, the description is severely incomplete. It doesn't explain what the tool does beyond the tautological name, provide usage context, detail behavioral aspects, or hint at return values. This inadequately supports an AI agent in selecting and invoking the tool correctly for a non-trivial operation.
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% (the 'sql' parameter is documented as '创建表的 SQL 语句' or 'SQL statement to create a table'), so the schema provides full parameter semantics. The description adds no additional meaning beyond what's in the schema, but the baseline is 3 since the schema adequately covers the single parameter without needing extra explanation from the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description '创建表' (create table) restates the tool name 'mysql_create_table' in Chinese, making it a tautology. It specifies the verb 'create' and resource 'table' but doesn't distinguish it from sibling tools like 'mysql_create_database' beyond the obvious resource difference, nor does it clarify what 'creating a table' entails in this context (e.g., SQL execution).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a database connection via 'mysql_connect'), exclusions (e.g., not for modifying existing tables), or comparisons to siblings like 'mysql_query' for general SQL execution. The description is too minimal to imply any usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 action 'connect' but doesn't describe what this entails: whether it establishes a persistent session, requires authentication, has side effects (e.g., opening network connections), returns a connection handle, or includes error handling. For a critical initialization 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, efficient sentence in Chinese ('连接到 MySQL 数据库') that directly states the tool's action. It is front-loaded with the core purpose and wastes no words, making it easy to parse quickly. For a simple connection tool, this conciseness is appropriate and effective.
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 database connection tool with no annotations and no output schema, the description is incomplete. It doesn't explain the return value (e.g., connection ID or status), error conditions, or how the connection integrates with sibling tools (e.g., mysql_query might require an active connection). For a foundational tool in a MySQL suite, more context is needed to guide the agent 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 100%, with all parameters documented in the input schema (host, port, user, password, database). The description adds no additional meaning beyond the schema, such as parameter interactions (e.g., database is optional for initial connection) or examples. With high schema coverage, the baseline is 3, as the description doesn't compensate but also doesn't detract.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description '连接到 MySQL 数据库' (Connect to MySQL database) states the basic action but is vague about scope and differentiation. It specifies the verb 'connect' and resource 'MySQL database', but doesn't clarify if this establishes a persistent connection, session, or temporary link, nor how it differs from sibling tools like mysql_disconnect or mysql_query. The purpose is understandable but lacks specificity for agent decision-making.
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 is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., must be called before other MySQL operations), exclusions (e.g., not needed for mysql_list_databases if already connected), or contextual cues. With siblings like mysql_disconnect and mysql_query, the agent must infer usage from the name alone, which is insufficient for reliable tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 but only states the basic action. It doesn't mention critical traits like whether deletions are permanent, require specific permissions, have transaction implications, or affect related data (e.g., foreign keys). For a destructive operation, this lack of transparency 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 with a single phrase ('删除表数据'), which is front-loaded and wastes no words. For a simple tool name like mysql_delete, this minimalism is appropriate, though it may sacrifice clarity.
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 doesn't explain what happens on success or failure, return values, error conditions, or safety considerations. For a tool that permanently removes data, more context is needed to guide safe usage.
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 (tableName and where). The description adds no additional meaning beyond what the schema provides, such as examples of where conditions or table naming conventions. 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.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description '删除表数据' (delete table data) states the basic action but is vague about scope and lacks sibling differentiation. It doesn't specify whether this deletes all rows, filtered rows, or has other limitations compared to siblings like mysql_drop_table (which drops the entire table structure). The purpose is understandable but insufficiently specific.
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 is provided on when to use this tool versus alternatives. For example, it doesn't clarify if this should be used instead of mysql_drop_table for deleting rows versus entire tables, or how it relates to mysql_update for data modification. The description offers no context about prerequisites, constraints, or typical use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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. '查看表结构' (view table structure) implies a read-only operation, but it doesn't specify whether this requires database permissions, what the output format is (e.g., column details, types, constraints), or if it's safe to use. The description lacks behavioral details beyond the basic purpose.
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 phrase ('查看表结构') that is extremely concise and front-loaded with the core purpose. There is no wasted text, and it efficiently communicates the tool's function 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 tool's moderate complexity (a database operation with 2 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like output format, error handling, or dependencies on other tools (e.g., 'mysql_connect'). For a tool in this context, more detail is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 parameters 'tableName' and 'database' documented in Chinese. The description doesn't add any meaning beyond what the schema provides (e.g., it doesn't explain parameter interactions or usage examples). With high schema coverage, the baseline score of 3 is appropriate as the schema handles parameter documentation adequately.
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 '查看表结构' (view table structure) states a clear purpose with a specific verb ('view') and resource ('table structure'), but it doesn't distinguish this tool from potential siblings like 'mysql_list_tables' or 'mysql_query' that might also provide table information. It's adequately specific but lacks 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 an active connection via 'mysql_connect'), exclusions, or comparisons to siblings like 'mysql_list_tables' (which lists tables) or 'mysql_query' (which could run DESCRIBE queries). Usage is implied but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/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. '删除数据库' implies a destructive, irreversible mutation, but it fails to specify critical details: whether it requires admin permissions, if it deletes all associated tables/data, what happens on success/failure (e.g., error if database doesn't exist), or any rate limits. This is inadequate for a high-risk operation.
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 phrase ('删除数据库'), which is maximally concise and front-loaded with the core action. There is zero wasted verbiage, making it efficient for quick comprehension, though this brevity contributes to gaps in other dimensions.
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 high complexity and risk of a destructive database operation, with no annotations and no output schema, the description is severely incomplete. It lacks essential context: behavioral traits (e.g., irreversibility), error handling, permissions, and output expectations. This leaves the agent under-informed for safe and effective use.
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 the single parameter 'name' documented as '数据库名称' (database name). The description adds no additional meaning beyond this—it doesn't clarify naming conventions, case sensitivity, or validation rules. 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description '删除数据库' (delete database) clearly states the verb (delete) and resource (database), making the purpose immediately understandable. It distinguishes from siblings like mysql_create_database (create) and mysql_list_databases (list), though it doesn't explicitly mention the MySQL context which is implied by the tool 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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a connection via mysql_connect), exclusions (e.g., not for tables—use mysql_drop_table instead), or consequences (e.g., irreversible data loss). This leaves the agent to infer usage from context alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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. '删除表' implies a destructive mutation, but it doesn't specify critical traits like whether it's irreversible, requires specific permissions, affects related data (e.g., foreign keys), or has side effects. This is a significant gap for a destructive 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 extremely concise with just two characters ('删除表'), which is front-loaded and wastes no words. For a simple tool, this brevity is appropriate, though it may sacrifice clarity.
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 (destructive database operation), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral risks, prerequisites, or return values, leaving the agent under-informed. This is inadequate for a mutation 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 input schema has 100% description coverage, with 'tableName' documented as '表名称' (table name). The description adds no meaning beyond this, as it doesn't explain parameter usage, constraints, or examples. However, with high schema coverage, the baseline is 3, 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 '删除表' (delete table) states a clear verb ('delete') and resource ('table'), which is better than a tautology. However, it lacks specificity about what exactly gets deleted (e.g., structure, data, or both) and doesn't distinguish it from siblings like 'mysql_drop_database' or 'mysql_delete' (which might delete rows). This makes it vague but functional.
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), exclusions (e.g., not for deleting rows), or comparisons to siblings like 'mysql_delete' or 'mysql_drop_database'. 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.
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 executes SQL queries but doesn't describe what happens (e.g., returns results for SELECT, affects rows for DML, may require authentication, could have side effects like data modification, or potential error handling). For a tool with no annotations and potential write operations, 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 with a single phrase ('执行 SQL 查询'), which is front-loaded and wastes no words. It efficiently conveys the core action without unnecessary elaboration, 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 complexity of SQL execution (which can include read/write operations, error cases, and result formats), no annotations, no output schema, and a vague description, the description is incomplete. It doesn't explain return values, error behavior, or safety considerations, leaving significant gaps for an AI agent to understand how to use the 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?
The schema description coverage is 100%, with clear descriptions for both parameters ('sql' as SQL query statement and 'params' as optional parameters for parameterized queries). The description adds no additional meaning beyond what the schema provides, such as examples or constraints on SQL syntax. 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 '执行 SQL 查询' (Execute SQL query) states a clear verb ('execute') and resource ('SQL query'), but it's vague about what types of queries are supported (e.g., SELECT, INSERT, UPDATE, DELETE) and doesn't distinguish this from sibling tools like mysql_insert or mysql_update. It provides basic purpose but lacks specificity.
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 offers no guidance on when to use this tool versus alternatives. It doesn't mention that this is a general-purpose query tool compared to more specific siblings like mysql_insert or mysql_update, nor does it provide any context about prerequisites (e.g., connection status) or exclusions. There's no usage advice beyond the basic action.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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. '更新表数据' indicates a write/mutation operation but provides no information about permissions needed, whether changes are reversible, transaction behavior, error conditions, or what happens when the WHERE clause matches multiple rows. For a database mutation tool with zero annotation coverage, this is a significant gap in behavioral 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 at just four Chinese characters ('更新表数据'). While it may be too brief for completeness, it's perfectly front-loaded with the core purpose and contains zero wasted words or 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?
Given this is a database mutation tool with no annotations, no output schema, and three required parameters (including nested objects), the description is inadequate. It doesn't explain what the tool returns, error conditions, transactional behavior, or how it differs from similar tools. The minimal description fails to provide the context needed for safe and effective use of a potentially destructive database operation.
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%, with all three parameters ('tableName', 'data', 'where') having descriptions in Chinese. The tool description adds no additional parameter information beyond what's already in the schema. According to scoring rules, when schema_description_coverage is high (>80%), the baseline is 3 even with no param info in the description.
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 '更新表数据' (Update table data) states a clear verb ('update') and resource ('table data'), which is better than a tautology. However, it doesn't distinguish this tool from its sibling 'mysql_insert' (which adds data) or 'mysql_delete' (which removes data) - it only generically describes updating without specifying how it differs from other data modification 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. With siblings like 'mysql_insert' (for adding new records), 'mysql_delete' (for removing records), and 'mysql_query' (for general SQL operations), there's no indication of when this specific UPDATE operation is appropriate versus using a more general query or other modification tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 action (export) but doesn't cover critical aspects like whether this requires write permissions to the file system, potential performance impacts on the database, file overwriting behavior, or error handling. This is inadequate for a tool that performs I/O operations.
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 phrase ('导出表数据到文件') that directly conveys the core action without unnecessary words. It is front-loaded and appropriately sized for its 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 tool's complexity (data export with file I/O), lack of annotations, and no output schema, the description is incomplete. It doesn't address behavioral traits, usage context, or return values, leaving significant gaps for an AI agent to understand how to invoke it correctly.
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 all parameters documented in the schema (tableName, filePath, format, where). The description adds no additional semantic context beyond what the schema provides, such as explaining the scope of 'where' or file path requirements. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description '导出表数据到文件' (Export table data to file) clearly states the verb (export) and resource (table data), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like mysql_query (which might also retrieve data) or mysql_import_data (the inverse operation), missing full sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. For example, it doesn't mention when to choose mysql_export_data over mysql_query for data retrieval or how it relates to mysql_import_data. The description lacks context on prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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. It mentions importing data but fails to disclose critical behavioral traits such as whether the operation is destructive (e.g., truncateFirst parameter), authentication requirements, error handling, or performance implications. This is a significant gap for a data import 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 in Chinese that directly states the tool's purpose without unnecessary words. It is front-loaded and appropriately sized for conveying the core action, making it highly concise.
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 data import tool with no annotations and no output schema, the description is incomplete. It doesn't cover behavioral aspects like side effects, error cases, or return values, leaving gaps that could hinder an AI agent's correct invocation.
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 fully documents all four parameters (tableName, filePath, format, truncateFirst). The description adds no additional meaning beyond the schema, such as explaining parameter interactions or constraints, which aligns with the baseline score when schema coverage is high.
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 (import) and target (data to table) in Chinese, which translates to 'import data from file to table.' It specifies the verb and resource but doesn't differentiate from sibling tools like mysql_export_data or mysql_insert, which handle related operations.
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 such as mysql_insert for direct data insertion or mysql_export_data for the reverse operation. It lacks context about prerequisites like needing an established connection or file format compatibility.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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. '插入数据到表' implies a write/mutation operation, but it doesn't disclose critical traits: whether it requires specific permissions, if it's idempotent, what happens on duplicate keys, error handling, or return values. For a mutation 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, efficient phrase ('插入数据到表') with zero wasted words. It's appropriately sized for a simple tool and front-loads the core action. Every element earns its place, making it highly concise.
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 no annotations and no output schema), the description is incomplete. It doesn't cover behavioral aspects like side effects, error cases, or what to expect upon success. For a database insert tool, this leaves the agent under-informed about critical usage 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 both parameters (tableName and data) clearly documented in the schema. The description adds no additional meaning beyond the schema—it doesn't explain parameter relationships, data format examples, or constraints. Baseline 3 is appropriate when the schema does all the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description '插入数据到表' (Insert data into table) clearly states the verb ('插入' - insert) and resource ('表' - table), making the purpose immediately understandable. It distinguishes from siblings like mysql_update (modify existing data) and mysql_delete (remove data). However, it doesn't specify what kind of data or table, making it slightly less specific than 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 an established connection via mysql_connect), when to choose insert over update/delete, or any constraints (e.g., table must exist). 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.
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. It states the action (disconnect) but doesn't disclose behavioral traits like whether it's idempotent, if it requires specific permissions, what happens to pending transactions, or if it closes all connections or just the current session. 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 in Chinese that directly states the tool's purpose with zero waste. It's appropriately sized and front-loaded, 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 to disconnect from a database), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what the tool returns, error conditions, or side effects, leaving significant gaps for an agent to understand its behavior fully.
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 input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate here. Baseline is 4 for zero parameters, as the schema fully covers the absence of inputs.
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 '断开 MySQL 数据库连接' clearly states the action (断开/disconnect) and target resource (MySQL 数据库连接/MySQL database connection). It distinguishes from siblings like mysql_connect (connect) and mysql_query (query), but doesn't specify what exactly gets disconnected (e.g., current session vs all connections).
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 is provided. It doesn't mention prerequisites (e.g., must be connected first), timing considerations, or what happens if called without an active connection. The description alone gives no usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 action (list databases) but doesn't describe what 'list' entails (e.g., format, pagination, permissions required, or whether it's read-only). 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 a single, efficient phrase ('列出所有数据库') that directly states the purpose with zero waste. It is appropriately sized and front-loaded, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimal. It states what the tool does but lacks context on behavior, usage, or output, making it incomplete for effective agent use despite the low complexity.
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 0 parameters, and schema description coverage is 100% (since there are no parameters to describe). The description doesn't need to add parameter semantics, so it meets the baseline of 4 for tools with no parameters.
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 '列出所有数据库' (List all databases) clearly states the verb (list) and resource (databases). It distinguishes from siblings like mysql_list_tables (lists tables) and mysql_create_database (creates databases), though it doesn't explicitly mention this distinction in the description itself.
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 via mysql_connect), exclusions, or typical use cases, leaving the agent to infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 what the tool does but doesn't describe any behavioral traits, such as whether it's read-only (implied by 'list'), what permissions are required, how results are returned (e.g., format, pagination), or error handling. 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, clear sentence in Chinese that directly states the tool's purpose without any unnecessary words. It's front-loaded and efficiently communicates the core functionality, making it easy for an agent to parse and understand quickly.
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's low complexity (one optional parameter) and no output schema, the description is minimally adequate but lacks completeness. It doesn't explain return values (e.g., list format, error cases) or behavioral context, which is important since no annotations are provided. However, the simplicity of the tool means the description isn't entirely inadequate.
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%, with the single parameter 'database' fully documented in the schema as optional and defaulting to the current connection. The description doesn't add any additional meaning beyond what the schema provides, such as examples or constraints, but the schema already covers the parameter adequately, meeting the baseline for high 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 ('列出' - list) and resource ('指定数据库的所有表' - all tables of a specified database), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'mysql_list_databases' or 'mysql_describe_table', but the specificity about tables provides some implicit distinction.
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 'mysql_list_databases' (for listing databases) or 'mysql_describe_table' (for table details). There's no mention of prerequisites, such as requiring an active connection via 'mysql_connect', or context about when listing tables is appropriate versus other operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![mysql-mcp MCP server](https://glama.ai/mcp/servers/pickstar-2002/mysql-mcp/badges/card.svg)](https://glama.ai/mcp/servers/pickstar-2002/mysql-mcp)

Score Badge

Copy to your README.md:

[![mysql-mcp MCP server](https://glama.ai/mcp/servers/pickstar-2002/mysql-mcp/badges/score.svg)](https://glama.ai/mcp/servers/pickstar-2002/mysql-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/pickstar-2002/mysql-mcp'

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