@levalicious/server-memory 0.0.3 → 0.0.5

package/dist/index.js

@@ -8,18 +8,22 @@ import { fileURLToPath } from 'url';
 // Define memory file path using environment variable with fallback
 const defaultMemoryPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'memory.json');
 // If MEMORY_FILE_PATH is just a filename, put it in the same directory as the script
-const MEMORY_FILE_PATH = process.env.MEMORY_FILE_PATH
+const DEFAULT_MEMORY_FILE_PATH = process.env.MEMORY_FILE_PATH
     ? path.isAbsolute(process.env.MEMORY_FILE_PATH)
         ? process.env.MEMORY_FILE_PATH
         : path.join(path.dirname(fileURLToPath(import.meta.url)), process.env.MEMORY_FILE_PATH)
     : defaultMemoryPath;
 // The KnowledgeGraphManager class contains all operations to interact with the knowledge graph
-class KnowledgeGraphManager {
+export class KnowledgeGraphManager {
     bclCtr = 0;
     bclTerm = "";
+    memoryFilePath;
+    constructor(memoryFilePath = DEFAULT_MEMORY_FILE_PATH) {
+        this.memoryFilePath = memoryFilePath;
+    }
     async loadGraph() {
         try {
-            const data = await fs.readFile(MEMORY_FILE_PATH, "utf-8");
+            const data = await fs.readFile(this.memoryFilePath, "utf-8");
             const lines = data.split("\n").filter(line => line.trim() !== "");
             return lines.reduce((graph, line) => {
                 const item = JSON.parse(line);
@@ -31,7 +35,7 @@ class KnowledgeGraphManager {
             }, { entities: [], relations: [] });
         }
         catch (error) {
-            if (error instanceof Error && 'code' in error && error.code === "ENOENT") {
+            if (error?.code === "ENOENT") {
                 return { entities: [], relations: [] };
             }
             throw error;
@@ -42,10 +46,21 @@ class KnowledgeGraphManager {
             ...graph.entities.map(e => JSON.stringify({ type: "entity", ...e })),
             ...graph.relations.map(r => JSON.stringify({ type: "relation", ...r })),
         ];
-        await fs.writeFile(MEMORY_FILE_PATH, lines.join("\n"));
+        await fs.writeFile(this.memoryFilePath, lines.join("\n"));
     }
     async createEntities(entities) {
         const graph = await this.loadGraph();
+        // Validate observation limits
+        for (const entity of entities) {
+            if (entity.observations.length > 2) {
+                throw new Error(`Entity "${entity.name}" has ${entity.observations.length} observations. Maximum allowed is 2.`);
+            }
+            for (const obs of entity.observations) {
+                if (obs.length > 140) {
+                    throw new Error(`Observation in entity "${entity.name}" exceeds 140 characters (${obs.length} chars): "${obs.substring(0, 50)}..."`);
+                }
+            }
+        }
         const newEntities = entities.filter(e => !graph.entities.some(existingEntity => existingEntity.name === e.name));
         graph.entities.push(...newEntities);
         await this.saveGraph(graph);
@@ -67,7 +82,17 @@ class KnowledgeGraphManager {
             if (!entity) {
                 throw new Error(`Entity with name ${o.entityName} not found`);
             }
+            // Validate observation character limits
+            for (const obs of o.contents) {
+                if (obs.length > 140) {
+                    throw new Error(`Observation for "${o.entityName}" exceeds 140 characters (${obs.length} chars): "${obs.substring(0, 50)}..."`);
+                }
+            }
             const newObservations = o.contents.filter(content => !entity.observations.includes(content));
+            // Validate total observation count
+            if (entity.observations.length + newObservations.length > 2) {
+                throw new Error(`Adding ${newObservations.length} observations to "${o.entityName}" would exceed limit of 2 (currently has ${entity.observations.length}).`);
+            }
             entity.observations.push(...newObservations);
             return { entityName: o.entityName, addedObservations: newObservations };
         });
@@ -97,16 +122,20 @@ class KnowledgeGraphManager {
             r.relationType === delRelation.relationType));
         await this.saveGraph(graph);
     }
-    async readGraph() {
-        return this.loadGraph();
-    }
-    // Very basic search function
+    // Regex-based search function
     async searchNodes(query) {
         const graph = await this.loadGraph();
+        let regex;
+        try {
+            regex = new RegExp(query, 'i'); // case-insensitive
+        }
+        catch (e) {
+            throw new Error(`Invalid regex pattern: ${query}`);
+        }
         // Filter entities
-        const filteredEntities = graph.entities.filter(e => e.name.toLowerCase().includes(query.toLowerCase()) ||
-            e.entityType.toLowerCase().includes(query.toLowerCase()) ||
-            e.observations.some(o => o.toLowerCase().includes(query.toLowerCase())));
+        const filteredEntities = graph.entities.filter(e => regex.test(e.name) ||
+            regex.test(e.entityType) ||
+            e.observations.some(o => regex.test(o)));
         // Create a Set of filtered entity names for quick lookup
         const filteredEntityNames = new Set(filteredEntities.map(e => e.name));
         // Filter relations to only include those between filtered entities
@@ -145,22 +174,25 @@ class KnowledgeGraphManager {
         };
         return filteredGraph;
     }
-    async getNeighbors(entityName, depth = 1) {
+    async getNeighbors(entityName, depth = 1, withEntities = false) {
         const graph = await this.loadGraph();
         const visited = new Set();
         const resultEntities = new Map();
-        const resultRelations = [];
+        const resultRelations = new Map(); // Deduplicate relations
+        const relationKey = (r) => `${r.from}|${r.relationType}|${r.to}`;
         const traverse = (currentName, currentDepth) => {
             if (currentDepth > depth || visited.has(currentName))
                 return;
             visited.add(currentName);
-            const entity = graph.entities.find(e => e.name === currentName);
-            if (entity) {
-                resultEntities.set(currentName, entity);
+            if (withEntities) {
+                const entity = graph.entities.find(e => e.name === currentName);
+                if (entity) {
+                    resultEntities.set(currentName, entity);
+                }
             }
             // Find all relations involving this entity
             const connectedRelations = graph.relations.filter(r => r.from === currentName || r.to === currentName);
-            resultRelations.push(...connectedRelations);
+            connectedRelations.forEach(r => resultRelations.set(relationKey(r), r));
             if (currentDepth < depth) {
                 // Traverse to connected entities
                 connectedRelations.forEach(r => {
@@ -172,7 +204,7 @@ class KnowledgeGraphManager {
         traverse(entityName, 0);
         return {
             entities: Array.from(resultEntities.values()),
-            relations: resultRelations
+            relations: Array.from(resultRelations.values())
         };
     }
     async findPath(fromEntity, toEntity, maxDepth = 5) {
@@ -233,6 +265,8 @@ class KnowledgeGraphManager {
         const graph = await this.loadGraph();
         const entityNames = new Set(graph.entities.map(e => e.name));
         const missingEntities = new Set();
+        const observationViolations = [];
+        // Check for missing entities in relations
         graph.relations.forEach(r => {
             if (!entityNames.has(r.from)) {
                 missingEntities.add(r.from);
@@ -241,7 +275,26 @@ class KnowledgeGraphManager {
                 missingEntities.add(r.to);
             }
         });
-        return Array.from(missingEntities);
+        // Check for observation limit violations
+        graph.entities.forEach(e => {
+            const oversizedObservations = [];
+            e.observations.forEach((obs, idx) => {
+                if (obs.length > 140) {
+                    oversizedObservations.push(idx);
+                }
+            });
+            if (e.observations.length > 2 || oversizedObservations.length > 0) {
+                observationViolations.push({
+                    entity: e.name,
+                    count: e.observations.length,
+                    oversizedObservations
+                });
+            }
+        });
+        return {
+            missingEntities: Array.from(missingEntities),
+            observationViolations
+        };
     }
     // BCL (Binary Combinatory Logic) evaluator
     async evaluateBCL(program, maxSteps) {
@@ -402,379 +455,387 @@ class KnowledgeGraphManager {
         this.bclTerm = "";
     }
 }
-const knowledgeGraphManager = new KnowledgeGraphManager();
-// The server instance and tools exposed to Claude
-const server = new Server({
-    name: "memory-server",
-    version: "0.0.0",
-}, {
-    capabilities: {
-        tools: {},
-    },
-});
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-        tools: [
-            {
-                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"
+/**
+ * Creates a configured MCP server instance with all tools registered.
+ * @param memoryFilePath Optional path to the memory file (defaults to MEMORY_FILE_PATH env var or memory.json)
+ */
+export function createServer(memoryFilePath) {
+    const knowledgeGraphManager = new KnowledgeGraphManager(memoryFilePath);
+    const server = new Server({
+        name: "memory-server",
+        icons: [
+            { src: "data:image/svg+xml;base64,PHN2ZyBmaWxsPSJjdXJyZW50Q29sb3IiIGZpbGwtcnVsZT0iZXZlbm9kZCIgaGVpZ2h0PSIxZW0iIHN0eWxlPSJmbGV4Om5vbmU7bGluZS1oZWlnaHQ6MSIgdmlld0JveD0iMCAwIDI0IDI0IiB3aWR0aD0iMWVtIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPjx0aXRsZT5Nb2RlbENvbnRleHRQcm90b2NvbDwvdGl0bGU+PHBhdGggZD0iTTIwLjEgNS41MlYxLjVoLS4xOGMtMy4zNi4xNS02LjE1IDIuMzEtNy44MyA0LjAybC0uMDkuMDktLjA5LS4wOUMxMC4yIDMuODEgNy40NCAxLjY1IDQuMDggMS41SDMuOXY0LjAySDB2Ni45M2MwIDEuNjguMDYgMy4zNi4xOCA0Ljc0YTUuNTcgNS41NyAwIDAgMCA1LjE5IDUuMWMyLjEzLjEyIDQuMzguMjEgNi42My4yMXM0LjUtLjA5IDYuNjMtLjI0YTUuNTcgNS41NyAwIDAgMCA1LjE5LTUuMWMuMTItMS4zOC4xOC0zLjA2LjE4LTQuNzR2LTYuOXptMCA2LjkzYzAgMS41OS0uMDYgMy4xNS0uMTggNC40MS0uMDkuODEtLjc1IDEuNDctMS41NiAxLjVhOTAgOTAgMCAwIDEtMTIuNzIgMGMtLjgxLS4wMy0xLjUtLjY5LTEuNTYtMS41LS4xMi0xLjI2LS4xOC0yLjg1LS4xOC00LjQxVjUuNTJjMi44Mi4xMiA1LjY0IDMuMTUgNi40OCA0LjMyTDEyIDEyLjA5bDEuNjItMi4yNWMuODQtMS4yIDMuNjYtNC4yIDYuNDgtNC4zMnoiLz48L3N2Zz4=",
+                mimeType: "image/svg+xml",
+                sizes: ["any"]
+            }
+        ],
+        version: "0.0.4",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: [
+                {
+                    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", maxLength: 140 },
+                                            maxItems: 2,
+                                            description: "Observations associated with the entity. MAX 2 observations, each MAX 140 characters."
+                                        },
                                     },
+                                    required: ["name", "entityType", "observations"],
                                 },
-                                required: ["name", "entityType", "observations"],
                             },
                         },
+                        required: ["entities"],
                     },
-                    required: ["entities"],
                 },
-            },
-            {
-                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" },
+                {
+                    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" },
+                                    },
+                                    required: ["from", "to", "relationType"],
                                 },
-                                required: ["from", "to", "relationType"],
                             },
                         },
+                        required: ["relations"],
                     },
-                    required: ["relations"],
                 },
-            },
-            {
-                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 the observations to" },
-                                    contents: {
-                                        type: "array",
-                                        items: { type: "string" },
-                                        description: "An array of observation contents to add"
+                {
+                    name: "add_observations",
+                    description: "Add new observations to existing entities in the knowledge graph. Entities are limited to 2 total observations.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            observations: {
+                                type: "array",
+                                items: {
+                                    type: "object",
+                                    properties: {
+                                        entityName: { type: "string", description: "The name of the entity to add the observations to" },
+                                        contents: {
+                                            type: "array",
+                                            items: { type: "string", maxLength: 140 },
+                                            description: "Observations to add. Each MAX 140 characters. Entity total MAX 2 observations."
+                                        },
                                     },
+                                    required: ["entityName", "contents"],
                                 },
-                                required: ["entityName", "contents"],
                             },
                         },
+                        required: ["observations"],
                     },
-                    required: ["observations"],
                 },
-            },
-            {
-                name: "delete_entities",
-                description: "Delete multiple entities and their associated relations from the knowledge graph",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        entityNames: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: "An array of entity names to delete"
+                {
+                    name: "delete_entities",
+                    description: "Delete multiple entities and their associated relations from the knowledge graph",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            entityNames: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "An array of entity names to delete"
+                            },
                         },
+                        required: ["entityNames"],
                     },
-                    required: ["entityNames"],
                 },
-            },
-            {
-                name: "delete_observations",
-                description: "Delete specific observations from entities in the knowledge graph",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        deletions: {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                properties: {
-                                    entityName: { type: "string", description: "The name of the entity containing the observations" },
-                                    observations: {
-                                        type: "array",
-                                        items: { type: "string" },
-                                        description: "An array of observations to delete"
+                {
+                    name: "delete_observations",
+                    description: "Delete specific observations from entities in the knowledge graph",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            deletions: {
+                                type: "array",
+                                items: {
+                                    type: "object",
+                                    properties: {
+                                        entityName: { type: "string", description: "The name of the entity containing the observations" },
+                                        observations: {
+                                            type: "array",
+                                            items: { type: "string" },
+                                            description: "An array of observations to delete"
+                                        },
                                     },
+                                    required: ["entityName", "observations"],
                                 },
-                                required: ["entityName", "observations"],
                             },
                         },
+                        required: ["deletions"],
                     },
-                    required: ["deletions"],
                 },
-            },
-            {
-                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", 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" },
+                {
+                    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", 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" },
+                                    },
+                                    required: ["from", "to", "relationType"],
                                 },
