server-memory-enhanced 2.3.2 → 3.0.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { KnowledgeGraphManager } from './lib/knowledge-graph-manager.js';
-import { EntitySchema, RelationSchema, SaveMemoryInputSchema, SaveMemoryOutputSchema, GetAnalyticsInputSchema, GetAnalyticsOutputSchema, GetObservationHistoryInputSchema, GetObservationHistoryOutputSchema, ListEntitiesInputSchema, ListEntitiesOutputSchema, ValidateMemoryInputSchema, ValidateMemoryOutputSchema, UpdateObservationInputSchema, UpdateObservationOutputSchema } from './lib/schemas.js';
+import { EntitySchema, RelationSchema, SaveMemoryInputSchema, SaveMemoryOutputSchema, GetAnalyticsInputSchema, GetAnalyticsOutputSchema, GetObservationHistoryInputSchema, GetObservationHistoryOutputSchema, ListEntitiesInputSchema, ListEntitiesOutputSchema, ValidateMemoryInputSchema, ValidateMemoryOutputSchema, UpdateObservationInputSchema, UpdateObservationOutputSchema, ReadGraphInputSchema, SearchNodesInputSchema, OpenNodesInputSchema, QueryNodesInputSchema, GetMemoryStatsInputSchema, GetRecentChangesInputSchema, FindRelationPathInputSchema, DetectConflictsInputSchema, GetFlaggedEntitiesInputSchema, GetContextInputSchema } from './lib/schemas.js';
 import { handleSaveMemory } from './lib/save-memory-handler.js';
 import { validateSaveMemoryRequest } from './lib/validation.js';
 import { JsonlStorageAdapter } from './lib/jsonl-storage-adapter.js';
