@cmd233/mcp-database-server 1.1.1

package/dist/src/tools/insightTools.js

@@ -0,0 +1,54 @@
+import { dbAll, dbExec, dbRun } from '../db/index.js';
+import { formatSuccessResponse } from '../utils/formatUtils.js';
+/**
+ * Add a business insight to the memo
+ * @param insight Business insight text
+ * @returns Result of the operation
+ */
+export async function appendInsight(insight) {
+    try {
+        if (!insight) {
+            throw new Error("Insight text is required");
+        }
+        // Create insights table if it doesn't exist
+        await dbExec(`
+      CREATE TABLE IF NOT EXISTS mcp_insights (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        insight TEXT NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        // Insert the insight
+        await dbRun("INSERT INTO mcp_insights (insight) VALUES (?)", [insight]);
+        return formatSuccessResponse({ success: true, message: "Insight added" });
+    }
+    catch (error) {
+        throw new Error(`Error adding insight: ${error.message}`);
+    }
+}
+/**
+ * List all insights in the memo
+ * @returns Array of insights
+ */
+export async function listInsights() {
+    try {
+        // Check if insights table exists
+        const tableExists = await dbAll("SELECT name FROM sqlite_master WHERE type='table' AND name = 'mcp_insights'");
+        if (tableExists.length === 0) {
+            // Create table if it doesn't exist
+            await dbExec(`
+        CREATE TABLE IF NOT EXISTS mcp_insights (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          insight TEXT NOT NULL,
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+            return formatSuccessResponse([]);
+        }
+        const insights = await dbAll("SELECT * FROM mcp_insights ORDER BY created_at DESC");
+        return formatSuccessResponse(insights);
+    }
+    catch (error) {
+        throw new Error(`Error listing insights: ${error.message}`);
+    }
+}

package/dist/src/tools/queryTools.js

@@ -0,0 +1,73 @@
+import { dbAll, dbRun } from '../db/index.js';
+import { formatSuccessResponse, convertToCSV } from '../utils/formatUtils.js';
+/**
+ * Execute a read-only SQL query
+ * @param query SQL query to execute
+ * @returns Query results
+ */
+export async function readQuery(query) {
+    try {
+        if (!query.trim().toLowerCase().startsWith("select")) {
+            throw new Error("Only SELECT queries are allowed with read_query");
+        }
+        const result = await dbAll(query);
+        return formatSuccessResponse(result);
+    }
+    catch (error) {
+        throw new Error(`SQL Error: ${error.message}`);
+    }
+}
+/**
+ * Execute a data modification SQL query
+ * @param query SQL query to execute
+ * @returns Information about affected rows
+ */
+export async function writeQuery(query) {
+    try {
+        const lowerQuery = query.trim().toLowerCase();
+        if (lowerQuery.startsWith("select")) {
+            throw new Error("Use read_query for SELECT operations");
+        }
+        if (!(lowerQuery.startsWith("insert") || lowerQuery.startsWith("update") || lowerQuery.startsWith("delete"))) {
+            throw new Error("Only INSERT, UPDATE, or DELETE operations are allowed with write_query");
+        }
+        const result = await dbRun(query);
+        return formatSuccessResponse({ affected_rows: result.changes });
+    }
+    catch (error) {
+        throw new Error(`SQL Error: ${error.message}`);
+    }
+}
+/**
+ * Export query results to CSV or JSON format
+ * @param query SQL query to execute
+ * @param format Output format (csv or json)
+ * @returns Formatted query results
+ */
+export async function exportQuery(query, format) {
+    try {
+        if (!query.trim().toLowerCase().startsWith("select")) {
+            throw new Error("Only SELECT queries are allowed with export_query");
+        }
+        const result = await dbAll(query);
+        if (format === "csv") {
+            const csvData = convertToCSV(result);
+            return {
+                content: [{
+                        type: "text",
+                        text: csvData
+                    }],
+                isError: false,
+            };
+        }
+        else if (format === "json") {
+            return formatSuccessResponse(result);
+        }
+        else {
+            throw new Error("Unsupported export format. Use 'csv' or 'json'");
+        }
+    }
+    catch (error) {
+        throw new Error(`Export Error: ${error.message}`);
+    }
+}

package/dist/src/tools/schemaTools.js

@@ -0,0 +1,118 @@
+import { dbAll, dbExec, getListTablesQuery, getDescribeTableQuery } from '../db/index.js';
+import { formatSuccessResponse } from '../utils/formatUtils.js';
+/**
+ * Create a new table in the database
+ * @param query CREATE TABLE SQL statement
+ * @returns Result of the operation
+ */
+export async function createTable(query) {
+    try {
+        if (!query.trim().toLowerCase().startsWith("create table")) {
+            throw new Error("Only CREATE TABLE statements are allowed");
+        }
+        await dbExec(query);
+        return formatSuccessResponse({ success: true, message: "Table created successfully" });
+    }
+    catch (error) {
+        throw new Error(`SQL Error: ${error.message}`);
+    }
+}
+/**
+ * Alter an existing table schema
+ * @param query ALTER TABLE SQL statement
+ * @returns Result of the operation
+ */
+export async function alterTable(query) {
+    try {
+        if (!query.trim().toLowerCase().startsWith("alter table")) {
+            throw new Error("Only ALTER TABLE statements are allowed");
+        }
+        await dbExec(query);
+        return formatSuccessResponse({ success: true, message: "Table altered successfully" });
+    }
+    catch (error) {
+        throw new Error(`SQL Error: ${error.message}`);
+    }
+}
+/**
+ * Drop a table from the database
+ * @param tableName Name of the table to drop
+ * @param confirm Safety confirmation flag
+ * @returns Result of the operation
+ */
+export async function dropTable(tableName, confirm) {
+    try {
+        if (!tableName) {
+            throw new Error("Table name is required");
+        }
+        if (!confirm) {
+            return formatSuccessResponse({
+                success: false,
+                message: "Safety confirmation required. Set confirm=true to proceed with dropping the table."
+            });
+        }
+        // First check if table exists by directly querying for tables
+        const query = getListTablesQuery();
+        const tables = await dbAll(query);
+        const tableNames = tables.map(t => t.name);
+        if (!tableNames.includes(tableName)) {
+            throw new Error(`Table '${tableName}' does not exist`);
+        }
+        // Drop the table
+        await dbExec(`DROP TABLE "${tableName}"`);
+        return formatSuccessResponse({
+            success: true,
+            message: `Table '${tableName}' dropped successfully`
+        });
+    }
+    catch (error) {
+        throw new Error(`Error dropping table: ${error.message}`);
+    }
+}
+/**
+ * List all tables in the database
+ * @returns Array of table names
+ */
+export async function listTables() {
+    try {
+        // Use adapter-specific query for listing tables
+        const query = getListTablesQuery();
+        const tables = await dbAll(query);
+        return formatSuccessResponse(tables.map((t) => t.name));
+    }
+    catch (error) {
+        throw new Error(`Error listing tables: ${error.message}`);
+    }
+}
+/**
+ * Get schema information for a specific table
+ * @param tableName Name of the table to describe
+ * @returns Column definitions for the table
+ */
+export async function describeTable(tableName) {
+    try {
+        if (!tableName) {
+            throw new Error("Table name is required");
+        }
+        // First check if table exists by directly querying for tables
+        const query = getListTablesQuery();
+        const tables = await dbAll(query);
+        const tableNames = tables.map(t => t.name);
+        if (!tableNames.includes(tableName)) {
+            throw new Error(`Table '${tableName}' does not exist`);
+        }
+        // Use adapter-specific query for describing tables
+        const descQuery = getDescribeTableQuery(tableName);
+        const columns = await dbAll(descQuery);
+        return formatSuccessResponse(columns.map((col) => ({
+            name: col.name,
+            type: col.type,
+            notnull: !!col.notnull,
+            default_value: col.dflt_value,
+            primary_key: !!col.pk
+        })));
+    }
+    catch (error) {
+        throw new Error(`Error describing table: ${error.message}`);
+    }
+}

package/dist/src/utils/formatUtils.js

@@ -0,0 +1,56 @@
+/**
+ * Convert data to CSV format
+ * @param data Array of objects to convert to CSV
+ * @returns CSV formatted string
+ */
+export function convertToCSV(data) {
+    if (data.length === 0)
+        return '';
+    // Get headers
+    const headers = Object.keys(data[0]);
+    // Create CSV header row
+    let csv = headers.join(',') + '\n';
+    // Add data rows
+    data.forEach(row => {
+        const values = headers.map(header => {
+            const val = row[header];
+            // Handle strings with commas, quotes, etc.
+            if (typeof val === 'string') {
+                return `"${val.replace(/"/g, '""')}"`;
+            }
+            // Use empty string for null/undefined
+            return val === null || val === undefined ? '' : val;
+        });
+        csv += values.join(',') + '\n';
+    });
+    return csv;
+}
+/**
+ * Format error response
+ * @param error Error object or message
+ * @returns Formatted error response object
+ */
+export function formatErrorResponse(error) {
+    const message = error instanceof Error ? error.message : error;
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({ error: message }, null, 2)
+            }],
+        isError: true
+    };
+}
+/**
+ * Format success response
+ * @param data Data to format
+ * @returns Formatted success response object
+ */
+export function formatSuccessResponse(data) {
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(data, null, 2)
+            }],
+        isError: false
+    };
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "@cmd233/mcp-database-server",
+    "version": "1.1.1",
+    "description": "MCP server for interacting with SQLite, SQL Server, PostgreSQL and MySQL databases (Fixed nullable field detection)",
+    "license": "MIT",
+    "author": "cmd233",
+    "homepage": "https://github.com/cmd233/mcp-database-server",
+    "bugs": "https://github.com/cmd233/mcp-database-server/issues",
+    "type": "module",
+    "bin": {
+        "ea-database-server": "dist/src/index.js"
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsc && shx chmod +x dist/src/index.js",
+        "prepare": "npm run build",
+        "watch": "tsc --watch",
+        "start": "node dist/src/index.js",
+        "dev": "tsc && node dist/src/index.js",
+        "example": "node examples/example.js",
+        "clean": "rimraf dist"
+    },
+    "dependencies": {
+        "@aws-sdk/rds-signer": "^3.0.0",
+        "@modelcontextprotocol/sdk": "1.9.0",
+        "mssql": "11.0.1",
+        "mysql2": "^3.14.1",
+        "pg": "^8.11.3",
+        "sqlite3": "5.1.7"
+    },
+    "devDependencies": {
+        "@types/mssql": "^9.1.5",
+        "@types/pg": "^8.11.13",
+        "@types/sqlite3": "5.1.0",
+        "rimraf": "^5.0.5",
+        "shx": "0.4.0",
+        "typescript": "5.8.3"
+    }
+}

