Microsoft Fabric MCP server

Microsoft Fabric MCP Server

A local-first Model Context Protocol (MCP) server that provides AI agents with comprehensive access to Microsoft Fabric's public APIs, item definitions, and best practices. Documentation tools use bundled specifications without connecting to live Fabric environments; operational tools call Fabric APIs using the configured identity.

Table of Contents

• Overview
• Installation
  • IDE
    • VS Code (Recommended)
    • Manual Setup
  • Docker
• Usage
  • Getting Started
  • What can you do with the Fabric MCP Server?
    • Capacity Discovery
    • Catalog Discovery
    • Fabric Item Types & APIs
    • Resource Definitions & Schemas
    • Best Practices & Examples
    • Development Workflows
  • Workspace Metadata
  • Available Tools
    • Namespace Filtering
    • API Documentation & Best Practices
    • OneLake Data Operations
    • OneLake Security — Data Access Roles
    • OneLake Shortcuts
    • OneLake Settings
    • Core Fabric Operations
    • Jobs
    • Data Factory Operations
• Support and Reference
  • Documentation
  • Feedback and Support
  • Security
  • Data Collection
  • Contributing
  • Code of Conduct
• License

Overview

Microsoft Fabric MCP Server gives your AI agents the knowledge they need to generate robust, production-ready code for Microsoft Fabric, alongside authenticated tools for working with Fabric resources.

Key capabilities:

• Complete API Context: Full OpenAPI specifications for all supported Fabric item types
• Item Definition Knowledge: JSON schemas for every Fabric item type (Lakehouses, pipelines, semantic models, notebooks, etc.)
• Built-in Best Practices: Embedded guidance on pagination, error handling, and recommended patterns
• Local-First Documentation: Documentation tools read bundled resources locally; operational tools access Fabric under the configured identity
• Workspace Metadata Updates: Rename a known workspace or update or clear its description without changing other properties
• Data Factory Integration: Pipeline and Dataflow Gen2 management with M query execution

Installation

The manual configuration examples use mcpServers as the root object. In Visual Studio and Visual Studio Code, use servers instead.

When using the VS Code extension, fabricMcp.enabledServices selects from core, jobs, docs, onelake, and datafactory. Leave the list empty to enable all toolsets. Select both core and jobs for workflows combining item or definition operations with job submission, cancellation, instance listing/lookup, or schedule listing/creation/updates; selecting only core does not expose Jobs. If an existing setting contains publicapis, replace it with docs or clear the list; saved settings are not migrated automatically.

IDE

Start using Fabric MCP with your favorite IDE. We recommend VS Code:

VS Code (Recommended)

Compatible with both the Stable and Insiders builds of VS Code.

1. Install the GitHub Copilot Chat extension.
2. Install the Fabric MCP Server extension.

Manual Setup

Fabric MCP Server can also be configured across other IDEs, CLIs, and MCP clients:

Use one of the following options to configure your mcp.json:

Option 1: Configure using the .NET tool (NuGet)

• Install the .NET 10 SDK or later. Verify it with dotnet --version.

• Install the published Microsoft.Fabric.Mcp tool:

  dotnet tool install --global Microsoft.Fabric.Mcp --source https://api.nuget.org/v3/index.json
  

• Ensure the .NET global tools directory is on the PATH available to your MCP client, then configure mcp.json:

  {
      "mcpServers": {
          "Fabric MCP Server": {
              "command": "fabmcp",
              "args": [
                  "server",
                  "start",
                  "--mode",
                  "all"
              ],
              "type": "stdio"
          }
      }
  }
  

Alternatively, .NET 10 supports running the published package on demand with dnx, without a permanent tool installation:

dnx Microsoft.Fabric.Mcp --source https://api.nuget.org/v3/index.json -- server start --mode all

Both commands use the latest published stable package unless you specify a version. To pin a released version, use --version <version> with dotnet tool install, or Microsoft.Fabric.Mcp@<version> with dnx.

Option 2: Configure using Node.js (npm/npx)

• Install a supported Node.js LTS version 22.0.0 or later, with npm and npx available on your system PATH. Verify your installation with node --version, npm --version, and npx --version.

