Fabric实时智能MCP

Prerequisites

1. Install either the stable or Insiders release of VS Code: 💫 Stable release 🔮 Insiders release 2. Install the GitHub Copilot and GitHub Copilot Chat extensions 3. Install uv

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

1. Open VS Code in an empty folder

Required Environment Variables

None - the server will work with default settings for demo purposes.

Getting Started

Install from PyPI (Pip)

The Fabric RTI MCP Server is available on PyPI, so you can install it using pip. This is the easiest way to install the server.

#### From VS Code 1. Open the command palette (Ctrl+Shift+P) and run the command MCP: Add Server 2. Select install from Pip 3. When prompted, enter the package name microsoft-fabric-rti-mcp 4. Follow the prompts to install the package and add it to your settings.json or your mcp.json file

The process should end with the below settings in your settings.json or your mcp.json file.

#### settings.json

{
    "mcp": {
        "servers": {
            "fabric-rti-mcp": {
                "command": "uvx",
                "args": [
                    "microsoft-fabric-rti-mcp"
                ],
                "env": {
                    "KUSTO_SERVICE_URI": "https://help.kusto.windows.net/",
                    "KUSTO_SERVICE_DEFAULT_DB": "Samples",
                    "FABRIC_API_BASE": "https://api.fabric.microsoft.com/v1"
                }
            }
        }
    }
}

Note: All environment variables are optional. The KUSTO_SERVICE_URI and KUSTO_SERVICE_DEFAULT_DB provide default cluster and database settings. The AZ_OPENAI_EMBEDDING_ENDPOINT is only needed for semantic search functionality in the kusto_get_shots tool.

From GitHub Copilot CLI

Use the interactive command within a GitHub Copilot CLI session:

/mcp add

Or manually add to your ~/.copilot/mcp-config.json:

{
    "mcpServers": {
        "fabric-rti-mcp": {
            "command": "uvx",
            "args": [
                "microsoft-fabric-rti-mcp"
            ],
            "env": {
                "KUSTO_SERVICE_URI": "https://help.kusto.windows.net/",
                "KUSTO_SERVICE_DEFAULT_DB": "Samples",
                "FABRIC_API_BASE": "https://api.fabric.microsoft.com/v1"
            }
        }
    }
}

For more information, see the GitHub Copilot CLI documentation.

🔧 Manual Install (Install from source)

1. Make sure you have Python 3.10+ installed properly and added to your PATH.
2. Clone the repository
3. Install the dependencies (pip install . or uv tool install .)
4. Add the settings below into your vscode settings.json or your mcp.json file.
5. Modify the path to match the repo location on your machine.
6. Modify the cluster uri in the settings to match your cluster.
7. Modify the cluster default database in the settings to match your database.
8. Modify the embeddings endpoint in the settings to match yours. This step is optional and needed only in case you supply a shots table

{
    "mcp": {
        "servers": {
            "fabric-rti-mcp": {
                "command": "uv",
                "args": [
                    "--directory",
                    "C:/path/to/fabric-rti-mcp/",
                    "run",
                    "-m",
                    "fabric_rti_mcp.server"
                ],
                "env": {
                    "KUSTO_SERVICE_URI": "https://help.kusto.windows.net/",
                    "KUSTO_SERVICE_DEFAULT_DB": "Samples",
                    "FABRIC_API_BASE": "https://api.fabric.microsoft.com/v1"
                }
            }
        }
    }
}

Install locally

pip install -e ".[dev]"

Remote Deployment

The MCP server can be deployed using the method of your choice. For example, you can follow the guide at https://github.com/Azure-Samples/mcp-sdk-functions-hosting-python/blob/main/ExistingServer.md to deploy the MCP server to an Azure Function App.

🔍 Example Prompts

Eventhouse Analytics: - "Get databases in my Eventhouse" - "Sample 10 rows from table 'StormEvents' in Eventhouse" - "What can you tell me about StormEvents data?" - "Analyze the StormEvents to come up with trend analysis across past 10 years of data" - "Analyze the commands in 'CommandExecution' table and categorize them as low/medium/high risks" - "Before running this query, check the execution plan and tell me if it's expensive" - "Compare these two query approaches and tell me which is more efficient" - "Check the cluster health — do we have enough capacity for a heavy analytics job?"

Eventstream Management: - "List all Eventstreams in my workspace" - "Show me the details of my IoT data Eventstream" - "Create a new Eventstream for processing sensor data" - "Update my existing Eventstream to add a new destination"

Activator Alerts: - "Using the StormEvents table, notify me via email when there is a flood in Illinois" - "Create a teams alert to notify me when my success rate drops below 95%" - "List all Activator artifacts in my workspace"

Map Visualization: - "List all Map items in my workspace" - "Create a new Map and add LakeHouse with name 'MyLakeHouse' as a data source to Map item 'MyMap'" - "Delete a Map item with name 'MyMap' from my workspace"

Example from test_kusto_tools_live_http.py

auth_header = f"Bearer {token.token}"

headers = { "Content-Type": "application/json", "Accept": "application/json, text/event-stream", "Authorization": auth_header, } ```

Configure

Follow the Manual Install instructions.

⚙️ Configuration

The MCP server can be configured using the following environment variables:

Optional Environment Variables

Embedding Endpoint Configuration

The AZ_OPENAI_EMBEDDING_ENDPOINT is used by the semantic search functionality (e.g., kusto_get_shots function) to find similar query examples.

Format Requirements:

https://{your-openai-resource}.openai.azure.com/openai/deployments/{deployment-name}/embeddings?api-version={api-version};impersonate

Components: - {your-openai-resource}: Your Azure OpenAI resource name - {deployment-name}: Your text embedding deployment name (e.g., text-embedding-ada-002) - {api-version}: API version (e.g., 2024-10-21, 2023-05-15) - ;impersonate: Authentication method (you might use managed identity)

Authentication Requirements: - Your Azure identity must have access to the OpenAI resource - In case of using managed identity, the OpenAI resource must be configured to accept managed identity authentication - The deployment must exist and be accessible

Configuration of Shots Table

The kusto_get_shots tool retrieves shots that are most similar to your prompt from the shots table. This function requires configuration of: - Shots table: Should have an "EmbeddingText" (string) column containing the natural language prompt, "AugmentedText" (string) column containing the respective KQL, and "EmbeddingVector" (dynamic) column containing the embedding vector of the EmbeddingText. - Azure OpenAI embedding endpoint: Used to create embedding vectors for your prompt. Note that this endpoint must use the same model that was used for creating the "EmbeddingVector" column in the shots table.

HTTP Mode Configuration for MCP Server

When the MCP server is running locally to the agent in HTTP mode or is deployed to Azure, the following environment variables are used to define and enable HTTP mode. You can find practical examples of this setup in the tests/live/test_kusto_tools_live_http.py file:

HTTP clients connecting to the server need to include the appropriate authentication token in the request headers:

```python