-                                required: ["from", "to", "relationType"],
+                                description: "An array of relations to delete"
                             },
-                            description: "An array of relations to delete"
                         },
+                        required: ["relations"],
                     },
-                    required: ["relations"],
-                },
-            },
-            {
-                name: "read_graph",
-                description: "Read the entire knowledge graph",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
                 },
-            },
-            {
-                name: "search_nodes",
-                description: "Search for nodes in the knowledge graph based on a query",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        query: { type: "string", description: "The search query to match against entity names, types, and observation content" },
+                {
+                    name: "search_nodes",
+                    description: "Search for nodes in the knowledge graph using a regex pattern",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            query: { type: "string", description: "Regex pattern to match against entity names, types, and observations. Use | for alternatives (e.g., 'Taranis|wheel'). Special regex characters must be escaped for literal matching." },
+                        },
+                        required: ["query"],
                     },
-                    required: ["query"],
                 },
-            },
-            {
-                name: "open_nodes_filtered",
-                description: "Open specific nodes in the knowledge graph by their names, filtering relations to only those between the opened nodes",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        names: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: "An array of entity names to retrieve",
+                {
+                    name: "open_nodes_filtered",
+                    description: "Open specific nodes in the knowledge graph by their names, filtering relations to only those between the opened nodes",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            names: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "An array of entity names to retrieve",
+                            },
                         },
