Which integrations are available for this server?

Provides read-only SQL query execution and database exploration capabilities for MySQL databases, allowing natural language queries via Claude.

How do I use MySQL MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MySQL MCP Server What tables are in my database?" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

MySQL MCP Server

by hovecapital

Overview Schema Related Servers Score Discussions

JavaScript

Remote

MySQL MCP Server

MCP Registry npm version

A Model Context Protocol (MCP) server that enables Claude Desktop to interact with MySQL databases through natural language queries.

Features

Execute read-only SQL queries through Claude Desktop
Dynamic connection configuration — connect to any MySQL database at runtime via connection string
Built-in security with query validation (only SELECT statements allowed)
Easy integration with Claude Desktop
JSON formatted query results
Environment-based configuration for database credentials

Related MCP server: MCP MySQL Server

Quick Start

For Claude Code Users (Recommended - Easiest Method)

claude mcp add mysql -s user -- npx -y @hovecapital/read-only-mysql-mcp-server@latest

Then set your database environment variables:

export DB_HOST=localhost
export DB_PORT=3306
export DB_DATABASE=your_database_name
export DB_USERNAME=your_username
export DB_PASSWORD=your_password

Done! Restart Claude Code and ask: "What tables are in my database?"

For Claude Desktop Users (Manual Configuration)

1. Open your config file:

# macOS
open ~/Library/Application\ Support/Claude/claude_desktop_config.json

# Windows
notepad %APPDATA%\Claude\claude_desktop_config.json

2. Add this configuration:

{
  "mcpServers": {
    "mysql": {
      "command": "npx",
      "args": ["-y", "@hovecapital/read-only-mysql-mcp-server@latest"],
      "env": {
        "DB_HOST": "localhost",
        "DB_PORT": "3306",
        "DB_DATABASE": "your_database_name",
        "DB_USERNAME": "your_username",
        "DB_PASSWORD": "your_password"
      }
    }
  }
}

3. Save, restart Claude Desktop, and test!

Prerequisites

Node.js (v16 or higher) - If using mise, update the command path accordingly
MySQL database server
Claude Desktop application

Installation

Option 1: Install from MCP Registry (Recommended)

This server is published in the Model Context Protocol Registry as capital.hove/read-only-local-mysql-mcp-server.

Method A: Claude Code CLI (Easiest!)

claude mcp add mysql -s user -- npx -y @hovecapital/read-only-mysql-mcp-server@latest

Then configure your database credentials using environment variables. Restart Claude Code and you're done!

Benefits:

One command installation
No manual JSON editing
Automatic configuration

Method B: Manual JSON Configuration

For Claude Desktop:

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "mysql": {
      "command": "npx",
      "args": ["-y", "@hovecapital/read-only-mysql-mcp-server@latest"],
      "env": {
        "DB_HOST": "localhost",
        "DB_PORT": "3306",
        "DB_DATABASE": "your_database_name",
        "DB_USERNAME": "your_username",
        "DB_PASSWORD": "your_password"
      }
    }
  }
}

For Claude Code:

Edit ~/.config/claude-code/settings.json (macOS/Linux) or %APPDATA%\claude-code\settings.json (Windows):

{
  "mcp": {
    "servers": {
      "mysql": {
        "command": "npx",
        "args": ["-y", "@hovecapital/read-only-mysql-mcp-server@latest"],
        "env": {
          "DB_HOST": "localhost",
          "DB_PORT": "3306",
          "DB_DATABASE": "your_database_name",
          "DB_USERNAME": "your_username",
          "DB_PASSWORD": "your_password"
        }
      }
    }
  }
}

Option 2: Install from npm

npm install -g @hovecapital/read-only-mysql-mcp-server

Option 3: Installation with Claude Code

If you're using Claude Code, you can easily install this MCP server:

# Clone the repository
git clone https://github.com/hovecapital/read-only-local-mysql-mcp-server.git
cd read-only-local-mysql-mcp-server

# Install dependencies and build
npm install
npm run build

Then configure Claude Code by adding to your MCP settings.

Option 4: Manual Installation

1. Clone or Download

Save the repository to a directory on your system:

mkdir ~/mcp-servers/mysql
cd ~/mcp-servers/mysql
git clone https://github.com/hovecapital/read-only-local-mysql-mcp-server.git .

2. Install Dependencies

npm install
npm run build

Configuration

Note: If you installed via Option 1 (MCP Registry with npx), you've already configured everything! This section is for users who chose Options 2, 3, or 4 (npm or manual installation).

Claude Code Configuration

If you're using Claude Code with a manual installation, add the MySQL server to your MCP settings:

Open your Claude Code settings (typically in ~/.config/claude-code/settings.json on macOS/Linux or %APPDATA%\claude-code\settings.json on Windows)
Add the MySQL MCP server configuration:

{
  "mcp": {
    "servers": {
      "mysql": {
        "command": "node",
        "args": ["/absolute/path/to/read-only-local-mysql-mcp-server/dist/index.js"],
        "env": {
          "DB_HOST": "localhost",
          "DB_PORT": "3306",
          "DB_DATABASE": "your_database_name",
          "DB_USERNAME": "your_username",
          "DB_PASSWORD": "your_password"
        }
      }
    }
  }
}

Restart Claude Code for the changes to take effect.

Claude Desktop Configuration

If you're using Claude Desktop with a manual installation, open your Claude Desktop configuration file:

macOS:

~/Library/Application Support/Claude/claude_desktop_config.json

Windows:

%APPDATA%\Claude\claude_desktop_config.json

Add the MySQL server configuration:

{
  "mcpServers": {
    "mysql": {
      "command": "node",
      "args": ["/absolute/path/to/read-only-local-mysql-mcp-server/dist/index.js"],
      "env": {
        "DB_HOST": "localhost",
        "DB_PORT": "3306",
        "DB_DATABASE": "your_database_name",
        "DB_USERNAME": "your_username",
        "DB_PASSWORD": "your_password"
      }
    }
  }
}

Using mise for Node.js

If you're using mise for Node.js version management, make sure to use the full path to the Node.js executable in your configuration.

Environment Variables

Variable	Description	Default
`DB_HOST`	MySQL server hostname	`mysql`
`DB_PORT`	MySQL server port	`3306`
`DB_DATABASE`	Database name	`database`
`DB_USERNAME`	MySQL username	`root`
`DB_PASSWORD`	MySQL password	(empty)

Usage

Restart Claude Desktop after updating the configuration
Start chatting with Claude about your database

Example Queries

"Show me all tables in my database"
"What's the structure of the users table?"
"Get the first 10 records from the products table"
"How many orders were placed last month?"
"Show me users with email addresses ending in @gmail.com"

Claude will automatically convert your natural language requests into appropriate SQL queries and execute them against your database.

Tools

`connect`

Connect to a MySQL database using a connection string. The connection persists for subsequent queries until changed or disconnected.

Parameters:

Parameter	Required	Description
`connectionString`	Yes	MySQL connection string (e.g., `mysql://user:password@host:port/database`)

`disconnect`

Disconnect from the current runtime database and revert to the default environment-configured connection. Takes no parameters.

`query`

Run a read-only SQL query against the currently connected database.

Parameters:

Parameter	Required	Description
`sql`	Yes	SQL query to execute (read-only)
`connectionString`	No	MySQL connection string to override the current connection for this query only

Dynamic Connection

The server supports switching databases at runtime without restarting. Connection priority:

Per-query connectionString — overrides everything for a single query
Runtime connection (from connect tool) — persists until disconnect is called
Environment variables — the default fallback

Connection string format:

mysql://username:password@hostname:port/database_name

Example workflow:

1. connect → mysql://analyst:pass@prod-db:3306/analytics
2. query   → SELECT COUNT(*) FROM events
3. query   → SELECT * FROM users LIMIT 5 (uses the same analytics connection)
4. query   → SELECT * FROM orders LIMIT 5, connectionString: mysql://analyst:pass@prod-db:3306/sales
              (one-off override — does not change the stored connection)
5. disconnect → reverts to env var defaults

Security Features

Read-Only Operations

The server only allows SELECT queries. The following operations are blocked:

