TOMPo MCP: AI-Powered Lineage Intelligence for Power BI & Microsoft Fabric

[TusharPardeshi]

                                       Get End to End AI Powered Lineage in matter of few minutes!   

         

Figure 1: Actual Output Snip of TOMPo — AI-Powered Lineage Intelligence for Microsoft Fabric & Power BI. Trace the complete data journey from semantic model columns and measures, through reports and pages, all the way to individual visuals — across workspaces, in seconds, using natural language.

 

The Problem: Why Lineage Matters

Imagine you manage a Power BI semantic model with 50+ tables, hundreds of measures, and dozens of reports. A business stakeholder asks: "What happens if we rename the Employee.StartDate column?" You now face a daunting manual task — open each report, inspect every visual, check every DAX measure, across every workspace. It could take hours, and you might still miss something.

In enterprise environments — where a single model can feed 20+ reports with 200+ visuals across same or multiple other cross workspaces — there is no built-in way to answer this question quickly. Fabric's native lineage view shows dataset-to-report connections, but it stops there. It doesn't drill into which specific columns or measures are used in which specific visuals.

This gap creates real risk: broken reports after schema changes, stale columns no one realizes are still in use, and governance blind spots that grow silently over time.

 

TOMPo: What It Is and How It Works

TOMPo - (T)abular (O)bject (M)odel (Po)wer BI is an open-source MCP server that brings deep lineage intelligence directly into your AI coding assistant — GitHub Copilot, Claude Desktop, Cursor, or any MCP-compatible client.

Instead of navigating portals and manually inspecting reports, you simply ask a question in natural language and TOMPo handles the rest:

• "What visuals use the Employee.Department column?"
• "Generate full interactive lineage for my AdventureWork semantic model"
• "Show me the governance health score for this workspace"
• "Export an interactive lineage visualization I can share with my team"

So, what exactly does TOMPo do?

Full Lineage Tracing: Semantic Model → Tables → Columns/Measures → Reports → Pages → Visuals. See exactly which fields appear in which visuals.

• Impact Analysis: Ask "what breaks if I rename X?" and instantly see every affected report, page, and visual.
• Cross-Workspace Lineage: Trace a semantic model's usage across ALL workspaces in your tenant — find reports you didn't even know existed.
• Governance Health Scoring: Automated quality scoring (0-100) that flags unused tables, missing descriptions and orphan measures.
• Interactive Visualization: Export a self-contained D3 tree (HTML file) with expand/collapse, zoom, search — works offline, no server needed.
• Zero Infrastructure: Runs locally on your machine using your own Azure identity. No App Service, no Docker, no backend deployment.

How TOMPo Works Under the Hood

TOMPo follows the Model Context Protocol (MCP) — an open standard that lets AI assistants call TOMPo tools. All the tools run locally, strictly using your access permissions on - workspace, semantic models and the reports.

When you type a question in Copilot Chat, the AI decides which TOMPo tool to invoke and passes the results back in a conversational format.

Architecture Flow:

1. You type a question in GitHub Copilot Chat (or Claude/Cursor)
2. Copilot identifies the intent and calls the appropriate TOMPo MCP tool
3. TOMPo runs locally on your machine using your az login identity
4. TOMPo calls Fabric REST APIs (getDefinition, Scanner, DAX executeQueries)
5. Parses semantic model + report definitions (TMDL, PBIR, BIM formats)
6. Builds the lineage tree and returns structured data to Copilot
7. Copilot formats the response as a readable table, tree, or saves an HTML file

Authentication — No App Registration Required

TOMPo uses Azure's DefaultAzureCredential which automatically picks up your existing identity:

• Azure CLI (az login) — most common for developers
• VS Code Azure Account extension
• Environment variables — for CI/CD pipelines
• No extra app registrations, service principals, or secrets needed. If you can access the workspace in the browser, TOMPo can too.

Metadata Extraction (3-Tier Fallback)

Not all semantic models expose metadata the same way. TOMPo handles this gracefully with a 3-tier fallback strategy:

1. Primary

Fabric getDefinition API

Returns full TMDL/BIM definitions — richest metadata

2. Fallback

Admin Scanner API

When getDefinition is blocked (e.g., sensitivity labels)

3. Last Resort

DAX executeQueries

Uses INFO.TABLES(), INFO.COLUMNS() DMVs via REST

 

MCP Tools Available

TOMPo exposes 8 tools that your AI assistant can call on your behalf:

• list_workspaces

  • List all Fabric/Power BI workspaces you have access to

• generate_lineage

  • Full lineage: Model → Tables → Reports → Pages → Visuals → Fields

• generate_workspace_lineage

  • Combined lineage for ALL semantic models in a workspace

• impact_analysis

  • Find every visual where a specific column or measure is used

• describe_semantic_model

  • Detailed metadata: tables, columns, measures, relationships, roles

• export_lineage_html

  • Generate interactive D3 visualization as a self-contained HTML file

• cross_workspace_lineage

  • Trace a model's usage across all workspaces in the tenant

• governance_health_score

  • Automated quality scoring (0-100) with issue breakdown

 

Getting Started — 3 Steps, Under 2 Minutes

Step 1: Install from PyPI

pip install tompo-mcp

Step 2: Login to Azure

az login

Now, Select the subscription linked to your Power BI / Fabric tenant — TOMPo will discover all workspaces your identity has access to within that tenant.

Step 3: Add to Visual Studio Code MCP config

Open VS Code, then press Shortcut : Ctr + Shift + P , Select Open User Configuration, Paste below, Save and Start the tompo server

