Skip to main content
Glama
Data Nexus MCP

Data Nexus MCP

Data Nexus MCP

A modular, secure platform for connecting to SQL and NoSQL databases via REST API, MCP (Model Context Protocol), and a Vue.js Web UI.

Architecture

┌─────────────┐     ┌──────────────┐     ┌─────────────────┐
│   Web UI    │────▶│  REST API    │────▶│ core-db-command │
│  (Vue.js)   │     │  (FastAPI)   │     │  (Python lib)   │
└─────────────┘     └──────┬───────┘     └────────┬────────┘
                           │                       │
                    ┌──────▼───────┐               │
                    │  MCP Server  │───────────────┘
                    └──────┬───────┘
                           │
                    ┌──────▼───────┐
                    │  MCP Client  │──▶ AI Agents / LLMs
                    └──────────────┘

Modules

Module

Package

Description

core-db-command

core_db_command/

Plugin-based Python library for all database drivers

rest-api-command

rest_api_command/

FastAPI REST layer with OAuth2/LDAP/basic auth

mcp-server

mcp_server/

MCP tools: query_database, get_schema, list_tables, describe_table, execute_sql

mcp-client

mcp_client/

MCP client bridge for agent integration

web-ui

web-ui/

Vue 3 + Pinia + Monaco Editor query studio

config

config/

YAML connection definitions with ${ENV} substitution

Related MCP server: AI-Orchestrator-MCP

Supported Database Types

The driver registry supports 50+ database types across 13 categories:

  • Relational: PostgreSQL, MySQL, MSSQL, Oracle, CockroachDB, TiDB, YugabyteDB, TimescaleDB, pgvector

  • Document: MongoDB, DocumentDB, Firestore, Couchbase (stub)

  • Key-Value: Redis, DynamoDB, Memcached/etcd/RocksDB (stub)

  • Wide-Column: Cassandra, ScyllaDB, Bigtable/HBase (stub)

  • Graph: Neo4j, Neptune/JanusGraph/ArangoDB (stub)

  • Time-Series: InfluxDB, ClickHouse, Prometheus/QuestDB (stub)

  • Vector: Qdrant, Weaviate, Milvus, Pinecone

  • Search: Elasticsearch, OpenSearch, Splunk/Solr (stub)

  • Warehouse: BigQuery, Snowflake, Redshift/Databricks (stub)

  • Multi-Model: Cosmos DB, OrientDB (stub)

  • Embedded: SQLite, DuckDB, Realm/LMDB (stub)

  • Ledger: QLDB/BigchainDB (stub)

  • NewSQL: Spanner (stub)

Fully implemented drivers include PostgreSQL, MySQL, MSSQL, Oracle, MongoDB, Redis, SQLite, DuckDB, Elasticsearch, ClickHouse, Neo4j, InfluxDB, Cassandra, DynamoDB, BigQuery, Snowflake, Qdrant, Weaviate, Milvus, Pinecone, Cosmos DB, and Firestore. Stub drivers are registered and extensible.

Quick Start

Prerequisites

  • Python 3.11+

  • Node.js 20+ (for Web UI development)

  • Docker & Docker Compose (optional)

1. Install Python dependencies

cp .env.example .env
pip install -e ".[dev]"

2. Configure connections

Edit config/connections.yaml and set secrets via environment variables:

connections:
  - name: postgres_prod
    type: postgresql
    host: localhost
    port: 5432
    database: mydb
    user: readonly_user
    password: ${PG_PASSWORD}

3. Start the REST API

db-rest-api
# or: uvicorn rest_api_command.app:app --reload

API docs: http://localhost:8000/docs

4. Start the Web UI (development)

cd web-ui
cp .env.example .env
npm install
npm run dev

Open http://localhost:5173 — default credentials: admin / changeme

5. Run with Docker Compose

docker compose up -d

Services:

REST API Endpoints

Method

Path

Description

GET

/api/connections

List connections (no credentials)

POST

/api/db/{name}/query

Parameterized query

POST

/api/db/{name}/sql

Raw SQL / native command

GET

/api/db/{name}/schema

Database schema

GET

/api/db/{name}/tables

List tables/collections

GET

/api/db/{name}/tables/{table}/describe

Table structure

GET/POST

/api/query-history

Query history

MCP Server

Configure in .env or Cursor MCP env:

MCP_REST_API_URL=http://localhost:8000
# Option A: bearer token (when REST_API_AUTH_MODE=oauth2)
MCP_REST_API_TOKEN=<jwt-from-/api/auth/token>
# Option B: username/password (works with basic auth; auto-fetches JWT if oauth2)
MCP_REST_API_USER=admin
MCP_REST_API_PASSWORD=changeme

