cdata-jdbc-mcp-gateway (Read-Only Access)

This generic Model Context Protocol (MCP) Server component is engineered specifically for read-only interactions with CData JDBC Drivers.

❗Important Notice: This specific implementation grants read-only privileges. For solutions supporting full CRUD operations (Create, Read, Update, Delete) and simplified deployment, explore the complimentary CData MCP Servers (beta).

Core Objective

The primary goal of this read-only MCP Gateway is to empower AI constructs, such as local LLMs (e.g., Claude Desktop), to execute queries against live datasets sourced from any of the 300+ supported repositories accessible via CData JDBC Drivers.

CData JDBC Drivers function by establishing connectivity to various SaaS platforms, NoSQL repositories, and web APIs, subsequently presenting their structures as standard relational SQL models.

This server component encapsulates these drivers, exposing their data through a streamlined MCP interface. This design permits AI agents to fetch current information by posing conversational queries, entirely obviating the need for manual SQL formulation.

Deployment Methodology

In the subsequent instructions, the placeholder {data source} refers to the target backend system (e.g., Salesforce). Code samples will use Salesforce for illustration, but the configuration principles apply universally across all supported JDBC Drivers. 1. Repository Acquisition: bash git clone https://github.com/cdatasoftware/cdata-jdbc-mcp-server.git cd cdata-jdbc-mcp-server

1. Server Compilation: bash mvn clean install

   This process yields the executable JAR: CDataMCP-jar-with-dependencies.jar 3. Driver Acquisition and Installation: Obtain the required CData JDBC Driver from https://www.cdata.com/jdbc 4. Driver Licensing (Salesforce Example): * Navigate to the lib subdirectory within the driver's installation path: * (Windows) C:\Program Files\CData\CData JDBC Driver for {data source}\ * (Mac/Linux) /Applications/CData JDBC Driver for {data source}/ * Execute the licensing utility command: java -jar cdata.jdbc.salesforce.jar --license * Input required user details and supply "TRIAL" or a valid license key. 5. Data Source Connection Configuration (Salesforce Example): * Invoke the driver JAR to launch the Connection String utility: java -jar cdata.jdbc.salesforce.jar

   • Configure the necessary connection parameters and validate with "Test Connection".

     Note: If the connection relies on OAuth, browser-based authentication will be necessary.

   • Upon successful verification, capture and retain the resulting JDBC connection string.
   • Creation of Connection Descriptor File (.prp): Generate a configuration file (e.g., Salesforce.prp) detailing the JDBC linkage using the subsequent attributes:
   • Prefix: Defines the namespace for exposed tools.
   • ServerName: A unique identifier for this server instance.
   • ServerVersion: Version tag for the service endpoint.
   • DriverPath: Absolute filesystem location of the JDBC driver JAR.
   • DriverClass: The fully qualified name of the JDBC Driver implementation class (e.g., cdata.jdbc.salesforce.SalesforceDriver).
   • JdbcUrl: The connection string obtained in the previous step.
   • Tables: If left empty, all accessible structures are exposed; otherwise, specify the exact tables for schema mapping. env Prefix=salesforce ServerName=CDataSalesforce ServerVersion=1.0 DriverPath=PATH\TO\cdata.jdbc.salesforce.jar DriverClass=cdata.jdbc.salesforce.SalesforceDriver JdbcUrl=jdbc:salesforce:InitiateOAuth=GETANDREFRESH; Tables=

Integration with AI Clients (e.g., Claude Desktop)

1. Client Configuration File Update: Compose or modify the client's configuration file (e.g., claude_desktop_config.json) to incorporate the new MCP endpoint definition within the mcpServers structure.

   Windows Configuration Snippet:

   { "mcpServers": { "salesforce": { "command": "PATH\TO\java.exe", "args": [ "-jar", "PATH\TO\CDataMCP-jar-with-dependencies.jar", "PATH\TO\Salesforce.prp" ] }, ... } }

   Linux/Mac Configuration Snippet:

   { "mcpServers": { "salesforce": { "command": "/PATH/TO/java", "args": [ "-jar", "/PATH/TO/CDataMCP-jar-with-dependencies.jar", "/PATH/TO/Salesforce.prp" ] }, ... } }

If necessary, relocate the generated configuration file to the application's designated directory (e.g., for Claude Desktop): Windows Relocation: bash cp C:\PATH\TO\claude_desktop_config.json %APPDATA%\Claude\claude_desktop_config.json

  **Linux/Mac Relocation:**
  bash
  cp /PATH/TO/claude_desktop_config.json /Users/{user}/Library/Application\ Support/Claude/claude_desktop_config.json

1. Client Restart/Activation: Relaunch or refresh the connected AI client application.

Tip: If the new MCP endpoint does not immediately appear, ensure the client application is completely terminated (verify via Task Manager/Activity Monitor) before reopening.

Direct Server Execution

