OpenLink MCP Server for JDBC

OpenLink MCP Server for JDBC

A lightweight Java-based MCP server enabling model context protocol integration with any JDBC-compatible database.

8
Stars
7
Forks
8
Watchers
1
Issues
OpenLink MCP Server for JDBC provides a Java-based implementation of the Model Context Protocol (MCP), facilitating structured, context-aware interactions with relational databases via JDBC. It supports a variety of database operations, including schema and table discovery, table element descriptions, SQL query execution in multiple formats, and Virtuoso-specific features. Easily configurable and designed for integration with tools like Claude Desktop, it enables model-context-aware applications to access and manage database content effectively.

Key Features

Implements Model Context Protocol (MCP) for JDBC databases
Supports schema and table discovery
Provides detailed table descriptions including keys and data types
Executes SQL and stored procedures with results in JSONL and Markdown formats
Includes Virtuoso-specific extensions (SPASQL, SPARQL, LLM integration)
Configurable via environment variables and JSON config
Optimized for use with Claude Desktop and similar tools
Multiple database driver support through JDBC
Lightweight Java-based server with Quarkus
API key-based authentication for secure access

Use Cases

Integrating databases with AI assistants such as Claude Desktop
Automating schema and table discovery for knowledge extraction
Generating data documentation and visualizations from relational databases
Querying multiple JDBC-compatible databases via a unified protocol
Facilitating AI-powered SQL generation and execution workflows
Providing structured database metadata to model context consumers
Executing Virtuoso-specific features like SPARQL and LLM integration
Building chatbots or tools that require contextual database access
Securing database interactions through centralized MCP server access
Supporting multimodal database querying with multiple output formats

README


OpenLink MCP Server for JDBC

A lightweight Java-based MCP (Model Context Protocol) server for JDBC built with Quakrus. This server is compatible with Virtuoso DBMS and any other DBMS backend that has a JDBC driver.

mcp-client-and-servers|648x499


Features

  • Get Schemas: Fetch and list all schema names from the connected database.
  • Get Tables: Retrieve table information for specific schemas or all schemas.
  • Describe Table: Generate a detailed description of table structures, including:
    • Column names and data types
    • Nullable attributes
    • Primary and foreign keys
  • Search Tables: Filter and retrieve tables based on name substrings.
  • Execute Stored Procedures: A Virtuoso-specific feature! Execute stored procedures and retrieve results.
  • Execute Queries:
    • JSONL result format: Optimized for structured responses.
    • Markdown table format: Ideal for reporting and visualization.

Prerequisites

MCP server requires Java 21 or above.


Installation

Clone this repository:

bash
git clone https://github.com/OpenLinkSoftware/mcp-jdbc-server.git  
cd mcp-jdbc-server

Environment Variables

Update your .env by overriding these defaults to match your preferences:

jdbc.url=jdbc:virtuoso://localhost:1111
jdbc.user=dba
jdbc.password=dba
jdbc.api_key=xxx

Configuration

For Claude Desktop users using Virtuoso and its JDBC driver:

Add the following to claude_desktop_config.json:

json
{
  "mcpServers": {
    "my_database": {
      "command": "java",
      "args": ["-jar", "/path/to/mcp-jdbc-server/MCPServer-1.0.0-runner.jar"],
      "env": {
        "jdbc.url": "jdbc:virtuoso://localhost:1111",
        "jdbc.user": "username",
        "jdbc.password": "password",
        "jdbc.api_key": "sk-xxx"
      }
    }
  }
}

For Claude Desktop users using another JDBC driver or a combination of drivers:

Add the following, edited to suit your local environment, to claude_desktop_config.json:

json
    "jdbc": {
      "command": "java",
      "args": [
        "-cp",
        "/path/to/mcp-jdbc-server/MCPServer-1.0.0-runner.jar:/path/to/jdbc_driver1.jar:/path/to/jdbc_driverN.jar",
        "io.quarkus.runner.GeneratedMain"
      ],
      "env": {
        "jdbc.url": "jdbc:virtuoso://localhost:1111",
        "jdbc.user": "dba",
        "jdbc.password": "dba"
      }
    }

Use

Tools Provided

After successful installation, the following tools will be available to MCP client applications.

Overview

