Connect Sigma Computing to Claude: Govern Teams, Access & Workspaces

If you need to connect Sigma Computing to Claude to automate workspace provisioning, audit data access, or manage team connections to cloud data warehouses, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's natural language tool calls and Sigma Computing's REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on connecting Sigma Computing to ChatGPT or explore our broader architectural overview on connecting Sigma Computing to AI Agents.

Giving a Large Language Model (LLM) read and write access to an enterprise Business Intelligence (BI) platform like Sigma Computing is a high-stakes engineering challenge. You have to handle complex object hierarchies, map massive JSON schemas to MCP tool definitions, and deal with Sigma's specific data warehouse connection paradigms. Every time the API updates an endpoint or deprecates a field, you have to update your server code, redeploy, and test the integration. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Sigma Computing, connect it natively to Claude, and execute complex data governance workflows using natural language.

The Engineering Reality of the Sigma Computing API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against enterprise BI APIs is painful. You are not just integrating a standard CRUD app - you are integrating a platform that manages active connections to Snowflake, BigQuery, and Redshift, alongside a deeply nested permissions model.

If you decide to build a custom MCP server for Sigma Computing, you own the entire API lifecycle. Here are the specific challenges you will face:

Complex Inode-Based Navigation and RBAC Sigma Computing uses an "inode" system to represent objects like workbooks, datasets, folders, and connection paths. When an LLM wants to grant a team access to a specific dataset, it cannot just pass a dataset name. It must resolve the exact inode type and ID, map that to the correct team ID, and format the permission grant payload correctly. A managed MCP server handles the schema translation so the LLM knows exactly which identifiers are required for which resources.

Strict Workbook Export Lifecycles Unlike simpler SaaS platforms where downloading a report is a single GET request, Sigma Computing's export architecture is asynchronous. You have to trigger a workbook export, handle potential chunking for large datasets, and poll for the jobComplete status before finally fetching the data via a queryId. If you expose this raw flow to Claude, the model will frequently timeout or fail to understand the polling loop.

Connection Path Resolution Data sources in Sigma are not simple text strings. They require mapping connection IDs to specific schema or database paths using endpoints like sigma_computing_paths_look_up. If your AI agent needs to swap data sources in a workbook template, it must accurately map sourceMapping, metricMapping, and connectionMapping. Building the JSON schema context for this natively in a custom MCP server is incredibly error-prone.

Rate Limits and 429 Handling Sigma Computing enforces rate limits to protect its infrastructure. When an AI agent loops through dozens of workbooks to extract SQL queries, it can easily exhaust API quotas. Truto handles this gracefully by passing the 429 Too Many Requests error directly downstream to the caller, while normalizing the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. Truto does not retry, throttle, or apply backoff on rate limit errors - the caller is responsible for implementing appropriate retry logic based on these standardized headers.

How to Generate a Sigma Computing MCP Server with Truto

Truto dynamically generates MCP servers based on an integration's documentation and resource configuration. Rather than hardcoding tool definitions, Truto reads the API schemas and translates them into a JSON-RPC 2.0 endpoint that any MCP client can consume. You can create this server via the Truto UI or programmatically via the API.

Method 1: Generating via the Truto UI

For administrators setting up Claude Desktop for internal use, the UI is the fastest path:

1. Log into your Truto dashboard and navigate to the Integrated Accounts page.
2. Select your connected Sigma Computing account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., restrict to read methods only, or filter by specific tool tags).
6. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/abc123def456...).

Method 2: Generating via the Truto API

For engineering teams building multi-tenant AI products, you need to generate MCP servers programmatically. When you send a POST request to the MCP endpoint, Truto verifies the underlying integration, generates a secure token, and registers the server in edge storage for ultra-low latency routing.

