@utaba/ucm-mcp-server 6.5.1 → 6.6.0

package/dist/clients/UcmLocalApiClient.d.ts

@@ -3,9 +3,8 @@ export declare class UcmLocalApiClient {
     private baseUrl;
     private authToken?;
     private authorId?;
-    private organizationId?;
     private client;
-    constructor(baseUrl: string, authToken?: string | undefined, timeout?: number, authorId?: string | undefined, organizationId?: string | undefined);
+    constructor(baseUrl: string, authToken?: string | undefined, timeout?: number, authorId?: string | undefined);
     private setupInterceptors;
     private ensureClient;
     getAuthors(): Promise<AuthorData[]>;
@@ -223,5 +222,178 @@ export declare class UcmLocalApiClient {
      * @param connectionType - Optional filter: 'sharepoint' | 'remote-mcp' | 'all' (default: 'all')
      */
     listAuthorizations(connectionType?: string): Promise<any>;
+    /**
+     * List memory graphs, optionally filtered by scope
+     * @param scope - 'organization' | 'personal' | 'all' (default: 'all')
+     */
+    listMemoryGraphs(scope?: string): Promise<any>;
+    /**
+     * Create a new Memory Graph for the authenticated user
+     */
+    createMemoryGraph(data: {
+        label: string;
+        templateId: string;
+        description?: string;
+        scope?: string;
+    }): Promise<any>;
+    /**
+     * List available vocabulary templates for Memory Graph creation
+     */
+    listMemoryGraphTemplates(): Promise<any>;
+    /**
+     * Semantic vector search across multiple Memory Graphs
+     */
+    graphSearchMultiple(query: string, options?: {
+        graphIds?: string[];
+        entityTypes?: string[];
+        limit?: number;
+        similarityThreshold?: number;
+    }): Promise<any>;
+    /**
+     * List knowledge sets for an organization
+     */
+    listKnowledgeSets(): Promise<any>;
+    /**
+     * List knowledge set summary (markdown) for an organization
+     */
+    listKnowledgeSetSummary(): Promise<string>;
+    /**
+     * Open a knowledge set — returns markdown summary with contents and tool guidance
+     */
+    openKnowledgeSet(knowledgeSetId: string): Promise<string>;
+    /**
+     * Open a memory graph — returns vocabulary, stats, instructions, policies, and metadata
+     */
+    graphOpen(graphId: string): Promise<any>;
+    /**
+     * Find entities with filters and pagination
+     */
+    graphFindEntities(graphId: string, query: {
+        entityTypes?: string[];
+        searchTerm?: string;
+        detailLevel?: string;
+        offset?: number;
+        limit?: number;
+    }): Promise<any>;
+    /**
+     * Get a single entity by ID
+     */
+    graphGetEntity(graphId: string, entityId: string, detailLevel?: string): Promise<any>;
+    /**
+     * Get relationships for an entity
+     */
+    graphGetRelationships(graphId: string, entityId: string, options?: {
+        direction?: string;
+        relationshipTypes?: string[];
+        limit?: number;
+    }): Promise<any>;
+    /**
+     * Explore neighbourhood around an entity (BFS, 1-3 hops)
+     */
+    graphExplore(graphId: string, options: {
+        entityId: string;
+        maxDepth?: number;
+        relationshipTypes?: string[];
+        entityTypes?: string[];
+        limit?: number;
+    }): Promise<any>;
+    /**
+     * Find paths between two entities
+     */
+    graphFindPaths(graphId: string, options: {
+        sourceEntityId: string;
+        targetEntityId: string;
+        maxDepth?: number;
+        relationshipTypes?: string[];
+    }): Promise<any>;
+    /**
+     * Structured graph traversal with a JSON spec
+     */
+    graphTraverse(graphId: string, spec: {
+        start: Record<string, any>;
+        steps: Array<Record<string, any>>;
+        returnMode?: string;
+        limit?: number;
+        detailLevel?: string;
+    }): Promise<any>;
+    /**
+     * Semantic vector search on entity embeddings
+     */
+    graphSearch(graphId: string, query: string, options?: {
+        entityTypes?: string[];
+        limit?: number;
+        similarityThreshold?: number;
+    }): Promise<any>;
+    /**
+     * Create one or more entities
+     */
+    graphCreateEntities(graphId: string, entities: Array<{
+        entityType: string;
+        label: string;
+        summary?: string;
+        properties?: Record<string, unknown>;
+        data?: unknown;
+    }>): Promise<any>;
+    /**
+     * Update one or more entities
+     */
+    graphUpdateEntities(graphId: string, updates: Array<{
+        entityId: string;
+        label?: string;
+        summary?: string;
+        properties?: Record<string, unknown>;
+        data?: unknown;
+    }>): Promise<any>;
+    /**
+     * Delete one or more entities
+     */
+    graphDeleteEntities(graphId: string, entityIds: string[]): Promise<any>;
+    /**
+     * Create one or more relationships
+     */
+    graphCreateRelationships(graphId: string, relationships: Array<{
+        sourceEntityId: string;
+        targetEntityId: string;
+        relationshipType: string;
+        properties?: Record<string, unknown>;
+    }>): Promise<any>;
+    /**
+     * Delete one or more relationships
+     */
+    graphDeleteRelationships(graphId: string, relationshipIds: string[]): Promise<any>;
+    /**
+     * Delete an entire memory graph (SQL record + CosmosDB repository)
+     */
+    graphDelete(graphId: string): Promise<any>;
+    /**
+     * Propose vocabulary extensions (entity types / relationship types)
+     */
+    graphProposeVocabulary(graphId: string, proposals: {
+        entityTypes?: Array<{
+            type: string;
+            description: string;
+            justification: string;
+            properties?: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+                description?: string;
+            }>;
+        }>;
+        relationshipTypes?: Array<{
+            type: string;
+            description: string;
+            justification: string;
+            allowedSourceTypes: string[];
+            allowedTargetTypes: string[];
+            bidirectional?: boolean;
+            properties?: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+                description?: string;
+            }>;
+        }>;
+    }): Promise<any>;
 }
 //# sourceMappingURL=UcmLocalApiClient.d.ts.map

