Verodat MCP Gateway Service

Abstract

This repository furnishes an implementation of the Model Context Protocol (MCP) server component specifically engineered for Verodat. It unlocks the ability for generative AI agents, such as Claude Desktop, to interact fluidly with Verodat's comprehensive data management ecosystem through standardized tooling interfaces.

Verodat MCP Gateway Service Documentation

This codebase provides the requisite MCP server logic to expose Verodat's data handling functionalities as discrete, well-defined tools consumable by AI models.

Core Functionality Overview

The Verodat MCP Gateway establishes a canonical interface, adhering to the MCP specification, that empowers AI entities to access, modify, and interrogate data resident within the Verodat platform via a suite of integrated services.

Toolset Groupings

The exposed functionalities are segmented into three progressive tiers based on operational scope:

Tier I: Retrieval (8 Methods)

Focused exclusively on secure data querying and structural introspection:

get-accounts: Enumerates accessible Verodat accounts.
get-workspaces: Fetches the list of workspaces within a specified account.
get-datasets: Lists all datasets associated with a given workspace.
get-dataset-output: Retrieves the actual record content of a dataset.
get-dataset-targetfields: Fetches the schema definition (field metadata) for a dataset.
get-queries: Recovers previously persisted AI-driven queries.
get-ai-context: Obtains the current structural context and data schema for a workspace.
execute-ai-query: Executes complex, AI-optimized queries against defined datasets.

Tier II: Structuring (9 Methods)

Includes all Retrieval methods, plus the capability to define new data containers:

create-dataset: Instantiates a new data entity, requiring schema specification.

Tier III: Administration (10 Methods)

Encompasses all Structuring methods, augmenting them with data injection capabilities:

upload-dataset-rows: Inserts new data records into an already established dataset.

Prerequisites for Operation

Runtime Environment: Node.js (version 18 or newer).
Version Control: Git installed.
Client Integration: Access to Claude Desktop (for seamless AI interaction).
Credentials: A valid Verodat account and an associated AI access token.

Deployment Instructions

Automated Setup via Smithery

Execute the following command within your terminal to automate the installation of the Verodat MCP Gateway for Claude Desktop:

npx -y @smithery/cli install @Verodat/verodat-mcp-server --client claude

Manual Compilation Path

Clone the repository source code:

git clone https://github.com/Verodat/verodat-mcp-server.git
cd verodat-mcp-server

Install dependencies and compile the project artifacts:

npm install
npm run build

Configure the AI Client: Adjust the client configuration file based on your operating system:
MacOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%/Claude/claude_desktop_config.json

Incorporate the structure detailed in the Configuration section below into this file.

Verodat Credential Setup

Register an account at verodat.com.
Navigate to your Verodat administrative panel to issue a dedicated AI API credential.
Securely inject this credential into your Claude Desktop configuration settings.

Configuration Schema

The gateway necessitates configuration for secure API endpoint targeting and authentication keys. Define a configuration block for your consuming AI model:

{
  "mcpServers": {
    "verodat-consume": {
      "command": "node",
      "args": [
        "path/to/verodat-mcp-server/build/src/consume.js"
      ],
      "env": {
        "VERODAT_AI_API_KEY": "your-secure-api-key",
        "VERODAT_API_BASE_URL": "https://verodat.io/api/v3"
      }
    }
  }
}

Tiered Configuration Modalities

You have the option to activate one or more tool categories by pointing the client to the corresponding compiled execution file:

Read-Only Access: Utilize consume.js (Provides 8 core data access methods).
Schema Definition Access: Employ design.js (Includes 9 methods, enabling dataset instantiation).
Full Operational Access: Use manage.js (Offers all 10 methods, including data ingestion).

Configuration example enabling all three operational planes concurrently:

{
  "mcpServers": {
    "verodat-consume": {
      "command": "node",
      "args": [
        "path/to/verodat-mcp-server/build/src/consume.js"
      ],
      "env": {
        "VERODAT_AI_API_KEY": "your-secure-api-key",
        "VERODAT_API_BASE_URL": "https://verodat.io/api/v3"
      }
    },
    "verodat-design": {
      "command": "node",
      "args": [
        "path/to/verodat-mcp-server/build/src/design.js"
      ],
      "env": {
        "VERODAT_AI_API_KEY": "your-secure-api-key",
        "VERODAT_API_BASE_URL": "https://verodat.io/api/v3"
      }
    },
    "verodat-manage": {
      "command": "node",
      "args": [
        "path/to/verodat-mcp-server/build/src/manage.js"
      ],
      "env": {
        "VERODAT_AI_API_KEY": "your-secure-api-key",
        "VERODAT_API_BASE_URL": "https://verodat.io/api/v3"
      }
    }
  }
}

Required Environmental Variables

