Skip to content
Back to search

redash-mcp

Model Context Protocol (MCP) server for integrating Redash with AI assistants like Claude.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/suthio/redash-mcp with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/suthio/redash-mcp'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/suthio--redash-mcp/badge.svg)](/listings/suthio--redash-mcp)

HTML

<a href="/listings/suthio--redash-mcp"><img src="/api/listings/suthio--redash-mcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

1. Clone this repository:

   git clone https://github.com/suthio/redash-mcp.git
   cd redash-mcp

2. Enable Corepack and install dependencies:

   corepack enable
   pnpm install

3. Create a `.env` file with your Redash configuration:

   REDASH_URL=https://your-redash-instance.com
   REDASH_API_KEY=your_api_key
   # Optional: Cloudflare Access (or other gateway) headers
   # REDASH_EXTRA_HEADERS='{"CF-Access-Client-Id":"<client_id>","CF-Access-Client-Secret":"<client_secret>"}'

4. Build the project:

   pnpm run build

5. Start the server:

   pnpm start

The default transport is stdio, which is the mode expected by most desktop MCP clients. The stdio entrypoint accepts both 2025-era MCP clients and clients that negotiate the current protocol.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 444 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Redash MCP Server
  2. Model Context Protocol (MCP) server for integrating Redash with AI assistants like Claude.
  3. <a href="https://glama.ai/mcp/servers/j9bl90s3tw">
  4. <img width="380" height="200" src="https://glama.ai/mcp/servers/j9bl90s3tw/badge" alt="Redash Server MCP server" />
  5. </a>
  6. ## Features
  7. - Connect to Redash instances via the Redash API
  8. - List available queries and dashboards as resources
  9. - Execute queries and retrieve results
  10. - Execute saved parameterized queries with typed values and saved defaults
  11. - Create and manage queries (create, update, archive)
  12. - Manage query parameters, dashboard parameters, and widget parameter mappings
  13. - Inspect and update dashboard widget layouts and grid positions
  14. - List data sources for query creation
  15. - Get dashboard details and visualizations
  16. - Update chart visualization options with Redash chart-specific settings
  17. ## Prerequisites
  18. - Node.js (v22.13 or later)
  19. - Corepack (included with Node.js 22; it selects the pnpm version pinned in `package.json`)
  20. - Access to a Redash instance
  21. - Redash API key
  22. ## Environment Variables
  23. The server requires the following environment variables:
  24. - `REDASH_URL`: Your Redash instance URL (e.g., https://redash.example.com)
  25. - `REDASH_API_KEY`: Your Redash API key
  26. Optional variables:
  27. - `REDASH_TIMEOUT`: Timeout for API requests in milliseconds (default: 30000)
  28. - `REDASH_MAX_RESULTS`: Maximum number of results to return (default: 1000)
  29. - `REDASH_EXTRA_HEADERS`: Extra HTTP headers to include with every Redash request. Accepts either a JSON object string or a semicolon/comma-separated list of `key=value` pairs.
  30. - `REDASH_SOCKS_PROXY`: SOCKS proxy URL for routing requests through a proxy (e.g., `socks5h://localhost:1080`). Use `socks5h://` (with `h`) to delegate DNS resolution to the proxy, which is required for internal hostnames that don't resolve on the local machine.
  31. - `MCP_TRANSPORT`: MCP transport to use. Supported values are `stdio`, `http`, and `streamable-http` (default: `stdio`).
  32. - `MCP_HTTP_HOST`: Host for Streamable HTTP mode (default: `127.0.0.1`).
  33. - `MCP_HTTP_PORT`: Port for Streamable HTTP mode (default: `3000`).
  34. - `MCP_HTTP_PATH`: Streamable HTTP endpoint path (default: `/mcp`).
  35. - `MCP_HTTP_ALLOWED_HOSTS`: Comma-separated Host header allowlist for Streamable HTTP mode. Values are hostnames without a scheme, port, path, or wildcard.
  36. - `MCP_HTTP_ALLOWED_ORIGINS`: Comma-separated browser Origin hostname allowlist. Values use the same hostname-only format and also control CORS responses. Set an empty value to reject every request that includes an `Origin` header.
  37. - OpenTelemetry variables: optional; see [OpenTelemetry observability](#opentelemetry-observability) for concrete OTLP and Prometheus configurations.
  38. Examples:
  39. JSON (recommended):
  40. ```
  41. REDASH_EXTRA_HEADERS='{"CF-Access-Client-Id":"<client_id>","CF-Access-Client-Secret":"<client_secret>"}'
  42. ```
  43. Key/value list:
  44. ```
  45. REDASH_EXTRA_HEADERS=CF-Access-Client-Id=<client_id>;CF-Access-Client-Secret=<client_secret>
  46. ```
  47. Notes:
  48. - The `Authorization` header is managed by the server (`Key <REDASH_API_KEY>`) and cannot be overridden.
  49. - All extra headers are added to every request made to Redash.
  50. ## Installation
  51. 1. Clone this repository:
  52. ```bash
  53. git clone https://github.com/suthio/redash-mcp.git
  54. cd redash-mcp
  55. ```
  56. 2. Enable Corepack and install dependencies:
  57. ```bash
  58. corepack enable
  59. pnpm install
  60. ```
  61. 3. Create a `.env` file with your Redash configuration:
  62. ```
  63. REDASH_URL=https://your-redash-instance.com
  64. REDASH_API_KEY=your_api_key
  65. # Optional: Cloudflare Access (or other gateway) headers
  66. # REDASH_EXTRA_HEADERS='{"CF-Access-Client-Id":"<client_id>","CF-Access-Client-Secret":"<client_secret>"}'
  67. ```
  68. 4. Build the project:
  69. ```bash
  70. pnpm run build
  71. ```
  72. 5. Start the server:
  73. ```bash
  74. pnpm start
  75. ```
  76. The default transport is stdio, which is the mode expected by most desktop MCP clients. The stdio entrypoint accepts both 2025-era MCP clients and clients that negotiate the current protocol.
  77. ## Usage with Claude for Desktop
  78. To use this MCP server with Claude for Desktop, configure it in your Claude for Desktop configuration file:
  79. **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
  80. **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
  81. Add the following configuration (edit paths as needed):
  82. ```json
  83. {
  84. "mcpServers": {
  85. "redash": {
  86. "command": "npx",
  87. "args": [
  88. "-y",
  89. "@suthio/redash-mcp"
  90. ],
  91. "env": {
  92. "REDASH_API_KEY": "your-api-key",
  93. "REDASH_URL": "https://your-redash-instance.com"
  94. }
  95. }
  96. }
  97. }
  98. ```
  99. ## Streamable HTTP Transport
  100. The server can also run as a stateless Streamable HTTP MCP server. The HTTP entrypoint is a Hono application served by `@hono/node-server`; environment variables configure the listener:
  101. ```bash
  102. REDASH_URL=https://your-redash-instance.com \
  103. MCP_TRANSPORT=http \
  104. pnpm start
  105. ```
  106. This starts `POST http://127.0.0.1:3000/mcp` by default. CLI flags override environment variables:
  107. ```bash
  108. REDASH_URL=https://your-redash-instance.com \
  109. pnpm start --transport http --host 127.0.0.1 --port 3333 --path /mcp
  110. ```
  111. Note: `REDASH_API_KEY` is not needed here - in HTTP mode each MCP client request supplies its own Redash token via its `Authorization` header (see below). You can still set `REDASH_API_KEY` as a fallback for requests that don't send one.
  112. For a non-local bind behind an authenticated, TLS-terminating reverse proxy, explicitly configure which request hosts and browser origins may reach the server. The equivalent CLI options are `--allowed-hosts` and `--allowed-origins`.
  113. ```bash
  114. REDASH_URL=https://redash.example.com \
  115. REDASH_API_KEY=your_api_key \
  116. MCP_TRANSPORT=http \
  117. MCP_HTTP_HOST=0.0.0.0 \
  118. MCP_HTTP_ALLOWED_HOSTS=mcp.example.com \
  119. MCP_HTTP_ALLOWED_ORIGINS=app.example.com \
  120. pnpm start
  121. ```
  122. | Who uses the server | MCP URL | Allowed Host header | Allowed browser Origin |
  123. | --- | --- | --- | --- |
  124. | Local MCP client | `http://127.0.0.1:3000/mcp` | `127.0.0.1` | `localhost`, `127.0.0.1`, `[::1]` |
  125. | Local Docker client | `http://localhost:3000/mcp` | `localhost` | `localhost`, `127.0.0.1`, `[::1]` |
  126. | Browser app at `https://app.example.com` through an authenticated reverse proxy | `https://mcp.example.com/mcp` | `mcp.example.com` | `app.example.com` |
  127. Host and Origin matching is case-insensitive and port-agnostic. For example, allowing `app.example.com` accepts the browser Origin `https://app.example.com:8443`. In HTTP mode, binding `MCP_HTTP_HOST` to a non-local address fails at startup unless both allowlist settings are explicitly present.
  128. Host and Origin allowlists protect against DNS rebinding and unwanted browser origins; they do not authenticate MCP clients. Do not expose the server listener directly to the internet. For `https://mcp.example.com/mcp`, keep the listener on a private network and require authentication at the reverse proxy or gateway.
  129. HTTP mode is stateless: the server does not issue `Mcp-Session-Id`, does not provide a standalone GET SSE stream, and handles each `POST /mcp` with a fresh MCP server instance. Both current MCP clients and 2025-era Streamable HTTP clients use that same URL. `GET /mcp` and `DELETE /mcp` return `405 Method Not Allowed`.
  130. The default bind is localhost-only (`127.0.0.1`) with Host and Origin protection. Browser requests from allowed origins receive CORS response headers; other origins are rejected with `403 Forbidden`.
  131. `GET http://127.0.0.1:3000/healthz` returns `200 OK` with the body `ok` for lightweight health checks. It uses the same Host and Origin allowlists as the MCP endpoint and does not contact Redash. If `MCP_HTTP_PATH=/healthz`, that URL remains the MCP endpoint and the standalone health check is disabled with a startup warning.
  132. The CLI handles `SIGINT` and `SIGTERM` gracefully. For example, `docker stop` sends `SIGTERM`; the server closes active MCP streams and then waits for the HTTP listener to stop before the process exits.
  133. ## OpenTelemetry observability
  134. Operators use this integration to follow one MCP operation from the client, through this server, to Redash, and to alert on latency or process health. The CLI initializes OpenTelemetry automatically. With no exporter endpoint or exporter setting, it opens no telemetry network connection; application logs still go to stderr so stdio stdout remains reserved for MCP messages.
  135. Choose the setup that matches the system reading the telemetry:
  136. | Who reads it | Set these variables | Where data is available |
  137. | --- | --- | --- |
  138. | An OpenTelemetry Collector receiving all three signals | `OTEL_EXPORTER_OTLP_ENDPOINT=http://127.0.0.1:4318` | Traces, metrics, and logs at the Collector OTLP/HTTP receiver |
  139. | Prometheus scraping an HTTP-mode server | `OTEL_METRICS_EXPORTER=prometheus` | `GET http://127.0.0.1:3000/metrics` |
  140. | Prometheus scraping a stdio server | `OTEL_METRICS_EXPORTER=prometheus`, `OTEL_EXPORTER_PROMETHEUS_HOST=127.0.0.1`, `OTEL_EXPORTER_PROMETHEUS_PORT=9464` | `GET http://127.0.0.1:9464/metrics` |
  141. | A Collector plus Prometheus | `OTEL_EXPORTER_OTLP_ENDPOINT=http://127.0.0.1:4318`, `OTEL_METRICS_EXPORTER=otlp,prometheus` | OTLP metrics and the Prometheus endpoint |
  142. For example, this HTTP-mode command exports all signals over OTLP/HTTP and also lets Prometheus scrape the same listener:
  143. ```bash
  144. REDASH_URL=https://redash.example.com \
  145. REDASH_API_KEY=your_api_key \
  146. MCP_TRANSPORT=http \
  147. OTEL_EXPORTER_OTLP_ENDPOINT=http://127.0.0.1:4318 \
  148. OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf \
  149. OTEL_METRICS_EXPORTER=otlp,prometheus \
  150. pnpm start
  151. curl http://127.0.0.1:3000/metrics
  152. ```
  153. The server emits these signals:
  154. | Signal | Representative data | What it answers |
  155. | --- | --- | --- |
  156. | Traces | inbound `POST /mcp`, MCP `tools/call list_queries`, outbound Redash `GET /api/queries` | Which MCP or Redash operation was slow or failed? |
  157. | Metrics | `mcp.server.operation.duration`, `mcp.server.session.duration`, `nodejs.eventloop.*`, `v8js.*`, `process.*`, `system.*`, HTTP client/server duration | Is latency, event-loop delay, memory, CPU, or network use changing? |
  158. | Logs | structured severity, fields, exception, and active `trace_id`/`span_id` | What happened inside the operation shown by a trace? |
  159. The names and attributes visible in a trace backend are deliberately stable:
  160. | What the MCP client does | Span name | Attributes used to filter it |
  161. | --- | --- | --- |
  162. | Calls `list_queries` | `tools/call list_queries` | `mcp.method.name=tools/call`, `gen_ai.operation.name=execute_tool`, `gen_ai.tool.name=list_queries` |
  163. | Reads `redash://query/42` | `resources/read` | `mcp.resource.uri=redash://query/42`; the URI is kept out of the span name to avoid one span group per resource |
  164. | Sends JSON-RPC error code `-32601` | The MCP method name | `rpc.response.status_code=-32601`, `error.type=-32601`, and span status `ERROR` |
  165. | Posts to a custom endpoint `/redash-mcp` | `POST /redash-mcp` | `http.route=/redash-mcp` |
  166. `mcp.protocol.version` records the negotiated revision in both stdio and stateless HTTP operations. `mcp.server.session.duration` applies to the long-lived stdio connection; HTTP mode is stateless, so its useful lifecycle measurement is `mcp.server.operation.duration`. Both histograms use the MCP-recommended explicit latency buckets.
  167. SEP-414 `traceparent`, `tracestate`, and `baggage` values in MCP request `_meta` are accepted. The extracted MCP client context becomes the MCP server span's parent, while the HTTP transport span is linked to it. Logs emitted while the tool runs carry the MCP span's `trace_id` and `span_id`.
  168. Application log messages always go to stderr. When OTel Logs is configured, the same message is exported with its structured fields; those fields are not printed to stderr. A compatible stdio MCP client also receives the message through `notifications/message` for backward compatibility. Stateless HTTP does not send those notifications because each POST uses a fresh server instance; use OTel Logs or stderr there.
  169. ### Exporter settings
  170. The OTLP exporters support gRPC, HTTP/protobuf, and HTTP/JSON:
  171. | Protocol | Variable value | Typical Collector endpoint |
  172. | --- | --- | --- |
  173. | OTLP/gRPC | `grpc` | `http://127.0.0.1:4317` |
  174. | OTLP/HTTP protobuf | `http/protobuf` | `http://127.0.0.1:4318` |
  175. | OTLP/HTTP JSON | `http/json` | `http://127.0.0.1:4318` |
  176. Set the shared `OTEL_EXPORTER_OTLP_PROTOCOL`, or override it with `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL`, `OTEL_EXPORTER_OTLP_METRICS_PROTOCOL`, and `OTEL_EXPORTER_OTLP_LOGS_PROTOCOL`. The corresponding standard endpoint, header, certificate, compression, and timeout variables are passed to the OpenTelemetry exporters.
  177. An endpoint enables its signal. You can make the decision explicit with `OTEL_TRACES_EXPORTER=otlp`, `OTEL_METRICS_EXPORTER=otlp`, and `OTEL_LOGS_EXPORTER=otlp`, or disable one with `none`. For example, this keeps logs on stderr while sending traces and metrics:
  178. ```bash
  179. OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector.internal:4318
  180. OTEL_TRACES_EXPORTER=otlp
  181. OTEL_METRICS_EXPORTER=otlp
  182. OTEL_LOGS_EXPORTER=none
  183. ```
  184. `OTEL_SDK_DISABLED=true` disables every telemetry signal. Invalid telemetry settings or an unavailable exporter produce a warning on stderr but do not stop MCP or Redash requests. Application configuration errors such as a missing `REDASH_API_KEY` still fail startup.
  185. ### Prometheus endpoint and content safety
  186. In HTTP mode, the embedded `/metrics` route uses the same Host allowlist as `/mcp`. If `MCP_HTTP_PATH=/metrics`, the server keeps that URL for MCP, traces it as `POST /metrics`, and disables the embedded Prometheus route with a warning. Set `OTEL_EXPORTER_PROMETHEUS_HOST` or `OTEL_EXPORTER_PROMETHEUS_PORT` to use a separate listener instead. A separate listener is not protected by the MCP Host/Origin checks, so bind it to `127.0.0.1` or protect it at the network layer.
  187. Safe operation metadata is always available. Content that may contain Redash data requires an explicit opt-in:
  188. | Data | Default | With `OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=true` |
  189. | --- | --- | --- |
  190. | Tool name, query/data-source IDs, HTTP method/path/status, request header names | Recorded on the applicable span or OTel Log | Same |
  191. | Successful tool arguments and results, including SQL, description, options, visualizations, result rows, and CSV text | Omitted | Recorded once on the MCP `tools/call` span as `gen_ai.tool.call.arguments` and `gen_ai.tool.call.result` |
  192. | Failed Redash request/response bodies and query job errors | Omitted | Recorded as structured OTel Log fields; stderr and the MCP error response remain content-free |
  193. | API keys and request header values | Never recorded | Never recorded |
  194. The option uses the GenAI instrumentation name because the OpenTelemetry MCP conventions model a tool call as a GenAI-compatible `execute_tool` operation. The Redash server does not perform model inference; it reuses the common `gen_ai.tool.call.*` attributes so an MCP call can be correlated with the agent that invoked it. Enable the option only when the trace and log backends are approved to retain Redash content.
  195. ### Embedding the server in another Node.js process
  196. Initialize telemetry before importing the main package so Node HTTP and Axios are patched before Redash requests begin:
  197. ```ts
  198. import {
  199. initializeTelemetry,
  200. shutdownTelemetry,
  201. } from "@suthio/redash-mcp/telemetry";
  202. await initializeTelemetry({ transport: "stdio" });
  203. const { createRedashMcpServer } = await import("@suthio/redash-mcp");
  204. const server = createRedashMcpServer();
  205. // Connect and use the server, then flush exporters during application shutdown.
  206. await server.close();
  207. await shutdownTelemetry();
  208. ```
  209. When the embedding process exposes MCP over HTTP at `POST /redash-mcp`, pass that exact route during telemetry initialization and identify the application protocol when creating the server:
  210. ```ts
  211. import {
  212. initializeTelemetry,
  213. shutdownTelemetry,
  214. } from "@suthio/redash-mcp/telemetry";
  215. await initializeTelemetry({ transport: "http", httpPath: "/redash-mcp" });
  216. const { createRedashMcpServer } = await import("@suthio/redash-mcp");
  217. const server = createRedashMcpServer({
  218. networkTransport: "tcp",
  219. networkProtocolName: "http",
  220. recordSession: false,
  221. });
  222. // Connect `server` to the embedding process's POST /redash-mcp transport.
  223. await server.close();
  224. await shutdownTelemetry();
  225. ```
  226. ### Per-request authentication (multi-user HTTP deployments)
  227. Redash's REST API is stateless and already carries its own auth on every call, so a single HTTP MCP process can safely be shared by many users - there is no need to run one process per user.
  228. In HTTP transport mode, the server reads the Redash API token from **each incoming MCP request's own `Authorization` header** instead of the process-wide `REDASH_API_KEY` environment variable. This lets every user authenticate with their own personal Redash access token while `REDASH_URL` (and the process itself) stays shared and static:
  229. ```bash
  230. # Client sends its own personal Redash token per request, e.g.:
  231. # Authorization: Bearer <personal-redash-token>
  232. # or
  233. # Authorization: Key <personal-redash-token>
  234. ```
  235. Both `Bearer <token>` and `Key <token>` prefixes are accepted (the raw token is extracted either way); a bare token with no prefix also works. The token is then forwarded to Redash using Redash's own `Key <token>` scheme, regardless of how the client sent it.
  236. If a request has no `Authorization` header, the server falls back to the static `REDASH_API_KEY` environment variable if one is set. If neither is available, the request fails with a clear error instead of silently using someone else's token.
  237. This is why `REDASH_API_KEY` is optional (not required) when `MCP_TRANSPORT=http`. In stdio mode `REDASH_API_KEY` remains required exactly as before - stdio has no per-request headers, so nothing changes for existing stdio users.
  238. A typical deployment behind nginx: one HTTP MCP process per Redash instance (e.g. one per environment, such as staging and production), with nginx handling TLS/path routing, and each user's MCP client configured to send their own personal Redash token as the `Authorization` header.
  239. ## Docker
  240. Container images are published to GitHub Container Registry for both `linux/amd64` and `linux/arm64`.
  241. ```bash
  242. docker run --rm -p 127.0.0.1:3000:3000 \
  243. -e REDASH_URL=https://your-redash-instance.com \
  244. -e REDASH_API_KEY=your_api_key \
  245. ghcr.io/suthio/redash-mcp:latest
  246. ```
  247. The container runs Streamable HTTP internally on `0.0.0.0:3000`, while the example publishes that port on the host's loopback interface only. Its default Host and Origin allowlists accept localhost access. When placing the container behind an authenticated reverse proxy or a private cluster service, set `MCP_HTTP_ALLOWED_HOSTS` and `MCP_HTTP_ALLOWED_ORIGINS` to the concrete DNS names used by clients.
  248. Published images are signed with keyless cosign.
  249. ## Available Tools
  250. ### Query Management
  251. - `list_queries`: List all available queries in Redash
  252. - `get_query`: Get details of a specific query
  253. - `create_query`: Create a new query in Redash
  254. - `update_query`: Update an existing query in Redash
  255. - `get_query_parameters`: Inspect saved query parameter definitions
  256. - `update_query_parameters`: Update saved query parameter definitions
  257. - `archive_query`: Archive (soft-delete) a query
  258. - `list_data_sources`: List all available data sources
  259. ### Query Execution
  260. - `execute_query`: Execute a query and return results, with optional `maxAge`
  261. - `execute_parameterized_query`: Execute a saved parameterized query with type-aware value coercion, saved defaults, and optional `maxAge`
  262. - `execute_adhoc_query`: Execute an ad-hoc query without saving it to Redash
  263. - `get_query_results_csv`: Get query results in CSV format (supports optional refresh for latest data)
  264. ### Schema Discovery
  265. - `get_schema`: Get the schema of a data source, paginated by table
  266. Use `get_schema` when an MCP client needs table and column names for writing a
  267. query. A caller can request a small page, inspect `hasMore`, and follow `nextPage`
  268. without loading the entire warehouse schema into this MCP server. For BigQuery,
  269. a configured location also allows the server to fetch only the requested tables.
  270. | Data source | How one page is read | Why |
  271. | --- | --- | --- |
  272. | BigQuery (`bigquery` and `bigquery_gce`) | Read the connection's configured `location` from `/api/data_sources/{dataSourceId}`, then query that region's `INFORMATION_SCHEMA` for only the requested tables. If the API does not expose a valid location or the metadata query fails, stream the schema endpoint instead. | A configured location lets Redash avoid materializing its complete cached schema for very large BigQuery projects. The fallback keeps `get_schema` usable for API keys that cannot read connection options. |
  273. | Query Results (`results`) | Static schema discovery is unavailable. Use `execute_adhoc_query` with tables such as `query_123` or `cached_query_123`. | Query Results creates its SQLite tables dynamically from saved query results, so there is no fixed table or column list for `get_schema` to return. |
  274. | Other schema-capable data sources | Stream `/api/data_sources/{dataSourceId}/schema`, parse tables incrementally, and stop the HTTP transfer after the requested page plus one table. | The MCP server retains only the requested page instead of the complete Redash response. |
  275. Parameters: `dataSourceId` (required), `page` (default 1), `pageSize` (default 25,
  276. max 100), and `search` (optional case-insensitive substring match on table names;
  277. pagination applies to the filtered set). The response includes `hasMore` and
  278. `nextPage` for iterating through large schemas.
  279. For example, to inspect tables in a BigQuery dataset named `analytics_public`
  280. on data source `7`, call `get_schema` with
  281. `{"dataSourceId":7,"pageSize":10,"search":"analytics_public."}`. `pageSize`
  282. limits the number of tables in one response; it does not split the columns or
  283. nested field paths within a table. A wide table such as a GA4 event export is
  284. therefore returned with all of its field paths even when `pageSize` is `1`.
  285. ### Dashboard Management
  286. - `list_dashboards`: List all available dashboards
  287. - `get_dashboard`: Get dashboard details and visualizations
  288. - `get_dashboard_layout`: Inspect widget positions, sizes, and visibility on a dashboard
  289. - `get_visualization`: Get details of a specific visualization
  290. - `get_dashboard_parameters`: Inspect dashboard parameter values and widget mappings
  291. - `update_dashboard_parameters`: Update dashboard parameter values and order
  292. - `update_dashboard_layout`: Move or resize multiple widgets in one call
  293. - `update_widget_layout`: Move or resize a single widget
  294. - `get_widget_parameter_mappings`: Inspect a widget's parameter mappings
  295. - `update_widget_parameter_mappings`: Update a widget's parameter mappings
  296. ### Visualization Management
  297. - `create_visualization`: Create a new visualization for a query
  298. - `update_visualization`: Update an existing visualization
  299. - `update_chart_visualization`: Patch chart-specific options like `globalSeriesType`, `columnMapping`, `seriesOptions`, `legend`, and axis settings
  300. - `delete_visualization`: Delete a visualization
  301. ## Development
  302. Run in development mode:
  303. ```bash
  304. pnpm run dev
  305. ```
  306. ## Testing
  307. ### Unit Tests
  308. ```bash
  309. pnpm test
  310. ```
  311. ### E2E Tests
  312. ```bash
  313. pnpm run e2e:test
  314. ```
  315. E2E tests use these default values (can be overridden with environment variables):
  316. - `REDASH_URL`: https://demo.redash.io
  317. - `REDASH_API_KEY`: test_api_key
  318. Override example:
  319. ```bash
  320. REDASH_URL=https://your-instance.com REDASH_API_KEY=your_key pnpm run e2e:test
  321. ```
  322. ### Manual Testing
  323. ```bash
  324. pnpm run inspector
  325. ```
  326. ## Version History
  327. - v1.1.0: Added query management functionality (create, update, archive)
  328. - v1.0.0: Initial release
  329. ## Maintainers
  330. - [@suthio](https://github.com/suthio)
  331. - [@kahirokunn](https://github.com/kahirokunn)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.