You can copy below JSON into your .vscode/mcp.json(as shown above) in VS Code:

{
  "servers": {
    "tompo": {
      "command": "python",
      "args": [
        "-m",
        "tompo_mcp"
      ],
      "type": "stdio"
    }
  }
}

Ensure that the tompo mcp server is shown running. That's it. Open Copilot Chat and start asking lineage questions in GitHub AI Chat window.

 

Demo: Tracing Lineage on a Real Semantic Model

Let's walk through a real-world example using an enterprise semantic model with 37 tables, 100+ measures, and multiple bound reports.

Step 1: List Workspaces

We start by asking Copilot to list our workspaces. TOMPo returns all workspaces the user has access to, with their IDs.

                                         

Figure 3: TOMPo discovers all 164 Fabric workspaces accessible to the user — one az login , one natural language prompt and instant results via MCP.

 

 

Step 2: Generate Full Lineage 

Next, we ask for the full lineage of our semantic model. TOMPo fetches the model definition, discovers all bound reports, parses every page and visual, and maps which columns/measures each visual uses.

For eg: You can ask "Give me full interactive lineage for Semanitc Model XYZ present in XYZ Workspace"

 

Step 3: Impact Analysis

Other powerful question you can ask: "What visuals use the Employee.Department column?"

 

Step 4: Export Interactive HTML Visualization

For sharing with stakeholders or archiving, we export the lineage as a self-contained interactive HTML file. This opens automatically in any browser — no server, no login required.

The HTML visualization includes three tabs:

• Lineage Tree Tab: Interactive D3 tree with expand/collapse, zoom, pan, and color-coded nodes
• Impact Analysis Tab: Searchable data grid showing column/measure → visual mappings
• Semantic Model Tab: Full model metadata — tables, columns, measures, relationships

It also contains Governance Health Scoring section:

Beyond lineage, TOMPo can assess the quality and governance health of your semantic models. The governance_health_score tool evaluates a model (or entire workspace) and returns a score from 0-100 with a detailed breakdown of issues found.

What It Checks:

• Unused Tables: Tables in the model that aren't referenced by any report visual (-3 per table)
• Missing Descriptions: Columns and tables without descriptions — documentation gaps (-1 to -2 each)
• Orphan Measures: Measures that exist but aren't used in any visual (-3 per measure)
• Missing Format Strings: Measures without proper formatting — affects report readability (-1 each)
• No Relationships: Multi-table models with zero relationships defined (-5)
• Empty Tables: Tables with zero columns — likely configuration artifacts (-3 each)

Cross-Workspace Lineage

In enterprise environments, a single semantic model often feeds reports in multiple workspaces. The cross_workspace_lineage tool scans your entire tenant and finds every report — even ones in workspaces you might not have checked — that binds to your model.

This is invaluable for:

• Identifying shadow IT — reports built by other teams using your model
• Planning migrations — understanding the full blast radius before changes
• Compliance — ensuring all consumers of sensitive data are accounted for

Key Observations

1. Natural Language Access: Users don't need to learn APIs or navigate portals. Ask a question in plain English and get lineage answers instantly.
2. Column-Level Granularity: Unlike Fabric's native lineage view (dataset → report), TOMPo drills down to individual columns and measures in specific visuals.
3. Enterprise Scale: Successfully tested on models with 37+ tables, 100+ measures, and 20+ bound reports across multiple workspaces.
4. Governance Automation: Health scoring turns subjective "is this model well-maintained?" into an objective, repeatable metric.
5. Zero Deployment Overhead: pip install + az login. No infrastructure, no secrets, no admin requests. Works in 2 minutes.
6. Open Source & Extensible: MIT licensed, published on PyPI (2,200+ downloads). Teams can extend with custom tools or integrate into CI/CD.

Conclusion

TOMPo brings a capability that has been missing from the Power BI and Fabric ecosystem: deep, column-level lineage intelligence accessible via natural language.

 

In summary, TOMPo provides:

• Column-to-visual lineage tracing across reports and workspaces
• Instant impact analysis — know what breaks before you change anything
• Automated governance scoring with actionable issue breakdowns
• Interactive, shareable HTML visualizations that work offline
• Zero infrastructure — install from PyPI and use in under 2 minutes
• Open source (MIT) — extend, customize, integrate into your workflows

Compatibility

• TOMPo works with any MCP-compatible AI client:
• GitHub Copilot (VS Code) — recommended for this release
• Claude Desktop
• Any custom MCP client

Requirements:

• Python 3.10+
• tompo-mcp (pip install tompo-mcp)
• VS Code
• Azure CLI (az login) or any Azure credential
• Access to Fabric/Power BI workspaces you want to analyze

Appendix and Links

Resources:

• PyPI Package: https://pypi.org/project/tompo-mcp/
• GitHub Repository: https://github.com/microsoft/HRDIUtilities/tree/main/TompoMCP
• Model Context Protocol (MCP): https://modelcontextprotocol.io/
• Fabric REST APIs — getDefinition: https://learn.microsoft.com/en-us/rest/api/fabric/semanticmodel/items/get-semantic-model-definition
• Azure DefaultAzureCredential: https://learn.microsoft.com/en-us/python/api/azure-identity/azure.identity.defaultazurecredential
• VS Code MCP Configuration: https://code.visualstudio.com/docs/copilot/chat/mcp-servers

Contributors

@TusharPardeshi ;  @JOSAMU ; @mithunm ; @kranthimeda ; @RajeshDadi ; @yogeshjain ; @dish_microsoft