# io.github.biztory/biztory-tableau-knowledge-mcp (pypi · biztory-tableau-knowledge-mcp)

Search, explore and enrich the Tableau Knowledge graph, and port it to Apache Ossie (OSI).

- Trust score: 82/100 (high trust)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- pypi · `biztory-tableau-knowledge-mcp`: 82/100 (this document), [markdown](https://verifymcp.io/servers/biztory-biztory-tableau-knowledge-mcp/biztory-tableau-knowledge-mcp.md), [page](https://verifymcp.io/servers/biztory-biztory-tableau-knowledge-mcp/biztory-tableau-knowledge-mcp)

## Channel facts

- Registry: `pypi`
- Package: `biztory-tableau-knowledge-mcp`
- Version: `0.4.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs hatchling.build at install time, a recognised build step with no custom scripting around it.
  - 0 of 29 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to biztory/biztory-tableau-knowledge-mcp).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 0 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 73/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 4114 tokens (~178/item across 23 items; 23 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 20/100
  - Stability observed for 6 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 71/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 24 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the io.github.biztory/biztory-tableau-knowledge-mcp server?

io.github.biztory/biztory-tableau-knowledge-mcp runs locally as a PyPI package, launched with uvx biztory-tableau-knowledge-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add biztory-biztory-tableau-knowledge-mcp -- uvx biztory-tableau-knowledge-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "biztory-biztory-tableau-knowledge-mcp": {
      "command": "uvx",
      "args": [
        "biztory-tableau-knowledge-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "biztory-biztory-tableau-knowledge-mcp": {
      "command": "uvx",
      "args": [
        "biztory-tableau-knowledge-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add biztory-biztory-tableau-knowledge-mcp -- uvx biztory-tableau-knowledge-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "biztory-biztory-tableau-knowledge-mcp": {
      "type": "local",
      "command": [
        "uvx",
        "biztory-tableau-knowledge-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add biztory-biztory-tableau-knowledge-mcp --command uvx --arg biztory-tableau-knowledge-mcp
```

### Hermes

```yaml
mcp_servers:
  biztory-biztory-tableau-knowledge-mcp:
    command: "uvx"
    args: ["biztory-tableau-knowledge-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "biztory-biztory-tableau-knowledge-mcp": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "biztory-tableau-knowledge-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add biztory-biztory-tableau-knowledge-mcp -t stdio -c uvx -a biztory-tableau-knowledge-mcp
```

### Other

```json
{
  "mcpServers": {
    "biztory-biztory-tableau-knowledge-mcp": {
      "command": "uvx",
      "args": [
        "biztory-tableau-knowledge-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-05 (score 82, +1)

No change was recorded against any check on this day. Stability & Change Management went from 17 to 20. That category is still filling its 30-day observation window: 5 days of observed history at the previous scan, 6 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-04 (score 81, +2)

- [security regression] Tool safety: pass → unverified
- [security] Stability: Stability not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet.
- [functional regression] Schema quality: 3070 → 4114
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional improvement] Stability: unverified → 0.17
- [functional] Package version: 0.3.0 → 0.4.0

### 2026-10-30 (score 79)

First indexed and scored.

## MCP tools (23)

### `server_info` (~84 tokens)

Connection and graphs

Report the connected Tableau site and its knowledge graphs: server URL, site, product
version, auth method, whether Tableau Knowledge is available, and every graph (id, name,
status, is_primary). Good first call: it confirms the connection and gives the graph ids the
other tools accept as `graph_id` (omit `graph_id` to use the primary graph).

### `search_nodes` (~245 tokens)

Search graph nodes

Find graph nodes by MEANING (semantic search), not exact name: "revenue" can match a
field named "Net Sales". Returns ranked matches with a 0-1 `score`; when a semantic statement
matched, it is shown under the node's `semantic_statements`.

\- `node_type` narrows to one type: PDS (published data source), WORKBOOK, SHEET, DASHBOARD,
  EMBEDDED_DATASOURCE, TABLE, FIELD, WAREHOUSE_TABLE, WAREHOUSE_COLUMN, CONNECTION, SCHEMA,
  SITE, SEMANTIC_CONTEXT, SEMANTIC_CONTEXT_EXTERNAL.
\- `scope_id` limits the search to one data source's subtree (a PDS node id plus its tables
  and fields).
\- `limit` 1-100 (default 10); `threshold` drops matches scoring below it (0-1).

Use the returned `id`s with get_node, list_edges, lineage and impact_analysis.

Input parameters:

- `graph_id`
- `limit` (integer)
- `node_type`
- `query` (string, required)
- `scope_id`
- `threshold`

### `get_node` (~116 tokens)

Get node

Get one node with its properties, its semantic statements (the business context attached
to it), and the child nodes it points to (`connected_nodes`, each with the edge type).

\`node` is a node id, or a plain-language description that is resolved by semantic search
(the response then includes `resolution` with the match score and alternatives). Set
\`include_children` false to skip `connected_nodes` on large containers.

Input parameters:

- `graph_id`
- `include_children` (boolean)
- `node` (string, required)

### `list_edges` (~139 tokens)

List edges

List the edges around one node, each with its `direction` (outgoing/incoming) and the node
on the other end. One hop only; use lineage for the wider neighborhood.

\`node` is a node id or a plain-language description. `edge_type` narrows to one of: CONTAINS,
HAS, JOINS, DEPENDS_ON, LINEAGE, SEMANTIC_EQUIV, DESCRIBES. `direction` is "outgoing" or
"incoming"; omit for both.

Input parameters:

- `direction`
- `edge_type`
- `graph_id`
- `node` (string, required)

### `lineage` (~185 tokens)

Lineage

The lineage neighborhood of a node: every node reachable within 10 steps, upstream AND
downstream, along lineage/dependency edges (LINEAGE, DEPENDS_ON), e.g. a data source and
the workbooks built on it. Answers "where does this come from?" and "what uses it?".

Containment (a table HAS a field, a workbook CONTAINS a sheet) is not followed, so a single
field often returns only itself; use list_edges or get_node to see what contains it.

\`node` is a node id or a plain-language description. Returns the anchor node, `nodes`,
\`edges` (source_id -> target_id, with type), and counts by node and edge type. For "what
breaks if this changes?", impact_analysis is more direct.

Input parameters:

- `graph_id`
- `node` (string, required)

### `impact_analysis` (~112 tokens)

Impact analysis

What breaks if this changes: every asset that depends on the node, directly OR transitively
(up to 10 steps, following DEPENDS_ON), e.g. the calcs, sheets, dashboards and workbooks
downstream of a column. The node itself is not included.

\`node` is a node id or a plain-language description. Returns `total`, `counts_by_type`, and
\`affected_assets` sorted by type then name.

Input parameters:

- `graph_id`
- `node` (string, required)

### `list_sources` (~141 tokens)

List sources

List the published data sources and workbooks connected to the knowledge graph, i.e. what
the graph has been built from. `node_type` "PDS" or "WORKBOOK" narrows it; omit for both.
\`ingest` shows the graph's latest ingestion (status running/completed, per-asset results).

With `site_search` (part of a name, case-insensitive), it instead searches the whole SITE for
data sources and workbooks to add with add_sources: each hit has its `luid` and `in_graph`.

Input parameters:

- `graph_id`
- `node_type`
- `site_search`

### `search_semantic_contexts` (~149 tokens)

Find semantic contexts

List semantic contexts: the business statements (definitions, rules, caveats) attached to
the graph. Includes user-managed (SEMANTIC_CONTEXT, editable) and Tableau-managed
(SEMANTIC_CONTEXT_EXTERNAL, read-only) contexts.

\- With `node` (an id or a description): only the contexts attached to that node.
\- Without `node`: every context on the graph; `is_global` true = only graph-wide contexts,
  false = only node-attached ones, omitted = both.

The API doesn't filter by text yet; to find statements by meaning, use search_nodes.

Input parameters:

- `graph_id`
- `is_global`
- `node`

### `graph_health` (~170 tokens)

Graph health

Graph-health report: a 0-100 `health_score`, coverage metrics (e.g. how many nodes carry
semantic context), graph stats, and concrete improvement suggestions (each with severity,
recommended_action and the target node ids), grouped by category and topic.

\`pds_id` scopes the report to one published data source's subtree. `severity` ("high",
"medium", "low"), `suggestion_type` and `limit` (default 20; a busy graph has hundreds) filter
only the suggestion lists; the score, metrics and `summary` totals always cover the full (or
PDS-scoped) graph.

