MySQL MCP Server Pro

Server Quality Checklist

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

Latest release: v0.2.1
Disambiguation4/5
Most tools have distinct purposes, such as execute_sql for SQL execution, get_table_desc for table structures, and optimize_sql for performance optimization. However, some tools like get_db_health_index_usage and get_db_health_running could be confused as both relate to health monitoring, though their specific focuses differ slightly.
Naming Consistency4/5
Tool names follow a consistent verb_noun pattern (e.g., execute_sql, get_table_desc, optimize_sql) with clear actions and targets. There are minor deviations like get_chinese_initials, which uses a different verb style, but overall the naming is predictable and readable.
Tool Count5/5
With 9 tools, the count is well-scoped for a MySQL server, covering core operations like SQL execution, table and index queries, health monitoring, and optimization. Each tool serves a specific function without unnecessary duplication, making the set efficient and focused.
Completeness4/5
The toolset provides good coverage for MySQL database management, including querying, health analysis, and optimization. Minor gaps exist, such as the lack of tools for database creation, user management, or backup operations, but core workflows like SQL execution and performance tuning are well-supported.
Average 3.3/5 across 9 of 9 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
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

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses multi-statement support (semicolon-separated), but critically omits: whether the tool returns result sets, error handling behavior, transaction semantics, timeout limits, or safety warnings appropriate for arbitrary SQL execution.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise single sentence with main action front-loaded. The parenthetical addition '(支持多条SQL语句，以分号分隔)' efficiently conveys multi-statement capability without verbosity. No wasted words.
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?
Inadequate for a high-complexity database execution tool with no output schema and no annotations. Missing critical context: return value format (result sets vs execution status), error handling, safety considerations for destructive operations, and whether it distinguishes between DDL/DML/DQL statements.
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 'query' parameter already described as '要执行的SQL语句'. The description adds context that multiple statements are supported (semicolon-separated), which applies to this parameter, but does not elaborate on SQL syntax requirements, injection risks, or result set limits.
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?
Clearly states the tool executes SQL on MySQL databases with specific verb '执行' (execute) and resource 'SQL'. However, it does not explicitly differentiate from read-only siblings like 'get_table_desc' or 'get_table_index' that could be used for inspection instead.
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?
Provides no explicit guidance on when to use this tool versus the specialized read-only alternatives (get_table_desc, get_table_index, etc.). While it notes multi-statement support in parentheses, it lacks warnings about write operations or prerequisites like permissions.
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 search function. It fails to clarify whether the operation is read-only, what specific index metadata is returned, or whether the search supports wildcards/patterns.
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 compact and front-loaded with the key action. The bilingual format (Chinese with English parenthetical) is slightly verbose but acceptable for clarity. No sentences are wasted.
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 single-parameter tool without an output schema, the description is minimally adequate. However, it could be improved by specifying the return format (e.g., list of index names vs. detailed metadata) or clarifying search pattern support given the 'multi-table' capability claim.
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?
With 100% schema coverage (single parameter 'text' described as 'table name to search'), the baseline is met. The description adds value by mentioning 'multi-table query' support, hinting that the text parameter may accept multiple table identifiers, though it does not specify the format (e.g., comma-separated).
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 searches for table indexes based on table names and explicitly mentions multi-table query support. However, it does not explicitly differentiate from siblings like 'get_table_desc' or 'execute_sql' which could potentially retrieve similar information.
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 such as 'execute_sql' (which could query indexes directly) or 'get_table_desc' (which might also return index information). There are no prerequisites or exclusion criteria mentioned.
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 fails to explain what specific health metrics are returned (e.g., connections, uptime, performance metrics), whether the check is read-only, or if it impacts database performance. The term 'running' in the tool name suggests process status monitoring, but the description only mentions general health.
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 with a single bilingual phrase. While not wasteful, the brevity is insufficient given the lack of annotations and output schema. The structure is simple but front-loads the core concept effectively.
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 absence of annotations, output schema, and parameters, the description should explain return values and specific health aspects checked. It fails to clarify what distinguishes this from 'get_db_health_index_usage' or what 'running' implies in the tool name. For a health monitoring tool, this leaves critical gaps in understanding.
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 contains zero parameters, which per evaluation rules establishes a baseline score of 4. There are no parameters requiring semantic clarification beyond the schema definition.
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 identifies the tool's purpose as retrieving/analyzing MySQL health status using specific verbs (获取/Analyze) and resource (MySQL health status). However, it does not distinguish from the sibling tool 'get_db_health_index_usage', which also deals with health but focuses specifically on indexes.
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 'get_db_health_index_usage' or other database monitoring tools. It does not mention prerequisites, execution context, or conditions that would trigger its use.
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?
Without annotations, the description carries the full burden. It discloses multi-table query support (useful behavioral context) but fails to indicate read-only safety, return format details, or whether partial matching/wildcards are supported in the search.
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 bilingual format (Chinese with English parenthetical) is efficient and front-loaded. The single sentence conveys both the core action and a key capability without redundancy, though the dual-language format slightly increases length.
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 single-parameter tool, the description is minimally adequate but lacks return value documentation (critical since no output schema exists) and safety annotations. The multi-table mention helps, but more detail on output structure would improve 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?
With 100% schema coverage, the baseline is 3. The description implies multi-table capability ('supporting multi-table queries') which hints at how the 'text' parameter might be used, but doesn't explicitly document syntax (comma-separated, wildcards, etc.) beyond the schema's basic definition.
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 it searches for 'table structures' and specifically 'table fields' (表字段) based on table names, distinguishing it from sibling get_table_name. However, it doesn't specify the exact schema metadata returned (e.g., data types, constraints, comments).
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?
While it mentions 'supporting multi-table queries' as a capability, it provides no explicit guidance on when to use this tool versus alternatives like execute_sql (which could also retrieve schema) or get_table_name. No 'when-not-to-use' or prerequisites are provided.
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 fails to disclose critical behavioral traits such as whether this is a pure computation (likely) or has side effects, the return value format (string? array? separator used?), rate limits, or idempotency. It only describes the input transformation.
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 front-loads the context ('when creating table structures') and follows with the action. No redundant words; every clause earns its place by establishing either the timing or the transformation logic.
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 simplicity (single string parameter, no nested objects), the description is minimally adequate. However, with no output schema provided, the description should have specified the return format (e.g., comma-separated initials, case format) which is currently missing.
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?
With 100% schema description coverage, the parameter 'text' is fully documented in the schema as comma-separated Chinese text. The description adds domain context by specifying these are 'field names' rather than arbitrary text, but does not add syntax details or examples beyond 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 tool converts Chinese field names to pinyin initials during table structure creation, using specific verbs ('convert') and resources ('Chinese field names', 'pinyin initials'). It distinguishes itself from database health/monitoring siblings by specifying the schema design context.
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 phrase '创建表结构时' (when creating table structures) provides implied usage context, indicating this is for database schema design. However, it lacks explicit guidance on when not to use it, prerequisites, or alternatives to this approach.
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 disclosure burden. While it implies a read-only diagnostic operation, it fails to mention performance impact (does it block?), real-time vs cached data, or what specific lock metadata is returned.
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 bilingual format (Chinese with English parenthetical) is efficient and accessible without redundancy. Information is front-loaded with the action verb immediately followed by the target resource.
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?
While adequate for a zero-parameter tool, the description lacks output format details (e.g., whether it returns thread IDs, lock modes, or blocked queries). Without an output schema, this omission creates a gap in contextual completeness.
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 contains zero parameters, establishing a baseline of 4. The description correctly implies no filtering arguments are needed (server-wide check), consistent with the empty schema.
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 checks for row-level and table-level locks in the current MySQL server. The specific resource (locks) and scope (current server) are explicit, and the function is distinct from siblings like get_table_desc or optimize_sql.
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 provided on when to use this tool versus alternatives like execute_sql (which could query information_schema directly). Missing prerequisites such as required privileges (e.g., PROCESS) or scenarios like deadlock investigation.
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?
With no annotations, description carries full burden. It discloses analytical methodology (execution plans, table structure analysis) and advisory nature ('provides suggestions'), but fails to explicitly state read-only safety, whether it executes the SQL to gather stats, or what output format to expect.
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?
Two-sentence structure is appropriately sized. Some redundancy between sentences (both mention optimization/suggestions), but the second sentence successfully elaborates on specific capabilities (index optimization, query rewriting).
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?
Adequate for a single-parameter tool but missing critical details given no output schema: no description of return value structure (textual advice vs. JSON), no explicit safety guarantees (read-only assertion), and no mention of whether it requires database connection permissions beyond the SQL text itself.
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 has 100% coverage with '要优化的sql'. Description mentions MySQL specifically, implying the SQL should be MySQL-compatible, but adds minimal semantic detail about expected format, length limits, or whether multiple statements are accepted.
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?
Description clearly states the tool optimizes SQL performance using MySQL execution plans and table metadata. It effectively distinguishes from sibling execute_sql (execution vs. analysis) and from metadata tools like get_table_index (retrieval vs. optimization advice).
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?
Description implies usage context (when you need SQL optimization advice) but lacks explicit when-to-use guidance or explicit contrast with alternatives. No mention of prerequisites like requiring valid MySQL SQL syntax or when to prefer execute_sql for testing.
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?
With no annotations provided, the description carries full burden and successfully discloses specific behavioral limits (returns 'top 5' unused indexes, focuses on queries >30 seconds). However, it omits safety-critical details like whether the operation is read-only, expensive to run on large databases, or if it acquires locks.
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?
Bilingual presentation is efficient for accessibility, with the core value proposition (database health diagnostics) presented immediately. The list of three specific check categories is appropriately detailed, though slightly verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Without an output schema, the description adequately compensates by enumerating the three specific data categories returned (redundant, poor performance, unused top 5). Could be improved by indicating the return format (table, JSON array, etc.).
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?
Tool accepts zero parameters, meeting the baseline expectation. The description appropriately implies no filtering is needed by specifying 'currently connected mysql库,' indicating it operates on the active session context without additional inputs.
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?
Description clearly states the specific diagnostic purpose (getting MySQL index usage) and distinguishes from sibling get_table_index by emphasizing database-level health metrics (redundant, poorly performing, unused indexes) rather than table schema listing.
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?
Provides implied usage context (diagnostic/health check scenarios) by listing specific index problems it detects, but lacks explicit guidance on when to use versus alternatives like optimize_sql or get_db_health_running, and omits prerequisites like requiring an existing database connection.
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 carries the full burden. It discloses that the search targets 'comments and descriptions' rather than exact table names, indicating a fuzzy-search behavior. However, it omits critical behavioral details: return format (single name vs list), matching logic (substring vs exact), and pagination 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 bilingual description is efficiently front-loaded with no wasted words. The Chinese-English pairing serves a broad audience without redundancy, and the single sentence structure places the action verb ('Search') and resource ('table names') immediately.
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 absence of an output schema, the description should ideally disclose what the tool returns (e.g., 'returns matching table name(s)'). While the tool name suggests it returns a table name, ambiguity remains regarding single vs. multiple results. The input side is fully covered, but the output side leaves gaps for an agent trying to chain this with get_table_desc.
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 100% schema coverage, the baseline is 3. The description adds valuable semantics: it clarifies that 'text' refers to Chinese table names or descriptions (not English table names), and includes the crucial constraint '仅支持单个查询' (only supports single query), which warns against batch inputs not obvious from the schema alone.
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 searches for table names using Chinese names or descriptions as the search key. It distinguishes itself from siblings like execute_sql (general SQL), get_table_desc (likely requires exact table name), and get_table_index/lock (performance/metadata tools) by specifying its unique fuzzy-search capability based on comments/descriptions.
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 context by specifying the search mechanism (Chinese names/descriptions), suggesting when to use it (when exact table names are unknown). However, it lacks explicit comparisons with siblings like get_table_desc or execute_sql, and doesn't state 'when not to use' or prerequisites.
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/lyuhaochen/mysql_mcp/badges/card.svg)](https://glama.ai/mcp/servers/lyuhaochen/mysql_mcp)

Score Badge

Copy to your README.md:

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

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