@utaba/ucm-mcp-server 6.5.0 → 6.6.0

package/dist/mcp-server/tools/list/ListNamespaceController.js

@@ -0,0 +1,8 @@
+"use strict";
+/*
+ This controller will:
+    call the GET API:
+    http://localhost:3000/api/v1/authors/utaba/commands/user?offset=0&limit=10
+
+*/ 
+//# sourceMappingURL=ListNamespaceController.js.map

package/dist/mcp-server/tools/memory-graph/GraphCreateEntitiesTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphCreateEntitiesParams } from '@/schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphCreateEntitiesTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphCreateEntitiesParams): Promise<string>;
+}
+//# sourceMappingURL=GraphCreateEntitiesTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/GraphCreateEntitiesTool.js

@@ -0,0 +1,58 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphCreateEntitiesSchema } from '@/schemas/memory-graph-tool-schemas.js';
+export class GraphCreateEntitiesTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_create_entities'; }
+    get description() {
+        return 'Create one or more entities in a Memory Graph. Each entity requires a type (from vocabulary) and label. Properties are validated against the vocabulary schema. Pass a single item in the array for single operations.';
+    }
+    get schema() { return GraphCreateEntitiesSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                entities: {
+                    type: 'array',
+                    description: 'Array of entities to create',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            entityType: { type: 'string', description: 'Entity type (must exist in vocabulary)' },
+                            label: { type: 'string', description: 'Human-readable label for the entity' },
+                            summary: { type: 'string', description: 'Brief summary/description' },
+                            properties: { type: 'object', description: 'Entity properties (validated against vocabulary schema)' },
+                            data: { type: ['string', 'object'], description: 'Optional freeform data attached to the entity' }
+                        },
+                        required: ['entityType', 'label']
+                    }
+                }
+            },
+            required: ['memoryGraphId', 'entities']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, entities } = params;
+        this.logger.info('GraphCreateEntitiesTool', `Creating ${entities.length} entities in graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphCreateEntities(memoryGraphId, entities);
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 400) {
+                throw new McpError(McpErrorCode.InvalidParams, error.response.data?.message || 'Validation error');
+            }
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Memory Graph not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to create entities: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphCreateEntitiesTool.js.map

package/dist/mcp-server/tools/memory-graph/GraphCreateRelationshipsTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphCreateRelationshipsParams } from '@/schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphCreateRelationshipsTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphCreateRelationshipsParams): Promise<string>;
+}
+//# sourceMappingURL=GraphCreateRelationshipsTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/GraphCreateRelationshipsTool.js

@@ -0,0 +1,57 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphCreateRelationshipsSchema } from '@/schemas/memory-graph-tool-schemas.js';
+export class GraphCreateRelationshipsTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_create_relationships'; }
+    get description() {
+        return 'Create one or more relationships between entities in a Memory Graph. Each relationship requires a type (from vocabulary), source entity ID, and target entity ID. Pass a single item in the array for single operations.';
+    }
+    get schema() { return GraphCreateRelationshipsSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                relationships: {
+                    type: 'array',
+                    description: 'Array of relationships to create',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            relationshipType: { type: 'string', description: 'Relationship type (must exist in vocabulary)' },
+                            sourceEntityId: { type: 'string', description: 'Source entity ID' },
+                            targetEntityId: { type: 'string', description: 'Target entity ID' },
+                            properties: { type: 'object', description: 'Optional relationship properties' }
+                        },
+                        required: ['relationshipType', 'sourceEntityId', 'targetEntityId']
+                    }
+                }
+            },
+            required: ['memoryGraphId', 'relationships']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, relationships } = params;
+        this.logger.info('GraphCreateRelationshipsTool', `Creating ${relationships.length} relationships in graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphCreateRelationships(memoryGraphId, relationships);
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 400) {
+                throw new McpError(McpErrorCode.InvalidParams, error.response.data?.message || 'Validation error');
+            }
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Entity or Memory Graph not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to create relationships: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphCreateRelationshipsTool.js.map

package/dist/mcp-server/tools/memory-graph/GraphCreateTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphCreateParams } from '@/schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphCreateTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphCreateParams): Promise<string>;
+}
+//# sourceMappingURL=GraphCreateTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/GraphCreateTool.js

