@prmichaelsen/remember-mcp 3.0.0 → 3.13.0

package/agent/tasks/milestone-14-memory-collection-v2/task-169-update-remember-search-space.md

@@ -0,0 +1,179 @@
+# Task 169: Implement remember_search_space Tool
+
+**Milestone**: Milestone 14 - Memory Collection Pattern v2
+**Estimated Time**: 4-6 hours
+**Dependencies**: [Task 165: Core Infrastructure Setup](task-165-core-infrastructure-setup.md)
+**Status**: Completed 2026-02-27
+
+---
+
+## Objective
+
+Implement the `remember_search_space` tool to query memories using space_ids filtering and support group searches.
+
+---
+
+## Steps
+
+### 1. Create Tool Schema
+
+**File**: `src/tools/remember-search-space.ts`
+
+**Actions**:
+- Update input schema to accept `spaces` array (filter by spaces)
+- Add `groups` array parameter (filter by groups)
+- Keep `query` parameter (search query)
+- Add `search_type` parameter (hybrid, bm25, semantic)
+- Update tool description
+
+**Expected Schema**:
+```typescript
+{
+  query: string,
+  spaces?: string[],      // ["cooking", "recipes"]
+  groups?: string[],      // ["{group-id}"]
+  search_type?: string,   // "hybrid" | "bm25" | "semantic"
+  limit?: number
+}
+```
+
+### 2. Implement Space Filtering
+
+**Actions**:
+- Query `Memory_spaces_public` collection
+- Filter by `space_ids` array contains any of specified spaces
+- Use Weaviate's array filtering capabilities
+- Return memories with composite IDs
+
+**Expected Behavior**:
+```typescript
+// Search specific spaces
+remember_search_space({
+  query: "recipe",
+  spaces: ["cooking", "recipes"]
+})
+
+// Queries: Memory_spaces_public WHERE space_ids contains "cooking" OR "recipes"
+```
+
+### 3. Implement Group Filtering
+
+**Actions**:
+- Query specific `Memory_groups_{groupId}` collections
+- Combine results from multiple group collections
+- Return memories with composite IDs
+
+**Expected Behavior**:
+```typescript
+// Search specific groups
+remember_search_space({
+  query: "recipe",
+  groups: ["{foodie-group}", "{recipe-club}"]
+})
+
+// Queries: Memory_groups_{foodie-group} AND Memory_groups_{recipe-club}
+```
+
+### 4. Implement Combined Search
+
+**Actions**:
+- Support searching both spaces and groups simultaneously
+- Merge results from both query types
+- Deduplicate by composite ID
+- Sort by relevance score
+
+**Expected Behavior**:
+```typescript
+// Search both spaces and groups
+remember_search_space({
+  query: "recipe",
+  spaces: ["cooking"],
+  groups: ["{foodie-group}"]
+})
+
+// Queries both Memory_spaces_public and Memory_groups_{foodie-group}
+// Returns merged, deduplicated results
+```
+
+### 5. Implement All-Public Search
+
+**Actions**:
+- When no spaces or groups specified, search all public memories
+- Query entire `Memory_spaces_public` collection
+- Return all matching memories regardless of space_ids
+
+**Expected Behavior**:
+```typescript
+// Search all public memories
+remember_search_space({
+  query: "recipe"
+})
+
+// Queries: Memory_spaces_public (all memories)
+```
+
+### 6. Write Integration Tests
+
+**File**: `tests/integration/remember-search-space.test.ts`
+
+**Actions**:
+- Test space filtering (single and multiple)
+- Test group filtering (single and multiple)
+- Test combined search (spaces + groups)
+- Test all-public search
+- Test deduplication
+- Test search types (hybrid, bm25, semantic)
+- Test error cases
+
+**Expected Output**: All tests passing
+
+---
+
+## Verification
+
+- [ ] Tool schema updated correctly
+- [ ] Space filtering works correctly
+- [ ] Group filtering works correctly
+- [ ] Combined search works correctly
+- [ ] All-public search works correctly
+- [ ] Deduplication works correctly
+- [ ] Search types work correctly
+- [ ] Integration tests passing
+- [ ] TypeScript compiles without errors
+- [ ] Tool description updated in MCP manifest
+
+---
+
+## Expected Output
+
+### Files Modified
+- `src/tools/remember-search-space-v2.ts` (~220 lines)
+
+### Files Created
+- `tests/integration/remember-search-space.test.ts` (~180 lines)
+
+### Test Output
+```
+✓ Space filtering (4 tests)
+✓ Group filtering (4 tests)
+✓ Combined search (4 tests)
+✓ All-public search (3 tests)
+✓ Deduplication (3 tests)
+✓ Search types (3 tests)
+✓ Error handling (3 tests)
+
+Total: 24 tests passing
+```
+
+---
+
+## Notes
+
+- This is a breaking change from v1 (single space only)
+- Deduplication critical for combined searches
+- Consider caching frequently searched spaces
+- Performance testing needed for large collections
+
+---
+
+**Next Task**: [Task 170: Update remember_create_memory Tool](task-170-update-remember-create-memory.md)

