Database MCP Server

MCP Server for AI database access. Connect to PostgreSQL, MySQL, or SQLite. Query data, inspect schemas, manage tables. 11 tools for complete database intelligence.

Features

• Multi-database - PostgreSQL, MySQL, SQLite
• Query execution - SELECT with automatic LIMIT protection
• Schema inspection - Tables, columns, foreign keys, indexes
• Safe operations - Separate read (query) and write (execute) tools
• Cloud-ready - Secure connections via Apify infrastructure

Input Parameters

Parameter	Type	Description
tool	string	Database tool to execute
dbType	string	postgresql, mysql, or sqlite
connectionString	string	Full connection URI
host	string	Database host
port	integer	Database port
database	string	Database name
user	string	Username
password	string	Password (secret)
ssl	boolean	Enable SSL (default: true)
query	string	SQL query to execute
tableName	string	Table for describe/info operations
limit	integer	Max rows to return (default: 1000)
timeout	integer	Query timeout in ms (default: 30000)
sqliteUrl	string	URL to SQLite database file
sqliteData	string	Base64-encoded SQLite database

Tools

Tool	Description
db.connect	Connect to database
db.disconnect	Close connection
db.query	Execute SELECT (read-only)
db.execute	Execute INSERT/UPDATE/DELETE/DDL
db.list_tables	List all tables
db.describe_table	Get column definitions
db.get_schema	Full schema (all tables)
db.list_databases	List databases on server
db.table_info	Row count, size statistics
db.foreign_keys	Foreign key relationships
db.indexes	Index information

Examples

Connect to PostgreSQL

{
  "tool": "db.connect",
  "dbType": "postgresql",
  "connectionString": "postgresql://user:pass@host:5432/dbname"
}

Or with individual parameters:

{
  "tool": "db.connect",
  "dbType": "postgresql",
  "host": "your-host.com",
  "port": 5432,
  "database": "mydb",
  "user": "myuser",
  "password": "mypassword",
  "ssl": true
}

Connect to MySQL

{
  "tool": "db.connect",
  "dbType": "mysql",
  "host": "your-mysql-host.com",
  "port": 3306,
  "database": "mydb",
  "user": "myuser",
  "password": "mypassword"
}

Connect to SQLite (URL)

{
  "tool": "db.connect",
  "dbType": "sqlite",
  "sqliteUrl": "https://example.com/database.db"
}

Query Data

{
  "tool": "db.query",
  "dbType": "postgresql",
  "connectionString": "postgresql://...",
  "query": "SELECT * FROM users WHERE active = true",
  "limit": 100
}

Get Schema

{
  "tool": "db.get_schema",
  "dbType": "postgresql",
  "connectionString": "postgresql://..."
}

Describe Table

{
  "tool": "db.describe_table",
  "dbType": "postgresql",
  "connectionString": "postgresql://...",
  "tableName": "users"
}

Execute Statement

{
  "tool": "db.execute",
  "dbType": "postgresql",
  "connectionString": "postgresql://...",
  "query": "INSERT INTO logs (message) VALUES ('Hello World')"
}

Output

Results are pushed to the run's dataset (not a live socket). Every run emits a server_info record first (version, tool list, supported databases); if you pass a tool, a tool_result record follows. Failures are pushed as error records — the run still completes.

Field	Type	Description
type	string	Record type: server_info, tool_result, or error
tool	string	Tool that was executed (on tool_result)
status	string	success or error
data	object	Result data (e.g. rows, fields, or connection/schema info)
rowCount	integer	Rows returned or affected
executionTime	integer	Tool execution time in ms
errors	array	Error entries [{ code, message }] on failures

Success Response

{
  "type": "tool_result",
  "tool": "db.query",
  "status": "success",
  "data": {
    "rows": [...],
    "fields": ["column1", "column2"]
  },
  "rowCount": 10,
  "executionTime": 45
}

Error Response

{
  "type": "tool_result",
  "tool": "db.query",
  "status": "error",
  "errors": [
    { "code": "TOOL_ERROR", "message": "relation \"users\" does not exist" }
  ]
}

MCP Integration

This Actor is a request/response tool dispatcher: you invoke it with a tool in the input and read the result from the run's dataset. It is not a long-lived stdio/SSE MCP server on its own. To call it as a tool from an MCP client (Claude Desktop, etc.), connect Apify's Actors MCP server, which exposes your Actors as MCP tools:

{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "constant_quadruped/database-mcp-server"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}

Apify Client (JavaScript)

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('constant_quadruped/database-mcp-server').call({
  tool: 'db.query',
  dbType: 'postgresql',
  connectionString: 'postgresql://user:pass@host:5432/db',
  query: 'SELECT * FROM users LIMIT 10'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Apify Client (Python)

from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("constant_quadruped/database-mcp-server").call(run_input={
    "tool": "db.query",
    "dbType": "postgresql",
    "connectionString": "postgresql://user:pass@host:5432/db",
    "query": "SELECT * FROM users LIMIT 10"
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)

Use Cases

• Data exploration - Understand database structure
• Report generation - Query data for AI reports
• Schema documentation - Auto-generate database docs
• Data migration - Inspect source and target schemas
• Debugging - Query logs and metrics tables

Security

• Passwords and connection strings marked as secrets
• SSL enabled by default for PostgreSQL and MySQL
• Query results limited to prevent memory issues
• Separate read (query) and write (execute) operations

Limitations

• One tool per run. Each Actor run dispatches a single tool call and returns its result in the dataset. It is not a persistent MCP server process — chain multiple runs, or connect via Apify's Actors MCP server (above), for multi-step sessions.
• Connections are not persisted across runs. A run auto-connects from the credentials you pass and tears the connection down at exit. A connectionId from db.connect is only reusable within that same run.
• db.query is read-only. It accepts SELECT/WITH/SHOW/EXPLAIN/PRAGMA only and auto-appends LIMIT when absent. Use db.execute for INSERT/UPDATE/DELETE/DDL.
• You supply the database. The Actor connects to a database you provide and reach; it stores no credentials or data between runs and cannot reach hosts your network/proxy can't.
• SQLite from file/URL is loaded into the run. Very large SQLite databases are bounded by the run's memory and timeout.
• SQLite driver is optional. better-sqlite3 is an optional dependency; SQLite support requires it to be present in the build image.

License

MIT