meMCP - Memory-Enhanced Model Context Protocol

Implementation Reference

• src/tools/modules/MemoryQueryHandler.js:84-144 (handler)

  Core handler function for 'memory_query' tool. Queries the factStore with provided args, formats results into a structured text response with scores, domains, tags etc., handles empty results and errors.

  async handleQuery(args) {
    try {
      const result = await this.factStore.queryFacts(args);
      
      if (result.facts.length === 0) {
        return {
          content: [
            {
              type: 'text',
              text: `No insights found matching your query: "${args.query}"`,
            },
          ],
        };
      }
      
      let response = `Found ${result.facts.length} insights (${result.total} total matches):\n\n`;
      
      for (const [index, fact] of result.facts.entries()) {
        response += `**${index + 1}. ${fact.type.replace('_', ' ')}** (Score: ${fact.qualityScore}/100)\n`;
        response += `*Domain: ${fact.domain}*\n`;
        response += `${fact.content}\n`;
        
        if (fact.tags && fact.tags.length > 0) {
          response += `*Tags: ${fact.tags.join(', ')}*\n`;
        }
        
        if (fact.relatedFacts && fact.relatedFacts.length > 0) {
          response += `*Related: ${fact.relatedFacts.length} connected facts*\n`;
        }
        
        if (fact.relevanceScore !== undefined) {
          response += `*Relevance: ${fact.relevanceScore.toFixed(2)}*\n`;
        }
        
        if (fact.semanticScore !== undefined) {
          response += `*Semantic: ${fact.semanticScore.toFixed(3)}*\n`;
        }
        
        response += `\n`;
      }
      
      return {
        content: [
          {
            type: 'text',
            text: response.trim(),
          },
        ],
      };
    } catch (error) {
      return {
        content: [
          {
            type: 'text',
            text: `Error querying insights: ${error.message}`,
          },
        ],
        isError: true,
      };
    }
  }

• src/tools/modules/MemoryQueryHandler.js:17-53 (schema)

  Input schema for the 'memory_query' tool defining parameters like query (required), filters for type, domain, tags, minScore, limit, includeRelated.

    type: 'object',
    properties: {
      query: {
        type: 'string',
        description: 'Search query to find relevant insights',
      },
      type: {
        type: 'string',
        description: 'Filter by fact type',
      },
      domain: {
        type: 'string',
        description: 'Filter by domain',
      },
      tags: {
        type: 'array',
        items: { type: 'string' },
        description: 'Filter by tags',
      },
      minScore: {
        type: 'number',
        description: 'Minimum quality score (0-100)',
        default: 0,
      },
      limit: {
        type: 'number',
        description: 'Maximum number of results',
        default: 10,
      },
      includeRelated: {
        type: 'boolean',
        description: 'Include related facts in results',
        default: false,
      },
    },
    required: ['query'],
  },

• src/tools/modules/MemoryQueryHandler.js:13-57 (registration)

  Direct registration of the 'memory_query' tool in registerQueryTool method, specifying name, description, schema, and handler.

  server.registerTool(
    'memory_query',
    'Search and retrieve relevant insights from the memory system',
    {
      type: 'object',
      properties: {
        query: {
          type: 'string',
          description: 'Search query to find relevant insights',
        },
        type: {
          type: 'string',
          description: 'Filter by fact type',
        },
        domain: {
          type: 'string',
          description: 'Filter by domain',
        },
        tags: {
          type: 'array',
          items: { type: 'string' },
          description: 'Filter by tags',
        },
        minScore: {
          type: 'number',
          description: 'Minimum quality score (0-100)',
          default: 0,
        },
        limit: {
          type: 'number',
          description: 'Maximum number of results',
          default: 10,
        },
        includeRelated: {
          type: 'boolean',
          description: 'Include related facts in results',
          default: false,
        },
      },
      required: ['query'],
    },
    async (args) => {
      return await this.handleQuery(args);
    }
  );

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

  MemoryTools.registerTools method which calls queryHandler.registerTools(server), delegating the memory_query registration.

  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/core/SequentialGraphitiIntegration.js:77-84 (registration)

  Top-level tool registration in SequentialGraphitiIntegration where MemoryTools (containing memory_query) is registered to the server.

  async registerTools(server) {
    if (!this.initialized) {
      throw new Error('Integration must be initialized before registering tools');
    }
  
    await this.memoryTools.registerTools(server);
    await this.configurationTools.registerTools(server);
  }