Request:

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Sigma Computing Data Governance Agent",
    "config": {
      "methods": ["read", "write"],
      "require_api_token_auth": false
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

Response:

{
  "id": "mcp_srv_987654321",
  "name": "Sigma Computing Data Governance Agent",
  "config": {
    "methods": ["read", "write"]
  },
  "expires_at": "2026-12-31T23:59:59.000Z",
  "url": "https://api.truto.one/mcp/token_xyz789..."
}

This single URL is all your client needs. It cryptographically encodes the routing, authentication, and token metadata required to execute Sigma Computing API calls.

How to Connect the MCP Server to Claude

Once you have your Truto MCP URL, you can connect it to Claude in under a minute. The open MCP standard means Claude can immediately request the tools/list endpoint and begin understanding the Sigma Computing schemas.

Method A: Via the Claude UI (or ChatGPT UI)

If you are using the Claude web application (Enterprise/Team plans) or ChatGPT:

For Claude:

1. Open Claude and navigate to Settings -> Integrations -> Add MCP Server.
2. Paste your Truto MCP URL.
3. Click Add. Claude will automatically discover all available Sigma Computing tools.

For ChatGPT:

1. Open ChatGPT and go to Settings -> Apps -> Advanced settings.
2. Enable Developer mode.
3. Click Add new server under Custom connectors.
4. Name it "Sigma Computing" and paste the Truto MCP URL.
5. Save and connect.

Method B: Via Manual Config File (Claude Desktop)

For developers running Claude Desktop locally, you can configure the server via the claude_desktop_config.json file. Because Truto MCP servers use HTTP POST for JSON-RPC communication, you use the official Server-Sent Events (SSE) bridge provided by the MCP specification.

1. Open your configuration file. On macOS, this is located at ~/Library/Application Support/Claude/claude_desktop_config.json.
2. Add the Truto MCP server using the npx @modelcontextprotocol/server-sse command:

{
  "mcpServers": {
    "sigma-computing": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/token_xyz789..."
      ]
    }
  }
}

3. Restart Claude Desktop. You will see a plug icon indicating the Sigma Computing tools are loaded and ready to use.

Sigma Computing Hero Tools for Claude

Truto automatically generates tool definitions by deriving them from Sigma's API resources and injecting prompt-optimized JSON schemas. The flat input namespace handles both query parameters and JSON body payloads intelligently. Here are some of the highest-leverage operations you can expose to Claude.

List All Sigma Computing Members

Tool Name: list_all_sigma_computing_members

This tool retrieves the user directory, returning member IDs, email addresses, and status flags (like isInactive or isArchived). It is essential for mapping natural language names to the UUIDs required for subsequent RBAC operations.

"Audit our Sigma Computing directory and list all members who are currently marked as inactive or archived. Create a markdown table with their name, email, and memberId."

Create a Sigma Computing Workspace

Tool Name: create_a_sigma_computing_workspace

Workspaces are the top-level organizational unit in Sigma. This tool allows Claude to dynamically provision workspaces. You can enforce naming conventions and use the noDuplicates flag to prevent errors.

"Provision a new workspace called 'Q3 Financial Audits'. Ensure you use the flag to prevent duplicate names, and let me know the workspaceId once it is created."

Create a Sigma Computing Workspaces Grant

Tool Name: create_a_sigma_computing_workspaces_grant

Security and access control are paramount in BI. This tool assigns permissions to a workspace for specific users or teams. Claude takes the workspace ID and a grants array specifying the grantee type (Member or Team) and permission level.

"Grant the 'Data Engineering' team (teamId: 888) 'viewedit' access to the 'Q3 Financial Audits' workspace (workspaceId: 999)."

List SQL Queries from Workbooks

Tool Name: sigma_computing_workbooks_sql_queries

One of the most powerful tools for data engineers. It extracts the raw SQL backing the elements within a workbook. Claude can use this to review SQL for performance bottlenecks, syntax errors, or schema drift.

"Extract all SQL queries from the 'Revenue Dashboard' workbook (workbookId: 555). Analyze the queries for any missing indexes on the joined tables or inefficient wildcard SELECTs."

Schedule Workbook Exports

Tool Name: create_a_sigma_computing_workbook_export_schedule

Instead of manually running reports, Claude can configure periodic data exports to external targets. You must supply a cron specification, a timezone, and the target configuration.

