---
title: "Connect Looker to Claude: Orchestrate Dashboards via MCP"
slug: connect-looker-to-claude-orchestrate-dashboards-alerts-and-boards
date: 2026-06-09
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect Looker to Claude using a managed MCP server. Automate inline queries, dashboard generation, and scheduled BI alerts with AI agents."
tldr: "Connect Looker to Claude using a managed MCP server to orchestrate dashboards, run inline LookML queries, and manage BI alerts. Includes working examples, tool configurations, and AI agent workflows."
canonical: https://truto.one/blog/connect-looker-to-claude-orchestrate-dashboards-alerts-and-boards/
---

# Connect Looker to Claude: Orchestrate Dashboards via MCP


If you need to connect Looker to Claude to orchestrate dashboard creation, automate scheduled reporting, or query business intelligence data directly via chat, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's function calls and Looker's REST API. You can either [build and maintain this infrastructure yourself](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), or use a [managed integration platform like Truto](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) to dynamically generate a secure, authenticated MCP server URL. 

If your team uses ChatGPT, check out our guide on [connecting Looker to ChatGPT](https://truto.one/connect-looker-to-chatgpt-query-data-and-manage-bi-user-accounts/) or explore our broader architectural overview on [connecting Looker to AI Agents](https://truto.one/connect-looker-to-ai-agents-automate-lookml-schedules-and-reports/).

Giving a Large Language Model (LLM) read and write access to a sprawling enterprise BI tool like Looker is an engineering challenge. You have to handle session authentication, map massive LookML schemas to MCP tool definitions, and deal with Looker's unique asynchronous query execution models. Every time a new view is added to a model, your tools need to reflect that. 

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Looker, connect it natively to Claude, and execute complex data orchestration workflows using natural language.

## The Engineering Reality of the Looker 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 Looker's API requires dealing with significant domain specific quirks.

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

**The Asynchronous Query Execution Trap**
Unlike a standard CRUD API where a `GET` request immediately returns data, Looker queries can take minutes to execute depending on the underlying data warehouse. The Looker API frequently requires an asynchronous pattern: you create an async query task, receive a `query_task_id`, and then poll the API until the status is complete. Exposing this raw polling mechanism to Claude results in context window exhaustion and hallucinated task IDs. Truto handles the underlying schema translation to make query execution look like a synchronous tool call to the model.

**Complex Nested Visualization Configurations**
When you create or update a dashboard element in Looker, the `vis_config` payload is notoriously complex. It is effectively a loosely typed JSON blob that dictates chart types, axis labeling, and color palettes. LLMs struggle to generate this from scratch. A properly configured MCP server needs to provide highly specific JSON schemas for these nested objects, otherwise the Looker API will reject the payload with a generic 400 error.

**Strict Rate Limiting and Backoff Penalties**
Looker imposes strict rate limits, often capping API calls per minute or concurrent query limits depending on your Looker instance sizing. If your AI agent loops through hundreds of dashboards to summarize them, it will quickly hit a wall. *Note on Truto's architecture:* Truto does not retry, throttle, or apply backoff on rate limit errors. When Looker returns an HTTP `429 Too Many Requests`, Truto passes that error directly to Claude. However, Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. Your agent is responsible for interpreting this and pausing execution.

Instead of building schema translation and authentication from scratch, you can use Truto. Truto derives tool definitions directly from the integration's resource configurations and automatically exposes Looker's endpoints as [ready-to-use MCP tools](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/).

## How to Generate a Looker MCP Server with Truto

Truto creates MCP servers dynamically based on your connected Looker instance. The tools are not hard-coded; they are generated on the fly from the integration's documentation and schema records. 

You can generate the Looker MCP server using either the Truto UI or the API.

### Method 1: Via the Truto UI

1. Navigate to the **Integrated Accounts** page in your Truto dashboard and select your connected Looker instance.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Configure the server (e.g., set it to "Read Only" or apply specific tags).
5. Copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/a1b2c3d4...`).

### Method 2: Via the Truto API

If you are dynamically provisioning AI capabilities for your own end-users, you can create the server via an API call. The backend validates the configuration, stores a hashed token in a distributed key-value store, and returns a ready-to-use URL.

```bash
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": "Looker BI Agent",
    "config": {
      "methods": ["read", "write"],
      "require_api_token_auth": false
    }
  }'
```

Response:
```json
{
  "id": "mcp-123",
  "name": "Looker BI Agent",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}
