lex-agentic-memory 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c20af8021bf914fea9be62a7cbfc8ebbf4f71c0a4ceb49defac2867fa2469b12
-  data.tar.gz: e4d005aa924f4007f1f8ea91a81311a8ada4e7c9501bab4d7f72559e31416c1c
+  metadata.gz: ab87360ac0b2afc81f1868d934c29c851acdbb9db7b3864bc41437a20d959850
+  data.tar.gz: 922800b83b2c11ae1d525d23c9da664fbe6098bab81d4c0f32b45d96cc80d111
 SHA512:
-  metadata.gz: 2128a3c7c86aee317d516df8a04b1849b7e886c9e309f76c32d63c9dbc67df6eaa34172d87614778c5670396ca6bcc9d31ca1049ebfd7c2a0260112f66d5b157
-  data.tar.gz: 34730c557e9c0438fa2093748f7878aa0104b53d81d51dd89a5ca29c2ff196410c315f6ea103ae3ddb20ac4b41341f854de847706575b2ce13a4835bf4b9537d
+  metadata.gz: 2b2d45540a99c67dae5a5b27b49f75b27c1baa3beb56db00f1b7f4aef671577172b6a9a3a71077e535c7d9bcff0dc8d0690eb3f8a1af818c9bea5b0ac7d04d2c
+  data.tar.gz: 212f0679f2e1248209ad7a4a41a92694348080f1d71d24bbd6baa2eb7fff4389d591bad3f931fd8c1d7fc48298fb361f64cb9c5d08053785f59c3ec82d5be2e1

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.1.6] - 2026-03-23
+
+### Fixed
+- Fix trace migration path registration (`'memory/local_migrations'` -> `'trace/local_migrations'`)
+- Refactor CacheStore from single-blob storage to per-trace individual cache keys with index, preventing OOM on flush
+
+### Changed
+- CacheStore now uses `legion:memory:trace:<uuid>` keys instead of serializing all traces into one key
+- Dirty set tracking replaces dirty flag for more efficient selective flushing
+- Batch flush in groups of 500 traces
+
 ## [0.1.5] - 2026-03-22
 
 ### Changed

data/lib/legion/extensions/agentic/memory/trace/helpers/cache_store.rb

@@ -7,27 +7,32 @@ module Legion
         module Trace
           module Helpers
             # Cache-backed store using Legion::Cache (Memcached/Redis).
-            # Keeps a local copy in memory, syncs to/from cache on load/flush.
-            # Call `flush` after a batch of writes, or it auto-flushes when dirty.
-            # Call `reload` to pull latest state from cache (e.g. after another process wrote).
+            # Each trace is stored as an individual cache key for scalability.
+            # An index key tracks all known trace IDs.
+            # Keeps a local in-memory copy for fast reads; syncs to cache on flush.
             class CacheStore
-              TRACES_KEY = 'legion:memory:traces'
-              ASSOC_KEY  = 'legion:memory:associations'
-              TTL        = 86_400 # 24 hours
+              TRACE_PREFIX = 'legion:memory:trace:'
+              INDEX_KEY    = 'legion:memory:trace_index'
+              ASSOC_KEY    = 'legion:memory:associations'
+              TTL          = 86_400 # 24 hours
+              FLUSH_BATCH  = 500    # traces per flush batch
 
               attr_reader :traces, :associations
 
               def initialize
-                Legion::Logging.info '[memory] CacheStore initialized (memcached-backed)'
-                @traces       = Legion::Cache.get(TRACES_KEY) || {}
-                @associations = Legion::Cache.get(ASSOC_KEY) || {}
-                @dirty        = false
+                Legion::Logging.info '[memory] CacheStore initialized (memcached-backed, per-key)'
+                @traces       = {}
+                @associations = {}
+                @dirty_ids    = Set.new
+                @deleted_ids  = Set.new
+                @assoc_dirty  = false
+                load_index
                 Legion::Logging.info "[memory] CacheStore loaded #{@traces.size} traces from cache"
               end
 
               def store(trace)
                 @traces[trace[:trace_id]] = trace
-                @dirty = true
+                @dirty_ids << trace[:trace_id]
                 trace[:trace_id]
               end
 
@@ -39,7 +44,9 @@ module Legion
                 @traces.delete(trace_id)
                 @associations.delete(trace_id)
                 @associations.each_value { |links| links.delete(trace_id) }
