MCP Server

Mind One’s MCP (Model Context Protocol) exposes full control of the platform as tools for AI agents. You can query, create, edit and approve master data using natural language — without opening the Mind One interface.

It’s the first data governance platform that can be natively controlled from an AI agent.

Mind One’s MCP is available on every plan, including Personal.

What the Model Context Protocol is

The Model Context Protocol (MCP) is an open standard developed by Anthropic that lets AI agents interact with external tools and data in a structured, secure way. Instead of the agent having to navigate an interface or call an API manually, MCP exposes Mind One’s capabilities as tools the agent can invoke directly.

Mind One implements an MCP server that exposes every platform operation as a tool available to any compatible client.

Compatible clients

Client	Status	Notes
Claude (claude.ai web)	✓ Tested	From the connector directory
Claude Desktop	✓ Tested	From the connector directory
Claude Code	✓ Tested	`claude mcp add` with the server URL
Cursor	✓ Compatible	Standard MCP configuration
Windsurf	✓ Compatible	Standard MCP configuration
Any MCP client	✓ Compatible	Follows the standard specification

How to connect

The MCP server is hosted by Mind One: there’s nothing to install or run. The client connects to this URL.

https://mcp.getmindapp.io/mcp

In Claude you don’t even need to paste it: Mind One is published in the connector directory, so you search for it by name and connect. In other clients, you add the URL by hand.

Installation and setup

Claude (web and desktop) — from the connector directory

Step 1 — In Claude, open Settings → Connectors → Browse connectors.

Step 2 — Search for Mind One and click Connect.

Step 3 — Claude will take you to the Mind One login. Sign in with your account (Google SSO included) and authorize access on the consent screen. The connector acts as you, with your role — you don’t need to paste any API Key.

This is the recommended way to connect Claude with Mind One: no URLs to copy, no keys to store, and access is revoked from Claude itself or from Profile → API Keys.

Claude (web and desktop) — custom connector by URL

Only if you can’t find it in the directory. The process is the same on claude.ai and Claude Desktop, and it does not go through any configuration file: remote servers are added from the interface.

Step 1 — Go to Settings → Connectors → Add → Add custom connector.

Step 2 — Enter the server URL:

https://mcp.getmindapp.io/mcp

Step 3 — Claude will redirect you to the Mind One login. Sign in with your account (Google SSO included) and authorize access on the consent screen. The connector will act as you, with your role — you don’t need to paste any API Key.

Claude Desktop’s claude_desktop_config.json is for local servers (command / args). A remote server like Mind One’s isn’t configured there: it’s added as a connector from Settings.

Claude Code, Cursor or Windsurf

These clients do declare the server in an MCP config file. It’s an HTTP connection, so the type field is required, and authentication uses your API Key in the header:

{
  "mcpServers": {
    "mind-one": {
      "type": "http",
      "url": "https://mcp.getmindapp.io/mcp",
      "headers": {
        "Authorization": "Bearer mk_your_api_key_here"
      }
    }
  }
}

Replace mk_your_api_key_here with your API Key. Each user generates and manages their own keys from Profile → API Keys. The key inherits your role, so the agent acts with your permissions.

Never share your API Key or include it in public code. Use environment variables or your system’s secrets manager — in Claude Code, "Authorization": "Bearer ${MINDONE_API_KEY}" picks up the value from the environment.

Available tools

The tools exposed by the MCP server correspond to Mind One’s public API operations.

Account

Tool	Description
`mindone_get_account`	Returns information about the tenant and user associated with the API Key

Workspaces

Tool	Description
`mindone_list_workspaces`	Lists all the tenant’s workspaces
`mindone_get_workspace`	Gets a workspace by ID
`mindone_create_workspace`	Creates a new workspace
`mindone_update_workspace`	Updates a workspace

Groups

Tool	Description
`mindone_list_datagroups`	Lists all groups
`mindone_get_datagroup`	Gets a group by ID
`mindone_create_datagroup`	Creates a new group
`mindone_update_datagroup`	Updates a group

Sheets

Tool	Description
`mindone_list_datagrids`	Lists all sheets
`mindone_get_datagrid`	Gets a sheet by ID
`mindone_search_datagrids`	Searches sheets by name
`mindone_create_datagrid`	Creates a new sheet
`mindone_update_datagrid`	Updates a sheet’s metadata
`mindone_update_datagrid_fields`	Replaces a sheet’s field schema
`mindone_insert_rows`	Inserts one or more records (asynchronous — returns a `jobId`)
`mindone_update_row`	Updates a record’s fields (asynchronous — returns a `jobId`)
`mindone_replace_row`	Replaces a full record (asynchronous — returns a `jobId`)
`mindone_patch_rows`	Adds, updates and deletes multiple records in a single synchronous call
`mindone_replace_datagrid_data`	Replaces all of a sheet’s records
`mindone_delete_datagrid`	Deletes a sheet

Value Lists

Tool	Description
`mindone_list_value_lists`	Lists all value lists
`mindone_get_value_list`	Gets a value list by ID
`mindone_create_value_list`	Creates a new value list
`mindone_update_value_list`	Updates a value list

Jobs

Tool	Description
`mindone_get_job_status`	Checks the status of an asynchronous job
`mindone_wait_for_job`	Waits for an asynchronous job to finish (automatic polling) and returns the result. If it’s still running after 25 seconds, it returns the current status so you can ask again