```

This URL is fully self-contained. It encodes the specific Looker account, the allowed tools, and the authentication layer. 

## How to Connect the MCP Server to Claude

Once you have the Truto MCP URL, you need to register it with your Claude client. You can do this through the Claude user interface or by directly modifying the configuration file.

### Method A: Via the Claude UI

If you are using Claude's web interface or a similar UI supporting custom connectors:
1. Open **Settings** -> **Integrations** (or **Connectors**).
2. Click **Add MCP Server** or **Add custom connector**.
3. Paste the Truto MCP URL into the Server URL field.
4. Click **Add**. Claude will immediately issue an `initialize` request to discover the available Looker tools.

### Method B: Via Manual Configuration File (Claude Desktop)

If you are running Claude Desktop locally or configuring a headless agent environment, edit the `claude_desktop_config.json` file. Truto provides an SSE (Server-Sent Events) bridge to translate the HTTP-based MCP server into a standard IO stream.

```json
{
  "mcpServers": {
    "looker_truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f67890"
      ]
    }
  }
}
```

Restart Claude Desktop. The model will now have native access to Looker.

## Hero Tools for Looker

Truto exposes dozens of Looker API endpoints as tools. Here are the highest-leverage tools your AI agents can use to orchestrate BI workflows. 

*(Note: These are snake_case representations generated dynamically by Truto's tool generation engine).* 

### `looker_query_run_inline`
This is the most powerful tool for an LLM. It allows Claude to define a query on the fly using Looker's Model, View, and Fields paradigm, and return the results immediately without saving the query to the database.

> "Query the 'ecommerce' model, 'orders' view. Return the count of orders grouped by 'users.state'. Limit to the top 10 and return the results as JSON."

### `create_a_looker_dashboard`
Allows the model to scaffold a new dashboard. This is typically step one in an orchestration workflow before appending specific visualization elements or query results to the board.

> "Create a new Looker dashboard called 'Q3 Executive Summary' in folder ID 14. Add a description explaining this tracks quarterly revenue metrics."

### `create_a_looker_scheduled_plan`
Enables Claude to automate reporting by creating a cron-based schedule. The model can configure email delivery or webhook destinations for a specific Look or Dashboard.

> "Create a daily scheduled plan for Dashboard ID 42. Set it to run at 8:00 AM UTC and email the results to the finance-team@company.com alias."

### `looker_dashboards_search`
Essential for discovery. Claude uses this to locate existing dashboards by title, slug, or folder ID before attempting to modify them or extract data from them.

> "Search our Looker instance for any dashboards containing 'Customer Churn' in the title. Return their IDs and descriptions."

### `create_a_looker_alert`
Lets the model define threshold-based alerts on specific dashboard elements. This allows the AI to act as an active monitoring agent, setting up tripwires on key performance indicators.

> "Create an alert on dashboard element ID 105. Set the condition to trigger if the 'revenue' field drops below 5000, and send the notification to the marketing team."

### `list_all_looker_users`
Used for directory synchronization, security audits, and permission management. Returns detailed information about user roles, group memberships, and credentials.

> "List all Looker users who are currently active but have not logged in for the past 90 days. Extract their email addresses and role IDs."

For the complete inventory of available Looker tools, schemas, and required parameters, review the [Looker integration page](https://truto.one/integrations/detail/looker).

## Workflows in Action

Here is how an AI agent strings these tools together to execute multi-step Looker workflows.

### Scenario 1: Ad-Hoc Data Request to Dashboard Scaffolding
**The User Prompt:**
> "Pull the total revenue by product category from the 'sales' model for the last 30 days. If any category is over $100k, create a new dashboard called 'High Value Categories' and add those results to it."

**The Execution:**
1. Claude calls `looker_query_run_inline` passing the `model`, `view`, and `fields` array for revenue and category, with a date filter applied.
2. The model analyzes the JSON response in memory, identifying categories exceeding the $100k threshold.
3. Claude calls `create_a_looker_dashboard` specifying the title "High Value Categories".
4. Claude calls `create_a_looker_dashboard_element` to attach the query parameters as a persistent chart to the newly created dashboard ID.

**The Result:** The user gets a conversational summary of the data, plus a link to a brand new, fully functioning Looker dashboard built specifically for their request.

### Scenario 2: Automated KPI Monitoring Setup
**The User Prompt:**
> "Find the 'Daily Active Users' dashboard. Set up a daily email schedule for it at 9am, and also create a threshold alert if DAU drops below 10,000."

**The Execution:**
1. Claude calls `looker_dashboards_search` with `title: "Daily Active Users"` to retrieve the dashboard ID.
2. Claude calls `get_single_looker_dashboard_by_id` to inspect the dashboard's elements and find the specific element ID representing the DAU metric.
3. Claude calls `create_a_looker_scheduled_plan` using the dashboard ID, a crontab string (`0 9 * * *`), and the email destination configuration.
4. Claude calls `create_a_looker_alert` applying the `< 10000` threshold to the identified dashboard element ID.

**The Result:** The agent fully provisions enterprise reporting schedules and data quality alerts without the user having to click through Looker's complex admin UI.

## Security and Access Control

Giving an LLM access to your core business intelligence platform requires [strict guardrails](https://truto.one/zero-data-retention-mcp-servers-building-soc-2-gdpr-compliant-ai-agents/). Truto provides several mechanisms to lock down the MCP server at the configuration level:

*   **Method Filtering:** By passing `methods: ["read"]` during server creation, you completely disable `create`, `update`, and `delete` operations. The LLM can run queries and read dashboards, but cannot alter the Looker environment.
*   **Tag Filtering:** You can restrict the server to specific functional areas using tags. For example, `tags: ["dashboards"]` ensures the LLM can only interact with dashboard resources, preventing it from touching user permissions or integration hub settings.
*   **Extra Authentication (`require_api_token_auth`):** If enabled, possessing the MCP URL is not enough. The client must also send a valid Truto API token via a Bearer header. This secures the endpoint even if the URL leaks in logs.
*   **Expiration (`expires_at`):** You can set an exact ISO datetime for the server to self-destruct. This is ideal for granting a contractor or temporary AI agent time-boxed access to Looker. The cleanup is handled automatically by backend alarms.

## Orchestrating BI with AI

Building an MCP server for Looker from scratch means spending weeks mapping `vis_config` schemas, handling polling loops for async queries, and managing OAuth lifecycles. By using a documentation-driven tool generator like Truto, you strip away the boilerplate.

You simply connect the account, generate the token, and let the LLM handle the logic. 

> Stop building custom integrations. Connect Looker, Snowflake, Salesforce, and 100+ other SaaS platforms to your AI agents in minutes with Truto.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)