@utaba/ucm-mcp-server 6.5.0 → 6.6.0

package/dist/schemas/memory-graph-tool-schemas.js

@@ -0,0 +1,181 @@
+/**
+ * Shared Zod schemas for all Memory Graph and Knowledge Set MCP tools.
+ *
+ * Used by three MCP servers (Local, Remote, Agent) for runtime validation.
+ * Each schema defines the tool input shape (what the AI sends).
+ */
+import { z } from 'zod';
+// ─── Common Fragments ───────────────────────────────────────────────
+const memoryGraphId = z.string().describe('The Memory Graph ID');
+const entityId = z.string().describe('The entity ID');
+const detailLevel = z.enum(['brief', 'summary', 'full']);
+const direction = z.enum(['outbound', 'inbound', 'both']);
+const traversalDirection = z.enum(['out', 'in', 'both']);
+const returnMode = z.enum(['terminal', 'all', 'paths']);
+const graphScope = z.enum(['organization', 'personal', 'all']);
+const createScope = z.enum(['personal', 'organization']);
+const entityInput = z.object({
+    entityType: z.string().describe('Entity type (must exist in vocabulary)'),
+    label: z.string().describe('Human-readable label'),
+    summary: z.string().optional().describe('Brief summary/description'),
+    properties: z.record(z.unknown()).optional().describe('Entity properties (validated against vocabulary schema)'),
+    data: z.union([z.string(), z.record(z.unknown())]).optional().describe('Optional freeform data'),
+});
+const entityUpdateInput = z.object({
+    entityId: z.string().describe('The entity ID to update'),
+    label: z.string().optional().describe('New label'),
+    summary: z.string().optional().describe('New summary'),
+    properties: z.record(z.unknown()).optional().describe('Properties to update (merged with existing)'),
+    data: z.record(z.unknown()).optional().describe('Data to update (merged with existing)'),
+});
+const relationshipInput = z.object({
+    relationshipType: z.string().describe('Relationship type (must exist in vocabulary)'),
+    sourceEntityId: z.string().describe('Source entity ID'),
+    targetEntityId: z.string().describe('Target entity ID'),
+    properties: z.record(z.unknown()).optional().describe('Optional relationship properties'),
+});
+const propertyFilter = z.object({
+    key: z.string(),
+    operator: z.string().describe('eq, neq, gt, gte, lt, lte, contains, isNull, isNotNull'),
+    value: z.unknown().optional(),
+});
+const traversalStart = z.object({
+    entityId: z.string().optional().describe('Start from specific entity'),
+    entityType: z.string().optional().describe('Start from all entities of this type'),
+    filter: z.array(propertyFilter).optional().describe('Property filters on start entities'),
+}).passthrough();
+const traversalStep = z.object({
+    direction: traversalDirection.optional().describe('Hop direction'),
+    relationshipTypes: z.array(z.string()).optional().describe('Filter by relationship types'),
+    entityTypes: z.array(z.string()).optional().describe('Filter by entity types at this step'),
+    filter: z.array(propertyFilter).optional().describe('Property filters on entities at this step'),
+    repeat: z.object({
+        min: z.number().optional(),
+        max: z.number().optional(),
+    }).optional().describe('Repeat this step min to max times'),
+}).passthrough();
+const entityTypeProposal = z.object({
+    type: z.string().describe('Entity type name (PascalCase, singular)'),
+    description: z.string().describe('What this entity type represents'),
+    justification: z.string().describe('Why this entity type is needed'),
+    properties: z.array(z.object({
+        name: z.string().describe('Property name (camelCase)'),
+        type: z.enum(['string', 'number', 'boolean', 'date']).describe('Property data type'),
+        required: z.boolean().optional().describe('Whether the property is required'),
+        description: z.string().describe('What this property captures'),
+        embeddable: z.boolean().optional().describe('Include in embedding text for semantic search'),
+    })).optional().describe('Property definitions'),
+}).passthrough();
+const relationshipTypeProposal = z.object({
+    type: z.string().describe('Relationship type name (UPPER_SNAKE_CASE)'),
+    description: z.string().describe('What this relationship means'),
+    justification: z.string().describe('Why this relationship type is needed'),
+    allowedSourceTypes: z.array(z.string()).describe('Entity types that can be the source'),
+    allowedTargetTypes: z.array(z.string()).describe('Entity types that can be the target'),
+    bidirectional: z.boolean().optional().describe('Whether the relationship is bidirectional'),
+    properties: z.array(z.object({
+        name: z.string(),
+        type: z.enum(['string', 'number', 'boolean', 'date']),
+        required: z.boolean().optional(),
+        description: z.string(),
+    })).optional().describe('Relationship property definitions'),
+}).passthrough();
+// ─── Discovery Tool Schemas ─────────────────────────────────────────
+export const GraphListSchema = z.object({
+    scope: graphScope.optional().describe('Filter by ownership scope (default: all)'),
+});
+export const GraphListTemplatesSchema = z.object({});
+export const KnowledgeSetListSchema = z.object({});
+export const KnowledgeSetOpenSchema = z.object({
+    knowledgeSetId: z.string().describe('The Knowledge Set ID to open'),
+});
+// ─── Graph Lifecycle Schemas ────────────────────────────────────────
+export const GraphCreateSchema = z.object({
+    label: z.string().describe('Display name for the new Memory Graph'),
+    templateId: z.string().describe('Vocabulary template ID — call ucm_graph_list_templates first'),
+    description: z.string().optional().describe('What this graph is for'),
+    scope: createScope.optional().describe('personal (default) or organization (requires Owner role)'),
+});
+export const GraphOpenSchema = z.object({
+    memoryGraphId,
+});
+// ─── Read Tool Schemas ──────────────────────────────────────────────
+export const GraphFindEntitiesSchema = z.object({
+    memoryGraphId,
+    searchTerm: z.string().optional().describe('Search term to match against entity labels'),
+    entityTypes: z.array(z.string()).optional().describe('Filter by entity types'),
+    detailLevel: detailLevel.optional().describe('Detail level (default: summary)'),
+    limit: z.number().optional().describe('Maximum results (default: 20, max: 100)'),
+    offset: z.number().optional().describe('Pagination offset (default: 0)'),
+});
+export const GraphGetEntitySchema = z.object({
+    memoryGraphId,
+    entityId,
+    detailLevel: detailLevel.optional().describe('Detail level (default: full)'),
+});
+export const GraphGetRelationshipsSchema = z.object({
+    memoryGraphId,
+    entityId,
+    relationshipTypes: z.array(z.string()).optional().describe('Filter by relationship types'),
+    direction: direction.optional().describe('Direction (default: both)'),
+    limit: z.number().optional().describe('Maximum results (default: 50)'),
+});
+export const GraphExploreSchema = z.object({
+    memoryGraphId,
+    entityId: z.string().describe('Starting entity ID'),
+    depth: z.number().optional().describe('Exploration depth: 1, 2, or 3 (default: 1)'),
+    relationshipTypes: z.array(z.string()).optional().describe('Filter by relationship types'),
+    entityTypes: z.array(z.string()).optional().describe('Filter by entity types'),
+    direction: direction.optional().describe('Direction (default: both)'),
+    limitPerType: z.number().optional().describe('Max results per type (default: 10)'),
+});
+export const GraphFindPathsSchema = z.object({
+    memoryGraphId,
+    sourceEntityId: z.string().describe('Starting entity ID'),
+    targetEntityId: z.string().describe('Target entity ID'),
+    maxDepth: z.number().optional().describe('Maximum path depth (default: 3, max: 5)'),
+    relationshipTypes: z.array(z.string()).optional().describe('Filter by relationship types'),
+});
+export const GraphTraverseSchema = z.object({
+    memoryGraphId,
+    start: traversalStart.describe('Start point specification'),
+    steps: z.array(traversalStep).describe('Ordered traversal steps (hops)'),
+    returnMode: returnMode.optional().describe('Return mode (default: terminal)'),
+    limit: z.number().optional().describe('Max results (default: 50)'),
+    detailLevel: detailLevel.optional().describe('Detail level (default: summary)'),
+});
+export const GraphSearchSchema = z.object({
+    memoryGraphId: z.string().optional().describe('Search a single graph (backwards compatible)'),
+    graphIds: z.array(z.string()).optional().describe('Search multiple graphs. Omit to search all accessible.'),
+    query: z.string().describe('Natural language search query'),
+    entityTypes: z.array(z.string()).optional().describe('Filter by entity types'),
+    limit: z.number().optional().describe('Per-graph result limit'),
+    similarityThreshold: z.number().optional().describe('Minimum similarity score (0-1)'),
+});
+// ─── Write Tool Schemas ─────────────────────────────────────────────
+export const GraphCreateEntitiesSchema = z.object({
+    memoryGraphId,
+    entities: z.array(entityInput).min(1).describe('Array of entities to create'),
+});
+export const GraphUpdateEntitiesSchema = z.object({
+    memoryGraphId,
+    updates: z.array(entityUpdateInput).min(1).describe('Array of entity updates'),
+});
+export const GraphDeleteEntitiesSchema = z.object({
+    memoryGraphId,
+    entityIds: z.array(z.string()).min(1).describe('Array of entity IDs to delete'),
+});
+export const GraphCreateRelationshipsSchema = z.object({
+    memoryGraphId,
+    relationships: z.array(relationshipInput).min(1).describe('Array of relationships to create'),
+});
+export const GraphDeleteRelationshipsSchema = z.object({
+    memoryGraphId,
+    relationshipIds: z.array(z.string()).min(1).describe('Array of relationship IDs to delete'),
+});
+export const GraphProposeVocabularySchema = z.object({
+    memoryGraphId,
+    entityTypes: z.array(entityTypeProposal).optional().describe('Entity type proposals'),
+    relationshipTypes: z.array(relationshipTypeProposal).optional().describe('Relationship type proposals'),
+});
+//# sourceMappingURL=memory-graph-tool-schemas.js.map

