roam-research-mcp 0.18.0 → 0.20.0

package/README.md

@@ -28,7 +28,7 @@ npm run build
 
 ## Features
 
-The server provides twelve powerful tools for interacting with Roam Research:
+The server provides fourteen powerful tools for interacting with Roam Research:
 
 1. `roam_fetch_page_by_title`: Fetch and read a page's content by title, recursively resolving block references up to 4 levels deep
 2. `roam_create_page`: Create new pages with optional content
@@ -42,6 +42,8 @@ The server provides twelve powerful tools for interacting with Roam Research:
 10. `roam_search_by_text`: Search for blocks containing specific text across all pages or within a specific page
 11. `roam_update_block`: Update block content with direct text or pattern-based transformations
 12. `roam_search_by_date`: Search for blocks and pages based on creation or modification dates
+13. `roam_search_for_tag`: Search for blocks containing specific tags with optional filtering by nearby tags
+14. `roam_remember`: Store and categorize memories or information with automatic tagging
 
 ## Setup
 
@@ -60,28 +62,14 @@ The server provides twelve powerful tools for interacting with Roam Research:
    ```
    ROAM_API_TOKEN=your-api-token
    ROAM_GRAPH_NAME=your-graph-name
+   MEMORIES_TAG='#[[LLM/Memories]]'
+   PROFILE_PAGE='LLM/Profile' (not yet implemented)
    ```
 
    Option 2: Using MCP settings (Alternative method)
    Add the configuration to your MCP settings file:
 
    - For Cline (`~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`):
-
-   ```json
-   {
-     "mcpServers": {
-       "roam-research": {
-         "command": "node",
-         "args": ["/path/to/roam-research/build/index.js"],
-         "env": {
-           "ROAM_API_TOKEN": "your-api-token",
-           "ROAM_GRAPH_NAME": "your-graph-name"
-         }
-       }
-     }
-   }
-   ```
-
    - For Claude desktop app (`~/Library/Application Support/Claude/claude_desktop_config.json`):
 
    ```json
@@ -92,7 +80,9 @@ The server provides twelve powerful tools for interacting with Roam Research:
          "args": ["/path/to/roam-research/build/index.js"],
          "env": {
            "ROAM_API_TOKEN": "your-api-token",
-           "ROAM_GRAPH_NAME": "your-graph-name"
+           "ROAM_GRAPH_NAME": "your-graph-name",
+           "MEMORIES_TAG": "#[[LLM/Memories]]",
+           "PROFILE_PAGE": "LLM/Profile"
          }
        }
      }
@@ -335,7 +325,7 @@ Search for blocks containing specific text across all pages or within a specific
 use_mcp_tool roam-research roam_search_by_text {
   "text": "search text",
   "page_title_uid": "optional-page-title-or-uid",
-  "case_sensitive": false
+  "case_sensitive": true
 }
 ```
 
@@ -351,7 +341,7 @@ Parameters:
 
 - `text`: The text to search for (required)
 - `page_title_uid`: Title or UID of the page to search in (optional)
