Microsoft Fabric RTI MCP Server
OfficialThis server enables AI agents to interact with Microsoft Fabric Real-Time Intelligence (RTI) services — including Eventhouse, Eventstreams, Activator, and Maps — for data querying, stream management, alerting, and geospatial visualization via the Model Context Protocol (MCP).
Eventhouse (Kusto) — Query & Analytics
Execute KQL queries and management commands (
.show,.create,.alter,.drop)List and describe entities: databases, tables, external tables, materialized views, functions, graphs
Execute graph queries; sample data from tables, views, or functions
Ingest inline CSV data into a specified table
Semantically search for similar KQL query examples using Azure OpenAI embeddings
Generate deep-link URLs to open queries in ADX or Fabric query workbench
Retrieve query execution plans and run cluster diagnostics
List all known/configured Kusto services
Eventstreams — Real-Time Stream Management
List, get, create, update, and delete Eventstreams
Build Eventstreams interactively via a session-based builder:
Add sample data or custom endpoint sources
Add derived streams and Eventhouse/custom endpoint destinations
Validate definitions before deployment and create from completed definitions
List available Eventstream components
Activator — Real-Time Alerting
List existing Activator artifacts in a workspace
Create triggers that monitor KQL queries and send email or Microsoft Teams notifications with configurable polling frequency
Maps — Geospatial Visualization
List, get, create, update (partial or full definition), and delete Map items
Authentication & Configuration
Integrates with Azure Identity via
DefaultAzureCredential(supports environment variables, Azure CLI, Visual Studio, interactive browser, OBO token exchange, and more)Highly configurable via environment variables (Kusto cluster defaults, Fabric API URLs, allowed tools, embedding endpoints, KQL shots table, etc.)
Supports a KQL Copilot Skill providing AI agents with deep KQL expertise for writing, debugging, and reviewing queries
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Microsoft Fabric RTI MCP Server Analyze the StormEvents table for trends over the past year"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
🎯 Overview
A comprehensive Model Context Protocol (MCP) server implementation for Microsoft Fabric Real-Time Intelligence (RTI). This server enables AI agents to interact with Fabric RTI services by providing tools through the MCP interface, allowing for seamless data querying, analysis, and streaming capabilities.
This project is in Public Preview and implementation may significantly change prior to General Availability.
🔍 How It Works
The Fabric RTI MCP Server acts as a bridge between AI agents and Microsoft Fabric RTI services:
🔄 MCP Protocol: Uses the Model Context Protocol to expose Fabric RTI capabilities as tools
🏗️ Natural Language to KQL: AI agents can translate natural language requests into KQL queries and Eventstream management
💡 Secure Authentication: Leverages Azure Identity for seamless, secure access to your resources
⚡ Real-time Data Access: Direct connection to Eventhouse and Eventstreams for live data analysis
📊 Unified Interface: For both analytics and streaming workloads with intelligent parameter suggestions
✨ Supported Services
Eventhouse (Kusto): Execute KQL queries against Microsoft Fabric RTI Eventhouse and Azure Data Explorer (ADX).
Eventstreams: Manage Microsoft Fabric Eventstreams for real-time data processing:
List Eventstreams in workspaces
Get Eventstream details and definitions
Create new Eventstreams
Update existing Eventstreams
Delete Eventstreams
Activator: Create and manage Microsoft Fabric Activator triggers for real-time alerting:
Create new triggers with KQL source monitoring
Set up email and Teams notifications when a condition occurs
List Activator artifacts in workspaces
Map: Create and manage Microsoft Fabric Map to visualize geospatial data:
Create a new map from a provided configuration
Visualize data on maps
List Map items in workspaces
Delete Map items
🧠 Copilot Skills
This repository includes a KQL Copilot Skill (.github/skills/kql/) that gives AI agents deep KQL expertise when writing, debugging, or reviewing Kusto queries. The skill covers:
Syntax gotchas and self-correction patterns for common KQL errors
Dynamic type discipline, join patterns, datetime pitfalls
Memory-safe query patterns and result-size discipline
Advanced functions: graph queries, vector similarity, geospatial operations, time series
Query templates for deduplication, top-N, sessionization, pivoting, and more
Full error-to-fix mapping for rapid recovery
The skill references the Fabric RTI MCP tools (kusto_query, kusto_command, kusto_sample_entity, etc.) so agents know how to execute queries through this MCP server.
Related MCP server: Microsoft Fabric MCP Server
🚧 Coming soon
Other RTI items
🔍 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"
Available tools
Eventhouse (Kusto) - 13 Tools + 1 Optional:
kusto_known_services- List all available Kusto services configured in the MCPkusto_query- Execute KQL queries on the specified databasekusto_command- Execute Kusto management commands (.show,.create,.alter,.drop)kusto_list_entities- List entities (databases, tables, external tables, materialized views, functions, graphs) in a cluster or databasekusto_describe_database- Get schema information for all entities in a databasekusto_describe_database_entity- Get detailed schema for a specific entity (table, external table, materialized view, function, graph)kusto_graph_query- Execute graph queries using snapshots or transient graphskusto_sample_entity- Retrieve sample records from a table, external table, materialized view, or functionkusto_ingest_inline_into_table- Ingest inline CSV data into a specified tablekusto_get_shots(whenKUSTO_SHOTS_TABLEis configured) - Find semantically similar saved KQL queries using local SLM or Azure OpenAI embeddingskusto_deeplink_from_query- Generate a deeplink URL to open a KQL query in Azure Data Explorer Web Explorer or Microsoft Fabric query workbenchkusto_show_queryplan- Retrieve the execution plan for a KQL query without running it. Returns planning stats (PlanSize, RelopSize), the logical operator tree, and execution hints (estimated row counts, concurrency/spread hints, per-shard scan info with filter detection). Useful for comparing query approaches, catching expensive joins, and validating query syntax before execution.kusto_diagnostics- Run a best-effort suite of cluster diagnostic commands and return a unified summary. Sections: capacity (resource slots), cluster (nodes/hardware), principal roles (caller permissions), internal diagnostics (health/utilization), workload groups, rowstores, and ingestion failures (last 24h). Each section runs independently — permission failures on one section don't block others.
Eventstreams - 17 Tools:
Core Operations (6 tools):
eventstream_list- List all Eventstreams in your Fabric workspaceeventstream_get- Get detailed information about a specific Eventstreameventstream_get_definition- Retrieve complete JSON definition of an Eventstreameventstream_create- Create new Eventstreams with custom configuration (auto-includes default stream)eventstream_update- Modify existing Eventstream settings and destinationseventstream_delete- Remove Eventstreams and associated resources
Builder Tools (11 tools):
Session Management:
eventstream_start_definition,eventstream_get_current_definition,eventstream_clear_definitionSources:
eventstream_add_sample_data_source,eventstream_add_custom_endpoint_sourceStreams:
eventstream_add_derived_streamDestinations:
eventstream_add_eventhouse_destination,eventstream_add_custom_endpoint_destinationValidation:
eventstream_validate_definition,eventstream_create_from_definition,eventstream_list_available_components
💡 Pro Tip: All tools work with natural language! Just describe what you want to do and the AI agent will use the appropriate tools automatically.
Activator - 2 Tools:
activator_list_artifacts- List all Activator artifacts in a Fabric workspaceactivator_create_trigger- Create new Activator triggers with KQL source monitoring and email/Teams alerts
Map - 7 Tools:
map_list- List all Map items in your Fabric workspacemap_get- Get detailed information about a specific Map itemmap_get_definition- Retrieve the full JSON definition of a Map itemmap_create- Create a new Map item from a provided configurationmap_update_definition- Replace the full JSON definition of an existing Map itemmap_update- Partially update properties of an existing Map itemmap_delete- Delete a Map item and its associated configuration
Getting Started
Prerequisites
Install either the stable or Insiders release of VS Code:
Install the GitHub Copilot and GitHub Copilot Chat extensions
Install
uv
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"or, check here for other install options
Open VS Code in an empty folder
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 fileThe 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_URIandKUSTO_SERVICE_DEFAULT_DBprovide default cluster and database settings.AZ_OPENAI_EMBEDDING_ENDPOINTconfigures the default AOAI embedding method used bykusto_get_shots.
From GitHub Copilot CLI
Use the interactive command within a GitHub Copilot CLI session:
/mcp addOr 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)
Make sure you have Python 3.10+ installed properly and added to your PATH.
Clone the repository
Install the dependencies (
pip install .oruv tool install .)Add the settings below into your vscode
settings.jsonor yourmcp.jsonfile.Modify the path to match the repo location on your machine.
Modify the cluster uri in the settings to match your cluster.
Modify the cluster default database in the settings to match your database.
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"
}
}
}
}
}🐛 Debugging the MCP Server locally
Assuming you have python installed and the repo cloned:
Install locally
pip install -e ".[dev]"Configure
Follow the Manual Install instructions.
Attach the debugger
Start the MCP server normally from the client that will invoke its tools, then set a breakpoint on an executable line. If you changed the Python source after the server started, restart the MCP server before attaching.
Option 1: Attach by process ID
Press F5 and select Python Debugger: Attach by Process ID. VS Code needs the PID of the Python process that is
running -m fabric_rti_mcp.server. You can identify it in either of these ways:
VS Code process picker: Select the matching Python process from the list. If several related processes are shown, select the deepest Python child running
-m fabric_rti_mcp.server, not theuvwrapper.Manual PID lookup: If VS Code asks you to enter a PID instead of displaying the process list, find it with Task Manager or PowerShell:
In Task Manager, open Details, enable the PID and Command line columns, and locate the matching
python.exeprocess.In PowerShell, run:
$servers = @(Get-CimInstance Win32_Process | Where-Object { $_.Name -eq "python.exe" -and $_.CommandLine -match "-m\s+fabric_rti_mcp\.server" }) $servers | Where-Object { $_.ProcessId -notin $servers.ParentProcessId } | Sort-Object CreationDate -Descending | Select-Object -First 1 ProcessId, CommandLine
Enter the returned
ProcessIdin the VS Code prompt.
On newer Windows versions, wmic.exe is disabled or removed. Some Python debugger versions still use it to
populate the process picker, causing process enumeration to fail. The manual methods above do not require WMIC.
Option 2: Inject debugpy and attach on port 5678
This repository includes the Python Debugger: Attach to Fabric RTI MCP launch configuration and its
Inject debugger into Fabric RTI MCP pre-launch task. This Windows-specific option uses PowerShell to find the
deepest Fabric RTI MCP Python process, inject debugpy, and connect VS Code to 127.0.0.1:5678.
Ensure the MCP server is already running.
Press F5 and select
Python Debugger: Attach to Fabric RTI MCP.Wait for the VS Code debug toolbar to appear.
Invoke the target tool from the same MCP client session that started the attached server.
Do not add debugpy --listen to the MCP server command. Some clients may start or reconnect to the command more
than once, which can cause port collisions. If multiple MCP client sessions are running, close the unrelated
sessions first so the debugger attaches to the intended server process.
🧪 Test the MCP Server
Via GitHub Copilot
Open GitHub Copilot in VS Code and switch to Agent mode
You should see the Fabric RTI MCP Server in the list of tools
Try prompts that tell the agent to use the RTI tools, such as:
Eventhouse: "List my Kusto tables" or "Show me a sample from the StormEvents table"
Eventstreams: "List all Eventstreams in my workspace" or "Show me details of my data processing Eventstream"
The agent should be able to use the Fabric RTI MCP Server tools to complete your query
⚙️ Configuration
The MCP server can be configured using the following environment variables:
Required Environment Variables
None - the server will work with default settings for demo purposes.
Optional Environment Variables
Variable | Service | Description | Default | Example |
| Kusto | Default Kusto cluster URI | None |
|
| Kusto | Default database name for Kusto queries |
|
|
| Kusto | Azure OpenAI endpoint used when | None |
|
| Kusto | JSON array of preconfigured Kusto services | None |
|
| Kusto | Whether to eagerly connect to default service on startup (not recommended) |
|
|
| Kusto | Security setting to allow connections to services not in |
|
|
| Kusto | Enable | None |
|
| Kusto | Default embedding method for |
|
|
| Kusto | Default SLM model for |
|
|
| Global | Base URL for Microsoft Fabric API |
|
|
| Global | Base URL for Microsoft Fabric web interface |
|
|
| Global | Comma-separated service names or full tool names to expose | All tools |
|
| Kusto | Override auto-detection of deeplink style | None |
|
FABRIC_RTI_ALLOWED_TOOLS accepts service names derived from the registered *_tools modules and full tool names.
Shots Embedding Configuration
All supported AOAI and SLM embedding paths return L2-normalized vectors. kusto_get_shots uses their known unit
magnitudes when calculating cosine similarity to avoid recalculating vector magnitudes for every shot. Custom or
manually generated EmbeddingVector values must therefore also be L2-normalized.
SLM embeddings
kusto_get_shots defaults to Azure OpenAI embeddings for backward compatibility. To use local SLM embeddings,
set embedding_method to slm for an individual call, or set KUSTO_SHOTS_EMBEDDING_METHOD=slm for the MCP
server. Configure the server's default model with KUSTO_SHOTS_SLM_MODEL; it defaults to
harrier-v1-270m. Explicit tool arguments override these server defaults. The queried database must contain a
pre-deployed slm_embeddings_fl function. Follow the SLM embeddings function documentation
and select either Azure Data Explorer or Microsoft Fabric from the Version selector in the left pane
for the correct deployment instructions.
The documented slm_embeddings_fl implementation supports:
Model | Vector dimensions |
| 512 |
| 384 |
| 640 |
Example SLM arguments:
{
"prompt": "Find a few storm events in Texas",
"cluster_uri": "https://mycluster.westus.kusto.windows.net",
"database": "MyDatabase",
"shots_table_name": "Shots",
"embedding_method": "slm",
"slm_model_name": "harrier-v1-270m"
}The SLM prompt is embedded with the query: prefix. The table's EmbeddingVector values must use the same model and vector dimension; for retrieval models, embed the stored EmbeddingText corpus with the corresponding passage: convention.
The MCP tool does not deploy the function or migrate existing shot vectors.
Azure OpenAI embeddings
AOAI is the default embedding method. Follow the AI embeddings plugin documentation and select either Azure Data Explorer or Microsoft Fabric from the Version selector in the left pane for the applicable setup instructions.
Example AOAI arguments:
{
"prompt": "Find a few storm events in Texas",
"cluster_uri": "https://mycluster.westus.kusto.windows.net",
"database": "MyDatabase",
"shots_table_name": "Shots",
"embedding_method": "aoai",
"embedding_endpoint": "https://your-resource.openai.azure.com/openai/deployments/text-embedding-ada-002/embeddings?api-version=2024-10-21;impersonate"
}If embedding_endpoint isn't supplied, AOAI calls use AZ_OPENAI_EMBEDDING_ENDPOINT.
Format Requirements:
https://{your-openai-resource}.openai.azure.com/openai/deployments/{deployment-name}/embeddings?api-version={api-version};impersonateComponents:
{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.
Matching embeddings: The prompt and
EmbeddingVectorcolumn must use the same provider, model, vector dimension, and compatible query/corpus conventions.
Existing AOAI calls remain backward compatible. When embedding_method="slm" is selected, embedding_endpoint is ignored.
🔑 Authentication
In stdio mode (local), the MCP Server integrates with your host operating system's authentication mechanisms.
We use Azure Identity via DefaultAzureCredential, which tries these authentication methods in order:
Environment Variables (
EnvironmentCredential) - Perfect for CI/CD pipelinesVisual Studio (
VisualStudioCredential) - Uses your Visual Studio credentialsAzure CLI (
AzureCliCredential) - Uses your existing Azure CLI loginAzure PowerShell (
AzurePowerShellCredential) - Uses your Az PowerShell loginAzure Developer CLI (
AzureDeveloperCliCredential) - Uses your azd loginInteractive Browser (
InteractiveBrowserCredential) - Falls back to browser-based login if needed
If you're already logged in through any of these methods, the Fabric RTI MCP Server will automatically use those credentials in stdio mode.
This MCP server is not intended to be exposed directly as a production HTTP endpoint.
If you choose to run it over HTTP, the deployment must provide its own security boundary before requests reach this server.
For example, put any Entra-aware authentication layer in front of it.
The HTTP configuration options below are guardrails and local-development conveniences; they are not a substitute for a production authentication boundary.
By default, HTTP requests must provide an Authorization bearer token; the server performs deployment-agnostic bearer token shape screening and forwards the bearer to downstream Fabric/Kusto services, or exchanges it with OBO when OBO is enabled.
It does not perform cryptographic Entra JWT signature, issuer, tenant, or audience validation.
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:
Variable | Description | Default | Example |
| Transport mode for the server |
|
|
| Host address for HTTP server |
|
|
| Port for HTTP server |
|
|
| HTTP path for MCP endpoint |
|
|
| Whether to use stateless HTTP mode |
|
|
| Allow HTTP requests without a bearer to use Managed Identity |
|
|
| Local HTTP testing mode that allows local process credentials and permissive CORS |
|
|
| Host allow-list for HTTP DNS-rebinding protection | empty |
|
| Origin allow-list for HTTP DNS-rebinding protection | empty |
|
| CORS origins. If unset, HTTP uses loopback origins; debug mode uses | empty |
|
| Filter |
|
|
HTTP credential behavior:
Mode | Behavior |
Default HTTP | Requires a bearer token. No local process credentials are used when the bearer is missing. |
| Exchanges the request bearer for the configured Fabric/Kusto audience. Forged tokens fail the OBO exchange. |
| Allows missing bearer tokens and uses |
| Restores local HTTP testing convenience with local process credentials, permissive CORS, and unsafe non-loopback binds. Do not use in production. |
Binding HTTP to a non-loopback address such as 0.0.0.0 exposes the MCP listener outside the local process boundary.
Non-loopback HTTP without an explicit host allow-list is allowed only in FABRIC_RTI_HTTP_DEBUG_MODE.
This exception is for local testing only; it does not make direct HTTP exposure production-safe.
HTTP clients connecting to the server need to include the appropriate authentication token in the request headers unless FABRIC_RTI_HTTP_ALLOW_MI or FABRIC_RTI_HTTP_DEBUG_MODE is explicitly enabled:
# 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,
}OBO Flow Authentication
If your scenario involves a user token with a non-Kusto audience and you need to exchange it for a Kusto audience token using the OBO flow, the Fabric RTI MCP Server can handle this exchange automatically by setting the following environment variables:
Variable | Description | Default | Example |
| Enable OBO flow for token exchange |
|
|
| Azure AD tenant ID |
|
|
| Entra App (AAD) Client ID | Your client ID | |
| User Managed Identity Client ID | Your UMI client ID |
This flow is typically used in OAuth scenarios where a gateway like Azure API Management (APIM) is involved (example: https://github.com/ai-microsoft/adsmcp-apim-dual-validation?tab=readme-ov-file). The user authenticates via Entra ID, and APIM forwards the token to the MCP server. The token audience is not Kusto, so the MCP server must perform an OBO token exchange to get a token with the Kusto audience. To support this setup, your Microsoft Entra App must be configured to use Federated Credentials following the official guide: https://learn.microsoft.com/en-us/entra/workload-id/workload-identity-federation. This enables the app to exchange tokens (OBO). Additionally, the Entra app must be granted Azure Data Explorer API permissions to successfully acquire an OBO token with the Kusto audience.
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.
🛡️ Security Note
Your credentials are always handled securely through the official Azure Identity SDK - we never store or manage tokens directly.
MCP as a phenomenon is very novel and cutting-edge. As with all new technology standards, consider doing a security review to ensure any systems that integrate with MCP servers follow all regulations and standards your system is expected to adhere to. This includes not only the Azure MCP Server, but any MCP client/agent that you choose to implement down to the model provider.
You should follow Microsoft security guidance for MCP servers, including enabling Entra ID authentication, secure token management, and network isolation. Refer to Microsoft Security Documentation for details.
👥 Contributing
This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.
When you submit a pull request, a CLA bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.
Permissions and Risk
MCP clients can invoke operations based on the user’s Fabric Role-Based Access Control (RBAC) permissions. Autonomous or misconfigured clients may perform destructive actions. You should review and apply least-privilege RBAC roles and implement safeguards before deployment. Certain safeguards, such as flags to prevent destructive operations, are not standardized in the MCP specification and may not be supported by all clients.
Compliance Responsibility
This MCP server may be installed, used and share data with clients and services, such as third party LLMs, AI agents or services that operate outside Fabric’s compliance boundaries. You are responsible for ensuring that any integration complies with applicable organizational, regulatory, and contractual requirements.
Third Party Components
This MCP server may use or depend on third party components. You are responsible for reviewing and complying with the licenses and security posture of any third-party components.
Export Control
Use of this software must comply with all applicable export laws and regulations, including U.S. Export Administration Regulations and local jurisdiction requirements.
No Warranty / Limitation of Liability
This software is provided “as is” without warranties or conditions of any kind, either express or implied. Microsoft shall not be liable for any damages arising from use, misuse, or misconfiguration of this software.
🤝 Code of Conduct
This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.
📚 Documentation
Changelog - Release history and breaking changes
Contributing - Contribution guidelines
Data Collection
The software may collect information about you and your use of the software and send it to Microsoft. Microsoft may use this information to provide services and improve our products and services. You may turn off the telemetry as described in the repository. There are also some features in the software that may enable you and Microsoft to collect data from users of your applications. If you use these features, you must comply with applicable law, including providing appropriate notices to users of your applications together with a copy of Microsoft’s privacy statement. Our privacy statement is located at https://go.microsoft.com/fwlink/?LinkID=824704. You can learn more about data collection and use in the help documentation and our privacy statement. Your use of the software operates as your consent to these practices.
Trademarks
This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft trademarks or logos is subject to and must follow Microsoft's Trademark & Brand Guidelines. Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship. Any use of third-party trademarks or logos are subject to those third-party's policies.
Available Tools
39 toolsactivator_create_triggerADestructive
Use this tool create an alert that will fire when the source generates data.
:param workspace_id: The workspace ID (UUID)
:param trigger_name: Name of the trigger
:param kql_cluster_url: The KQL cluster URL
:param kql_database: The KQL database name
:param kql_query: The KQL query to monitor. The query MUST be appropriate for the schema of the underlying
data, otherwise the alert will not function correctly
:param alert_recipient: Email address of the alert recipient
:param alert_message: Alert message for the trigger
:param alert_headline: Alert headline for the trigger
:param alert_type: Type of alert - "teams" or "email" (defaults to "teams")
:param kql_polling_frequency_minutes: Polling frequency in minutes. Must be one of: 5, 15, 60, 180, 360, 720,
1440 (defaults to 5)
:param artifact_id: If specified, the trigger will be created in the specified Activator artifact.
If left blank, a new Activator artifact will be created.
:return: Created trigger details:
* url: URL back to the trigger in Fabric UI for further management
* id: Artifact ID if a new one was created
* displayName: Name of newly created trigger
Critical:
* This API call will NOT tell the caller if a KQL query is used which does not match the source data schema,
so any KQL query should be double-checked upfront.
Inputs: kql_query (required), kql_database (required), trigger_name (required), workspace_id (required), +7 more. Returns: object
activator_list_artifactsBRead-only
Use this tool to list all Activator artifacts in a workspace.
:param workspace_id: The workspace ID (UUID)
:return: List of activator artifacts
Inputs: workspace_id (required). Returns: result
eventstream_add_custom_endpoint_destinationB
Add a custom endpoint destination to the eventstream definition.
:param session_id: Builder session ID
:param input_streams: List of stream names that feed this destination
:param destination_name: Name for the destination (auto-generated if not provided)
:param endpoint_url: Custom endpoint URL (deprecated - use data connections instead)
:param method: HTTP method (deprecated)
:param headers: Optional HTTP headers (deprecated)
:return: Updated definition summary
Inputs: session_id (required), input_streams (required), method, headers, +2 more. Returns: object
eventstream_add_custom_endpoint_sourceA
Add a custom endpoint source to the eventstream definition.
:param session_id: Builder session ID
:param source_name: Name for the source (auto-generated if not provided)
:param endpoint_url: Custom endpoint URL (deprecated - use data connections instead)
:return: Updated definition summary
Inputs: session_id (required), source_name, endpoint_url. Returns: object
eventstream_add_derived_streamA
Add a derived stream to the eventstream definition.
:param session_id: Builder session ID
:param stream_name: Name for the stream
:param input_nodes: List of node names (sources, operators, or other streams) that feed this stream.
If None and only one stream exists, automatically connects to that stream.
:return: Updated definition summary
Inputs: session_id (required), stream_name (required), input_nodes. Returns: object
eventstream_add_eventhouse_destinationB
Add an Eventhouse destination to the eventstream definition.
:param session_id: Builder session ID
:param workspace_id: Fabric workspace ID
:param item_id: Eventhouse item ID
:param database_name: Target database name
:param table_name: Target table name
:param input_streams: List of stream names that feed this destination
:param destination_name: Name for the destination (auto-generated if not provided)
:param data_ingestion_mode: Ingestion mode (ProcessedIngestion or DirectIngestion)
:param encoding: Input encoding
:return: Updated definition summary
Inputs: item_id (required), session_id (required), table_name (required), workspace_id (required), +5 more. Returns: object
eventstream_add_sample_data_sourceA
Add a sample data source to the eventstream definition.
:param session_id: Builder session ID
:param sample_type: Type of sample data (Bicycles, Stock, etc.)
:param source_name: Name for the source (auto-generated if not provided)
:return: Updated definition summary
Inputs: session_id (required), sample_type, source_name. Returns: object
eventstream_clear_definitionADestructive
Clear the current eventstream definition and start over.
:param session_id: Builder session ID
:return: Confirmation of clearing
Inputs: session_id (required). Returns: object
eventstream_createADestructive
Create an Eventstream item in Microsoft Fabric.
Authentication is handled transparently using Azure Identity.
User-friendly options:
- Provide only eventstream_name: Auto-generates IDs and creates basic eventstream
- Provide only eventstream_id: Auto-generates name as "Eventstream_YYYYMMDD_HHMMSS"
- Provide both: Uses your specified values
- Provide full definition: Advanced users can specify complete eventstream config
:param workspace_id: The workspace ID (UUID)
:param eventstream_name: Name for the new eventstream (auto-generated if not provided)
:param eventstream_id: ID for the eventstream (auto-generated if not provided)
:param definition: Eventstream definition (auto-generated basic one if not provided)
:param description: Optional description for the eventstream
:return: Created eventstream details
Inputs: workspace_id (required), definition, description, eventstream_id, +1 more. Returns: result
eventstream_create_from_definitionCDestructive
Create an eventstream in Fabric from the current definition.
:param session_id: Builder session ID
:param workspace_id: Target Fabric workspace ID
:return: Creation results
Inputs: session_id (required), workspace_id (required). Returns: object
eventstream_deleteADestructive
Delete an Eventstream item by workspace and item ID.
Authentication is handled transparently using Azure Identity.
:param workspace_id: The workspace ID (UUID)
:param item_id: The eventstream item ID (UUID)
:return: Deletion confirmation
Inputs: item_id (required), workspace_id (required). Returns: result
eventstream_getARead-only
Get an Eventstream item by workspace and item ID.
Authentication is handled transparently using Azure Identity.
:param workspace_id: The workspace ID (UUID)
:param item_id: The eventstream item ID (UUID)
:return: Eventstream item details
Inputs: item_id (required), workspace_id (required). Returns: result
eventstream_get_current_definitionCRead-only
Get the current eventstream definition.
:param session_id: Builder session ID
:return: Current definition
Inputs: session_id (required). Returns: object
eventstream_get_definitionBRead-only
Get the definition of an Eventstream item.
Authentication is handled transparently using Azure Identity.
:param workspace_id: The workspace ID (UUID)
:param item_id: The eventstream item ID (UUID)
:return: Eventstream definition
Inputs: item_id (required), workspace_id (required). Returns: result
eventstream_listARead-only
List all Eventstream items in a workspace.
Authentication is handled transparently using Azure Identity.
:param workspace_id: The workspace ID (UUID)
:return: List of eventstream items
Inputs: workspace_id (required). Returns: result
eventstream_list_available_componentsBRead-only
List available components for building eventstreams.
:return: Available components
Inputs: no named parameters. Returns: object
eventstream_start_definitionA
Start a new eventstream definition builder session.
:param name: Name of the eventstream to create
:param description: Optional description of the eventstream
:return: Session information and next steps
Inputs: name (required), description. Returns: object
eventstream_updateADestructive
Update an Eventstream item by workspace and item ID.
Authentication is handled transparently using Azure Identity.
:param workspace_id: The workspace ID (UUID)
:param item_id: The eventstream item ID (UUID)
:param definition: Updated eventstream definition
:return: Updated eventstream details
Inputs: item_id (required), definition (required), workspace_id (required). Returns: result
eventstream_validate_definitionCRead-only
Validate the current eventstream definition.
:param session_id: Builder session ID
:return: Validation results
Inputs: session_id (required). Returns: object
kusto_commandBDestructive
Executes a kusto management command on the specified database. If no database is provided,
it will use the default database.
:param command: The kusto management command to execute.
:param cluster_uri: The URI of the Kusto cluster.
:param database: Optional database name. If not provided, uses the default database.
:param client_request_properties: Optional dictionary of additional client request properties.
:return: The result of the command execution as a list of dictionaries (json).
Inputs: command (required), cluster_uri (required), database, client_request_properties. Returns: object
kusto_deeplink_from_queryARead-only
Build a deeplink URL that opens the given KQL query in the appropriate web explorer UI.
For Azure Data Explorer clusters, opens in Kusto Web Explorer (dataexplorer.azure.com).
For Microsoft Fabric Eventhouse clusters, opens in the Fabric query workbench.
The cluster type is auto-detected from the URI. If detection fails,
falls back to querying the cluster with `.show version`.
:param cluster_uri: The URI of the Kusto cluster.
:param database: The database name.
:param query: The KQL query text.
:return: A deeplink URL string, or None if the cluster type could not be determined.
Inputs: query (required), database (required), cluster_uri (required). Returns: result
kusto_describe_databaseARead-only
Retrieves schema information for all entities (tables, external tables, materialized views,
functions, graphs) in the specified database.
In most cases, it would be useful to call kusto_sample_entity() to see *actual* data samples,
since schema information alone may not provide a complete picture of the data (e.g. dynamic columns, etc...)
:param cluster_uri: The URI of the Kusto cluster.
:param database: The name of the database to get schema for.
:param client_request_properties: Optional dictionary of additional client request properties.
:return: List of dictionaries containing entity schema information.
Inputs: database (required), cluster_uri (required), client_request_properties. Returns: object
kusto_describe_database_entityARead-only
Retrieves the schema information for a specific entity (table, external table,
materialized view, function, graph) in the specified database.
If no database is provided, uses the default database.
:param entity_name: Name of the entity to get schema for.
:param entity_type: Type of the entity (table, external-table, materialized-view, function, graph).
:param cluster_uri: The URI of the Kusto cluster.
:param database: Optional database name. If not provided, uses the default database.
:param client_request_properties: Optional dictionary of additional client request properties.
:return: List of dictionaries containing entity schema information.
Inputs: cluster_uri (required), entity_name (required), entity_type (required), database, +1 more. Returns: object
kusto_diagnosticsARead-only
Runs a suite of diagnostic commands and returns a JSON summary of the cluster's
current state. Each section runs independently — if a command fails (e.g., due to
permissions or unsupported features), that section returns an error while others
continue normally.
:param cluster_uri: The URI of the Kusto cluster.
:param database: Optional database name. If not provided, uses the default database.
:param client_request_properties: Optional dictionary of additional client request properties.
:return: A dictionary with keys for each diagnostic area. Each value is either a list
of row-dicts or {"error": "<message>"} if that command failed.
Sections returned:
* capacity — resource utilization limits (total, consumed, remaining per resource)
* cluster — cluster node info and state
* principal_roles — caller's permission scope and role
* diagnostics — internal cluster diagnostics (health, latency, utilization)
* workload_groups — configured workload groups and their policies
* rowstores — rowstore state and memory usage
* ingestion_failures — ingestion failures from the last 24 hours
Inputs: cluster_uri (required), database, client_request_properties. Returns: object
kusto_graph_queryARead-only
Intelligently executes a graph query using snapshots if they exist,
otherwise falls back to transient graphs.
If no database is provided, uses the default database.
:param graph_name: Name of the graph to query.
:param query: The KQL query to execute after the graph() function.
Must include proper project clause for graph-match queries.
:param cluster_uri: The URI of the Kusto cluster.
:param database: Optional database name. If not provided, uses the default database.
:param client_request_properties: Optional dictionary of additional client request properties.
:return: List of dictionaries containing query results.
Critical:
* Graph queries must have a graph-match clause and a projection clause.
Optionally they may contain a where clause.
* Graph entities are only accessible in the graph-match scope.
When leaving that scope (sub-sequent '|'), the data is treated as a table,
and graph-specific functions (like labels()) will not be available.
* Always prefer expressing everything with graph patterns.
Avoid using graph-to-table operator unless you have no other way around it.
* There is no id() function on graph entities. If you need a unique identifier,
make sure to check the schema and use an appropriate property.
* There is no `type` property on graph entities.
Use `labels()` function to get the list of labels for a node or edge.
* Properties that are used outside the graph-match context are renamed to `_` instead of `.`.
For example, `node.name` becomes `node_name`.
* For variable length paths, you can use `all` or `any` to enforce conditions on all/any edges
in variable path length elements (e.g. `()-[e*1..3]->() where all(e, labels() has 'Label')`).
Examples:
# Basic node counting with graph-match (MUST include project clause):
kusto_graph_query(
"MyGraph",
"| graph-match (node) project labels=labels(node)
| mv-expand label = labels
| summarize count() by tostring(label)",
cluster_uri
)
# Relationship matching:
kusto_graph_query(
"MyGraph",
"| graph-match (house)-[relationship]->(character)
where labels(house) has 'House' and labels(character) has 'Character'
project house.name, character.firstName, character.lastName
| project house_name=house_name, character_full_name=character_firstName + ' ' + character_lastName
| limit 10",
cluster_uri
)
# Variable length path matching:
kusto_graph_query(
"MyGraph",
"| graph-match (source)-[path*1..3]->(m)-[e]->(target)
where all(path, labels() has 'Label')
project source, destination, path, m, e, target
| take 100",
cluster_uri
)
Inputs: query (required), database (required), graph_name (required), cluster_uri (required), +1 more. Returns: object
kusto_ingest_inline_into_tableB
Ingests inline CSV data into a specified table. The data should be provided as a comma-separated string.
If no database is provided, uses the default database.
:param table_name: Name of the table to ingest data into.
:param data_comma_separator: Comma-separated data string to ingest.
:param cluster_uri: The URI of the Kusto cluster.
:param database: Optional database name. If not provided, uses the default database.
:param client_request_properties: Optional dictionary of additional client request properties.
:return: List of dictionaries containing the ingestion result.
Inputs: table_name (required), cluster_uri (required), data_comma_separator (required), database, +1 more. Returns: object
kusto_known_servicesARead-only
Retrieves a list of all Kusto services known to the MCP.
Could be null if no services are configured.
:return: List of objects, {"service": str, "description": str, "default_database": str}
Inputs: no named parameters. Returns: result
kusto_list_entitiesARead-only
Retrieves a list of all entities (databases, tables, external tables, materialized views,
functions, graphs) in the Kusto cluster.
:param entity_type: Type of entities to list: "databases", "tables", "external-tables",
"materialized-views", "functions", "graphs".
:param database: The name of the database to list entities from.
Required for all types except "databases" (which are top-level).
:param cluster_uri: The URI of the Kusto cluster.
:param client_request_properties: Optional dictionary of additional client request properties.
:return: List of dictionaries containing entity information.
Inputs: cluster_uri (required), entity_type (required), database, client_request_properties. Returns: object
kusto_queryARead-only
Executes a KQL query on the specified database. If no database is provided,
it will use the default database.
:param query: The KQL query to execute.
:param cluster_uri: The URI of the Kusto cluster.
:param database: Optional database name. If not provided, uses the default database.
:param client_request_properties: Optional dictionary of additional client request properties.
:return: The result of the query execution as a list of dictionaries (json).
Inputs: query (required), cluster_uri (required), database, client_request_properties. Returns: object
kusto_sample_entityARead-only
Retrieves a data sample from the specified entity.
If no database is provided, uses the default database.
:param entity_name: Name of the entity to sample data from.
:param entity_type: Type of the entity (table, external-table, materialized-view, function, graph).
:param cluster_uri: The URI of the Kusto cluster.
:param sample_size: Number of records to sample. Defaults to 10.
:param database: Optional database name. If not provided, uses the default database.
:param client_request_properties: Optional dictionary of additional client request properties.
:return: List of dictionaries containing sampled records.
Inputs: cluster_uri (required), entity_name (required), entity_type (required), database, +2 more. Returns: object
kusto_show_commandARead-only
Executes a Kusto .show management command on the specified database.
If no database is provided, it will use the default database.
Only .show commands are accepted.
:param command: The .show command to execute.
:param cluster_uri: The URI of the Kusto cluster.
:param database: Optional database name. If not provided, uses the default database.
:param client_request_properties: Optional dictionary of additional client request properties.
:return: The result of the command execution as a list of dictionaries (json).
Inputs: command (required), cluster_uri (required), database, client_request_properties. Returns: object
kusto_show_queryplanARead-only
Retrieves the query execution plan without actually running the query.
This is significantly lighter than execution and useful for understanding
performance characteristics and estimating query impact.
:param query: The KQL query to get the execution plan for.
:param cluster_uri: The URI of the Kusto cluster.
:param database: Optional database name. If not provided, uses the default database.
:param client_request_properties: Optional dictionary of additional client request properties.
:return: A compact dictionary with the following keys:
* query_text — the query as received by the engine
* stats — planning statistics: Duration, PlanSize (bytes), RelopSize (bytes)
* relop_tree — the logical operator tree (compact JSON)
* execution_hints — extracted from the physical plan:
* estimated_rows — total row count the engine expects to process
* concurrency — parallelism hint (-1 = auto, 1 = parallel partitions)
* spread — node spread hint (-1 = auto, 1 = distributed)
* shard_scans — per-shard info: total_rows and has_selection (filter applied)
* error — if the query has semantic errors (e.g., bad column name), this contains
the error message. The query is NOT executed.
Critical:
* This does NOT execute the query — it only generates the plan.
* The plan shows the logical operators the engine would use.
* Use this to estimate cost and understand performance before running expensive queries.
* PlanSize indicates the overall plan complexity; RelopSize indicates the logical tree size.
* execution_hints.estimated_rows and shard_scans reveal the data volume the engine expects to scan.
* has_selection=true in shard_scans means a filter narrows the scan (extent pruning applies).
Inputs: query (required), cluster_uri (required), database, client_request_properties. Returns: object
map_createADestructive
Create a Map item in Microsoft Fabric.
Authentication is handled transparently using Azure Identity.
:param workspace_id: The workspace ID (UUID)
:param map_name: Name for the new map item
:param definition: Map item definition (auto-generated basic one if not provided)
:param description: Optional description for the map
:param folder_id: Optional folder ID (UUID) to place the map in.
If not specified, the Map is created with the workspace root folder.
:return: Created map details
Inputs: map_name (required), workspace_id (required), folder_id, definition, +1 more. Returns: object
map_deleteADestructive
Delete a Map item by workspace and item ID.
Authentication is handled transparently using Azure Identity.
:param workspace_id: The workspace ID (UUID)
:param item_id: The map item ID (UUID)
:return: Error details or empty response on success
Inputs: item_id (required), workspace_id (required). Returns: object
map_getARead-only
Get a Map item by workspace and item ID.
Authentication is handled transparently using Azure Identity.
:param workspace_id: The workspace ID (UUID) of the Map item
:param item_id: The map item ID (UUID)
:return: Map item details
Inputs: item_id (required), workspace_id (required). Returns: object
map_get_definitionARead-only
Get the definition of a Map item.
Authentication is handled transparently using Azure Identity.
:param workspace_id: The workspace ID (UUID)
:param item_id: The map item ID (UUID)
:return: Map definition
Inputs: item_id (required), workspace_id (required). Returns: object
map_listARead-only
List all Map items in a workspace.
Authentication is handled transparently using Azure Identity.
:param workspace_id: The workspace ID (UUID)
:return: The list of map items in the specified workspace or error details
Inputs: workspace_id (required). Returns: object
map_updateADestructive
Update a Map item's display name and description by workspace and item ID.
Authentication is handled transparently using Azure Identity.
:param workspace_id: The workspace ID (UUID)
:param item_id: The Map item ID (UUID)
:param display_name: The Map display name. The display name must follow naming rules according to item type.
:param description: The Map description. Maximum length is 256 characters.
:return: Updated map details
Inputs: item_id (required), workspace_id (required), description, display_name. Returns: object
map_update_definitionBDestructive
Update a Map item's definition by workspace and item ID.
Authentication is handled transparently using Azure Identity.
:param workspace_id: The workspace ID (UUID)
:param item_id: The map item ID (UUID)
:param definition: Updated map definition
:return: Updated map details
Inputs: item_id (required), definition (required), workspace_id (required). Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 39 tools
Most tools are clearly separated by domain prefix and action, but there are several near-overlaps such as kusto_command vs kusto_show_command, eventstream_get_definition vs eventstream_get_current_definition, and eventstream_create vs eventstream_create_from_definition. Descriptions help clarify the intended use, but an agent could still plausibly select the wrong tool in these cases.
Tool names consistently use snake_case with domain prefixes like kusto_, eventstream_, map_, and activator_, and most follow a verb_noun pattern. Minor deviations such as kusto_known_services, kusto_diagnostics, and the overloaded eventstream_*_definition names keep it from being perfectly consistent.
With 39 tools, the server is heavily loaded and exceeds the 25-tool threshold for a typical MCP surface. The count reflects the broad Fabric RTI scope, but the toolset would be easier for agents to navigate if split into more focused servers per domain.
Kusto, Eventstream, and Map have strong coverage with querying, schema inspection, ingestion, lifecycle management, and definition editing. However, Activator is notably thin: only artifact listing and trigger creation exist, with no way to get, update, list, or delete existing triggers, leaving an obvious management gap.
Maintenance
Related MCP Connectors
Lets AI agents analyze API metrics, request logs, and traces, and manage apps and alerts.
Provide real-time data querying and visualization by integrating Tako with your agents. Generate o…
Amazon Ads, Seller Central, Vendor Central and AMC data for AI agents. Read-only by default.
Turn Microsoft Fabric tables into an explainable graph and a GraphQL API. Understand how your Fabric tables fit together. See how your Fabric tables connect: the keys and relationships Krusgraph suggests, why, and what your data says, before a report or an app depends on them. A one-stop-shop for Data Engineering on Fabric
Related MCP Servers
- AlicenseBqualityCmaintenanceEnables AI agents to interact with Microsoft Fabric by exposing tools for managing workspaces, notebooks, SQL queries, pipelines, and Livy Spark sessions. It provides a comprehensive set of operations for data engineering and analytics tasks using standard Azure authentication.374MIT
- AlicenseBqualityDmaintenanceEnables AI assistants to interact with Microsoft Fabric and Power BI services through the Model Context Protocol. Users can manage workspaces, execute DAX queries, refresh datasets, and create Fabric notebooks using natural language.69 npm2MIT
- AlicenseNot gradedqualityCmaintenanceEnables agents to manage Microsoft Fabric workspaces, items, lakehouses, warehouses, and notebooks via the control plane, and run guarded read-only SQL plus optional DAX queries against semantic models.MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to securely connect to your own Power BI or Fabric tenant using your Azure identity, with tools to inspect workspaces and models, run read-only DAX, validate and deploy your own reports, take page screenshots, and enforce guardrails that protect shared resources.1MIT