package/dist/server/ToolRegistry.js

@@ -1,11 +1,9 @@
 import { McpError, McpErrorCode } from '../utils/McpErrorHandler.js';
 // Import utility tools
-// import { HealthCheckController } from '../tools/utility/HealthCheckController.js'; // commented out — use ucm_connect instead
 import { QuickstartTool } from '../tools/utility/QuickstartTool.js';
 import { AuthorIndexTool } from '../tools/utility/AuthorIndexTool.js';
 import { AuthorRecentsTool } from '../tools/utility/AuthorRecentsTool.js';
 import { ListRepositoriesTool } from '../tools/utility/ListRepositoriesTool.js';
-// import { SubmitFeedbackTool } from '../tools/utility/SubmitFeedbackTool.js'; // removed — tool disabled
 // Import core tools
 import { GetArtifactTool } from '../tools/core/GetArtifactTool.js';
 import { GetChunkTool } from '../tools/core/GetChunkTool.js';
@@ -21,10 +19,9 @@ import { MoveArtifactTool } from '../tools/core/MoveArtifactTool.js';
 import { CreateRepositoryTool } from '../tools/repository/CreateRepositoryTool.js';
 import { GetRepositoryTool } from '../tools/repository/GetRepositoryTool.js';
 import { UpdateRepositoryTool } from '../tools/repository/UpdateRepositoryTool.js';