-- `case_sensitive`: Whether to perform a case-sensitive search (optional, default: false)
+- `case_sensitive`: Whether to perform a case-sensitive search (optional, default: true to match Roam's native behavior)
 
 Returns:
 
@@ -421,6 +411,86 @@ Returns:
 }
 ```
 
+### Search For Tags
+
+Search for blocks containing specific tags with optional filtering by nearby tags:
+
+```typescript
+use_mcp_tool roam-research roam_search_for_tag {
+  "primary_tag": "Project/Tasks",
+  "page_title_uid": "optional-page-title-or-uid",
+  "near_tag": "optional-secondary-tag",
+  "case_sensitive": true
+}
+```
+
+Features:
+
+- Search for blocks containing specific tags
+- Optional filtering by presence of another tag
+- Page-scoped or graph-wide search
+- Case-sensitive or case-insensitive search
+- Returns block content with page context
+- Efficient tag matching using Datalog queries
+
+Parameters:
+
+- `primary_tag`: The main tag to search for (required)
+- `page_title_uid`: Title or UID of the page to search in (optional)
+- `near_tag`: Another tag to filter results by (optional)
+- `case_sensitive`: Whether to perform case-sensitive search (optional, default: true to match Roam's native behavior)
+
+Returns:
+
+```json
+{
+  "success": true,
+  "matches": [
+    {
+      "block_uid": "matching-block-uid",
+      "content": "Block content containing #[[primary_tag]]",
+      "page_title": "Page containing block"
+    }
+  ],
+  "message": "Found N block(s) referencing \"primary_tag\""
+}
+```
+
+### Remember Information
+
+Store memories or important information with automatic tagging and categorization:
+
+```typescript
+use_mcp_tool roam-research roam_remember {
+  "memory": "Important information to remember",
+  "categories": ["Work", "Project/Alpha"]
+}
+```
+
+Features:
+
+- Store information with #[[LLM/Memories]] tag
+- Add optional category tags for organization
+- Automatically adds to today's daily page
+- Supports multiple categories per memory
+- Easy retrieval using roam_search_for_tag
+- Maintains chronological order of memories
+
+Parameters:
+
+- `memory`: The information to remember (required)
+- `categories`: Optional array of categories to tag the memory with
+
+Returns:
+
+```json
+{
+  "success": true,
+  "block_uid": "created-block-uid",
+  "content": "Memory content with tags"
+}
+```
+
 ### Search By Date
 
 Search for blocks and pages based on creation or modification dates:

package/build/server/roam-server.js

@@ -22,6 +22,7 @@ export class RoamServer {
         }, {
             capabilities: {
                 tools: {
+                    roam_remember: {},
                     roam_add_todo: {},
                     roam_fetch_page_by_title: {},
                     roam_create_page: {},
@@ -35,6 +36,7 @@ export class RoamServer {
                     find_pages_modified_today: {},
                     roam_search_by_text: {},
                     roam_update_block: {},
+                    roam_update_blocks: {},
                     roam_search_by_date: {}
                 },
             },
@@ -56,6 +58,13 @@ export class RoamServer {
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             try {
                 switch (request.params.name) {
+                    case 'roam_remember': {
+                        const { memory, categories } = request.params.arguments;
+                        const result = await this.toolHandlers.remember(memory, categories);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
                     case 'roam_fetch_page_by_title': {
                         const { title } = request.params.arguments;
                         const content = await this.toolHandlers.fetchPageByTitle(title);
@@ -166,6 +175,13 @@ export class RoamServer {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
+                    case 'roam_update_blocks': {
+                        const { updates } = request.params.arguments;
+                        const result = await this.toolHandlers.updateBlocks(updates);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
                     default:
                         throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
                 }

package/build/tools/schemas.js

@@ -2,7 +2,7 @@
 export const toolSchemas = {
     roam_add_todo: {
         name: 'roam_add_todo',
-        description: 'Add a list of todo items as individual blocks to today\'s daily page in Roam. Each item becomes its own actionable block with todo status.',
+        description: 'Add a list of todo items as individual blocks to today\'s daily page in Roam. Each item becomes its own actionable block with todo status.\nNOTE on Roam-flavored markdown: For direct linking: use [[link]] syntax. For aliased linking, use [alias]([[link]]) syntax. Do not concatenate words in links/hashtags - correct: #[[multiple words]] #self-esteem (for typically hyphenated words).',
         inputSchema: {
             type: 'object',
             properties: {
@@ -52,7 +52,7 @@ export const toolSchemas = {
     },
     roam_create_block: {
         name: 'roam_create_block',
-        description: 'Add a new block to an existing Roam page. If no page specified, adds to today\'s daily note. Best for capturing immediate thoughts, additions to discussions, or content that doesn\'t warrant its own page. Can specify page by title or UID.',
+        description: 'Add a new block to an existing Roam page. If no page specified, adds to today\'s daily note. Best for capturing immediate thoughts, additions to discussions, or content that doesn\'t warrant its own page. Can specify page by title or UID.\nNOTE on Roam-flavored markdown: For direct linking: use [[link]] syntax. For aliased linking, use [alias]([[link]]) syntax. Do not concatenate words in links/hashtags - correct: #[[multiple words]] #self-esteem (for typically hyphenated words).',
         inputSchema: {
             type: 'object',
             properties: {
@@ -74,7 +74,7 @@ export const toolSchemas = {
     },
     roam_create_outline: {
         name: 'roam_create_output_with_nested_structure',
-        description: 'Create a structured outline or output with nested structure in Roam from an array of items with explicit levels. Can be added on a specific page or under a specific block.',
+        description: 'Create a structured outline or output with nested structure in Roam from an array of items with explicit levels. Can be added on a specific page or under a specific block. Ideal for saving a conversation with an LLM response, research, or organizing thoughts.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -146,7 +146,7 @@ export const toolSchemas = {
     },
     roam_search_for_tag: {
         name: 'roam_search_for_tag',
-        description: 'Search for blocks containing a specific tag and optionally filter by blocks that also contain another tag nearby.',
+        description: 'Search for blocks containing a specific tag and optionally filter by blocks that also contain another tag nearby. Example: Use this to search for memories that are tagged with the MEMORIES_TAG.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -161,6 +161,11 @@ export const toolSchemas = {
                 near_tag: {
                     type: 'string',
                     description: 'Optional: Another tag to filter results by - will only return blocks where both tags appear',
+                },
+                case_sensitive: {
+                    type: 'boolean',
+                    description: 'Optional: Whether to perform case-sensitive matching (default: true, matching Roam\'s native behavior)',
+                    default: true
                 }
             },
             required: ['primary_tag']
@@ -188,6 +193,11 @@ export const toolSchemas = {
                 exclude: {
                     type: 'string',
                     description: 'Optional: Comma-separated list of terms to filter results by exclusion (matches content or page title)'
+                },
+                case_sensitive: {
+                    type: 'boolean',
+                    description: 'Optional: Whether to perform case-sensitive matching (default: true, matching Roam\'s native behavior)',
+                    default: true
                 }
             },
             required: ['status']
@@ -266,7 +276,8 @@ export const toolSchemas = {
                 },
                 case_sensitive: {
                     type: 'boolean',
-                    description: 'Optional: Whether to perform a case-sensitive search (default: false)'
+                    description: 'Optional: Whether to perform case-sensitive search (default: true, matching Roam\'s native behavior)',
+                    default: true
                 }
             },
             required: ['text']
@@ -274,7 +285,7 @@ export const toolSchemas = {
     },
     roam_update_block: {
         name: 'roam_update_block',
-        description: 'Update the content of an existing block identified by its UID. Can either provide new content directly or use a transform pattern to modify existing content.',
+        description: 'Update the content of an existing block identified by its UID. Can either provide new content directly or use a transform pattern to modify existing content.\nNOTE on Roam-flavored markdown: For direct linking: use [[link]] syntax. For aliased linking, use [alias]([[link]]) syntax. Do not concatenate words in links/hashtags - correct: #[[multiple words]] #self-esteem (for typically hyphenated words).',
         inputSchema: {
             type: 'object',
             properties: {
@@ -314,6 +325,58 @@ export const toolSchemas = {
             ]
         }
     },
+    roam_update_blocks: {
+        name: 'roam_update_blocks',
+        description: 'Update multiple blocks in a single batch operation. Each update can provide either new content directly or a transform pattern.\nNOTE on Roam-flavored markdown: For direct linking: use [[link]] syntax. For aliased linking, use [alias]([[link]]) syntax. Do not concatenate words in links/hashtags - correct: #[[multiple words]] #self-esteem (for typically hyphenated words).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                updates: {
+                    type: 'array',
+                    description: 'Array of block updates to perform',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            block_uid: {
+                                type: 'string',
+                                description: 'UID of the block to update'
+                            },
+                            content: {
+                                type: 'string',
+                                description: 'New content for the block. If not provided, transform will be used.'
+                            },
+                            transform: {
+                                type: 'object',
+                                description: 'Pattern to transform the current content. Used if content is not provided.',
+                                properties: {
+                                    find: {
+                                        type: 'string',
+                                        description: 'Text or regex pattern to find'
+                                    },
+                                    replace: {
+                                        type: 'string',
+                                        description: 'Text to replace with'
+                                    },
+                                    global: {
+                                        type: 'boolean',
+                                        description: 'Whether to replace all occurrences',
+                                        default: true
+                                    }
+                                },
+                                required: ['find', 'replace']
+                            }
+                        },
+                        required: ['block_uid'],
+                        oneOf: [
+                            { required: ['content'] },
+                            { required: ['transform'] }
+                        ]
+                    }
+                }
+            },
+            required: ['updates']
+        }
+    },
     roam_search_by_date: {
         name: 'roam_search_by_date',
         description: 'Search for blocks or pages based on creation or modification dates',
@@ -342,9 +405,35 @@ export const toolSchemas = {
                     type: 'boolean',
                     description: 'Whether to include the content of matching blocks/pages',
                     default: true,
+                },
+                case_sensitive: {
+                    type: 'boolean',
+                    description: 'Optional: Whether to perform case-sensitive matching (default: true, matching Roam\'s native behavior)',
+                    default: true
                 }
             },
             required: ['start_date', 'type', 'scope']
         }
+    },
+    roam_remember: {
+        name: 'roam_remember',
+        description: 'Add a memory or piece of information to remember, stored on the daily page with #[[LLM/Memories]] tag and optional categories. Use roam_search_for_tag with "LLM/Memories" to find stored memories.\nNOTE on Roam-flavored markdown: For direct linking: use [[link]] syntax. For aliased linking, use [alias]([[link]]) syntax. Do not concatenate words in links/hashtags - correct: #[[multiple words]] #self-esteem (for typically hyphenated words).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memory: {
+                    type: 'string',
+                    description: 'The memory or information to remember'
+                },
+                categories: {
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    },
+                    description: 'Optional categories to tag the memory with (will be converted to Roam tags)'
+                }
+            },
+            required: ['memory']
+        }
     }
 };

package/build/tools/tool-handlers.js

@@ -157,21 +157,23 @@ export class ToolHandlers {
         // Get or create the target page
         const targetPageUid = await findOrCreatePage(page_title_uid || formatRoamDate(new Date()));
         // Helper function to find block with improved relationship checks
-        const findBlockWithRetry = async (pageUid, blockString, maxRetries = 5, initialDelay = 1000) => {
+        const findBlockWithRetry = async (pageUid, blockString, maxRetries = 5, initialDelay = 1000, case_sensitive = false) => {
             // Try multiple query strategies
             const queries = [
                 // Strategy 1: Direct page and string match
                 `[:find ?b-uid ?order
           :where [?p :block/uid "${pageUid}"]
                  [?b :block/page ?p]
-                 [?b :block/string "${blockString}"]
+                 [?b :block/string ?block-str]
+                 [(${case_sensitive ? '=' : 'clojure.string/equals-ignore-case'} ?block-str "${blockString}")]
                  [?b :block/order ?order]
                  [?b :block/uid ?b-uid]]`,
                 // Strategy 2: Parent-child relationship
                 `[:find ?b-uid ?order
           :where [?p :block/uid "${pageUid}"]
                  [?b :block/parents ?p]
-                 [?b :block/string "${blockString}"]
+                 [?b :block/string ?block-str]
+                 [(${case_sensitive ? '=' : 'clojure.string/equals-ignore-case'} ?block-str "${blockString}")]
                  [?b :block/order ?order]
                  [?b :block/uid ?b-uid]]`,
                 // Strategy 3: Broader page relationship
@@ -179,7 +181,8 @@ export class ToolHandlers {
           :where [?p :block/uid "${pageUid}"]
                  [?b :block/page ?page]
                  [?p :block/page ?page]
-                 [?b :block/string "${blockString}"]
+                 [?b :block/string ?block-str]
+                 [(${case_sensitive ? '=' : 'clojure.string/equals-ignore-case'} ?block-str "${blockString}")]
                  [?b :block/order ?order]
                  [?b :block/uid ?b-uid]]`
             ];
