roam-research-mcp 1.6.0 → 2.4.3

package/build/server/roam-server.js

@@ -2,8 +2,8 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { CallToolRequestSchema, ErrorCode, ListResourcesRequestSchema, ReadResourceRequestSchema, McpError, ListToolsRequestSchema, ListPromptsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { initializeGraph } from '@roam-research/roam-api-sdk';
-import { API_TOKEN, GRAPH_NAME, HTTP_STREAM_PORT } from '../config/environment.js';
+import { HTTP_STREAM_PORT, validateEnvironment } from '../config/environment.js';
+import { createRegistryFromEnv } from '../config/graph-registry.js';
 import { toolSchemas } from '../tools/schemas.js';
 import { ToolHandlers } from '../tools/tool-handlers.js';
 import { readFileSync } from 'node:fs';
@@ -20,28 +20,34 @@ const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
 const serverVersion = packageJson.version;
 export class RoamServer {
     constructor() {
+        this.toolHandlersCache = new Map();
+        // Validate environment first
+        validateEnvironment();
         try {
-            this.graph = initializeGraph({
-                token: API_TOKEN,
-                graph: GRAPH_NAME,
-            });
+            this.registry = createRegistryFromEnv();
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new McpError(ErrorCode.InternalError, `Failed to initialize Roam graph: ${errorMessage}`);
-        }
-        try {
-            this.toolHandlers = new ToolHandlers(this.graph);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new McpError(ErrorCode.InternalError, `Failed to initialize tool handlers: ${errorMessage}`);
+            throw new McpError(ErrorCode.InternalError, `Failed to initialize graph registry: ${errorMessage}`);
         }
         // Ensure toolSchemas is not empty before proceeding
         if (Object.keys(toolSchemas).length === 0) {
             throw new McpError(ErrorCode.InternalError, 'No tool schemas defined in src/tools/schemas.ts');
         }
     }
+    /**
+     * Get or create a ToolHandlers instance for a specific graph
+     * Handlers are cached per-graph for efficiency
+     */
+    getToolHandlers(graph, graphKey) {
+        const cached = this.toolHandlersCache.get(graphKey);
+        if (cached) {
+            return cached;
+        }
+        const handlers = new ToolHandlers(graph);
+        this.toolHandlersCache.set(graphKey, handlers);
+        return handlers;
+    }
     // Helper to create and configure MCP server instance
     createMcpServer(nameSuffix = '') {
         const server = new Server({
@@ -59,6 +65,25 @@ export class RoamServer {
         this.setupRequestHandlers(server);
         return server;
     }
+    /**
+     * Extract graph and write_key from tool arguments
+     */
+    extractGraphParams(args) {
+        const { graph, write_key, ...cleanedArgs } = args;
+        return {
+            graphKey: graph,
+            writeKey: write_key,
+            cleanedArgs,
+        };
+    }
+    /**
+     * Resolve graph for a tool call with validation
+     */
+    resolveGraph(toolName, graphKey, writeKey) {
+        const resolvedKey = graphKey ?? this.registry.defaultKey;
+        const graph = this.registry.resolveGraphForTool(toolName, graphKey, writeKey);
+        return { graph, resolvedKey };
+    }
     // Refactored to accept a Server instance
     setupRequestHandlers(mcpServer) {
         // List available tools
@@ -81,139 +106,145 @@ export class RoamServer {
         // Handle tool calls
         mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
             try {
+                const args = (request.params.arguments ?? {});
+                const { graphKey, writeKey, cleanedArgs } = this.extractGraphParams(args);
+                const { graph, resolvedKey } = this.resolveGraph(request.params.name, graphKey, writeKey);
+                const toolHandlers = this.getToolHandlers(graph, resolvedKey);
                 switch (request.params.name) {
                     case 'roam_markdown_cheatsheet': {
-                        const content = await this.toolHandlers.getRoamMarkdownCheatsheet();
+                        const graphInfo = this.registry.getGraphInfoMarkdown();
+                        const cheatsheet = await toolHandlers.getRoamMarkdownCheatsheet();
+                        const content = graphInfo + cheatsheet;
                         return {
                             content: [{ type: 'text', text: content }],
                         };
                     }
                     case 'roam_remember': {
-                        const { memory, categories } = request.params.arguments;
-                        const result = await this.toolHandlers.remember(memory, categories);
+                        const { memory, categories, heading, parent_uid, include_memories_tag } = cleanedArgs;
+                        const result = await toolHandlers.remember(memory, categories, heading, parent_uid, include_memories_tag);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_fetch_page_by_title': {
-                        const { title, format } = request.params.arguments;
-                        const content = await this.toolHandlers.fetchPageByTitle(title, format);
+                        const { title, format } = cleanedArgs;
+                        const content = await toolHandlers.fetchPageByTitle(title, format);
                         return {
                             content: [{ type: 'text', text: content }],
                         };
                     }
                     case 'roam_create_page': {
-                        const { title, content } = request.params.arguments;
-                        const result = await this.toolHandlers.createPage(title, content);
+                        const { title, content } = cleanedArgs;
+                        const result = await toolHandlers.createPage(title, content);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_import_markdown': {
-                        const { content, page_uid, page_title, parent_uid, parent_string, order = 'first' } = request.params.arguments;
-                        const result = await this.toolHandlers.importMarkdown(content, page_uid, page_title, parent_uid, parent_string, order);
+                        const { content, page_uid, page_title, parent_uid, parent_string, order = 'first' } = cleanedArgs;
+                        const result = await toolHandlers.importMarkdown(content, page_uid, page_title, parent_uid, parent_string, order);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_add_todo': {
-                        const { todos } = request.params.arguments;
-                        const result = await this.toolHandlers.addTodos(todos);
+                        const { todos } = cleanedArgs;
+                        const result = await toolHandlers.addTodos(todos);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_create_outline': {
-                        const { outline, page_title_uid, block_text_uid } = request.params.arguments;
-                        const result = await this.toolHandlers.createOutline(outline, page_title_uid, block_text_uid);
+                        const { outline, page_title_uid, block_text_uid } = cleanedArgs;
+                        const result = await toolHandlers.createOutline(outline, page_title_uid, block_text_uid);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_search_for_tag': {
-                        const { primary_tag, page_title_uid, near_tag } = request.params.arguments;
-                        const result = await this.toolHandlers.searchForTag(primary_tag, page_title_uid, near_tag);
+                        const { primary_tag, page_title_uid, near_tag } = cleanedArgs;
+                        const result = await toolHandlers.searchForTag(primary_tag, page_title_uid, near_tag);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_search_by_status': {
-                        const { status, page_title_uid, include, exclude } = request.params.arguments;
-                        const result = await this.toolHandlers.searchByStatus(status, page_title_uid, include, exclude);
+                        const { status, page_title_uid, include, exclude } = cleanedArgs;
+                        const result = await toolHandlers.searchByStatus(status, page_title_uid, include, exclude);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_search_block_refs': {
-                        const params = request.params.arguments;
-                        const result = await this.toolHandlers.searchBlockRefs(params);
+                        const params = cleanedArgs;
+                        const result = await toolHandlers.searchBlockRefs(params);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_search_hierarchy': {
-                        const params = request.params.arguments;
+                        const params = cleanedArgs;
                         // Validate that either parent_uid or child_uid is provided, but not both
                         if ((!params.parent_uid && !params.child_uid) || (params.parent_uid && params.child_uid)) {
                             throw new McpError(ErrorCode.InvalidRequest, 'Either parent_uid or child_uid must be provided, but not both');
                         }
-                        const result = await this.toolHandlers.searchHierarchy(params);
+                        const result = await toolHandlers.searchHierarchy(params);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_find_pages_modified_today': {
-                        const { max_num_pages } = request.params.arguments;
-                        const result = await this.toolHandlers.findPagesModifiedToday(max_num_pages || 50);
+                        const { max_num_pages } = cleanedArgs;
+                        const result = await toolHandlers.findPagesModifiedToday(max_num_pages || 50);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_search_by_text': {
-                        const params = request.params.arguments;
-                        const result = await this.toolHandlers.searchByText(params);
+                        const params = cleanedArgs;
+                        const result = await toolHandlers.searchByText(params);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_search_by_date': {
-                        const params = request.params.arguments;
-                        const result = await this.toolHandlers.searchByDate(params);
+                        const params = cleanedArgs;
+                        const result = await toolHandlers.searchByDate(params);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_recall': {
-                        const { sort_by = 'newest', filter_tag } = request.params.arguments;
-                        const result = await this.toolHandlers.recall(sort_by, filter_tag);
+                        const { sort_by = 'newest', filter_tag } = cleanedArgs;
+                        const result = await toolHandlers.recall(sort_by, filter_tag);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_datomic_query': {
-                        const { query, inputs } = request.params.arguments;
-                        const result = await this.toolHandlers.executeDatomicQuery({ query, inputs });
+                        const { query, inputs } = cleanedArgs;
+                        const result = await toolHandlers.executeDatomicQuery({ query, inputs });
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_process_batch_actions': {
-                        const { actions } = request.params.arguments;
-                        const result = await this.toolHandlers.processBatch(actions);
+                        const { actions } = cleanedArgs;
+                        const result = await toolHandlers.processBatch(actions);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_fetch_block_with_children': {
-                        const { block_uid, depth } = request.params.arguments;
-                        const result = await this.toolHandlers.fetchBlockWithChildren(block_uid, depth);
+                        const { block_uid, depth } = cleanedArgs;
+                        const result = await toolHandlers.fetchBlockWithChildren(block_uid, depth);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_create_table': {
-                        const { parent_uid, order, headers, rows } = request.params.arguments;
-                        const result = await this.toolHandlers.createTable({
+                        const { parent_uid, order, headers, rows } = cleanedArgs;
+                        const result = await toolHandlers.createTable({
                             parent_uid,
                             order,
                             headers,
@@ -223,9 +254,23 @@ export class RoamServer {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
+                    case 'roam_move_block': {
+                        const { block_uid, parent_uid, order = 'last' } = cleanedArgs;
+                        const result = await toolHandlers.moveBlock(block_uid, parent_uid, order);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
                     case 'roam_update_page_markdown': {
-                        const { title, markdown, dry_run = false } = request.params.arguments;
-                        const result = await this.toolHandlers.updatePageMarkdown(title, markdown, dry_run);
+                        const { title, markdown, dry_run = false } = cleanedArgs;
+                        const result = await toolHandlers.updatePageMarkdown(title, markdown, dry_run);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'roam_rename_page': {
+                        const { old_title, uid, new_title } = cleanedArgs;
+                        const result = await toolHandlers.renamePage({ old_title, uid, new_title });
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };

package/build/shared/validation.js

@@ -24,7 +24,8 @@ export function validateBlockString(str, allowEmpty = false) {
 /**
  * Validates a Roam UID.
  * UIDs must be either:
- * - 9 alphanumeric characters (standard Roam UID)
+ * - 9 alphanumeric characters (standard Roam block UID)
+ * - A date format like MM-DD-YYYY (daily page UID)
  * - A placeholder like {{uid:name}}
  * @param uid The UID to validate
  * @param required If true, UID is required
@@ -38,11 +39,15 @@ export function validateUid(uid, required = true) {
     if (UID_PLACEHOLDER_REGEX.test(uid)) {
         return null;
     }
-    // Check if it's a valid Roam UID (9 alphanumeric characters)
-    if (!/^[a-zA-Z0-9_-]{9}$/.test(uid)) {
-        return 'uid must be 9 alphanumeric characters or a {{uid:name}} placeholder';
+    // Check if it's a valid Roam block UID (9 alphanumeric characters)
+    if (/^[a-zA-Z0-9_-]{9}$/.test(uid)) {
+        return null;
     }
-    return null;
+    // Check if it's a daily page UID (MM-DD-YYYY format)
+    if (/^\d{2}-\d{2}-\d{4}$/.test(uid)) {
+        return null;
+    }
+    return 'uid must be 9 alphanumeric characters, MM-DD-YYYY date, or a {{uid:name}} placeholder';
 }
 /**
  * Validates an outline level.

package/build/tools/helpers/refs.js

@@ -1,47 +1,66 @@
 import { q } from '@roam-research/roam-api-sdk';
+// Roam block UIDs are 9 alphanumeric characters (with _ and -)
+const REF_PATTERN = /\(\(([a-zA-Z0-9_-]{9})\)\)/g;
 /**
- * Collects all referenced block UIDs from text
+ * Extract all block UIDs referenced in text
  */
-export const collectRefs = (text, depth = 0, refs = new Set()) => {
-    if (depth >= 4)
-        return refs; // Max recursion depth
-    const refRegex = /\(\(([a-zA-Z0-9_-]+)\)\)/g;
+export function collectRefs(text) {
+    const refs = new Set();
     let match;
-    while ((match = refRegex.exec(text)) !== null) {
-        const [_, uid] = match;
-        refs.add(uid);
+    while ((match = REF_PATTERN.exec(text)) !== null) {
+        refs.add(match[1]);
     }
+    REF_PATTERN.lastIndex = 0; // Reset for reuse
     return refs;
-};
+}
 /**
- * Resolves block references in text by replacing them with their content
+ * Resolve block references in text by replacing ((uid)) with block content.
+ * Handles nested refs up to maxDepth, with circular reference protection.
+ *
+ * @param graph - Roam graph connection
+ * @param text - Text containing ((uid)) references
+ * @param depth - Current recursion depth (internal)
+ * @param maxDepth - Maximum depth to resolve nested refs (default: 4)
+ * @param seen - UIDs already resolved in this chain (circular protection)
  */
-export const resolveRefs = async (graph, text, depth = 0) => {
-    if (depth >= 4)
-        return text; // Max recursion depth
-    const refs = collectRefs(text, depth);
+export async function resolveRefs(graph, text, depth = 0, maxDepth = 4, seen = new Set()) {
+    if (depth >= maxDepth)
+        return text;
+    const refs = collectRefs(text);
     if (refs.size === 0)
         return text;
-    // Get referenced block contents
+    // Filter out already-seen refs to prevent circular resolution
+    const newRefs = Array.from(refs).filter(uid => !seen.has(uid));
+    if (newRefs.length === 0)
+        return text;
+    // Track these refs as seen
+    newRefs.forEach(uid => seen.add(uid));
+    // Batch fetch all referenced blocks
     const refQuery = `[:find ?uid ?string
                     :in $ [?uid ...]
                     :where [?b :block/uid ?uid]
                           [?b :block/string ?string]]`;
-    const refResults = await q(graph, refQuery, [Array.from(refs)]);
-    // Create lookup map of uid -> string
-    const refMap = new Map();
-    refResults.forEach(([uid, string]) => {
-        refMap.set(uid, string);
-    });
-    // Replace references with their content
-    let resolvedText = text;
-    for (const uid of refs) {
-        const refContent = refMap.get(uid);
-        if (refContent) {
-            // Recursively resolve nested references
-            const resolvedContent = await resolveRefs(graph, refContent, depth + 1);
-            resolvedText = resolvedText.replace(new RegExp(`\\(\\(${uid}\\)\\)`, 'g'), resolvedContent);
+    const results = await q(graph, refQuery, [newRefs]);
+    // Build lookup map
+    const refMap = new Map(results);
+    // Collect refs that have nested refs needing resolution
+    const nestedTexts = new Map();
+    for (const uid of newRefs) {
+        const content = refMap.get(uid);
+        if (content && collectRefs(content).size > 0) {
+            nestedTexts.set(uid, content);
         }
     }
-    return resolvedText;
-};
+    // Resolve nested refs in parallel
+    if (nestedTexts.size > 0) {
+        const resolvedEntries = await Promise.all(Array.from(nestedTexts.entries()).map(async ([uid, content]) => {
+            const resolved = await resolveRefs(graph, content, depth + 1, maxDepth, seen);
+            return [uid, resolved];
+        }));
+        resolvedEntries.forEach(([uid, resolved]) => refMap.set(uid, resolved));
+    }
+    // Replace all refs in a single pass
+    return text.replace(REF_PATTERN, (match, uid) => {
+        return refMap.get(uid) ?? match;
+    });
+}

package/build/tools/operations/blocks.js

@@ -1,4 +1,4 @@
-import { q, updateBlock as updateRoamBlock, batchActions, createPage } from '@roam-research/roam-api-sdk';
+import { q, updateBlock as updateRoamBlock, moveBlock as moveRoamBlock, batchActions, createPage } from '@roam-research/roam-api-sdk';
 import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
 import { formatRoamDate } from '../../utils/helpers.js';
 import { parseMarkdown, convertToRoamActions, convertToRoamMarkdown } from '../../markdown-utils.js';
@@ -189,6 +189,43 @@ export class BlockOperations {
             throw new McpError(ErrorCode.InternalError, `Failed to update block: ${error.message}`);
         }
     }
+    async moveBlock(block_uid, parent_uid, order = 'last') {
+        if (!block_uid) {
+            throw new McpError(ErrorCode.InvalidRequest, 'block_uid is required');
+        }
+        if (!parent_uid) {
+            throw new McpError(ErrorCode.InvalidRequest, 'parent_uid is required');
+        }
+        // Verify the block exists
+        const blockQuery = `[:find ?uid .
+                        :where [?b :block/uid "${block_uid}"]
+                               [?b :block/uid ?uid]]`;
+        const blockExists = await q(this.graph, blockQuery, []);
+        if (!blockExists) {
+            throw new McpError(ErrorCode.InvalidRequest, `Block with UID "${block_uid}" not found`);
+        }
+        try {
+            await moveRoamBlock(this.graph, {
+                action: 'move-block',
+                location: {
+                    'parent-uid': parent_uid,
+                    order: order
+                },
+                block: {
+                    uid: block_uid
+                }
+            });
+            return {
+                success: true,
+                block_uid,
+                new_parent_uid: parent_uid,
+                order
+            };
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to move block: ${error.message}`);
+        }
+    }
     async updateBlocks(updates) {
         if (!Array.isArray(updates) || updates.length === 0) {
             throw new McpError(ErrorCode.InvalidRequest, 'updates must be a non-empty array');

package/build/tools/operations/memory.js

@@ -1,6 +1,7 @@
 import { q, createPage, batchActions } from '@roam-research/roam-api-sdk';
 import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
 import { formatRoamDate } from '../../utils/helpers.js';
+import { generateBlockUid } from '../../markdown-utils.js';
 import { resolveRefs } from '../helpers/refs.js';
 import { SearchOperations } from './search/index.js';
 import { pageUidCache } from '../../cache/page-uid-cache.js';
@@ -9,7 +10,7 @@ export class MemoryOperations {
         this.graph = graph;
         this.searchOps = new SearchOperations(graph);
     }
-    async remember(memory, categories) {
+    async remember(memory, categories, heading, parent_uid, include_memories_tag = true) {
         // Get today's date
         const today = new Date();
         const dateStr = formatRoamDate(today);
@@ -47,25 +48,74 @@ export class MemoryOperations {
                 }
             }
         }
+        // Determine parent block for the memory
+        let targetParentUid;
+        if (parent_uid) {
+            // Use provided parent_uid directly
+            targetParentUid = parent_uid;
+        }
+        else if (heading) {
+            // Search for heading block on today's page, create if not found
+            const headingQuery = `[:find ?uid
+                            :in $ ?page-uid ?text
+                            :where
+                            [?page :block/uid ?page-uid]
+                            [?page :block/children ?block]
+                            [?block :block/string ?text]
+                            [?block :block/uid ?uid]]`;
+            const headingResults = await q(this.graph, headingQuery, [pageUid, heading]);
+            if (headingResults && headingResults.length > 0) {
+                targetParentUid = headingResults[0][0];
+            }
+            else {
+                // Create the heading block
+                const headingBlockUid = generateBlockUid();
+                try {
+                    await batchActions(this.graph, {
+                        action: 'batch-actions',
+                        actions: [{
+                                action: 'create-block',
+                                location: { 'parent-uid': pageUid, order: 'last' },
+                                block: { uid: headingBlockUid, string: heading }
+                            }]
+                    });
+                    targetParentUid = headingBlockUid;
+                }
+                catch (error) {
+                    throw new McpError(ErrorCode.InternalError, `Failed to create heading block: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        else {
+            // Default: use daily page root
+            targetParentUid = pageUid;
+        }
         // Get memories tag from environment
-        const memoriesTag = process.env.MEMORIES_TAG;
-        if (!memoriesTag) {
-            throw new McpError(ErrorCode.InternalError, 'MEMORIES_TAG environment variable not set');
+        let memoriesTag;
+        if (include_memories_tag) {
+            memoriesTag = process.env.MEMORIES_TAG;
+            if (!memoriesTag) {
+                throw new McpError(ErrorCode.InternalError, 'MEMORIES_TAG environment variable not set');
+            }
         }
         // Format categories as Roam tags if provided
         const categoryTags = categories?.map(cat => {
             // Handle multi-word categories
             return cat.includes(' ') ? `#[[${cat}]]` : `#${cat}`;
-        }).join(' ') || '';
-        // Create block with memory, memories tag, and optional categories
-        const blockContent = `${memoriesTag} ${memory} ${categoryTags}`.trim();
+        }) ?? [];
+        // Create block with memory, then all tags together at the end
+        const tags = memoriesTag ? [...categoryTags, memoriesTag] : categoryTags;
+        const blockContent = [memory, ...tags].join(' ').trim();
+        // Pre-generate UID so we can return it
+        const blockUid = generateBlockUid();
         const actions = [{
                 action: 'create-block',
                 location: {
-                    'parent-uid': pageUid,
+                    'parent-uid': targetParentUid,
                     order: 'last'
                 },
                 block: {
+                    uid: blockUid,
                     string: blockContent
                 }
             }];
@@ -81,7 +131,7 @@ export class MemoryOperations {
         catch (error) {
             throw new McpError(ErrorCode.InternalError, `Failed to create memory block: ${error instanceof Error ? error.message : String(error)}`);
         }
-        return { success: true };
+        return { success: true, block_uid: blockUid, parent_uid: targetParentUid };
     }
     async recall(sort_by = 'newest', filter_tag) {
         // Get memories tag from environment