name description
jdbc_get_schemas List database schemas accessible to connected database management system (DBMS).
jdbc_get_tables List tables associated with a selected database schema.
jdbc_describe_table Provide the description of a table associated with a designated database schema. This includes information about column names, data types, nulls handling, autoincrement, primary key, and foreign keys.
jdbc_filter_table_names List tables, based on a substring pattern from the q input field, associated with a selected database schema.
jdbc_query_database Execute a SQL query and return results in JSONL format.
jdbc_execute_query Execute a SQL query and return results in JSONL format.
jdbc_execute_query_md Execute a SQL query and return results in Markdown table format.
jdbc_spasql_query A Virtuoso-specific feature! Execute a SPASQL query and return results.
jdbc_sparql_query A Virtuoso-specific feature! Execute a SPARQL query and return results.
jdbc_virtuoso_support_ai A Virtuoso-specific feature! Interact with LLMs through the Virtuoso Support Assistant/Agent.

Detailed Description

  • jdbc_get_schemas

    • Retrieve and return a list of all schema names from the connected database.
    • Input parameters:
      • user (string, optional): Database username. Defaults to "demo".
      • password (string, optional): Database password. Defaults to "demo".
      • url (string, optional): JDBC URL connection string.
    • Returns a JSON string array of schema names.
  • jdbc_get_tables

    • Retrieve and return a list containing information about tables in a specified schema. If no schema is provided, uses the connection's default schema.
    • Input parameters:
      • schema (string, optional): Database schema to filter tables. Defaults to connection default.
      • user (string, optional): Database username. Defaults to "demo".
      • password (string, optional): Database password. Defaults to "demo".
      • url (string, optional): JDBC URL connection string.
    • Returns a JSON string containing table information (e.g., TABLE_CAT, TABLE_SCHEM, TABLE_NAME, TABLE_TYPE).
  • jdbc_filter_table_names

    • Filters and returns information about tables whose names contain a specific substring.
    • Input parameters:
      • q (string, required): The substring to search for within table names.
      • schema (string, optional): Database schema to filter tables. Defaults to connection default.
      • user (string, optional): Database username. Defaults to "demo".
      • password (string, optional): Database password. Defaults to "demo".
      • url (string, optional): JDBC URL connection string.
    • Returns a JSON string containing information for matching tables.
  • jdbc_describe_table

    • Retrieve and return detailed information about the columns of a specific table.
    • Input parameters:
      • schema (string, required): The database schema name containing the table.
      • table (string, required): The name of the table to describe.
      • user (string, optional): Database username. Defaults to "demo".
      • password (string, optional): Database password. Defaults to "demo".
      • url (string, optional): JDBC URL connection string.
    • Returns a JSON string describing the table's columns (e.g., COLUMN_NAME, TYPE_NAME, COLUMN_SIZE, IS_NULLABLE).
  • jdbc_query_database

    • Execute a standard SQL query and return the results in JSON format.
    • Input parameters:
      • query (string, required): The SQL query string to execute.
      • user (string, optional): Database username. Defaults to "demo".
      • password (string, optional): Database password. Defaults to "demo".
      • url (string, optional): JDBC URL connection string.
    • Returns query results as a JSON string.
  • jdbc_query_database_md

    • Execute a standard SQL query and return the results formatted as a Markdown table.
    • Input parameters:
      • query (string, required): The SQL query string to execute.
      • user (string, optional): Database username. Defaults to "demo".
      • password (string, optional): Database password. Defaults to "demo".
      • url (string, optional): JDBC URL connection string.
    • Returns query results as a Markdown table string.
  • jdbc_query_database_jsonl

    • Execute a standard SQL query and return the results in JSON Lines (JSONL) format (one JSON object per line).
    • Input parameters:
      • query (string, required): The SQL query string to execute.
      • user (string, optional): Database username. Defaults to "demo".
      • password (string, optional): Database password. Defaults to "demo".
      • url (string, optional): JDBC URL connection string.
    • Returns query results as a JSONL string.
  • jdbc_spasql_query

    • A Virtuoso-specific feature!
    • Execute a SPASQL (SQL/SPARQL hybrid) query return results.
    • Input parameters:
      • query (string, required): The SPASQL query string.
      • max_rows (number, optional): Maximum number of rows to return. Defaults to 20.
      • timeout (number, optional): Query timeout in milliseconds. Defaults to 30000 (i.e., 30 seconds).
      • user (string, optional): Database username. Defaults to "demo".
      • password (string, optional): Database password. Defaults to "demo".
      • url (string, optional): JDBC URL connection string.
    • Returns the result from the underlying stored procedure call (e.g., Demo.demo.execute_spasql_query).
  • jdbc_sparql_query

    • A Virtuoso-specific feature!
    • Execute a SPARQL query and return results.
    • Input parameters:
      • query (string, required): The SPARQL query string.
      • format (string, optional): Desired result format. Defaults to 'json'.
      • timeout (number, optional): Query timeout in milliseconds. Defaults to 30000 (i.e., 30 seconds).
      • user (string, optional): Database username. Defaults to "demo".
      • password (string, optional): Database password. Defaults to "demo".
      • url (string, optional): JDBC URL connection string.
    • Returns the result from the underlying function call (e.g., "UB".dba."sparqlQuery").
  • jdbc_virtuoso_support_ai

    • A Virtuoso-specific feature!
    • Utilizes a Virtuoso-specific AI Assistant function, passing a prompt and optional API key.
    • Input parameters:
      • prompt (string, required): The prompt text for the AI function.
      • api_key (string, optional): API key for the AI service. Defaults to "none".
      • user (string, optional): Database username. Defaults to "demo".
      • password (string, optional): Database password. Defaults to "demo".
      • url (string, optional): JDBC URL connection string.
    • Returns the result from the AI Support Assistant function call (e.g., DEMO.DBA.OAI_VIRTUOSO_SUPPORT_AI).