Asynchronous operations

Tools that modify records one at a time — mindone_insert_rows, mindone_update_row and mindone_replace_row — don’t complete immediately. Instead of returning the final result, they respond with a 202 status code and a job identifier ({ "jobId": "..." }).

To learn the operation’s actual outcome, you must check the job’s status with mindone_get_job_status, passing that jobId, until status reaches a terminal state:

queued — the job is queued, waiting to be processed.
running — the job is running.
succeeded — the job finished successfully (check the result field).
failed — the job failed (check the error field for the reason).

Don’t consider the operation successful just because you received the jobId: the work may still be in progress or may fail. The agent should poll mindone_get_job_status every 1-2 seconds until it gets succeeded or failed before reporting the result.

The bulk operations mindone_patch_rows and mindone_replace_datagrid_data are synchronous: they return the result directly and don’t require polling.

Usage examples with Claude

Querying data:

“How many active customers are there in the Master Customers sheet?”

Creating a record:

“Add a new room type to the Hotel Products workspace: Junior Suite, capacity 2, sea view.”

Approving a sheet:

“Move the Summer 2025 Rates sheet to Approved status.”

Auditing:

“Who last modified the Suppliers sheet, and when?”

Multi-workspace management:

“List all sheets in Draft status across every workspace and tell me which ones have gone more than 7 days without being approved.”

Skills for Claude Code

Besides the MCP server, Mind One publishes a set of Claude Code skills: high-level instructions built on top of the MCP tools. Instead of invoking tools one by one, skills guide Claude step by step to complete tasks — exploring your account, creating data structures, importing records or searching for sheets — from natural language.

Skills follow the open Agent Skills standard, so they work in any compatible AI tool.

Skills require Mind One’s MCP server to be configured. Follow the Installation and setup steps on this same page before using them.

Requirements

Claude Code v2.1 or later
Mind One’s MCP server configured (see the Installation and setup section)

Installation

The skills repository is available on GitHub:

https://github.com/Mind-Analytics-SL/mind_one_mcp_skills

Option 1 — Load at session start (nothing to copy)

Clone the repository once and pass it with --add-dir every time you start Claude Code:

git clone https://github.com/Mind-Analytics-SL/mind_one_mcp_skills ~/mind_one_mcp_skills
claude --add-dir ~/mind_one_mcp_skills

To update to the latest version, run git pull inside the cloned folder.

Option 2 — Install permanently

Clone the repo and run the install script to copy the skills to ~/.claude/skills/, making them available in every Claude Code session:

git clone https://github.com/Mind-Analytics-SL/mind_one_mcp_skills
cd mind_one_mcp_skills
./install.sh

Restart Claude Code after installing. To update, run git pull and run ./install.sh again.

Available skills

Skill	Command	Description
Explore	`/mindone-explore`	Explore your workspaces, groups and sheets
Create	`/mindone-create`	Create workspaces, groups and sheets from natural language
Import	`/mindone-import`	Insert or replace data in a sheet
Search	`/mindone-search`	Search for sheets across all your workspaces

Usage

Invoke any skill directly with its command:

/mindone-explore
/mindone-create a workspace for the sales team with a contacts datagrid
/mindone-import orders into the Q1 Sales datagrid
/mindone-search customer

Or simply ask Claude naturally — it will invoke the right skill when relevant:

“What sheets do I have?”
“Create a new workspace for the engineering team with a tasks sheet.”
“Find all sheets related to invoices.”

Security

The MCP inherits the platform’s full security model:

Authentication: the API Key belongs to a user and the agent acts with their role. The public API/MCP enforces that role: read access for every role; record edits from Contributor upward; creating and editing structure (sheets, groups, workspaces, value lists) from Modeller upward; full access for Admin.
Tenant isolation: the agent can only access the data of the API Key’s tenant.
Auditing: every operation the agent performs is logged in the change history with the API Key’s identifier.
Rate limiting: the same rate limits that apply to the REST API apply to the MCP.

We recommend using a dedicated API Key for the MCP (revocable independently without affecting other integrations). Its scope is determined by your user’s role.

Frequently asked questions

Can I run the MCP server on my own machine? Not today: the server is used hosted at mcp.getmindapp.io and we don’t publish a local distribution. Any MCP-compatible client can connect to that URL, using the Mind One login where the client supports it or an API Key in the Authorization header.

What happens if the agent makes a mistake? Every operation is logged in the audit history. You can see exactly what the agent did, when, and with what values.

Can I limit what the agent can do? Yes. The agent inherits the role of the user who owns the API Key. For example, if you connect with a user with the Data Viewer role, the agent will only be able to query data; with Contributor, it will also be able to edit records, but not create or delete structure.

Does it work with any AI model? It works with any client that implements the MCP standard. Claude, Cursor and Windsurf are tested. Other MCP-compatible clients will work without additional configuration.

Does the MCP have access to my data warehouse credentials? No. The MCP accesses Mind One’s data, not the data warehouse directly. Autosync credentials are managed separately and aren’t accessible through the MCP.

Claude Code Skills — A skills repository that automates Mind One tasks from Claude Code.
API Documentation — Direct programmatic access to Mind One via REST.
Connections — Automatic syncing with data warehouses via Autosync.
Users and Roles — Managing permissions for MCP API Keys.

Connections API Documentation