package/readme.md

@@ -0,0 +1,328 @@
+[![MseeP.ai Security Assessment Badge](https://mseep.net/pr/executeautomation-mcp-database-server-badge.png)](https://mseep.ai/app/executeautomation-mcp-database-server)
+
+# MCP Database Server
+
+This MCP (Model Context Protocol) server provides database access capabilities to Claude, supporting SQLite, SQL Server, PostgreSQL, and MySQL databases.
+
+## Installation
+
+1. Clone the repository:
+```
+git clone https://github.com/executeautomation/mcp-database-server.git
+cd mcp-database-server
+```
+
+2. Install dependencies:
+```
+npm install
+```
+
+3. Build the project:
+```
+npm run build
+```
+
+## Usage Options
+
+There are two ways to use this MCP server with Claude:
+
+1. **Direct usage**: Install the package globally and use it directly
+2. **Local development**: Run from your local development environment
+
+### Direct Usage with NPM Package
+
+The easiest way to use this MCP server is by installing it globally:
+
+```bash
+npm install -g @executeautomation/database-server
+```
+
+This allows you to use the server directly without building it locally.
+
+### Local Development Setup
+
+If you want to modify the code or run from your local environment:
+
+1. Clone and build the repository as shown in the Installation section
+2. Run the server using the commands in the Usage section below
+
+## Usage
+
+### SQLite Database
+
+To use with an SQLite database:
+
+```
+node dist/src/index.js /path/to/your/database.db
+```
+
+### SQL Server Database
+
+To use with a SQL Server database:
+
+```
+node dist/src/index.js --sqlserver --server <server-name> --database <database-name> [--user <username> --password <password>]
+```
+
+Required parameters:
+- `--server`: SQL Server host name or IP address
+- `--database`: Name of the database
+
+Optional parameters:
+- `--user`: Username for SQL Server authentication (if not provided, Windows Authentication will be used)
+- `--password`: Password for SQL Server authentication
+- `--port`: Port number (default: 1433)
+
+### PostgreSQL Database
+
+To use with a PostgreSQL database:
+
+```
+node dist/src/index.js --postgresql --host <host-name> --database <database-name> [--user <username> --password <password>]
+```
+
+Required parameters:
+- `--host`: PostgreSQL host name or IP address
+- `--database`: Name of the database
+
+Optional parameters:
+- `--user`: Username for PostgreSQL authentication
+- `--password`: Password for PostgreSQL authentication
+- `--port`: Port number (default: 5432)
+- `--ssl`: Enable SSL connection (true/false)
+- `--connection-timeout`: Connection timeout in milliseconds (default: 30000)
+
+### MySQL Database
+
+#### Standard Authentication
+
+To use with a MySQL database:
+
+```
+node dist/src/index.js --mysql --host <host-name> --database <database-name> --port <port> [--user <username> --password <password>]
+```
+
+Required parameters:
+- `--host`: MySQL host name or IP address
+- `--database`: Name of the database
+- `--port`: Port number (default: 3306)
+
+Optional parameters:
+- `--user`: Username for MySQL authentication
+- `--password`: Password for MySQL authentication
+- `--ssl`: Enable SSL connection (true/false or object)
+- `--connection-timeout`: Connection timeout in milliseconds (default: 30000)
+
+#### AWS IAM Authentication
+
+For Amazon RDS MySQL instances with IAM database authentication:
+
+**Prerequisites:**
+- AWS credentials must be configured (the RDS Signer uses the default credential provider chain)
+- Configure using one of these methods:
+  - `aws configure` (uses default profile)
+  - `AWS_PROFILE=myprofile` environment variable
+  - `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` environment variables
+  - IAM roles (if running on EC2)
+
+```
+node dist/src/index.js --mysql --aws-iam-auth --host <rds-endpoint> --database <database-name> --user <aws-username> --aws-region <region>
+```
+
+Required parameters:
+- `--host`: RDS endpoint hostname
+- `--database`: Name of the database
+- `--aws-iam-auth`: Enable AWS IAM authentication
+- `--user`: AWS IAM username (also the database user)
+- `--aws-region`: AWS region where RDS instance is located
+
+Note: SSL is automatically enabled for AWS IAM authentication
+
+## Configuring Claude Desktop
+
+### Direct Usage Configuration
+
+If you installed the package globally, configure Claude Desktop with:
+
+```json
+{
+  "mcpServers": {
+    "sqlite": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@executeautomation/database-server",
+        "/path/to/your/database.db"
+      ]
+    },
+    "sqlserver": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@executeautomation/database-server",
+        "--sqlserver",
+        "--server", "your-server-name",
+        "--database", "your-database-name",
+        "--user", "your-username",
+        "--password", "your-password"
+      ]
+    },
+    "postgresql": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@executeautomation/database-server",
+        "--postgresql",
+        "--host", "your-host-name",
+        "--database", "your-database-name",
+        "--user", "your-username",
+        "--password", "your-password"
+      ]
+    },
+    "mysql": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@executeautomation/database-server",
+        "--mysql",
+        "--host", "your-host-name",
+        "--database", "your-database-name",
+        "--port", "3306",
+        "--user", "your-username",
+        "--password", "your-password"
+      ]
+    },
+    "mysql-aws": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@executeautomation/database-server",
+        "--mysql",
+        "--aws-iam-auth",
+        "--host", "your-rds-endpoint.region.rds.amazonaws.com",
+        "--database", "your-database-name",
+        "--user", "your-aws-username",
+        "--aws-region", "us-east-1"
+      ]
+    }
+  }
+}
+```
+
+### Local Development Configuration
+
+For local development, configure Claude Desktop to use your locally built version:
+
+```json
+{
+  "mcpServers": {
+    "sqlite": {
+      "command": "node",
+      "args": [
+        "/absolute/path/to/mcp-database-server/dist/src/index.js", 
+        "/path/to/your/database.db"
+      ]
+    },
+    "sqlserver": {
+      "command": "node",
+      "args": [
+        "/absolute/path/to/mcp-database-server/dist/src/index.js",
+        "--sqlserver",
+        "--server", "your-server-name",
+        "--database", "your-database-name",
+        "--user", "your-username",
+        "--password", "your-password"
+      ]
+    },
+    "postgresql": {
+      "command": "node",
+      "args": [
+        "/absolute/path/to/mcp-database-server/dist/src/index.js",
+        "--postgresql",
+        "--host", "your-host-name",
+        "--database", "your-database-name",
+        "--user", "your-username",
+        "--password", "your-password"
+      ]
+    },
+    "mysql": {
+      "command": "node",
+      "args": [
+        "/absolute/path/to/mcp-database-server/dist/src/index.js",
+        "--mysql",
+        "--host", "your-host-name",
+        "--database", "your-database-name",
+        "--port", "3306",
+        "--user", "your-username",
+        "--password", "your-password"
+      ]
+    },
+    "mysql-aws": {
+      "command": "node",
+      "args": [
+        "/absolute/path/to/mcp-database-server/dist/src/index.js",
+        "--mysql",
+        "--aws-iam-auth",
+        "--host", "your-rds-endpoint.region.rds.amazonaws.com",
+        "--database", "your-database-name",
+        "--user", "your-aws-username",
+        "--aws-region", "us-east-1"
+      ]
+    }
+  }
+}
+```
+
+The Claude Desktop configuration file is typically located at:
+- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+- Linux: `~/.config/Claude/claude_desktop_config.json`
+
+## Available Database Tools
+
+The MCP Database Server provides the following tools that Claude can use:
+
+| Tool | Description | Required Parameters |
+|------|-------------|---------------------|
+| `read_query` | Execute SELECT queries to read data | `query`: SQL SELECT statement |
+| `write_query` | Execute INSERT, UPDATE, or DELETE queries | `query`: SQL modification statement |
+| `create_table` | Create new tables in the database | `query`: CREATE TABLE statement |
+| `alter_table` | Modify existing table schema | `query`: ALTER TABLE statement |
+| `drop_table` | Remove a table from the database | `table_name`: Name of table<br>`confirm`: Safety flag (must be true) |
+| `list_tables` | Get a list of all tables | None |
+| `describe_table` | View schema information for a table | `table_name`: Name of table |
+| `export_query` | Export query results as CSV/JSON | `query`: SQL SELECT statement<br>`format`: "csv" or "json" |
+| `append_insight` | Add a business insight to memo | `insight`: Text of insight |
+| `list_insights` | List all business insights | None |
+
+For practical examples of how to use these tools with Claude, see [Usage Examples](docs/usage-examples.md).
+
+## Additional Documentation
+
+- [SQL Server Setup Guide](docs/sql-server-setup.md): Details on connecting to SQL Server databases
+- [PostgreSQL Setup Guide](docs/postgresql-setup.md): Details on connecting to PostgreSQL databases
+- [Usage Examples](docs/usage-examples.md): Example queries and commands to use with Claude
+
+## Development
+
+To run the server in development mode:
+
+```
+npm run dev
+```
+
+To watch for changes during development:
+
+```
+npm run watch
+```
+
+## Requirements
+
+- Node.js 18+
+- For SQL Server connectivity: SQL Server 2012 or later
+- For PostgreSQL connectivity: PostgreSQL 9.5 or later
+
+## License
+
+MIT