Basic Use & Troubleshooting

MCP Inspector Connecting to Virtuoso's ODBC Driver

For basic MCP client use and troubleshooting, use the MCP Inspector as follows:

  1. Install the MCP Inspector:

    bash
    npm install -g @modelcontextprotocol/inspector
    
  2. Start the inspector:

    bash
    npx @modelcontextprotocol/inspector java -jar /path/to/mcp-jdbc-server/MCPServer-1.0.0-runner.jar
    

Access the URL returned by the inspector to troubleshoot MCP server interactions.

MCP Inspector Connecting to additional Drivers

For basic MCP client use and troubleshooting, use the MCP Inspector as follows:

  1. Install the JDBC Driver(s), ensuring their JAR files are registered with the host operating system's Java Virtual Machine (JVM) via $CLASSPATH. For instance:

    bash
    export CLASSPATH=$CLASSPATH:/path/to/driver1.jar:/path/to/driver2.jar:/path/to/driverN.jar
    
  2. Start the inspector using the following command-line arguments:

    bash
    npx @modelcontextprotocol/inspector java -cp MCPServer-1.0.0-runner.jar:/path/to/driver1.jar:/path/to/driver2.jar:/path/to/driverN.jar io.quarkus.runner.GeneratedMain
    

Use Example based on Oracle and Informix Drivers

  1. Assuming the following JDBC Driver information:

    • Oracle JDBC Driver URL Template

      bash
      jdbc:oracle:thin:@<hostname>:[port]:<SERVICEID>
      
    • Informix JDBC Driver URL Template

      bash
      jdbc:informix-sqli://<hostname>:<port>/<database></database>:<INFORMIXSERVER>=<SERVICEID>
      
  2. Install the Oracle (ojdbc17.jar) and/or Informix (jdbc-15.0.0.1.1.jar) JDBC Drivers, and ensure their JAR files are registered with the host operating system's Java Virtual Machine (JVM) via $CLASSPATH. For instance:

    bash
     export CLASSPATH=$CLASSPATH:/path/to/Java/Extensions/jdbc-15.0.0.1.1.jar
     export CLASSPATH=$CLASSPATH:/path/to/Java/Extensions/ojdbc17.jar
    
  3. Start the inspector using the following command-line arguments:

    bash
    npx @modelcontextprotocol/inspector java -cp MCPServer-1.0.0-runner.jar:/path/to/Java/Extensions/ojdbc17.jar:/path/to/Java/Extensions/jdbc-15.0.0.1.1.jar io.quarkus.runner.GeneratedMain
    
  4. Access the URL returned by the inspector and then use the jdbc_execute_query operation to query the target database, by providing actual values for the following input field templates:

    • JDBC URL
    • User
    • Password
    • Query

Star History

Star History Chart

Repository Owner

OpenLinkSoftware
OpenLinkSoftware

Organization

Repository Details

Language Java
Default Branch main
Size 17,779 KB
Contributors 3
License MIT License
MCP Verified Nov 12, 2025

Programming Languages

Java
100%

Tags

Join Our Newsletter

Stay updated with the latest AI tools, news, and offers by subscribing to our weekly newsletter.