package/dist/clients/UcmLocalApiClient.js

@@ -3,13 +3,11 @@ export class UcmLocalApiClient {
     baseUrl;
     authToken;
     authorId;
-    organizationId;
     client;
-    constructor(baseUrl, authToken, timeout = 600000, authorId, organizationId) {
+    constructor(baseUrl, authToken, timeout = 600000, authorId) {
         this.baseUrl = baseUrl;
         this.authToken = authToken;
         this.authorId = authorId;
-        this.organizationId = organizationId;
         this.client = axios.create({
             baseURL: this.baseUrl,
             timeout,
@@ -515,5 +513,207 @@ export class UcmLocalApiClient {
         const response = await client.get('/api/v1/oauth/authorizations', { params });
         return response.data;
     }
+    // ─── Memory Graph API Methods ───────────────────────────────────────
+    /**
+     * List memory graphs, optionally filtered by scope
+     * @param scope - 'organization' | 'personal' | 'all' (default: 'all')
+     */
+    async listMemoryGraphs(scope) {
+        const client = this.ensureClient();
+        const params = {};
+        if (scope && scope !== 'all') {
+            params.scope = scope;
+        }
+        const response = await client.get(`/api/v1/memory-graphs`, { params });
+        return response.data;
+    }
+    /**
+     * Create a new Memory Graph for the authenticated user
+     */
+    async createMemoryGraph(data) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs`, data);
+        return response.data;
+    }
+    /**
+     * List available vocabulary templates for Memory Graph creation
+     */
+    async listMemoryGraphTemplates() {
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/memory-graphs/templates`);
+        return response.data;
+    }
+    /**
+     * Semantic vector search across multiple Memory Graphs
+     */
+    async graphSearchMultiple(query, options) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/search`, {
+            query,
+            ...options
+        });
+        return response.data;
+    }
+    /**
+     * List knowledge sets for an organization
+     */
+    async listKnowledgeSets() {
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/knowledge-sets`);
+        return response.data;
+    }
+    /**
+     * List knowledge set summary (markdown) for an organization
+     */
+    async listKnowledgeSetSummary() {
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/knowledge-sets/summary`);
+        return response.data.markdown;
+    }
+    /**
+     * Open a knowledge set — returns markdown summary with contents and tool guidance
+     */
+    async openKnowledgeSet(knowledgeSetId) {
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/knowledge-sets/${knowledgeSetId}/summary`);
+        return response.data.markdown;
+    }
+    /**
+     * Open a memory graph — returns vocabulary, stats, instructions, policies, and metadata
+     */
+    async graphOpen(graphId) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/open`);
+        return response.data;
+    }
+    /**
+     * Find entities with filters and pagination
+     */
+    async graphFindEntities(graphId, query) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/entities/find`, query);
+        return response.data;
+    }
+    /**
+     * Get a single entity by ID
+     */
+    async graphGetEntity(graphId, entityId, detailLevel) {
+        const client = this.ensureClient();
+        const params = {};
+        if (detailLevel)
+            params.detailLevel = detailLevel;
+        const response = await client.get(`/api/v1/memory-graphs/${graphId}/entities/${entityId}`, { params });
+        return response.data;
+    }
+    /**
+     * Get relationships for an entity
+     */
+    async graphGetRelationships(graphId, entityId, options) {
+        const client = this.ensureClient();
+        const params = {};
+        if (options?.direction)
+            params.direction = options.direction;
+        if (options?.relationshipTypes)
+            params.relationshipTypes = options.relationshipTypes.join(',');
+        if (options?.limit)
+            params.limit = String(options.limit);
+        const response = await client.get(`/api/v1/memory-graphs/${graphId}/entities/${entityId}/relationships`, { params });
+        return response.data;
+    }
+    /**
+     * Explore neighbourhood around an entity (BFS, 1-3 hops)
+     */
+    async graphExplore(graphId, options) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/explore`, options);
+        return response.data;
+    }
+    /**
+     * Find paths between two entities
+     */
+    async graphFindPaths(graphId, options) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/find-paths`, options);
+        return response.data;
+    }
+    /**
+     * Structured graph traversal with a JSON spec
+     */
+    async graphTraverse(graphId, spec) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/traverse`, spec);
+        return response.data;
+    }
+    /**
+     * Semantic vector search on entity embeddings
+     */
+    async graphSearch(graphId, query, options) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/search`, {
+            query,
+            ...options
+        });
+        return response.data;
+    }
+    /**
+     * Create one or more entities
+     */
+    async graphCreateEntities(graphId, entities) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/entities`, { entities });
+        return response.data;
+    }
+    /**
+     * Update one or more entities
+     */
+    async graphUpdateEntities(graphId, updates) {
+        const client = this.ensureClient();
+        const response = await client.put(`/api/v1/memory-graphs/${graphId}/entities`, { updates });
+        return response.data;
+    }
+    /**
+     * Delete one or more entities
+     */
+    async graphDeleteEntities(graphId, entityIds) {
+        const client = this.ensureClient();
+        const response = await client.delete(`/api/v1/memory-graphs/${graphId}/entities`, {
+            data: { entityIds }
+        });
+        return response.data;
+    }
+    /**
+     * Create one or more relationships
+     */
+    async graphCreateRelationships(graphId, relationships) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/relationships`, { relationships });
+        return response.data;
+    }
+    /**
+     * Delete one or more relationships
+     */
+    async graphDeleteRelationships(graphId, relationshipIds) {
+        const client = this.ensureClient();
+        const response = await client.delete(`/api/v1/memory-graphs/${graphId}/relationships`, {
+            data: { relationshipIds }
+        });
+        return response.data;
+    }
+    /**
+     * Delete an entire memory graph (SQL record + CosmosDB repository)
+     */
+    async graphDelete(graphId) {
+        const client = this.ensureClient();
+        const response = await client.delete(`/api/v1/memory-graphs/${graphId}`);
+        return response.data;
+    }
+    /**
+     * Propose vocabulary extensions (entity types / relationship types)
+     */
+    async graphProposeVocabulary(graphId, proposals) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/vocabulary/propose`, proposals);
+        return response.data;
+    }
 }
 //# sourceMappingURL=UcmLocalApiClient.js.map