package/agent/tasks/milestone-14-memory-collection-v2/task-170-update-remember-create-update.md

@@ -0,0 +1,139 @@
+# Task 170: Implement remember_create_memory and remember_update_memory Tools
+
+**Milestone**: Milestone 14 - Memory Collection Pattern v2
+**Estimated Time**: 3-4 hours
+**Dependencies**: [Task 165: Core Infrastructure Setup](task-165-core-infrastructure-setup.md)
+**Status**: Completed 2026-02-27
+
+---
+
+## Objective
+
+Implement `remember_create_memory` and `remember_update_memory` tools to initialize and maintain tracking arrays (space_ids, group_ids) in user memories.
+
+---
+
+## Steps
+
+### 1. Implement remember_create_memory Tool
+
+**File**: `src/tools/remember-create-memory.ts`
+
+**Actions**:
+- Add `space_ids: []` to new memory objects (empty array)
+- Add `group_ids: []` to new memory objects (empty array)
+- Ensure memories created in `Memory_users_{userId}` collection
+- Keep all existing functionality
+
+**Expected Behavior**:
+```typescript
+// Create new memory
+remember_create_memory({
+  content: "My recipe",
+  content_type: "note"
+})
+
+// Creates in Memory_users_{userId}:
+{
+  id: "auto-generated-id",
+  content: "My recipe",
+  content_type: "note",
+  space_ids: [],      // ← New field
+  group_ids: [],      // ← New field
+  created_at: timestamp,
+  updated_at: timestamp
+}
+```
+
+### 2. Implement remember_update_memory Tool
+
+**File**: `src/tools/remember-update-memory.ts`
+
+**Actions**:
+- Preserve `space_ids` and `group_ids` arrays during updates
+- Don't allow direct modification of tracking arrays (use publish/retract instead)
+- Update `updated_at` timestamp
+- Keep all existing functionality
+
+**Expected Behavior**:
+```typescript
+// Update memory content
+remember_update_memory({
+  id: "my-recipe",
+  content: "Updated recipe"
+})
+
+// Updates in Memory_users_{userId}:
+{
+  id: "my-recipe",
+  content: "Updated recipe",  // ← Updated
+  space_ids: ["cooking"],     // ← Preserved
+  group_ids: [],              // ← Preserved
+  updated_at: timestamp       // ← Updated
+}
+```
+
+### 3. Add Validation
+
+**Actions**:
+- Validate `space_ids` and `group_ids` are arrays
+- Prevent direct modification of tracking arrays
+- Ensure arrays are initialized on create
+- Handle migration of old memories without tracking arrays
+
+### 4. Write Unit Tests
+
+**File**: `tests/unit/remember-create-update.test.ts`
+
+**Actions**:
+- Test memory creation with tracking arrays
+- Test memory update preserves tracking arrays
+- Test validation of tracking arrays
+- Test error cases
+
+**Expected Output**: All tests passing
+
+---
+
+## Verification
+
+- [ ] remember_create_memory initializes tracking arrays
+- [ ] remember_update_memory preserves tracking arrays
+- [ ] Tracking arrays cannot be directly modified
+- [ ] Validation works correctly
+- [ ] Unit tests passing
+- [ ] TypeScript compiles without errors
+- [ ] Tool descriptions updated
+
+---
+
+## Expected Output
+
+### Files Modified
+- `src/tools/remember-create-memory-v2.ts` (~150 lines)
+- `src/tools/remember-update-memory-v2.ts` (~150 lines)
+
+### Files Created
+- `tests/unit/remember-create-update.test.ts` (~100 lines)
+
+### Test Output
+```
+✓ Memory creation (5 tests)
+✓ Memory update (5 tests)
+✓ Tracking array validation (4 tests)
+✓ Error handling (3 tests)
+
+Total: 17 tests passing
+```
+
+---
+
+## Notes
+
+- Minimal changes to existing tools
+- Tracking arrays managed by publish/retract/revise tools
+- Backward compatibility for old memories without tracking arrays
+
+---
+
+**Next Task**: [Task 171: Implement Migration Script](task-171-implement-migration-script.md)

package/agent/tasks/milestone-14-memory-collection-v2/task-172-performance-testing-optimization.md