• Configure the mcp.json file with the following:

  {
      "mcpServers": {
          "fabric-mcp-server": {
              "command": "npx",
              "args": [
                  "-y",
                  "@microsoft/fabric-mcp@latest",
                  "server",
                  "start",
                  "--mode",
                  "all"
              ]
          }
      }
  }
  

Build from source (contributors)

Building the repository is a separate development workflow, not required to use the published packages:

git clone https://github.com/microsoft/mcp.git
cd mcp
dotnet build servers/Fabric.Mcp.Server/src/Fabric.Mcp.Server.csproj --configuration Release

Use the built servers/Fabric.Mcp.Server/src/bin/Release/fabmcp executable as your MCP client's command, with ["server", "start", "--mode", "all"] as its arguments. On Windows, use backslashes and the .exe extension.

Client-Specific Configuration

IDE	File Location	Documentation Link
Claude Code	~/.claude.json or .mcp.json (project)	Claude Code MCP Configuration
Claude Desktop	~/.claude/claude_desktop_config.json (macOS)%APPDATA%\Claude\claude_desktop_config.json (Windows)	Claude Desktop MCP Setup
Cursor	~/.cursor/mcp.json or .cursor/mcp.json	Cursor MCP Documentation
VS Code	.vscode/mcp.json (workspace)settings.json (user)	VS Code MCP Documentation
Windsurf	~/.codeium/windsurf/mcp_config.json	Windsurf Cascade MCP Integration

Docker

The published container image is available from Microsoft Container Registry as mcr.microsoft.com/fabric/fabric-mcp. Use Docker with Linux containers. The latest tag selects the most recently published image; when pinning a version, choose a tag that already exists in the registry.

The container does not inherit your host's az login session. For operational tools, configure an identity supported by the Fabric APIs you intend to call and grant it the required Fabric permissions. For example, supply a service principal using a local environment file stored outside your repository:

AZURE_TENANT_ID=<tenant-id>
AZURE_CLIENT_ID=<client-id>
AZURE_CLIENT_SECRET=<client-secret>
AZURE_TOKEN_CREDENTIALS=EnvironmentCredential

Never commit this file or put its secret values in mcp.json. See environment credential options for other supported credential settings.

Configure your MCP client, replacing the environment-file placeholder with an absolute path:

{
    "mcpServers": {
        "fabric-mcp-server": {
            "command": "docker",
            "args": [
                "run",
                "--rm",
                "-i",
                "--env-file",
                "<absolute-path-to-env-file>",
                "mcr.microsoft.com/fabric/fabric-mcp:latest",
                "--mode",
                "all"
            ]
        }
    }
}

Keep stdin open with -i, without allocating a TTY. The image entrypoint already runs server start; do not repeat those arguments after the image name.

Usage

Getting Started

1. Open GitHub Copilot in VS Code and switch to Agent mode.
2. Click refresh on the tools list
   • You should see the Fabric MCP Server in the list of tools
3. Try a prompt that uses Fabric context, such as What Fabric item types are available?
   • The agent should be able to use the Fabric MCP Server tools to complete your query
4. Check out the Microsoft Fabric documentation and review the troubleshooting guide for commonly asked questions
5. We're building this in the open. Your feedback is much appreciated!
   • Open an issue in the public repository

What can you do with the Fabric MCP Server?

The Fabric MCP Server supercharges your agents with Microsoft Fabric context. Here are some prompts you can try:

Capacity Discovery

• "List Fabric capacities where I am an administrator or contributor"
• "Show the IDs, SKUs, regions, and states of my accessible Fabric capacities"
• "Get the next page of Fabric capacities using the continuation token from the previous response"

core_list-capacities returns exactly one page of capacity metadata in capacities, with continuationToken and continuationUri when supplied by Fabric. Pass the token unchanged through --continuation-token to request another page. Returned URIs are metadata only and are never followed; the tool does not retrieve all pages automatically.

The Fabric List Capacities API lists capacities where the calling principal is an administrator or contributor. It supports users, service principals, and managed identities. Delegated calls require Capacity.Read.All or Capacity.ReadWrite.All; this is not an Azure subscription inventory and takes no subscription parameter.

Catalog Discovery

