meMCP - Memory-Enhanced Model Context Protocol

Implementation Reference

• src/tools/ConfigurationTools.js:320-357 (handler)

  Main handler for config_validate tool: calls configManager.validateConfiguration() and formats results into a structured text response.

  async handleValidate(args) {
    try {
      const validation = await this.configManager.validateConfiguration();
      
      let response = `🔍 **Configuration Validation**\n\n`;
      response += `**Status:** ${validation.valid ? '✅ Valid' : '❌ Issues Found'}\n`;
      
      if (validation.issues.length > 0) {
        response += `\n**Issues:**\n`;
        for (const issue of validation.issues) {
          response += `- ${issue}\n`;
        }
      } else {
        response += `\n*No issues found. Configuration is valid.*`;
      }
      
      response += `\n\n*Checked at: ${validation.checkedAt}*`;
      
      return {
        content: [
          {
            type: 'text',
            text: response,
          },
        ],
      };
    } catch (error) {
      return {
        content: [
          {
            type: 'text',
            text: `Error validating configuration: ${error.message}`,
          },
        ],
        isError: true,
      };
    }
  }

• src/tools/ConfigurationTools.js:150-161 (registration)

  Registers the config_validate tool on the MCP server within ConfigurationTools.registerTools(), including description and input schema.

  // Register config_validate tool
  server.registerTool(
    'config_validate',
    'Validate current configuration for issues',
    {
      type: 'object',
      properties: {},
    },
    async (args) => {
      return await this.handleValidate(args);
    }
  );

• src/tools/ConfigurationTools.js:155-157 (schema)

  Input schema for config_validate: no parameters required.

    type: 'object',
    properties: {},
  },

• src/config/ConfigurationManager.js:289-321 (helper)

  Supporting validation function in ConfigurationManager that performs the actual config checks for scoring weights and fact types.

  async validateConfiguration() {
    const issues = [];
    
    if (this.config.scoringWeights) {
      try {
        this.validateScoringWeights(this.config.scoringWeights);
      } catch (error) {
        issues.push(`Scoring weights: ${error.message}`);
      }
    }
    
    if (this.config.factTypes) {
      for (const [typeName, typeConfig] of Object.entries(this.config.factTypes)) {
        if (!typeConfig.name || !typeConfig.description) {
          issues.push(`Fact type '${typeName}': missing name or description`);
        }
        
        if (typeof typeConfig.priority !== 'number' || typeConfig.priority < 1 || typeConfig.priority > 10) {
          issues.push(`Fact type '${typeName}': priority must be between 1 and 10`);
        }
        
        if (typeof typeConfig.retentionMonths !== 'number' || typeConfig.retentionMonths < 1) {
          issues.push(`Fact type '${typeName}': retentionMonths must be a positive number`);
        }
      }
    }
    
    return {
      valid: issues.length === 0,
      issues,
      checkedAt: new Date().toISOString(),
    };
  }