LunaLabs

Data infrastructure · 2026

Tableau MCP

Give an agent hands inside a workbook.

Analytics workbooks are opaque to tooling: the logic lives inside a binary-adjacent file format, and the interesting parts — level-of-detail calculations, mark encodings, data-source relationships — are reachable only through the application itself. This server exposes them as protocol tools, so an agent can read a workbook, answer questions about it, and make validated edits.

Status
Active
Domain
Developer tooling · Protocol servers
Role
Author
Year
2026

Stack

  • Python
  • Model Context Protocol
  • XML schema validation
  • Hyper

A Model Context Protocol server for a desktop analytics application — introspect, query and edit local workbooks directly from an AI coding agent.

01

Read before write, always

The tool surface is staged deliberately: the read tools ship first, including a parser for level-of-detail expressions and worksheet mark structures, then the data pipeline, and only then the write tools — each validated against the format schema before anything touches a file.

Editing a workbook badly is worse than not editing it at all, so writes arrive last and arrive checked.

02

File-first and local

The server operates on local files over a standard input/output transport.

No server deployment, no credentials, no data leaving the machine. It is the smallest possible surface that makes the workbook legible to an agent.

03

Designing a tool surface for a model

Protocol tools are an API whose consumer is a language model, which changes what good design means.

Names have to be unambiguous without documentation, arguments have to be hard to supply wrongly, and errors have to explain themselves well enough that the caller can correct without a human. A tool that returns a stack trace is a tool the agent will retry identically.

04

Level-of-detail is where the logic hides

The genuinely difficult analytical logic in a workbook lives in level-of-detail expressions — the calculations that fix or exclude dimensions from an aggregation.

Surfacing them as structure rather than as opaque strings is what turns "an agent can read this file" into "an agent can explain what this dashboard computes", which is the entire point of the server.

Pipeline

Tool surface

Stage Can reject

  1. 01

    Workbook file

    Local XML

  2. 02

    Parse

    Structure

  3. 03

    LOD parser

    Legible calculations

    Where the logic hides

  4. 04

    Read tools

    Answers to an agent

  5. 05

    Validate

    Schema-checked edit

  6. 06

    Write tools

    Modified workbook

Skills exercised

What the build
actually demanded.

Against the corpus · 15 systems

  • Stack breadth 4
  • Design decisions 4
  • Pipeline stages 6
  • Decision gates 1

This system Corpus median

Protocol design

  • Tool surface design for agent consumption
  • Standard I/O transport and local file scoping
  • Staged capability rollout, read before write
  • Schema-validated mutation of a third-party format

Format work

  • Workbook XML parsing and traversal
  • Level-of-detail expression parsing
  • Worksheet mark and encoding introspection
  • Columnar extract handling

What it establishes

  • Read tools first

    LOD parser and mark introspection before any write

  • Schema-validated writes

    Every edit checked against the format

  • Local, no credentials

    Standard I/O transport, files never leave

  • Designed for a model caller

    Self-explaining errors, unambiguous names