llmemory 0.2.1 → 0.2.3

data/lib/llmemory/cli/commands/maintain.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Llmemory
+  module Cli
+    module Commands
+      # Runs the cognitive maintenance pass for a user: reflect -> mine skills ->
+      # expire. Each step is isolated; failures are reported, not fatal.
+      class Maintain < Commands::Base
+        def option_parser(parser)
+          parser.on("--[no-]reflect", "Distill insights from recent episodes (default: on)") { |v| @reflect = v }
+          parser.on("--mine-skills", "Mine and register skills from episodes (default: config)") { @mine = true }
+          parser.on("--[no-]expire", "Soft-archive entries past their TTL (default: on)") { |v| @expire = v }
+          parser.on("--window N", Integer, "Episodes to reflect over (default 10)") { |v| @window = v }
+          parser.on("--store TYPE", "Storage type (memory|file|postgres|active_record)") { |v| @store_type = v }
+        end
+
+        def execute(argv, _opts)
+          user_id = argv.first
+          unless user_id
+            $stderr.puts "Usage: llmemory maintain USER_ID [--[no-]reflect] [--mine-skills] [--[no-]expire] [--window N] [--store TYPE]"
+            exit 1
+          end
+
+          opts = {
+            episodic: Llmemory::LongTerm::Episodic::Memory.new(user_id: user_id, storage: episodic_storage(@store_type)),
+            procedural: Llmemory::LongTerm::Procedural::Memory.new(user_id: user_id, storage: procedural_storage(@store_type)),
+            semantic: build_semantic(user_id),
+            reflect: @reflect.nil? ? true : @reflect,
+            expire: @expire.nil? ? true : @expire
+          }
+          opts[:mine_skills] = @mine unless @mine.nil?
+          opts[:reflection_window] = @window if @window
+
+          report = Llmemory::Maintenance::CognitivePass.run!(user_id, **opts)
+          print_report(user_id, report)
+        end
+
+        private
+
+        def build_semantic(user_id)
+          if Llmemory.configuration.long_term_type.to_s == "graph_based"
+            Llmemory::LongTerm::GraphBased::Memory.new(user_id: user_id, storage: graph_based_storage(@store_type))
+          else
+            Llmemory::LongTerm::FileBased::Memory.new(user_id: user_id, storage: file_based_storage(@store_type))
+          end
+        end
+
+        def print_report(user_id, report)
+          expired = report[:expired] || {}
+          puts "Cognitive pass for #{user_id}:"
+          puts "  insights:     #{Array(report[:insights]).size}"
+          puts "  skills mined: #{Array(report[:mined]).size}"
+          puts "  expired:      episodic=#{expired[:episodic] || 0} procedural=#{expired[:procedural] || 0}"
+          errors = report[:errors] || {}
+          errors.each { |step, msg| puts "  error (#{step}): #{msg}" }
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/cli/commands/mine_skills.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Llmemory
+  module Cli
+    module Commands
+      # Mines reusable skills from a user's successful episodes. Human-in-the-loop
+      # by default: prints proposals and writes nothing unless --register is given.
+      class MineSkills < Commands::Base
+        def option_parser(parser)
+          parser.on("--window N", Integer, "Episodes to mine (default 20)") { |v| @window = v }
+          parser.on("--outcomes LIST", "Comma-separated outcome allowlist (e.g. success,recovered)") { |v| @outcomes = v.split(",").map(&:strip) }
+          parser.on("--register", "Register the proposals instead of only printing them") { @register = true }
+          parser.on("--store TYPE", "Storage type (memory|file|postgres|active_record)") { |v| @store_type = v }
+        end
+
+        def execute(argv, _opts)
+          user_id = argv.first
+          unless user_id
+            $stderr.puts "Usage: llmemory mine-skills USER_ID [--window N] [--outcomes LIST] [--register] [--store TYPE]"
+            exit 1
+          end
+
+          episodic = Llmemory::LongTerm::Episodic::Memory.new(user_id: user_id, storage: episodic_storage(@store_type))
+          procedural = Llmemory::LongTerm::Procedural::Memory.new(user_id: user_id, storage: procedural_storage(@store_type))
+          result = Llmemory::SkillMining::Miner.new(episodic: episodic, procedural: procedural).mine(
+            window: @window || Llmemory::SkillMining::Miner::DEFAULT_WINDOW,
+            outcomes: @outcomes,
+            auto_register: @register
+          )
+
+          if result.empty?
+            puts "No skills could be mined for user #{user_id}."
+            return
+          end
+
+          if @register
+            puts "Registered #{result.size} mined skill(s): #{result.join(', ')}"
+          else
+            puts "#{result.size} skill proposal(s) for user #{user_id} (not registered):"
+            result.each do |p|
+              puts "  - #{p[:name]} (#{p[:kind]}, confidence: #{p[:confidence]}): #{p[:description] || p[:body]}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/cli.rb

