mcp-dbutils 0.9.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

mcp_dbutils/postgres/config.py

@@ -1,28 +1,35 @@
 """PostgreSQL configuration module"""
 from dataclasses import dataclass
 from typing import Optional, Dict, Any, Literal
-from urllib.parse import urlparse
+from urllib.parse import urlparse, parse_qs
 from ..config import ConnectionConfig
 
-def parse_jdbc_url(jdbc_url: str) -> Dict[str, str]:
-    """Parse JDBC URL into connection parameters
+@dataclass
+class SSLConfig:
+    """SSL configuration for PostgreSQL connection"""
+    mode: Literal['disable', 'require', 'verify-ca', 'verify-full'] = 'disable'
+    cert: Optional[str] = None
+    key: Optional[str] = None
+    root: Optional[str] = None
+
+def parse_url(url: str) -> Dict[str, Any]:
+    """Parse PostgreSQL URL into connection parameters
     
     Args:
-        jdbc_url: JDBC URL (e.g. jdbc:postgresql://host:port/dbname)
+        url: URL (e.g. postgresql://host:port/dbname?sslmode=verify-full)
         
     Returns:
-        Dictionary of connection parameters
+        Dictionary of connection parameters including SSL settings
     """
-    if not jdbc_url.startswith('jdbc:postgresql://'):
-        raise ValueError("Invalid PostgreSQL JDBC URL format")
+    if not url.startswith('postgresql://'):
+        raise ValueError("Invalid PostgreSQL URL format")
     
-    # Remove jdbc: prefix and ensure no credentials in URL
-    url = jdbc_url[5:]
     if '@' in url:
-        raise ValueError("JDBC URL should not contain credentials. Please provide username and password separately.")
+        raise ValueError("URL should not contain credentials. Please provide username and password separately.")
     
-    # Parse URL
+    # Parse URL and query parameters
     parsed = urlparse(url)
+    query_params = parse_qs(parsed.query)
     
     params = {
         'host': parsed.hostname or 'localhost',
@@ -32,6 +39,24 @@ def parse_jdbc_url(jdbc_url: str) -> Dict[str, str]:
     
     if not params['dbname']:
         raise ValueError("PostgreSQL database name must be specified in URL")
+
+    # Parse SSL parameters if present
+    ssl_params = {}
+    if 'sslmode' in query_params:
+        mode = query_params['sslmode'][0]
+        if mode not in ['disable', 'require', 'verify-ca', 'verify-full']:
+            raise ValueError(f"Invalid sslmode: {mode}")
+        ssl_params['mode'] = mode
+        
+    if 'sslcert' in query_params:
+        ssl_params['cert'] = query_params['sslcert'][0]
+    if 'sslkey' in query_params:
+        ssl_params['key'] = query_params['sslkey'][0]
+    if 'sslrootcert' in query_params:
+        ssl_params['root'] = query_params['sslrootcert'][0]
+        
+    if ssl_params:
+        params['ssl'] = SSLConfig(**ssl_params)
         
     return params
 
@@ -44,6 +69,8 @@ class PostgreSQLConfig(ConnectionConfig):
     port: str = '5432'
     local_host: Optional[str] = None
     type: Literal['postgres'] = 'postgres'
+    url: Optional[str] = None
+    ssl: Optional[SSLConfig] = None
 
     @classmethod
     def from_yaml(cls, yaml_path: str, db_name: str, local_host: Optional[str] = None) -> 'PostgreSQLConfig':
@@ -74,9 +101,9 @@ class PostgreSQLConfig(ConnectionConfig):
             raise ValueError("Password must be specified in connection configuration")
 
         # Get connection parameters
-        if 'jdbc_url' in db_config:
-            # Parse JDBC URL for connection parameters
-            params = parse_jdbc_url(db_config['jdbc_url'])
+        if 'url' in db_config:
+            # Parse URL for connection parameters
+            params = parse_url(db_config['url'])
             config = cls(
                 dbname=params['dbname'],
                 user=db_config['user'],
@@ -84,6 +111,8 @@ class PostgreSQLConfig(ConnectionConfig):
                 host=params['host'],
                 port=params['port'],
                 local_host=local_host,
+                url=db_config['url'],
+                ssl=params.get('ssl')
             )
         else:
             if not db_config.get('dbname'):
@@ -92,6 +121,24 @@ class PostgreSQLConfig(ConnectionConfig):
                 raise ValueError("Host must be specified in connection configuration")
             if not db_config.get('port'):
                 raise ValueError("Port must be specified in connection configuration")
+            
+            # Parse SSL configuration if present
+            ssl_config = None
+            if 'ssl' in db_config:
+                ssl_params = db_config['ssl']
+                if not isinstance(ssl_params, dict):
+                    raise ValueError("SSL configuration must be a dictionary")
+                
+                if ssl_params.get('mode') not in [None, 'disable', 'require', 'verify-ca', 'verify-full']:
+                    raise ValueError(f"Invalid sslmode: {ssl_params.get('mode')}")
+                
+                ssl_config = SSLConfig(
+                    mode=ssl_params.get('mode', 'disable'),
+                    cert=ssl_params.get('cert'),
+                    key=ssl_params.get('key'),
+                    root=ssl_params.get('root')
+                )
+            
             config = cls(
                 dbname=db_config['dbname'],
                 user=db_config['user'],
@@ -99,17 +146,18 @@ class PostgreSQLConfig(ConnectionConfig):
                 host=db_config['host'],
                 port=str(db_config['port']),
                 local_host=local_host,
+                ssl=ssl_config
             )
         config.debug = cls.get_debug_mode()
         return config
 
     @classmethod
-    def from_jdbc_url(cls, jdbc_url: str, user: str, password: str, 
-                     local_host: Optional[str] = None) -> 'PostgreSQLConfig':
-        """Create configuration from JDBC URL and credentials
+    def from_url(cls, url: str, user: str, password: str, 
+                local_host: Optional[str] = None) -> 'PostgreSQLConfig':
+        """Create configuration from URL and credentials
         
         Args:
-            jdbc_url: JDBC URL (jdbc:postgresql://host:port/dbname)
+            url: URL (postgresql://host:port/dbname)
             user: Username for connection
             password: Password for connection
             local_host: Optional local host address
@@ -117,7 +165,7 @@ class PostgreSQLConfig(ConnectionConfig):
         Raises:
             ValueError: If URL format is invalid or required parameters are missing
         """
-        params = parse_jdbc_url(jdbc_url)
+        params = parse_url(url)
         
         config = cls(
             dbname=params['dbname'],
@@ -126,6 +174,8 @@ class PostgreSQLConfig(ConnectionConfig):
             host=params['host'],
             port=params['port'],
             local_host=local_host,
+            url=url,
+            ssl=params.get('ssl')
         )
         config.debug = cls.get_debug_mode()
         return config
@@ -139,6 +189,17 @@ class PostgreSQLConfig(ConnectionConfig):
             'host': self.local_host or self.host,
             'port': self.port
         }
+        
+        # Add SSL parameters if configured
+        if self.ssl:
+            params['sslmode'] = self.ssl.mode
+            if self.ssl.cert:
+                params['sslcert'] = self.ssl.cert
+            if self.ssl.key:
+                params['sslkey'] = self.ssl.key
+            if self.ssl.root:
+                params['sslrootcert'] = self.ssl.root
+                
         return {k: v for k, v in params.items() if v}
 
     def get_masked_connection_info(self) -> Dict[str, Any]:

mcp_dbutils-0.10.0.dist-info/METADATA

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: mcp-dbutils
+Version: 0.10.0
+Summary: MCP Database Utilities Service
+Author: Dong Hao
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.2.1
+Requires-Dist: psycopg2-binary>=2.9.10
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: pyyaml>=6.0.2
+Provides-Extra: test
+Requires-Dist: aiosqlite>=0.19.0; extra == 'test'
+Requires-Dist: docker>=7.0.0; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'test'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'test'
+Requires-Dist: pytest-docker>=2.0.0; extra == 'test'
+Requires-Dist: pytest>=7.0.0; extra == 'test'
+Requires-Dist: testcontainers>=3.7.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# MCP Database Utilities
+
+![GitHub Repo stars](https://img.shields.io/github/stars/donghao1393/mcp-dbutils)
+![PyPI version](https://img.shields.io/pypi/v/mcp-dbutils)
+[![Coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/donghao1393/bdd0a63ec2a816539ff8c136ceb41e48/raw/coverage.json)](https://github.com/donghao1393/mcp-dbutils/actions)
+![Python](https://img.shields.io/badge/Python-3.10%2B-blue)
+![License](https://img.shields.io/github/license/donghao1393/mcp-dbutils)
+[![smithery badge](https://smithery.ai/badge/@donghao1393/mcp-dbutils)](https://smithery.ai/server/@donghao1393/mcp-dbutils)
+
+[中文文档](README_CN.md)
+
+## Overview
+MCP Database Utilities is a unified database access service that supports multiple database types (PostgreSQL and SQLite). Through its abstraction layer design, it provides a simple and unified database operation interface for MCP servers.
+
+## Features
+- Unified database access interface
+- Support for multiple database configurations
+- Secure read-only query execution
+- Table structure and schema information retrieval
+- Database tables listing via MCP tools
+- Intelligent connection management and resource cleanup
+- Debug mode support
+- SSL/TLS connection support for PostgreSQL
+
+## Installation and Configuration
+
+### Installation Methods
+#### Installing via Smithery
+
+To install Database Utilities for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@donghao1393/mcp-dbutils):
+
+```bash
+npx -y @smithery/cli install @donghao1393/mcp-dbutils --client claude
+```
+
+#### Using uvx (Recommended)
+No installation required, run directly using `uvx`:
+```bash
+uvx mcp-dbutils --config /path/to/config.yaml
+```
+
+Add to Claude configuration:
+```json
+"mcpServers": {
+  "mcp-dbutils": {
+    "command": "uvx",
+    "args": [
+      "mcp-dbutils",
+      "--config",
+      "/path/to/config.yaml"
+    ],
+    "env": {
+      "MCP_DEBUG": "1"  // Optional: Enable debug mode
+    }
+  }
+}
+```
+
+#### Using pip
+```bash
+pip install mcp-dbutils
+```
+
+Add to Claude configuration:
+```json
+"mcpServers": {
+  "mcp-dbutils": {
+    "command": "python",
+    "args": [
+      "-m",
+      "mcp_dbutils",
+      "--config",
+      "/path/to/config.yaml"
+    ],
+    "env": {
+      "MCP_DEBUG": "1"  // Optional: Enable debug mode
+    }
+  }
+}
+```
+
+#### Using Docker
+```bash
+docker run -i --rm \
+  -v /path/to/config.yaml:/app/config.yaml \
+  -v /path/to/sqlite.db:/app/sqlite.db \  # Optional: for SQLite database
+  -e MCP_DEBUG=1 \  # Optional: Enable debug mode
+  mcp/dbutils --config /app/config.yaml
+```
+
+Add to Claude configuration:
+```json
+"mcpServers": {
+  "mcp-dbutils": {
+    "command": "docker",
+    "args": [
+      "run",
+      "-i",
+      "--rm",
+      "-v",
+      "/path/to/config.yaml:/app/config.yaml",
+      "-v",
+      "/path/to/sqlite.db:/app/sqlite.db",  // Optional: for SQLite database
+      "mcp/dbutils",
+      "--config",
+      "/app/config.yaml"
+    ],
+    "env": {
+      "MCP_DEBUG": "1"  // Optional: Enable debug mode
+    }
+  }
+}
+```
+
+> **Note for Docker database connections:**
+> - For SQLite: Mount your database file using `-v /path/to/sqlite.db:/app/sqlite.db`
+> - For PostgreSQL running on host:
+>   - On Mac/Windows: Use `host.docker.internal` as host in config
+>   - On Linux: Use `172.17.0.1` (docker0 IP) or run with `--network="host"`
+
+### Requirements
+- Python 3.10+
+- PostgreSQL (optional)
+- SQLite3 (optional)
+
+### Configuration File
+The project requires a YAML configuration file, specified via the `--config` parameter. Configuration examples:
+
+```yaml
+connections:
+  # SQLite configuration examples
+  dev-db:
+    type: sqlite
+    path: /path/to/dev.db
+    # Password is optional
+    password: 
+
+  # PostgreSQL standard configuration
+  test-db:
+    type: postgres
+    host: postgres.example.com
+    port: 5432
+    dbname: test_db
+    user: test_user
+    password: test_pass
+
+  # PostgreSQL URL configuration with SSL
+  prod-db:
+    type: postgres
+    url: postgresql://postgres.example.com:5432/prod-db?sslmode=verify-full
+    user: prod_user
+    password: prod_pass
+    
+  # PostgreSQL full SSL configuration example
+  secure-db:
+    type: postgres
+    host: secure-db.example.com
+    port: 5432
+    dbname: secure_db
+    user: secure_user
+    password: secure_pass
+    ssl:
+      mode: verify-full  # disable/require/verify-ca/verify-full
+      cert: /path/to/client-cert.pem
+      key: /path/to/client-key.pem
+      root: /path/to/root.crt
+```
+
+PostgreSQL SSL Configuration Options:
+1. Using URL parameters:
+   ```
+   postgresql://host:port/dbname?sslmode=verify-full&sslcert=/path/to/cert.pem
+   ```
+2. Using dedicated SSL configuration section:
+   ```yaml
+   ssl:
+     mode: verify-full  # SSL verification mode
+     cert: /path/to/cert.pem      # Client certificate
+     key: /path/to/key.pem        # Client private key
+     root: /path/to/root.crt      # CA certificate
+   ```
+
+SSL Modes:
+- disable: No SSL
+- require: Use SSL but no certificate verification
+- verify-ca: Verify server certificate is signed by trusted CA
+- verify-full: Verify server certificate and hostname match
+
+SQLite Configuration Options:
+1. Basic configuration with path:
+   ```yaml
+   type: sqlite
+   path: /path/to/db.sqlite
+   password: optional_password  # Optional encryption
+   ```
+2. Using URI parameters:
+   ```yaml
+   type: sqlite
+   path: /path/to/db.sqlite?mode=ro&cache=shared
+   ```
+
+### Debug Mode
+Set environment variable `MCP_DEBUG=1` to enable debug mode for detailed logging output.
+
+[Rest of the README content remains unchanged...]

{mcp_dbutils-0.9.0.dist-info → mcp_dbutils-0.10.0.dist-info}/RECORD

@@ -4,15 +4,15 @@ mcp_dbutils/config.py,sha256=uFI4Haw4en5gxHfCM9zugUqNCQFikdlHJZU_NTht7gQ,1905
 mcp_dbutils/log.py,sha256=fibVIwsb1HVU5zriGrDZTMEirKjgIuxuN_B_YTdAJ7I,996
 mcp_dbutils/stats.py,sha256=WYD9NAKHH2bFKmUSTOg18-SuIXergpznPq8AtIjtxdI,7101
 mcp_dbutils/postgres/__init__.py,sha256=XanCXw-kVE6ayqFqjuLJ9swWPcCVlcKZXB2Et2Wjl9w,154
-mcp_dbutils/postgres/config.py,sha256=Kqq0ZCa7PhtvMaBX3sfdEscGosHR1dWuiP8IkI5lzDo,5495
+mcp_dbutils/postgres/config.py,sha256=FG0YUV4TtP1IGZT87ov_PK-ouOEjAOHdSaK42klk5OE,7750
 mcp_dbutils/postgres/handler.py,sha256=O45K0MOosNQ68SJ8piXXH3aZ74RVQ981hudk6faj28Y,24397
 mcp_dbutils/postgres/server.py,sha256=FROogvjr3xlKAZcAvJMNHGgyHqT_LaMK9-vYbA0Dbm0,8716
 mcp_dbutils/sqlite/__init__.py,sha256=lTUOkSfSWNw_BohJ_KNxYKMCANdtpGa3JK_ZyJsg_Ls,134
 mcp_dbutils/sqlite/config.py,sha256=2ekTp89rcCu4qQN1O3sZjIcOwjhzWi4tisD20T2WAik,4533
 mcp_dbutils/sqlite/handler.py,sha256=VxBVbwpNSQHyiudQXYFYpcdoScvbK2IGzYMbkcpvFcI,17731
 mcp_dbutils/sqlite/server.py,sha256=49ug43nyXZApclMXo0t5dKCN4wjDyDUZ-vmf746ac8M,7709
-mcp_dbutils-0.9.0.dist-info/METADATA,sha256=I52Q7IV8un9A5tmTTmEOFKZiW_UYCrWwBDhDq1tzFyE,11986
-mcp_dbutils-0.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_dbutils-0.9.0.dist-info/entry_points.txt,sha256=XTjt0QmYRgKOJQT6skR9bp1EMUfIrgpHeZJPZ3CJffs,49
-mcp_dbutils-0.9.0.dist-info/licenses/LICENSE,sha256=1A_CwpWVlbjrKdVEYO77vYfnXlW7oxcilZ8FpA_BzCI,1065
-mcp_dbutils-0.9.0.dist-info/RECORD,,
+mcp_dbutils-0.10.0.dist-info/METADATA,sha256=TC_KrWktHUIG6vznvxhIsz-pJG_WWxgH8s1HQJO7NgQ,6262
+mcp_dbutils-0.10.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_dbutils-0.10.0.dist-info/entry_points.txt,sha256=XTjt0QmYRgKOJQT6skR9bp1EMUfIrgpHeZJPZ3CJffs,49
+mcp_dbutils-0.10.0.dist-info/licenses/LICENSE,sha256=1A_CwpWVlbjrKdVEYO77vYfnXlW7oxcilZ8FpA_BzCI,1065
+mcp_dbutils-0.10.0.dist-info/RECORD,,

mcp_dbutils-0.9.0.dist-info/METADATA

@@ -1,392 +0,0 @@
-Metadata-Version: 2.4
-Name: mcp-dbutils
-Version: 0.9.0
-Summary: MCP Database Utilities Service
-Author: Dong Hao
-License-Expression: MIT
-License-File: LICENSE
-Requires-Python: >=3.10
-Requires-Dist: mcp>=1.2.1
-Requires-Dist: psycopg2-binary>=2.9.10
-Requires-Dist: python-dotenv>=1.0.1
-Requires-Dist: pyyaml>=6.0.2
-Provides-Extra: test
-Requires-Dist: aiosqlite>=0.19.0; extra == 'test'
-Requires-Dist: docker>=7.0.0; extra == 'test'
-Requires-Dist: pytest-asyncio>=0.23.0; extra == 'test'
-Requires-Dist: pytest-cov>=4.1.0; extra == 'test'
-Requires-Dist: pytest-docker>=2.0.0; extra == 'test'
-Requires-Dist: pytest>=7.0.0; extra == 'test'
-Requires-Dist: testcontainers>=3.7.0; extra == 'test'
-Description-Content-Type: text/markdown
-
-# MCP Database Utilities
-
-![GitHub Repo stars](https://img.shields.io/github/stars/donghao1393/mcp-dbutils)
-![PyPI version](https://img.shields.io/pypi/v/mcp-dbutils)
-[![Coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/donghao1393/bdd0a63ec2a816539ff8c136ceb41e48/raw/coverage.json)](https://github.com/donghao1393/mcp-dbutils/actions)
-![Python](https://img.shields.io/badge/Python-3.10%2B-blue)
-![License](https://img.shields.io/github/license/donghao1393/mcp-dbutils)
-[![smithery badge](https://smithery.ai/badge/@donghao1393/mcp-dbutils)](https://smithery.ai/server/@donghao1393/mcp-dbutils)
-
-[中文文档](README_CN.md)
-
-## Overview
-MCP Database Utilities is a unified database access service that supports multiple database types (PostgreSQL and SQLite). Through its abstraction layer design, it provides a simple and unified database operation interface for MCP servers.
-
-## Features
-- Unified database access interface
-- Support for multiple database configurations
-- Secure read-only query execution
-- Table structure and schema information retrieval
-- Database tables listing via MCP tools
-- Intelligent connection management and resource cleanup
-- Debug mode support
-
-## Installation and Configuration
-
-### Installation Methods
-#### Installing via Smithery
-
-To install Database Utilities for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@donghao1393/mcp-dbutils):
-
-```bash
-npx -y @smithery/cli install @donghao1393/mcp-dbutils --client claude
-```
-
-#### Using uvx (Recommended)
-No installation required, run directly using `uvx`:
-```bash
-uvx mcp-dbutils --config /path/to/config.yaml
-```
-
-Add to Claude configuration:
-```json
-"mcpServers": {
-  "mcp-dbutils": {
-    "command": "uvx",
-    "args": [
-      "mcp-dbutils",
-      "--config",
-      "/path/to/config.yaml"
-    ],
-    "env": {
-      "MCP_DEBUG": "1"  // Optional: Enable debug mode
-    }
-  }
-}
-```
-
-#### Using pip
-```bash
-pip install mcp-dbutils
-```
-
-Add to Claude configuration:
-```json
-"mcpServers": {
-  "mcp-dbutils": {
-    "command": "python",
-    "args": [
-      "-m",
-      "mcp_dbutils",
-      "--config",
-      "/path/to/config.yaml"
-    ],
-    "env": {
-      "MCP_DEBUG": "1"  // Optional: Enable debug mode
-    }
-  }
-}
-```
-
-#### Using Docker
-```bash
-docker run -i --rm \
-  -v /path/to/config.yaml:/app/config.yaml \
-  -v /path/to/sqlite.db:/app/sqlite.db \  # Optional: for SQLite database
-  -e MCP_DEBUG=1 \  # Optional: Enable debug mode
-  mcp/dbutils --config /app/config.yaml
-```
-
-Add to Claude configuration:
-```json
-"mcpServers": {
-  "mcp-dbutils": {
-    "command": "docker",
-    "args": [
-      "run",
-      "-i",
-      "--rm",
-      "-v",
-      "/path/to/config.yaml:/app/config.yaml",
-      "-v",
-      "/path/to/sqlite.db:/app/sqlite.db",  // Optional: for SQLite database
-      "mcp/dbutils",
-      "--config",
-      "/app/config.yaml"
-    ],
-    "env": {
-      "MCP_DEBUG": "1"  // Optional: Enable debug mode
-    }
-  }
-}
-```
-
-> **Note for Docker database connections:**
-> - For SQLite: Mount your database file using `-v /path/to/sqlite.db:/app/sqlite.db`
-> - For PostgreSQL running on host:
->   - On Mac/Windows: Use `host.docker.internal` as host in config
->   - On Linux: Use `172.17.0.1` (docker0 IP) or run with `--network="host"`
-
-### Requirements
-- Python 3.10+
-- PostgreSQL (optional)
-- SQLite3 (optional)
-
-### Configuration File
-The project requires a YAML configuration file, specified via the `--config` parameter. Configuration example:
-
-```yaml
-connections:
-  # Standard PostgreSQL configuration example
-  my_postgres:
-    type: postgres
-    dbname: test_db
-    user: postgres
-    password: secret
-    host: host.docker.internal  # For Mac/Windows
-    # host: 172.17.0.1         # For Linux (docker0 IP)
-    port: 5432
-
-  # PostgreSQL with JDBC URL example
-  my_postgres_jdbc:
-    type: postgres
-    jdbc_url: jdbc:postgresql://host.docker.internal:5432/test_db
-    user: postgres            # Credentials must be provided separately
-    password: secret          # Not included in JDBC URL for security
-
-  # SQLite standard configuration
-  my_sqlite:
-    type: sqlite
-    path: /app/sqlite.db       # Database file path
-    password: optional_password # optional
-
-  # SQLite with JDBC URL configuration
-  my_sqlite_jdbc:
-    type: sqlite
-    jdbc_url: jdbc:sqlite:/app/data.db?mode=ro&cache=shared  # Supports query parameters
-    password: optional_password    # Provided separately for security
-```
-
-The configuration supports JDBC URL format for both PostgreSQL and SQLite:
-
-PostgreSQL:
-1. Standard configuration with individual parameters
-2. JDBC URL configuration with separate credentials
-
-SQLite:
-1. Standard configuration with path parameter
-2. JDBC URL configuration with query parameters support:
-   - mode=ro: Read-only mode
-   - cache=shared: Shared cache mode
-   - Other SQLite URI parameters
-
-### Debug Mode
-Set environment variable `MCP_DEBUG=1` to enable debug mode for detailed logging output.
-
-## Architecture Design
-
-### Core Concept: Abstraction Layer
-
-```mermaid
-graph TD
-  Client[Client] --> DatabaseServer[Database Server]
-  subgraph MCP Server
-    DatabaseServer
-    DatabaseHandler[Database Handler]
-    PostgresHandler[PostgreSQL Handler]
-    SQLiteHandler[SQLite Handler]
-    DatabaseServer --> DatabaseHandler
-    DatabaseHandler --> PostgresHandler
-    DatabaseHandler --> SQLiteHandler
-  end
-  PostgresHandler --> PostgreSQL[(PostgreSQL)]
-  SQLiteHandler --> SQLite[(SQLite)]
-```
-
-The abstraction layer design is the core architectural concept in MCP Database Utilities. Just like a universal remote control that works with different devices, users only need to know the basic operations without understanding the underlying complexities.
-
-#### 1. Simplified User Interaction
-- Users only need to know the database configuration name (e.g., "my_postgres")
-- No need to deal with connection parameters and implementation details
-- MCP server automatically handles database connections and queries
-
-#### 2. Unified Interface Design
-- DatabaseHandler abstract class defines unified operation interfaces
-- All specific database implementations (PostgreSQL/SQLite) follow the same interface
-- Users interact with different databases in the same way
-
-#### 3. Configuration and Implementation Separation
-- Complex database configuration parameters are encapsulated in configuration files
-- Runtime access through simple database names
-- Easy management and modification of database configurations without affecting business code
-
-### System Components
-1. DatabaseServer
-   - Core component of the MCP server
-   - Handles resource and tool requests
-   - Manages database connection lifecycle
-
-2. DatabaseHandler
-   - Abstract base class defining unified interface
-   - Includes get_tables(), get_schema(), execute_query(), etc.
-   - Implemented by PostgreSQL and SQLite handlers
-
-3. Configuration System
-   - YAML-based configuration file
-   - Support for multiple database configurations
-   - Type-safe configuration validation
-
-4. Error Handling and Logging
-   - Unified error handling mechanism
-   - Detailed logging output
-   - Sensitive information masking
-
-## Usage Examples
-
-### Basic Query
-```python
-# Access through connection name
-async with server.get_handler("my_postgres") as handler:
-    # Execute SQL query
-    result = await handler.execute_query("SELECT * FROM users")
-```
-
-### View Table Structure
-```python
-# Get all tables
-tables = await handler.get_tables()
-
-# Get specific table schema
-schema = await handler.get_schema("users")
-```
-
-### Error Handling
-```python
-try:
-    async with server.get_handler("my_connection") as handler:
-        result = await handler.execute_query("SELECT * FROM users")
-except ValueError as e:
-    print(f"Configuration error: {e}")
-except Exception as e:
-    print(f"Query error: {e}")
-```
-
-## Security Notes
-- Supports SELECT queries only to protect database security
-- Automatically masks sensitive information (like passwords) in logs
-- Executes queries in read-only transactions
-
-## API Documentation
-
-### DatabaseServer
-Core server class providing:
-- Resource list retrieval
-- Tool call handling (list_tables, query)
-- Database handler management
-
-### MCP Tools
-
-#### dbutils-list-tables
-Lists all tables in the specified database.
-- Parameters:
-  * connection: Database connection name
-- Returns: Text content with a list of table names
-
-#### dbutils-run-query
-Executes a SQL query on the specified database.
-- Parameters:
-  * connection: Database connection name
-  * sql: SQL query to execute (SELECT only)
-- Returns: Query results in a formatted text
-
-#### dbutils-get-stats
-Get table statistics information.
-- Parameters:
-  * connection: Database connection name
-  * table: Table name
-- Returns: Statistics including row count, size, column stats
-
-#### dbutils-list-constraints
-List table constraints (primary key, foreign keys, etc).
-- Parameters:
-  * connection: Database connection name
-  * table: Table name
-- Returns: Detailed constraint information
-
-#### dbutils-explain-query
-Get query execution plan with cost estimates.
-- Parameters:
-  * connection: Database connection name
-  * sql: SQL query to explain
-- Returns: Formatted execution plan
-
-#### dbutils-get-performance
-Get database performance statistics.
-- Parameters:
-  * connection: Database connection name
-- Returns: Detailed performance statistics including query times, query types, error rates, and resource usage
-
-#### dbutils-analyze-query
-Analyze a SQL query for performance and provide optimization suggestions.
-- Parameters:
-  * connection: Database connection name
-  * sql: SQL query to analyze
-- Returns: Query analysis with execution plan, timing information, and optimization suggestions
-
-### DatabaseHandler
-Abstract base class defining interfaces:
-- get_tables(): Get table resource list
-- get_schema(): Get table structure
-- execute_query(): Execute SQL query
-- cleanup(): Resource cleanup
-
-### PostgreSQL Implementation
-Provides PostgreSQL-specific features:
-- Remote connection support
-- Table description information
-- Constraint queries
-
-### SQLite Implementation
-Provides SQLite-specific features:
-- File path handling
-- URI scheme support
-- Password protection support (optional)
-
-## Contributing
-Contributions are welcome! Here's how you can help:
-
-1. 🐛 Report bugs: Open an issue describing the bug and how to reproduce it
-2. 💡 Suggest features: Open an issue to propose new features
-3. 🛠️ Submit PRs: Fork the repo and create a pull request with your changes
-
-### Development Setup
-1. Clone the repository
-2. Create a virtual environment using `uv venv`
-3. Install dependencies with `uv sync --all-extras`
-4. Run tests with `pytest`
-
-For detailed guidelines, see [CONTRIBUTING.md](.github/CONTRIBUTING.md)
-
-## Acknowledgments
-- [MCP Servers](https://github.com/modelcontextprotocol/servers) for inspiration and demonstration
-- AI Editors:
-  * [Claude Desktop](https://claude.ai/download)
-  * [5ire](https://5ire.app/)
-  * [Cline](https://cline.bot)
-- [Model Context Protocol](https://modelcontextprotocol.io/) for comprehensive interfaces
-
-## Star History
-
-[![Star History Chart](https://api.star-history.com/svg?repos=donghao1393/mcp-dbutils&type=Date)](https://star-history.com/#donghao1393/mcp-dbutils&Date)