@prmichaelsen/remember-mcp 0.2.7 → 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,171 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.1] - 2026-02-12
+
+### 🐛 Fixed
+
+- **Empty Or/And Operator Bug**: Fixed "no children for operator Or" error
+  - Added validation to filter out undefined/null values before combining filters
+  - `combineFiltersWithOr` now validates operands array is not empty
+  - `combineFiltersWithAnd` now validates operands array is not empty
+  - `buildCombinedSearchFilters` filters out invalid filters before OR combination
+  - Prevents creation of operators with empty children arrays
+
+### ✨ Added
+
+- **Edge Case Tests**: Added 3 new test cases for undefined/null filter handling
+  - Test for empty Or operator prevention
+  - Test for empty And operator prevention
+  - Test for mixed valid and undefined filters
+
+### 📊 Test Results
+
+- **57 tests passing** (up from 54)
+- **4 test suites passing** (all green)
+- **Code coverage: 90.56%** on weaviate-filters.ts (up from 83.67%)
+
+---
+
+## [1.0.0] - 2026-02-12
+
+### 🚨 BREAKING CHANGES
+
+- **`createServer` is now async**: The factory function now returns `Promise<Server>` instead of `Server`. Consumers must use `await` when calling `createServer()`.
+
+  ```typescript
+  // Before (0.2.x)
+  const server = createServer(token, userId);
+  
+  // After (1.0.0+)
+  const server = await createServer(token, userId);
+  ```
+
+  **Impact**: Only affects direct factory users. The mcp-auth wrapper handles async factories automatically, so no changes needed for mcp-auth users.
+
+### ✨ Added
+
+- **Weaviate v3 Filter API**: Implemented proper Weaviate v3 filter builders using fluent API
+  - Created `src/utils/weaviate-filters.ts` with filter builder utilities
+  - Supports AND/OR logic for complex filter combinations
+  - Comprehensive filter support: type, weight, trust, date range, tags
+
+- **Combined Memory + Relationship Search**: `remember_search_memory` now searches BOTH memories and relationships by default
+  - Uses OR logic to search both doc types
+  - Results separated into `memories` and `relationships` arrays
+  - Backward compatible: set `include_relationships: false` to search only memories
+  - Relationship observations are now searchable
+
+- **Comprehensive Unit Tests**: Added 29 test cases for filter builders
+  - Tests for `buildMemoryOnlyFilters`, `buildRelationshipOnlyFilters`, `buildCombinedSearchFilters`
+  - Tests for edge cases and complex filter scenarios
+  - 83.67% code coverage on weaviate-filters.ts
+
+- **Jest Type Support**: Added "jest" to tsconfig types array for proper TypeScript support in test files
+
+### 🐛 Fixed
+
+- **gRPC Filter Error**: Fixed "paths needs to have an uneven number of components" error
+  - Replaced old Weaviate v2 filter format (path/operator/valueText) with v3 fluent API
+  - Affected tools: `remember_search_memory`, `remember_query_memory`
+
+- **Database Initialization**: Changed from fire-and-forget to await pattern
+  - Server now waits for database initialization before accepting requests
+  - Prevents server from starting in broken state
+  - Errors propagate clearly to caller
+
+- **Test Failures**: Fixed server-factory tests to handle async createServer
+  - Updated all tests to use async/await
+  - Changed synchronous expect() calls to async expect().resolves/rejects
+
+### 📊 Test Results
+
+- **54 tests passing** (up from 25)
+- **4 test suites passing** (all green)
+- **Overall coverage: 26.54%** (up from 22.53%)
+- **1 skipped** (integration test requiring live Weaviate)
+
+### 📝 Documentation
+
+- Updated `agent/progress.yaml` with Task 20 completion
+- Updated `agent/tasks/task-20-fix-weaviate-v3-filters.md` with implementation details
+- All changes documented in agent directory
+
+---
+
+## [0.2.8] - 2026-02-11
+
+### ✨ Added
+
+- Complete memory CRUD operations (create, read, update, delete)
+- Complete relationship CRUD operations (create, read, update, delete)
+- User preferences system with 6 categories
+- 12 MCP tools fully implemented
+- Hybrid search (semantic + keyword)
+- Vector similarity search
+- RAG-optimized queries
+- 45 content types
+
+### 📊 Milestones Completed
+
+- M1: Project Foundation (100%)
+- M2: Core Memory System (100%)
+- M3: Relationships & Graph (100%)
+- M4: User Preferences (100%)
+
+---
+
+## [0.1.0] - 2026-02-11
+
+### ✨ Initial Release
+
+- Project structure and configuration
+- Weaviate client with multi-tenant support
+- Firestore integration
+- Basic MCP server with stdio transport
+- Server factory for mcp-auth compatibility
+- 25 unit tests
+- Dual build: standalone server + library factory
+
+---
+
+## Migration Guides
+
+### Migrating from 0.2.x to 1.0.0
+
+**If you're using the factory export:**
+
+```typescript
+// OLD (0.2.x)
+import { createServer } from '@prmichaelsen/remember-mcp/factory';
+const server = createServer(accessToken, userId);
+
+// NEW (1.0.0+)
+import { createServer } from '@prmichaelsen/remember-mcp/factory';
+const server = await createServer(accessToken, userId);
+```
+
+**If you're using mcp-auth wrapper:**
+- No changes needed! mcp-auth handles async factories automatically.
+
+**If you're using standalone server:**
+- No changes needed! You don't call createServer directly.
+
+**If you're using Claude Desktop:**
+- No changes needed! You use the built server via npx.
+
+---
+
+## Versioning Policy
+
+This project follows [Semantic Versioning](https://semver.org/):
+
+- **Major** (X.0.0): Breaking changes
+- **Minor** (0.X.0): New features, backward compatible
+- **Patch** (0.0.X): Bug fixes, backward compatible
+
+**Note**: Version 1.0.0 indicates the first stable release with a breaking change from 0.2.x. Future breaking changes will increment the major version (2.0.0, 3.0.0, etc.).

package/agent/tasks/task-remember-mcp-fix-or-operator.md

@@ -0,0 +1,82 @@
+# Task: Fix Weaviate "Or" Operator Query Bug
+
+**Project**: remember-mcp  
+**Estimated Time**: 1-2 hours  
+**Priority**: High  
+**Status**: Not Started
+
+---
+
+## Problem
+
+Weaviate query failing with error:
+```
+no children for operator "Or"
+```
+
+This occurs when searching memories, indicating the query builder is creating an "Or" operator with an empty children array, which is invalid in Weaviate.
+
+## Root Cause
+
+The Weaviate query construction in remember-mcp is building a filter with an "Or" operator but not adding any child conditions to it. This happens when:
+- Building complex filters with multiple conditions
+- Conditional logic results in empty filter arrays
+- Or operator is created before checking if there are conditions to add
+
+## Investigation Steps
+
+1. **Find where "Or" operator is used**
+   - Search for `.or(` or `Or(` in remember-mcp codebase
+   - Check search-memory.ts, query-memory.ts, find-similar.ts
+
+2. **Identify the query construction logic**
+   - Look for filter building code
+   - Find where Or operator is created
+   - Check if children array is validated before creating operator
+
+3. **Reproduce locally**
+   - Test search with various parameters
+   - Identify which search parameters trigger the bug
+   - Confirm the empty Or operator
+
+## Expected Fix
+
+Add validation before creating Or operator:
+```typescript
+// Before (buggy):
+const orFilter = weaviate.filter.or(...conditions);
+
+// After (fixed):
+if (conditions.length === 0) {
+  // Skip Or operator if no conditions
+  return baseQuery;
+} else if (conditions.length === 1) {
+  // Use single condition directly
+  return baseQuery.withWhere(conditions[0]);
+} else {
+  // Use Or operator only when multiple conditions
+  return baseQuery.withWhere(weaviate.filter.or(...conditions));
+}
+```
+
+## Files to Check
+
+- `src/tools/search-memory.ts` - Main search implementation
+- `src/tools/query-memory.ts` - Query tool
+- `src/tools/find-similar.ts` - Similarity search
+- `src/weaviate/client.ts` - Weaviate client wrapper
+- Any file that builds Weaviate filters
+
+## Verification
+
+- [ ] Or operator only created when conditions.length > 1
+- [ ] Empty conditions array handled gracefully
+- [ ] Single condition doesn't use Or operator
+- [ ] All search tools work without errors
+- [ ] Tests pass
+
+---
+
+**Impact**: High - blocks all search functionality  
+**Complexity**: Medium - requires understanding Weaviate query API  
+**Location**: remember-mcp project (not remember-mcp-server)

package/dist/server-factory.d.ts

@@ -38,5 +38,5 @@ export interface ServerOptions {
  * });
  * ```
  */
-export declare function createServer(accessToken: string, userId: string, options?: ServerOptions): Server;
+export declare function createServer(accessToken: string, userId: string, options?: ServerOptions): Promise<Server>;
 //# sourceMappingURL=server-factory.d.ts.map

package/dist/server-factory.js

@@ -1411,14 +1411,14 @@ async function handleCreateMemory(args, userId, context) {
 function buildCombinedSearchFilters(collection, filters) {
   const memoryFilters = buildDocTypeFilters(collection, "memory", filters);
   const relationshipFilters = buildDocTypeFilters(collection, "relationship", filters);
-  if (memoryFilters && relationshipFilters) {
-    return combineFiltersWithOr([memoryFilters, relationshipFilters]);
-  } else if (memoryFilters) {
-    return memoryFilters;
-  } else if (relationshipFilters) {
-    return relationshipFilters;
-  }
-  return void 0;
+  const validFilters = [memoryFilters, relationshipFilters].filter((f) => f !== void 0 && f !== null);
+  if (validFilters.length === 0) {
+    return void 0;
+  } else if (validFilters.length === 1) {
+    return validFilters[0];
+  } else {
+    return combineFiltersWithOr(validFilters);
+  }
 }
 function buildDocTypeFilters(collection, docType, filters) {
   const filterList = [];
@@ -1483,27 +1483,29 @@ function buildMemoryOnlyFilters(collection, filters) {
   return buildDocTypeFilters(collection, "memory", filters);
 }
 function combineFiltersWithAnd(filters) {
-  if (filters.length === 0) {
+  const validFilters = filters.filter((f) => f !== void 0 && f !== null);
+  if (validFilters.length === 0) {
     return void 0;
   }
-  if (filters.length === 1) {
-    return filters[0];
+  if (validFilters.length === 1) {
+    return validFilters[0];
   }
   return {
     operator: "And",
-    operands: filters
+    operands: validFilters
   };
 }
 function combineFiltersWithOr(filters) {
-  if (filters.length === 0) {
+  const validFilters = filters.filter((f) => f !== void 0 && f !== null);
+  if (validFilters.length === 0) {
     return void 0;
   }
-  if (filters.length === 1) {
-    return filters[0];
+  if (validFilters.length === 1) {
+    return validFilters[0];
   }
   return {
     operator: "Or",
-    operands: filters
+    operands: validFilters
   };
 }
 
@@ -3190,14 +3192,12 @@ async function ensureDatabasesInitialized() {
   })();
   return initializationPromise;
 }
-function createServer(accessToken, userId, options = {}) {
+async function createServer(accessToken, userId, options = {}) {
   if (!userId) {
     throw new Error("userId is required");
   }
   logger.debug("Creating server instance", { userId });
-  ensureDatabasesInitialized().catch((error) => {
-    logger.error("Failed to initialize databases:", error);
-  });
+  await ensureDatabasesInitialized();
   const server = new Server(
     {
       name: options.name || "remember-mcp",

package/dist/server.js

@@ -1340,14 +1340,14 @@ async function handleCreateMemory(args, userId, context) {
 function buildCombinedSearchFilters(collection, filters) {
   const memoryFilters = buildDocTypeFilters(collection, "memory", filters);
   const relationshipFilters = buildDocTypeFilters(collection, "relationship", filters);
-  if (memoryFilters && relationshipFilters) {
-    return combineFiltersWithOr([memoryFilters, relationshipFilters]);
-  } else if (memoryFilters) {
-    return memoryFilters;
-  } else if (relationshipFilters) {
-    return relationshipFilters;
-  }
-  return void 0;
+  const validFilters = [memoryFilters, relationshipFilters].filter((f) => f !== void 0 && f !== null);
+  if (validFilters.length === 0) {
+    return void 0;
+  } else if (validFilters.length === 1) {
+    return validFilters[0];
+  } else {
+    return combineFiltersWithOr(validFilters);
+  }
 }
 function buildDocTypeFilters(collection, docType, filters) {
   const filterList = [];
@@ -1412,27 +1412,29 @@ function buildMemoryOnlyFilters(collection, filters) {
   return buildDocTypeFilters(collection, "memory", filters);
 }
 function combineFiltersWithAnd(filters) {
-  if (filters.length === 0) {
+  const validFilters = filters.filter((f) => f !== void 0 && f !== null);
+  if (validFilters.length === 0) {
     return void 0;
   }
-  if (filters.length === 1) {
-    return filters[0];
+  if (validFilters.length === 1) {
+    return validFilters[0];
   }
   return {
     operator: "And",
-    operands: filters
+    operands: validFilters
   };
 }
 function combineFiltersWithOr(filters) {
-  if (filters.length === 0) {
+  const validFilters = filters.filter((f) => f !== void 0 && f !== null);
+  if (validFilters.length === 0) {
     return void 0;
   }
-  if (filters.length === 1) {
-    return filters[0];
+  if (validFilters.length === 1) {
+    return validFilters[0];
   }
   return {
     operator: "Or",
-    operands: filters
+    operands: validFilters
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prmichaelsen/remember-mcp",
-  "version": "0.2.7",
+  "version": "1.0.1",
   "description": "Multi-tenant memory system MCP server with vector search and relationships",
   "main": "dist/server.js",
   "type": "module",

package/src/server-factory.spec.ts

@@ -3,24 +3,24 @@ import { createServer } from './server-factory.js';
 
 describe('Server Factory', () => {
   describe('Parameter Validation', () => {
-    it('should create server instance with valid parameters', () => {
-      const server = createServer('test-token', 'user123');
+    it('should create server instance with valid parameters', async () => {
+      const server = await createServer('test-token', 'user123');
       expect(server).toBeDefined();
       expect(server).toHaveProperty('setRequestHandler');
     });
 
-    it('should allow empty accessToken (not used by remember-mcp)', () => {
+    it('should allow empty accessToken (not used by remember-mcp)', async () => {
       // accessToken is not used by remember-mcp (self-managed data)
       // Should not throw even with empty string
-      expect(() => createServer('', 'user123')).not.toThrow();
+      await expect(createServer('', 'user123')).resolves.toBeDefined();
     });
 
-    it('should require userId', () => {
-      expect(() => createServer('token', '')).toThrow('userId is required');
+    it('should require userId', async () => {
+      await expect(createServer('token', '')).rejects.toThrow('userId is required');
     });
 
-    it('should accept custom options', () => {
-      const server = createServer('token', 'user123', {
+    it('should accept custom options', async () => {
+      const server = await createServer('token', 'user123', {
         name: 'custom-name',
         version: '2.0.0',
       });

package/src/server-factory.ts

@@ -113,11 +113,11 @@ async function ensureDatabasesInitialized(): Promise<void> {
  * });
  * ```
  */