• "Search the OneLake catalog for items related to 'sales revenue'"
• "Find a Lakehouse with 'customer' in the name across my workspaces"
• "Discover all Report items in the catalog and show which workspace they live in"
• "Filter the catalog to Warehouse and Notebook items"
• "List the Fabric workspaces I can access and show their capacity and domain metadata"
• "List my Fabric workspaces where I am an Admin or Member"
• "List accessible Fabric workspaces and include their workspace-specific API endpoints"
• "List item metadata in my Fabric workspace, including nested folders"
• "Show only the Lakehouses directly in this Fabric folder"

Fabric Item Types & APIs

• "What are the available Fabric item types I can work with?"
• "Show me the OpenAPI operations for 'notebook' and give a sample creation body"
• "Get the platform-level API specifications for Microsoft Fabric"
• "List all supported Fabric item types"

Resource Definitions & Schemas

• "Create a Lakehouse resource definition with a schema that enforces a string column and a datetime column"
• "Show me the JSON schema for a Data Pipeline item definition"
• "Generate a Semantic Model configuration with sample measures"
• "What properties are required for creating a KQL Database?"

Best Practices & Examples

• "Show me best practices for handling API throttling in Fabric"
• "How should I implement retry logic for Fabric API rate limits?"
• "List recommended retry/backoff behavior for Fabric APIs when rate-limited"
• "Show me best practices for authenticating with Fabric APIs"
• "Get example request/response payloads for creating a Notebook"
• "What are the pagination patterns for Fabric REST APIs?"

Development Workflows

• "Get the metadata for Fabric item '' in workspace '' without reading its data or definition"
• "Show the display name, description, and type of Fabric item '' in workspace ''"
• "Generate a data pipeline configuration with sample data sources"
• "Help me scaffold a Fabric workspace with Lakehouse and notebooks"
• "Create a Microsoft Fabric workspace called Sales Planning"
• "Create a Fabric workspace called Capacity Analytics using the existing capacity with ID <capacity-id>"
• "Show me how to handle long-running operations in Fabric APIs"
• "What's the recommended error handling pattern for Fabric API calls?"

Workspace Metadata

Use core_get-workspace to retrieve metadata for one known workspace through the Get Workspace REST API.

• "Get metadata for Fabric workspace aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa."
• "Show the capacity, domain, and workspace identity for Fabric workspace aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa."
• "Get Fabric workspace aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa with workspace-specific API and OneLake endpoints."

Argument	Required	Description
workspace-id	Yes	Nonempty workspace UUID, not a name or URL. Accepted UUID representations are normalized before the request.
prefer-workspace-specific-endpoints	No	Boolean endpoint preference. Omit to preserve the service default, or explicitly pass true or false.

fabmcp core get-workspace --workspace-id aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa
fabmcp core get-workspace --workspace-id aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa --prefer-workspace-specific-endpoints true

The result contains a workspace object with id and displayName. When returned by Fabric it also includes type, description, capacityId, capacityAssignmentProgress, capacityRegion, domainId, workspaceIdentity, oneLakeEndpoints, apiEndpoint, and applied tags. Missing/null optional fields are omitted; an explicitly empty tag list remains empty. New workspace types, capacity regions, and progress values are preserved.

Workspace identity fields contain application and service-principal IDs, not credentials. Returned endpoints are metadata only: this tool never contacts them. Workspaces with public access disabled may return workspace-specific OneLake endpoints even when the preference is omitted or false; an absent API endpoint is not inferred.

The tool does not list workspaces or items, read item data or definitions, modify resources, or poll capacity assignments. Errors retain their HTTP status without exposing backend bodies. A 429 includes validated Retry-After guidance when available, but the tool does not automatically retry.

Permissions: The caller needs Viewer-or-higher workspace access. Delegated callers also need Workspace.Read.All or Workspace.ReadWrite.All. The API supports users, service principals, and managed identities subject to their permissions and Fabric configuration. The tool preserves the server's configured credentials: stdio/hosting identity uses the host's credential provider, and HTTP/OBO uses the current caller's delegated context.

By default, the MCP text response contains the command envelope with results.workspace. With --structured-output-mode compact or --structured-output-mode duplicated, the server also advertises the typed output schema and returns structuredContent.workspace.

Available Tools

The Fabric MCP Server exposes core, jobs, docs, onelake, and datafactory areas.