459 lines
15 KiB
TypeScript
459 lines
15 KiB
TypeScript
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
|
|
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
|
|
import {
|
|
CallToolRequestSchema,
|
|
ListResourcesRequestSchema,
|
|
ListToolsRequestSchema,
|
|
ListPromptsRequestSchema,
|
|
GetPromptRequestSchema,
|
|
ReadResourceRequestSchema
|
|
} from '@modelcontextprotocol/sdk/types.js';
|
|
import { MCPServerConfig, N8NConfig } from '../types';
|
|
import { n8nTools } from './tools';
|
|
import { n8nResources } from './resources';
|
|
import { n8nPrompts } from './prompts';
|
|
import { N8NApiClient } from '../utils/n8n-client';
|
|
import { N8NMCPBridge } from '../utils/bridge';
|
|
import { logger } from '../utils/logger';
|
|
import { NodeSourceExtractor } from '../utils/node-source-extractor';
|
|
import { NodeDocumentationService } from '../services/node-documentation-service';
|
|
|
|
export class N8NMCPServer {
|
|
private server: Server;
|
|
private n8nClient: N8NApiClient;
|
|
private nodeExtractor: NodeSourceExtractor;
|
|
private nodeDocService: NodeDocumentationService;
|
|
|
|
constructor(config: MCPServerConfig, n8nConfig: N8NConfig) {
|
|
this.n8nClient = new N8NApiClient(n8nConfig);
|
|
this.nodeExtractor = new NodeSourceExtractor();
|
|
this.nodeDocService = new NodeDocumentationService();
|
|
logger.info('Initializing n8n MCP server', { config, n8nConfig });
|
|
this.server = new Server(
|
|
{
|
|
name: 'n8n-mcp-server',
|
|
version: '1.0.0',
|
|
},
|
|
{
|
|
capabilities: {
|
|
tools: {},
|
|
resources: {},
|
|
prompts: {},
|
|
},
|
|
}
|
|
);
|
|
|
|
this.setupHandlers();
|
|
}
|
|
|
|
private setupHandlers(): void {
|
|
// Handle tool listing
|
|
this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
|
|
tools: n8nTools,
|
|
}));
|
|
|
|
// Handle tool execution
|
|
this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
|
|
const { name, arguments: args } = request.params;
|
|
|
|
try {
|
|
logger.debug(`Executing tool: ${name}`, { args });
|
|
const result = await this.executeTool(name, args);
|
|
logger.debug(`Tool ${name} executed successfully`, { result });
|
|
return {
|
|
content: [
|
|
{
|
|
type: 'text',
|
|
text: JSON.stringify(result, null, 2),
|
|
},
|
|
],
|
|
};
|
|
} catch (error) {
|
|
logger.error(`Error executing tool ${name}`, error);
|
|
return {
|
|
content: [
|
|
{
|
|
type: 'text',
|
|
text: `Error executing tool ${name}: ${error instanceof Error ? error.message : 'Unknown error'}`,
|
|
},
|
|
],
|
|
isError: true,
|
|
};
|
|
}
|
|
});
|
|
|
|
// Handle resource listing
|
|
this.server.setRequestHandler(ListResourcesRequestSchema, async () => ({
|
|
resources: n8nResources,
|
|
}));
|
|
|
|
// Handle resource reading
|
|
this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
|
|
const { uri } = request.params;
|
|
|
|
try {
|
|
logger.debug(`Reading resource: ${uri}`);
|
|
const content = await this.readResource(uri);
|
|
logger.debug(`Resource ${uri} read successfully`);
|
|
return {
|
|
contents: [
|
|
{
|
|
uri,
|
|
mimeType: 'application/json',
|
|
text: JSON.stringify(content, null, 2),
|
|
},
|
|
],
|
|
};
|
|
} catch (error) {
|
|
logger.error(`Failed to read resource ${uri}`, error);
|
|
throw new Error(`Failed to read resource ${uri}: ${error instanceof Error ? error.message : 'Unknown error'}`);
|
|
}
|
|
});
|
|
|
|
// Handle prompt listing
|
|
this.server.setRequestHandler(ListPromptsRequestSchema, async () => ({
|
|
prompts: n8nPrompts,
|
|
}));
|
|
|
|
// Handle prompt retrieval
|
|
this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
|
|
const { name, arguments: args } = request.params;
|
|
|
|
const prompt = n8nPrompts.find(p => p.name === name);
|
|
if (!prompt) {
|
|
throw new Error(`Prompt ${name} not found`);
|
|
}
|
|
|
|
const promptText = await this.generatePrompt(name, args);
|
|
|
|
return {
|
|
description: prompt.description,
|
|
messages: [
|
|
{
|
|
role: 'user',
|
|
content: {
|
|
type: 'text',
|
|
text: promptText,
|
|
},
|
|
},
|
|
],
|
|
};
|
|
});
|
|
}
|
|
|
|
private async executeTool(name: string, args: any): Promise<any> {
|
|
// Tool execution logic based on specific n8n operations
|
|
switch (name) {
|
|
case 'execute_workflow':
|
|
return this.executeWorkflow(args);
|
|
case 'list_workflows':
|
|
return this.listWorkflows(args);
|
|
case 'get_workflow':
|
|
return this.getWorkflow(args);
|
|
case 'create_workflow':
|
|
return this.createWorkflow(args);
|
|
case 'update_workflow':
|
|
return this.updateWorkflow(args);
|
|
case 'delete_workflow':
|
|
return this.deleteWorkflow(args);
|
|
case 'get_executions':
|
|
return this.getExecutions(args);
|
|
case 'get_execution_data':
|
|
return this.getExecutionData(args);
|
|
case 'get_node_source_code':
|
|
return this.getNodeSourceCode(args);
|
|
case 'list_available_nodes':
|
|
return this.listAvailableNodes(args);
|
|
case 'get_node_info':
|
|
return this.getNodeInfo(args);
|
|
case 'search_nodes':
|
|
return this.searchNodes(args);
|
|
case 'get_node_statistics':
|
|
return this.getNodeStatistics(args);
|
|
case 'rebuild_documentation_database':
|
|
return this.rebuildDocumentationDatabase(args);
|
|
default:
|
|
throw new Error(`Unknown tool: ${name}`);
|
|
}
|
|
}
|
|
|
|
private async readResource(uri: string): Promise<any> {
|
|
// Resource reading logic
|
|
if (uri.startsWith('workflow://')) {
|
|
const workflowId = uri.replace('workflow://', '');
|
|
return this.getWorkflow({ id: workflowId });
|
|
} else if (uri === 'nodes://available') {
|
|
return this.listAvailableNodes({});
|
|
} else if (uri.startsWith('nodes://source/')) {
|
|
const nodeType = uri.replace('nodes://source/', '');
|
|
return this.getNodeSourceCode({ nodeType });
|
|
}
|
|
throw new Error(`Unknown resource URI: ${uri}`);
|
|
}
|
|
|
|
private async generatePrompt(name: string, args: any): Promise<string> {
|
|
// Prompt generation logic will be implemented
|
|
switch (name) {
|
|
case 'create_workflow_prompt':
|
|
return `Create an n8n workflow that ${args.description}`;
|
|
case 'debug_workflow_prompt':
|
|
return `Debug the n8n workflow with ID ${args.workflowId} and identify any issues`;
|
|
default:
|
|
throw new Error(`Unknown prompt: ${name}`);
|
|
}
|
|
}
|
|
|
|
// n8n integration methods
|
|
private async executeWorkflow(args: any): Promise<any> {
|
|
try {
|
|
const result = await this.n8nClient.executeWorkflow(args.workflowId, args.data);
|
|
return N8NMCPBridge.sanitizeData(result);
|
|
} catch (error) {
|
|
throw new Error(`Failed to execute workflow: ${error instanceof Error ? error.message : 'Unknown error'}`);
|
|
}
|
|
}
|
|
|
|
private async listWorkflows(args: any): Promise<any> {
|
|
try {
|
|
const workflows = await this.n8nClient.getWorkflows(args);
|
|
return {
|
|
workflows: workflows.data.map((wf: any) => N8NMCPBridge.n8nWorkflowToMCP(wf)),
|
|
};
|
|
} catch (error) {
|
|
throw new Error(`Failed to list workflows: ${error instanceof Error ? error.message : 'Unknown error'}`);
|
|
}
|
|
}
|
|
|
|
private async getWorkflow(args: any): Promise<any> {
|
|
try {
|
|
const workflow = await this.n8nClient.getWorkflow(args.id);
|
|
return N8NMCPBridge.n8nWorkflowToMCP(workflow);
|
|
} catch (error) {
|
|
throw new Error(`Failed to get workflow: ${error instanceof Error ? error.message : 'Unknown error'}`);
|
|
}
|
|
}
|
|
|
|
private async createWorkflow(args: any): Promise<any> {
|
|
try {
|
|
const workflowData = N8NMCPBridge.mcpToN8NWorkflow(args);
|
|
const result = await this.n8nClient.createWorkflow(workflowData);
|
|
return N8NMCPBridge.n8nWorkflowToMCP(result);
|
|
} catch (error) {
|
|
throw new Error(`Failed to create workflow: ${error instanceof Error ? error.message : 'Unknown error'}`);
|
|
}
|
|
}
|
|
|
|
private async updateWorkflow(args: any): Promise<any> {
|
|
try {
|
|
const result = await this.n8nClient.updateWorkflow(args.id, args.updates);
|
|
return N8NMCPBridge.n8nWorkflowToMCP(result);
|
|
} catch (error) {
|
|
throw new Error(`Failed to update workflow: ${error instanceof Error ? error.message : 'Unknown error'}`);
|
|
}
|
|
}
|
|
|
|
private async deleteWorkflow(args: any): Promise<any> {
|
|
try {
|
|
await this.n8nClient.deleteWorkflow(args.id);
|
|
return { success: true, id: args.id };
|
|
} catch (error) {
|
|
throw new Error(`Failed to delete workflow: ${error instanceof Error ? error.message : 'Unknown error'}`);
|
|
}
|
|
}
|
|
|
|
private async getExecutions(args: any): Promise<any> {
|
|
try {
|
|
const executions = await this.n8nClient.getExecutions(args);
|
|
return {
|
|
executions: executions.data.map((exec: any) => N8NMCPBridge.n8nExecutionToMCPResource(exec)),
|
|
};
|
|
} catch (error) {
|
|
throw new Error(`Failed to get executions: ${error instanceof Error ? error.message : 'Unknown error'}`);
|
|
}
|
|
}
|
|
|
|
private async getExecutionData(args: any): Promise<any> {
|
|
try {
|
|
const execution = await this.n8nClient.getExecution(args.executionId);
|
|
return N8NMCPBridge.n8nExecutionToMCPResource(execution);
|
|
} catch (error) {
|
|
throw new Error(`Failed to get execution data: ${error instanceof Error ? error.message : 'Unknown error'}`);
|
|
}
|
|
}
|
|
|
|
private async getNodeSourceCode(args: any): Promise<any> {
|
|
try {
|
|
logger.info(`Getting source code for node: ${args.nodeType}`);
|
|
const nodeInfo = await this.nodeExtractor.extractNodeSource(args.nodeType);
|
|
|
|
const result: any = {
|
|
nodeType: nodeInfo.nodeType,
|
|
sourceCode: nodeInfo.sourceCode,
|
|
location: nodeInfo.location,
|
|
};
|
|
|
|
if (args.includeCredentials && nodeInfo.credentialCode) {
|
|
result.credentialCode = nodeInfo.credentialCode;
|
|
}
|
|
|
|
if (nodeInfo.packageInfo) {
|
|
result.packageInfo = {
|
|
name: nodeInfo.packageInfo.name,
|
|
version: nodeInfo.packageInfo.version,
|
|
description: nodeInfo.packageInfo.description,
|
|
};
|
|
}
|
|
|
|
return result;
|
|
} catch (error) {
|
|
logger.error(`Failed to get node source code`, error);
|
|
throw new Error(`Failed to get node source code: ${error instanceof Error ? error.message : 'Unknown error'}`);
|
|
}
|
|
}
|
|
|
|
private async listAvailableNodes(args: any): Promise<any> {
|
|
try {
|
|
logger.info('Listing available nodes', args);
|
|
const nodes = await this.nodeExtractor.listAvailableNodes(args.category, args.search);
|
|
return {
|
|
nodes,
|
|
total: nodes.length,
|
|
};
|
|
} catch (error) {
|
|
logger.error(`Failed to list available nodes`, error);
|
|
throw new Error(`Failed to list available nodes: ${error instanceof Error ? error.message : 'Unknown error'}`);
|
|
}
|
|
}
|
|
|
|
|
|
private async getNodeInfo(args: any): Promise<any> {
|
|
try {
|
|
logger.info('Getting comprehensive node information', args);
|
|
const nodeInfo = await this.nodeDocService.getNodeInfo(args.nodeType);
|
|
|
|
if (!nodeInfo) {
|
|
throw new Error(`Node ${args.nodeType} not found`);
|
|
}
|
|
|
|
return {
|
|
nodeType: nodeInfo.nodeType,
|
|
name: nodeInfo.name,
|
|
displayName: nodeInfo.displayName,
|
|
description: nodeInfo.description,
|
|
category: nodeInfo.category,
|
|
subcategory: nodeInfo.subcategory,
|
|
icon: nodeInfo.icon,
|
|
documentation: {
|
|
markdown: nodeInfo.documentationMarkdown,
|
|
url: nodeInfo.documentationUrl,
|
|
title: nodeInfo.documentationTitle,
|
|
},
|
|
operations: nodeInfo.operations || [],
|
|
apiMethods: nodeInfo.apiMethods || [],
|
|
examples: nodeInfo.documentationExamples || [],
|
|
templates: nodeInfo.templates || [],
|
|
relatedResources: nodeInfo.relatedResources || [],
|
|
requiredScopes: nodeInfo.requiredScopes || [],
|
|
exampleWorkflow: nodeInfo.exampleWorkflow,
|
|
exampleParameters: nodeInfo.exampleParameters,
|
|
propertiesSchema: nodeInfo.propertiesSchema,
|
|
metadata: {
|
|
packageName: nodeInfo.packageName,
|
|
version: nodeInfo.version,
|
|
hasCredentials: nodeInfo.hasCredentials,
|
|
isTrigger: nodeInfo.isTrigger,
|
|
isWebhook: nodeInfo.isWebhook,
|
|
aliases: nodeInfo.aliases,
|
|
},
|
|
sourceCode: {
|
|
node: nodeInfo.sourceCode,
|
|
credential: nodeInfo.credentialCode,
|
|
},
|
|
};
|
|
} catch (error) {
|
|
logger.error(`Failed to get node info`, error);
|
|
throw new Error(`Failed to get node info: ${error instanceof Error ? error.message : 'Unknown error'}`);
|
|
}
|
|
}
|
|
|
|
private async searchNodes(args: any): Promise<any> {
|
|
try {
|
|
logger.info('Searching nodes with enhanced filtering', args);
|
|
const results = await this.nodeDocService.searchNodes({
|
|
query: args.query,
|
|
category: args.category,
|
|
packageName: args.packageName,
|
|
hasCredentials: args.hasCredentials,
|
|
isTrigger: args.isTrigger,
|
|
limit: args.limit || 20,
|
|
});
|
|
|
|
return {
|
|
nodes: results.map(node => ({
|
|
nodeType: node.nodeType,
|
|
name: node.name,
|
|
displayName: node.displayName,
|
|
description: node.description,
|
|
category: node.category,
|
|
packageName: node.packageName,
|
|
hasDocumentation: !!node.documentationMarkdown,
|
|
hasExamples: !!(node.documentationExamples && node.documentationExamples.length > 0),
|
|
operationCount: node.operations?.length || 0,
|
|
metadata: {
|
|
hasCredentials: node.hasCredentials,
|
|
isTrigger: node.isTrigger,
|
|
isWebhook: node.isWebhook,
|
|
},
|
|
})),
|
|
total: results.length,
|
|
};
|
|
} catch (error) {
|
|
logger.error(`Failed to search nodes`, error);
|
|
throw new Error(`Failed to search nodes: ${error instanceof Error ? error.message : 'Unknown error'}`);
|
|
}
|
|
}
|
|
|
|
private async getNodeStatistics(args: any): Promise<any> {
|
|
try {
|
|
logger.info(`Getting node statistics`);
|
|
const stats = await this.nodeDocService.getStatistics();
|
|
|
|
return {
|
|
...stats,
|
|
formattedTotalSize: stats.totalCodeSize ? `${(stats.totalCodeSize / 1024 / 1024).toFixed(2)} MB` : '0 MB',
|
|
};
|
|
} catch (error) {
|
|
logger.error(`Failed to get node statistics`, error);
|
|
throw new Error(`Failed to get node statistics: ${error instanceof Error ? error.message : 'Unknown error'}`);
|
|
}
|
|
}
|
|
|
|
private async rebuildDocumentationDatabase(args: any): Promise<any> {
|
|
try {
|
|
logger.info('Rebuilding documentation database', args);
|
|
const stats = await this.nodeDocService.rebuildDatabase();
|
|
|
|
return {
|
|
success: true,
|
|
message: 'Documentation database rebuilt successfully',
|
|
statistics: stats,
|
|
};
|
|
} catch (error) {
|
|
logger.error(`Failed to rebuild documentation database`, error);
|
|
throw new Error(`Failed to rebuild documentation database: ${error instanceof Error ? error.message : 'Unknown error'}`);
|
|
}
|
|
}
|
|
|
|
|
|
async start(): Promise<void> {
|
|
try {
|
|
logger.info('Starting n8n MCP server...');
|
|
const transport = new StdioServerTransport();
|
|
await this.server.connect(transport);
|
|
logger.info('n8n MCP server started successfully');
|
|
} catch (error) {
|
|
logger.error('Failed to start MCP server', error);
|
|
throw error;
|
|
}
|
|
}
|
|
} |