-export function createServer(
+export async function createServer(
   accessToken: string,
   userId: string,
   options: ServerOptions = {}
-): Server {
+): Promise<Server> {
   // Note: accessToken is not used by remember-mcp (self-managed data)
   // but required by mcp-auth contract. Can be any value including empty string.
   
@@ -128,11 +128,8 @@ export function createServer(
   logger.debug('Creating server instance', { userId });
   
   // Ensure databases are initialized (happens once globally)
-  // Note: This is synchronous to match the Server return type
-  // The actual initialization happens on first tool call
-  ensureDatabasesInitialized().catch(error => {
-    logger.error('Failed to initialize databases:', error);
-  });
+  // Initialization must succeed or server creation fails
+  await ensureDatabasesInitialized();
   
   // Create MCP server
   const server = new Server(

package/src/utils/weaviate-filters.spec.ts

@@ -512,4 +512,53 @@ describe('weaviate-filters', () => {
       });
     });
   });
+
+  describe('undefined/null filter handling', () => {
+    it('should not create Or operator with empty operands', () => {
+      const emptyCollection = {
+        filter: {
+          byProperty: () => ({
+            equal: () => undefined,
+            greaterThanOrEqual: () => undefined,
+            lessThanOrEqual: () => undefined,
+            containsAny: () => undefined,
+          }),
+        },
+      };
+      
+      const result = buildCombinedSearchFilters(emptyCollection);
+      expect(result).toBeUndefined();
+    });
+
+    it('should not create And operator with empty operands', () => {
+      const emptyCollection = {
+        filter: {
+          byProperty: () => ({
+            equal: () => undefined,
+          }),
+        },
+      };
+      
+      const result = buildMemoryOnlyFilters(emptyCollection);
+      expect(result).toBeUndefined();
+    });
+
+    it('should handle mixed valid and undefined filters in OR', () => {
+      const result = buildCombinedSearchFilters(mockCollection, {
+        types: ['note'],
+      });
+      
+      expect(result.operator).toBe('Or');
+      expect(result.operands).toHaveLength(2);
+      expect(result.operands[0]).toBeDefined();
+      expect(result.operands[1]).toBeDefined();
+      
+      if (result.operands[0].operands) {
+        expect(result.operands[0].operands.length).toBeGreaterThan(0);
+      }
+      if (result.operands[1].operands) {
+        expect(result.operands[1].operands.length).toBeGreaterThan(0);
+      }
+    });
+  });
 });

