@bytebase/dbhub 0.0.6 → 0.0.8

package/README.md

@@ -1,7 +1,7 @@
 <p align="center">
 <a href="https://dbhub.ai/" target="_blank">
 <picture>
-  <img src="https://raw.githubusercontent.com/bytebase/dbhub/main/assets/logo-full.svg" width="50%">
+  <img src="https://raw.githubusercontent.com/bytebase/dbhub/main/resources/images/logo-full.svg" width="50%">
 </picture>
 </a>
 </p>
@@ -14,11 +14,11 @@ DBHub is a universal database gateway implementing the Model Context Protocol (M
  |                  |    |              |    |                  |
  |  Claude Desktop  +--->+              +--->+    PostgreSQL    |
  |                  |    |              |    |                  |
- |      Cursor      +--->+    DBHub     +--->+      MySQL       |
+ |      Cursor      +--->+    DBHub     +--->+    SQL Server    |
  |                  |    |              |    |                  |
  |     Other MCP    +--->+              +--->+     SQLite       |
  |      Clients     |    |              |    |                  |
- |                  |    |              +--->+     DuckDB       |
+ |                  |    |              +--->+     MySQL        |
  |                  |    |              |    |                  |
  |                  |    |              +--->+  Other Databases |
  |                  |    |              |    |                  |
@@ -26,18 +26,35 @@ DBHub is a universal database gateway implementing the Model Context Protocol (M
       MCP Clients           MCP Server             Databases
 ```
 
-## Features
+## Supported Matrix
 
-- Browse available tables in the database
-- View schema information for tables
-- Run read-only SQL queries against the database
-- Safety checks to prevent dangerous queries
+### Database Resources
+
+| Resource               | URI Format | PostgreSQL | MySQL | SQL Server | SQLite |
+|------------------------|:----------:|:----------:|:-----:|:----------:|:------:|
+| Tables                 | `db://tables` |     ✅     |   ✅  |     ✅     |   ✅   |
+| Schema                 | `db://schema/{tableName}` |     ✅     |   ✅  |     ✅     |   ✅   |
+
+### Database Tools
+
+| Tool                   | Command Name       | PostgreSQL | MySQL | SQL Server | SQLite |
+|------------------------|:------------------:|:----------:|:-----:|:----------:|:------:|
+| Execute Query          | `run_query`        |     ✅     |   ✅  |     ✅     |   ✅   |
+| List Connectors        | `list_connectors`  |     ✅     |   ✅  |     ✅     |   ✅   |
+
+### Prompt Capabilities
+
+| Prompt                 | Command Name     | PostgreSQL | MySQL | SQL Server | SQLite |
+|------------------------|:----------------:|:----------:|:-----:|:----------:|:------:|
+| Generate SQL           | `generate_sql`   |     ✅     |   ✅  |     ✅     |   ✅   |
+| Explain DB Elements    | `explain_db`     |     ✅     |   ✅  |     ✅     |   ✅   |
 
 ## Installation
 
 ### Docker
 
 ```bash
+# PostgreSQL example
 docker run --rm --init \
    --name dbhub \
    --publish 8080:8080 \
@@ -47,17 +64,96 @@ docker run --rm --init \
    --dsn "postgres://user:password@localhost:5432/dbname?sslmode=disable"
 ```
 
+```bash
+# Demo mode with sample employee database
+docker run --rm --init \
+   --name dbhub \
+   --publish 8080:8080 \
+   bytebase/dbhub \
+   --transport sse \
+   --port 8080 \
+   --demo
+```
+
 ### NPM
 
 ```bash
+# PostgreSQL example
 npx @bytebase/dbhub --transport sse --port 8080 --dsn "postgres://user:password@localhost:5432/dbname"
 ```
 
+```bash
+# Demo mode with sample employee database
+npx @bytebase/dbhub --transport sse --port 8080 --demo
+```
+
+### Claude Desktop
+
+![claude-desktop](https://raw.githubusercontent.com/bytebase/dbhub/main/resources/images/claude-desktop.webp)
+
+- Claude Desktop only supports `stdio` transport https://github.com/orgs/modelcontextprotocol/discussions/16
+
+```json
+// claude_desktop_config.json
+{
+  "mcpServers": {
+    "dbhub-postgres-docker": {
+      "command": "docker",
+      "args": [
+        "run",
+        "-i",
+        "--rm",
+        "bytebase/dbhub",
+        "--transport",
+        "stdio",
+        "--dsn",
+        // Use host.docker.internal as the host if connecting to the local db
+        "postgres://user:password@host.docker.internal:5432/dbname?sslmode=disable"
+      ]
+    },
+    "dbhub-postgres-npx": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@bytebase/dbhub",
+        "--transport",
+        "stdio",
+        "--dsn",
+        "postgres://user:password@localhost:5432/dbname?sslmode=disable"
+      ]
+    },
+    "dbhub-demo": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@bytebase/dbhub",
+        "--transport",
+        "stdio",
+        "--demo"
+      ]
+    }
+  }
+}
+```
+
+### Cursor
+
+![cursor](https://raw.githubusercontent.com/bytebase/dbhub/main/resources/images/cursor.webp)
+
+- Cursor supports both `stdio` and `sse`.
+- Follow [Cursor MCP guide](https://docs.cursor.com/context/model-context-protocol) and make sure to use [Agent](https://docs.cursor.com/chat/agent) mode.
+
 ## Usage
 
 ### Configure your database connection
 
-Database Source Name (DSN) is required to connect to your database. You can provide this in several ways:
+You can use DBHub in demo mode with a sample employee database for testing:
+
+```bash
+pnpm dev --demo
+```
+
+For real databases, a Database Source Name (DSN) is required. You can provide this in several ways:
 
 - **Command line argument** (highest priority):
 
@@ -79,6 +175,15 @@ Database Source Name (DSN) is required to connect to your database. You can prov
   DSN=postgres://user:password@localhost:5432/dbname?sslmode=disable
   ```
 
+DBHub supports the following database connection string formats:
+
+| Database   | DSN Format                                                | Example                                                 |
+|------------|-----------------------------------------------------------|--------------------------------------------------------|
+| PostgreSQL | `postgres://[user]:[password]@[host]:[port]/[database]`   | `postgres://user:password@localhost:5432/dbname?sslmode=disable` |
+| SQLite     | `sqlite:///[path/to/file]` or `sqlite::memory:`           | `sqlite:///path/to/database.db` or `sqlite::memory:`  |
+| SQL Server | `sqlserver://[user]:[password]@[host]:[port]/[database]`  | `sqlserver://user:password@localhost:1433/dbname`      |
+| MySQL      | `mysql://[user]:[password]@[host]:[port]/[database]`      | `mysql://user:password@localhost:3306/dbname`          |
+
 ### Transport
 
 - **stdio** (default) - for direct integration with tools like Claude Desktop:
@@ -96,60 +201,11 @@ Database Source Name (DSN) is required to connect to your database. You can prov
 
 | Option    | Description                                                     | Default                             |
 | :-------- | :-------------------------------------------------------------- | :---------------------------------- |
-| dsn       | Database connection string                                      | Required if not set via environment |
+| demo      | Run in demo mode with sample employee database                  | `false`                             |
+| dsn       | Database connection string                                      | Required if not in demo mode        |
 | transport | Transport mode: `stdio` or `sse`                                | `stdio`                             |
 | port      | HTTP server port (only applicable when using `--transport=sse`) | `8080`                              |
 
-### Claude Desktop
-
-![claude-desktop](https://raw.githubusercontent.com/bytebase/dbhub/main/assets/claude-desktop.webp)
-
-- Claude Desktop only supports `stdio` transport https://github.com/orgs/modelcontextprotocol/discussions/16
-
-#### Docker
-
-```json
-// claude_desktop_config.json
-{
-  "mcpServers": {
-    "dbhub": {
-      "command": "docker",
-      "args": [
-        "run",
-        "-i",
-        "--rm",
-        "bytebase/dbhub",
-        "--transport",
-        "stdio",
-        "--dsn",
-        // Use host.docker.internal as the host if connecting to the local db
-        "postgres://user:password@host.docker.internal:5432/dbname?sslmode=disable"
-      ]
-    }
-  }
-}
-```
-
-#### NPX
-
-```json
-// claude_desktop_config.json
-{
-  "mcpServers": {
-    "dbhub": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@bytebase/dbhub",
-        "--transport",
-        "stdio",
-        "--dsn",
-        "postgres://user:password@localhost:5432/dbname?sslmode=disable"
-      ]
-    }
-  }
-}
-```
 
 ## Development
 
@@ -176,6 +232,7 @@ Database Source Name (DSN) is required to connect to your database. You can prov
 #### stdio
 
 ```bash
+# PostgreSQL example
 TRANSPORT=stdio DSN="postgres://user:password@localhost:5432/dbname?sslmode=disable" npx @modelcontextprotocol/inspector node /path/to/dbhub/dist/index.js
 ```
 
@@ -191,4 +248,4 @@ npx @modelcontextprotocol/inspector
 
 Connect to the DBHub server `/sse` endpoint
 
-![mcp-inspector](https://raw.githubusercontent.com/bytebase/dbhub/main/assets/mcp-inspector.webp)
+![mcp-inspector](https://raw.githubusercontent.com/bytebase/dbhub/main/resources/images/mcp-inspector.webp)

package/dist/config/demo-loader.js

@@ -0,0 +1,45 @@
+/**
+ * Demo data loader for SQLite in-memory database
+ *
+ * This module loads the sample employee database into the SQLite in-memory database
+ * when the --demo flag is specified.
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+// Create __dirname equivalent for ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Path to sample data files
+const DEMO_DATA_DIR = path.join(__dirname, '..', '..', 'resources', 'employee-sqlite');
+/**
+ * Load SQL file contents
+ */
+export function loadSqlFile(fileName) {
+    const filePath = path.join(DEMO_DATA_DIR, fileName);
+    return fs.readFileSync(filePath, 'utf8');
+}
+/**
+ * Get SQLite DSN for in-memory database
+ */
+export function getInMemorySqliteDSN() {
+    return 'sqlite::memory:';
+}
+/**
+ * Load SQL files sequentially
+ */
+export function getSqliteInMemorySetupSql() {
+    // First, load the schema
+    let sql = loadSqlFile('employee.sql');
+    // Replace .read directives with the actual file contents
+    // This is necessary because in-memory SQLite can't use .read
+    const readRegex = /\.read\s+([a-zA-Z0-9_]+\.sql)/g;
+    let match;
+    while ((match = readRegex.exec(sql)) !== null) {
+        const includePath = match[1];
+        const includeContent = loadSqlFile(includePath);
+        // Replace the .read line with the file contents
+        sql = sql.replace(match[0], includeContent);
+    }
+    return sql;
+}

package/dist/config/env.js

@@ -62,6 +62,14 @@ export function loadEnvFiles() {
     }
     return null;
 }
+/**
+ * Check if demo mode is enabled from command line args
+ * Returns true if --demo flag is provided
+ */
+export function isDemoMode() {
+    const args = parseCommandLineArgs();
+    return args.demo === 'true';
+}
 /**
  * Resolve DSN from command line args, environment variables, or .env files
  * Returns the DSN and its source, or null if not found
@@ -69,7 +77,16 @@ export function loadEnvFiles() {
 export function resolveDSN() {
     // Get command line arguments
     const args = parseCommandLineArgs();
-    // 1. Check command line arguments first (highest priority)
+    // Check for demo mode first (highest priority)
+    if (isDemoMode()) {
+        // Will use in-memory SQLite with demo data
+        return {
+            dsn: 'sqlite::memory:',
+            source: 'demo mode',
+            isDemo: true
+        };
+    }
+    // 1. Check command line arguments 
     if (args.dsn) {
         return { dsn: args.dsn, source: 'command line argument' };
     }

package/dist/connectors/manager.js

@@ -15,7 +15,7 @@ export class ConnectorManager {
     /**
      * Initialize and connect to the database using a DSN
      */
-    async connectWithDSN(dsn) {
+    async connectWithDSN(dsn, initScript) {
         // First try to find a connector that can handle this DSN
         let connector = ConnectorRegistry.getConnectorForDSN(dsn);
         if (!connector) {
@@ -23,7 +23,7 @@ export class ConnectorManager {
         }
         this.activeConnector = connector;
         // Connect to the database
-        await this.activeConnector.connect(dsn);
+        await this.activeConnector.connect(dsn, initScript);
         this.connected = true;
     }
     /**

package/dist/connectors/mysql/index.js

@@ -0,0 +1,169 @@
+import mysql from 'mysql2/promise';
+import { ConnectorRegistry } from '../interface.js';
+/**
+ * MySQL DSN Parser
+ * Handles DSN strings like: mysql://user:password@localhost:3306/dbname
+ */
+class MySQLDSNParser {
+    parse(dsn) {
+        // Basic validation
+        if (!this.isValidDSN(dsn)) {
+            throw new Error(`Invalid MySQL DSN: ${dsn}`);
+        }
+        try {
+            const url = new URL(dsn);
+            const config = {
+                host: url.hostname,
+                port: url.port ? parseInt(url.port) : 3306,
+                database: url.pathname.substring(1), // Remove leading '/'
+                user: url.username,
+                password: url.password,
+            };
+            // Handle query parameters
+            url.searchParams.forEach((value, key) => {
+                if (key === 'ssl') {
+                    config.ssl = value === 'true' ? {} : undefined;
+                }
+                // Add other parameters as needed
+            });
+            return config;
+        }
+        catch (error) {
+            throw new Error(`Failed to parse MySQL DSN: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    getSampleDSN() {
+        return 'mysql://root:password@localhost:3306/mysql';
+    }
+    isValidDSN(dsn) {
+        try {
+            const url = new URL(dsn);
+            return url.protocol === 'mysql:';
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}
+/**
+ * MySQL Connector Implementation
+ */
+export class MySQLConnector {
+    constructor() {
+        this.id = 'mysql';
+        this.name = 'MySQL';
+        this.dsnParser = new MySQLDSNParser();
+        this.pool = null;
+    }
+    async connect(dsn) {
+        try {
+            const config = this.dsnParser.parse(dsn);
+            this.pool = mysql.createPool(config);
+            // Test the connection
+            const [rows] = await this.pool.query('SELECT 1');
+            console.error("Successfully connected to MySQL database");
+        }
+        catch (err) {
+            console.error("Failed to connect to MySQL database:", err);
+            throw err;
+        }
+    }
+    async disconnect() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+        }
+    }
+    async getTables() {
+        if (!this.pool) {
+            throw new Error('Not connected to database');
+        }
+        try {
+            // Get all tables from the current database
+            const [rows] = await this.pool.query(`
+        SELECT table_name 
+        FROM information_schema.tables 
+        WHERE table_schema = DATABASE()
+        ORDER BY table_name
+      `);
+            return rows.map(row => row.table_name);
+        }
+        catch (error) {
+            console.error("Error getting tables:", error);
+            throw error;
+        }
+    }
+    async tableExists(tableName) {
+        if (!this.pool) {
+            throw new Error('Not connected to database');
+        }
+        try {
+            const [rows] = await this.pool.query(`
+        SELECT COUNT(*) as count
+        FROM information_schema.tables 
+        WHERE table_schema = DATABASE() 
+        AND table_name = ?
+      `, [tableName]);
+            return rows[0].count > 0;
+        }
+        catch (error) {
+            console.error("Error checking if table exists:", error);
+            throw error;
+        }
+    }
+    async getTableSchema(tableName) {
+        if (!this.pool) {
+            throw new Error('Not connected to database');
+        }
+        try {
+            // Get table columns
+            const [rows] = await this.pool.query(`
+        SELECT 
+          column_name, 
+          data_type, 
+          is_nullable,
+          column_default
+        FROM information_schema.columns
+        WHERE table_schema = DATABASE()
+        AND table_name = ?
+        ORDER BY ordinal_position
+      `, [tableName]);
+            return rows;
+        }
+        catch (error) {
+            console.error("Error getting table schema:", error);
+            throw error;
+        }
+    }
+    async executeQuery(query) {
+        if (!this.pool) {
+            throw new Error('Not connected to database');
+        }
+        const safetyCheck = this.validateQuery(query);
+        if (!safetyCheck.isValid) {
+            throw new Error(safetyCheck.message || "Query validation failed");
+        }
+        try {
+            const [rows, fields] = await this.pool.query(query);
+            return { rows, fields };
+        }
+        catch (error) {
+            console.error("Error executing query:", error);
+            throw error;
+        }
+    }
+    validateQuery(query) {
+        // Basic check to prevent non-SELECT queries
+        const normalizedQuery = query.trim().toLowerCase();
+        if (!normalizedQuery.startsWith('select')) {
+            return {
+                isValid: false,
+                message: "Only SELECT queries are allowed for security reasons."
+            };
+        }
+        return { isValid: true };
+    }
+}
+// Create and register the connector
+const mysqlConnector = new MySQLConnector();
+ConnectorRegistry.register(mysqlConnector);

package/dist/connectors/sqlite/index.js

@@ -1,12 +1,13 @@
 /**
- * SQLite Connector Implementation (Template)
+ * SQLite Connector Implementation
  *
- * This is a template showing how to implement a new database connector.
+ * Implements SQLite database connectivity for DBHub
  * To use this connector:
- * 1. Install the required dependencies: npm install sqlite3
- * 2. Implement the methods below
- * 3. Set DSN=sqlite:///path/to/database.db in your .env file
+ * 1. Set DSN=sqlite:///path/to/database.db in your .env file
+ * 2. Or set DB_CONNECTOR_TYPE=sqlite for default in-memory database
  */
+import { ConnectorRegistry } from '../interface.js';
+import sqlite3 from 'sqlite3';
 /**
  * SQLite DSN Parser
  * Handles DSN strings like:
@@ -63,129 +64,132 @@ export class SQLiteConnector {
         this.id = 'sqlite';
         this.name = 'SQLite';
         this.dsnParser = new SQLiteDSNParser();
-        this.dbPath = null;
+        this.db = null;
+        this.dbPath = ':memory:'; // Default to in-memory database
     }
-    async connect(dsn) {
+    async connect(dsn, initScript) {
         const config = this.dsnParser.parse(dsn);
         this.dbPath = config.dbPath;
-        // Example implementation (requires sqlite3 package)
-        /*
         return new Promise((resolve, reject) => {
-          const sqlite3 = require('sqlite3').verbose();
-          this.db = new sqlite3.Database(this.dbPath, (err) => {
-            if (err) {
-              console.error("Failed to connect to SQLite database:", err);
-              reject(err);
-            } else {
-              console.error("Successfully connected to SQLite database");
-              resolve();
-            }
-          });
+            this.db = new sqlite3.Database(this.dbPath, (err) => {
+                if (err) {
+                    console.error("Failed to connect to SQLite database:", err);
+                    reject(err);
+                }
+                else {
+                    // Can't use console.log here because it will break the stdio transport
+                    console.error("Successfully connected to SQLite database");
+                    // If an initialization script is provided, run it
+                    if (initScript) {
+                        this.db.exec(initScript, (err) => {
+                            if (err) {
+                                console.error("Failed to initialize database with script:", err);
+                                reject(err);
+                            }
+                            else {
+                                console.error("Successfully initialized database with script");
+                                resolve();
+                            }
+                        });
+                    }
+                    else {
+                        resolve();
+                    }
+                }
+            });
         });
-        */
-        throw new Error('SQLite connector not implemented yet');
     }
     async disconnect() {
         // Close the SQLite connection
-        /*
         if (this.db) {
-          return new Promise((resolve, reject) => {
-            this.db.close((err) => {
-              if (err) {
-                reject(err);
-              } else {
-                this.db = null;
-                resolve();
-              }
+            return new Promise((resolve, reject) => {
+                this.db.close((err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        this.db = null;
+                        resolve();
+                    }
+                });
             });
-          });
         }
-        */
-        throw new Error('SQLite connector not implemented yet');
+        return Promise.resolve();
     }
     async getTables() {
-        // Get all tables from SQLite
-        /*
+        if (!this.db) {
+            throw new Error("Not connected to SQLite database");
+        }
         return new Promise((resolve, reject) => {
-          this.db.all(
-            `SELECT name FROM sqlite_master
-             WHERE type='table' AND name NOT LIKE 'sqlite_%'
-             ORDER BY name`,
-            (err, rows) => {
-              if (err) {
-                reject(err);
-              } else {
-                resolve(rows.map(row => row.name));
-              }
-            }
-          );
+            this.db.all(`SELECT name FROM sqlite_master 
+         WHERE type='table' AND name NOT LIKE 'sqlite_%'
+         ORDER BY name`, (err, rows) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(rows.map(row => row.name));
+                }
+            });
         });
-        */
-        throw new Error('SQLite connector not implemented yet');
     }
     async tableExists(tableName) {
-        // Check if a table exists in SQLite
-        /*
+        if (!this.db) {
+            throw new Error("Not connected to SQLite database");
+        }
         return new Promise((resolve, reject) => {
-          this.db.get(
-            `SELECT name FROM sqlite_master
-             WHERE type='table' AND name = ?`,
-            [tableName],
-            (err, row) => {
-              if (err) {
-                reject(err);
-              } else {
-                resolve(!!row);
-              }
-            }
-          );
+            this.db.get(`SELECT name FROM sqlite_master 
+         WHERE type='table' AND name = ?`, [tableName], (err, row) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(!!row);
+                }
+            });
         });
-        */
-        throw new Error('SQLite connector not implemented yet');
     }
     async getTableSchema(tableName) {
-        // Get schema for a specific table
-        /*
+        if (!this.db) {
+            throw new Error("Not connected to SQLite database");
+        }
         return new Promise((resolve, reject) => {
-          this.db.all(
-            `PRAGMA table_info(${tableName})`,
-            (err, rows) => {
-              if (err) {
-                reject(err);
-              } else {
-                // Convert SQLite schema format to our standard TableColumn format
-                const columns = rows.map(row => ({
-                  column_name: row.name,
-                  data_type: row.type,
-                  is_nullable: row.notnull ? 'NO' : 'YES',
-                  column_default: row.dflt_value
-                }));
-                resolve(columns);
-              }
-            }
-          );
+            this.db.all(`PRAGMA table_info(${tableName})`, (err, rows) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    // Convert SQLite schema format to our standard TableColumn format
+                    const columns = rows.map(row => ({
+                        column_name: row.name,
+                        data_type: row.type,
+                        is_nullable: row.notnull === 0 ? 'YES' : 'NO', // In SQLite, 0 means nullable
+                        column_default: row.dflt_value
+                    }));
+                    resolve(columns);
+                }
+            });
         });
-        */
-        throw new Error('SQLite connector not implemented yet');
     }
     async executeQuery(query) {
-        // Execute a query against SQLite
+        if (!this.db) {
+            throw new Error("Not connected to SQLite database");
+        }
+        // Validate query for safety
         const safetyCheck = this.validateQuery(query);
         if (!safetyCheck.isValid) {
             throw new Error(safetyCheck.message || "Query validation failed");
         }
-        /*
         return new Promise((resolve, reject) => {
-          this.db.all(query, (err, rows) => {
-            if (err) {
-              reject(err);
-            } else {
-              resolve({ rows });
-            }
-          });
+            this.db.all(query, (err, rows) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve({ rows });
+                }
+            });
         });
-        */
-        throw new Error('SQLite connector not implemented yet');
     }
     validateQuery(query) {
         // Basic check to prevent non-SELECT queries
@@ -199,6 +203,6 @@ export class SQLiteConnector {
         return { isValid: true };
     }
 }
-// To enable this connector, uncomment the following lines and install sqlite3:
-// const sqliteConnector = new SQLiteConnector();
-// ConnectorRegistry.register(sqliteConnector);
+// Register the SQLite connector
+const sqliteConnector = new SQLiteConnector();
+ConnectorRegistry.register(sqliteConnector);

package/dist/index.js

@@ -2,7 +2,8 @@
 // Import connector modules to register them
 import './connectors/postgres/index.js'; // Register PostgreSQL connector
 import './connectors/sqlserver/index.js'; // Register SQL Server connector
-// import './connectors/sqlite/index.js';  // Uncomment to enable SQLite
+import './connectors/sqlite/index.js'; // SQLite connector
+import './connectors/mysql/index.js'; // MySQL connector
 // Import main function from server.ts
 import { main } from './server.js';
 /**

package/dist/prompts/index.js

@@ -5,7 +5,7 @@ import { dbExplainerPromptHandler, dbExplainerSchema } from './db-explainer.js';
  */
 export function registerPrompts(server) {
     // Register SQL Generator prompt
-    server.prompt("generate-sql", "Generate SQL queries from natural language descriptions", sqlGeneratorSchema, sqlGeneratorPromptHandler);
+    server.prompt("generate_sql", "Generate SQL queries from natural language descriptions", sqlGeneratorSchema, sqlGeneratorPromptHandler);
     // Register Database Explainer prompt
-    server.prompt("explain-db", "Get explanations about database tables, columns, and structures", dbExplainerSchema, dbExplainerPromptHandler);
+    server.prompt("explain_db", "Get explanations about database tables, columns, and structures", dbExplainerSchema, dbExplainerPromptHandler);
 }

package/dist/server.js

@@ -8,6 +8,7 @@ import { fileURLToPath } from 'url';
 import { ConnectorManager } from './connectors/manager.js';
 import { ConnectorRegistry } from './connectors/interface.js';
 import { resolveDSN, resolveTransport, resolvePort } from './config/env.js';
+import { getSqliteInMemorySetupSql } from './config/demo-loader.js';
 import { registerResources } from './resources/index.js';
 import { registerTools } from './tools/index.js';
 import { registerPrompts } from './prompts/index.js';
@@ -23,7 +24,8 @@ export const SERVER_VERSION = packageJson.version;
 /**
  * Generate ASCII art banner with version information
  */
-export function generateBanner(version) {
+export function generateBanner(version, isDemo = false) {
+    const demoText = isDemo ? " [DEMO MODE]" : "";
     return `
  _____  ____  _   _       _     
 |  __ \\|  _ \\| | | |     | |    
@@ -32,7 +34,7 @@ export function generateBanner(version) {
 | |__| | |_) | | | | |_| | |_) |
 |_____/|____/|_| |_|\\__,_|_.__/ 
                                 
-v${version} - Universal Database MCP Server
+v${version}${demoText} - Universal Database MCP Server
 `;
 }
 /**
@@ -51,9 +53,10 @@ export async function main() {
 ERROR: Database connection string (DSN) is required.
 Please provide the DSN in one of these ways (in order of priority):
 
-1. Command line argument: --dsn="your-connection-string"
-2. Environment variable: export DSN="your-connection-string"
-3. .env file: DSN=your-connection-string
+1. Use demo mode: --demo (uses in-memory SQLite with sample employee database)
+2. Command line argument: --dsn="your-connection-string"
+3. Environment variable: export DSN="your-connection-string"
+4. .env file: DSN=your-connection-string
 
 Example formats:
 ${sampleFormats}
@@ -75,13 +78,21 @@ See documentation for more details on configuring database connections.
         const connectorManager = new ConnectorManager();
         console.error(`Connecting with DSN: ${dsnData.dsn}`);
         console.error(`DSN source: ${dsnData.source}`);
-        await connectorManager.connectWithDSN(dsnData.dsn);
+        // If in demo mode, load the employee database
+        if (dsnData.isDemo) {
+            console.error('Running in demo mode with sample employee database');
+            const initScript = getSqliteInMemorySetupSql();
+            await connectorManager.connectWithDSN(dsnData.dsn, initScript);
+        }
+        else {
+            await connectorManager.connectWithDSN(dsnData.dsn);
+        }
         // Resolve transport type
         const transportData = resolveTransport();
         console.error(`Using transport: ${transportData.type}`);
         console.error(`Transport source: ${transportData.source}`);
         // Print ASCII art banner with version and slogan
-        console.error(generateBanner(SERVER_VERSION));
+        console.error(generateBanner(SERVER_VERSION, dsnData.isDemo));
         // Set up transport based on type
         if (transportData.type === 'sse') {
             // Set up Express server for SSE transport

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebase/dbhub",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Universal Database MCP Server",
   "main": "dist/index.js",
   "type": "module",
@@ -17,10 +17,13 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.6.1",
+    "@types/sqlite3": "^5.1.0",
     "dotenv": "^16.4.7",
     "express": "^4.18.2",
     "mssql": "^11.0.1",
+    "mysql2": "^3.13.0",
     "pg": "^8.13.3",
+    "sqlite3": "^5.1.7",
     "zod": "^3.24.2"
   },
   "devDependencies": {