@@ -9,6 +9,8 @@ require_relative "cli/commands/episodic"
 require_relative "cli/commands/procedural"
 require_relative "cli/commands/working"
 require_relative "cli/commands/forget_log"
+require_relative "cli/commands/mine_skills"
+require_relative "cli/commands/maintain"
 require_relative "cli/commands/stats"
 require_relative "cli/commands/search"
 require_relative "cli/commands/mcp"
@@ -55,6 +57,8 @@ module Llmemory
         "skills" => Cli::Commands::Procedural,
         "working" => Cli::Commands::Working,
         "forget_log" => Cli::Commands::ForgetLog,
+        "mine_skills" => Cli::Commands::MineSkills,
+        "maintain" => Cli::Commands::Maintain,
         "search" => Cli::Commands::Search,
         "stats" => Cli::Commands::Stats,
         "mcp" => Cli::Commands::Mcp
@@ -80,6 +84,8 @@ module Llmemory
           skills USER_ID           List registered skills (procedural memory)
           working USER_ID SESSION  Show working-memory slots for a session
           forget-log USER_ID       Show audit of forgotten entries
+          mine-skills USER_ID      Mine reusable skills from episodes (--register to save)
+          maintain USER_ID         Run the cognitive maintenance pass (reflect/mine/expire)
           search USER_ID "query"   Search in memory
           stats [USER_ID]          Show statistics
           mcp [serve]              Start MCP server for LLM agents

data/lib/llmemory/configuration.rb

@@ -45,12 +45,17 @@ module Llmemory
                   :embedding_cache_enabled,
                   :embedding_cache_max_entries,
                   :max_message_chars,
-                  :message_sanitizer_enabled
+                  :message_sanitizer_enabled,
+                  :ttl_episodic_days,
+                  :ttl_procedural_days,
+                  :skill_mining_enabled,
+                  :encryption_enabled,
+                  :encryption_key
 
     def initialize
       @llm_provider = :openai
       @llm_api_key = ENV["OPENAI_API_KEY"]
-      @llm_model = "gpt-4"
+      @llm_model = nil # falls back to the active provider's DEFAULT_MODEL
       @llm_base_url = nil
       @short_term_store = :memory
       @redis_url = ENV["REDIS_URL"] || "redis://localhost:6379/0"
@@ -59,6 +64,9 @@ module Llmemory
       @long_term_storage_path = ENV["LLMEMORY_STORAGE_PATH"] || "./llmemory_data"
       @episodic_vector_enabled = false
       @procedural_vector_enabled = false
+      @ttl_episodic_days = nil
+      @ttl_procedural_days = nil
+      @skill_mining_enabled = false
       @database_url = ENV["DATABASE_URL"]
       @vector_store = nil
       @time_decay_half_life_days = 30
@@ -92,6 +100,8 @@ module Llmemory
       @embedding_cache_max_entries = 10_000
       @max_message_chars = 32_000
       @message_sanitizer_enabled = false
+      @encryption_enabled = false
+      @encryption_key = ENV["LLMEMORY_ENCRYPTION_KEY"]
     end
   end
 
@@ -107,5 +117,21 @@ module Llmemory
     def reset_configuration!
       @configuration = Configuration.new
     end
