Deterministic Documentation
Tables, columns, measures, hierarchies, and relationships extracted directly from metadata. DAX expressions preserved verbatim with optional multi-provider AI interpretations tagged by confidence level.
Semantic Model Compiler & Quality Gate
Refactor Power BI models for developers, teams, and modern AI dashboards.
Static analysis and architectural verification for Tabular models. Audit 8 best-practice rules, write descriptions directly back into your model, and export verified semantic contracts for Claude dashboards and Microsoft Fabric Rayfin data apps.
Unsubscribe anytime. Zero spam. View our Privacy Policy.
- In-place refactoring: 8-rule health audit and native Tabular write-back
- Forward modernization: Claude prompt manifests and Fabric Rayfin TypeScript specs
- 100% private: local in-memory execution, zero model telemetry stored
54/100
Grade F
3 high
2 medium
3 low
- BP-01 Bi-directional filter:
'Customer'[RegionKey] ↔ 'Region'[RegionKey] - BP-03 Calculated column in fact table:
'Sales'[Amount Band] - BP-05 Relationship targets missing table:
'Region' - BP-02 Exposed foreign key column:
'Sales'[OrderDate] - BP-07 Undocumented table entity:
'Customer'
Verified output from sample SalesModel fixture.
Undocumented models become technical debt. Reverse-engineering them shouldn't.
Production models accumulate hundreds of measures, unoptimized relationships, and undocumented DAX dependencies over years of releases. Manual documentation is obsolete the moment it is written, while generic LLM chats hallucinate calculations without ground-truth metadata. RefactorBI executes factual extraction deterministically, isolating AI interpretation to strictly verified review queues.
Capabilities
Static analysis, governance, and model modernization
Architectural Health Scorecard
A 0-100 score and A-F grade evaluated against 8 structural rules: bi-directional filters, exposed foreign keys, calculated fact columns, many-to-many cardinality, broken relationships, ambiguous DAX, undocumented tables, and orphan measures.
Lineage & DAX Dependency Trees
Entity-relationship diagram with cardinality and filter propagation, plus measure dependency graphs that reveal downstream impact before modifying or deprecating DAX logic.
Two-Way Tabular Write-Back
Synchronize approved descriptions back into your model as native tooltips. Export an enriched .bim or generate Tabular Editor C# scripts. Existing descriptions are protected unless explicitly overwritten.
Report Visual Usage Audit
Parse PBIR or .pbix report layouts to map field and measure bindings across visuals, identifying high-impact metrics and flagging dead-weight measures with zero references.
Governance Review Queue
Review and verify AI-generated enrichments before sign-off. Export immutable compliance audit logs (signoff_audit.json) for enterprise data cataloging.
Interactive Output
Inspect model architecture, lineage, and contracts
Live deliverables generated from our sample SalesModel fixture.
Measure: Sales LY Metadata fact
- Home table
Sales- References
[Total Sales],'Date'[Date]
CALCULATE (
[Total Sales],
SAMEPERIODLASTYEAR ( 'Date'[Date] )
)AI interpretation Strong inference
Total sales for the same period one year earlier, utilized for year-over-year performance benchmarking. Requires continuous date sequences on the marked Date dimension.
AI interpretations are quarantined with confidence indicators until reviewed and approved by an engineer.
'Sales'[Amount]
→
[Total Sales]
→
[Sales LY]
[Sales by Ship Date]
Maps direct and indirect DAX dependency chains to prevent regressions.
// Tabular Editor C# Script: updates live model descriptions
Model.Tables["Sales"].Measures["Sales LY"].Description =
"Total sales for the same period in the previous year.";
Model.Tables["Customer"].Description =
"One row per customer, with region assignment.";
// Existing descriptions preserved unless overwrite is enabled.// rayfin_schema.ts: Compiled for Microsoft Fabric Rayfin Data Apps
export interface SalesModelSchema {
tables: {
Sales: { columns: ["CustomerKey", "OrderDate", "ShipDate", "Amount"] };
Customer: { columns: ["CustomerKey", "CustomerName", "RegionKey"] };
};
verifiedMeasures: {
"Total Sales": { dax: "SUM(Sales[Amount])", concept: "Gross Revenue" };
"Sales LY": { dax: "CALCULATE([Total Sales], SAMEPERIODLASTYEAR('Date'[Date]))", concept: "Prior Year Comp" };
};
}
// Ready for: npx rayfin up OR direct import into Claude Projects
Modernize & Migrate
Bridge verified business logic to Claude and Microsoft Fabric Rayfin
Avoid rebuilding production metrics by hand. RefactorBI compiles legacy semantic models into typed, machine-readable contracts for AI coding agents and custom data apps.
Claude Dashboard Manifests
Export token-optimized claude_agent_context.md manifests with verified metric formulas, table relationships, and filter contexts. Build interactive dashboards and answer executive questions without hallucination.
Fabric Rayfin App Schemas
Generate production-ready TypeScript schemas (rayfin_schema.ts) ready for Fabric's Rayfin CLI. Build custom, interactive React and Plotly operational data applications wired directly to OneLake.
Dead-Weight Measure Elimination
Identify unreferenced measures across all report visuals and filters. Prune abandoned legacy calculations before migrating a single line of application code.
Supported Inputs
Compatible with modern Power BI project formats
| Format | Extracted Content |
|---|---|
| PBIP (zipped project) | Semantic model (TMDL or BIM) and report layout visuals for complete audit coverage |
| TMDL | Tables, columns, measures, hierarchies, and relationships in tabular definition language |
| BIM / TMSL | Full Tabular model JSON exported from Tabular Editor, Visual Studio, or Microsoft Fabric |
| PBIR | Report pages, visuals, and specific field bindings |
| PBIX | Report layout layer: pages, visuals, and bound measures. Save as .pbip in Power BI Desktop for data model metadata. |
Privacy & Security
Metadata only. Local in-memory processing.
Never Transmitted
- Underlying data rows: RefactorBI inspects metadata only
- Power Query / M scripts and SQL source expressions
- Connection strings and database credentials
- Row-level security (RLS) definitions
- Model annotations
AI Provider (Only If Enabled)
- Table, column, and measure names
- Data types and existing descriptions
- DAX expressions
Supports bring-your-own-key (Claude, OpenAI, Gemini) or internal enterprise gateway. When AI is disabled, zero data leaves your machine.
Processed Locally
- Parsed directly in memory with zero database persistence
- No user account or telemetry required
- Parsing, health audits, lineage, and write-back execute deterministically
Comparison
Designed to complement your existing engineering stack
| Capability | Manual Docs | Generic LLM Chat | Tabular Editor | RefactorBI |
|---|---|---|---|---|
| Time to Full Document | Days | Hours (copy-paste) | Scripting required | Seconds |
| Ground-Truth Separation | None | No (hallucinations) | None | Yes (fact vs inference) |
| Multi-Vendor AI Explanations | No | Unverified | Manual | Yes (BYOK / Gateway) |
| Best-Practice Architecture Audit | No | No | Yes (BPA rules) | Yes (8 rules + scorecard) |
| Lineage & ER Diagrams | Manual | No | Partial | Yes (ERD + DAX trees) |
| Tabular Model Write-Back | Manual | No | Yes | Yes (.bim + TE scripts) |
| Visual Usage Audit | No | No | No | Yes (PBIR / PBIX) |
| Claude & Rayfin Contract Bridge | No | No | No | Yes (0% metric drift) |
RefactorBI generates scripts compatible with Tabular Editor 2 and 3.
Community & Access
Free developer utility. Zero lock-in.
RefactorBI is distributed as a community utility for Power BI developers, analytics engineers, and BI consultants.
Available Now
Community Edition
Free
Fully-featured for individual developers and internal engineering teams
- Deterministic metadata extraction (.pbip, .tmdl, .bim, .pbir, .pbix)
- 8-rule Model Health Scorecard (0-100% score and A-F letter grade)
- Interactive Mermaid ER diagrams and DAX dependency lineage trees
- Multi-provider AI engine (Claude, OpenAI, Gemini, or corporate proxy BYOK)
- Two-way write-back: enriched .bim download and Tabular Editor C# scripts
- Next-gen AI bridge: Claude Agent context (.md) and Fabric Rayfin schemas (.ts)
- Report visual usage audit and orphan measure detection (PBIR / PBIX)
- Headless CI/CD quality gate CLI for GitHub Actions and Azure DevOps
- Governance review queue with developer sign-off stamps and audit logs
- 100% private in-memory processing (zero telemetry or database persistence)
Roadmap Preview
Cloud & Team Workspaces
Preview
Future hosted edition for enterprise organizations
- Centralized team documentation portal and searchable model catalog
- Automated direct synchronization with Power BI Service and Fabric REST APIs
- Multi-developer collaborative sign-off queues and approval workflows
- Enterprise SSO (Entra ID, Okta) and role-based access control
- Cross-workspace metric drift alerting and semantic cataloging
- Self-hosted Docker and Kubernetes deployment options
Community edition is free for personal, internal, and client engagements. No credit card, no telemetry, no invoices.
FAQ
Frequently Asked Questions
Do I need an AI API key to use RefactorBI?
No. Documentation extraction, health scores, lineage diagrams, and write-back scripts execute deterministically without AI. AI explanations are strictly optional: you can supply your own API key for Anthropic Claude, OpenAI, or Google Gemini, or connect an internal corporate proxy.
Can the AI generate hallucinations or incorrect metrics?
Metadata facts (tables, columns, data types, relationships, DAX formulas) are parsed directly from source files and are never passed through an LLM. AI is only used for descriptive interpretations, which are tagged with confidence indicators and quarantined in a review queue until an engineer approves them.
Does it work with existing .pbix files?
For .pbix files, RefactorBI parses the report layout layer: pages, visuals, and bound measures. Because the internal data model in a .pbix is compressed and proprietary, full model documentation requires saving the project as a Power BI Project (File → Save as → .pbip) and uploading the folder.
Will RefactorBI modify my original files?
Never directly. Write-back outputs a new .bim file or a Tabular Editor C# script that you review and execute inside your development environment. Existing descriptions are preserved unless you deliberately choose to overwrite them.
Does RefactorBI evaluate DAX formulas or query source data?
No. DAX expressions are analyzed statically as text: they are never executed, and RefactorBI never connects to your underlying databases or data sources.
Is there native support for Microsoft Fabric or Power BI Service?
You can upload models exported via Power BI Desktop, Tabular Editor, or Fabric Git integration (TMDL/PBIP). Direct workspace API synchronization is part of the cloud roadmap preview.
Automate your Power BI model documentation and health audits
Join the early access waitlist for developer downloads, CLI releases, and cloud workspace updates.
You will only receive notifications regarding RefactorBI releases and access. Unsubscribe anytime. View our Privacy Policy.