Skip to main content
Glama

commit_workspace_to_git

Exports a Fabric workspace and commits its reports and semantic models as PBIP files to a local Git repository for backup and version control.

Instructions

Export and commit a Fabric workspace into a local Git repository.

Use this tool when the user asks to:

  • Back up or version-control a Fabric workspace into Git.

  • Snapshot reports and semantic models into local PBIP files with Git commits.

Args: workspace_id: Source Fabric workspace ID (UUID). output_repo_path: Local path to destination Git repository. branch: Git branch to commit into. commit_message: Commit message describing the snapshot. exclude_items: Optional list of item IDs to exclude. auth_mode: Optional auth mode ("interactive", "service_principal", "managed_identity"). tenant_id: Optional Azure AD tenant ID. client_id: Optional Azure AD client ID. dry_run: If True, inspect items without creating git commits. fabric_client: Optional injected bridge/client (for testing).

Returns: Dict with committed items, commit SHA, and repository status.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "workspace_id": "<workspace_id>",
      "output_repo_path": "<output_repo_path>"
    },
    "name": "commit_workspace_to_git"
  }
}

Input Schema

NameRequiredDescriptionDefault
branchNo
dry_runNo
auth_modeNo
client_idNo
tenant_idNo
workspace_idYes
exclude_itemsNo
fabric_clientNo
commit_messageNo
output_repo_pathYes

Output Schema

NameRequiredDescriptionDefault

No arguments

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed4 schema fields changedv1.25.1
    • addedInput schema / properties / auth_mode
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Auth Mode"
      +}
    • addedInput schema / properties / client_id
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Client Id"
      +}
    • addedInput schema / properties / fabric_client
      Added value: +{
      +  "default": null,
      +  "title": "Fabric Client"
      +}
    • addedInput schema / properties / tenant_id
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Tenant Id"
      +}
  2. First observedv0.1.0

TDQS

A3.5/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are supplied, so the description carries the full behavioral burden. It does disclose the dry_run inspection mode and the return payload (committed items, commit SHA, repo status), but omits whether the destination repo must already exist, branch-creation behavior, what local files get overwritten, and what permissions or auth each auth_mode requires for a mutating Git operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Well front-loaded: purpose sentence first, then usage bullets, then Args, then Returns. The Args block is long but standard and each entry is a single line; the Returns section is mild duplication given an output schema exists, but nothing is padded with filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 10-parameter, unannotated mutating tool, the definition covers purpose, usage and every parameter, and an output schema covers the return shape. What is missing is the operational context an agent needs before invoking: auth/permission prerequisites, required local repo state, and the fact that the default dry_run=true makes the call a no-op for Git.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description compensates by documenting all ten parameters in an Args block, including the enumerated auth_mode values ("interactive", "service_principal", "managed_identity") and the testing-only nature of fabric_client — information the schema does not convey. Some entries remain thin (branch does not say the default-branch fallback), which keeps it from a 5.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

"Export and commit a Fabric workspace into a local Git repository" gives a specific verb pair and a clear direction of flow (workspace → Git), which implicitly contrasts with the reverse-direction sibling sync_git_to_workspace. It stops short of naming that sibling or stating the contrast explicitly, so it is clear but not fully differentiated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Three bullets state when to use it (backup/version-control, snapshot reports and semantic models to PBIP), which is real usage guidance. There is no when-not-to-use guidance and no routing to the inverse tool, and it never warns that dry_run defaults to true, so a naive caller may believe commits happened when nothing was written.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.