+
+    # Builds a Crypto::Cipher when encryption is enabled and a key is present;
+    # otherwise returns Crypto::NullCipher. An explicit non-empty instance key
+    # enables encryption even when the global flag is off.
+    def build_cipher(key = nil)
+      explicit_key = !key.nil? && !key.to_s.empty?
+      resolved = key.nil? ? configuration.encryption_key : key
+      enabled = configuration.encryption_enabled || explicit_key
+      if enabled && !resolved.to_s.empty?
+        require_relative "crypto/cipher"
+        Crypto::Cipher.new(resolved)
+      else
+        require_relative "crypto/cipher"
+        Crypto::NullCipher.new
+      end
+    end
   end
 end

data/lib/llmemory/crypto/cipher.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "json"
+
+module Llmemory
+  module Crypto
+    class DecryptionError < Llmemory::Error; end
+
+    # No-op cipher when encryption is disabled or no key is configured.
+    class NullCipher
+      def enabled?
+        false
+      end
+
+      def encrypt(str)
+        str.to_s
+      end
+
+      def encrypt_deterministic(str)
+        str.to_s
+      end
+
+      def decrypt(str)
+        str.to_s
+      end
+
+      def encrypt_json(obj)
+        JSON.generate(obj)
+      end
+
+      def decrypt_json(str)
+        JSON.parse(str.to_s, symbolize_names: true)
+      end
+
+      def encrypted?(str)
+        false
+      end
+    end
+
+    # AES-256-GCM encryption with separate content (random IV) and index
+    # (deterministic IV) subkeys derived from the master key via HMAC-SHA256.
+    class Cipher
+      MARKER = "enc:v1:"
+      DETERMINISTIC_MARKER = "encd:v1:"
+      IV_LENGTH = 12
+      TAG_LENGTH = 16
+
+      def initialize(key)
+        @master_key = derive_master_key(key)
+        @content_key = derive_subkey("content")
+        @index_key = derive_subkey("index")
+      end
+
+      def enabled?
+        true
+      end
+
+      def encrypt(plaintext)
+        str = plaintext.to_s
+        return str if str.empty?
+
+        encrypt_with_key(str, @content_key, iv: OpenSSL::Random.random_bytes(IV_LENGTH), marker: MARKER)
+      end
+
+      def encrypt_deterministic(plaintext)
+        str = plaintext.to_s
+        return str if str.empty?
+
+        iv = OpenSSL::HMAC.digest("SHA256", @index_key, str)[0, IV_LENGTH]
+        encrypt_with_key(str, @index_key, iv: iv, marker: DETERMINISTIC_MARKER)
+      end
+
+      def decrypt(ciphertext)
+        str = ciphertext.to_s
+        return str if str.empty?
+        return str unless encrypted?(str)
+
+        marker, key = if str.start_with?(DETERMINISTIC_MARKER)
+          [DETERMINISTIC_MARKER, @index_key]
+        else
+          [MARKER, @content_key]
+        end
+
+        payload = decode64(str.delete_prefix(marker))
+        iv = payload[0, IV_LENGTH]
+        tag = payload[IV_LENGTH, TAG_LENGTH]
+        ct = payload[(IV_LENGTH + TAG_LENGTH)..]
+
+        cipher = OpenSSL::Cipher.new("aes-256-gcm")
+        cipher.decrypt
+        cipher.key = key
+        cipher.iv = iv
+        cipher.auth_tag = tag
+        cipher.auth_data = ""
+        cipher.update(ct) + cipher.final
+      rescue OpenSSL::Cipher::CipherError, ArgumentError => e
+        raise DecryptionError, "Failed to decrypt data: #{e.message}"
+      end
+
+      def encrypt_json(obj)
+        encrypt(JSON.generate(obj))
+      end
+
+      def decrypt_json(str)
+        JSON.parse(decrypt(str), symbolize_names: true)
+      end
+
+      def encrypted?(str)
+        s = str.to_s
+        s.start_with?(MARKER) || s.start_with?(DETERMINISTIC_MARKER)
+      end
+
+      private
+
+      def encrypt_with_key(plaintext, key, iv:, marker:)
+        cipher = OpenSSL::Cipher.new("aes-256-gcm")
+        cipher.encrypt
+        cipher.key = key
+        cipher.iv = iv
+        cipher.auth_data = ""
+        ct = cipher.update(plaintext) + cipher.final
+        tag = cipher.auth_tag
+        marker + encode64(iv + tag + ct)
+      end
+
+      def encode64(bin)
+        [bin].pack("m0")
+      end
+
+      def decode64(str)
+        str.unpack1("m0")
+      end
+
+      def derive_master_key(key)
+        raw = key.to_s
+        raise ConfigurationError, "encryption_key cannot be empty when encryption is enabled" if raw.empty?
+
+        OpenSSL::Digest::SHA256.digest(raw)
+      end
+
+      def derive_subkey(label)
+        OpenSSL::HMAC.digest("SHA256", @master_key, "llmemory:#{label}")[0, 32]
+      end
+    end
+  end
+end