@@ -314,14 +314,14 @@ server.registerTool("delete_relations", {
 // Register read_graph tool
 server.registerTool("read_graph", {
     title: "Read Graph",
-    description: "Read the entire knowledge graph",
-    inputSchema: {},
+    description: "Read the knowledge graph for a specific thread (thread isolation enforced)",
+    inputSchema: ReadGraphInputSchema,
     outputSchema: {
         entities: z.array(EntitySchemaCompat),
         relations: z.array(RelationSchemaCompat)
     }
-}, async () => {
-    const graph = await knowledgeGraphManager.readGraph();
+}, async (input) => {
+    const graph = await knowledgeGraphManager.readGraph(input.threadId);
     return {
         content: [{ type: "text", text: JSON.stringify(graph, null, 2) }],
         structuredContent: { ...graph }
@@ -330,16 +330,14 @@ server.registerTool("read_graph", {
 // Register search_nodes tool
 server.registerTool("search_nodes", {
     title: "Search Nodes",
-    description: "Search for nodes in the knowledge graph based on a query",
-    inputSchema: {
-        query: z.string().describe("The search query to match against entity names, types, and observation content")
-    },
+    description: "Search for nodes in the knowledge graph based on a query (thread isolation enforced)",
+    inputSchema: SearchNodesInputSchema,
     outputSchema: {
         entities: z.array(EntitySchemaCompat),
         relations: z.array(RelationSchemaCompat)
     }
-}, async ({ query }) => {
-    const graph = await knowledgeGraphManager.searchNodes(query);
+}, async (input) => {
+    const graph = await knowledgeGraphManager.searchNodes(input.threadId, input.query);
     return {
         content: [{ type: "text", text: JSON.stringify(graph, null, 2) }],
         structuredContent: { ...graph }
@@ -348,16 +346,14 @@ server.registerTool("search_nodes", {
 // Register open_nodes tool
 server.registerTool("open_nodes", {
     title: "Open Nodes",
-    description: "Open specific nodes in the knowledge graph by their names",
-    inputSchema: {
-        names: z.array(z.string()).describe("An array of entity names to retrieve")
-    },
+    description: "Open specific nodes in the knowledge graph by their names (thread isolation enforced)",
+    inputSchema: OpenNodesInputSchema,
     outputSchema: {
         entities: z.array(EntitySchemaCompat),
         relations: z.array(RelationSchemaCompat)
     }
-}, async ({ names }) => {
-    const graph = await knowledgeGraphManager.openNodes(names);
+}, async (input) => {
+    const graph = await knowledgeGraphManager.openNodes(input.threadId, input.names);
     return {
         content: [{ type: "text", text: JSON.stringify(graph, null, 2) }],
         structuredContent: { ...graph }
@@ -366,21 +362,15 @@ server.registerTool("open_nodes", {
 // Register query_nodes tool for advanced filtering
 server.registerTool("query_nodes", {
     title: "Query Nodes",
-    description: "Query nodes and relations in the knowledge graph with advanced filtering by timestamp, confidence, and importance ranges",
-    inputSchema: {
-        timestampStart: z.string().optional().describe("ISO 8601 timestamp - filter for items created on or after this time"),
-        timestampEnd: z.string().optional().describe("ISO 8601 timestamp - filter for items created on or before this time"),
-        confidenceMin: z.number().min(0).max(1).optional().describe("Minimum confidence value (0-1)"),
-        confidenceMax: z.number().min(0).max(1).optional().describe("Maximum confidence value (0-1)"),
-        importanceMin: z.number().min(0).max(1).optional().describe("Minimum importance value (0-1)"),
-        importanceMax: z.number().min(0).max(1).optional().describe("Maximum importance value (0-1)")
-    },
+    description: "Query nodes and relations in the knowledge graph with advanced filtering by timestamp, confidence, and importance ranges (thread isolation enforced)",
+    inputSchema: QueryNodesInputSchema,
     outputSchema: {
         entities: z.array(EntitySchemaCompat),
         relations: z.array(RelationSchemaCompat)
     }
-}, async (filters) => {
-    const graph = await knowledgeGraphManager.queryNodes(filters);
+}, async (input) => {
+    const { threadId, ...filters } = input;
+    const graph = await knowledgeGraphManager.queryNodes(threadId, Object.keys(filters).length > 0 ? filters : undefined);
     return {
         content: [{ type: "text", text: JSON.stringify(graph, null, 2) }],
         structuredContent: { ...graph }
@@ -389,7 +379,7 @@ server.registerTool("query_nodes", {
 // Register list_entities tool for simple entity lookup
 server.registerTool("list_entities", {
     title: "List Entities",
-    description: "List entities with optional filtering by entity type and name pattern. Returns a simple list of entity names and types for quick discovery.",
+    description: "List entities with optional filtering by entity type and name pattern. Returns a simple list of entity names and types for quick discovery. Thread isolation enforced - only shows entities from the specified thread.",
     inputSchema: ListEntitiesInputSchema,
     outputSchema: ListEntitiesOutputSchema
 }, async (input) => {
@@ -522,8 +512,8 @@ server.registerTool("validate_memory", {
 // Register get_memory_stats tool
 server.registerTool("get_memory_stats", {
     title: "Get Memory Statistics",
-    description: "Get comprehensive statistics about the knowledge graph including entity counts, thread activity, and confidence/importance metrics",
-    inputSchema: {},
+    description: "Get comprehensive statistics about the knowledge graph for a specific thread including entity counts, activity, and confidence/importance metrics (thread isolation enforced)",
+    inputSchema: GetMemoryStatsInputSchema,
     outputSchema: {
         entityCount: z.number(),
         relationCount: z.number(),
@@ -536,8 +526,8 @@ server.registerTool("get_memory_stats", {
             entityCount: z.number()
         }))
     }
-}, async () => {
-    const stats = await knowledgeGraphManager.getMemoryStats();
+}, async (input) => {
+    const stats = await knowledgeGraphManager.getMemoryStats(input.threadId);
     return {
         content: [{ type: "text", text: JSON.stringify(stats, null, 2) }],
         structuredContent: stats
@@ -546,16 +536,14 @@ server.registerTool("get_memory_stats", {
 // Register get_recent_changes tool
 server.registerTool("get_recent_changes", {
     title: "Get Recent Changes",
-    description: "Retrieve entities and relations that were created or modified since a specific timestamp",
-    inputSchema: {
-        since: z.string().describe("ISO 8601 timestamp - return changes since this time")
-    },
+    description: "Retrieve entities and relations that were created or modified since a specific timestamp (thread isolation enforced)",
+    inputSchema: GetRecentChangesInputSchema,
     outputSchema: {
         entities: z.array(EntitySchemaCompat),
         relations: z.array(RelationSchemaCompat)
     }
-}, async ({ since }) => {
-    const changes = await knowledgeGraphManager.getRecentChanges(since);
+}, async (input) => {
+    const changes = await knowledgeGraphManager.getRecentChanges(input.threadId, input.since);
     return {
         content: [{ type: "text", text: JSON.stringify(changes, null, 2) }],
         structuredContent: { ...changes }
@@ -564,19 +552,15 @@ server.registerTool("get_recent_changes", {
 // Register find_relation_path tool
 server.registerTool("find_relation_path", {
     title: "Find Relationship Path",
-    description: "Find a path of relationships connecting two entities in the knowledge graph",
-    inputSchema: {
-        from: z.string().describe("Starting entity name"),
-        to: z.string().describe("Target entity name"),
-        maxDepth: z.number().optional().default(5).describe("Maximum path depth to search (default: 5)")
-    },
+    description: "Find a path of relationships connecting two entities in the knowledge graph (thread isolation enforced)",
+    inputSchema: FindRelationPathInputSchema,
     outputSchema: {
         found: z.boolean(),
         path: z.array(z.string()),
         relations: z.array(RelationSchemaCompat)
     }
-}, async ({ from, to, maxDepth }) => {
-    const result = await knowledgeGraphManager.findRelationPath(from, to, maxDepth || 5);
+}, async (input) => {
+    const result = await knowledgeGraphManager.findRelationPath(input.threadId, input.from, input.to, input.maxDepth || 5);
     return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         structuredContent: result
@@ -585,8 +569,8 @@ server.registerTool("find_relation_path", {
 // Register detect_conflicts tool
 server.registerTool("detect_conflicts", {
     title: "Detect Conflicts",
-    description: "Detect potentially conflicting observations within entities using pattern matching and negation detection",
-    inputSchema: {},
+    description: "Detect potentially conflicting observations within entities using pattern matching and negation detection (thread isolation enforced)",
+    inputSchema: DetectConflictsInputSchema,
     outputSchema: {
         conflicts: z.array(z.object({
             entityName: z.string(),
@@ -597,8 +581,8 @@ server.registerTool("detect_conflicts", {
             }))
         }))
     }
-}, async () => {
-    const conflicts = await knowledgeGraphManager.detectConflicts();
+}, async (input) => {
+    const conflicts = await knowledgeGraphManager.detectConflicts(input.threadId);
     return {
         content: [{ type: "text", text: JSON.stringify({ conflicts }, null, 2) }],
         structuredContent: { conflicts }
@@ -670,13 +654,13 @@ server.registerTool("flag_for_review", {
 // Register get_flagged_entities tool
 server.registerTool("get_flagged_entities", {
     title: "Get Flagged Entities",
-    description: "Retrieve all entities that have been flagged for human review",
-    inputSchema: {},
+    description: "Retrieve all entities that have been flagged for human review (thread isolation enforced)",
+    inputSchema: GetFlaggedEntitiesInputSchema,
     outputSchema: {
         entities: z.array(EntitySchemaCompat)
     }
-}, async () => {
-    const entities = await knowledgeGraphManager.getFlaggedEntities();
+}, async (input) => {
+    const entities = await knowledgeGraphManager.getFlaggedEntities(input.threadId);
     return {
         content: [{ type: "text", text: JSON.stringify({ entities }, null, 2) }],
         structuredContent: { entities }
@@ -685,17 +669,14 @@ server.registerTool("get_flagged_entities", {
 // Register get_context tool
 server.registerTool("get_context", {
     title: "Get Context",
-    description: "Retrieve entities and relations related to specified entities up to a certain depth, useful for understanding context around specific topics",
-    inputSchema: {
-        entityNames: z.array(z.string()).describe("Names of entities to get context for"),
-        depth: z.number().optional().default(1).describe("How many relationship hops to include (default: 1)")
-    },
+    description: "Retrieve entities and relations related to specified entities up to a certain depth, useful for understanding context around specific topics (thread isolation enforced)",
+    inputSchema: GetContextInputSchema,
     outputSchema: {
         entities: z.array(EntitySchemaCompat),
         relations: z.array(RelationSchemaCompat)
     }
-}, async ({ entityNames, depth }) => {
-    const context = await knowledgeGraphManager.getContext(entityNames, depth || 1);
+}, async (input) => {
+    const context = await knowledgeGraphManager.getContext(input.threadId, input.entityNames, input.depth || 1);
     return {
         content: [{ type: "text", text: JSON.stringify(context, null, 2) }],
         structuredContent: { ...context }
@@ -738,11 +719,11 @@ server.registerTool("get_analytics", {
 // Register get_observation_history tool
 server.registerTool("get_observation_history", {
     title: "Get Observation History",
-    description: "Retrieve the full version chain for a specific observation, showing how it evolved over time",
+    description: "Retrieve the full version chain for a specific observation, showing how it evolved over time (thread isolation enforced)",
     inputSchema: GetObservationHistoryInputSchema,
     outputSchema: GetObservationHistoryOutputSchema
 }, async (input) => {
-    const result = await knowledgeGraphManager.getObservationHistory(input.entityName, input.observationId);
+    const result = await knowledgeGraphManager.getObservationHistory(input.threadId, input.entityName, input.observationId);
     return {
         content: [{ type: "text", text: JSON.stringify({ history: result }, null, 2) }],
         structuredContent: { history: result }

package/dist/lib/analysis/conflict-detector.js

@@ -5,11 +5,13 @@ import { hasNegation, NEGATION_WORDS } from '../utils/negation-detector.js';
 /**
  * Detect conflicting observations within entities
  * Identifies potential contradictions by checking for negation patterns
+ * Filtered by threadId for thread isolation
  */
-export async function detectConflicts(storage) {
+export async function detectConflicts(storage, threadId) {
     const graph = await storage.loadGraph();
     const conflicts = [];
-    for (const entity of graph.entities) {
+    // Only analyze entities in the specified thread
+    for (const entity of graph.entities.filter(e => e.agentThreadId === threadId)) {
         const entityConflicts = [];
         for (let i = 0; i < entity.observations.length; i++) {
             for (let j = i + 1; j < entity.observations.length; j++) {

package/dist/lib/analysis/context-builder.js

@@ -4,16 +4,18 @@
 /**
  * Get context (entities related to specified entities up to a certain depth)
  * Expands to include related entities up to specified depth
+ * Filtered by threadId for thread isolation
  */
-export async function getContext(storage, entityNames, depth = 1) {
+export async function getContext(storage, threadId, entityNames, depth = 1) {
     const graph = await storage.loadGraph();
     const contextEntityNames = new Set(entityNames);
-    // Expand to include related entities up to specified depth
+    // Expand to include related entities up to specified depth - only within this thread
     for (let d = 0; d < depth; d++) {
         const currentEntities = Array.from(contextEntityNames);
         for (const entityName of currentEntities) {
-            // Find all relations involving this entity
-            const relatedRelations = graph.relations.filter(r => r.from === entityName || r.to === entityName);
+            // Find all relations involving this entity - only from this thread
+            const relatedRelations = graph.relations.filter(r => r.agentThreadId === threadId &&
+                (r.from === entityName || r.to === entityName));
             // Add related entities
             relatedRelations.forEach(r => {
                 contextEntityNames.add(r.from);
@@ -21,9 +23,10 @@ export async function getContext(storage, entityNames, depth = 1) {
             });
         }
     }
-    // Get all entities and relations in context
-    const contextEntities = graph.entities.filter(e => contextEntityNames.has(e.name));
-    const contextRelations = graph.relations.filter(r => contextEntityNames.has(r.from) && contextEntityNames.has(r.to));
+    // Get all entities and relations in context - only from this thread
+    const contextEntities = graph.entities.filter(e => e.agentThreadId === threadId && contextEntityNames.has(e.name));
+    const contextRelations = graph.relations.filter(r => r.agentThreadId === threadId &&
+        contextEntityNames.has(r.from) && contextEntityNames.has(r.to));
     return {
         entities: contextEntities,
         relations: contextRelations

package/dist/lib/analysis/memory-stats.js

@@ -2,31 +2,34 @@
  * Memory statistics service
  */
 /**
- * Get comprehensive memory statistics
+ * Get comprehensive memory statistics for a specific thread
+ * Filtered by threadId for thread isolation
  */
-export async function getMemoryStats(storage) {
+export async function getMemoryStats(storage, threadId) {
     const graph = await storage.loadGraph();
+    // Filter entities and relations by threadId
+    const threadEntities = graph.entities.filter(e => e.agentThreadId === threadId);
+    const threadRelations = graph.relations.filter(r => r.agentThreadId === threadId);
     // Count entity types
     const entityTypes = {};
-    graph.entities.forEach(e => {
+    threadEntities.forEach(e => {
         entityTypes[e.entityType] = (entityTypes[e.entityType] || 0) + 1;
     });
     // Calculate averages
-    const avgConfidence = graph.entities.length > 0
-        ? graph.entities.reduce((sum, e) => sum + e.confidence, 0) / graph.entities.length
+    const avgConfidence = threadEntities.length > 0
+        ? threadEntities.reduce((sum, e) => sum + e.confidence, 0) / threadEntities.length
         : 0;
-    const avgImportance = graph.entities.length > 0
-        ? graph.entities.reduce((sum, e) => sum + e.importance, 0) / graph.entities.length
+    const avgImportance = threadEntities.length > 0
+        ? threadEntities.reduce((sum, e) => sum + e.importance, 0) / threadEntities.length
         : 0;
-    // Count unique threads
-    const threads = new Set([
-        ...graph.entities.map(e => e.agentThreadId),
-        ...graph.relations.map(r => r.agentThreadId)
-    ]);
-    // Recent activity (last 7 days, grouped by day)
+    // Count unique threads in the system (across all entities in the graph)
+    const threads = new Set(graph.entities
+        .map(e => e.agentThreadId)
+        .filter((id) => !!id));
+    // Recent activity (last 7 days, grouped by day) - only for this thread
     const now = new Date();
     const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
-    const recentEntities = graph.entities.filter(e => new Date(e.timestamp) >= sevenDaysAgo);
+    const recentEntities = threadEntities.filter(e => new Date(e.timestamp) >= sevenDaysAgo);
     // Group by day
     const activityByDay = {};
     recentEntities.forEach(e => {
@@ -37,8 +40,8 @@ export async function getMemoryStats(storage) {
         .map(([timestamp, entityCount]) => ({ timestamp, entityCount }))
         .sort((a, b) => a.timestamp.localeCompare(b.timestamp));
     return {
-        entityCount: graph.entities.length,
-        relationCount: graph.relations.length,
+        entityCount: threadEntities.length,
+        relationCount: threadRelations.length,
         threadCount: threads.size,
         entityTypes,
         avgConfidence,
@@ -47,15 +50,16 @@ export async function getMemoryStats(storage) {
     };
 }
 /**
- * Get recent changes since a specific timestamp
+ * Get recent changes since a specific timestamp for a specific thread
+ * Filtered by threadId for thread isolation
  */
-export async function getRecentChanges(storage, since) {
+export async function getRecentChanges(storage, threadId, since) {
     const graph = await storage.loadGraph();
     const sinceDate = new Date(since);
-    // Only return entities and relations that were actually modified since the specified time
-    const recentEntities = graph.entities.filter(e => new Date(e.timestamp) >= sinceDate);
-    // Only include relations that are recent themselves
-    const recentRelations = graph.relations.filter(r => new Date(r.timestamp) >= sinceDate);
+    // Only return entities and relations from this thread that were modified since the specified time
+    const recentEntities = graph.entities.filter(e => e.agentThreadId === threadId && new Date(e.timestamp) >= sinceDate);
+    // Only include relations from this thread that are recent themselves
+    const recentRelations = graph.relations.filter(r => r.agentThreadId === threadId && new Date(r.timestamp) >= sinceDate);
     return {
         entities: recentEntities,
         relations: recentRelations

package/dist/lib/analysis/path-finder.js

@@ -4,16 +4,17 @@
 /**
  * Find the shortest path between two entities in the knowledge graph
  * Uses BFS algorithm with bidirectional search
+ * Filtered by threadId for thread isolation
  */
-export async function findRelationPath(storage, from, to, maxDepth = 5) {
+export async function findRelationPath(storage, threadId, from, to, maxDepth = 5) {
     const graph = await storage.loadGraph();
     if (from === to) {
         return { found: true, path: [from], relations: [] };
     }
-    // Build indexes for efficient relation lookup
+    // Build indexes for efficient relation lookup - only for relations in this thread
     const relationsFrom = new Map();
     const relationsTo = new Map();
-    for (const rel of graph.relations) {
+    for (const rel of graph.relations.filter(r => r.agentThreadId === threadId)) {
         if (!relationsFrom.has(rel.from)) {
             relationsFrom.set(rel.from, []);
         }

package/dist/lib/collaboration/flag-manager.js

@@ -30,9 +30,11 @@ export async function flagForReview(storage, entityName, reason, reviewer) {
     }
 }
 /**
- * Get all entities flagged for review
+ * Get all entities flagged for review in a specific thread
+ * Filtered by threadId for thread isolation
  */
-export async function getFlaggedEntities(storage) {
+export async function getFlaggedEntities(storage, threadId) {
     const graph = await storage.loadGraph();
-    return graph.entities.filter(e => e.observations.some(obs => obs.content.includes('[FLAGGED FOR REVIEW:')));
+    return graph.entities.filter(e => e.agentThreadId === threadId &&
+        e.observations.some(obs => obs.content.includes('[FLAGGED FOR REVIEW:')));
 }

package/dist/lib/knowledge-graph-manager.js

@@ -74,22 +74,22 @@ export class KnowledgeGraphManager {
         return ObservationOps.updateObservation(this.storage, params);
     }
     // Graph Reading Operations
-    async readGraph() {
+    async readGraph(threadId) {
         await this.ensureInitialized();
-        return GraphReader.readGraph(this.storage);
+        return GraphReader.readGraph(this.storage, threadId);
     }
     // Search Operations
-    async searchNodes(query) {
+    async searchNodes(threadId, query) {
         await this.ensureInitialized();
-        return SearchService.searchNodes(this.storage, query);
+        return SearchService.searchNodes(this.storage, threadId, query);
     }
-    async openNodes(names) {
+    async openNodes(threadId, names) {
         await this.ensureInitialized();
-        return SearchService.openNodes(this.storage, names);
+        return SearchService.openNodes(this.storage, threadId, names);
     }
-    async queryNodes(filters) {
+    async queryNodes(threadId, filters) {
         await this.ensureInitialized();
-        return SearchService.queryNodes(this.storage, filters);
+        return SearchService.queryNodes(this.storage, threadId, filters);
     }
     // Entity Query Operations
     async getAllEntityNames() {
@@ -105,26 +105,26 @@ export class KnowledgeGraphManager {
         return EntityQueries.listEntities(this.storage, threadId, entityType, namePattern);
     }
     // Memory Statistics & Insights
-    async getMemoryStats() {
+    async getMemoryStats(threadId) {
         await this.ensureInitialized();
-        return MemoryStats.getMemoryStats(this.storage);
+        return MemoryStats.getMemoryStats(this.storage, threadId);
     }
-    async getRecentChanges(since) {
+    async getRecentChanges(threadId, since) {
         await this.ensureInitialized();
-        return MemoryStats.getRecentChanges(this.storage, since);
+        return MemoryStats.getRecentChanges(this.storage, threadId, since);
     }
     // Analysis Operations
-    async findRelationPath(from, to, maxDepth = 5) {
+    async findRelationPath(threadId, from, to, maxDepth = 5) {
         await this.ensureInitialized();
-        return PathFinder.findRelationPath(this.storage, from, to, maxDepth);
+        return PathFinder.findRelationPath(this.storage, threadId, from, to, maxDepth);
     }
-    async detectConflicts() {
+    async detectConflicts(threadId) {
         await this.ensureInitialized();
-        return ConflictDetector.detectConflicts(this.storage);
+        return ConflictDetector.detectConflicts(this.storage, threadId);
     }
-    async getContext(entityNames, depth = 1) {
+    async getContext(threadId, entityNames, depth = 1) {
         await this.ensureInitialized();
-        return ContextBuilder.getContext(this.storage, entityNames, depth);
+        return ContextBuilder.getContext(this.storage, threadId, entityNames, depth);
     }
     async getAnalytics(threadId) {
         await this.ensureInitialized();
@@ -144,17 +144,17 @@ export class KnowledgeGraphManager {
         await this.ensureInitialized();
         return FlagManager.flagForReview(this.storage, entityName, reason, reviewer);
     }
-    async getFlaggedEntities() {
+    async getFlaggedEntities(threadId) {
         await this.ensureInitialized();
-        return FlagManager.getFlaggedEntities(this.storage);
+        return FlagManager.getFlaggedEntities(this.storage, threadId);
     }
     async listConversations() {
         await this.ensureInitialized();
         return ConversationService.listConversations(this.storage);
     }
     // Observation Versioning
-    async getObservationHistory(entityName, observationId) {
+    async getObservationHistory(threadId, entityName, observationId) {
         await this.ensureInitialized();
-        return ObservationHistory.getObservationHistory(this.storage, entityName, observationId);
+        return ObservationHistory.getObservationHistory(this.storage, threadId, entityName, observationId);
     }
 }

package/dist/lib/queries/entity-queries.js

@@ -2,55 +2,57 @@
  * Entity query operations
  */
 /**
- * Get names of all entities that can be referenced in relations.
- * @returns Set of entity names that exist in the graph.
+ * Get names of all entities across all threads.
  *
- * Note: Returns ALL entities globally because entity names are globally unique across
- * all threads in the collaborative knowledge graph (by design - see createEntities).
- * This enables any thread to reference any existing entity, supporting incremental
- * building and cross-thread collaboration. Thread-specific filtering is not needed
- * since entity names cannot conflict across threads.
+ * Note: This function is used for administrative purposes and returns entity names
+ * from all threads. Entity names are NOT globally unique - different threads can
+ * have entities with the same name. This function is primarily used by the manager's
+ * getAllEntityNames() method.
+ *
+ * For thread-isolated validation (e.g., in save_memory), use getEntityNamesInThread() instead.
  */
 export async function getAllEntityNames(storage) {
     const graph = await storage.loadGraph();
     const entityNames = new Set();
-    // Return all entities in the graph that can be referenced
-    // This allows incremental building: entities from previous save_memory calls
-    // can be referenced in new calls, enabling cross-save entity relations
+    // Return all entity names from all threads
     for (const entity of graph.entities) {
         entityNames.add(entity.name);
     }
     return entityNames;
 }
 /**
- * @deprecated Use {@link getAllEntityNames} instead.
- *
- * This method is kept for backward compatibility. It accepts a threadId parameter
- * for API consistency but does not use it for filtering; it returns the same
- * global set of entity names as {@link getAllEntityNames}.
+ * Get names of entities in a specific thread for thread isolation.
+ * This ensures entities can only reference other entities in the same thread.
  *
  * @param storage Storage adapter
- * @param threadId The thread ID (accepted but not used)
- * @returns Set of entity names that exist in the graph
+ * @param threadId The thread ID to filter by
+ * @returns Set of entity names that exist in the thread
  */
 export async function getEntityNamesInThread(storage, threadId) {
-    return getAllEntityNames(storage);
+    const graph = await storage.loadGraph();
+    const entityNames = new Set();
+    // Return only entities in the specified thread
+    for (const entity of graph.entities) {
+        if (entity.agentThreadId === threadId) {
+            entityNames.add(entity.name);
+        }
+    }
+    return entityNames;
 }
 /**
  * List entities with optional filtering by type and name pattern
+ * Thread isolation enforced - threadId is required.
+ *
  * @param storage Storage adapter
- * @param threadId Optional thread ID to filter by. If not provided, returns entities from all threads.
+ * @param threadId Thread ID to filter by (required for thread isolation)
  * @param entityType Optional entity type filter (exact match)
  * @param namePattern Optional name pattern filter (case-insensitive substring match)
  * @returns Array of entities with name and entityType
  */
 export async function listEntities(storage, threadId, entityType, namePattern) {
     const graph = await storage.loadGraph();
-    let filteredEntities = graph.entities;
-    // Filter by thread ID if specified (otherwise returns all threads)
-    if (threadId) {
-        filteredEntities = filteredEntities.filter(e => e.agentThreadId === threadId);
-    }
+    // Filter by thread ID (required for thread isolation)
+    let filteredEntities = graph.entities.filter(e => e.agentThreadId === threadId);
     // Filter by entity type if specified
     if (entityType) {
         filteredEntities = filteredEntities.filter(e => e.entityType === entityType);

package/dist/lib/queries/graph-reader.js

@@ -2,8 +2,19 @@
  * Graph reading operations
  */
 /**
- * Read the entire knowledge graph
+ * Read the knowledge graph filtered by threadId for thread isolation
  */
-export async function readGraph(storage) {
-    return storage.loadGraph();
+export async function readGraph(storage, threadId) {
+    const graph = await storage.loadGraph();
+    // Filter entities by threadId
+    const filteredEntities = graph.entities.filter(e => e.agentThreadId === threadId);
+    // 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 and from the same thread
+    const filteredRelations = graph.relations.filter(r => r.agentThreadId === threadId &&
+        filteredEntityNames.has(r.from) && filteredEntityNames.has(r.to));
+    return {
+        entities: filteredEntities,
+        relations: filteredRelations
+    };
 }

package/dist/lib/queries/search-service.js

@@ -4,17 +4,20 @@
 /**
  * Search for nodes in the knowledge graph by query string
  * Searches entity names, types, and observation content
+ * Filtered by threadId for thread isolation
  */
-export async function searchNodes(storage, query) {
+export async function searchNodes(storage, threadId, query) {
     const graph = await storage.loadGraph();
-    // 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.content?.toLowerCase().includes(query.toLowerCase())));
+    // Filter entities by threadId first, then by search query
+    const filteredEntities = graph.entities.filter(e => e.agentThreadId === threadId &&
+        (e.name.toLowerCase().includes(query.toLowerCase()) ||
+            e.entityType.toLowerCase().includes(query.toLowerCase()) ||
+            e.observations.some(o => o.content?.toLowerCase().includes(query.toLowerCase()))));
     // 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
-    const filteredRelations = graph.relations.filter(r => filteredEntityNames.has(r.from) && filteredEntityNames.has(r.to));
+    // Filter relations to only include those between filtered entities and from the same thread
+    const filteredRelations = graph.relations.filter(r => r.agentThreadId === threadId &&
+        filteredEntityNames.has(r.from) && filteredEntityNames.has(r.to));
     const filteredGraph = {
         entities: filteredEntities,
         relations: filteredRelations,
@@ -24,15 +27,17 @@ export async function searchNodes(storage, query) {
 /**
  * Open specific nodes by name
  * Returns a subgraph containing only the specified entities and relations between them
+ * Filtered by threadId for thread isolation
  */
-export async function openNodes(storage, names) {
+export async function openNodes(storage, threadId, names) {
     const graph = await storage.loadGraph();
-    // Filter entities
-    const filteredEntities = graph.entities.filter(e => names.includes(e.name));
+    // Filter entities by threadId first, then by name
+    const filteredEntities = graph.entities.filter(e => e.agentThreadId === threadId && names.includes(e.name));
     // 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
-    const filteredRelations = graph.relations.filter(r => filteredEntityNames.has(r.from) && filteredEntityNames.has(r.to));
+    // Filter relations to only include those between filtered entities and from the same thread
+    const filteredRelations = graph.relations.filter(r => r.agentThreadId === threadId &&
+        filteredEntityNames.has(r.from) && filteredEntityNames.has(r.to));
     const filteredGraph = {
         entities: filteredEntities,
         relations: filteredRelations,
@@ -42,15 +47,18 @@ export async function openNodes(storage, names) {
 /**
  * Query nodes with advanced filters
  * Supports filtering by timestamp range, confidence range, and importance range
+ * Filtered by threadId for thread isolation
  */
-export async function queryNodes(storage, filters) {
+export async function queryNodes(storage, threadId, filters) {
     const graph = await storage.loadGraph();
-    // If no filters provided, return entire graph
-    if (!filters) {
-        return graph;
-    }
-    // Apply filters to entities
+    // Apply filters to entities, starting with threadId filter
     const filteredEntities = graph.entities.filter(e => {
+        // Thread isolation filter - must match
+        if (e.agentThreadId !== threadId)
+            return false;
+        // Optional filters below
+        if (!filters)
+            return true;
         // Timestamp range filter
         if (filters.timestampStart && e.timestamp < filters.timestampStart)
             return false;
@@ -72,9 +80,15 @@ export async function queryNodes(storage, filters) {
     const filteredEntityNames = new Set(filteredEntities.map(e => e.name));
     // Apply filters to relations (and ensure they connect filtered entities)
     const filteredRelations = graph.relations.filter(r => {
+        // Thread isolation filter - must match
+        if (r.agentThreadId !== threadId)
+            return false;
         // Must connect filtered entities
         if (!filteredEntityNames.has(r.from) || !filteredEntityNames.has(r.to))
             return false;
+        // Optional filters below
+        if (!filters)
+            return true;
         // Timestamp range filter
         if (filters.timestampStart && r.timestamp < filters.timestampStart)
             return false;

package/dist/lib/schemas.js

@@ -50,8 +50,8 @@ export const SaveMemoryEntitySchema = z.object({
     importance: z.number().min(0).max(1).optional().default(0.5).describe("Importance for memory integrity (0-1)")
 });
 export const SaveMemoryInputSchema = z.object({
-    entities: z.array(SaveMemoryEntitySchema).min(1).describe("Array of entities to save"),
-    threadId: z.string().min(1).describe("Thread ID for this conversation/project")
+    threadId: z.string().min(1).describe("Thread ID for this conversation/project"),
+    entities: z.array(SaveMemoryEntitySchema).min(1).describe("Array of entities to save")
 });
 export const SaveMemoryOutputSchema = z.object({
     success: z.boolean(),
@@ -95,6 +95,7 @@ export const GetAnalyticsOutputSchema = z.object({
 });
 // Schema for get_observation_history tool (Observation Versioning section of spec)
 export const GetObservationHistoryInputSchema = z.object({
+    threadId: z.string().min(1).describe("Thread ID for this conversation/project"),
     entityName: z.string().min(1).describe("Name of the entity"),
     observationId: z.string().min(1).describe("ID of the observation to retrieve history for")
 });
@@ -103,7 +104,7 @@ export const GetObservationHistoryOutputSchema = z.object({
 });
 // Schema for list_entities tool (Simple Entity Lookup)
 export const ListEntitiesInputSchema = z.object({
-    threadId: z.string().optional().describe("Filter by thread ID (optional - returns entities from all threads if not specified)"),
+    threadId: z.string().min(1).describe("Thread ID for this conversation/project"),
     entityType: z.string().optional().describe("Filter by entity type (e.g., 'Person', 'Service', 'Document')"),
     namePattern: z.string().optional().describe("Filter by name pattern (case-insensitive substring match)")
 });
@@ -115,8 +116,8 @@ export const ListEntitiesOutputSchema = z.object({
 });
 // Schema for validate_memory tool (Pre-Validation)
 export const ValidateMemoryInputSchema = z.object({
-    entities: z.array(SaveMemoryEntitySchema).min(1).describe("Array of entities to validate"),
-    threadId: z.string().min(1).describe("Thread ID for this conversation/project")
+    threadId: z.string().min(1).describe("Thread ID for this conversation/project"),
+    entities: z.array(SaveMemoryEntitySchema).min(1).describe("Array of entities to validate")
 });
 export const ValidateMemoryOutputSchema = z.object({
     all_valid: z.boolean().describe("True if all entities pass validation"),
@@ -131,10 +132,10 @@ export const ValidateMemoryOutputSchema = z.object({
 });
 // Schema for update_observation tool
 export const UpdateObservationInputSchema = z.object({
+    agentThreadId: z.string().min(1).describe("Agent thread ID making this update"),
     entityName: z.string().min(1).describe("Name of the entity containing the observation"),
     observationId: z.string().min(1).describe("ID of the observation to update"),
     newContent: z.string().min(1).max(300).describe("New content for the observation (max 300 chars). Minimum 1 character to allow short but valid observations like abbreviations or single words."),
-    agentThreadId: z.string().min(1).describe("Agent thread ID making this update"),
     timestamp: z.string().describe("ISO 8601 timestamp of the update"),
     confidence: z.number().min(0).max(1).optional().describe("Optional confidence score (0-1), inherits from old observation if not provided"),
     importance: z.number().min(0).max(1).optional().describe("Optional importance score (0-1), inherits from old observation if not provided")
@@ -144,3 +145,57 @@ export const UpdateObservationOutputSchema = z.object({
     updatedObservation: ObservationSchema.describe("The new version of the observation"),
     message: z.string()
 });
+// Schema for read_graph tool
+export const ReadGraphInputSchema = z.object({
+    threadId: z.string().min(1).describe("Thread ID for this conversation/project")
+});
+// Schema for search_nodes tool
+export const SearchNodesInputSchema = z.object({
+    threadId: z.string().min(1).describe("Thread ID for this conversation/project"),
+    query: z.string().min(1).describe("Search query string")
+});
+// Schema for open_nodes tool
+export const OpenNodesInputSchema = z.object({
+    threadId: z.string().min(1).describe("Thread ID for this conversation/project"),
+    names: z.array(z.string()).min(1).describe("Array of entity names to open")
+});
+// Schema for query_nodes tool
+export const QueryNodesInputSchema = z.object({
+    threadId: z.string().min(1).describe("Thread ID for this conversation/project"),
+    timestampStart: z.string().optional().describe("Filter by start timestamp (ISO 8601)"),
+    timestampEnd: z.string().optional().describe("Filter by end timestamp (ISO 8601)"),
+    confidenceMin: z.number().min(0).max(1).optional().describe("Filter by minimum confidence (0-1)"),
+    confidenceMax: z.number().min(0).max(1).optional().describe("Filter by maximum confidence (0-1)"),
+    importanceMin: z.number().min(0).max(1).optional().describe("Filter by minimum importance (0-1)"),
+    importanceMax: z.number().min(0).max(1).optional().describe("Filter by maximum importance (0-1)")
+});
+// Schema for get_memory_stats tool
+export const GetMemoryStatsInputSchema = z.object({
+    threadId: z.string().min(1).describe("Thread ID for this conversation/project")
+});
+// Schema for get_recent_changes tool
+export const GetRecentChangesInputSchema = z.object({
+    threadId: z.string().min(1).describe("Thread ID for this conversation/project"),
+    since: z.string().describe("ISO 8601 timestamp to get changes since")
+});
+// Schema for find_relation_path tool
+export const FindRelationPathInputSchema = z.object({
+    threadId: z.string().min(1).describe("Thread ID for this conversation/project"),
+    from: z.string().min(1).describe("Source entity name"),
+    to: z.string().min(1).describe("Target entity name"),
+    maxDepth: z.number().int().min(1).optional().default(5).describe("Maximum path depth (default: 5)")
+});
+// Schema for detect_conflicts tool
+export const DetectConflictsInputSchema = z.object({
+    threadId: z.string().min(1).describe("Thread ID for this conversation/project")
+});
+// Schema for get_flagged_entities tool
+export const GetFlaggedEntitiesInputSchema = z.object({
+    threadId: z.string().min(1).describe("Thread ID for this conversation/project")
+});
+// Schema for get_context tool
+export const GetContextInputSchema = z.object({
+    threadId: z.string().min(1).describe("Thread ID for this conversation/project"),
+    entityNames: z.array(z.string()).min(1).describe("Array of entity names to get context for"),
+    depth: z.number().int().min(1).optional().default(1).describe("Context depth (default: 1)")
+});

package/dist/lib/versioning/observation-history.js

@@ -1,17 +1,23 @@
 /**
  * Observation history and versioning service
  */
-import { findEntity, findObservation } from '../utils/entity-finder.js';
 /**
  * Get full history chain for an observation
  * Traces backwards and forwards through the version chain
+ * Filtered by threadId for thread isolation
  */
-export async function getObservationHistory(storage, entityName, observationId) {
+export async function getObservationHistory(storage, threadId, entityName, observationId) {
     const graph = await storage.loadGraph();
-    // Find the entity
-    const entity = findEntity(graph, entityName);
+    // Find the entity - only in the specified thread
+    const entity = graph.entities.find(e => e.name === entityName && e.agentThreadId === threadId);
+    if (!entity) {
+        throw new Error(`Entity '${entityName}' not found in thread '${threadId}'`);
+    }
     // Find the starting observation
-    const startObs = findObservation(entity, observationId);
+    const startObs = entity.observations.find(o => o.id === observationId);
+    if (!startObs) {
+        throw new Error(`Observation '${observationId}' not found in entity '${entityName}'`);
+    }
     // Build the version chain
     const history = [];
     // Trace backwards to find all predecessors

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "server-memory-enhanced",
-  "version": "2.3.2",
+  "version": "3.0.0",
   "description": "Enhanced MCP server for memory with agent threading, timestamps, and confidence scoring",
   "license": "MIT",
   "mcpName": "io.github.modelcontextprotocol/server-memory-enhanced",