1. The MCP Gateway can be initiated independently via the command line: bash java -jar /PATH/TO/CDataMCP-jar-with-dependencies.jar /PATH/TO/Salesforce.prp

   Constraint: The server communicates via standard input/output (stdio), thus limiting its operational scope to clients running on the same host machine as the server instance.

Operational Scope and Examples

Following successful configuration, the AI client gains access to intrinsic tools for interacting with the underlying data structures. Direct invocation of these tools is usually unnecessary; simply direct the client to pose questions regarding the connected data environment. For instance: * "Determine the relationship between realized sales opportunities and the industry sector of the associated accounts." * "Quantify the volume of active support incidents logged within the SUPPORT department." * "List all scheduled appointments for the current day."

The suite of available functions and their definitions are detailed below. The placeholder {servername} corresponds to the identifier defined in the configuration file (e.g., salesforce).

Available Functions & Specifications

• {servername}_get_tables - Fetches a delimited list of accessible data structures. Use {servername}_get_columns subsequently to enumerate fields within a specific structure. Output is delivered in Comma-Separated Values (CSV) format, with the first line containing field headers.
• {servername}_get_columns - Retrieves the field definitions for a designated structure. Cross-reference with {servername}_get_tables for the full structure inventory. Output format is CSV, including a header row.
• {servername}_run_query - Executes a SQL SELECT command against the data source.

JSON-RPC Interaction Prototypes

For scenarios involving direct scripting of server interactions rather than relying on an AI abstraction layer (like Claude), refer to the following JSON-RPC 2.0 compliant payload blueprints when invoking the exposed functions.

{servername}_get_tables Invocation

{ "jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": { "name": "salesforce_get_tables", "arguments": {} } }

{servername}_get_columns Invocation

{ "jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": { "name": "salesforce_get_columns", "arguments": { "table": "Account" } } }

{servername}_run_query Invocation

{ "jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": { "name": "salesforce_run_query", "arguments": { "sql": "SELECT * FROM [Account] WHERE [IsDeleted] = true" } } }

Diagnostic Guide

1. Visibility Issue: If the CData MCP Server fails to materialize in the client interface, confirm that the client application has been fully shut down (check background processes via system monitors).
2. Data Retrieval Failure: If the client cannot fetch data, meticulously verify the connection string configuration, ensuring the string copied from the utility matches the entry in the descriptor (.prp) file.
3. Connectivity Problems: For difficulties linking to the primary data system, engage the CData Support Team.
4. MCP Server Feedback: For comments or issues specifically related to the MCP server functionality, utilize the CData Community.

Licensing Information

This MCP gateway is distributed under the terms of the MIT License, granting users the liberty to utilize, modify, and disseminate the software, contingent upon adherence to the license's stipulations. Full particulars are available in the project's LICENSE file.

Data Source Compatibility Roster

Access	Act CRM	Act-On	Active Directory
ActiveCampaign	Acumatica	Adobe Analytics	Adobe Commerce
ADP	Airtable	AlloyDB	Amazon Athena
Amazon DynamoDB	Amazon Marketplace	Amazon S3	Asana
Authorize.Net	Avalara AvaTax	Avro	Azure Active Directory
Azure Analysis Services	Azure Data Catalog	Azure Data Lake Storage	Azure DevOps
Azure Synapse	Azure Table	Basecamp	BigCommerce
BigQuery	Bing Ads	Bing Search	Bitbucket
Blackbaud FE NXT	Box	Bullhorn CRM	Cassandra
Certinia	Cloudant	CockroachDB	Confluence
Cosmos DB	Couchbase	CouchDB	CSV
Cvent	Databricks	DB2	DocuSign
Dropbox	Dynamics 365	Dynamics 365 Business Central	Dynamics CRM
Dynamics GP	Dynamics NAV	eBay	eBay Analytics
Elasticsearch	Email	EnterpriseDB	Epicor Kinetic
Exact Online	Excel	Excel Online	Facebook
Facebook Ads	FHIR	Freshdesk	FTP
GitHub	Gmail	Google Ad Manager	Google Ads
Google Analytics	Google Calendar	Google Campaign Manager 360	Google Cloud Storage
Google Contacts	Google Data Catalog	Google Directory	Google Drive
Google Search	Google Sheets	Google Spanner	GraphQL
Greenhouse	Greenplum	HarperDB	HBase
HCL Domino	HDFS	Highrise	Hive
HubDB	HubSpot	IBM Cloud Data Engine	IBM Cloud Object Storage
IBM Informix	Impala	Instagram	JDBC-ODBC Bridge
Jira	Jira Assets	Jira Service Management	JSON
Kafka	Kintone	LDAP	LinkedIn
LinkedIn Ads	MailChimp	MariaDB	Marketo
MarkLogic	Microsoft Dataverse	Microsoft Entra ID	Microsoft Exchange
Microsoft OneDrive	Microsoft Planner	Microsoft Project	Microsoft Teams
Monday.com	MongoDB	MYOB AccountRight	MySQL
nCino	Neo4J	NetSuite	OData
Odoo	Office 365	Okta	OneNote
Oracle	Oracle Eloqua	Oracle Financials Cloud	Oracle HCM Cloud
Oracle Sales	Oracle SCM	Oracle Service Cloud	Outreach.io
Parquet	Paylocity	PayPal	Phoenix
PingOne	Pinterest	Pipedrive	PostgreSQL
Power BI XMLA	Presto	Quickbase	QuickBooks
QuickBooks Online	QuickBooks Time	Raisers Edge NXT	Reckon
Reckon Accounts Hosted	Redis	Redshift	REST
RSS	Sage 200	Sage 300	Sage 50 UK
Sage Cloud Accounting	Sage Intacct	Salesforce	Salesforce Data Cloud
Salesforce Financial Service Cloud	Salesforce Marketing	Salesforce Marketing Cloud Account Engagement	Salesforce Pardot
Salesloft	SAP	SAP Ariba Procurement	SAP Ariba Source
SAP Business One	SAP BusinessObjects BI	SAP ByDesign	SAP Concur
SAP Fieldglass	SAP HANA	SAP HANA XS Advanced	SAP Hybris C4C
SAP Netweaver Gateway	SAP SuccessFactors	SAS Data Sets	SAS xpt
SendGrid	ServiceNow	SFTP	SharePoint
SharePoint Excel Services	ShipStation	Shopify	SingleStore
Slack	Smartsheet	Snapchat Ads	Snowflake
Spark	Splunk	SQL Analysis Services	SQL Server
Square	Stripe	Sugar CRM	SuiteCRM
SurveyMonkey	Sybase	Sybase IQ	Tableau CRM Analytics
Tally	TaxJar	Teradata	Tier1
TigerGraph	Trello	Trino	Twilio
Twitter	Twitter Ads	Veeva CRM	Veeva Vault
Wave Financial	WooCommerce	WordPress	Workday
xBase	Xero	XML	YouTube Analytics
Zendesk	Zoho Books	Zoho Creator	Zoho CRM
Zoho Inventory	Zoho Projects	Zuora	... Many More