data/lib/llmemory/crypto/field_helpers.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Llmemory
+  module Crypto
+    # Shared encrypt/decrypt helpers for storage backends.
+    module FieldHelpers
+      private
+
+      def cipher
+        @cipher || Llmemory.build_cipher
+      end
+
+      def enc(str)
+        return str if str.nil?
+        return str.to_s unless cipher.enabled?
+
+        cipher.encrypt(str.to_s)
+      end
+
+      def dec(str)
+        return str if str.nil?
+        return str unless str.is_a?(String) && cipher.encrypted?(str)
+
+        cipher.decrypt(str)
+      end
+
+      def enc_det(str)
+        return str if str.nil?
+        return str.to_s unless cipher.enabled?
+
+        cipher.encrypt_deterministic(str.to_s)
+      end
+
+      def enc_json(obj)
+        return obj if obj.nil?
+        return obj unless cipher.enabled?
+
+        cipher.encrypt_json(obj)
+      end
+
+      def dec_json(value)
+        return value if value.nil?
+        return value.transform_keys(&:to_sym) if value.is_a?(Hash)
+        return value unless value.is_a?(String) && cipher.encrypted?(value)
+
+        cipher.decrypt_json(value)
+      end
+
+      def write_encrypted_file(path, data)
+        payload = JSON.generate(data)
+        File.write(path, cipher.enabled? ? cipher.encrypt(payload) : payload)
+      end
+
+      def read_encrypted_file(path)
+        raw = File.read(path)
+        json = cipher.enabled? && cipher.encrypted?(raw) ? cipher.decrypt(raw) : raw
+        JSON.parse(json, symbolize_names: true)
+      end
+
+      def write_encrypted_text_file(path, content, append: false)
+        text = content.to_s
+        if cipher.enabled?
+          if append && File.file?(path)
+            existing = read_encrypted_text_file(path)
+            text = existing + text
+          end
+          File.write(path, cipher.encrypt(text))
+        elsif append && File.file?(path)
+          File.write(path, File.read(path) + text)
+        else
+          File.write(path, text)
+        end
+      end
+
+      def read_encrypted_text_file(path)
+        raw = File.read(path)
+        cipher.enabled? && cipher.encrypted?(raw) ? cipher.decrypt(raw) : raw
+      end
+
+      def serialize_state(state)
+        json = JSON.generate(state)
+        return json unless cipher.enabled?
+
+        cipher.encrypt(json)
+      end
+
+      def deserialize_state(data)
+        if data.is_a?(Hash)
+          return data.transform_keys(&:to_sym)
+        end
+
+        str = data.to_s
+        json = cipher.enabled? && cipher.encrypted?(str) ? cipher.decrypt(str) : str
+        JSON.parse(json, symbolize_names: true)
+      end
+
+      def parse_provenance(value)
+        return nil if value.nil?
+        return value.transform_keys(&:to_sym) if value.is_a?(Hash)
+        return dec_json(value) if value.is_a?(String) && cipher.encrypted?(value)
+
+        JSON.parse(value.to_s, symbolize_names: true)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/llmemory/instrumentation.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Llmemory
+  # Lightweight instrumentation seam. When ActiveSupport::Notifications is
+  # available (Rails apps, opt-in elsewhere), events are published with the
+  # `.llmemory` suffix so subscribers can hook into LLM calls, retrieval,
+  # writes and forgets for metrics, traces or cost dashboards. When AS is not
+  # loaded, the block is yielded transparently and no event is emitted.
+  #
+  # Events (payload keys are best-effort; subscribers should treat them as
+  # optional):
+  #
+  #   llm_invoke.llmemory       provider:, model:, prompt_chars:, response_chars:
+  #   llm_embed.llmemory        provider:, model:, text_chars:, dimensions:
+  #   memory_write.llmemory     memory_type:, user_id:
+  #   memory_forget.llmemory    memory_type:, user_id:, count:
+  #   retrieve.llmemory         query_chars:, candidates:, results:
+  #   iterative_retrieve.llmemory  hops:, total_results:
+  #   reflect.llmemory          window:, insights:
+  #   mine_skills.llmemory      window:, auto_register:
+  module Instrumentation
+    module_function
+
+    def instrument(event, payload = {})
+      name = "#{event}.llmemory"
+      if defined?(ActiveSupport::Notifications)
+        ActiveSupport::Notifications.instrument(name, payload) { yield if block_given? }
+      else
+        yield if block_given?
+      end
+    end
+  end
+end