-import { DeleteRepositoryGuidanceTool } from '../tools/repository/DeleteRepositoryGuidanceTool.js';
 // Import connection/SharePoint tools
 import { ListConnectionsTool } from '../tools/sharepoint/SharePointListConnectionsTool.js';
-// DEPRECATED: Legacy SharePoint tools - use ucm_call_remote_tool via unified gateway instead
+// DEPRECATED: Legacy SharePoint tools - use ucm_connection_call_tool via unified gateway instead
 // Commented out 2026-02-13 - pending confirmation that unified gateway works correctly
 // import { SharePointSearchTool } from '../tools/sharepoint/SharePointSearchTool.js';
 // import { SharePointListFoldersTool } from '../tools/sharepoint/SharePointListFoldersTool.js';
@@ -36,6 +33,26 @@ import { ListAuthorizationsTool } from '../tools/authorization/ListAuthorization
 // Import connection tools
 import { AccessConnectionTool } from '../tools/connections/AccessConnectionTool.js';
 import { CallRemoteToolTool } from '../tools/connections/CallRemoteToolTool.js';
+// Import memory graph tools
+import { GraphListTool } from '../tools/memory-graph/GraphListTool.js';
+import { GraphCreateTool } from '../tools/memory-graph/GraphCreateTool.js';
+import { GraphListTemplatesTool } from '../tools/memory-graph/GraphListTemplatesTool.js';
+import { KnowledgeSetListTool } from '../tools/memory-graph/KnowledgeSetListTool.js';
+import { KnowledgeSetOpenTool } from '../tools/memory-graph/KnowledgeSetOpenTool.js';
+import { GraphOpenTool } from '../tools/memory-graph/GraphOpenTool.js';
+import { GraphFindEntitiesTool } from '../tools/memory-graph/GraphFindEntitiesTool.js';
+import { GraphGetEntityTool } from '../tools/memory-graph/GraphGetEntityTool.js';
+import { GraphGetRelationshipsTool } from '../tools/memory-graph/GraphGetRelationshipsTool.js';
+import { GraphExploreTool } from '../tools/memory-graph/GraphExploreTool.js';
+import { GraphFindPathsTool } from '../tools/memory-graph/GraphFindPathsTool.js';
+import { GraphTraverseTool } from '../tools/memory-graph/GraphTraverseTool.js';
+import { GraphSearchTool } from '../tools/memory-graph/GraphSearchTool.js';
+import { GraphCreateEntitiesTool } from '../tools/memory-graph/GraphCreateEntitiesTool.js';
+import { GraphUpdateEntitiesTool } from '../tools/memory-graph/GraphUpdateEntitiesTool.js';
+import { GraphDeleteEntitiesTool } from '../tools/memory-graph/GraphDeleteEntitiesTool.js';
+import { GraphCreateRelationshipsTool } from '../tools/memory-graph/GraphCreateRelationshipsTool.js';
+import { GraphDeleteRelationshipsTool } from '../tools/memory-graph/GraphDeleteRelationshipsTool.js';
+import { GraphProposeVocabularyTool } from '../tools/memory-graph/GraphProposeVocabularyTool.js';
 export class ToolRegistry {
     ucmClient;
     logger;
@@ -54,11 +71,9 @@ export class ToolRegistry {
     registerTools() {
         // Register utility tools
         this.registerTool(new QuickstartTool(this.ucmClient, this.logger, this.authorId));
-        // this.registerTool(new HealthCheckController(this.ucmClient, this.logger, this.authorId)); // commented out — use ucm_connect instead
         this.registerTool(new AuthorIndexTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new AuthorRecentsTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new ListRepositoriesTool(this.ucmClient, this.logger, this.authorId));
-        // this.registerTool(new SubmitFeedbackTool(this.ucmClient, this.logger, this.authorId)); // removed — tool disabled
         // Register core tools
         this.registerTool(new GetArtifactTool(this.ucmClient, this.logger, this.authorId, this.trustedAuthors));
         this.registerTool(new GetChunkTool(this.ucmClient, this.logger, this.authorId));
@@ -74,10 +89,9 @@ export class ToolRegistry {
         this.registerTool(new CreateRepositoryTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new GetRepositoryTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new UpdateRepositoryTool(this.ucmClient, this.logger, this.authorId));
-        this.registerTool(new DeleteRepositoryGuidanceTool(this.ucmClient, this.logger, this.authorId, this.baseUrl));
         // Register connection tools (ListConnectionsTool is unified - lists all connection types)
         this.registerTool(new ListConnectionsTool(this.ucmClient, this.logger, this.authorId));
-        // DEPRECATED: Legacy SharePoint tools - use ucm_call_remote_tool via unified gateway instead
+        // DEPRECATED: Legacy SharePoint tools - use ucm_connection_call_tool via unified gateway instead
         // Commented out 2026-02-13 - pending confirmation that unified gateway works correctly
         // this.registerTool(new SharePointSearchTool(this.ucmClient, this.logger, this.authorId));
         // this.registerTool(new SharePointListFoldersTool(this.ucmClient, this.logger, this.authorId));
@@ -89,6 +103,26 @@ export class ToolRegistry {
         // Register unified authorization tools
         this.registerTool(new SignOutTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new ListAuthorizationsTool(this.ucmClient, this.logger, this.authorId));
+        // Register memory graph tools
+        this.registerTool(new GraphListTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphCreateTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphListTemplatesTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new KnowledgeSetListTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new KnowledgeSetOpenTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphOpenTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphFindEntitiesTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphGetEntityTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphGetRelationshipsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphExploreTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphFindPathsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphTraverseTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphSearchTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphCreateEntitiesTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphUpdateEntitiesTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphDeleteEntitiesTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphCreateRelationshipsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphDeleteRelationshipsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphProposeVocabularyTool(this.ucmClient, this.logger, this.authorId));
         this.logger.info('ToolRegistry', `Registered ${this.tools.size} MCP tools`);
     }
     registerTool(tool) {

package/dist/tools/authorization/ListAuthorizationsTool.js

@@ -8,7 +8,7 @@ export class ListAuthorizationsTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_list_authorizations';
+        return 'ucm_connection_list_auth';
     }
     get description() {
         return 'List all your active OAuth authorizations across connection types. Shows which services you are currently authorized to access, with expiry info and connection details.';
@@ -138,7 +138,7 @@ export class ListAuthorizationsTool extends BaseToolController {
                 }
             }
             lines.push('\n## Actions\n');
-            lines.push('To revoke an authorization, use: `ucm_signout` with connectionType and connectionId');
+            lines.push('To revoke an authorization, use: `ucm_connection_signout` with connectionType and connectionId');
         }
         return lines.join('\n');
     }

package/dist/tools/authorization/SignOutTool.js

@@ -9,7 +9,7 @@ export class SignOutTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_signout';
+        return 'ucm_connection_signout';
     }
     get description() {
         return 'Sign out from an OAuth-authorized connection. Revokes user-delegated permissions by deleting access tokens. Works for SharePoint OnBehalfOf connections and Remote MCP Servers with user-delegated OAuth.';
@@ -25,7 +25,7 @@ export class SignOutTool extends BaseToolController {
                 },
                 connectionId: {
                     type: 'string',
-                    description: 'Connection ID to revoke authorization for (get from ucm_list_authorizations or ucm_list_connections)',
+                    description: 'Connection ID to revoke authorization for (get from ucm_connection_list_auth or ucm_connection_list)',
                     minLength: 36,
                     maxLength: 36
                 }

package/dist/tools/connections/AccessConnectionTool.js

@@ -11,10 +11,10 @@ export class AccessConnectionTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_access_connection';
+        return 'ucm_connection_access';
     }
     get description() {
-        return 'Access a specific external connection, check auth status, and return available tool schemas. Call without toolNames to get a summary index of all available tools. Pass toolNames to retrieve full parameter schemas. If any tool name in toolNames is not recognised, the full catalogue is returned for all tools — use this to identify the correct name.';
+        return 'Access a specific external connection, check auth status, and return available tool schemas. Call without toolNames to get a summary index of all available tools. Pass toolNames to retrieve full parameter schemas.';
     }
     get inputSchema() {
         return {
@@ -22,7 +22,7 @@ export class AccessConnectionTool extends BaseToolController {
             properties: {
                 connectionId: {
                     type: 'string',
-                    description: 'Connection ID (SharePoint connection or Remote MCP Server) from ucm_list_connections',
+                    description: 'Connection ID (SharePoint connection or Remote MCP Server) from ucm_connection_list',
                     minLength: 36,
                     maxLength: 36
                 },
@@ -66,14 +66,16 @@ export class AccessConnectionTool extends BaseToolController {
             if (result.markdown) {
                 return result.markdown;
             }
-            // toolNames mode — return compact JSON with filtered tools
-            return JSON.stringify({
+            // Tools mode — return compact JSON with schemas
+            const json = {
                 connectionId: result.connectionId,
                 connectionName: result.connectionName,
                 instructions: result.instructions,
                 policies: result.policies,
+                ...(result.error && { error: result.error }),
                 tools: result.tools
-            });
+            };
+            return JSON.stringify(json);
         }
         catch (error) {
             // Sanitize error for logging

package/dist/tools/connections/CallRemoteToolTool.js

@@ -11,10 +11,10 @@ export class CallRemoteToolTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_call_remote_tool';
+        return 'ucm_connection_call_tool';
     }
     get description() {
-        return 'Call a tool on an external connection. If the tool name is invalid, the response will include the full tool catalogue so you can identify the correct tool and retry immediately. If the parameters are invalid, the response will include the correct schema — retry using that schema directly. No additional discovery calls are needed to recover from errors.';
+        return 'Call a tool on an external connection.';
     }
     get inputSchema() {
         return {
@@ -22,13 +22,13 @@ export class CallRemoteToolTool extends BaseToolController {
             properties: {
                 connectionId: {
                     type: 'string',
-                    description: 'Connection ID (SharePoint connection or Remote MCP Server) from ucm_list_connections',
+                    description: 'Connection ID (SharePoint connection or Remote MCP Server) from ucm_connection_list',
                     minLength: 36,
                     maxLength: 36
                 },
                 toolName: {
                     type: 'string',
-                    description: 'Name of the tool to call (see ucm_access_connection for available tools)',
+                    description: 'Name of the tool to call (see ucm_connection_access for available tools)',
                     minLength: 1
                 },
                 args: {

package/dist/tools/core/DeleteArtifactTool.js

@@ -4,7 +4,7 @@ export class DeleteArtifactTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_delete_artifact';
+        return 'ucm_artifact_delete';
     }
     get description() {
         return 'Delete a UCM artifact by path and version. This action cannot be undone. Only the latest or specified version is deleted.';
@@ -13,7 +13,7 @@ export class DeleteArtifactTool extends BaseToolController {
         return {
             type: 'object',
             properties: {
-                author: {
+                workspace: {
                     type: 'string',
                     description: `Author name (e.g., ${this.publishingAuthorId || '01234567890'})`,
                     minLength: 1,
@@ -44,11 +44,12 @@ export class DeleteArtifactTool extends BaseToolController {
                     maxLength: 150
                 }
             },
-            required: ['author', 'repository', 'category', 'subcategory', 'filename']
+            required: ['workspace', 'repository', 'category', 'subcategory', 'filename']
         };
     }
     async handleExecute(params) {
-        const { author, repository, category, subcategory, filename } = params;
+        const { workspace, repository, category, subcategory, filename } = params;
+        const author = workspace;
         this.logger.debug('DeleteArtifactTool', `Deleting artifact: ${author}/${repository}/${category}/${subcategory}/${filename}`);
         try {
             // Parse filename to extract version if present

package/dist/tools/core/EditArtifactMetadataTool.js

@@ -6,7 +6,7 @@ export class EditArtifactMetadataTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_edit_artifact_metadata';
+        return 'ucm_artifact_edit_metadata';
     }
     get description() {
         return 'Edit artifact metadata and move artifacts. Supports updating description, namespace, filename, MIME type, technology, and tags. Move operations affect all versions while metadata-only updates apply to latest version only.';

package/dist/tools/core/GetArtifactTool.js

@@ -8,7 +8,7 @@ export class GetArtifactTool extends BaseToolController {
         this.trustedAuthors = trustedAuthors;
     }
     get name() {
-        return 'ucm_get_artifact';
+        return 'ucm_artifact_get';
     }
     get description() {
         return 'Retrieve UCM artifact content with metadata. Large files are automatically chunked.';

package/dist/tools/core/GetArtifactVersionsTool.js

@@ -5,7 +5,7 @@ export class GetArtifactVersionsTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_get_artifact_versions';
+        return 'ucm_artifact_get_versions';
     }
     get description() {
         return 'Get all available versions of a specific UCM artifact';

package/dist/tools/core/GetChunkTool.js

@@ -6,7 +6,7 @@ export class GetChunkTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_get_chunk';
+        return 'ucm_artifact_get_chunk';
     }
     get description() {
         return 'Retrieve the next chunk of a large UCM artifact response';

package/dist/tools/core/ListArtifactsTool.js

@@ -5,7 +5,7 @@ export class ListArtifactsTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_list_artifacts';
+        return 'ucm_artifact_list';
     }
     get description() {
         return `List artifacts with exploratory browsing support. Can list authors, repositories, categories, subcategories, or artifacts depending on path depth. ${this.publishingAuthorId ? "Your author value is '" + this.publishingAuthorId + "'" : ''}`;

package/dist/tools/core/MoveArtifactTool.js

@@ -6,7 +6,7 @@ export class MoveArtifactTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_move_artifact';
+        return 'ucm_artifact_move';
     }
     get description() {
         return 'Move an artifact from one namespace location to another. All versions are moved. Requires read access on source and write access on destination.';

package/dist/tools/core/PublishArtifactFromFileTool.js

@@ -8,7 +8,7 @@ export class PublishArtifactFromFileTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_publish_artifact_fromfile';
+        return 'ucm_artifact_publish_from_file';
     }
     get description() {
         return 'Create or update UCM artifacts from a file URI. Supports versioning. PREFERRED METHOD: Use this tool for file-based content as it is much faster and more efficient. Pass the local file path as a file:// URI (e.g., "file:///path/to/file.txt").';

package/dist/tools/core/PublishArtifactTool.js

@@ -6,10 +6,10 @@ export class PublishArtifactTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_publish_artifact';
+        return 'ucm_artifact_publish';
     }
     get description() {
-        return 'Create or update UCM artifacts with content and metadata. Supports versioning and automatic conflict detection. The API automatically detects whether to create or update based on existing artifacts. NOTE: Only use this tool for small data - use ucm_publish_artifact_fromfile for files as it is much faster and more efficient.';
+        return 'Create or update UCM artifacts with content and metadata. Supports versioning and automatic conflict detection. The API automatically detects whether to create or update based on existing artifacts. NOTE: Only use this tool for small data - use ucm_artifact_publish_from_file for files as it is much faster and more efficient.';
     }
     get inputSchema() {
         return {

package/dist/tools/core/SearchArtifactsTool.js

@@ -4,10 +4,10 @@ export class SearchArtifactsTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_search_artifacts';
+        return 'ucm_artifact_search';
     }
     get description() {
-        return `Search artifacts by text across multiple metadata fields with privacy filtering. Searches namespace, filename, description, and tags fields. ${this.publishingAuthorId ? "Your author value is '" + this.publishingAuthorId + "'" : ''}`;
+        return `Search your workspaces by text across multiple metadata fields. Searches namespace, filename, description, and tags fields. ${this.publishingAuthorId ? "Your workspace value is '" + this.publishingAuthorId + "'" : ''}`;
     }
     get inputSchema() {
         return {
@@ -21,12 +21,12 @@ export class SearchArtifactsTool extends BaseToolController {
                 },
                 namespace: {
                     type: 'string',
-                    description: 'Optional namespace filter (e.g., "utaba/main/commands/user")',
+                    description: 'Optional namespace filter (e.g., "main/commands/user")',
                     maxLength: 200
                 },
-                author: {
+                workspace: {
                     type: 'string',
-                    description: `Optional.  Leave empty to search your own author and public authors.  '(e.g., "' + this.publishingAuthorId + '")' : ''}`,
+                    description: `Optional workspace filter. Leave empty to search your workspaces. ${this.publishingAuthorId ? '(e.g., "' + this.publishingAuthorId + '")' : ''}`,
                     maxLength: 50
                 },
                 repository: {
@@ -70,7 +70,8 @@ export class SearchArtifactsTool extends BaseToolController {
         };
     }
     async handleExecute(params) {
-        const { searchText, namespace, author, repository, category, subcategory, filename, tags, offset, limit } = params;
+        const { searchText, namespace, workspace, repository, category, subcategory, filename, tags, offset, limit } = params;
+        const author = workspace;
         this.logger.debug('SearchArtifactsTool', `Searching with filters`, '', {
             searchText,
             namespace,

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

@@ -0,0 +1,11 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+export declare class GraphCreateEntitiesTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get inputSchema(): any;
+    protected handleExecute(params: any): Promise<any>;
+}
+//# sourceMappingURL=GraphCreateEntitiesTool.d.ts.map

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

@@ -0,0 +1,56 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.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 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/tools/memory-graph/GraphCreateRelationshipsTool.d.ts

@@ -0,0 +1,11 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+export declare class GraphCreateRelationshipsTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get inputSchema(): any;
+    protected handleExecute(params: any): Promise<any>;
+}
+//# sourceMappingURL=GraphCreateRelationshipsTool.d.ts.map