Run:

db-mcp-server

Add to Cursor/Claude MCP config:

{
  "mcpServers": {
    "data-nexus-mcp": {
      "command": "db-mcp-server",
      "cwd": "/path/to/data_nexus_mcp",
      "env": {
        "MCP_REST_API_URL": "http://localhost:8000",
        "MCP_REST_API_USER": "admin",
        "MCP_REST_API_PASSWORD": "changeme"
      }
    }
  }
}

Note: REST_API_* variables belong on the REST API process (db-rest-api), not in the MCP server config.

MCP Client

db-mcp-client                    # list available tools
db-mcp-client query local_sqlite "SELECT 1"

Authentication

Set REST_API_AUTH_MODE to one of:

  • basic — HTTP Basic Auth (default for development)

  • oauth2 — JWT bearer tokens via /api/auth/token

  • ldap — LDAP bind (requires REST_API_LDAP_SERVER and REST_API_LDAP_BASE_DN)

Adding a New Driver

  1. Create core_db_command/drivers/mydb.py

  2. Subclass BaseDriver and set driver_type

  3. Decorate with @DriverRegistry.register

  4. Import in core_db_command/drivers/registry_loader.py

from core_db_command.base import BaseDriver, DriverRegistry

@DriverRegistry.register
class MyDBDriver(BaseDriver):
    driver_type = "mydb"

    async def connect(self): ...
    async def disconnect(self): ...
    async def query(self, query, params=None): ...
    async def execute(self, command, params=None): ...
    async def list_tables(self, schema=None): ...
    async def describe_table(self, table, schema=None): ...

Testing

pytest tests/ -v

Security Notes

  • Credentials are never returned by the REST API or MCP server

  • Secrets must use ${ENV_VAR} placeholders in YAML config

  • All API endpoints require authentication

  • Query input is validated and length-limited

Project Structure

data-nexus-mcp/
├── core_db_command/       # Core library + drivers
├── rest_api_command/      # FastAPI REST API
├── mcp_server/            # MCP server
├── mcp_client/            # MCP client
├── web-ui/                # Vue.js frontend
├── config/                # YAML connection config
├── tests/                 # Unit tests
├── docker-compose.yml
├── Dockerfile
└── pyproject.toml

License

Apache 2.0

Available Tools

5 tools
describe_tableA

Describe the structure of a specific table or collection.

Inputs: table (required), connection_name (required), schema. Returns: result

execute_sqlB

Execute raw SQL or native database command on a named connection.

Inputs: command (required), connection_name (required), params. Returns: result

get_schemaC

Retrieve schema information for a named database connection.

Inputs: connection_name (required). Returns: result

list_tablesC

List all tables or collections in a named database connection.

Inputs: connection_name (required), schema. Returns: result

query_databaseD

Run a parameterized query on a named database connection.

Inputs: query (required), connection_name (required), params. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3/5.0

    Scored across 5 tools

    Disambiguation4/5

    Tools are mostly distinct: query_database and execute_sql both run queries but one is parameterized and the other raw; get_schema, list_tables, describe_table each target different metadata. Minor potential for confusion between the two query tools, but descriptions clarify the difference.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern with lowercase and underscores: query_database, get_schema, list_tables, describe_table, execute_sql. No mixed conventions or irregularities.

    Tool Count5/5

    5 tools are well-scoped for a database MCP server. The set covers core operations—querying, schema retrieval, table listing, structure description, raw execution—without being overwhelming or too sparse.

    Completeness4/5

    The tool surface covers essential query and schema exploration operations. The execute_sql tool can handle DDL, but there are no dedicated create/alter/drop tools; transaction commands are also missing. Overall, it's nearly complete for a typical read-heavy interaction pattern.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides universal database operations for AI assistants through MCP, supporting 40+ databases including PostgreSQL, MySQL, MongoDB, Redis, and SQLite with built-in introspection tools for schema exploration.
      34 npm
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      Enables AI agents to interact with heterogeneous databases (MySQL, MongoDB, BigQuery) through MCP tools, allowing natural language queries and database operations.
      -
    • A
      license
      A
      quality
      C
      maintenance
      Enables AI agents to inspect real databases through MCP with tools for listing tables, describing schemas, sampling rows, running queries, and explaining execution plans, all with engine-enforced read-only access to SQLite and MySQL.
      5
      12 npm
      MIT
    • F
      license
      Not graded
      quality
      A
      maintenance
      Enables LLM agents to connect to and retrieve data from PostgreSQL, MySQL, SQLite, BigQuery, Oracle, MS SQL, and Redshift via a unified MCP API, with schema normalization, query optimization, and secure connections.
      -