data/lib/llmemory/llm/anthropic.rb

@@ -8,30 +8,35 @@ module Llmemory
   module LLM
     class Anthropic < Base
       DEFAULT_BASE_URL = "https://api.anthropic.com"
+      DEFAULT_MODEL = "claude-sonnet-4-6"
 
       def initialize(api_key: nil, model: nil, base_url: nil)
         @api_key = api_key || config.llm_api_key || ENV["ANTHROPIC_API_KEY"]
-        @model = model || config.llm_model || "claude-3-sonnet-20240229"
+        @model = model || config.llm_model || DEFAULT_MODEL
         @base_url = base_url || config.llm_base_url || DEFAULT_BASE_URL
       end
 
       def invoke(prompt)
-        response = connection.post("v1/messages") do |req|
-          req.body = {
-            model: @model,
-            max_tokens: 1024,
-            messages: [{ role: "user", content: prompt }]
-          }.to_json
-          req.headers["Content-Type"] = "application/json"
-          req.headers["x-api-key"] = @api_key
-          req.headers["anthropic-version"] = "2023-06-01"
+        result = nil
+        Llmemory::Instrumentation.instrument(:llm_invoke, provider: :anthropic, model: @model, prompt_chars: prompt.to_s.length) do
+          response = connection.post("v1/messages") do |req|
+            req.body = {
+              model: @model,
+              max_tokens: 1024,
+              messages: [{ role: "user", content: prompt }]
+            }.to_json
+            req.headers["Content-Type"] = "application/json"
+            req.headers["x-api-key"] = @api_key
+            req.headers["anthropic-version"] = "2023-06-01"
+          end
+
+          raise Llmemory::LLMError, "Anthropic API error: #{response.body}" unless response.success?
+
+          body = response.body.is_a?(Hash) ? response.body : JSON.parse(response.body.to_s)
+          content = body.dig("content", 0, "text")
+          result = content&.strip || ""
         end
-
-        raise Llmemory::LLMError, "Anthropic API error: #{response.body}" unless response.success?
-
-        body = response.body.is_a?(Hash) ? response.body : JSON.parse(response.body.to_s)
-        content = body.dig("content", 0, "text")
-        content&.strip || ""
+        result
       end
 
       private

data/lib/llmemory/llm/openai.rb

@@ -8,28 +8,33 @@ module Llmemory
   module LLM
     class OpenAI < Base
       DEFAULT_BASE_URL = "https://api.openai.com/v1"
+      DEFAULT_MODEL = "gpt-4"
 
       def initialize(api_key: nil, model: nil, base_url: nil)
         @api_key = api_key || config.llm_api_key
-        @model = model || config.llm_model
+        @model = model || config.llm_model || DEFAULT_MODEL
         @base_url = base_url || config.llm_base_url || DEFAULT_BASE_URL
       end
 
       def invoke(prompt)
-        response = connection.post("chat/completions") do |req|
-          req.body = {
-            model: @model,
-            messages: [{ role: "user", content: prompt }],
-            temperature: 0.3
-          }.to_json
-          req.headers["Content-Type"] = "application/json"
-          req.headers["Authorization"] = "Bearer #{@api_key}"
-        end
+        result = nil
+        Llmemory::Instrumentation.instrument(:llm_invoke, provider: :openai, model: @model, prompt_chars: prompt.to_s.length) do
+          response = connection.post("chat/completions") do |req|
+            req.body = {
+              model: @model,
+              messages: [{ role: "user", content: prompt }],
+              temperature: 0.3
+            }.to_json
+            req.headers["Content-Type"] = "application/json"
+            req.headers["Authorization"] = "Bearer #{@api_key}"
+          end
 
