# Multi-Database SQL MCP Server

A Model Context Protocol (MCP) server that provides SQL database connectivity for multiple database types including SQLite, MySQL, PostgreSQL, and SQL Server.

## Features

- **Multi-database support**: SQLite, MySQL, PostgreSQL, and SQL Server
- **Connection management**: Create, manage, and disconnect multiple database connections
- **Query execution**: Execute SQL queries with parameterized support
- **Schema inspection**: Get table and column information
- **Type-safe**: Built with TypeScript for better development experience

## Installation

```bash
npm install
```

## Development

```bash
# Build the project
npm run build
```
## 🔌 MCP Server Integration

To integrate this toolset into your MCP-based system, modify your configuration like this:

```json
{
  "mcpServers": {
    "weather": {
      "command": "node",
      "args": [
        "/ABSOLUTE/PATH/TO/PARENT/FOLDER/project/build/index.js"
      ]
    }
  }
}
```
---

To integrate this toolset into your MCP-based system, update your configuration to run the Playwright server using a custom npm script:

```json
{
  "mcpServers": {
    "playwright": {
      "command": "npm",
      "args": [
        "run",
        "start:mcp"
      ]
    }
  }
}
```

> ✅ Make sure your `package.json` includes a `start:mcp` script that points to the correct TypeScript entry file via `ts-node`.

Example `package.json` snippet:

```json
"scripts": {
  "start:mcp": "ts-node src/index.ts"
}
```

This allows you to skip the manual `npm run build` step during development, making it quicker to iterate and test MCP tools directly from TypeScript source.

---
## Usage

The server supports the following tools:

### 1. connect_database
Connect to a database with the specified configuration.

**Parameters:**
- `connectionId` (string, required): Unique identifier for the connection
- `type` (string, required): Database type - 'sqlite', 'mysql', 'postgresql', or 'mssql'
- `database` (string, required): Database name
- `host` (string, optional): Database host (not required for SQLite)
- `port` (number, optional): Database port (not required for SQLite)
- `username` (string, optional): Database username (not required for SQLite)
- `password` (string, optional): Database password (not required for SQLite)
- `filename` (string, optional): SQLite database file path (required for SQLite)
- `ssl` (boolean, optional): Enable SSL connection
- `trustServerCertificate` (boolean, optional): Trust server certificate (MSSQL only)

### 2. execute_query
Execute a SQL query on a connected database.

**Parameters:**
- `connectionId` (string, required): Connection identifier
- `query` (string, required): SQL query to execute
- `parameters` (array, optional): Query parameters for parameterized queries

### 3. get_table_schema
Get schema information for tables.

**Parameters:**
- `connectionId` (string, required): Connection identifier
- `tableName` (string, optional): Specific table name (if not provided, returns all tables)

### 4. list_connections
List all active database connections.

**Parameters:** None

### 5. disconnect_database
Disconnect from a database.

**Parameters:**
- `connectionId` (string, required): Connection identifier to disconnect

## Database-Specific Notes

### SQLite
- Requires `filename` parameter pointing to the database file
- No host, port, username, or password required
- File will be created if it doesn't exist

### MySQL
- Default port: 3306
- Supports SSL connections
- Uses mysql2 driver for Promise-based operations

### PostgreSQL
- Default port: 5432
- Supports SSL connections with `rejectUnauthorized: false` for development
- Uses pg driver

### SQL Server (MSSQL)
- Default port: 1433
- Supports SSL encryption
- Use `trustServerCertificate: true` for self-signed certificates
- Uses mssql driver

## Example Connections

### SQLite
```json
{
  "connectionId": "my-sqlite",
  "type": "sqlite",
  "database": "myapp",
  "filename": "./data/myapp.db"
}
```

### MySQL
```json
{
  "connectionId": "my-mysql",
  "type": "mysql",
  "host": "localhost",
  "port": 3306,
  "database": "myapp",
  "username": "root",
  "password": "password",
  "ssl": false
}
```

### PostgreSQL
```json
{
  "connectionId": "my-postgres",
  "type": "postgresql",
  "host": "localhost",
  "port": 5432,
  "database": "myapp",
  "username": "postgres",
  "password": "password",
  "ssl": false
}
```

### SQL Server
```json
{
  "connectionId": "my-mssql",
  "type": "mssql",
  "host": "localhost",
  "port": 1433,
  "database": "myapp",
  "username": "sa",
  "password": "YourStrong@Passw0rd",
  "ssl": true,
  "trustServerCertificate": true
}
```

## Error Handling

The server includes comprehensive error handling for:
- Database connection failures
- Query execution errors
- Invalid connection IDs
- Unsupported database types
- Schema inspection errors

All errors are returned with descriptive messages to help with debugging.

## Project Structure

```
src/
├── index.ts           # Main server entry point
├── DatabaseManager.ts # Database connection and query management
├── handlers.ts        # Tool call handlers
├── tools.ts          # Tool definitions
└── types.ts          # TypeScript type definitions
```

## Requirements

- Node.js 18+
- TypeScript 5+
- Database drivers for your specific database types

## License

MIT
## 🤝 Contributing
We welcome contributions! Please see our [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.