+                        required: ["names"],
                     },
-                    required: ["names"],
                 },
-            },
-            {
-                name: "open_nodes",
-                description: "Open specific nodes in the knowledge graph by their names",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        names: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: "An array of entity names to retrieve",
+                {
+                    name: "open_nodes",
+                    description: "Open specific nodes in the knowledge graph by their names",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            names: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "An array of entity names to retrieve",
+                            },
                         },
+                        required: ["names"],
                     },
-                    required: ["names"],
                 },
-            },
-            {
-                name: "get_neighbors",
-                description: "Get neighboring entities connected to a specific entity within a given depth",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        entityName: { type: "string", description: "The name of the entity to find neighbors for" },
-                        depth: { type: "number", description: "Maximum depth to traverse (default: 1)", default: 1 },
+                {
+                    name: "get_neighbors",
+                    description: "Get neighboring entities connected to a specific entity within a given depth",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            entityName: { type: "string", description: "The name of the entity to find neighbors for" },
+                            depth: { type: "number", description: "Maximum depth to traverse (default: 0)", default: 0 },
+                            withEntities: { type: "boolean", description: "If true, include full entity data. Default returns only relations for lightweight structure exploration.", default: false },
+                        },
+                        required: ["entityName"],
                     },
-                    required: ["entityName"],
                 },