@@ -0,0 +1,161 @@
+# Task 172: Performance Testing and Optimization
+
+**Milestone**: Milestone 14 - Memory Collection Pattern v2
+**Estimated Time**: 6-8 hours
+**Dependencies**: All previous tasks
+**Status**: Not Started
+
+---
+
+## Objective
+
+Conduct comprehensive performance testing of Memory Collection Pattern v2 and optimize query performance to meet targets (<200ms for typical queries).
+
+---
+
+## Steps
+
+### 1. Create Performance Test Suite
+
+**File**: `tests/performance/v2-performance.test.ts`
+
+**Actions**:
+- Create test data generator (1K, 10K, 100K memories)
+- Implement query performance tests
+- Implement write performance tests
+- Implement migration performance tests
+- Set performance baselines
+
+### 2. Test Query Performance
+
+**Scenarios**:
+- Search single space (small: <100 memories)
+- Search single space (medium: 1K-10K memories)
+- Search single space (large: >10K memories)
+- Search multiple spaces
+- Search groups
+- Search all public memories
+- Composite ID lookups
+
+**Target**: <200ms for typical queries (1K-10K memories)
+
+### 3. Test Write Performance
+
+**Scenarios**:
+- Create memory
+- Update memory
+- Publish to single space
+- Publish to multiple spaces
+- Publish to groups
+- Retract from spaces
+- Revise published memories
+
+**Target**: <100ms for write operations
+
+### 4. Test Migration Performance
+
+**Scenarios**:
+- Migrate 1K memories
+- Migrate 10K memories
+- Migrate 100K memories
+- Backup creation
+- Rollback execution
+
+**Target**: <10 minutes for 10K memories
+
+### 5. Identify Bottlenecks
+
+**Actions**:
+- Profile query execution
+- Identify slow operations
+- Analyze Weaviate query plans
+- Check index usage
+- Monitor memory usage
+
+### 6. Implement Optimizations
+
+**Potential Optimizations**:
+- Add Weaviate indexes on space_ids and group_ids
+- Optimize composite ID generation
+- Batch operations where possible
+- Cache frequently accessed data
+- Optimize tracking array operations
+- Parallelize migration steps
+
+### 7. Benchmark Results
+
+**Actions**:
+- Run performance tests before optimization
+- Run performance tests after optimization
+- Compare results
+- Document improvements
+- Generate performance report
+
+---
+
+## Verification
+
+- [ ] Performance test suite created
+- [ ] Query performance meets targets (<200ms)
+- [ ] Write performance meets targets (<100ms)
+- [ ] Migration performance meets targets (<10 min for 10K)
+- [ ] Bottlenecks identified and documented
+- [ ] Optimizations implemented
+- [ ] Benchmarks show improvement
+- [ ] Performance report generated
+
+---
+
+## Expected Output
+
+### Files Created
+- `tests/performance/v2-performance.test.ts` (~400 lines)
+- `docs/performance/v2-benchmarks.md` (~50 lines)
+
+### Performance Report
+```
+Memory Collection Pattern v2 - Performance Benchmarks
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Query Performance (10K memories):
+  Single space search:        145ms  ✓ (target: <200ms)
+  Multi-space search:         178ms  ✓ (target: <200ms)
+  Group search:               132ms  ✓ (target: <200ms)
+  All public search:          189ms  ✓ (target: <200ms)
+  Composite ID lookup:         12ms  ✓ (target: <50ms)
+
+Write Performance:
+  Create memory:               45ms  ✓ (target: <100ms)
+  Update memory:               38ms  ✓ (target: <100ms)
+  Publish (single space):      67ms  ✓ (target: <100ms)
+  Publish (multi-space):       89ms  ✓ (target: <100ms)
+  Retract:                     52ms  ✓ (target: <100ms)
+  Revise:                      78ms  ✓ (target: <100ms)
+
+Migration Performance:
+  1K memories:              1.2 min  ✓ (target: <2 min)
+  10K memories:             8.5 min  ✓ (target: <10 min)
+  100K memories:           82.3 min  ✓ (target: <120 min)
+
+Optimizations Applied:
+  ✓ Added indexes on space_ids and group_ids
+  ✓ Optimized composite ID generation (30% faster)
+  ✓ Batched tracking array updates (40% faster)
+  ✓ Parallelized migration steps (2x faster)
+
+Overall: All performance targets met ✓
+```
+
+---
+
+## Notes
+
+- Performance testing should use realistic data volumes
+- Test on hardware similar to production
+- Consider network latency in benchmarks
+- Document any performance regressions
+- Optimization should not compromise correctness
+
+---
+
+**Next Task**: [Task 173: Documentation and Examples](task-173-documentation-examples.md)