Adding MCP capability in DAB

schemas/dab.draft.schema.json

@@ -158,13 +158,13 @@
           "type": "object",
           "properties": {
             "max-page-size": {
-              "type": ["integer", "null"],
+              "type": [ "integer", "null" ],
               "description": "Defines the maximum number of records that can be returned in a single page of results. If set to null, the default value is 100,000.",
               "default": 100000,
               "minimum": 1
             },
             "default-page-size": {
-              "type": ["integer", "null"],
+              "type": [ "integer", "null" ],
               "description": "Sets the default number of records returned in a single response. When this limit is reached, a continuation token is provided to retrieve the next page. If set to null, the default value is 100.",
               "default": 100,
               "minimum": 1
@@ -214,7 +214,7 @@
               "description": "Allow enabling/disabling GraphQL requests for all entities."
             },
             "depth-limit": {
-              "type": ["integer", "null"],
+              "type": [ "integer", "null" ],
               "description": "Maximum allowed depth of a GraphQL query.",
               "default": null
             },
@@ -239,26 +239,87 @@
             }
           }
         },
+        "mcp": {
+          "type": "object",
+          "description": "Global MCP endpoint configuration",
+          "additionalProperties": false,
+          "properties": {
+            "path": {
+              "default": "/mcp",
+              "type": "string"
+            },
+            "enabled": {
+              "type": "boolean",
+              "description": "Allow enabling/disabling MCP requests for all entities.",
+              "default": true
+            },
+            "dml-tools": {
+              "oneOf": [
+                {
+                  "type": "boolean",
+                  "description": "Enable/disable all DML tools with default settings."
+                },
+                {
+                  "type": "object",
+                  "description": "Individual DML tools configuration",
+                  "additionalProperties": false,
+                  "properties": {
+                    "describe-entities": {
+                      "type": "boolean",
+                      "description": "Enable/disable the describe-entities tool.",
+                      "default": false
+                    },
+                    "create-record": {
+                      "type": "boolean",
+                      "description": "Enable/disable the create-record tool.",
+                      "default": false
+                    },
+                    "read-records": {
+                      "type": "boolean",
+                      "description": "Enable/disable the read-records tool.",
+                      "default": false
+                    },
+                    "update-record": {
+                      "type": "boolean",
+                      "description": "Enable/disable the update-record tool.",
+                      "default": false
+                    },
+                    "delete-record": {
+                      "type": "boolean",
+                      "description": "Enable/disable the delete-record tool.",
+                      "default": false
+                    },
+                    "execute-entity": {
+                      "type": "boolean",
+                      "description": "Enable/disable the execute-entity tool.",
+                      "default": false
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        },
         "host": {
           "type": "object",
           "description": "Global hosting configuration",
           "additionalProperties": false,
           "properties": {
             "max-response-size-mb": {
-              "type": ["integer", "null"],
+              "type": [ "integer", "null" ],
               "description": "Specifies the maximum size, in megabytes, of the database response allowed in a single result. If set to null, the default value is 158 MB.",
               "default": 158,
               "minimum": 1,
               "maximum": 158
             },
             "mode": {
               "description": "Set if running in Development or Production mode",
-              "type": ["string", "null"],
+              "type": [ "string", "null" ],
               "default": "production",
-              "enum": ["production", "development"]
+              "enum": [ "production", "development" ]
             },
             "cors": {
-              "type": ["object", "null"],
+              "type": [ "object", "null" ],
               "description": "Configure CORS",
               "additionalProperties": false,
               "properties": {
@@ -278,7 +339,7 @@
               }
             },
             "authentication": {
-              "type": ["object", "null"],
+              "type": [ "object", "null" ],
               "additionalProperties": false,
               "properties": {
                 "provider": {
@@ -322,7 +383,7 @@
                       "type": "string"
                     }
                   },
-                  "required": ["audience", "issuer"]
+                  "required": [ "audience", "issuer" ]
                 }
               },
               "allOf": [
@@ -338,9 +399,9 @@
                         ]
                       }
                     },
-                    "required": ["provider"]
+                    "required": [ "provider" ]
                   },
-                  "then": { "required": ["jwt"] },
+                  "then": { "required": [ "jwt" ] },
                   "else": { "properties": { "jwt": false } }
                 }
               ]
@@ -382,7 +443,7 @@
                   "default": true
                 }
               },
-              "required": ["connection-string"]
+              "required": [ "connection-string" ]
             },
             "open-telemetry": {
               "type": "object",
@@ -405,15 +466,15 @@
                   "type": "string",
                   "description": "Open Telemetry protocol",
                   "default": "grpc",
-                  "enum": ["grpc", "httpprotobuf"]
+                  "enum": [ "grpc", "httpprotobuf" ]
                 },
                 "enabled": {
                   "type": "boolean",
                   "description": "Allow enabling/disabling Open Telemetry.",
                   "default": true
                 }
               },