-            },
-            {
-                name: "find_path",
-                description: "Find a path between two entities in the knowledge graph",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        fromEntity: { type: "string", description: "The name of the starting entity" },
-                        toEntity: { type: "string", description: "The name of the target entity" },
-                        maxDepth: { type: "number", description: "Maximum depth to search (default: 5)", default: 5 },
+                {
+                    name: "find_path",
+                    description: "Find a path between two entities in the knowledge graph",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            fromEntity: { type: "string", description: "The name of the starting entity" },
+                            toEntity: { type: "string", description: "The name of the target entity" },
+                            maxDepth: { type: "number", description: "Maximum depth to search (default: 5)", default: 5 },
+                        },
+                        required: ["fromEntity", "toEntity"],
                     },
-                    required: ["fromEntity", "toEntity"],
                 },
-            },
-            {
-                name: "get_entities_by_type",
-                description: "Get all entities of a specific type",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        entityType: { type: "string", description: "The type of entities to retrieve" },
+                {
+                    name: "get_entities_by_type",
+                    description: "Get all entities of a specific type",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            entityType: { type: "string", description: "The type of entities to retrieve" },
+                        },
+                        required: ["entityType"],
                     },
-                    required: ["entityType"],
                 },
-            },
-            {
-                name: "get_entity_types",
-                description: "Get all unique entity types in the knowledge graph",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
+                {
+                    name: "get_entity_types",
+                    description: "Get all unique entity types in the knowledge graph",
+                    inputSchema: {
+                        type: "object",
+                        properties: {},
+                    },
                 },
-            },
-            {
-                name: "get_relation_types",
-                description: "Get all unique relation types in the knowledge graph",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
+                {
+                    name: "get_relation_types",
+                    description: "Get all unique relation types in the knowledge graph",
+                    inputSchema: {
+                        type: "object",
+                        properties: {},
+                    },
                 },
-            },
-            {
-                name: "get_stats",
-                description: "Get statistics about the knowledge graph",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
+                {
+                    name: "get_stats",
+                    description: "Get statistics about the knowledge graph",
+                    inputSchema: {
+                        type: "object",
+                        properties: {},
+                    },
                 },
-            },
-            {
-                name: "get_orphaned_entities",
-                description: "Get entities that have no relations (orphaned entities)",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
+                {
+                    name: "get_orphaned_entities",
+                    description: "Get entities that have no relations (orphaned entities)",
+                    inputSchema: {
+                        type: "object",
+                        properties: {},
+                    },
                 },
-            },
-            {
-                name: "validate_graph",
-                description: "Validate the knowledge graph and return a list of missing entities referenced in relations",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
+                {
+                    name: "validate_graph",
+                    description: "Validate the knowledge graph. Returns missing entities referenced in relations and observation limit violations (>2 observations or >140 chars).",
+                    inputSchema: {
+                        type: "object",
+                        properties: {},
+                    },
                 },
-            },
-            {
-                name: "evaluate_bcl",
-                description: "Evaluate a Binary Combinatory Logic (BCL) program",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        program: { type: "string", description: "The BCL program as a binary string (syntax: T:=00|01|1TT) 00=K, 01=S, 1=application." },
-                        maxSteps: { type: "number", description: "Maximum number of reduction steps to perform (default: 1000000)", default: 1000000 },
+                {
+                    name: "evaluate_bcl",
+                    description: "Evaluate a Binary Combinatory Logic (BCL) program",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            program: { type: "string", description: "The BCL program as a binary string (syntax: T:=00|01|1TT) 00=K, 01=S, 1=application." },
+                            maxSteps: { type: "number", description: "Maximum number of reduction steps to perform (default: 1000000)", default: 1000000 },
+                        },
+                        required: ["program"],
                     },
