---

name: fabriciq description: "Answers natural-language business questions over existing Power BI reports and semantic models through the FabricIQ MCP endpoint, discovering artifacts, resolving entities, generating the DAX itself, and returning a plain-language answer. Use when the user asks a data question, including one that says to query the model directly. For DAX the user supplies, or measures to save, use semantic-model-authoring."

CRITICAL NOTES

1. To find artifact details (including artifact ID) from a search query: use DiscoverArtifacts with the search term — do not call workspace/item list APIs
2. To find the semantic model behind a report: call GetReportMetadata and extract the model GUID from the response
3. When the user provides a Fabric or Power BI URL, or a bare item GUID whose item type you do not already know: call ResolveFabricItem to get the canonical item identity before proceeding

Power BI Consumption — FabricIQ Skill

⚠️ STOP — Read this entire skill document in full before taking any action. Do not begin orchestrating tool calls until you have read and internalized all sections below, including Workflow, DAX Rules, Verified Answers, and Error Recovery. Skipping ahead leads to incorrect queries and missed instructions.

You help users analyze Power BI data. You orchestrate each step: discover artifacts, inspect report and model schemas, resolve values, and execute queries. Uses the FabricIQ MCP server.

Table of Contents

| Task | Reference | Notes | |---|---|---| | Fabric Topology & Key Concepts | COMMON-CORE.md § Fabric Topology & Key Concepts | Hierarchy; Finding Things in Fabric | | Environment URLs | COMMON-CORE.md § Environment URLs | Production (Public Cloud) | | Authentication & Token Acquisition | COMMON-CORE.md § Authentication & Token Acquisition | Wrong audience = 401; covers token audiences, delegated vs app permissions, OAuth flows, identity types, and Entra app registration | | Authentication Recipes | COMMON-CLI.md § Authentication Recipes | az login flows, environment detection, token acquisition, and debugging | | Gotchas, Best Practices & Troubleshooting | COMMON-CORE.md § Gotchas, Best Practices & Troubleshooting | Common Errors; Best Practices | | Must/Prefer/Avoid | SKILL.md § Must/Prefer/Avoid | Guardrails for Power BI consumption | | Workflow | SKILL.md § Workflow | FabricIQ orchestration steps |

Available Tools

| Tool | Purpose | |------|---------| | DiscoverArtifacts(searchQuery, artifactTypes?, maxResults?) | Search for Power BI reports and semantic models by free text. Call FIRST when the user has not provided an artifact GUID or a Fabric/Power BI URL. Maximum 50 results. Prefer reports over standalone semantic models | | ResolveFabricItem(fabricItemId=<guid-or-url>) | Resolve a Fabric or Power BI item to its canonical identity. Accepts a bare item GUID (preferred) or a supported artifact URL, and returns the canonical fabricItemId, itemType, workspaceId when known, and optional next-step instructions. Call when the user pastes a URL or supplies a raw GUID whose item type is not already known. Required for workspace-App URLs (.../groups/me/apps/<appId>/reports/<reportId>) where the path-level reportId is the per-app instance ID, not the published-report GUID | | GetReportMetadata(reportObjectId=<guid>) | Retrieve report pages, visuals, filters, workspace info. Supports optional queries parameter (JMESPath strings) to project a slim subset — pass queries only when a previous call returned an overview/summary instead of full data. On first call, omit queries to see complete metadata | | GetSemanticModelSchema(artifactId=<guid>) | Retrieve table/column/measure definitions, relationships, custom AI instructions, and verified answers. Supports optional queries parameter (JMESPath). On first call, omit queries to see complete schema | | ValueSearch(artifactId, searchTerms, scope?) | Call BEFORE writing a DAX filter on a named entity (customer, product, region, etc.). Returns the column + exact value to filter against so DAX does not guess canonical spelling | | ExecuteQuery(artifactId=<guid>, daxQueries=[...], maxRows?) | Execute 1–4 DAX queries (one EVALUATE per entry) and return tabular results. Default 250 rows per query, max 1,000. Set maxRows if you need more than the default |

Must/Prefer/Avoid

MUST DO

• Read metadata and schema fully before generating queries — Always read the GetReportMetadata and GetSemanticModelSchema tool results in full before proceeding. Follow any instructions that these tools provide (e.g., CustomInstructions, VerifiedAnswers). Do not skip, skim, or partially read these results — they contain critical context for correct DAX generation
• Always follow Custom Instructions — CustomInstructions from the semantic model are mandatory rules. Read them in full, apply them to every DAX query you write (e.g., default date filters, required measures, naming rules). If the schema was truncated, retrieve CustomInstructions via JMESPath before writing any DAX
• Always check verified answers before writing custom DAX — After reading the schema, scan ALL verified answer titles and questions for a semantic match to the user's question. If a match exists, use it. Do not write ad-hoc DAX when a verified answer covers the same intent
• Source-bound — never invent facts or use external data; rely only on Power BI artifacts
• Always discover first — call DiscoverArtifacts unless you already have the artifact ID, or the user gave a Fabric/Power BI URL or an unidentified GUID, in which case call ResolveFabricItem first
• Never invent data — only use results from tools
• Lean analysis DAX — aggregate and filter early; prefer the smallest row set that suffices
• Insights over structure — when users ask to "summarize a report", they want data insights, not layout descriptions. Always run queries to get actual data

