Merge pull request #6436 from FlowFuse/6249-expert-mcp-feature-branch

Expert MCP feature branch

Author: dimitrieh

config/webpack.config.js

@@ -164,6 +164,9 @@ module.exports = function (env, argv) {
             port: 3000,
             historyApiFallback: true
         },
+        watchOptions: {
+            poll: 1000
+        },
         resolve: {
             alias: {
                 // Use vue with the runtime compiler (needed for template strings)

forge/ee/db/models/MCPRegistration.js

@@ -1,7 +1,7 @@
 /**
  * Stores MCP endpoints for a Team
  */
-const { DataTypes } = require('sequelize')
+const { DataTypes, literal } = require('sequelize')
 
 module.exports = {
     name: 'MCPRegistration',
@@ -21,16 +21,64 @@ module.exports = {
     ],
     associations: function (M) {
         this.belongsTo(M.Team, { foreignKey: { allowNull: false } })
+        this.belongsTo(M.Project, { foreignKey: 'targetId', constraints: false }) // allow byTeam to include instance info
+        this.belongsTo(M.Device, { foreignKey: 'targetId', constraints: false }) // allow byTeam to include instance info
     },
     finders: function (M, app) {
+        const isPG = this.sequelize.getDialect() === 'postgres'
+        const instanceOwnershipJoin = literal(`
+            "MCPRegistration"."targetType" = 'instance'
+            AND (
+                CASE
+                    WHEN "MCPRegistration"."targetType" = 'instance'
+                    THEN "MCPRegistration"."targetId"${isPG ? '::uuid' : ''}
+                END
+            ) = "Project"."id"
+        `)
+        const deviceOwnershipJoin = literal(`
+            "MCPRegistration"."targetType" = 'device'
+            AND (
+                CASE
+                    WHEN "MCPRegistration"."targetType" = 'device'
+                    THEN "MCPRegistration"."targetId"${isPG ? '::int' : ''}
+                END
+            ) = "Device"."id"
+        `)
         return {
             static: {
-                byTeam: async (teamId) => {
+                byTeam: async (teamIdOrHash, {
+                    includeTeam = false,
+                    includeInstance = false
+                } = {}) => {
+                    let teamId = teamIdOrHash
                     if (typeof teamId === 'string') {
                         teamId = M.Team.decodeHashid(teamId)
                     }
+                    const include = []
+                    if (includeTeam) {
+                        include.push({ model: M.Team, include: { model: M.TeamType } })
+                    }
+                    if (includeInstance) {
+                        include.push({
+                            model: M.Project,
+                            attributes: ['hashid', 'id', 'name', 'slug', 'links', 'url', 'ApplicationId'],
+                            required: false,
+                            on: instanceOwnershipJoin
+                        })
+                        include.push({
+                            model: M.Device,
+                            attributes: ['hashid', 'id', 'name', 'type', 'ApplicationId'],
+                            required: false,
+                            on: deviceOwnershipJoin,
+                            include: {
+                                model: M.Project,
+                                attributes: ['ApplicationId']
+                            }
+                        })
+                    }
                     return this.findAll({
-                        where: { TeamId: teamId }
+                        where: { TeamId: teamId },
+                        include
                     })
                 },
                 byTypeAndIDs: async (targetType, targetId, nodeId) => {

forge/routes/api/expert.js

@@ -17,7 +17,7 @@ module.exports = async function (app) {
 
     app.addHook('preHandler', app.verifySession)
     app.addHook('preHandler', async (request, reply) => {
-        if (!serviceEnabled) {
+        if (!serviceEnabled || !expertUrl) {
             return reply.code(501).send({
                 code: 'service_disabled',
                 error: 'Expert service is not enabled'
@@ -38,11 +38,24 @@ module.exports = async function (app) {
             // Get the user object
             request.user = await app.db.models.User.byId(request.session.User.id)
             if (!request.user) {
-                reply.code(401).send({
+                return reply.code(401).send({
                     code: 'unauthorized',
                     error: 'unauthorized'
                 })
             }
+            // Ensure users team access is valid
+            const teamId = request.body.context?.teamId // `context.teamId` is the hash provided in the body context by the client
+            if (!teamId) {
+                return reply.status(404).send({ code: 'not_found', error: 'Not Found' })
+            }
+            const existingRole = await request.user.getTeamMembership(teamId)
+            if (!existingRole) {
+                return reply.status(404).send({ code: 'not_found', error: 'Not Found' })
+            }
+            request.team = await app.db.models.Team.byId(teamId)
+            if (!request.team) {
+                return reply.status(404).send({ code: 'not_found', error: 'Not Found' })
+            }
         }
     })
 
@@ -104,9 +117,164 @@ module.exports = async function (app) {
                 throw new Error('Transaction ID mismatch')
             }
 
+            reply.send(response.data)
+        } catch (error) {
+            reply.code(error.response?.status || 500).send({ code: error.response?.data?.code || 'unexpected_error', error: error.response?.data?.error || error.message })
+        }
+    })
+    /**
+     * an endpoint to retrieve MCP features (prompts/resources/tools) for the users team
+     */
+    app.post('/mcp/features', {
+        schema: {
+            hide: true, // dont show in swagger
+            headers: {
+                type: 'object',
+                properties: {
+                    'x-chat-transaction-id': { type: 'string', minLength: 1 }
+                },
+                required: ['x-chat-transaction-id']
+            },
+            body: {
+                type: 'object',
+                properties: {
+                    context: {
+                        type: 'object',
+                        properties: {
+                            teamId: { type: 'string', minLength: 10 }
+                        },
+                        required: ['teamId'],
+                        additionalProperties: true
+                    }
+                },
+                required: ['context']
+            },
+            response: {
+                200: {
+                    type: 'object',
+                    properties: {
+                        transactionId: { type: 'string' },
+                        servers: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    team: { type: 'string' },
+                                    instance: { type: 'string' },
+                                    instanceType: { type: 'string', enum: ['instance', 'device'] },
+                                    instanceName: { type: 'string' },
+                                    mcpServerName: { type: 'string' },
+                                    prompts: { type: 'array', items: { type: 'object', additionalProperties: true } },
+                                    resources: { type: 'array', items: { type: 'object', additionalProperties: true } },
+                                    resourceTemplates: { type: 'array', items: { type: 'object', additionalProperties: true } },
+                                    tools: { type: 'array', items: { type: 'object', additionalProperties: true } },
+                                    mcpProtocol: { type: 'string', enum: ['http', 'sse'] },
+                                    mcpServerUrl: { type: 'string' },
+                                    title: { type: 'string' },
+                                    version: { type: 'string' },
+                                    description: { type: 'string' }
+                                },
+                                required: ['instance', 'instanceType', 'instanceName', 'mcpServerName', 'prompts', 'resources', 'resourceTemplates', 'tools', 'mcpProtocol'],
+                                additionalProperties: false
+                            }
+                        }
+                    },
+                    additionalProperties: false
+                },
+                '4xx': {
+                    $ref: 'APIError'
+                }
+            }
+        }
+    },
+    /**
+     * Get MCP capabilities for the user's team
+     * @param {import('fastify').FastifyRequest} request
+     * @param {import('fastify').FastifyReply} reply
+     */
+    async (request, reply) => {
+        try {
+            /** @type {MCPServerItem[]} */
+            const runningInstancesWithMCPServer = []
+            const transactionId = request.headers['x-chat-transaction-id']
+            const mcpCapabilitiesUrl = `${expertUrl.split('/').slice(0, -1).join('/')}/mcp/features`
+            const mcpServers = await app.db.models.MCPRegistration.byTeam(request.team.id, { includeInstance: true }) || []
+
+            for (const server of mcpServers) {
+                const { name, protocol, endpointRoute, TeamId, Project, Device, title, version, description } = server
+                if (TeamId !== request.team.id) {
+                    // shouldn't happen due to byTeam filter, but just in case
+                    continue
+                }
+                let owner, ownerId, ownerType
+                if (Device) {
+                    ownerType = 'device'
+                    owner = Device
+                    ownerId = Device.hashid
+                } else if (Project) {
+                    ownerType = 'instance'
+                    owner = Project
+                    ownerId = Project.id
+                } else {
+                    continue
+                }
+
+                const liveState = await owner.liveState({ omitStorageFlows: true })
+                if (liveState?.meta?.state !== 'running') {
+                    continue
+                }
+
+                runningInstancesWithMCPServer.push({
+                    team: request.team.hashid,
+                    instance: ownerId,
+                    instanceType: ownerType,
+                    instanceName: owner.name,
+                    instanceUrl: owner.url,
+                    mcpServerName: name,
+                    mcpEndpoint: endpointRoute,
+                    mcpProtocol: protocol,
+                    title,
+                    version,
+                    description
+                })
+            }
+            if (runningInstancesWithMCPServer.length === 0) {
+                return reply.send({ servers: [], transactionId })
+            }
+            const response = await axios.post(mcpCapabilitiesUrl, {
+                teamId: request.team.hashid,
+                servers: runningInstancesWithMCPServer
+            }, {
+                headers: {
+                    Origin: request.headers.origin,
+                    'X-Chat-Transaction-ID': transactionId,
+                    ...(serviceToken ? { Authorization: `Bearer ${serviceToken}` } : {})
+                },
+                timeout: requestTimeout
+            })
+
+            if (response.data.transactionId !== transactionId) {
+                throw new Error('Transaction ID mismatch')
+            }
+
             reply.send(response.data)
         } catch (error) {
             reply.code(error.response?.status || 500).send({ code: error.response?.data?.code || 'unexpected_error', error: error.response?.data?.error || error.message })
         }
     })
 }
+
+/**
+ * @typedef {Object} MCPServerItem MCP server info for a team
+ * @property {string} team
+ * @property {string} instance
+ * @property {string} instanceType
+ * @property {string} instanceName
+ * @property {string} instanceUrl
+ * @property {string} mcpServerName
+ * @property {string} mcpEndpoint
+ * @property {string} mcpProtocol
+ * @property {string} [title]
+ * @property {string} [version]
+ * @property {string} [description]
+*/

frontend/src/App.vue

@@ -142,8 +142,7 @@ export default {
         this.$store.dispatch('product/checkFlags')
     },
     methods: {
-        // todo this should be switched to a dedicated context store
-        ...mapActions('product/expert', ['updateRoute'])
+        ...mapActions('context', ['updateRoute'])
     }
 }
 </script>

frontend/src/api/expert.js

@@ -31,6 +31,23 @@ const chat = async ({
     })
 }
 
+const getCapabilities = async (payload) => {
+    const transactionId = uuidv4()
+    return client.post('/api/v1/expert/mcp/features', payload, {
+        headers: {
+            'X-Chat-Transaction-ID': transactionId
+        }
+    }).then(res => {
+        if (res.data.transactionId !== transactionId) {
+            // ignore transaction ID mismatch for this endpoint for now
+            console.warn('Transaction ID mismatch - response may be from a different request')
+            return {}
+        }
+        return res.data
+    })
+}
+
 export default {
-    chat
+    chat,
+    getCapabilities
 }

frontend/src/components/drawers/RightDrawer.vue

@@ -374,7 +374,7 @@ export default {
 
 <style scoped lang="scss">
 #right-drawer {
-    position: absolute;
+    position: fixed;
     border-left: 1px solid $ff-grey-300;
     background: $ff-grey-50;
     height: calc(100% - 60px);