snow-flow 1.4.49 → 2.0.0

package/src/mcp/servicenow-graph-memory-mcp.ts

@@ -0,0 +1,832 @@
+#!/usr/bin/env node
+/**
+ * ServiceNow Graph Memory MCP Server
+ * Neo4j-based intelligent memory system for ServiceNow artifacts
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ErrorCode,
+  ListToolsRequestSchema,
+  McpError,
+} from '@modelcontextprotocol/sdk/types.js';
+import { Logger } from '../utils/logger.js';
+import { mcpConfig } from '../utils/mcp-config-manager.js';
+import neo4j, { Driver, Session } from 'neo4j-driver';
+
+interface ArtifactNode {
+  id: string;
+  name: string;
+  type: 'widget' | 'flow' | 'script_include' | 'business_rule' | 'table' | 'client_script' | 'ui_script';
+  content?: string;
+  purpose?: string;
+  complexity?: number;
+  last_updated?: string;
+  deployment_count?: number;
+  success_rate?: number;
+}
+
+interface ArtifactRelationship {
+  from: string;
+  to: string;
+  type: 'USES' | 'REQUIRES' | 'TRIGGERS' | 'CREATES' | 'MODIFIES' | 'CALLS' | 'EXTENDS';
+  strength?: number;
+  data_flow?: string;
+}
+
+interface ValidatedNeo4jConfig {
+  uri: string;
+  username: string;
+  password: string;
+  database?: string;
+}
+
+class ServiceNowGraphMemoryMCP {
+  private server: Server;
+  private logger: Logger;
+  private driver: Driver | null = null;
+  private config: ValidatedNeo4jConfig | null = null;
+  private neo4jAvailable: boolean = false;
+
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'servicenow-graph-memory',
+        version: '1.0.0',
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    this.logger = new Logger('ServiceNowGraphMemoryMCP');
+    const rawConfig = mcpConfig.getNeo4jConfig();
+    
+    // Validate Neo4j configuration - but don't fail if missing
+    if (!rawConfig?.uri || !rawConfig?.username || !rawConfig?.password) {
+      this.logger.warn('Neo4j configuration missing. Graph Memory MCP will run in fallback mode without Neo4j functionality.');
+      this.logger.info('To enable Neo4j: set NEO4J_URI, NEO4J_USERNAME, and NEO4J_PASSWORD environment variables.');
+      this.neo4jAvailable = false;
+    } else {
+      // After validation, we know these are defined
+      this.config = {
+        uri: rawConfig.uri,
+        username: rawConfig.username,
+        password: rawConfig.password,
+        database: rawConfig.database
+      };
+      this.neo4jAvailable = true;
+    }
+
+    this.setupHandlers();
+  }
+
+  private createFallbackResponse(toolName: string): any {
+    return {
+      success: false,
+      message: `${toolName} requires Neo4j database. Please install and configure Neo4j to use graph memory features.`,
+      fallback_mode: true,
+      instructions: [
+        '1. Install Neo4j Community Edition',
+        '2. Start Neo4j service',
+        '3. Set environment variables: NEO4J_URI, NEO4J_USERNAME, NEO4J_PASSWORD',
+        '4. Restart the MCP server'
+      ]
+    };
+  }
+
+  private async connectToNeo4j() {
+    if (!this.neo4jAvailable || !this.config) {
+      this.logger.warn('Neo4j not available - using fallback mode');
+      return;
+    }
+    
+    if (!this.driver) {
+      try {
+        this.driver = neo4j.driver(
+          this.config.uri,
+          neo4j.auth.basic(this.config.username, this.config.password)
+        );
+        await this.driver.verifyConnectivity();
+        this.logger.info('Connected to Neo4j');
+        
+        // Create indexes for better performance
+        const session = this.driver.session();
+        try {
+          await session.run('CREATE INDEX artifact_id IF NOT EXISTS FOR (a:Artifact) ON (a.id)');
+          await session.run('CREATE INDEX artifact_type IF NOT EXISTS FOR (a:Artifact) ON (a.type)');
+          await session.run('CREATE INDEX artifact_name IF NOT EXISTS FOR (a:Artifact) ON (a.name)');
+        } finally {
+          await session.close();
+        }
+      } catch (error) {
+        this.logger.error('Failed to connect to Neo4j', error);
+        this.neo4jAvailable = false;
+        if (this.driver) {
+          await this.driver.close();
+          this.driver = null;
+        }
+        throw error;
+      }
+    }
+    return this.driver;
+  }
+
+  private setupHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: 'snow_graph_index_artifact',
+          description: 'AUTONOMOUS graph indexing - stores ServiceNow artifacts in Neo4j with relationships, enables instant understanding of dependencies and connections',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              artifact: {
+                type: 'object',
+                properties: {
+                  id: { type: 'string', description: 'Unique identifier for the artifact' },
+                  name: { type: 'string', description: 'Artifact name' },
+                  type: { type: 'string', enum: ['widget', 'flow', 'script_include', 'business_rule', 'table', 'client_script', 'ui_script'] },
+                  content: { type: 'string', description: 'Full content/code of the artifact' },
+                  purpose: { type: 'string', description: 'What this artifact does' },
+                },
+                required: ['id', 'name', 'type'],
+              },
+              relationships: {
+                type: 'array',
+                description: 'Relationships to other artifacts',
+                items: {
+                  type: 'object',
+                  properties: {
+                    to: { type: 'string', description: 'Target artifact ID' },
+                    type: { type: 'string', enum: ['USES', 'REQUIRES', 'TRIGGERS', 'CREATES', 'MODIFIES', 'CALLS', 'EXTENDS'] },
+                    data_flow: { type: 'string', description: 'How data flows between artifacts' },
+                  },
+                },
+              },
+            },
+            required: ['artifact'],
+          },
+        },
+        {
+          name: 'snow_graph_find_related',
+          description: 'INTELLIGENT relationship discovery - finds all artifacts related to a given artifact, understands dependencies, data flows, and impact _analysis',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              artifact_id: { type: 'string', description: 'Artifact ID to find relationships for' },
+              depth: { type: 'number', description: 'How many levels of relationships to traverse', default: 2 },
+              relationship_types: {
+                type: 'array',
+                description: 'Filter by relationship types',
+                items: { type: 'string', enum: ['USES', 'REQUIRES', 'TRIGGERS', 'CREATES', 'MODIFIES', 'CALLS', 'EXTENDS'] },
+              },
+            },
+            required: ['artifact_id'],
+          },
+        },
+        {
+          name: 'snow_graph_analyze_impact',
+          description: 'IMPACT ANALYSIS - shows what will be affected if an artifact is modified, critical for safe deployments',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              artifact_id: { type: 'string', description: 'Artifact to analyze impact for' },
+              change_type: { type: 'string', enum: ['modify', 'delete', 'upgrade'], description: 'Type of change planned' },
+            },
+            required: ['artifact_id'],
+          },
+        },
+        {
+          name: 'snow_graph_suggest_artifacts',
+          description: 'AI-POWERED suggestions - recommends artifacts based on current context and past successful patterns',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              context: { type: 'string', description: 'Current development context' },
+              artifact_type: { type: 'string', description: 'Type of artifact needed' },
+              requirements: { type: 'array', items: { type: 'string' }, description: 'Specific requirements' },
+            },
+            required: ['context'],
+          },
+        },
+        {
+          name: 'snow_graph_pattern__analysis',
+          description: 'PATTERN RECOGNITION - identifies common patterns, best practices, and reusable components across all artifacts',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              pattern_type: { type: 'string', enum: ['architectural', 'coding', 'integration', 'error_handling'], description: 'Type of pattern to analyze' },
+              min_occurrences: { type: 'number', description: 'Minimum times pattern must appear', default: 3 },
+            },
+          },
+        },
+        {
+          name: 'snow_graph_visualize',
+          description: 'GRAPH VISUALIZATION - generates Cypher queries for visualizing artifact relationships in Neo4j Browser',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              focus_artifact: { type: 'string', description: 'Central artifact to visualize around' },
+              include_types: { type: 'array', items: { type: 'string' }, description: 'Artifact types to include' },
+              max_nodes: { type: 'number', description: 'Maximum nodes to display', default: 50 },
+            },
+          },
+        },
+        {
+          name: 'snow_graph_export_knowledge',
+          description: 'KNOWLEDGE EXPORT - exports learned patterns and relationships for backup or sharing',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              format: { type: 'string', enum: ['cypher', 'json', 'graphml'], description: 'Export format' },
+              include_content: { type: 'boolean', description: 'Include full artifact content', default: false },
+            },
+          },
+        },
+      ],
+    }));
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      try {
+        await this.connectToNeo4j();
+
+        switch (name) {
+          case 'snow_graph_index_artifact':
+            return await this.indexArtifact(args);
+          case 'snow_graph_find_related':
+            return await this.findRelatedArtifacts(args);
+          case 'snow_graph_analyze_impact':
+            return await this.analyzeImpact(args);
+          case 'snow_graph_suggest_artifacts':
+            return await this.suggestArtifacts(args);
+          case 'snow_graph_pattern__analysis':
+            return await this.analyzePatterns(args);
+          case 'snow_graph_visualize':
+            return await this.generateVisualization(args);
+          case 'snow_graph_export_knowledge':
+            return await this.exportKnowledge(args);
+          default:
+            throw new McpError(
+              ErrorCode.MethodNotFound,
+              `Unknown tool: ${name}`
+            );
+        }
+      } catch (error) {
+        this.logger.error(`Tool execution failed: ${name}`, error);
+        throw new McpError(
+          ErrorCode.InternalError,
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    });
+  }
+
+  private async indexArtifact(args: any) {
+    if (!this.neo4jAvailable || !this.driver) {
+      return this.createFallbackResponse('snow_graph_index_artifact');
+    }
+    
+    const session = this.driver.session();
+    try {
+      const { artifact, relationships = [] } = args;
+
+      // Create or update the artifact node
+      await session.run(
+        `
+        MERGE (a:Artifact {id: $id})
+        SET a.name = $name,
+            a.type = $type,
+            a.content = $content,
+            a.purpose = $purpose,
+            a.last_updated = datetime(),
+            a.indexed_at = datetime()
+        RETURN a
+        `,
+        artifact
+      );
+
+      // Create relationships
+      for (const rel of relationships) {
+        await session.run(
+          `
+          MATCH (a:Artifact {id: $fromId})
+          MERGE (b:Artifact {id: $toId})
+          MERGE (a)-[r:${rel.type}]->(b)
+          SET r.data_flow = $dataFlow,
+              r.created_at = datetime()
+          `,
+          {
+            fromId: artifact.id,
+            toId: rel.to,
+            dataFlow: rel.data_flow || ''
+          }
+        );
+      }
+
+      // Analyze artifact content for automatic relationship discovery
+      const discoveredRelations = await this.discoverRelationships(artifact);
+      
+      return {
+        content: [{
+          type: 'text',
+          text: `✅ Artifact indexed successfully!
+
+📊 **Artifact Details:**
+- ID: ${artifact.id}
+- Name: ${artifact.name}
+- Type: ${artifact.type}
+- Relationships: ${relationships.length} explicit, ${discoveredRelations} discovered
+
+🔗 **Graph Impact:**
+- Node created/updated in Neo4j
+- Relationships established
+- Available for pattern analysis
+- Ready for impact assessment
+
+💡 **Next Steps:**
+- Use snow_graph_find_related to explore connections
+- Use snow_graph_analyze_impact before modifications
+- Use snow_graph_pattern__analysis to find similar artifacts`
+        }]
+      };
+    } finally {
+      await session.close();
+    }
+  }
+
+  private async discoverRelationships(artifact: any): Promise<number> {
+    // Analyze artifact content to discover implicit relationships
+    const content = artifact.content || '';
+    const discoveries: string[] = [];
+
+    // Find script includes used
+    const scriptIncludeMatches = content.match(/new\s+(\w+)\(/g) || [];
+    for (const match of scriptIncludeMatches) {
+      const className = match.match(/new\s+(\w+)\(/)?.[1];
+      if (className) discoveries.push(className);
+    }
+
+    // Find table references
+    const tableMatches = content.match(/GlideRecord\(['"](\w+)['"]\)/g) || [];
+    for (const match of tableMatches) {
+      const tableName = match.match(/GlideRecord\(['"](\w+)['"]\)/)?.[1];
+      if (tableName) discoveries.push(tableName);
+    }
+
+    return discoveries.length;
+  }
+
+  private async findRelatedArtifacts(args: any) {
+    if (!this.neo4jAvailable || !this.driver) {
+      return this.createFallbackResponse('snow_graph_find_related');
+    }
+    
+    const session = this.driver!.session();
+    try {
+      const { artifact_id, depth = 2, relationship_types = [] } = args;
+
+      const relFilter = relationship_types.length > 0 
+        ? `WHERE type(r) IN [${relationship_types.map((t: string) => `'${t}'`).join(', ')}]`
+        : '';
+
+      const result = await session.run(
+        `
+        MATCH (start:Artifact {id: $artifactId})
+        CALL apoc.path.subgraphAll(start, {
+          maxLevel: $depth,
+          relationshipFilter: "${relFilter}"
+        })
+        YIELD nodes, relationships
+        RETURN nodes, relationships
+        `,
+        { artifactId: artifact_id, depth }
+      );
+
+      const nodes = result.records[0]?.get('nodes') || [];
+      const relationships = result.records[0]?.get('relationships') || [];
+
+      return {
+        content: [{
+          type: 'text',
+          text: `🔗 Related Artifacts Found:
+
+📊 **Summary:**
+- Total artifacts: ${nodes.length}
+- Total relationships: ${relationships.length}
+- Search depth: ${depth} levels
+
+🗂️ **Artifacts:**
+${nodes.map((n: any) => `- ${n.properties.type}: ${n.properties.name} (${n.properties.id})`).join('\n')}
+
+🔀 **Relationships:**
+${relationships.map((r: any) => `- ${r.type}: ${r.start} → ${r.end}`).join('\n')}
+
+💡 **Insights:**
+- This artifact is part of a ${nodes.length > 10 ? 'complex' : 'simple'} dependency network
+- ${relationships.filter((r: any) => r.type === 'REQUIRES').length} required dependencies
+- ${relationships.filter((r: any) => r.type === 'USES').length} usage relationships`
+        }]
+      };
+    } finally {
+      await session.close();
+    }
+  }
+
+  private async analyzeImpact(args: any) {
+    if (!this.neo4jAvailable || !this.driver) {
+      return this.createFallbackResponse('snow_graph_analyze_impact');
+    }
+    
+    const session = this.driver!.session();
+    try {
+      const { artifact_id, change_type = 'modify' } = args;
+
+      // Find all artifacts that depend on this one
+      const result = await session.run(
+        `
+        MATCH (target:Artifact {id: $artifactId})
+        MATCH (dependent:Artifact)-[:USES|REQUIRES|CALLS]->(target)
+        RETURN dependent, count(*) as impact_count
+        ORDER BY impact_count DESC
+        `,
+        { artifactId: artifact_id }
+      );
+
+      const impactedArtifacts = result.records.map((r: any) => ({
+        artifact: r.get('dependent').properties,
+        impact: r.get('impact_count').toNumber()
+      }));
+
+      const riskLevel = impactedArtifacts.length > 5 ? 'HIGH' : 
+                       impactedArtifacts.length > 2 ? 'MEDIUM' : 'LOW';
+
+      return {
+        content: [{
+          type: 'text',
+          text: `⚠️ Impact Analysis for ${change_type} operation:
+
+🎯 **Target Artifact:** ${artifact_id}
+
+📊 **Impact Summary:**
+- Affected artifacts: ${impactedArtifacts.length}
+- Risk level: ${riskLevel}
+- Change type: ${change_type}
+
+🔗 **Affected Artifacts:**
+${impactedArtifacts.map((a: any) => `- ${a.artifact.type}: ${a.artifact.name} (Impact: ${a.impact})`).join('\n')}
+
+⚡ **Recommendations:**
+${riskLevel === 'HIGH' ? '- Create comprehensive test plan\n- Consider phased deployment\n- Notify all stakeholders' :
+  riskLevel === 'MEDIUM' ? '- Test affected components\n- Review integration points' :
+  '- Safe to proceed with standard testing'}
+
+🛡️ **Safety Measures:**
+- ${change_type === 'delete' ? 'Archive artifact before deletion' : 'Create backup before modification'}
+- Update all dependent artifacts
+- Run integration tests`
+        }]
+      };
+    } finally {
+      await session.close();
+    }
+  }
+
+  private async suggestArtifacts(args: any) {
+    if (!this.neo4jAvailable || !this.driver) {
+      return this.createFallbackResponse('snow_graph_suggest_artifacts');
+    }
+    
+    const session = this.driver!.session();
+    try {
+      const { context, artifact_type, requirements = [] } = args;
+
+      // Find similar contexts and successful patterns
+      const result = await session.run(
+        `
+        MATCH (a:Artifact)
+        WHERE a.purpose CONTAINS $context
+        ${artifact_type ? 'AND a.type = $artifactType' : ''}
+        WITH a
+        MATCH (a)-[r]-(related:Artifact)
+        RETURN a, collect(related) as related_artifacts
+        ORDER BY a.deployment_count DESC, a.success_rate DESC
+        LIMIT 10
+        `,
+        { context, artifactType: artifact_type }
+      );
+
+      const suggestions = result.records.map((r: any) => ({
+        artifact: r.get('a').properties,
+        related: r.get('related_artifacts').map((n: any) => n.properties)
+      }));
+
+      return {
+        content: [{
+          type: 'text',
+          text: `🤖 AI-Powered Artifact Suggestions:
+
+📋 **Context:** ${context}
+${artifact_type ? `📦 **Type:** ${artifact_type}` : ''}
+
+✨ **Recommended Artifacts:**
+${suggestions.map((s: any, i: number) => `
+${i + 1}. **${s.artifact.name}** (${s.artifact.type})
+   - Purpose: ${s.artifact.purpose || 'General purpose'}
+   - Success rate: ${s.artifact.success_rate || 'Not measured'}%
+   - Used with: ${s.related.map((r: any) => r.name).join(', ')}
+`).join('\n')}
+
+🎯 **Pattern Analysis:**
+- Most successful pattern: ${suggestions[0]?.artifact.name || 'No patterns found'}
+- Common dependencies: ${this.findCommonDependencies(suggestions)}
+- Recommended architecture: ${this.suggestArchitecture(suggestions)}
+
+💡 **Implementation Tips:**
+- Start with the highest success rate artifact
+- Check compatibility with existing components
+- Consider the related artifacts for complete solution`
+        }]
+      };
+    } finally {
+      await session.close();
+    }
+  }
+
+  private findCommonDependencies(suggestions: any[]): string {
+    const deps = new Map<string, number>();
+    suggestions.forEach((s: any) => {
+      s.related.forEach((r: any) => {
+        deps.set(r.name, (deps.get(r.name) || 0) + 1);
+      });
+    });
+    
+    const sorted = Array.from(deps.entries())
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 3)
+      .map(([name]) => name);
+    
+    return sorted.join(', ') || 'None identified';
+  }
+
+  private suggestArchitecture(suggestions: any[]): string {
+    const types = suggestions.map(s => s.artifact.type);
+    if (types.includes('flow') && types.includes('script_include')) {
+      return 'Flow-based with script include utilities';
+    } else if (types.includes('widget') && types.includes('client_script')) {
+      return 'UI-centric with client-side logic';
+    } else if (types.includes('business_rule')) {
+      return 'Event-driven with business rules';
+    }
+    return 'Standard ServiceNow pattern';
+  }
+
+  private async analyzePatterns(args: any) {
+    if (!this.neo4jAvailable || !this.driver) {
+      return this.createFallbackResponse('snow_graph_pattern__analysis');
+    }
+    
+    const session = this.driver!.session();
+    try {
+      const { pattern_type = 'architectural', min_occurrences = 3 } = args;
+
+      // This would be more sophisticated in production
+      const query = pattern_type === 'architectural' ? `
+        MATCH (a:Artifact)-[r]->(b:Artifact)
+        WITH type(r) as relType, a.type as sourceType, b.type as targetType, count(*) as occurrences
+        WHERE occurrences >= $minOccurrences
+        RETURN sourceType, relType, targetType, occurrences
+        ORDER BY occurrences DESC
+      ` : `
+        MATCH (a:Artifact)
+        WHERE a.content IS NOT NULL
+        RETURN a.type, count(*) as count
+        ORDER BY count DESC
+      `;
+
+      const result = await session.run(query, { minOccurrences: min_occurrences });
+
+      return {
+        content: [{
+          type: 'text',
+          text: `🔍 Pattern Analysis Results:
+
+📊 **Pattern Type:** ${pattern_type}
+🔢 **Minimum Occurrences:** ${min_occurrences}
+
+📈 **Discovered Patterns:**
+${result.records.map((r: any) => {
+  if (pattern_type === 'architectural') {
+    return `- ${r.get('sourceType')} → ${r.get('relType')} → ${r.get('targetType')} (${r.get('occurrences')} times)`;
+  } else {
+    return `- ${r.get('type')}: ${r.get('count')} artifacts`;
+  }
+}).join('\n')}
+
+💡 **Insights:**
+- Most common pattern: ${result.records[0] ? this.describePattern(result.records[0], pattern_type) : 'No patterns found'}
+- Recommended approach: Follow the established patterns for consistency
+- Optimization opportunity: Reuse common patterns as templates`
+        }]
+      };
+    } finally {
+      await session.close();
+    }
+  }
+
+  private describePattern(record: any, patternType: string): string {
+    if (patternType === 'architectural') {
+      return `${record.get('sourceType')} components typically ${record.get('relType').toLowerCase()} ${record.get('targetType')} components`;
+    }
+    return `${record.get('type')} is the most common artifact type`;
+  }
+
+  private async generateVisualization(args: any) {
+    if (!this.neo4jAvailable || !this.driver) {
+      return this.createFallbackResponse('snow_graph_visualize');
+    }
+    
+    const { focus_artifact, include_types = [], max_nodes = 50 } = args;
+
+    const typeFilter = include_types.length > 0 
+      ? `WHERE n.type IN [${include_types.map((t: string) => `'${t}'`).join(', ')}]`
+      : '';
+
+    const cypherQuery = focus_artifact ? `
+      MATCH (center:Artifact {id: '${focus_artifact}'})
+      CALL apoc.path.subgraphAll(center, {
+        maxLevel: 3,
+        limit: ${max_nodes}
+      })
+      YIELD nodes, relationships
+      ${typeFilter}
+      RETURN nodes, relationships
+    ` : `
+      MATCH (n:Artifact)
+      ${typeFilter}
+      WITH n LIMIT ${max_nodes}
+      MATCH (n)-[r]-(m:Artifact)
+      RETURN n, r, m
+    `;
+
+    return {
+      content: [{
+        type: 'text',
+        text: `🎨 Graph Visualization Query:
+
+\`\`\`cypher
+${cypherQuery}
+\`\`\`
+
+📊 **Visualization Settings:**
+- Focus: ${focus_artifact || 'All artifacts'}
+- Types: ${include_types.join(', ') || 'All types'}
+- Max nodes: ${max_nodes}
+
+🖥️ **To Visualize:**
+1. Open Neo4j Browser
+2. Paste the query above
+3. Click Run
+4. Use the graph view for interactive exploration
+
+🎯 **Visualization Tips:**
+- Click nodes to see properties
+- Drag nodes to rearrange
+- Double-click to expand connections
+- Use filters to focus on specific relationships`
+      }]
+    };
+  }
+
+  private async exportKnowledge(args: any) {
+    if (!this.neo4jAvailable || !this.driver) {
+      return this.createFallbackResponse('snow_graph_export_knowledge');
+    }
+    
+    const session = this.driver!.session();
+    try {
+      const { format = 'json', include_content = false } = args;
+
+      if (format === 'cypher') {
+        return {
+          content: [{
+            type: 'text',
+            text: `📤 Export Script (Cypher):
+
+\`\`\`cypher
+// Create indexes
+CREATE INDEX artifact_id IF NOT EXISTS FOR (a:Artifact) ON (a.id);
+CREATE INDEX artifact_type IF NOT EXISTS FOR (a:Artifact) ON (a.type);
+
+// Export all artifacts
+MATCH (a:Artifact)
+RETURN a.id, a.name, a.type, a.purpose${include_content ? ', a.content' : ''};
+
+// Export all relationships
+MATCH (a:Artifact)-[r]->(b:Artifact)
+RETURN a.id, type(r), b.id, r.data_flow;
+\`\`\`
+
+💾 **Usage:**
+1. Run in target Neo4j instance
+2. Import will recreate the knowledge graph
+3. All patterns and relationships preserved`
+          }]
+        };
+      } else {
+        const artifacts = await session.run('MATCH (a:Artifact) RETURN a');
+        const relationships = await session.run('MATCH (a:Artifact)-[r]->(b:Artifact) RETURN a.id as from, type(r) as type, b.id as to');
+
+        const exportData = {
+          artifacts: artifacts.records.map((r: any) => r.get('a').properties),
+          relationships: relationships.records.map((r: any) => ({
+            from: r.get('from'),
+            type: r.get('type'),
+            to: r.get('to')
+          })),
+          metadata: {
+            exported_at: new Date().toISOString(),
+            total_artifacts: artifacts.records.length,
+            total_relationships: relationships.records.length
+          }
+        };
+
+        return {
+          content: [{
+            type: 'text',
+            text: `📤 Knowledge Export Complete:
+
+\`\`\`json
+${JSON.stringify(exportData, null, 2).substring(0, 1000)}...
+\`\`\`
+
+📊 **Export Summary:**
+- Format: ${format}
+- Artifacts: ${exportData.metadata.total_artifacts}
+- Relationships: ${exportData.metadata.total_relationships}
+- Content included: ${include_content ? 'Yes' : 'No'}
+
+💾 **Next Steps:**
+1. Save the export to a file
+2. Use for backup or migration
+3. Share with team members
+4. Import into another instance`
+          }]
+        };
+      }
+    } finally {
+      await session.close();
+    }
+  }
+
+  async start() {
+    try {
+      // Try to connect to Neo4j if configured
+      if (this.neo4jAvailable && this.config) {
+        try {
+          await this.connectToNeo4j();
+          this.logger.info('Neo4j connection established');
+        } catch (error) {
+          this.logger.warn('Neo4j connection failed - running in fallback mode', error);
+          this.neo4jAvailable = false;
+        }
+      }
+      
+      const transport = new StdioServerTransport();
+      await this.server.connect(transport);
+      this.logger.info('ServiceNow Graph Memory MCP Server started');
+      
+      if (!this.neo4jAvailable) {
+        this.logger.info('Running without Neo4j - all operations will return fallback responses');
+      }
+    } catch (error) {
+      this.logger.error('Failed to start server', error);
+      throw error;
+    }
+  }
+
+  async stop() {
+    if (this.driver) {
+      await this.driver.close();
+    }
+  }
+}
+
+// Start the server
+const server = new ServiceNowGraphMemoryMCP();
+server.start().catch((error) => {
+  console.error('Failed to start ServiceNow Graph Memory MCP:', error);
+  process.exit(1);
+});
+
+// Graceful shutdown
+process.on('SIGINT', async () => {
+  await server.stop();
+  process.exit(0);
+});