@@ -0,0 +1,64 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphCreateSchema } from '@/schemas/memory-graph-tool-schemas.js';
+export class GraphCreateTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_create'; }
+    get description() {
+        return 'Create a new Memory Graph with a vocabulary template. Defaults to a personal graph. Set scope to \'organization\' to create an org-wide graph (requires Owner role). Call ucm_graph_list_templates first to see available templates.';
+    }
+    get schema() { return GraphCreateSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                label: {
+                    type: 'string',
+                    description: 'Display name for the new Memory Graph'
+                },
+                templateId: {
+                    type: 'string',
+                    description: 'Vocabulary template ID to use for the graph. Use ucm_graph_list_templates to see available templates.'
+                },
+                description: {
+                    type: 'string',
+                    description: 'Optional description of the Memory Graph purpose'
+                },
+                scope: {
+                    type: 'string',
+                    enum: ['personal', 'organization'],
+                    description: 'Graph ownership scope. "personal" (default) creates a graph owned by you. "organization" creates an org-wide graph (requires Owner role).'
+                }
+            },
+            required: ['label', 'templateId']
+        };
+    }
+    async handleExecute(params) {
+        const { label, templateId, description, scope } = params;
+        const resolvedScope = scope || 'personal';
+        this.logger.info('GraphCreateTool', `Creating ${resolvedScope} memory graph: ${label}`);
+        try {
+            const result = await this.ucmClient.createMemoryGraph({ label, templateId, description, scope: resolvedScope });
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 400) {
+                const detail = error.response?.data?.message || 'Invalid parameters for graph creation';
+                throw new McpError(McpErrorCode.InvalidParams, detail);
+            }
+            if (error.response?.status === 403) {
+                throw new McpError(McpErrorCode.InvalidParams, 'Creating an organisation graph requires Owner role on the organisation.');
+            }
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Template not found: ${templateId}`);
+            }
+            if (error.response?.status === 503) {
+                throw new McpError(McpErrorCode.InternalError, `Deep Memory service is not configured`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to create memory graph: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphCreateTool.js.map

package/dist/mcp-server/tools/memory-graph/GraphDeleteEntitiesTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphDeleteEntitiesParams } from '@/schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphDeleteEntitiesTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphDeleteEntitiesParams): Promise<string>;
+}
+//# sourceMappingURL=GraphDeleteEntitiesTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/GraphDeleteEntitiesTool.js

@@ -0,0 +1,45 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphDeleteEntitiesSchema } from '@/schemas/memory-graph-tool-schemas.js';
+export class GraphDeleteEntitiesTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_delete_entities'; }
+    get description() {
+        return 'Delete one or more entities from a Memory Graph. Each deleted entity also has its relationships removed. Pass entity IDs as an array.';
+    }
+    get schema() { return GraphDeleteEntitiesSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                entityIds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of entity IDs to delete'
+                }
+            },
+            required: ['memoryGraphId', 'entityIds']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, entityIds } = params;
+        this.logger.info('GraphDeleteEntitiesTool', `Deleting ${entityIds.length} entities from graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphDeleteEntities(memoryGraphId, entityIds);
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Memory Graph not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to delete entities: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphDeleteEntitiesTool.js.map

package/dist/mcp-server/tools/memory-graph/GraphDeleteRelationshipsTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphDeleteRelationshipsParams } from '@/schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphDeleteRelationshipsTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphDeleteRelationshipsParams): Promise<string>;
+}
+//# sourceMappingURL=GraphDeleteRelationshipsTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/GraphDeleteRelationshipsTool.js