Input parameters:

- `graph_id`
- `limit` (integer)
- `pds_id`
- `severity`
- `suggestion_type`

### `create_semantic_context` (~204 tokens)

Add semantic context

WRITE: attach business context (one or more statements, 5-1000 characters each) to the
knowledge graph, e.g. "Net Sales excludes returns and is reported in EUR."

Set exactly ONE of: `target_node_id` (an exact node id from search_nodes/get_node; the
context then DESCRIBES that node) or `is_global=true` (applies to the whole graph).
CONNECTION, SITE, SCHEMA and semantic-context nodes can't be targets. Some sites accept only
graph-wide context through the API (error node_semantic_context_disabled): then use
is_global=true and name the field or data source in each statement. `name` is optional
(derived when omitted). Needs the Creator role. Returns the new context, with its id.

Input parameters:

- `graph_id`
- `is_global` (boolean)
- `name`
- `statements` (array, required)
- `target_node_id`

### `update_semantic_context` (~163 tokens)

Update semantic context

WRITE: change a user-managed semantic context (`ctx_id`, e.g. "semctx:<uuid>"). Only what
you pass changes.

\- `statements` REPLACES the whole stored set (include every statement you want to keep).
\- `name` renames it.
\- `attach_to` (an exact node id) re-attaches it to that node; `make_global=true` detaches it
  and makes it graph-wide. Not both.

