SQLx MCP Server

A Model Context Protocol (MCP) server implementation in Rust that provides comprehensive database management tools using SQLx.

🚀 Features

This server provides 6 powerful MCP tools for database management:

1. 🔍 get_database_info - Get basic database information

2. 📋 list_tables - List all tables with metadata (comments, row counts, etc.)

3. 🏗️ get_table_structure - Get detailed table structure information

4. 📜 get_table_ddl - Export table DDL (CREATE TABLE statements)

5. 👁️ execute_readonly_query - Execute read-only SQL queries safely

6. ✏️ execute_write_query - Execute write SQL operations

🎯 Smart Configuration Management

• Auto-Configuration Detection: Server automatically detects and reports database configuration at startup

• Client Notification: Clients receive configuration status via MCP protocol initialization

• Flexible URL Management: Optional database URL parameters when server is pre-configured

• Secure Display: Database credentials are automatically masked for security

🗄️ Supported Databases

• PostgreSQL - Full support with native features

• MySQL - Complete functionality including engine-specific features

• SQLite - Comprehensive support for embedded database operations

🔧 Installation

Option 1: NPM (Recommended)

Install globally via npm:

Or use directly with npx (no installation needed):

Option 2: Build from Source

Prerequisites

• Rust 1.70 or later

• Git

Build Steps

🚀 Quick Start

1. Run as Standalone Server

Using NPM/npx (Recommended):

Using Built Binary:

2. Integrate with Claude Desktop

Add to your Claude Desktop configuration. The server will automatically notify Claude about the current database configuration status.

Using NPM Package (Recommended):

With Environment Variable (Recommended):

With Command Line Argument:

Without Pre-configuration (require database_url in each tool call):

Using Built Binary:

Windows (

macOS/Linux:

🔗 Database Configuration

The server provides intelligent database configuration management with automatic detection and client notification.

Configuration Priority

The server resolves database connections with the following priority:

1. Tool Parameter (highest) - database_url parameter in individual tool calls

2. Command Line - --database-url argument at server startup

3. Environment Variable (lowest) - DATABASE_URL environment variable

Auto-Detection & Client Notification

When clients connect to the MCP server, they automatically receive configuration information:

• Configuration Status: Whether a database is pre-configured

• Connection Source: How the database was configured (command line, environment, or none)

• Masked URL: Database connection string with credentials safely hidden

• Usage Guidance: Whether database_url parameter is required in tool calls

Example Client Notifications:

No Configuration:

Environment Variable Configuration:

Command Line Configuration:

Flexible Usage Patterns

Pre-configured Server (Recommended)

Then use tools without database_url parameter:

Per-Tool Database URLs

This allows flexible connection management for multiple databases.

🛠️ Tool Usage Examples

Get Database Information

List Tables with Metadata

Export Table DDL

Execute Safe Read-Only Queries

Supports SELECT, WITH (CTE), SHOW, DESCRIBE, EXPLAIN:

Note: When the server is pre-configured with a database (via command line or environment variable), the database_url parameter becomes optional in all tool calls. The server will notify clients about the current configuration status during MCP initialization.

🔒 Security Features

• Query Validation: Strict read-only query enforcement for safe operations

• SQL Injection Protection: Parameterized queries where possible

• Connection Security: Supports SSL/TLS encrypted connections

• Access Control: Respects database user permissions

• Credential Protection: Database passwords automatically masked in logs and client notifications

• Secure Configuration Display: Connection strings shown with sensitive information hidden

🏗️ Architecture

Built with modern Rust ecosystem:

• rmcp - Rust MCP SDK for protocol compliance

• SQLx - Async SQL toolkit with compile-time checked queries

• Tokio - Async runtime for high performance

• Serde - Serialization framework for JSON handling

• Tracing - Structured logging and debugging

📚 Documentation

• Detailed Usage Guide

• Database Configuration Guide

• DDL Export Feature

• List Tables Feature

• Improvements Summary

• Deployment Guide

• PowerShell Environment Setup

🔧 Development & Release

This project includes an advanced automated release system powered by AI:

Environment Setup

For Windows PowerShell users who want to use the automated release features:

For detailed PowerShell environment setup, see PowerShell Environment Setup Guide.

Release Management

The project includes a comprehensive release script with AI-powered commit message generation:

Features:

• 🤖 AI-powered commit message generation using OpenRouter

• 📦 Automatic version management

• 🔄 Multi-file synchronization (Cargo.toml ↔ package.json)

• 🚀 Git automation (commit, tag, push)

• 🖥️ Cross-platform support (Windows, macOS, Linux)

🤝 Contributing

1. Fork the repository

2. Create a feature branch (git checkout -b feature/amazing-feature)

3. Commit your changes (git commit -m 'Add some amazing feature')

4. Push to the branch (git push origin feature/amazing-feature)

5. Open a Pull Request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• Model Context Protocol for the protocol specification

• SQLx for the excellent SQL toolkit

• rmcp for the Rust MCP SDK

📞 Support

• Create an Issue for bug reports

• Start a Discussion for questions

• Check the Documentation for detailed guides

Made with ❤️ and 🦀 (Rust)