@danielsimonjr/memory-mcp 0.7.2 → 0.41.0

package/dist/server/MCPServer.js

@@ -0,0 +1,889 @@
+/**
+ * MCP Server
+ *
+ * Handles Model Context Protocol server initialization and tool registration.
+ *
+ * @module server/MCPServer
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { logger } from '../utils/logger.js';
+/**
+ * MCP Server for Knowledge Graph operations.
+ * Exposes tools for entity/relation management, search, and analysis.
+ */
+export class MCPServer {
+    server;
+    manager;
+    constructor(manager) {
+        this.manager = manager;
+        this.server = new Server({
+            name: "memory-server",
+            version: "0.8.0",
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.registerToolHandlers();
+    }
+    registerToolHandlers() {
+        // Register list tools handler
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: this.getToolDefinitions(),
+            };
+        });
+        // Register call tool handler
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            return this.handleToolCall(name, args || {});
+        });
+    }
+    getToolDefinitions() {
+        return [
+            {
+                name: "create_entities",
+                description: "Create multiple new entities in the knowledge graph",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entities: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    name: { type: "string", description: "The name of the entity" },
+                                    entityType: { type: "string", description: "The type of the entity" },
+                                    observations: {
+                                        type: "array",
+                                        items: { type: "string" },
+                                        description: "An array of observation contents associated with the entity"
+                                    },
+                                },
+                                required: ["name", "entityType", "observations"],
+                                additionalProperties: false,
+                            },
+                        },
+                    },
+                    required: ["entities"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "create_relations",
+                description: "Create multiple new relations between entities in the knowledge graph. Relations should be in active voice",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        relations: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    from: { type: "string", description: "The name of the entity where the relation starts" },
+                                    to: { type: "string", description: "The name of the entity where the relation ends" },
+                                    relationType: { type: "string", description: "The type of the relation in active voice (e.g., 'works_at', 'knows')" },
+                                },
+                                required: ["from", "to", "relationType"],
+                                additionalProperties: false,
+                            },
+                        },
+                    },
+                    required: ["relations"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "add_observations",
+                description: "Add new observations to existing entities in the knowledge graph",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        observations: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    entityName: { type: "string", description: "The name of the entity to add observations to" },
+                                    contents: {
+                                        type: "array",
+                                        items: { type: "string" },
+                                        description: "An array of observation contents to add"
+                                    },
+                                },
+                                required: ["entityName", "contents"],
+                                additionalProperties: false,
+                            },
+                        },
+                    },
+                    required: ["observations"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "delete_entities",
+                description: "Delete multiple entities from the knowledge graph",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entityNames: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "An array of entity names to delete"
+                        },
+                    },
+                    required: ["entityNames"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "delete_observations",
+                description: "Delete specific observations from entities",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        deletions: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    entityName: { type: "string" },
+                                    observations: {
+                                        type: "array",
+                                        items: { type: "string" }
+                                    },
+                                },
+                                required: ["entityName", "observations"],
+                            },
+                        },
+                    },
+                    required: ["deletions"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "delete_relations",
+                description: "Delete multiple relations from the knowledge graph",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        relations: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    from: { type: "string" },
+                                    to: { type: "string" },
+                                    relationType: { type: "string" },
+                                },
+                                required: ["from", "to", "relationType"],
+                                additionalProperties: false,
+                            },
+                        },
+                    },
+                    required: ["relations"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "read_graph",
+                description: "Read the entire knowledge graph",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "search_nodes",
+                description: "Search for nodes in the knowledge graph based on query string, with optional tag and importance filtering",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "The search query" },
+                        tags: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Optional array of tags to filter by"
+                        },
+                        minImportance: { type: "number", description: "Optional minimum importance score (0-10)" },
+                        maxImportance: { type: "number", description: "Optional maximum importance score (0-10)" },
+                    },
+                    required: ["query"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "open_nodes",
+                description: "Open specific nodes by their names",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        names: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Array of entity names to retrieve"
+                        },
+                    },
+                    required: ["names"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "search_by_date_range",
+                description: "Search entities within a date range, with optional filtering by entity type and tags",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        startDate: { type: "string", description: "Start date in ISO 8601 format" },
+                        endDate: { type: "string", description: "End date in ISO 8601 format" },
+                        entityType: { type: "string", description: "Optional entity type to filter by" },
+                        tags: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Optional array of tags to filter by"
+                        },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "add_tags",
+                description: "Add tags to an entity",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entityName: { type: "string", description: "Name of the entity" },
+                        tags: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Array of tags to add"
+                        },
+                    },
+                    required: ["entityName", "tags"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "remove_tags",
+                description: "Remove tags from an entity",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entityName: { type: "string", description: "Name of the entity" },
+                        tags: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Array of tags to remove"
+                        },
+                    },
+                    required: ["entityName", "tags"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "set_importance",
+                description: "Set the importance score of an entity (0-10)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entityName: { type: "string", description: "Name of the entity" },
+                        importance: { type: "number", description: "Importance score between 0 and 10" },
+                    },
+                    required: ["entityName", "importance"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "add_tags_to_multiple_entities",
+                description: "Add the same tags to multiple entities at once",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entityNames: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Array of entity names"
+                        },
+                        tags: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Array of tags to add to all entities"
+                        },
+                    },
+                    required: ["entityNames", "tags"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "replace_tag",
+                description: "Replace a tag with a new tag across all entities",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        oldTag: { type: "string", description: "The tag to replace" },
+                        newTag: { type: "string", description: "The new tag" },
+                    },
+                    required: ["oldTag", "newTag"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "merge_tags",
+                description: "Merge two tags into a target tag across all entities",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        tag1: { type: "string", description: "First tag to merge" },
+                        tag2: { type: "string", description: "Second tag to merge" },
+                        targetTag: { type: "string", description: "Target tag to merge into" },
+                    },
+                    required: ["tag1", "tag2", "targetTag"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "get_graph_stats",
+                description: "Get statistics about the knowledge graph",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "validate_graph",
+                description: "Validate the knowledge graph for integrity issues",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "save_search",
+                description: "Save a search query for later reuse",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string", description: "Name of the saved search" },
+                        query: { type: "string", description: "Search query" },
+                        tags: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Optional tags filter"
+                        },
+                        minImportance: { type: "number", description: "Optional minimum importance" },
+                        maxImportance: { type: "number", description: "Optional maximum importance" },
+                        searchType: { type: "string", description: "Type of search (basic, boolean, fuzzy, ranked)" },
+                        description: { type: "string", description: "Optional description of the search" },
+                    },
+                    required: ["name", "query"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "execute_saved_search",
+                description: "Execute a previously saved search by name",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string", description: "Name of the saved search" },
+                    },
+                    required: ["name"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "list_saved_searches",
+                description: "List all saved searches",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "delete_saved_search",
+                description: "Delete a saved search",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string", description: "Name of the saved search to delete" },
+                    },
+                    required: ["name"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "update_saved_search",
+                description: "Update a saved search",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string", description: "Name of the saved search" },
+                        updates: {
+                            type: "object",
+                            description: "Fields to update",
+                        },
+                    },
+                    required: ["name", "updates"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "boolean_search",
+                description: "Perform boolean search with AND, OR, NOT operators",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "Boolean query (e.g., 'alice AND bob')" },
+                        tags: {
+                            type: "array",
+                            items: { type: "string" },
+                        },
+                        minImportance: { type: "number" },
+                        maxImportance: { type: "number" },
+                    },
+                    required: ["query"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "fuzzy_search",
+                description: "Perform fuzzy search with typo tolerance",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "Search query" },
+                        threshold: { type: "number", description: "Similarity threshold (0.0-1.0)" },
+                        tags: {
+                            type: "array",
+                            items: { type: "string" },
+                        },
+                        minImportance: { type: "number" },
+                        maxImportance: { type: "number" },
+                    },
+                    required: ["query"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "search_nodes_ranked",
+                description: "Perform TF-IDF ranked search",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "Search query" },
+                        tags: {
+                            type: "array",
+                            items: { type: "string" },
+                        },
+                        minImportance: { type: "number" },
+                        maxImportance: { type: "number" },
+                        limit: { type: "number", description: "Max results" },
+                    },
+                    required: ["query"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "get_search_suggestions",
+                description: "Get search suggestions for a query",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "Search query" },
+                        maxSuggestions: { type: "number", description: "Max suggestions to return" },
+                    },
+                    required: ["query"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "add_tag_alias",
+                description: "Add a tag alias (synonym mapping)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        alias: { type: "string", description: "The alias/synonym" },
+                        canonical: { type: "string", description: "The canonical tag" },
+                        description: { type: "string", description: "Optional description" },
+                    },
+                    required: ["alias", "canonical"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "list_tag_aliases",
+                description: "List all tag aliases",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "remove_tag_alias",
+                description: "Remove a tag alias",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        alias: { type: "string", description: "The alias to remove" },
+                    },
+                    required: ["alias"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "get_aliases_for_tag",
+                description: "Get all aliases for a canonical tag",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        canonicalTag: { type: "string", description: "The canonical tag" },
+                    },
+                    required: ["canonicalTag"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "resolve_tag",
+                description: "Resolve a tag to its canonical form",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        tag: { type: "string", description: "Tag to resolve" },
+                    },
+                    required: ["tag"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "set_entity_parent",
+                description: "Set the parent of an entity for hierarchical organization",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entityName: { type: "string" },
+                        parentName: { type: ["string", "null"], description: "Parent entity name or null to remove parent" },
+                    },
+                    required: ["entityName", "parentName"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "get_children",
+                description: "Get all child entities of an entity",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entityName: { type: "string" },
+                    },
+                    required: ["entityName"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "get_parent",
+                description: "Get the parent entity of an entity",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entityName: { type: "string" },
+                    },
+                    required: ["entityName"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "get_ancestors",
+                description: "Get all ancestor entities of an entity",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entityName: { type: "string" },
+                    },
+                    required: ["entityName"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "get_descendants",
+                description: "Get all descendant entities of an entity",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entityName: { type: "string" },
+                    },
+                    required: ["entityName"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "get_subtree",
+                description: "Get entity and all its descendants as a subgraph",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entityName: { type: "string" },
+                    },
+                    required: ["entityName"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "get_root_entities",
+                description: "Get all root entities (entities without parents)",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "get_entity_depth",
+                description: "Get the depth of an entity in the hierarchy",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entityName: { type: "string" },
+                    },
+                    required: ["entityName"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "move_entity",
+                description: "Move an entity to a new parent",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entityName: { type: "string" },
+                        newParentName: { type: ["string", "null"] },
+                    },
+                    required: ["entityName", "newParentName"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "find_duplicates",
+                description: "Find potential duplicate entities based on similarity",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        threshold: { type: "number", description: "Similarity threshold (0.0-1.0)" },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "merge_entities",
+                description: "Merge multiple entities into one",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        entityNames: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Entities to merge"
+                        },
+                        targetName: { type: "string", description: "Optional target entity name" },
+                    },
+                    required: ["entityNames"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "compress_graph",
+                description: "Compress the graph by merging similar entities",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        threshold: { type: "number", description: "Similarity threshold" },
+                        dryRun: { type: "boolean", description: "Preview without applying changes" },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "archive_entities",
+                description: "Archive old or low-importance entities",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        olderThan: { type: "string", description: "Archive entities older than this date (ISO 8601)" },
+                        importanceLessThan: { type: "number", description: "Archive entities below this importance" },
+                        tags: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Archive entities with these tags"
+                        },
+                        dryRun: { type: "boolean", description: "Preview without applying changes" },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "import_graph",
+                description: "Import knowledge graph from various formats",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        format: { type: "string", enum: ["json", "csv", "graphml"] },
+                        data: { type: "string", description: "Import data as string" },
+                        mergeStrategy: {
+                            type: "string",
+                            enum: ["replace", "skip", "merge", "fail"],
+                            description: "How to handle conflicts"
+                        },
+                        dryRun: { type: "boolean", description: "Preview without applying changes" },
+                    },
+                    required: ["format", "data"],
+                    additionalProperties: false,
+                },
+            },
+            {
+                name: "export_graph",
+                description: "Export knowledge graph in various formats",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        format: {
+                            type: "string",
+                            enum: ["json", "csv", "graphml", "gexf", "dot", "markdown", "mermaid"],
+                            description: "Export format"
+                        },
+                        filter: {
+                            type: "object",
+                            properties: {
+                                startDate: { type: "string" },
+                                endDate: { type: "string" },
+                                entityType: { type: "string" },
+                                tags: {
+                                    type: "array",
+                                    items: { type: "string" }
+                                },
+                            },
+                            description: "Optional filter"
+                        },
+                    },
+                    required: ["format"],
+                    additionalProperties: false,
+                },
+            },
+        ];
+    }
+    async handleToolCall(name, args) {
+        switch (name) {
+            case "create_entities":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.createEntities(args.entities), null, 2) }] };
+            case "create_relations":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.createRelations(args.relations), null, 2) }] };
+            case "add_observations":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.addObservations(args.observations), null, 2) }] };
+            case "delete_entities":
+                await this.manager.deleteEntities(args.entityNames);
+                return { content: [{ type: "text", text: `Deleted ${args.entityNames.length} entities` }] };
+            case "delete_observations":
+                await this.manager.deleteObservations(args.deletions);
+                return { content: [{ type: "text", text: "Observations deleted successfully" }] };
+            case "delete_relations":
+                await this.manager.deleteRelations(args.relations);
+                return { content: [{ type: "text", text: `Deleted ${args.relations.length} relations` }] };
+            case "read_graph":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.readGraph(), null, 2) }] };
+            case "search_nodes":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.searchNodes(args.query, args.tags, args.minImportance, args.maxImportance), null, 2) }] };
+            case "open_nodes":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.openNodes(args.names), null, 2) }] };
+            case "search_nodes_ranked":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.searchNodesRanked(args.query, args.tags, args.minImportance, args.maxImportance, args.limit), null, 2) }] };
+            case "list_saved_searches":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.listSavedSearches(), null, 2) }] };
+            case "search_by_date_range":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.searchByDateRange(args.startDate, args.endDate, args.entityType, args.tags), null, 2) }] };
+            case "add_tags":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.addTags(args.entityName, args.tags), null, 2) }] };
+            case "remove_tags":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.removeTags(args.entityName, args.tags), null, 2) }] };
+            case "set_importance":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.setImportance(args.entityName, args.importance), null, 2) }] };
+            case "add_tags_to_multiple_entities":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.addTagsToMultipleEntities(args.entityNames, args.tags), null, 2) }] };
+            case "replace_tag":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.replaceTag(args.oldTag, args.newTag), null, 2) }] };
+            case "merge_tags":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.mergeTags(args.tag1, args.tag2, args.targetTag), null, 2) }] };
+            case "save_search":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.saveSearch(args), null, 2) }] };
+            case "execute_saved_search":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.executeSavedSearch(args.name), null, 2) }] };
+            case "delete_saved_search":
+                const deleted = await this.manager.deleteSavedSearch(args.name);
+                return { content: [{ type: "text", text: deleted ? `Saved search "${args.name}" deleted successfully` : `Saved search "${args.name}" not found` }] };
+            case "update_saved_search":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.updateSavedSearch(args.name, args.updates), null, 2) }] };
+            case "boolean_search":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.booleanSearch(args.query, args.tags, args.minImportance, args.maxImportance), null, 2) }] };
+            case "fuzzy_search":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.fuzzySearch(args.query, args.threshold, args.tags, args.minImportance, args.maxImportance), null, 2) }] };
+            case "get_search_suggestions":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.getSearchSuggestions(args.query, args.maxSuggestions), null, 2) }] };
+            case "add_tag_alias":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.addTagAlias(args.alias, args.canonical, args.description), null, 2) }] };
+            case "list_tag_aliases":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.listTagAliases(), null, 2) }] };
+            case "remove_tag_alias":
+                const removed = await this.manager.removeTagAlias(args.alias);
+                return { content: [{ type: "text", text: removed ? `Tag alias "${args.alias}" removed successfully` : `Tag alias "${args.alias}" not found` }] };
+            case "get_aliases_for_tag":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.getAliasesForTag(args.canonicalTag), null, 2) }] };
+            case "resolve_tag":
+                return { content: [{ type: "text", text: JSON.stringify({ tag: args.tag, resolved: await this.manager.resolveTag(args.tag) }, null, 2) }] };
+            case "set_entity_parent":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.setEntityParent(args.entityName, args.parentName), null, 2) }] };
+            case "get_children":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.getChildren(args.entityName), null, 2) }] };
+            case "get_parent":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.getParent(args.entityName), null, 2) }] };
+            case "get_ancestors":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.getAncestors(args.entityName), null, 2) }] };
+            case "get_descendants":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.getDescendants(args.entityName), null, 2) }] };
+            case "get_subtree":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.getSubtree(args.entityName), null, 2) }] };
+            case "get_root_entities":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.getRootEntities(), null, 2) }] };
+            case "get_entity_depth":
+                return { content: [{ type: "text", text: JSON.stringify({ entityName: args.entityName, depth: await this.manager.getEntityDepth(args.entityName) }, null, 2) }] };
+            case "move_entity":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.moveEntity(args.entityName, args.newParentName), null, 2) }] };
+            case "get_graph_stats":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.getGraphStats(), null, 2) }] };
+            case "validate_graph":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.validateGraph(), null, 2) }] };
+            case "find_duplicates":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.findDuplicates(args.threshold), null, 2) }] };
+            case "merge_entities":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.mergeEntities(args.entityNames, args.targetName), null, 2) }] };
+            case "compress_graph":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.compressGraph(args.threshold, args.dryRun), null, 2) }] };
+            case "archive_entities":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.archiveEntities({ olderThan: args.olderThan, importanceLessThan: args.importanceLessThan, tags: args.tags }, args.dryRun), null, 2) }] };
+            case "import_graph":
+                return { content: [{ type: "text", text: JSON.stringify(await this.manager.importGraph(args.format, args.data, args.mergeStrategy, args.dryRun), null, 2) }] };
+            case "export_graph":
+                return { content: [{ type: "text", text: await this.manager.exportGraph(args.format, args.filter) }] };
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    async start() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        logger.info('Knowledge Graph MCP Server running on stdio');
+    }
+}