Tableau-managed (SEMANTIC_CONTEXT_EXTERNAL) contexts can't be changed. Needs the Creator role.

Input parameters:

- `attach_to`
- `ctx_id` (string, required)
- `graph_id`
- `make_global` (boolean)
- `name`
- `statements`

### `delete_semantic_context` (~105 tokens)

Delete semantic context

WRITE: delete a user-managed semantic context and its statements. Only semantic contexts
created through Tableau Knowledge can be deleted; ids of other nodes are ignored, and
Tableau-managed (SEMANTIC_CONTEXT_EXTERNAL) contexts are refused.

Returns what was deleted (name and statements, so it can be recreated if needed). Deleting an
id that doesn't exist succeeds without effect. Needs the Creator role.

Input parameters:

- `ctx_id` (string, required)
- `graph_id`

### `create_semantic_context_from_document` (~223 tokens)

Add semantic context from a document

WRITE: upload a local document (.txt, .md, .csv, .pdf, .docx, .xlsx; max 2 MB) and let
Tableau turn it into semantic context, e.g. a KPI glossary or a business-rules note.

\`file_path` is a path on the machine running this server; the file's content is sent to your
Tableau site, so confirm the file with the user first. Set exactly ONE of `target_node_id` (an
exact node id) or `is_global=true`, as for create_semantic_context (some sites accept only
graph-wide context). Tableau makes each line a statement (headings too), so write one rule
per line. Returns the new context with its statements and any `statements_skipped`.

Uses Tableau Knowledge's undocumented web-app API, which can change without notice.

Input parameters:

- `file_path` (string, required)
- `graph_id`
- `is_global` (boolean)
- `name`
- `target_node_id`

### `add_sources` (~172 tokens)

Add sources to graph

WRITE: add published data sources (`pds_luids`) and/or workbooks (`workbook_luids`) to a
knowledge graph. Tableau ingests them in the background (seconds to minutes); check with
list_sources (`ingest.status`). Adds only: sources already in the graph stay, and re-adding
one re-ingests it.

Exact LUIDs only, never names: find them with list_sources(site_search="part of a name").
\`graph_id` is required (or TABLEAU_KNOWLEDGE_GRAPH_ID): this never falls back to the primary
graph. Confirm the list with the user first.

Uses Tableau Knowledge's undocumented web-app API, which can change without notice.

Input parameters:

- `graph_id`
- `pds_luids`
- `workbook_luids`

### `remove_sources` (~174 tokens)

Remove sources from graph

WRITE: remove published data sources and/or workbooks, and the nodes built from them, from a
knowledge graph. The Tableau content itself is untouched. Context attached to removed nodes may
be lost; graph-wide context stays.