-              "required": ["endpoint"]
+              "required": [ "endpoint" ]
             },
             "azure-log-analytics": {
               "type": "object",

src/Azure.DataApiBuilder.Mcp/Azure.DataApiBuilder.Mcp.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="ModelContextProtocol" />
+    <PackageReference Include="ModelContextProtocol.AspNetCore" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Core\Azure.DataApiBuilder.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="CustomTools\" />
+  </ItemGroup>
+
+</Project>

src/Azure.DataApiBuilder.Mcp/BuiltInTools/CreateRecordTool.cs

@@ -0,0 +1,87 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Text.Json;
+using Azure.DataApiBuilder.Mcp.Model;
+using ModelContextProtocol.Protocol;
+using static Azure.DataApiBuilder.Mcp.Model.McpEnums;
+
+namespace Azure.DataApiBuilder.Mcp.BuiltInTools
+{
+    public class CreateRecordTool : IMcpTool
+    {
+        public ToolType ToolType { get; } = ToolType.BuiltIn;
+
+        public Tool GetToolMetadata()
+        {
+            return new Tool
+            {
+                Name = "create-record",
+                Description = "Creates a new record in the specified entity.",
+                InputSchema = JsonSerializer.Deserialize<JsonElement>(
+                    @"{
+                        ""type"": ""object"",
+                        ""properties"": {
+                            ""entity"": {
+                                ""type"": ""string"",
+                                ""description"": ""The name of the entity""
+                            },
+                            ""data"": {
+                                ""type"": ""object"",
+                                ""description"": ""The data for the new record""
+                            }
+                        },
+                        ""required"": [""entity"", ""data""]
+                    }"
+                )
+            };
+        }
+
+        public Task<CallToolResult> ExecuteAsync(
+            JsonDocument? arguments,
+            IServiceProvider serviceProvider,
+            CancellationToken cancellationToken = default)
+        {
+            if (arguments == null)
+            {
+                return Task.FromResult(new CallToolResult
+                {
+                    Content = [new TextContentBlock { Type = "text", Text = "Error: No arguments provided" }]
+                });
+            }
+
+            try
+            {
+                // Extract arguments
+                JsonElement root = arguments.RootElement;
+
+                if (!root.TryGetProperty("entity", out JsonElement entityElement) ||
+                    !root.TryGetProperty("data", out JsonElement dataElement))
+                {
+                    return Task.FromResult(new CallToolResult
+                    {
+                        Content = [new TextContentBlock { Type = "text", Text = "Error: Missing required arguments 'entity' or 'data'" }]
+                    });
+                }
+
+                string entityName = entityElement.GetString() ?? string.Empty;
+
+                // TODO: Implement actual create logic using DAB's internal services
+                // For now, return a placeholder response
+                string result = $"Would create record in entity '{entityName}' with data: {dataElement.GetRawText()}";
+
+                return Task.FromResult(new CallToolResult
+                {
+                    Content = [new TextContentBlock { Type = "text", Text = result }]
+                });
+            }
+            catch (Exception ex)
+            {
+                return Task.FromResult(new CallToolResult
+                {
+                    Content = [new TextContentBlock { Type = "text", Text = $"Error: {ex.Message}" }]
+                });
+            }
+        }
+    }
+}

src/Azure.DataApiBuilder.Mcp/BuiltInTools/DescribeEntitiesTool.cs

@@ -0,0 +1,83 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Text.Json;
+using Azure.DataApiBuilder.Config.ObjectModel;
+using Azure.DataApiBuilder.Core.Configurations;
+using Azure.DataApiBuilder.Mcp.Model;
+using Microsoft.Extensions.DependencyInjection;
+using ModelContextProtocol.Protocol;
+using static Azure.DataApiBuilder.Mcp.Model.McpEnums;
+
+namespace Azure.DataApiBuilder.Mcp.BuiltInTools
+{
+    public class DescribeEntitiesTool : IMcpTool
+    {
+        public ToolType ToolType { get; } = ToolType.BuiltIn;
+
+        public Tool GetToolMetadata()
+        {
+            return new Tool
+            {
+                Name = "describe-entities",
+                Description = "Lists and describes all entities in the database."
+            };
+        }
+
+        public Task<CallToolResult> ExecuteAsync(
+            JsonDocument? arguments,
+            IServiceProvider serviceProvider,
+            CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                // Get the runtime config provider
+                RuntimeConfigProvider? runtimeConfigProvider = serviceProvider.GetService<RuntimeConfigProvider>();
+                if (runtimeConfigProvider == null || !runtimeConfigProvider.TryGetConfig(out RuntimeConfig? runtimeConfig))
+                {
+                    return Task.FromResult(new CallToolResult
+                    {
+                        Content = [new TextContentBlock { Type = "text", Text = "Error: Runtime configuration not available." }]
+                    });
+                }
+
+                // Extract entity information from the runtime config
+                Dictionary<string, object> entities = new();
+
+                if (runtimeConfig.Entities != null)
+                {
+                    foreach (KeyValuePair<string, Entity> entity in runtimeConfig.Entities)
+                    {
+                        entities[entity.Key] = new
+                        {
+                            source = entity.Value.Source,
+                            permissions = entity.Value.Permissions?.Select(p => new
+                            {
+                                role = p.Role,
+                                actions = p.Actions
+                            })
+                        };
+                    }
+                }
+
+                string entitiesJson = JsonSerializer.Serialize(entities, new JsonSerializerOptions
+                {
+                    WriteIndented = true,
+                    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+                });
+
+                return Task.FromResult(new CallToolResult
+                {
+                    Content = [new TextContentBlock { Type = "application/json", Text = entitiesJson }]
+                });
+            }
+            catch (Exception ex)
+            {
+                return Task.FromResult(new CallToolResult
+                {
+                    Content = [new TextContentBlock { Type = "text", Text = $"Error: {ex.Message}" }]
+                });
+            }
+        }
+    }
+}