-                @dirty = true
+                @dirty_ids.delete(trace_id)
+                @deleted_ids << trace_id
+                @assoc_dirty = true
               end
 
               def retrieve_by_type(type, min_strength: 0.0, limit: 100)
@@ -77,7 +84,7 @@ module Legion
 
                 threshold = Helpers::Trace::COACTIVATION_THRESHOLD
                 link_traces(trace_id_a, trace_id_b) if @associations[trace_id_a][trace_id_b] >= threshold
-                @dirty = true
+                @assoc_dirty = true
               end
 
               def all_traces(min_strength: 0.0)
@@ -121,26 +128,81 @@ module Legion
                 results
               end
 
-              # Write local state to cache
+              # Write dirty traces to cache as individual keys
               def flush
-                return unless @dirty
-
-                Legion::Cache.set(TRACES_KEY, @traces, TTL)
-                Legion::Cache.set(ASSOC_KEY, strip_default_procs(@associations), TTL)
-                @dirty = false
-                Legion::Logging.debug "[memory] CacheStore flushed #{@traces.size} traces to cache"
+                flush_deleted
+                flush_traces
+                flush_associations
+                flush_index
+                Legion::Logging.debug "[memory] CacheStore flushed #{@dirty_ids.size} dirty traces (#{@traces.size} total)"
+                @dirty_ids.clear
+                @deleted_ids.clear
               end
 
-              # Pull latest state from cache (after another process wrote)
+              # Pull latest state from cache
               def reload
-                @traces       = Legion::Cache.get(TRACES_KEY) || {}
-                @associations = Legion::Cache.get(ASSOC_KEY) || {}
-                @dirty        = false
+                @traces.clear
+                @associations = {}
+                @dirty_ids.clear
+                @deleted_ids.clear
+                @assoc_dirty = false
+                load_index
                 Legion::Logging.debug "[memory] CacheStore reloaded #{@traces.size} traces from cache"
               end
 
               private
 
+              def trace_key(trace_id)
+                "#{TRACE_PREFIX}#{trace_id}"
+              end
+
+              def load_index
+                index = Legion::Cache.get(INDEX_KEY)
+                return unless index.is_a?(Array)
+
+                loaded = 0
+                index.each do |id|
+                  trace = Legion::Cache.get(trace_key(id))
+                  if trace
+                    @traces[id] = trace
+                    loaded += 1
+                  end
+                end
+                Legion::Logging.debug "[memory] CacheStore loaded #{loaded}/#{index.size} traces from index" if defined?(Legion::Logging)
+              rescue StandardError => e
+                Legion::Logging.warn "[memory] CacheStore load_index failed: #{e.message}" if defined?(Legion::Logging)
+              end
+
+              def flush_traces
+                return if @dirty_ids.empty?
+
+                @dirty_ids.each_slice(FLUSH_BATCH) do |batch|
+                  batch.each do |id|
+                    trace = @traces[id]
+                    Legion::Cache.set(trace_key(id), trace, TTL) if trace
+                  end
+                end
+              end
+
+              def flush_deleted
+                @deleted_ids.each do |id|
+                  Legion::Cache.delete(trace_key(id))
+                end
+              end
+
+              def flush_associations
+                return unless @assoc_dirty
+
+                Legion::Cache.set(ASSOC_KEY, strip_default_procs(@associations), TTL)
+                @assoc_dirty = false
+              end
+
+              def flush_index
+                return if @dirty_ids.empty? && @deleted_ids.empty?
+
+                Legion::Cache.set(INDEX_KEY, @traces.keys, TTL)
+              end
+
               def strip_default_procs(hash)
                 hash.each_with_object({}) do |(k, v), plain|
                   plain[k] = v.is_a?(Hash) ? {}.merge(v) : v

data/lib/legion/extensions/agentic/memory/trace.rb

@@ -47,7 +47,7 @@ module Legion
     if defined?(Legion::Data::Local)
       Legion::Data::Local.register_migrations(
         name: :memory,
-        path: File.join(__dir__, 'memory', 'local_migrations')
+        path: File.join(__dir__, 'trace', 'local_migrations')
       )
     end
   end

data/lib/legion/extensions/agentic/memory/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Memory
-        VERSION = '0.1.5'
+        VERSION = '0.1.6'
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-memory
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Esity