package/src/utils/weaviate-filters.ts

@@ -25,16 +25,17 @@ export function buildCombinedSearchFilters(
   // Build relationship-specific filters
   const relationshipFilters = buildDocTypeFilters(collection, 'relationship', filters);
   
+  // Filter out undefined/null values before combining
+  const validFilters = [memoryFilters, relationshipFilters].filter(f => f !== undefined && f !== null);
+  
   // Combine with OR: search both memories and relationships
-  if (memoryFilters && relationshipFilters) {
-    return combineFiltersWithOr([memoryFilters, relationshipFilters]);
-  } else if (memoryFilters) {
-    return memoryFilters;
-  } else if (relationshipFilters) {
-    return relationshipFilters;
+  if (validFilters.length === 0) {
+    return undefined;
+  } else if (validFilters.length === 1) {
+    return validFilters[0];
+  } else {
+    return combineFiltersWithOr(validFilters);
   }
-  
-  return undefined;
 }
 
 /**
@@ -164,17 +165,21 @@ export function buildRelationshipOnlyFilters(
  * @returns Combined filter or undefined
  */
 function combineFiltersWithAnd(filters: any[]): any {
-  if (filters.length === 0) {
+  // Filter out any undefined/null values
+  const validFilters = filters.filter(f => f !== undefined && f !== null);
+  
+  if (validFilters.length === 0) {
     return undefined;
   }
-  if (filters.length === 1) {
-    return filters[0];
+  if (validFilters.length === 1) {
+    return validFilters[0];
   }
   
   // Weaviate v3 uses operator/operands structure for combining filters
+  // Only create And operator if we have 2+ valid filters
   return {
     operator: 'And',
-    operands: filters
+    operands: validFilters
   };
 }
 
@@ -185,17 +190,21 @@ function combineFiltersWithAnd(filters: any[]): any {
  * @returns Combined filter or undefined
  */
 function combineFiltersWithOr(filters: any[]): any {
-  if (filters.length === 0) {
+  // Filter out any undefined/null values
+  const validFilters = filters.filter(f => f !== undefined && f !== null);
+  
+  if (validFilters.length === 0) {
     return undefined;
   }
-  if (filters.length === 1) {
-    return filters[0];
+  if (validFilters.length === 1) {
+    return validFilters[0];
   }
   
   // Weaviate v3 uses operator/operands structure for combining filters
+  // Only create Or operator if we have 2+ valid filters
   return {
     operator: 'Or',
-    operands: filters
+    operands: validFilters
   };
 }