Generating complete Power BI Dashboards with AI and Natural Language

Creating Power BI dashboards from scratch often involves repetitive layout tasks: creating cards, placing slicers, dragging visual components around the canvas, and tweaking pixel alignments. While Power BI Desktop handles data modelling well, building visual report layouts manually remains a time-consuming chore.

To automate this workflow, we built an open-source Power BI MCP (Model Context Protocol) server called SimBI MCP.

The key design insight behind SimBI MCP is that it acts as a compiler for Power BI reports. Instead of controlling Power BI Desktop via UI automation or relying on the Power BI service to render visuals, SimBI MCP compiles declarative high-level layouts (annotated HTML/CSS and TMDL schemas) directly into native Power BI Project files (.pbip and .Report/ directories) on disk.

In this article, we’ll cover how SimBI MCP’s compiler pipeline works under the hood, how it handles layout extraction, and how you can use it to automate dashboard creation.

What is SimBI MCP?

SimBI MCP is built on top of Anthropic’s Model Context Protocol, connecting AI assistants like Claude Desktop or Claude Code directly to Power BI’s file-based project format (.pbip).

Instead of attempting to guide an LLM through manual UI steps, SimBI MCP treats report generation as a compilation pipeline:

• Source Data Profiling: Inspects CSV or Excel datasets to infer schema, cardinality, and data types.
• Semantic Model Compilation: Generates TMDL (Tabular Model Definition Language) code, lints DAX measures, and persists model definitions to disk.
• Declarative Layout Drafting: Uses structured HTML and CSS grid frameworks as an intermediate layout representation.
• PBIR Code Generation: Parses layout coordinates and compiles valid, native PBIR (visual.json) files directly to disk without requiring Power BI Desktop to be running during emission.

How the Compiler Pipeline Works: 3-Phase Architecture

Under the hood, SimBI MCP chains three distinct phases across specialized MCP tools:

Below is the structural compilation flow from initial data profiling down to native file emission:

graph TD
    A[.pbip Created in Power BI Desktop] --> B{Choose Path}
    
    subgraph Phase 1: Semantic Modeling
        B -->|Path 1: SimBI Only| C[analyze_data_source]
        C --> D[lint_measures]
        D --> E[write_semantic_model]
        B -->|Path 2: MS Power BI MCP| F[ExportToTmdlFolder]
    end
    
    E --> G[CLOSE Power BI Desktop]
    F --> G
    
    subgraph Phase 2: Intermediate Representation
        G --> H[parse_schema]
        H --> I[Read simbi://annotation-vocabulary]
        I --> J[Generate Annotated HTML Mockup]
        J --> K[validate_mockup_html]
    end
    
    subgraph Phase 3: Target Compilation
        K --> L[emit_report]
        L --> M[Headless Chrome / Playwright Layout Extraction]
        M --> N[Generate .Report/ Visual PBIR Files & Resolved Theme]
    end
    
    N --> O[Open .pbip Fresh in Power BI Desktop]

Phase 1: Semantic Modeling (TMDL Compilation)

SimBI inspects your source files using analyze_data_source to identify table structures, data types, and potential unpivot requirements. It then drafts TMDL code representing tables, relationships, and measures.

Before emitting code to disk, lint_measures performs advisory static analysis to catch runtime DAX and model errors, such as:

• Invalid GUID formats for lineage tags or relationships.
• Missing 4th arguments in SEARCH() functions.
• Missing target columns or undefined measure references.

Once validated, write_semantic_model normalizes table names and writes the TMDL structure directly into the report’s .SemanticModel/ directory.

Phase 2: Intermediate Representation (HTML Mockup & Spatial Reasoning)

AI models struggle with raw absolute 2D coordinate space, but excel at producing structured HTML and CSS. SimBI uses annotated HTML mockups as its Intermediate Representation (IR) for layout planning.

The server exposes a custom resource (simbi://annotation-vocabulary) that teaches the LLM how to tag HTML containers using standard data-pbi-* attributes:

<!-- Example intermediate representation tag -->
<div data-pbi="columnChart" 
     data-pbi-axis="sales[Region]" 
     data-pbi-values="Total Revenue">
</div>

The model layouts visuals using standard CSS flexbox/grid classes (db-page, db-grid, db-card). Then the validate_mockup_html tool acts as an AST type-checker, verifying that all referenced measures exist in the model schema before code generation begins.

Phase 3: Target Compilation (PBIR Extraction & Theme Baking)

Power BI’s enhanced project format (PBIR) uses JSON definitions to dictate visual positions and query states. The emit_report tool compiles the intermediate HTML mockup into PBIR output files:

1. Headless Browser AST Evaluation: Playwright launches headless Google Chrome to parse and calculate the computed layout tree.
2. Bounding Box Extraction: SimBI queries element bounding boxes (x, y, width, height) and maps CSS styling properties (background colors, borders, typography) directly into visual layout JSON configurations.
3. PBIR File Generation: SimBI generates the output directory structure under .Report/definition/pages/, outputting distinct visual.json files for every card, chart, and slicer.
4. Theme Resolution: SimBI deep-merges Microsoft’s default palette (CY25SU10), custom user branding parameters, and opinionated visual styling choices (such as disabling chart gridlines and applying clean Segoe UI typography) into a resolved report theme.

Supported Visuals & Features

SimBI MCP supports 33 HTML annotation visual types, which map to 32 core Power BI visuals:

Advanced Interactive Capabilities (SimBI MCP Pro)

For complex dashboard requirements, SimBI MCP Pro adds advanced interactivity features directly into the compilation target:

• Interactive Bookmarks & Action Buttons: Target visual state transitions via data-pbi="bookmark" and data-pbi-action="bookmark".
• Field Parameters: Create dynamic measure-switching slicers via data-pbi-field-param.
• Dynamic Text Boxes: Display context-aware titles powered by DAX measures via data-pbi-title-measure.
• Shape & Container Styling Overrides: Map inline CSS properties (border-radius, box-shadow, custom fills) directly into PBIR shape elements and container style overrides.

Beyond Dashboards: SimBI MCP as a Prelude to Deterministic AI Infrastructure

While building an automated Power BI report layout compiler solves a real developer pain point, generating visual artifacts was never the ultimate goal of the SimBI project.

Large language models have become remarkably good at writing SQL, generating DAX, drafting Python, and rendering UI components. However, in enterprise environments, trust in generative outputs is the real bottleneck. Traditional LLMs rely on probabilistic reasoning; given identical instructions, an agent may choose different tools or make subtle context errors that break downstream financial or regulatory workflows.

The core philosophy of SimBI is a shift from purely generative analytics to generative and deterministic autonomous systems.

The Control Layer: LINT Measures & AST Validation

SimBI MCP serves as a practical, open-source preview of this broader control philosophy in action. Features like lint_measures and validate_mockup_html are not just convenience checks, they represent the fundamental architectural separation between probabilistic reasoning and deterministic enforcement:

• Probabilistic Reasoning (The LLM): Interprets ambiguous prompt requirements, plans layout layouts, drafts TMDL model definitions, and structures DAX calculations.
• Deterministic Enforcement (SimBI Engine): Intercepts the generated code, lints DAX syntax, validates lineage tags and UUID formats, verifies table schema alignments, and rejects un-executable code before anything is written to disk or executed.

By assuming the AI model might be incorrect or hallucinate structural properties, SimBI forces every AI-generated action through an independent, deterministic validation layer. Generation becomes only one stage within a larger, governed execution pipeline.

What’s Next: Autonomous Decision Infrastructure (ADI)

Applying deterministic checks to Power BI reports is only the starting point. The broader evolution of SimBI is building what we term Autonomous Decision Infrastructure (ADI).

Just as modern network firewalls inspect packet traffic before it reaches a server, ADI acts as an independent runtime firewall positioned between autonomous AI agents and enterprise systems:

• Executable Metadata & Suitability: Moving beyond human documentation to machine-readable rules that evaluate whether a dataset or action is contextually appropriate for the requested task prior to execution.
• Pre-Execution Policy Governance: Validating permissions, organizational policies, and compliance rules in real-time so decisions are governed before they occur, rather than audited after the fact.
• Immutable Provenance & Lineage: Association of persistent invocation IDs to create complete auditability, allowing complex AI agent workflows to be reconstructed, replayed, and verified.

SimBI MCP proves that when you decouple reasoning from code emission and enforce strict AST layout and measure validation, AI agents can generate complex, production-ready Power BI projects reliably. As we expand the platform, this same deterministic control plane will govern broader operational workflows, reconciliations, and enterprise decision systems.

Step-by-Step Guide: Compiling Your First Dashboard

Prerequisites

• Python 3.11 or higher
• uv package manager installed
• Google Chrome installed
• Power BI Desktop (configured with Power BI Project .pbip feature enabled)

Step 1: Install SimBI MCP

Clone and sync the repository:

git clone https://gitlab.com/ds-simbi/simbi-mcp.git
cd simbi-mcp
uv sync

Step 2: Configure Your MCP Client

Add simbi-mcp to your Claude Desktop configuration file (claude_desktop_config.json):

{
  "mcpServers": {
    "simbi": {
      "command": "uv",
      "args": ["run", "--directory", "/path/to/simbi-mcp", "simbi-mcp"]
    }
  }
}

Step 3: Initialize Your Project Directory

1. Open Power BI Desktop.
2. Select File > New, then File > Save As.
3. Choose Power BI Project (*.pbip) format and save to your working directory :
   C:\Reports\SalesDashboard\SalesDashboard.pbip
4. [optional] Load your dataset to create a data model. Save.
5. Close Power BI Desktop. (Mandatory: Because Power BI Desktop caches report files in memory while open, it must be closed so the SimBI compiler can write directly to disk without file locks).

Step 4: Prompt the AI Agent

Prompt Claude with the following instruction:

“I have a sales data CSV file at C:\Reports\SalesDashboard\Data\sales.csv. The project file C:\Reports\SalesDashboard\SalesDashboard.pbip exists and Power BI Desktop is closed.

Please generate a complete Sales Dashboard using SimBI MCP:

1. Profile the source CSV using analyze_data_source.

2. Write a TMDL model definition containing core measures (Total Revenue, Order Count, Avg Order Value) and lint it.

3. Persist the semantic model to disk and parse its schema.

4. Read the annotation vocabulary and build an executive sales dashboard mockup.

5. Validate the HTML layout against the schema and call emit_report to generate the .Report folder.”

Output Structure

Once execution finishes, your project folder contains compiled, valid Power BI report files:

C:/Reports/SalesDashboard/
│
├── SalesDashboard.pbip              <- Master project file
├── SalesDashboard.SemanticModel/    <- Compiled TMDL data model, tables & measures
└── SalesDashboard.Report/           <- Compiled PBIR visual layouts, visual.json files & themes

Reopen SalesDashboard.pbip in Power BI Desktop and click refresh data when prompted. Because all output files were written directly to native PBIR structures, all visual bounds, slicers, cards, and theme configurations load seamlessly and remain 100% editable inside Power BI Desktop.

Summary

By treating report generation as a compilation problem rather than a UI automation task, SimBI MCP bridges the gap between conversational AI and enterprise BI development. Compiling intermediate CSS/HTML layouts directly into native PBIR files eliminates manual layout boilerplate while delivering completely open, editable reports.

• Check out the SimBI MCP Repository to clone the code or contribute.
• View supported visual specs in our Chart Catalog Documentation.