"Set up a weekly export schedule for the 'Marketing Spend' workbook. Configure it to run every Monday at 9 AM EST, and include a message body notifying the team that the latest data is ready."

Manage Data Connections

Tool Name: create_a_sigma_computing_connection

This tool allows infrastructure teams to programmatically wire up Sigma to data warehouses like Snowflake or Redshift. It accepts detailed connection parameters, including user roles, timeout settings, pool sizes, and write access configurations.

"Create a new connection to our Snowflake staging environment. Set the type to 'snowflake', configure the pool size to 10, and disable writeAccess for safety."

If you want to view the complete list of available endpoints, parameter requirements, and schema definitions, check out the Sigma Computing integration page.

Workflows in Action

Exposing individual tools to Claude is useful, but the real power comes from chaining these tools into multi-step, agentic workflows. Here is how different personas can leverage Claude connected to Sigma Computing.

Scenario 1: Automated Onboarding and Workspace Provisioning (Data Admin)

When a new cross-functional team is formed, a Data Admin needs to provision a workspace, create a dedicated team, and ensure access rights are correctly assigned.

"We just formed a new 'Growth Marketing' pod. Please create a new Sigma Computing team called 'Growth Marketing', add member email 'sarah@company.com' to it, create a new workspace called 'Growth Analytics', and grant the team view/edit permissions to that workspace."

Execution Steps:

1. Claude calls list_all_sigma_computing_members to find the UUID for sarah@company.com.
2. Claude calls create_a_sigma_computing_team with the name "Growth Marketing" and includes Sarah's member ID.
3. Claude calls create_a_sigma_computing_workspace to provision "Growth Analytics" and captures the new workspace ID.
4. Claude calls create_a_sigma_computing_workspaces_grant mapping the new team ID to the new workspace ID with view/edit rights.

Result: The admin receives a confirmation that the team is built, the user is added, the workspace is live, and the RBAC is securely linked - all without navigating a single menu.

Scenario 2: BI Code Review and Performance Auditing (Data Engineer)

A Data Engineer needs to debug a slow-loading dashboard and ensure the underlying SQL is optimized before it is shared with the executive team.

"The 'Q4 Executive Summary' workbook is loading slowly. Can you extract the SQL queries backing it, analyze them for potential performance issues, and check if any embedded materialization schedules are currently paused?"

Execution Steps:

1. Claude calls sigma_computing_workbooks_sql_queries passing the workbook ID to pull the raw SQL strings for every element.
2. Claude analyzes the returned SQL text internally (using its standard context window) to identify slow subqueries or missing join conditions.
3. Claude calls list_all_sigma_computing_workbook_materializations to check the schedule status and verify if caching/materialization has been paused or has failed.

Result: The Data Engineer gets a summarized code review of the dashboard's SQL, pinpointing the exact query causing the slowdown, alongside the operational status of the workbook's materialization jobs.

Security and Access Control

When providing an LLM access to your primary BI platform, governance is critical. Truto's MCP servers provide four layers of security to restrict what AI agents can do:

• Method Filtering: You can restrict a server to read operations only. If an LLM attempts to call create_a_sigma_computing_team, the MCP server will reject it before it ever hits the proxy layer.
• Tag Filtering: Truto allows you to group tools by tags. You can generate an MCP server that only exposes resources tagged with workbooks and exports, entirely hiding user administration tools.
• API Token Authentication (require_api_token_auth): By default, the MCP URL acts as a bearer token. By enabling this flag, the client must also provide a valid Truto API token in the Authorization header, enforcing dual-layer authentication.
• Auto-Expiring Servers (expires_at): For temporary workflows or contractor access, you can set a TTL (Time-To-Live). Once the ISO datetime is reached, distributed alarms sweep the credentials, instantly revoking access with zero stale data left behind.

Instead of losing engineering cycles building rigid, single-purpose integrations, managed MCP servers dynamically adapt to your connected APIs. By standardizing authentication, cursor-based pagination, and schema mapping, Truto lets your team focus on building intelligent agent behaviors rather than maintaining API boilerplate. Connect Sigma Computing to Claude today, and turn your BI platform into a natural language operating system.