MySQL MCP

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation5/5
Each tool has a unique and clearly defined purpose targeting different database operations (e.g., create table, insert data, execute query). There is no ambiguity or overlap among the tools.
Naming Consistency5/5
All tool names follow a consistent verb_noun pattern in snake_case (e.g., create_table, list_tables, update_data). This makes the naming predictable and easy to understand.
Tool Count5/5
With 8 tools, the server is well-scoped for basic MySQL database operations. The count is appropriate, covering essential CRUD and metadata operations without being too sparse or bloated.
Completeness4/5
The tool set covers core operations like table creation, data manipulation, and querying. However, it is missing important DDL operations such as DROP TABLE or ALTER TABLE, which could be considered minor gaps.
Average 3.3/5 across 8 of 8 tools scored.
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
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
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

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility. It only states the tool returns a dictionary with results, but does not disclose behavioral traits like side effects on global state, idempotency, connection handling, or error conditions. This is insufficient for safe agent invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is structured as a docstring with Args and Returns sections, which is clear. However, it is somewhat verbose for a simple switching action; the purpose could be conveyed in one sentence. Every sentence earns its place, but brevity could be improved.
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 and minimal annotations, the description lacks completeness. It does not explain what 'switching' entails (e.g., persistent vs session-level), potential errors (invalid database name, connection issues), or return value details (keys/structure of the result dictionary). More context is needed for reliable tool usage.
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?
Schema coverage is 0%, but the description adds meaningful parameter explanations: 'database_name' is the database name, and 'db_config' configures connection parameters with a default of None. While db_config lacks specifics (e.g., allowed keys), the description adds value beyond the schema's titles and structure.
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 switches databases, using a specific verb ('切换到') and resource ('数据库'). However, it does not elaborate on what 'switching' implies operationally (e.g., setting active database for subsequent queries), which could be clearer. It is distinct from sibling tools like create_table or execute_query.
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 others, nor any when-not or alternative suggestions. The description does not indicate prerequisites (e.g., need an existing database) or scenario 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 present, and the description does not disclose behavioral traits like required permissions, the irreversible nature of updates, or side effects. It only states the return type ('包含更新结果的字典'), which is insufficient for an AI agent making safe decisions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description uses a docstring format with bullet-like lines, which is acceptable but not optimally concise. Some details (e.g., default config) could be streamlined, and the structure is not highly scannable for AI.
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?
The description covers all 5 parameters but does not specify default behavior for db_config or error handling. With no output schema, the return value description ('包含更新结果的字典') is vague. Gaps remain in what constitutes a successful update.
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?
Schema coverage is 0%, but the description explains each parameter's purpose (e.g., '要更新的数据，字段名和值的字典' for data) beyond the schema's type information. This adds meaningful guidance, though it could be more precise about the condition format.
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 uses the verb '更新' (update) and specifies the resource '表中的数据' (data in table), which distinguishes it from insertion or deletion. However, it does not explicitly differentiate from sibling tools like insert_data or delete_data, leaving room for confusion.
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 (e.g., insert for new records, delete for removal). The description lacks context on prerequisites, such as whether the table must exist or what conditions are appropriate.
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, and the description only states it deletes data and returns a dictionary. It does not disclose destructive behavior, authorization needs, rollback possibilities, or rate limits. For a delete operation, 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with a purpose sentence followed by a parameter list and return statement. It is front-loaded and contains no unnecessary words. However, it could be more structured with a clear use-case sentence.
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 is destructive (delete) with 4 parameters, no output schema, and no annotations, the description lacks critical details: return dictionary keys, safety warnings, and when to use this vs siblings like update_data. It is incomplete for a production 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?
The input schema has 0% description coverage, so the description must compensate. It provides brief Chinese explanations for each parameter (e.g., table_name: '表名', condition: 'WHERE条件子句'). These add some meaning beyond the schema's types, but are minimal and lack details like format or examples.
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 deletes data from a table. It uses the specific verb 'delete' and resource 'data from table'. This distinguishes it from siblings like insert_data, update_data, and create_table.
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 does not provide any guidance on when to use this tool versus alternatives like update_data or execute_query. It lacks prerequisites, warnings about irreversible deletion, or examples.
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 must fully disclose behavior. It mentions the return value ('包含创建结果的字典') but lacks details on authentication, rate limits, side effects (e.g., what happens if table exists), or error conditions.
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 reasonably concise with a clear Args/Returns structure. It avoids unnecessary text, but could be slightly more compact without losing 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 table creation tool with no output schema and no annotations, the description covers the basic function and parameters. However, it lacks warnings about table existence, permission requirements, or transactional behavior, which limits completeness.
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 provides no descriptions (0% coverage), so the description must compensate. It explains db_config's purpose and default behavior, and gives a concrete example for columns_def. However, table_name is only described as '表名' (table name), which adds little value beyond the schema's title.
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 '创建新表' (create new table), which is a specific verb+resource. It distinguishes itself from sibling tools like delete_data, describe_table, etc., by focusing on table creation.
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 (e.g., insert_data, update_data). There is no mention of prerequisites, when not to use, or comparisons with siblings, leaving the agent without context for 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. It states that the tool inserts data (implying mutation) but does not disclose side effects, permissions, error handling, or result format beyond a generic dictionary. For a mutation tool, more transparency is needed.
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 concise with a front-loaded purpose line followed by structured Args/Returns sections. However, the docstring format is slightly verbose; still, it effectively conveys the necessary information without waste.
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?
The description covers parameter semantics but lacks details on return values (vague 'dict containing insert results'), error conditions, and prerequisites (e.g., table must exist). For a 3-parameter tool with no output schema, it is minimally adequate but not comprehensive.
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?
With 0% schema description coverage, the tool description adds significant meaning to each parameter: table_name is the table name, data is a dictionary of field names and values, and db_config is an optional database connection config. This goes beyond the schema's type-only information.
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 '向表中插入数据' (insert data into table), which is a specific verb+resource combination. This distinguishes it from sibling tools like create_table, update_data, and delete_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?
No guidance is provided on when to use this tool versus alternatives. There is no mention of context, prerequisites, or scenarios where other tools would be more appropriate.
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, the description carries full burden but only states it returns a dictionary. It does not disclose read-only nature, required permissions, potential side effects, or any behavioral traits beyond the basic 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 concise with three clear sections (description, args, returns) and no superfluous text. It is efficiently structured and front-loaded.
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 no output schema and no annotations, the description should provide more context about the returned data structure and behavior. It lacks details on what '表结构信息' includes (e.g., column names, data types) and does not clarify whether it is a read-only 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 coverage is 0%, so the description must compensate. It provides brief Chinese explanations for each parameter ('表名' for table_name, '数据库连接配置参数...' for db_config), adding some meaning beyond names. However, the explanations are minimal and do not fully clarify types or constraints.
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 '获取表结构' (get table structure), which is a specific verb and resource. It distinguishes itself from sibling tools like create_table and list_tables by focusing on structural metadata.
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 implicitly indicates when to use it (when you need table structure), but it does not explicitly state when not to use it or provide alternatives. No comparison with sibling tools is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations were provided, so the description must cover behavioral traits. It mentions parameterized queries for SQL injection prevention and optional db_config, but does not disclose side effects (e.g., whether reads are safe, if DML statements are allowed, error behavior, or resource usage). The return format is noted as a dict, but missing details on success/failure indicators.
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 concise with a clear docstring structure (Args and Returns sections), front-loading the purpose. No redundant sentences; however, it could be slightly restructured to improve readability.
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 has 3 parameters (1 required), no output schema, and sibling tools, the description covers basic usage but lacks error handling details, differentiation from siblings, and implications of running DML queries. It leaves gaps for an agent to determine safe boundaries.
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?
With 0% schema description coverage, the description adds significant meaning: 'query' is the SQL statement, 'params' for parameterized queries, and 'db_config' for optional connection settings. This clarifies each parameter's role beyond the schema's type information, though more detail on allowed values or formats would improve it.
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 '执行SQL查询语句，返回查询结果' (Execute SQL query statement, return query results), specifying the verb 'execute' and resource 'SQL query'. It distinguishes from sibling tools like create_table, delete_data, etc., which are specific table operations, making the purpose unambiguous.
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 execute_query versus alternatives like describe_table or select (if any). It does not mention prerequisites or common use cases, leaving the agent to infer appropriate usage without explicit context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must convey behavior. It mentions the return type (dictionary) but lacks details on whether this is read-only, error handling, or authentication needs. Adequate but not exhaustive.
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 concise, with a clear one-sentence purpose and structured Args/Returns sections. No wasted words.
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 no output schema and a simple listing operation, the description covers the basics but could elaborate on edge cases like invalid database or connection failures. It is minimally complete.
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?
With 0% schema description coverage, the description compensates by explaining that database_name can be None for default and db_config for connection config. This adds meaning beyond the schema's bare structure.
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 lists all tables in a database ('列出指定数据库中的所有表'), using a specific verb and resource. It distinguishes from sibling tools like create_table, describe_table, and execute_query.
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 provides basic argument explanations but does not explicitly guide when to use this tool versus alternatives, such as describe_table or execute_query. Usage is implied but not elaborated.
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/Liu-creators/mysql-mcp/badges/card.svg)](https://glama.ai/mcp/servers/Liu-creators/mysql-mcp)

Score Badge

Copy to your README.md:

[![mysql-mcp MCP server](https://glama.ai/mcp/servers/Liu-creators/mysql-mcp/badges/score.svg)](https://glama.ai/mcp/servers/Liu-creators/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/Liu-creators/mysql-mcp'

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