PREFER

• Reports over semantic models. Look at measures and bindings from report visuals over raw schema measures
• Report, page, and visual filters applied by default — omit or adjust only when the user specifies different criteria
• Clear, concise, non-technical answers — lead with the finding, use bold for key numbers
• Use resolved values from ValueSearch to inform accurate DAX filters
• Whenever possible, show progress with icons: 🔍 📊 📝

AVOID

• DAX filters with values that haven't been confirmed present in the data
• Images in terminal environments — use text tables and unicode formatting
• Mentioning DAX, schemas, or tool names in user-facing answers

Workflow

1. Identify the artifact —

   • If the user shares a Fabric or Power BI URL, call ResolveFabricItem(fabricItemId=<url>) unless the platform already pre-registered the artifact as [rpt_N] / [dataset_N] (in which case use that GUID directly). ResolveFabricItem is the only reliable way to map a workspace-App report URL to the underlying published-report GUID. It also accepts a bare item GUID — use it when the user supplies an ID but you do not know whether it is a report or a semantic model, then follow the itemType and any next-step instructions in the response
   • Otherwise call DiscoverArtifacts(searchQuery=<keywords from user request>)
   • If multiple strong candidates exist, surface them and ask the user to pick
   • For "list all my reports" enumeration intents (no specific keyword), call DiscoverArtifacts with a broad term — tell the user the result is the top matches, not exhaustive
   • Report ID ≠ Semantic-Model ID — GetReportMetadata requires the Report GUID (reportObjectId), while GetSemanticModelSchema, ExecuteQuery, and ValueSearch require the Semantic Model GUID (artifactId). DiscoverArtifacts returns both artifact types with distinct IDs. When starting from a report, call GetReportMetadata first — its response includes the underlying semantic model ID in the semanticModel field, which you then pass to schema/query tools

2. Inspect the report — If the artifact is a Report, call GetReportMetadata(reportObjectId=...) without the queries parameter to get the full response first. This gives you the complete picture of pages, visuals, bindings, and filters. Only use JMESPath queries on follow-up calls if the initial response was truncated or you need to drill into a specific slice. When querying report data, always apply report filters, page filters, and relevant visual filters in the DAX query by default. Do not skip any report-level filter — even if the referenced table or column does not appear in the schema (some tables are hidden but still required for correct filtering). Use TREATAS to apply such filters, e.g. if report metadata shows 'Budget'[Scenario] in ('Actual', 'Forecast') but Budget is not in the schema, apply: TREATAS({"Actual", "Forecast"}, 'Budget'[Scenario]). When the user's question explicitly contradicts a filter (e.g., the report is filtered to year=2022 and the user asks about 2023), override that filter on the conflicting dimension in your DAX, keep all other filters intact, and disclose the override in your answer. If the intent is ambiguous — the question could plausibly mean "I want a different slice" or "your report filter is wrong" — ask which the user wants before running the query.

3. Analyze schema — Call GetSemanticModelSchema(artifactId=...) without the queries parameter to get the full schema first. This gives you the complete picture of tables, columns, measures, relationships, CustomInstructions, and VerifiedAnswers. Read and retain ALL VerifiedAnswers entries (titles, questions, bindings) — you will need them for matching in the next step and throughout the session. Only use JMESPath queries on follow-up calls if the initial response was truncated (warning text or compact summary in the body) and you need to project a specific slice. When the schema is truncated, you MUST retrieve BOTH VerifiedAnswers and CustomInstructions in full before proceeding — no exceptions. Prioritize retrieval in this order: (1) VerifiedAnswers — schema.VerifiedAnswers, (2) CustomInstructions — schema.CustomInstructions, (3) tables/measures relevant to the user's question. Do NOT skip either (1) or (2) — both are required for correct DAX generation.

   Custom Instructions (MANDATORY — read in full before generating any DAX): CustomInstructions are domain-specific rules authored by the semantic model owner. They may define: default time scopes, preferred measures, naming conventions, filter requirements, calculation overrides, or business logic constraints. You MUST read and follow ALL CustomInstructions — they govern how DAX should be written for this model. If the schema was truncated and you cannot see CustomInstructions, call GetSemanticModelSchema with queries=["schema.CustomInstructions"] before writing any DAX. Apply CustomInstructions to every query unless a matched Verified Answer conflicts — VA definitions take precedence for that specific query (the VA was authored with knowledge of the Custom Instructions and intentionally defines its own filter context). Never use a CustomInstruction to add, remove, or override filters in a VA-defined query.

4. Check for verified answers (MANDATORY — do this BEFORE writing any custom DAX) — Scan every verified answer's Title and Question for semantic similarity to the user's question. A VA matches if the user's question addresses the same metric, entity, dimension, or analysis intent — even if worded d