-        raise Llmemory::LLMError, "OpenAI API error: #{response.body}" unless response.success?
+          raise Llmemory::LLMError, "OpenAI API error: #{response.body}" unless response.success?
 
-        body = response.body.is_a?(Hash) ? response.body : JSON.parse(response.body.to_s)
-        body.dig("choices", 0, "message", "content")&.strip || ""
+          body = response.body.is_a?(Hash) ? response.body : JSON.parse(response.body.to_s)
+          result = body.dig("choices", 0, "message", "content")&.strip || ""
+        end
+        result
       end
 
       # Calls the model with response_format json_schema (Structured Outputs).

data/lib/llmemory/long_term/episodic/memory.rb

@@ -21,9 +21,10 @@ module Llmemory
 
         attr_reader :user_id, :storage
 
-        def initialize(user_id:, storage: nil, vector_store: nil)
+        def initialize(user_id:, storage: nil, vector_store: nil, cipher: nil)
           @user_id = user_id
-          @storage = storage || Storages.build
+          @cipher = cipher || Llmemory.build_cipher
+          @storage = storage || Storages.build(cipher: @cipher)
           @vector_store = vector_store
           @vector_explicit = !vector_store.nil?
         end
@@ -52,8 +53,8 @@ module Llmemory
           @storage.list_episodes(@user_id, limit: limit).map { |e| Episode.from_h(e) }
         end
 
-        def episodes(limit: nil)
-          @storage.list_episodes(@user_id, limit: limit).map { |e| Episode.from_h(e) }
+        def episodes(limit: nil, offset: nil)
+          @storage.list_episodes(@user_id, limit: limit, offset: offset).map { |e| Episode.from_h(e) }
         end
 
         def find_episode(id)
@@ -84,24 +85,37 @@ module Llmemory
         # --- MemoryModule uniform interface ---
 
         def write(steps:, summary: nil, outcome: nil, importance: 0.5, **_meta)
-          record_episode(steps: steps, summary: summary, outcome: outcome, importance: importance)
+          result = nil
+          Llmemory::Instrumentation.instrument(:memory_write, memory_type: "episodic", user_id: @user_id) do
+            result = record_episode(steps: steps, summary: summary, outcome: outcome, importance: importance)
+          end
+          result
         end
 
-        def list(user_id: nil, limit: nil)
-          episodes(limit: limit)
+        def list(user_id: nil, limit: nil, offset: nil)
+          episodes(limit: limit, offset: offset)
         end
 
         def stats(user_id: nil)
           { episodes: count }
         end
 
-        def forget(ids:, reason: nil)
+        def forget(ids:, reason: nil, mode: :soft)
           requested = Array(ids).map(&:to_s)
           existing = @storage.list_episodes(@user_id).map { |e| (e[:id] || e["id"]).to_s }
-          removed = requested & existing
-          @storage.delete_episodes(@user_id, removed)
-          forget_log.record(@user_id, memory_type: "episodic", ids: removed, reason: reason)
-          removed.size
+          targeted = requested & existing
+          count = case mode
+          when :hard then @storage.delete_episodes(@user_id, targeted).to_i
+          else @storage.archive_episodes(@user_id, targeted).to_i
+          end
+          forget_log.record(@user_id, memory_type: "episodic", ids: targeted, reason: reason)
+          Llmemory::Instrumentation.instrument(:memory_forget, memory_type: "episodic", user_id: @user_id, count: count, mode: mode)
+          count
+        end
+
+        # Storage accessor for the TTL maintenance job.
+        def expired_ids(cutoff:)
+          @storage.expired_episode_ids(@user_id, cutoff: cutoff)
         end
 
         private
@@ -112,7 +126,7 @@ module Llmemory
           if @vector_explicit
             @vector_store
           elsif Llmemory.configuration.episodic_vector_enabled
-            @vector_store ||= Llmemory::VectorStore.build(source_type: "episode")
+            @vector_store ||= Llmemory::VectorStore.build(source_type: "episode", cipher: @cipher)
           end
         end