INSERT - Adding new records
UPDATE - Modifying existing records
DELETE - Removing records
DROP - Removing tables/databases
ALTER - Modifying table structure
CREATE - Creating new tables/databases

Recommended Database Setup

For enhanced security, create a dedicated read-only user for the MCP server:

-- Create a read-only user
CREATE USER 'claude_readonly'@'localhost' IDENTIFIED BY 'secure_password';

-- Grant only SELECT permissions on your specific database
GRANT SELECT ON your_database_name.* TO 'claude_readonly'@'localhost';

-- Apply the changes
FLUSH PRIVILEGES;

Troubleshooting

Connection Issues

Verify MySQL is running: Check if your MySQL server is active
Check credentials: Ensure username/password are correct
Network connectivity: Confirm Claude Desktop can reach your MySQL server

Configuration Issues

Restart required: Always restart Claude Desktop after configuration changes
Path accuracy: Ensure the absolute path to dist/index.js is correct
JSON syntax: Validate your claude_desktop_config.json format

Debug Mode

To see server logs, you can run the server manually:

node dist/index.js

File Structure

~/mcp-servers/mysql/
├── src/
│   └── index.ts
├── dist/
│   ├── index.js
│   └── index.d.ts
├── package.json
├── tsconfig.json
└── node_modules/

Dependencies

@modelcontextprotocol/sdk: MCP protocol implementation
mysql2: Modern MySQL client for Node.js with Promise support

Contributing

Feel free to submit issues and enhancement requests!

License

This project is open source and available under the MIT License.

Support

If you encounter issues:

Check the troubleshooting section above
Verify your MySQL connection independently
Ensure Claude Desktop is updated to the latest version
Review the Claude Desktop MCP documentation

Note: This server is designed for development and analysis purposes. For production use, consider additional security measures and monitoring.

Available Tools

3 tools

connectA

Connect to a MySQL database using a connection string. The connection will be used for subsequent queries until changed.

ParametersJSON Schema