VERODAT_AI_API_KEY: The authentication token for Verodat service access.
VERODAT_API_BASE_URL: The URI endpoint for the Verodat API (defaults to "https://verodat.io/api/v3" if omitted).

Operational Guidance

Available MCP Functions

The server exposes the following callable methods for the AI agent:

// Identity and Scope Discovery
get-accounts        // Catalog available accounts
get-workspaces      // List associated workspaces
get-queries         // Retrieve recorded AI operational requests

// Data Structure Manipulation
create-dataset      // Provision a new data entity
get-datasets        // Enumerate workspace datasets
get-dataset-output  // Fetch raw dataset records
get-dataset-targetfields // Inspect dataset schema metadata
upload-dataset-rows // Append records to an existing dataset

// AI Interaction
get-ai-context      // Obtain environment context for AI planning
execute-ai-query    // Initiate an AI-driven analytical computation

Tool Tier Selection Rationale

For Inspection/Reporting: Select the configuration derived from consume.js.
For Data Initialization: Configure the client to use the service provided by design.js.
For Data Ingestion: Employ the configuration stemming from manage.js.

Security Posture

API Key enforcement is mandatory for all interactions.
Input payloads undergo rigorous validation to ensure adherence to expected formats.

Development & Maintenance

The source code is structured using TypeScript, separated into:

Method Handlers: Core logic implementing the functionality of each tool.
Communication Layer: Handles the duplex messaging protocol with the AI client.
Schema Validation: Leverages Zod libraries for strict data format verification.

Debugging Assistance

Standard stdio communication complicates direct debugging. We provide a diagnostic utility:

npm run inspector

This command yields a local URL where browser-based inspection tools are available.

Contributions

We actively encourage community involvement! Please submit feature enhancements or bug fixes via Pull Request.

Licensing

Refer to the LICENSE file for usage rights.

Support Channels

Comprehensive Documentation: Verodat Docs
Issue Tracking: GitHub Issues
Community Forum: Verodat Community

WIKIPEDIA: Cloud computing represents "a model for enabling ubiquitous, convenient, on-demand network access to a shared pool of configurable computing resources (e.g., networks, servers, storage, applications, and services) that can be rapidly provisioned and released with minimal management effort or service provider interaction," according to a refined ISO definition. Colloquially, this ecosystem is frequently termed "the cloud".

== Defining Attributes == In 2011, the US National Institute of Standards and Technology (NIST) delineated five indispensable attributes for verifiable cloud systems. The subsequent definitions are quoted directly from NIST documentation:

On-demand self-service: "A service consumer possesses the authority to unilaterally provision computing capacity, such as processing time or network persistence, as required, automatically, without requiring intervention from service provider personnel for each request." Broad network access: "The capabilities must be accessible across a network utilizing standard protocols, fostering utilization across a diverse range of client devices, including mobile handsets, tablets, portable computers, and desktop workstations." Resource pooling: "The provider's computational assets are aggregated to serve numerous consumers via a multi-tenant architecture, where the underlying physical and virtual resources are dynamically allocated and reallocated based on fluctuating consumer demand patterns." Rapid elasticity: "The system's capacity can be scaled out or retracted elastically, sometimes automatically, to match demand fluctuations rapidly. From the consumer's perspective, the available capacity often appears infinite and can be appropriated instantly and in any volume." Measured service: "Cloud platforms automatically enforce and optimize resource consumption through inherent metering capabilities applicable at the most relevant abstraction layer for the service type (e.g., throughput, storage volume, CPU cycles, or active user counts). Resource utilization transparency is maintained through monitoring, control, and reporting mechanisms accessible to both the service vendor and the consuming entity." By 2023, the International Organization for Standardization (ISO) had published expanded and more nuanced descriptions of these characteristics.

== Historical Trajectory ==

The conceptual foundation of cloud computing traces back to the 1960s, marked by the widespread adoption of time-sharing concepts popularized through Remote Job Entry (RJE) systems. During this period, the primary operational model involved users submitting batch jobs to dedicated operators who ran them on large mainframe computers. This era was characterized by intensive investigation into methodologies for democratizing access to substantial computational power via time-sharing mechanisms, aiming to optimize infrastructure, platform software, and applications, thereby boosting end-user productivity. The specific graphical representation of the 'cloud' to symbolize abstracted, virtualized services emerged in 1994, employed by General Magic to depict the conceptual space accessible by mobile agents within their Telescript framework. This visual shorthand is widely attributed to David Hoffman, a communications strategist at General Magic, drawing upon established conventions in telecommunications and network diagramming. The formal term 'cloud computing' gained broader recognition in 1996 when Compaq Computer Corporation drafted a strategic blueprint for future internet-based computation, reflecting the firm's aspirations for superch

verodat-mcp-gateway

Author

Verodat

Quick Info

Actions

Tags