@@ -0,0 +1,45 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphDeleteRelationshipsSchema } from '@/schemas/memory-graph-tool-schemas.js';
+export class GraphDeleteRelationshipsTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_delete_relationships'; }
+    get description() {
+        return 'Delete one or more relationships from a Memory Graph by their IDs. Pass relationship IDs as an array.';
+    }
+    get schema() { return GraphDeleteRelationshipsSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                relationshipIds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of relationship IDs to delete'
+                }
+            },
+            required: ['memoryGraphId', 'relationshipIds']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, relationshipIds } = params;
+        this.logger.info('GraphDeleteRelationshipsTool', `Deleting ${relationshipIds.length} relationships from graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphDeleteRelationships(memoryGraphId, relationshipIds);
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Memory Graph not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to delete relationships: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphDeleteRelationshipsTool.js.map

package/dist/mcp-server/tools/memory-graph/GraphExploreTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphExploreParams } from '@/schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphExploreTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphExploreParams): Promise<string>;
+}
+//# sourceMappingURL=GraphExploreTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/GraphExploreTool.js

@@ -0,0 +1,73 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphExploreSchema } from '@/schemas/memory-graph-tool-schemas.js';
+export class GraphExploreTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_explore'; }
+    get description() {
+        return 'Explore the neighbourhood around an entity using BFS traversal (1-3 hops). Returns connected entities grouped by distance, with optional relationship/entity type filters.';
+    }
+    get schema() { return GraphExploreSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                entityId: {
+                    type: 'string',
+                    description: 'Starting entity ID for exploration'
+                },
+                depth: {
+                    type: 'number',
+                    description: 'Exploration depth: 1, 2, or 3 hops (default: 1)'
+                },
+                relationshipTypes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter by relationship types'
+                },
+                entityTypes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter by entity types'
+                },
+                direction: {
+                    type: 'string',
+                    enum: ['outbound', 'inbound', 'both'],
+                    description: 'Traversal direction (default: both)'
+                },
+                limitPerType: {
+                    type: 'number',
+                    description: 'Maximum results per relationship type (default: 10)'
+                }
+            },
+            required: ['memoryGraphId', 'entityId']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, entityId, depth, relationshipTypes, entityTypes, direction, limitPerType } = params;
+        this.logger.info('GraphExploreTool', `Exploring from entity ${entityId} in graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphExplore(memoryGraphId, {
+                entityId,
+                maxDepth: depth,
+                relationshipTypes,
+                entityTypes,
+                limit: limitPerType
+            });
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Entity or Memory Graph not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to explore neighbourhood: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphExploreTool.js.map

package/dist/mcp-server/tools/memory-graph/GraphFindEntitiesTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphFindEntitiesParams } from '@/schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphFindEntitiesTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphFindEntitiesParams): Promise<string>;
+}
+//# sourceMappingURL=GraphFindEntitiesTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/GraphFindEntitiesTool.js

@@ -0,0 +1,68 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphFindEntitiesSchema } from '@/schemas/memory-graph-tool-schemas.js';
+export class GraphFindEntitiesTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_find_entities'; }
+    get description() {
+        return 'Find entities in a Memory Graph by label, type, or property filters. Supports pagination and detail levels (brief/summary/full).';
+    }
+    get schema() { return GraphFindEntitiesSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                searchTerm: {
+                    type: 'string',
+                    description: 'Search term to match against entity labels (partial match)'
+                },
+                entityTypes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter by entity types (from vocabulary)'
+                },
+                detailLevel: {
+                    type: 'string',
+                    enum: ['brief', 'summary', 'full'],
+                    description: 'Detail level for returned entities (default: summary)'
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum results to return (default: 20, max: 100)'
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Pagination offset (default: 0)'
+                }
+            },
+            required: ['memoryGraphId']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, searchTerm, entityTypes, detailLevel, limit, offset } = params;
+        this.logger.info('GraphFindEntitiesTool', `Finding entities in graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphFindEntities(memoryGraphId, {
+                entityTypes,
+                searchTerm,
+                detailLevel,
+                offset,
+                limit
+            });
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Memory Graph not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to find entities: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphFindEntitiesTool.js.map

package/dist/mcp-server/tools/memory-graph/GraphFindPathsTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphFindPathsParams } from '@/schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphFindPathsTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphFindPathsParams): Promise<string>;
+}
+//# sourceMappingURL=GraphFindPathsTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/GraphFindPathsTool.js

@@ -0,0 +1,62 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphFindPathsSchema } from '@/schemas/memory-graph-tool-schemas.js';
+export class GraphFindPathsTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_find_paths'; }
+    get description() {
+        return 'Find paths between two entities in a Memory Graph. Returns all paths up to the specified max depth with optional relationship/entity type filtering.';
+    }
+    get schema() { return GraphFindPathsSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                sourceEntityId: {
+                    type: 'string',
+                    description: 'Starting entity ID'
+                },
+                targetEntityId: {
+                    type: 'string',
+                    description: 'Target entity ID'
+                },
+                maxDepth: {
+                    type: 'number',
+                    description: 'Maximum path depth (3-5, default: 3)'
+                },
+                relationshipTypes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter by relationship types'
+                }
+            },
+            required: ['memoryGraphId', 'sourceEntityId', 'targetEntityId']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, sourceEntityId, targetEntityId, maxDepth, relationshipTypes } = params;
+        this.logger.info('GraphFindPathsTool', `Finding paths in graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphFindPaths(memoryGraphId, {
+                sourceEntityId,
+                targetEntityId,
+                maxDepth,
+                relationshipTypes
+            });
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Entity or Memory Graph not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to find paths: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphFindPathsTool.js.map

package/dist/mcp-server/tools/memory-graph/GraphGetEntityTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphGetEntityParams } from '@/schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphGetEntityTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphGetEntityParams): Promise<string>;
+}
+//# sourceMappingURL=GraphGetEntityTool.d.ts.map