-                    required: ["program"],
                 },
-            },
-            {
-                name: "add_bcl_term",
-                description: "Add a BCL term to the constructor, maintaining valid syntax. Returns completion status.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        term: {
-                            type: "string",
-                            description: "BCL term to add. Valid values: '1' or 'App' (application), '00' or 'K' (K combinator), '01' or 'S' (S combinator)"
+                {
+                    name: "add_bcl_term",
+                    description: "Add a BCL term to the constructor, maintaining valid syntax. Returns completion status.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            term: {
+                                type: "string",
+                                description: "BCL term to add. Valid values: '1' or 'App' (application), '00' or 'K' (K combinator), '01' or 'S' (S combinator)"
+                            },
                         },
+                        required: ["term"],
                     },
-                    required: ["term"],
                 },
-            },
-            {
-                name: "clear_bcl_term",
-                description: "Clear the current BCL term being constructed and reset the constructor state",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
+                {
+                    name: "clear_bcl_term",
+                    description: "Clear the current BCL term being constructed and reset the constructor state",
+                    inputSchema: {
+                        type: "object",
+                        properties: {},
+                    },
                 },
-            },
-        ],
-    };
-});
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    if (!args) {
-        throw new Error(`No arguments provided for tool: ${name}`);
-    }
-    switch (name) {
-        case "create_entities":
-            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.createEntities(args.entities), null, 2) }] };
-        case "create_relations":
-            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.createRelations(args.relations), null, 2) }] };
-        case "add_observations":
-            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.addObservations(args.observations), null, 2) }] };
-        case "delete_entities":
-            await knowledgeGraphManager.deleteEntities(args.entityNames);
-            return { content: [{ type: "text", text: "Entities deleted successfully" }] };
-        case "delete_observations":
-            await knowledgeGraphManager.deleteObservations(args.deletions);
-            return { content: [{ type: "text", text: "Observations deleted successfully" }] };
-        case "delete_relations":
-            await knowledgeGraphManager.deleteRelations(args.relations);
-            return { content: [{ type: "text", text: "Relations deleted successfully" }] };
-        case "read_graph":
-            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.readGraph(), null, 2) }] };
-        case "search_nodes":
-            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.searchNodes(args.query), null, 2) }] };
-        case "open_nodes_filtered":
-            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.openNodesFiltered(args.names), null, 2) }] };
-        case "open_nodes":
-            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.openNodes(args.names), null, 2) }] };
-        case "get_neighbors":
-            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.getNeighbors(args.entityName, args.depth), null, 2) }] };
-        case "find_path":
-            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.findPath(args.fromEntity, args.toEntity, args.maxDepth), null, 2) }] };
-        case "get_entities_by_type":
-            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.getEntitiesByType(args.entityType), null, 2) }] };
-        case "get_entity_types":
-            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.getEntityTypes(), null, 2) }] };
-        case "get_relation_types":
-            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.getRelationTypes(), null, 2) }] };
-        case "get_stats":
-            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.getStats(), null, 2) }] };
-        case "get_orphaned_entities":
-            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.getOrphanedEntities(), null, 2) }] };
-        case "validate_graph":
-            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.validateGraph(), null, 2) }] };
-        case "evaluate_bcl":
-            return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.evaluateBCL(args.program, args.maxSteps), null, 2) }] };
-        case "add_bcl_term":
-            return { content: [{ type: "text", text: await knowledgeGraphManager.addBCLTerm(args.term) }] };
-        case "clear_bcl_term":
-            await knowledgeGraphManager.clearBCLTerm();
-            return { content: [{ type: "text", text: "BCL term constructor cleared successfully" }] };
-        default:
-            throw new Error(`Unknown tool: ${name}`);
-    }
-});
-async function main() {
+            ],
+        };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        if (!args) {
+            throw new Error(`No arguments provided for tool: ${name}`);
+        }
+        switch (name) {
+            case "create_entities":
+                return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.createEntities(args.entities), null, 2) }] };
+            case "create_relations":
+                return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.createRelations(args.relations), null, 2) }] };
+            case "add_observations":
+                return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.addObservations(args.observations), null, 2) }] };
+            case "delete_entities":
+                await knowledgeGraphManager.deleteEntities(args.entityNames);
+                return { content: [{ type: "text", text: "Entities deleted successfully" }] };
+            case "delete_observations":
+                await knowledgeGraphManager.deleteObservations(args.deletions);
+                return { content: [{ type: "text", text: "Observations deleted successfully" }] };
+            case "delete_relations":
+                await knowledgeGraphManager.deleteRelations(args.relations);
+                return { content: [{ type: "text", text: "Relations deleted successfully" }] };
+            case "search_nodes":
+                return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.searchNodes(args.query), null, 2) }] };
+            case "open_nodes_filtered":
+                return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.openNodesFiltered(args.names), null, 2) }] };
+            case "open_nodes":
+                return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.openNodes(args.names), null, 2) }] };
+            case "get_neighbors":
+                return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.getNeighbors(args.entityName, args.depth, args.withEntities), null, 2) }] };
+            case "find_path":
+                return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.findPath(args.fromEntity, args.toEntity, args.maxDepth), null, 2) }] };
+            case "get_entities_by_type":
+                return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.getEntitiesByType(args.entityType), null, 2) }] };
+            case "get_entity_types":
+                return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.getEntityTypes(), null, 2) }] };
+            case "get_relation_types":
+                return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.getRelationTypes(), null, 2) }] };
+            case "get_stats":
+                return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.getStats(), null, 2) }] };
+            case "get_orphaned_entities":
+                return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.getOrphanedEntities(), null, 2) }] };
+            case "validate_graph":
+                return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.validateGraph(), null, 2) }] };
+            case "evaluate_bcl":
+                return { content: [{ type: "text", text: JSON.stringify(await knowledgeGraphManager.evaluateBCL(args.program, args.maxSteps), null, 2) }] };
+            case "add_bcl_term":
+                return { content: [{ type: "text", text: await knowledgeGraphManager.addBCLTerm(args.term) }] };
+            case "clear_bcl_term":
+                await knowledgeGraphManager.clearBCLTerm();
+                return { content: [{ type: "text", text: "BCL term constructor cleared successfully" }] };
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    });
+    return server;
+}
+// Main entry point - only runs when executed directly, not when imported
+const isMainModule = process.argv[1] && (process.argv[1].endsWith('index.js') ||
+    process.argv[1].endsWith('index.ts'));
+if (isMainModule) {
+    const server = createServer();
     const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error("Knowledge Graph MCP Server running on stdio");
+    server.connect(transport).then(() => {
+        console.error("Knowledge Graph MCP Server running on stdio");
+    }).catch((error) => {
+        console.error("Fatal error:", error);
+        process.exit(1);
+    });
 }
-main().catch((error) => {
-    console.error("Fatal error in main():", error);
-    process.exit(1);
-});