meMCP - Memory-Enhanced Model Context Protocol

Implementation Reference

• src/tools/modules/MemoryOperations.js:290-333 (handler)

  The core handler function that implements the logic for the 'memory_get_related' tool. It destructures args for factId and maxDepth, retrieves related facts from the factStore, and constructs a formatted markdown response listing the related facts by relationship and depth, or handles errors.

  async handleGetRelated(args) {
    try {
      const { factId, maxDepth = 2 } = args;
      
      const related = await this.factStore.getRelatedFacts(factId, maxDepth);
      
      if (related.length === 0) {
        return {
          content: [
            {
              type: 'text',
              text: `No related facts found for ${factId}`,
            },
          ],
        };
      }
      
      let response = `🔗 **Related Facts for ${factId}:**\n\n`;
      
      for (const item of related) {
        response += `**${item.relationship}** (depth ${item.depth})\n`;
        response += `${item.fact.type}: ${item.fact.content.substring(0, 100)}...\n\n`;
      }
      
      return {
        content: [
          {
            type: 'text',
            text: response.trim(),
          },
        ],
      };
    } catch (error) {
      return {
        content: [
          {
            type: 'text',
            text: `Error getting related facts: ${error.message}`,
          },
        ],
        isError: true,
      };
    }
  }

• src/tools/modules/MemoryOperations.js:123-146 (registration)

  The registration of the 'memory_get_related' tool, including its name, description, input schema (factId required, maxDepth optional), and the handler function that delegates to handleGetRelated.

  registerGetRelatedTool(server) {
    server.registerTool(
      'memory_get_related',
      'Get facts related to a specific fact',
      {
        type: 'object',
        properties: {
          factId: {
            type: 'string',
            description: 'The ID of the fact to find related facts for',
          },
          maxDepth: {
            type: 'number',
            description: 'Maximum relationship depth to traverse',
            default: 2,
          },
        },
        required: ['factId'],
      },
      async (args) => {
        return await this.handleGetRelated(args);
      }
    );
  }

• src/tools/MemoryTools.js:23-29 (registration)

  Top-level registration method in MemoryTools class that calls registerTools on MemoryOperations (which registers memory_get_related) and other modules.

  async registerTools(server) {
    // Register tools from modular components
    this.operations.registerTools(server);
    this.queryHandler.registerTools(server);
    this.streamingTools.registerTools(server);
    this.management.registerTools(server);
  }

• src/tools/modules/MemoryOperations.js:127-141 (schema)

  The JSON schema defining the input parameters for the memory_get_related tool: factId (string, required), maxDepth (number, optional default 2).

  {
    type: 'object',
    properties: {
      factId: {
        type: 'string',
        description: 'The ID of the fact to find related facts for',
      },
      maxDepth: {
        type: 'number',
        description: 'Maximum relationship depth to traverse',
        default: 2,
      },
    },
    required: ['factId'],
  },

• src/tools/MemoryTools.js:52-54 (helper)

  Wrapper/delegation method in MemoryTools that forwards calls to the MemoryOperations handler for backward compatibility.

  async handleGetRelated(args) {
    return await this.operations.handleGetRelated(args);
  }