WIKIPEDIA: XMLHttpRequest (XHR) is a specific interface within JavaScript, structured as an object, utilized to dispatch HTTP communications between a web browser client and a remote server. Its methods grant browser-hosted applications the capability to issue requests subsequent to page rendering and process incoming server data asynchronously. XHR is foundational to Ajax-style development paradigms. Prior to XHR/Ajax, interaction with servers heavily relied on traditional page navigation initiated via form submissions or hyperlink clicks, which typically resulted in a full page refresh.

== Historical Context == The conceptual basis for XMLHttpRequest originated around the year 2000, developed by the engineering team behind Microsoft Outlook. This concept was subsequently embedded into Internet Explorer 5 (released 1999). However, the initial syntax did not utilize the standardized XMLHttpRequest name; instead, proprietary identifiers like ActiveXObject("Msxml2.XMLHTTP") and ActiveXObject("Microsoft.XMLHTTP") were employed. By the release of Internet Explorer 7 (2006), universal adoption of the XMLHttpRequest identifier was achieved across major browser implementations, including Mozilla's Gecko engine (2002), Safari 1.2 (2004), and Opera 8.0 (2005).

=== Standardization Efforts === The World Wide Web Consortium (W3C) formalized the specification for the XMLHttpRequest object with a Working Draft on April 5, 2006. A subsequent Level 2 specification followed on February 25, 2008, introducing features for tracking request progress, enabling cross-origin requests, and managing binary data streams. By late 2011, the Level 2 augmentations were merged back into the primary specification. Development authority transitioned to the WHATWG at the close of 2012, where it is now maintained as a living document documented using Web IDL.

== Operational Flow == Executing a network request using XMLHttpRequest typically involves a sequential programming routine:

1. Object Instantiation: Create an instance of the XMLHttpRequest object via its constructor.
2. Request Definition: Invoke the "open" method to set the HTTP verb (GET/POST, etc.), designate the target resource URL, and specify operational mode (synchronous or asynchronous).
3. Asynchronous Listener Setup (If Async): Define an event handler function to be triggered when the request's status changes.
4. Transmission: Initiate the outbound server transmission using the "send" method. Data payloads are passed to this method if required.
5. Response Processing: Monitor state transitions via the registered event listener. Upon receipt of server data, it populates the responseText property (by default). When the object completes all processing steps, it transitions to state 4, signifying completion ("done"). Beyond these essential steps, XHR offers extensive control over request behavior. Custom headers can be injected to guide server processing, and data can be uploaded directly within the send() call. Responses can be parsed directly from JSON into native JavaScript objects or processed incrementally as chunks arrive, avoiding wait times for full transmission. The operation can also be terminated prematurely or configured with a maximum timeout duration.

== Cross-Origin Transactions == In the nascent stages of the World Wide Web, the restriction against scripts on one domain requesting resources from another domain (the Same-Origin Policy) was identified as a potential obstacle to the development of robust, interconnected applications.