MemoryMesh

Instructions

Implementation Reference

• src/integration/tools/DynamicSchemaToolRegistry.ts:165-192 (handler)

  Core handler logic for the 'add_location' tool (and similar add_<schema> tools). Checks if node exists, creates nodes and relationships using createSchemaNode, adds them to the graph in a transaction, and returns formatted response.

  switch (operation) {
      case 'add': {
          const nodeData = args[schemaName];
          const existingNodes = await knowledgeGraphManager.openNodes([nodeData.name]);
  
          if (existingNodes.nodes.length > 0) {
              throw new Error(`Node already exists: ${nodeData.name}`);
          }
  
          const {nodes, edges} = await createSchemaNode(nodeData, schema, schemaName);
  
          await knowledgeGraphManager.beginTransaction();
          try {
              await knowledgeGraphManager.addNodes(nodes);
              if (edges.length > 0) {
                  await knowledgeGraphManager.addEdges(edges);
              }
              await knowledgeGraphManager.commit();
  
              return formatToolResponse({
                  data: {nodes, edges},
                  actionTaken: `Created ${schemaName}: ${nodeData.name}`
              });
          } catch (error) {
              await knowledgeGraphManager.rollback();
              throw error;
          }
      }

• src/core/schema/SchemaBuilder.ts:253-259 (schema)

  SchemaBuilder.build() method generates the Tool inputSchema for 'add_location' from the schema configuration, used as the tool schema in dynamic tool generation.

  build(): SchemaConfig {
      return {
          ...this.schema as SchemaConfig,
          relationships: Object.fromEntries(this.relationships),
          metadataConfig: this.metadataConfig
      };
  }

• src/integration/tools/registry/toolsRegistry.ts:34-59 (registration)

  ToolsRegistry.initialize() registers all dynamic tools (including 'add_location' if location schema exists) into the central tools Map by calling dynamicToolManager.getTools().

  async initialize(knowledgeGraphManager: ApplicationManager): Promise<void> {
      if (this.initialized) {
          return;
      }
  
      try {
          this.knowledgeGraphManager = knowledgeGraphManager;
  
          // Register static tools
          allStaticTools.forEach(tool => {
              this.tools.set(tool.name, tool);
          });
  
          // Initialize and register dynamic tools
          await dynamicToolManager.initialize();
          dynamicToolManager.getTools().forEach(tool => {
              this.tools.set(tool.name, tool);
          });
  
          this.initialized = true;
          console.error(`[ToolsRegistry] Initialized with ${this.tools.size} tools`);
      } catch (error) {
          console.error('[ToolsRegistry] Initialization error:', error);
          throw error;
      }
  }

• src/integration/tools/DynamicSchemaToolRegistry.ts:52-77 (registration)

  DynamicSchemaToolRegistry.initialize() loads schema files, creates SchemaBuilder instances, generates add/update/delete tools (e.g. 'add_location'), and caches them.

  public async initialize(): Promise<void> {
      try {
          const SCHEMAS_DIR = CONFIG.PATHS.SCHEMAS_DIR;
          const schemaFiles = await fs.readdir(SCHEMAS_DIR);
  
          // Process schema files
          for (const file of schemaFiles) {
              if (file.endsWith('.schema.json')) {
                  const schemaName = path.basename(file, '.schema.json');
                  const schema = await SchemaLoader.loadSchema(schemaName);
                  this.schemas.set(schemaName, schema);
              }
          }
  
          // Generate tools for each schema
          for (const [schemaName, schema] of this.schemas.entries()) {
              const tools = await this.generateToolsForSchema(schemaName, schema);
              tools.forEach(tool => this.toolsCache.set(tool.name, tool));
          }
  
          console.error(`[DynamicSchemaTools] Initialized ${this.schemas.size} schemas and ${this.toolsCache.size} tools`);
      } catch (error) {
          console.error('[DynamicSchemaTools] Initialization error:', error);
          throw error;
      }
  }

• src/core/schema/SchemaBuilder.ts:64-91 (schema)

  SchemaBuilder constructor initializes the inputSchema structure specifically for 'add_*' named schemas (like 'add_location'), setting up the object wrapper and properties.

  constructor(name: string, description: string) {
      this.schema = {
          name,
          description,
          inputSchema: {
              type: "object",
              properties: {
                  [name.replace('add_', '')]: {
                      type: "object",
                      properties: {},
                      required: [],
                      additionalProperties: {
                          type: "string",
                          description: "Any additional properties"
                      }
                  }
              },
              required: [name.replace('add_', '')]
          }
      };
  
      this.relationships = new Map();
      this.metadataConfig = {
          requiredFields: [],
          optionalFields: [],
          excludeFields: []
      };
  }