Name	Required	Description	Default
`connectionString`	Yes	MySQL connection string (e.g., mysql://user:password@host:port/database)

TDQS

A4.2/5.0

Behavior3/5

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

No annotations, so description carries full burden. Indicates statefulness but lacks details on error handling, timeouts, or reconnection 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?

Two sentences, no fluff, front-loaded with purpose. Efficient.

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?

Given only one parameter and no output schema, description covers essential purpose and statefulness. Adequate for a setup tool.

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 100%; description adds example format for connection string, providing extra context beyond 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?

Clearly states action (connect), resource (MySQL database), and method (connection string). Distinguishes from siblings disconnect and query.

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

Usage Guidelines4/5

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

Implies usage before queries, but does not explicitly state when not to use or alternative disconnection. Still clear enough.

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

disconnectA

Disconnect from the current runtime database and revert to the default environment-configured connection

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A3.7/5.0

Behavior2/5

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

No annotations are provided, so the description alone must convey behavioral traits. It does not disclose side effects (e.g., dropping open transactions, whether it's safe, or if it changes global state). This is insufficient for a mutating 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, front-loaded sentence that conveys the essential purpose without unnecessary words. Every word earns its place.

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 simple tool with no parameters and no output schema, the description is fairly complete in stating the action. However, it lacks details on what happens after disconnection (e.g., connection state management) and any error conditions, which would be helpful for 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?

There are no parameters, and the schema coverage is 100% (empty schema). The description adds context beyond the schema by specifying what is being disconnected from, which is valuable for understanding the tool's action.

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 verb 'disconnect' and the specific resource 'current runtime database', and explains the effect of reverting to the default connection. This distinguishes it from siblings 'connect' and '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 implies usage after connecting but does not explicitly state when to use or when not to use, nor does it mention prerequisites like being connected. More guidance would help an agent decide.

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

queryA

Run a read-only SQL query against the currently connected database

ParametersJSON Schema

Name	Required	Description	Default
`sql`	Yes	SQL query to execute (read-only)
`connectionString`	No	Optional: MySQL connection string to override the current connection for this query only

TDQS

A3.6/5.0

Behavior2/5

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

With no annotations, the description bears full burden for behavioral disclosure. It only notes 'read-only', which is a key trait, but fails to describe error handling, response format, or what happens on invalid SQL. No info on permissions or rate limits.

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 10-word sentence that front-loads the key action and read-only constraint. Every word is purposeful, with no fluff.

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

Completeness2/5

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

Given the lack of output schema and annotations, the description is sparse. It does not explain return values, error behavior, or the effect of the optional connectionString override. For a database query tool, more detail would be expected for 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 coverage is 100% (both parameters have descriptions in the schema). The description adds no additional meaning beyond what the schema provides; it only mentions 'currently connected database' which is tangentially related to the connectionString parameter but does not clarify its usage.

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 'Run a read-only SQL query against the currently connected database', specifying the verb 'run', the resource 'SQL query', and the read-only nature, which distinguishes it from potential write operations. The sibling tools are 'connect' and 'disconnect', making 'query' obviously the data retrieval tool.

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

Usage Guidelines4/5

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

The description implies usage when a connection is already established ('against the currently connected database'), providing context that the tool requires a prior connection. However, it does not explicitly state when to use alternatives like 'connect' or 'disconnect', though the sibling names make this obvious. No exclusive guidance is given.

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

Tool Schema Changelog

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

3 tool updatesv0.1.1Jun 24, 2026
- First observedconnect
- First observeddisconnect
- First observedquery

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.9/5.0

Disambiguation5/5

Each tool has a clear, distinct purpose: connecting, disconnecting, and querying. There is no overlap or ambiguity.

Naming Consistency5/5

All tool names are single verbs (connect, disconnect, query), following a consistent pattern. No mixing of conventions.

Tool Count4/5

Three tools is minimal but covers the essential operations for a simple MySQL server. While somewhat thin, it is well-scoped and avoids unnecessary tools.

Completeness3/5

The tool set covers connect, disconnect, and read-only queries, but lacks any schema exploration or metadata tools (e.g., list tables). This limits usability for agents that need to discover the database structure.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

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

Related MCP Connectors

mcpmyadminOAuth
ai.mcpmyadmin
Query 40 databases from Claude, ChatGPT, or Cursor — on any device. Read-only, encrypted, audited.
Databases Security
2
QueryBearOAuth
io.github.spencerpauly
Safe, read-only Postgres and MySQL access for AI agents. Audit log + column-level controls.
Databases RAG Systems
2
Contextflo
com.contextflo
Query your warehouse or a CSV with Claude/ChatGPT over MCP, governed by table-level ACL + audit.
Databases Security
1
Dataassist-IOOAuth
io.github.DataAssistIO
Query your org's data in natural language — read-only MCP access to SQL, NoSQL, files & warehouses.
Search Databases
2

Related MCP Servers

MCPDB - Database Access MCP
Databases RAG Systems
jantuitman
F
license
Not graded
quality
D
maintenance
Provides Claude Desktop with secure access to multiple database connections, allowing users to query MySQL, PostgreSQL, SQLite, and SQL Server databases directly through natural language.
Updated a year ago (2025-05-29 13:39 UTC)
-
MCP MySQL Server
Databases Developer Tools
keleshteri
A
license
Not graded
quality
D
maintenance
Enables Claude Desktop to interact with MySQL databases through secure query execution, schema discovery, and multi-database support with configurable read/write permissions and built-in SQL injection protection.
Updated a year ago (2025-07-31 06:34 UTC)
121
MIT
MySQL MCP Server
Databases Developer Tools
bhaveshrmahajan
A
license
Not graded
quality
D
maintenance
Connects AI assistants like Claude Desktop directly to MySQL databases, enabling natural language interaction for schema inspection, data querying, CRUD operations, and database administration tasks.
Updated 3 months ago (2026-05-31 14:59 UTC)
21
MIT
Universal DB MCP
Databases Search Developer Tools
Anarkh-Lee
A
license
Not graded
quality
C
maintenance
Enables Claude Desktop to interact with MySQL, PostgreSQL, and Redis databases using natural language for data querying and schema analysis. It provides a secure interface with a default read-only mode to prevent unauthorized database modifications.
Updated 6 months ago (2026-03-17 08:35 UTC)
115
922
MIT

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/hovecapital/read-only-local-mysql-mcp-server'

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