Agentic MCP server integration

Table of Contents

Integration overview
- How it works
Get started with the integration
Configuration considerations and best practices
Additional resources

ThoughtSpot’s Agentic Multi-Client Protocol (MCP) Server allows integrating ThoughtSpot analytics directly into any AI agent, custom chatbot, or LLM-based systems and platforms that support MCP. It acts as a connector between the ThoughtSpot instance and external AI client, and provides a set of tools to interact with ThoughtSpot’s data and its analytics capabilities programmatically.

The MCP tools of the Agentic MCP Server support the following functions:

Ask natural language questions and get data in a structured format from ThoughtSpot
Retrieve relevant analytical questions based on user queries
Create a Liveboard with the answers generated from the queries
Get data source recommendations based on a user’s query and intent

Integration overview🔗

The Agentic MCP server integration requires the following core components and authentication framework:

MCP server

The MCP server provides a tools wrapper with a discoverable interface for agentic analytics. It exposes a set of tools to external agents to interact with ThoughtSpot’s resources, data, and analytical capabilities. The MCP server includes an orchestration layer that determines which tools to invoke based on the incoming queries and user intent. The MCP server can be hosted by ThoughtSpot or by customers in their own environment.

MCP tools, resources, and AI APIs

MCP tools are the actions that the MCP server exposes to the agent for interaction with ThoughtSpot. Currently, the MCP server supports the following tools:

ping to test connection to ThoughtSpot
getRelevantQuestions to get relevant analytical questions
The getRelevantQuestions tool calls /api/rest/2.0/ai/relevant-questions/ API and gets relevant data questions for a given data context by breaking down a user’s query.
getAnswer to execute the queries and fetch data
The getAnswer tool calls /api/rest/2.0/ai/agent/converse/sse API and generates answers and insights for a given data context.
createLiveboard to create a Liveboard in ThoughtSpot
The createLiveboard tool calls the Liveboard creation workflow and creates a Liveboard with the answers generated from user’s query.
getDataSourceSuggestions to get data source suggestions
Based on the type of data that users want to fetch, getDataSourceSuggestions gets a list of data source recommendations. Currently, getDataSourceSuggestions is not exposed as an MCP tool and is available as an MCP resource. To data source suggestions, the user or MCP client must have at least view access to ThoughtSpot data sources.

MCP host/client

The external system or application environment with AI Agent, Claude, OpenAI, or a custom chatbot that acts as a user interface, orchestrates interaction with ThoughtSpot MCP server, and enables agentic workflows.

Configuration settings to enable the integration

Integration requires configuration, typically via a config file, to specify server addresses, credentials, and other connection details.

Authentication and security settings

Access to ThoughtSpot instance:
For MCP server connection, users require access to a ThoughtSpot instance. ThoughtSpot administrators can use the SSO framework with SAML or OAuth token-based authentication methods to authenticate and sign in the users.
To get answers to their data queries, your application users require at least view access to ThoughtSpot data sources. To generate an Answer or to create Liveboard, users
CSP and CORS settings:
To secure communication between the MCP client and the ThoughtSpot instance, administrators must add the MCP server URL to CSP (Content Security Policy) and CORS (Cross-Origin Resource Sharing) allowlists in ThoughtSpot.
SAML redirect settings:
For SAML SSO users, the SAML redirect domain configuration is required to ensure that users are redirected to an allowed and trusted domain after they are authenticated.
Client connection configuration:
MCP server integration also requires configuration on the client side, typically via a config file, to include the MCP server addresses, credentials, and other details.

How it works🔗

When the MCP Server integration is enabled, your host app connects to ThoughtSpot and enables the following workflow:

User initiates a request.
The user sends a query to get data from a specific ThoughtSpot data model or context.
AI agent receives the request and discovers the MCP tools
The agent discovers MCP tools available in its environment and processes the request to the MCP server, specifying the data model or context and the user’s query.
MCP server receives the request and executes actions via tools
The MCP server executes tools and triggers API requests to ThoughtSpot to break down the user’s query into relevant questions, get information for the specified data context, or create an artifact.
The MCP server sends the response to the MCP host.
The agent receives the response and constructs the output
The agent receives the response from the MCP host and presents it to the user
User receives the response
The user can refine the analysis or choose a direction for further exploration.
For example, after receiving relevant questions and answer, the user can send follow-up questions or send a Liveboard creation request.

The following figure illustrates the sequence of workflows in a typical MCP server integration setup:

Get started with the integration🔗

To get started with the integration, complete the steps described in the following sections. In this article, we’ll integrate ThoughtSpot MCP server with Claude and enable agentic interaction and workflows.

Before you begin🔗

Before you begin, verify if your application setup has the following:

Node.js version 22 or later is installed on your system.
A ThoughtSpot instance with 10.11.0.cl or later release version. You’ll need administrator credentials to configure security settings or set up token-based authentication for your application users.
Your application users require at least view access to the data source objects to query data and get answers.
Row-level and column-level security rules are configured for data security and access control.

Configure security settings on ThoughtSpot🔗

To allow the secure communication between the MCP server and your ThoughtSpot instance, configure the following settings:

On your ThoughtSpot instance, navigate to Develop > Customizations > Security Settings.
Add the MCP server domain to CSP and CORS allowlists.
If your setup uses SAML SSO logins, add the MCP server domain to the SAML redirect domain allowlist.

Add MCP server to the MCP client’s config🔗

If your MCP client supports remote MCP servers, add the MCP server URL to the client’s config file.

MCP clients such as Claude Desktop, Windsurf, and Cursor do not support remote MCP servers. In such a case, add the URL with arguments shown in this example:

{
  "mcpServers": {
    "ThoughtSpot": {
      "command": "npx",
      "args": [
         "mcp-remote",
         "https://agent.thoughtspot.app/mcp"
      ]
    }
  }
}

After updating the config file:

Connect to ThoughtSpot instance and complete authentication.
Restart your MCP client to load the new configuration.

If the connection is successful, you’ll see an option to add data context from ThoughtSpot.
For example, the Claude Desktop shows the Add to ThoughtSpot as shown in the following figure:
Verify if the MCP tools are available.
For example, on Claude Desktop, click the Search and tools icon to view the MCP tools.

You can adjust tool access, resources, instructions to data models, object permissions, and user privileges as needed. To get insights, the user requires view access to the data source objects and data download privilege.

Verify the query and response workflow🔗

Select a datasource to set the context of your query.
For example, on Claude Desktop, click the + icon and select a data source.
Ask an analytics question to trigger the query and response workflow.
Verify if the AI agent on your MCP client gets relevant data questions from ThoughtSpot and generates an Answer.
Try sending a query to create a Liveboard and verify if a Liveboard is created on your ThoughtSpot instance.

Configuration considerations and best practices🔗

Users must have access to the data source. If not, it will lead to empty results.
Ensure that data is modeled. Large or complex data sources may impact response time.
Streaming responses require client support for real-time updates. Ensure that the system is available.
Each conversation is session-based. Ensure that session IDs are managed correctly in your integration.

Additional resources🔗

Check the MCP Server GitHub repo for implementation instructions.
Check your MCP client’s documentation for instructions on how to connect to MCP servers.
To understand ThoughtSpot agentic analytics capabilities and AI APIs, refer to the following documentation:
In case of issues with connection or authentication, check the troubleshooting steps.