Exact LUIDs only (a source's properties.luid from list_sources); pass them in either list, the
type comes from the graph. LUIDs that aren't in the graph are reported and skipped. `graph_id`
is required (or TABLEAU_KNOWLEDGE_GRAPH_ID). Confirm with the user first. Returns what was
removed; add_sources with the same LUIDs puts it back.

Uses Tableau Knowledge's undocumented web-app API, which can change without notice.

Input parameters:

- `graph_id`
- `pds_luids`
- `workbook_luids`

### `create_graph` (~88 tokens)

Create graph

WRITE: create a new, empty knowledge graph on the site (sites allow a few: see
server_info `features.max_graphs_per_site`). Then fill it with add_sources. Returns the graph
with its id. Confirm the name with the user first.

Uses Tableau Knowledge's undocumented web-app API, which can change without notice.

Input parameters:

- `description`
- `name` (string, required)

### `update_graph` (~111 tokens)

Update graph

WRITE: rename a knowledge graph, replace its description, and/or make it the site's primary
graph (the default for everyone who doesn't pick a graph; only one graph is primary). Only
what you pass changes. `graph_id` is an exact id from server_info. Confirm with the user first.

Uses Tableau Knowledge's undocumented web-app API, which can change without notice.

Input parameters:

- `description`
- `graph_id` (string, required)
- `make_primary` (boolean)
- `name`

### `ask_tableau_agent` (~184 tokens)

Ask Tableau Agent

Ask Tableau's own agent (the chat in Tableau Knowledge) a question about a graph and get its
answer, e.g. to test semantic context and Business Preferences against an answer key: ask one
question at a time and compare the numbers yourself.

Pass the returned `conversation_id` to ask a follow-up in the same conversation (this server
keeps the history in memory, so it lasts until the server restarts). Omit it for a fresh
conversation, which is the fair way to test. `tools_used` lists the agent's own tool calls. The
agent can also write semantic statements when asked to, so phrase questions as questions. Can
take a minute.

Uses Tableau Knowledge's undocumented web-app API, which can change without notice.

Input parameters:

- `conversation_id`
- `graph_id`
- `question` (string, required)

### `export_to_ossie` (~266 tokens)

Export to Ossie

Export a published data source's semantic model to Apache Ossie (formerly OSI) YAML, the
vendor-neutral format that Snowflake, dbt, Power BI, Databricks, Tableau Next and other tools
convert from. Returns `ossie` (the YAML text, to save as `file_name`), `summary`, `validation`
and `losses` (what could not be carried and what to fix by hand).

\`datasource` is a PDS id (from list_sources) or a description of it. Logical tables become
datasets, fields become fields, row-level calcs become fields and aggregate calcs become
metrics; every calc keeps its Tableau formula and gains portable SQL when the translation is
exact. Semantic-context statements become ai_context. `default_aggregation_metrics` also turns
each measure's Tableau default aggregation into a metric (total_sales = SUM(sales)).
Always read `losses`: Tableau Knowledge has no physical table paths or join keys, so `source`
and `relationships` need filling in before the model is used elsewhere. See ossie_guide.

Input parameters:

- `datasource` (string, required)
- `default_aggregation_metrics` (boolean)
- `graph_id`
- `include_hidden` (boolean)

### `validate_ossie` (~129 tokens)

Validate Ossie model

Validate an Apache Ossie (formerly OSI) model, given as YAML or JSON text, against the
official JSON Schema (0.2.0.dev0, bundled) and the spec's semantic rules: duplicate names,
keys and relationship columns that are not declared fields, unknown datasets, qualified names
in dataset-scoped metrics. 0.1.1 documents (`semantic_model:` list) are converted first; pass
\`model_name` when one holds several models. Runs locally: nothing is sent to Tableau.

Input parameters:

- `document` (string, required)
- `model_name`

### `import_from_ossie` (~348 tokens)

Import from Ossie

Bring the business meaning of an Apache Ossie (formerly OSI) model into Tableau Knowledge
as semantic contexts. WRITES only when `apply` is true; by default it returns the PLAN.

\`document` is the model as YAML or JSON text. Elements are matched to nodes of one published
data source: models exported by export_to_ossie map back by their stored ids; other models
need `target_datasource_id` (an exact PDS id from list_sources) and match by name. Each matched
node gets one context named `ossie:<model>` holding its description, ai_context instructions,
synonyms ("Also known as: ..."), example questions, metric definition (`include_definitions`)
and relationships. Re-importing updates those contexts instead of duplicating them.

\`scope`: "auto" (default) attaches contexts to nodes and, on sites that accept only graph-wide
context through the API (error node_semantic_context_disabled), writes the plan's
\`global_fallback` instead: one global `ossie:<model>` context whose statements are prefixed
with what they describe. "node" never falls back; "global" plans the global context directly.

Workflow: call without `apply`, show the user the operations (create/update/unchanged) and
\`unmatched` list, then call again with `apply=true` once they agree. Needs the Creator role.

Input parameters:

- `apply` (boolean)
- `document` (string, required)
- `graph_id`
- `include_definitions` (boolean)
- `model_name`
- `scope` (string)
- `target_datasource_id`

### `ossie_guide` (~142 tokens)

Ossie guide

Reference for Apache Ossie (formerly Open Semantic Interchange, OSI), the open standard for
semantic models: what it is and its versions, the object model and rules, expressions and
dialects, how Tableau maps onto it, relationships, ai_context, extensions, validation, the
converters for other platforms (with exact commands), and a porting playbook with pitfalls.
Read it before hand-editing a model or advising on a port. `topic` is one of: overview, model,
expressions, tableau, relationships, ai_context, extensions, validation, converters, porting;
omit it for everything.

Input parameters:

- `topic`

### `check_business_preferences` (~287 tokens)

Check Business Preferences

Check a Tableau Business Preferences file (the "# rule" lines Tableau's agent reads before it
answers) so every line is one the agent will actually follow. Call it with no `text` first to
get the rulebook: format, limits, wording rules, workbook preparation and how to test.

Checks: the "# " line format (a slip makes Tableau silently ignore the line), the limits (Tableau
Cloud: 50 rules and 8,000 characters per dashboard; Tableau Next: 30,000 per semantic model),
headers, duplicates, contradictions, thresholds without "use only this value", formatting rules
that would leak into queries, conversational lines, absences that can be over-read, ambiguous
ordering and averages, and missing baseline rules (query formatting, failure handling).

\`target` (a dashboard, sheet, workbook or data source: id or description) also checks every
[Field] and "Field" the file names against the captions the agent will see in Tableau Knowledge,
with "did you mean" suggestions, and flags workbook problems (duplicate, generic or helper field
names). `product` is "cloud" or "next". Returns `ok` (no errors), `issues` by line, and stats.

Input parameters:

- `graph_id`
- `product` (string)
- `target`
- `text` (string)

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/biztory-biztory-tableau-knowledge-mcp/biztory-tableau-knowledge-mcp#diagnostics

## Score history

- 2026-11-05: 82
- 2026-11-04: 81
- 2026-11-03: 79
- 2026-11-02: 79
- 2026-11-01: 79
- 2026-10-31: 79
- 2026-10-30: 79

## Common questions

### What is the io.github.biztory/biztory-tableau-knowledge-mcp server?

io.github.biztory/biztory-tableau-knowledge-mcp is listed in the public MCP registry as io.github.biztory/biztory-tableau-knowledge-mcp. Search, explore and enrich the Tableau Knowledge graph, and port it to Apache Ossie (OSI). This page covers its PyPI package (biztory-tableau-knowledge-mcp).

### Is the io.github.biztory/biztory-tableau-knowledge-mcp server safe to use?

io.github.biztory/biztory-tableau-knowledge-mcp scores 82 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the io.github.biztory/biztory-tableau-knowledge-mcp server expose?

io.github.biztory/biztory-tableau-knowledge-mcp exposes 23 tools: server_info, search_nodes, get_node, list_edges, lineage, and 18 more. Their descriptions and schemas cost roughly 3,937 tokens of context every time the server is loaded.

### Is the io.github.biztory/biztory-tableau-knowledge-mcp server still maintained?

io.github.biztory/biztory-tableau-knowledge-mcp is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the io.github.biztory/biztory-tableau-knowledge-mcp server under?

io.github.biztory/biztory-tableau-knowledge-mcp declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the io.github.biztory/biztory-tableau-knowledge-mcp server?

VerifyMCP ran 16 checks on io.github.biztory/biztory-tableau-knowledge-mcp, covering Malware scan, Known CVEs, Install scripts, Dependency health and 12 more. Endpoint Security and Transport & Reachability do not apply to a PyPI package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- PyPI project: https://pypi.org/project/biztory-tableau-knowledge-mcp/
- Socket report: https://socket.dev/pypi/package/biztory-tableau-knowledge-mcp
- Repository: https://github.com/biztory/biztory-tableau-knowledge-mcp
- Changelog RSS feed: https://verifymcp.io/servers/biztory-biztory-tableau-knowledge-mcp/biztory-tableau-knowledge-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/biztory-biztory-tableau-knowledge-mcp/biztory-tableau-knowledge-mcp/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/biztory-biztory-tableau-knowledge-mcp/biztory-tableau-knowledge-mcp.json
- HTML version of this page: https://verifymcp.io/servers/biztory-biztory-tableau-knowledge-mcp/biztory-tableau-knowledge-mcp