Zanny's Persistent Memory Manager

Verified
Knowledge & Memory
Overview InspectNew Schema Related Servers Reviews Score
mcp-memory-bank-1
src
import express from 'express';
import { MemoryManager, Memory } from './memoryManager';
import { config } from './config';
import logger from './logger';

// Interfaces for JSON-RPC
interface JsonRpcRequest {
  jsonrpc: string;
  id: string | number;
  method: string;
  params?: any;
}

interface JsonRpcResponse {
  jsonrpc: string;
  id: string | number;
  result?: any;
  error?: {
    code: number;
    message: string;
    data?: any;
  };
}

// MCP Tool interfaces
interface Tool {
  name: string;
  description: string;
  parameters: {
    type: string;
    properties?: Record<string, any>;
    required?: string[];
  };
}

export class MCPServer {
  private app: express.Application;
  private memoryManager: MemoryManager;
  
  constructor() {
    this.app = express();
    this.memoryManager = new MemoryManager();
    this.setupMiddleware();
    this.setupRoutes();
  }
  
  /**
   * Set up middleware for the Express application
   */
  private setupMiddleware(): void {
    this.app.use(express.json({ limit: '50mb' })); // Allow large payloads
    this.app.use(express.urlencoded({ extended: true }));
    
    // Log all requests using structured logging to avoid interfering with JSON-RPC
    this.app.use((req, res, next) => {
      logger.info(JSON.stringify({
        method: req.method,
        url: req.url,
        timestamp: new Date().toISOString()
      }));
      next();
    });
  }
  