We respect your privacy. Unsubscribe at any time.

Related MCPs

Discover similar Model Context Protocol servers

  • OpenLink MCP Server for ODBC

    OpenLink MCP Server for ODBC

    MCP-compatible ODBC server enabling LLMs to access diverse databases.

    OpenLink MCP Server for ODBC provides a TypeScript-based server that implements the Model Context Protocol (MCP), facilitating seamless access for Large Language Models to ODBC-accessible data sources. Built on top of node-odbc, it enables actions such as schema and table discovery, SQL query execution, and database introspection. The server supports a wide range of ODBC drivers and robust environment configuration, making it adaptable to multiple database backends and use cases. By leveraging the MCP standard, it simplifies and standardizes how LLMs interface with structured data via ODBC.

    • 9
    • MCP
    • OpenLinkSoftware/mcp-odbc-server
  • MCP Server ODBC via SQLAlchemy

    MCP Server ODBC via SQLAlchemy

    A lightweight FastAPI server enabling model context protocol access to ODBC-compatible databases via SQLAlchemy.

    MCP Server ODBC via SQLAlchemy provides a lightweight, FastAPI-based server that implements the Model Context Protocol (MCP) for accessing ODBC-compatible databases. It bridges AI tools and database systems by exposing standardized endpoints for fetching schema, tables, table descriptions, and executing queries or stored procedures. With support for Virtuoso, PostgreSQL, MySQL, and SQLite, it allows seamless, structured, and context-aware database access for context-driven applications.

    • 19
    • MCP
    • OpenLinkSoftware/mcp-sqlalchemy-server
  • Quarkus Model Context Protocol Servers

    Quarkus Model Context Protocol Servers

    Extensible Java-based servers implementing the Model Context Protocol for context-aware LLM integrations.

    Quarkus Model Context Protocol Servers offers a collection of Java-based servers implementing the Model Context Protocol (MCP) to extend the capabilities of language model applications. Built with the Quarkus MCP server framework, it enables integration with JDBC databases, JVM processes, file systems, JavaFX, Kubernetes, containers, and Wolfram Alpha. The project allows easy deployment and extension of context-aware services for AI applications via MCP. Its servers can be run across different environments using jbang and are easily extensible for new capabilities.

    • 176
    • MCP
    • quarkiverse/quarkus-mcp-servers
  • Multi-Database MCP Server (by Legion AI)

    Multi-Database MCP Server (by Legion AI)

    Unified multi-database access and AI interaction server with MCP integration.

    Multi-Database MCP Server enables seamless access and querying of diverse databases via a unified API, with native support for the Model Context Protocol (MCP). It supports popular databases such as PostgreSQL, MySQL, SQL Server, and more, and is built for integration with AI assistants and agents. Leveraging the MCP Python SDK, it exposes databases as resources, tools, and prompts for intelligent, context-aware interactions, while delivering zero-configuration schema discovery and secure credential management.

    • 76
    • MCP
    • TheRaLabs/legion-mcp
  • MCP libSQL by xexr

    MCP libSQL by xexr

    Secure, protocol-compliant libSQL database server for MCP-enabled clients.

    MCP libSQL by xexr provides a Model Context Protocol (MCP) server designed for secure database access and management via libSQL. It enables database operations—such as querying, table management, and schema inspection—through standardized MCP tools, ensuring compatibility with clients like Claude Desktop and Cursor. The project emphasizes robust security validation, audit logging, and comprehensive error handling. Users benefit from production-ready deployment, extensive test coverage, and streamlined integration with MCP-compatible platforms.

    • 16
    • MCP
    • Xexr/mcp-libsql
  • Alkemi MCP Server

    Alkemi MCP Server

    Integrate Alkemi Data sources with MCP Clients for seamless, standardized data querying.

    Alkemi MCP Server provides a STDIO wrapper for connecting Alkemi data sources—including Snowflake, Google BigQuery, and Databricks—with MCP Clients using the Model Context Protocol. It facilitates context sharing, database metadata management, and query generation through a standardized protocol endpoint. Shared MCP Servers allow teams to maintain consistent, high-quality data querying capabilities without needing to replicate schemas or query knowledge for each agent. Out-of-the-box integration with Claude Desktop and robust debugging tools are also included.

    • 2
    • MCP
    • alkemi-ai/alkemi-mcp
  • Didn't find tool you were looking for?

    Be as detailed as possible for better results