@@ -201,7 +204,7 @@ export class ToolHandlers {
             throw new McpError(ErrorCode.InternalError, `Failed to find block "${blockString}" under page "${pageUid}" after trying multiple strategies`);
         };
         // Helper function to create and verify block with improved error handling
-        const createAndVerifyBlock = async (content, parentUid, maxRetries = 5, initialDelay = 1000, isRetry = false) => {
+        const createAndVerifyBlock = async (content, parentUid, maxRetries = 5, initialDelay = 1000, isRetry = false, case_sensitive = false) => {
             try {
                 // Initial delay before any operations
                 if (!isRetry) {
@@ -223,7 +226,7 @@ export class ToolHandlers {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     try {
                         // Try to find the block using our improved findBlockWithRetry
-                        return await findBlockWithRetry(parentUid, content);
+                        return await findBlockWithRetry(parentUid, content, maxRetries, initialDelay, case_sensitive);
                     }
                     catch (error) {
                         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -241,7 +244,7 @@ export class ToolHandlers {
                 // Otherwise, try one more time with a clean slate
                 console.log(`Retrying block creation for "${content}" with fresh attempt`);
                 await new Promise(resolve => setTimeout(resolve, initialDelay * 2));
-                return createAndVerifyBlock(content, parentUid, maxRetries, initialDelay, true);
+                return createAndVerifyBlock(content, parentUid, maxRetries, initialDelay, true, case_sensitive);
             }
         };
         // Get or create the parent block
@@ -728,7 +731,110 @@ export class ToolHandlers {
             throw new McpError(ErrorCode.InternalError, `Failed to update block: ${error.message}`);
         }
     }
-    async searchByStatus(status, page_title_uid, include, exclude) {
+    async updateBlocks(updates) {
+        if (!Array.isArray(updates) || updates.length === 0) {
+            throw new McpError(ErrorCode.InvalidRequest, 'updates must be a non-empty array');
+        }
+        // Validate each update has required fields
+        updates.forEach((update, index) => {
+            if (!update.block_uid) {
+                throw new McpError(ErrorCode.InvalidRequest, `Update at index ${index} missing block_uid`);
+            }
+            if (!update.content && !update.transform) {
+                throw new McpError(ErrorCode.InvalidRequest, `Update at index ${index} must have either content or transform`);
+            }
+        });
+        // Get current content for all blocks
+        const blockUids = updates.map(u => u.block_uid);
+        const blockQuery = `[:find ?uid ?string
+                        :in $ [?uid ...]
+                        :where [?b :block/uid ?uid]
+                               [?b :block/string ?string]]`;
+        const blockResults = await q(this.graph, blockQuery, [blockUids]);
+        // Create map of uid -> current content
+        const contentMap = new Map();
+        blockResults.forEach(([uid, string]) => {
+            contentMap.set(uid, string);
+        });
+        // Prepare batch actions
+        const actions = [];
+        const results = [];
+        for (const update of updates) {
+            try {
+                const currentContent = contentMap.get(update.block_uid);
+                if (!currentContent) {
+                    results.push({
+                        block_uid: update.block_uid,
+                        content: '',
+                        success: false,
+                        error: `Block with UID "${update.block_uid}" not found`
+                    });
+                    continue;
+                }
+                // Determine new content
+                let newContent;
+                if (update.content) {
+                    newContent = update.content;
+                }
+                else if (update.transform) {
+                    const regex = new RegExp(update.transform.find, update.transform.global ? 'g' : '');
+                    newContent = currentContent.replace(regex, update.transform.replace);
+                }
+                else {
+                    // This shouldn't happen due to earlier validation
+                    throw new Error('Invalid update configuration');
+                }
+                // Add to batch actions
+                actions.push({
+                    action: 'update-block',
+                    block: {
+                        uid: update.block_uid,
+                        string: newContent
+                    }
+                });
+                results.push({
+                    block_uid: update.block_uid,
+                    content: newContent,
+                    success: true
+                });
+            }
+            catch (error) {
+                results.push({
+                    block_uid: update.block_uid,
+                    content: contentMap.get(update.block_uid) || '',
+                    success: false,
+                    error: error.message
+                });
+            }
+        }
+        // Execute batch update if we have any valid actions
+        if (actions.length > 0) {
+            try {
+                const batchResult = await batchActions(this.graph, {
+                    action: 'batch-actions',
+                    actions
+                });
+                if (!batchResult) {
+                    throw new Error('Batch update failed');
+                }
+            }
+            catch (error) {
+                // Mark all previously successful results as failed
+                results.forEach(result => {
+                    if (result.success) {
+                        result.success = false;
+                        result.error = `Batch update failed: ${error.message}`;
+                    }
+                });
+            }
+        }
+        return {
+            success: results.every(r => r.success),
+            results
+        };
+    }
+    async searchByStatus(status, page_title_uid, include, exclude, case_sensitive = true // Changed to true to match Roam's behavior
+    ) {
         // Get target page UID if provided
         let targetPageUid;
         if (page_title_uid) {
@@ -789,16 +895,26 @@ export class ToolHandlers {
                 ...(pageTitle && { page_title: pageTitle })
             };
         });
-        // Post-query filtering
+        // Post-query filtering with case sensitivity option
         if (include) {
-            const includeTerms = include.toLowerCase().split(',').map(term => term.trim());
-            matches = matches.filter(match => includeTerms.some(term => match.content.toLowerCase().includes(term) ||
-                (match.page_title && match.page_title.toLowerCase().includes(term))));
+            const includeTerms = include.split(',').map(term => term.trim());
+            matches = matches.filter(match => {
+                const matchContent = case_sensitive ? match.content : match.content.toLowerCase();
+                const matchTitle = match.page_title && (case_sensitive ? match.page_title : match.page_title.toLowerCase());
+                const terms = case_sensitive ? includeTerms : includeTerms.map(t => t.toLowerCase());
+                return terms.some(term => matchContent.includes(case_sensitive ? term : term.toLowerCase()) ||
+                    (matchTitle && matchTitle.includes(case_sensitive ? term : term.toLowerCase())));
+            });
         }
         if (exclude) {
-            const excludeTerms = exclude.toLowerCase().split(',').map(term => term.trim());
-            matches = matches.filter(match => !excludeTerms.some(term => match.content.toLowerCase().includes(term) ||
-                (match.page_title && match.page_title.toLowerCase().includes(term))));
+            const excludeTerms = exclude.split(',').map(term => term.trim());
+            matches = matches.filter(match => {
+                const matchContent = case_sensitive ? match.content : match.content.toLowerCase();
+                const matchTitle = match.page_title && (case_sensitive ? match.page_title : match.page_title.toLowerCase());
+                const terms = case_sensitive ? excludeTerms : excludeTerms.map(t => t.toLowerCase());
+                return !terms.some(term => matchContent.includes(case_sensitive ? term : term.toLowerCase()) ||
+                    (matchTitle && matchTitle.includes(case_sensitive ? term : term.toLowerCase())));
+            });
         }
         return {
             success: true,
@@ -806,7 +922,8 @@ export class ToolHandlers {
             message: `Found ${matches.length} block(s) with status ${status}${include ? ` including "${include}"` : ''}${exclude ? ` excluding "${exclude}"` : ''}`
         };
     }
-    async searchForTag(primary_tag, page_title_uid, near_tag) {
+    async searchForTag(primary_tag, page_title_uid, near_tag, case_sensitive = true // Changed to true to match Roam's behavior
+    ) {
         // Ensure tags are properly formatted with #
         const formatTag = (tag) => tag.startsWith('#') ? tag : `#${tag}`;
         const primaryTagFormatted = formatTag(primary_tag);
@@ -841,8 +958,12 @@ export class ToolHandlers {
                            [?b :block/page ?p]
                            [?b :block/string ?block-str]
                            [?b :block/uid ?block-uid]
-                           [(clojure.string/includes? ?block-str ?primary-tag)]
-                           [(clojure.string/includes? ?block-str ?near-tag)]]`;
+                           [(clojure.string/includes? 
+                             ${case_sensitive ? '?block-str' : '(clojure.string/lower-case ?block-str)'} 
+                             ${case_sensitive ? '?primary-tag' : '(clojure.string/lower-case ?primary-tag)'})]
+                           [(clojure.string/includes? 
+                             ${case_sensitive ? '?block-str' : '(clojure.string/lower-case ?block-str)'} 
+                             ${case_sensitive ? '?near-tag' : '(clojure.string/lower-case ?near-tag)'})]`;
                 queryParams = [primaryTagFormatted, nearTagFormatted, targetPageUid];
             }
             else {
@@ -852,7 +973,9 @@ export class ToolHandlers {
                            [?b :block/page ?p]
                            [?b :block/string ?block-str]
                            [?b :block/uid ?block-uid]
-                           [(clojure.string/includes? ?block-str ?primary-tag)]]`;
+                           [(clojure.string/includes? 
+                             ${case_sensitive ? '?block-str' : '(clojure.string/lower-case ?block-str)'} 
+                             ${case_sensitive ? '?primary-tag' : '(clojure.string/lower-case ?primary-tag)'})]`;
                 queryParams = [primaryTagFormatted, targetPageUid];
             }
         }
@@ -865,8 +988,12 @@ export class ToolHandlers {
                            [?b :block/uid ?block-uid]
                            [?b :block/page ?p]
                            [?p :node/title ?page-title]
-                           [(clojure.string/includes? ?block-str ?primary-tag)]
-                           [(clojure.string/includes? ?block-str ?near-tag)]]`;
+                           [(clojure.string/includes? 
+                             ${case_sensitive ? '?block-str' : '(clojure.string/lower-case ?block-str)'} 
+                             ${case_sensitive ? '?primary-tag' : '(clojure.string/lower-case ?primary-tag)'})]
+                           [(clojure.string/includes? 
+                             ${case_sensitive ? '?block-str' : '(clojure.string/lower-case ?block-str)'} 
+                             ${case_sensitive ? '?near-tag' : '(clojure.string/lower-case ?near-tag)'})]`;
                 queryParams = [primaryTagFormatted, nearTagFormatted];
             }
             else {
@@ -876,7 +1003,9 @@ export class ToolHandlers {
                            [?b :block/uid ?block-uid]
                            [?b :block/page ?p]
                            [?p :node/title ?page-title]
-                           [(clojure.string/includes? ?block-str ?primary-tag)]]`;
+                           [(clojure.string/includes? 
+                             ${case_sensitive ? '?block-str' : '(clojure.string/lower-case ?block-str)'} 
+                             ${case_sensitive ? '?primary-tag' : '(clojure.string/lower-case ?primary-tag)'})]`;
                 queryParams = [primaryTagFormatted];
             }
         }
@@ -945,6 +1074,20 @@ export class ToolHandlers {
             ...(params.include_content && { content }),
             page_title: pageTitle
         }));
+        // Apply case sensitivity if content is included
+        if (params.include_content) {
+            const case_sensitive = params.case_sensitive ?? true; // Default to true to match Roam's behavior
+            if (!case_sensitive) {
+                matches.forEach(match => {
+                    if (match.content) {
+                        match.content = match.content.toLowerCase();
+                    }
+                    if (match.page_title) {
+                        match.page_title = match.page_title.toLowerCase();
+                    }
+                });
+            }
+        }
         // Sort by time
         const sortedMatches = matches.sort((a, b) => b.time - a.time);
         return {
@@ -953,6 +1096,58 @@ export class ToolHandlers {
             message: `Found ${sortedMatches.length} matches for the given date range and criteria`
         };
     }
+    async remember(memory, categories) {
+        // Get today's date
+        const today = new Date();
+        const dateStr = formatRoamDate(today);
+        // Try to find today's page
+        const findQuery = `[:find ?uid :in $ ?title :where [?e :node/title ?title] [?e :block/uid ?uid]]`;
+        const findResults = await q(this.graph, findQuery, [dateStr]);
+        let pageUid;
+        if (findResults && findResults.length > 0) {
+            pageUid = findResults[0][0];
+        }
+        else {
+            // Create today's page if it doesn't exist
+            const success = await createPage(this.graph, {
+                action: 'create-page',
+                page: { title: dateStr }
+            });
+            if (!success) {
+                throw new McpError(ErrorCode.InternalError, 'Failed to create today\'s page');
+            }
+            // Get the new page's UID
+            const results = await q(this.graph, findQuery, [dateStr]);
+            if (!results || results.length === 0) {
+                throw new McpError(ErrorCode.InternalError, 'Could not find created today\'s page');
+            }
+            pageUid = results[0][0];
+        }
+        // Get memories tag from environment
+        const 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();
+        const success = await createBlock(this.graph, {
+            action: 'create-block',
+            location: {
+                "parent-uid": pageUid,
+                "order": "last"
+            },
+            block: { string: blockContent }
+        });
+        if (!success) {
+            throw new McpError(ErrorCode.InternalError, 'Failed to create memory block');
+        }
+        return { success: true };
+    }
     async addTodos(todos) {
         if (!Array.isArray(todos) || todos.length === 0) {
             throw new McpError(ErrorCode.InvalidRequest, 'todos must be a non-empty array');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roam-research-mcp",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "A Model Context Protocol (MCP) server for Roam Research API integration",
   "private": false,
   "repository": {