  /**
   * Set up routes for the Express application
   */
  private setupRoutes(): void {
    // Health check
    this.app.get('/health', (req, res) => {
      res.status(200).json({ status: 'OK', name: config.name });
    });
    
    // MCP JSON-RPC endpoints
    this.app.post('/tools/list', this.handleToolsList.bind(this));
    this.app.post('/tools/call', this.handleToolsCall.bind(this));
    
    // Legacy API routes (keeping for backward compatibility)
    this.app.post('/api/memories', this.storeMemory.bind(this));
    this.app.get('/api/memories', this.listMemories.bind(this));
    this.app.get('/api/memories/:id', this.getMemory.bind(this));
    this.app.delete('/api/memories/:id', this.deleteMemory.bind(this));
    this.app.post('/api/detect', this.detectTriggers.bind(this));
    
    // Error handler
    this.app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
      const errorObj = { error: err.message };
      logger.error(JSON.stringify(errorObj));
      res.status(500).json(errorObj);
    });
  }
  
  /**
   * Handle JSON-RPC tools/list request
   */
  private handleToolsList(req: express.Request, res: express.Response): void {
    const jsonRpcReq = req.body as JsonRpcRequest;
    
    // Validate JSON-RPC request
    if (!this.isValidJsonRpcRequest(jsonRpcReq)) {
      res.status(400).json(this.createJsonRpcError(
        jsonRpcReq?.id || null,
        -32600,
        'Invalid JSON-RPC request'
      ));
      return;
    }

    // List of available tools
    const tools: Tool[] = [
      {
        name: 'store_memory',
        description: 'Store a new memory in the memory bank',
        parameters: {
          type: 'object',
          properties: {
            content: {
              type: 'string',
              description: 'Memory content to store'
            },
            tags: {
              type: 'array',
              items: {
                type: 'string'
              },
              description: 'Optional tags for the memory'
            }
          },
          required: ['content']
        }
      },
      {
        name: 'retrieve_memory',
        description: 'Retrieve a memory by its ID',
        parameters: {
          type: 'object',
          properties: {
            id: {
              type: 'string',
              description: 'Memory ID to retrieve'
            }
          },
          required: ['id']
        }
      },
      {
        name: 'search_memories',
        description: 'Search memories by content or tags',
        parameters: {
          type: 'object',
          properties: {
            search: {
              type: 'string',
              description: 'Search term to look for in memory content'
            },
            tags: {
              type: 'array',
              items: {
                type: 'string'
              },
              description: 'Tags to filter memories by'
            }
          }
        }
      },
      {
        name: 'list_memories',
        description: 'List all stored memories',
        parameters: {
          type: 'object',
          properties: {}
        }
      },
      {
        name: 'delete_memory',
        description: 'Delete a memory by its ID',
        parameters: {
          type: 'object',
          properties: {
            id: {
              type: 'string',
              description: 'Memory ID to delete'
            }
          },
          required: ['id']
        }
      },
      {
        name: 'detect_command',
        description: 'Detect and process memory commands in natural language text',
        parameters: {
          type: 'object',
          properties: {
            text: {
              type: 'string',
              description: 'Natural language text to analyze for memory commands'
            }
          },
          required: ['text']
        }
      }
    ];
    
    // Create JSON-RPC response
    const response: JsonRpcResponse = {
      jsonrpc: '2.0',
      id: jsonRpcReq.id,
      result: tools
    };
    
    res.status(200).json(response);
  }
  
  /**
   * Handle JSON-RPC tools/call request
   */
  private async handleToolsCall(req: express.Request, res: express.Response): Promise<void> {
    const jsonRpcReq = req.body as JsonRpcRequest;
    
    // Validate JSON-RPC request
    if (!this.isValidJsonRpcRequest(jsonRpcReq)) {
      res.status(400).json(this.createJsonRpcError(
        jsonRpcReq?.id || null,
        -32600,
        'Invalid JSON-RPC request'
      ));
      return;
    }

    const toolName = jsonRpcReq.params?.name;
    const toolParams = jsonRpcReq.params?.parameters || {};
    
    try {
      let result;
      
      // Call the appropriate tool function based on the tool name
      switch (toolName) {
        case 'store_memory':
          result = await this.memoryManager.storeMemory(toolParams.content, toolParams.tags);
          break;
        
        case 'retrieve_memory':
          result = await this.memoryManager.getMemoryById(toolParams.id);
          if (!result) {
            res.status(200).json(this.createJsonRpcError(
              jsonRpcReq.id,
              404,
              'Memory not found'
            ));
            return;
          }
          break;
        
        case 'search_memories':
          result = await this.memoryManager.searchMemories(
            toolParams.search,
            toolParams.tags
          );
          break;
        
        case 'list_memories':
          result = await this.memoryManager.listAllMemories();
          break;
        
        case 'delete_memory':
          result = await this.memoryManager.deleteMemory(toolParams.id);
          if (!result) {
            res.status(200).json(this.createJsonRpcError(
              jsonRpcReq.id,
              404,
              'Memory not found'
            ));
            return;
          }
          result = { success: true, message: `Memory with ID ${toolParams.id} has been deleted` };
          break;
        
        case 'detect_command':
          result = await this.processCommand(toolParams.text);
          break;
        
        default:
          res.status(200).json(this.createJsonRpcError(
            jsonRpcReq.id,
            -32601,
            'Method not found',
            { toolName }
          ));
          return;
      }
      
      // Create JSON-RPC response
      const response: JsonRpcResponse = {
        jsonrpc: '2.0',
        id: jsonRpcReq.id,
        result
      };
      
      res.status(200).json(response);
    } catch (error: any) {
      // Create JSON-RPC error response
      const errorResponse = this.createJsonRpcError(
        jsonRpcReq.id,
        -32000,
        error.message || 'Server error',
        { stack: error.stack }
      );
      
      res.status(200).json(errorResponse);
    }
  }
  
  /**
   * Validate a JSON-RPC request
   */
  private isValidJsonRpcRequest(req: any): boolean {
    return (
      req &&
      req.jsonrpc === '2.0' &&
      req.id !== undefined &&
      typeof req.method === 'string'
    );
  }
  
  /**
   * Create a JSON-RPC error response
   */
  private createJsonRpcError(
    id: string | number | null,
    code: number,
    message: string,
    data?: any
  ): JsonRpcResponse {
    return {
      jsonrpc: '2.0',
      id: id === null ? 0 : id,
      error: {
        code,
        message,
        ...(data ? { data } : {})
      }
    };
  }
  
  /**
   * Start the MCP server
   */
  public start(): void {
    const port = config.port;
    this.app.listen(port, () => {
      logger.info(JSON.stringify({
        event: 'server_start',
        name: config.name,
        port,
        timestamp: new Date().toISOString()
      }));
    });
  }
  
  /**
   * Store a new memory
   */
  private async storeMemory(req: express.Request, res: express.Response): Promise<void> {
    try {
      const { content, tags } = req.body;
      
      if (!content) {
        res.status(400).json({ error: 'Content is required' });
        return;
      }
      
      const memory = await this.memoryManager.storeMemory(content, tags);
      res.status(201).json(memory);
    } catch (error) {
      logger.error(`Error storing memory: ${error}`);
      res.status(500).json({ error: `Failed to store memory: ${error}` });
    }
  }
  
  /**
   * Get a specific memory by ID
   */
  private async getMemory(req: express.Request, res: express.Response): Promise<void> {
    try {
      const { id } = req.params;
      const memory = await this.memoryManager.getMemoryById(id);
      
      if (!memory) {
        res.status(404).json({ error: 'Memory not found' });
        return;
      }
      
      res.status(200).json(memory);
    } catch (error) {
      logger.error(`Error getting memory: ${error}`);
      res.status(500).json({ error: `Failed to get memory: ${error}` });
    }
  }
  
  /**
   * List or search memories
   */
  private async listMemories(req: express.Request, res: express.Response): Promise<void> {
    try {
      const { search, tags } = req.query;
      let memories: Memory[];
      
      if (search || tags) {
        const tagsArray = tags ? String(tags).split(',') : undefined;
        memories = await this.memoryManager.searchMemories(
          search ? String(search) : undefined, 
          tagsArray
        );
      } else {
        memories = await this.memoryManager.listAllMemories();
      }
      
      res.status(200).json(memories);
    } catch (error) {
      logger.error(`Error listing memories: ${error}`);
      res.status(500).json({ error: `Failed to list memories: ${error}` });
    }
  }
  
  /**
   * Delete a memory by ID
   */
  private async deleteMemory(req: express.Request, res: express.Response): Promise<void> {
    try {
      const { id } = req.params;
      const deleted = await this.memoryManager.deleteMemory(id);
      
      if (!deleted) {
        res.status(404).json({ error: 'Memory not found' });
        return;
      }
      
      res.status(204).send();
    } catch (error) {
      logger.error(`Error deleting memory: ${error}`);
      res.status(500).json({ error: `Failed to delete memory: ${error}` });
    }
  }
  
  /**
   * Detect trigger keywords in text
   */
  private async detectTriggers(req: express.Request, res: express.Response): Promise<void> {
    try {
      const { text } = req.body;
      
      if (!text) {
        res.status(400).json({ error: 'Text is required' });
        return;
      }
      
      const lowerText = text.toLowerCase();
      const triggers = config.triggerKeywords.filter(keyword => 
        lowerText.includes(keyword.toLowerCase())
      );
      
      const triggered = triggers.length > 0;
      logger.info(`Trigger detection: ${triggered ? 'Triggered' : 'Not triggered'} by "${text}"`);
      
      if (triggered) {
        // Check for command patterns
        const result = this.processCommand(text);
        res.status(200).json({
          triggered,
          triggers,
          result
        });
      } else {
        res.status(200).json({
          triggered,
          triggers: []
        });
      }
    } catch (error) {
      logger.error(`Error detecting triggers: ${error}`);
      res.status(500).json({ error: `Failed to detect triggers: ${error}` });
    }
  }
  
  /**
   * Process a command based on the input text
   */
  private async processCommand(text: string): Promise<any> {
    const lowerText = text.toLowerCase();
    
    // Store memory pattern
    const storePattern = /(remember|store|save|memorize)( this)?:? (.*)/i;
    const storeMatch = text.match(storePattern);
    
    if (storeMatch && storeMatch[3]) {
      const content = storeMatch[3].trim();
      const memory = await this.memoryManager.storeMemory(content);
      return {
        action: 'store',
        memory,
        message: `I've stored that memory for you. You can reference it with ID: ${memory.id}`
      };
    }
    
    // Recall memory pattern (by search)
    const recallPattern = /(recall|remember|retrieve|get)( memory)? (about|regarding|related to|on)? (.*)/i;
    const recallMatch = text.match(recallPattern);
    
    if (recallMatch && recallMatch[4]) {
      const searchTerm = recallMatch[4].trim();
      const memories = await this.memoryManager.searchMemories(searchTerm);
      
      if (memories.length > 0) {
        return {
          action: 'recall',
          memories,
          message: `I found ${memories.length} memories about "${searchTerm}"`
        };
      } else {
        return {
          action: 'recall',
          memories: [],
          message: `I couldn't find any memories about "${searchTerm}"`
        };
      }
    }
    
    // Delete memory pattern
    const deletePattern = /(delete|remove|forget)( memory)? (with id|id|#)? (.*)/i;
    const deleteMatch = text.match(deletePattern);
    
    if (deleteMatch && deleteMatch[4]) {
      const memoryId = deleteMatch[4].trim();
      const deleted = await this.memoryManager.deleteMemory(memoryId);
      
      if (deleted) {
        return {
          action: 'delete',
          success: true,
          message: `Memory with ID ${memoryId} has been deleted`
        };
      } else {
        return {
          action: 'delete',
          success: false,
          message: `No memory found with ID ${memoryId}`
        };
      }
    }
    
    // List all memories pattern
    if (/(list|show) all memories/i.test(lowerText)) {
      const memories = await this.memoryManager.listAllMemories();
      return {
        action: 'list',
        memories,
        message: `You have ${memories.length} stored memories`
      };
    }
    
    // Default action - no specific command detected
    return {
      action: 'unknown',
      message: 'I detected memory-related keywords, but I couldn\'t identify a specific command. You can store, recall, or delete memories.'
    };
  }
} 