llmemory 0.1.12 → 0.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33ff7cbff0694be426fa937233f3429688759f595e7522a0bc3c22aa9dcb6214
-  data.tar.gz: 53ccabdcd6706037e63574bf97cd575bf5310c1cde96dd794e83d38ec0ed3606
+  metadata.gz: 3bdfe8a5f7301af319a99e853c36646491cdc64c581b566811605fb4e63415dd
+  data.tar.gz: 27d827d262c35f3e42757416895fe91ad84290032f0091dbfd7a24806da5cf73
 SHA512:
-  metadata.gz: 463b3028747f9ff47b9949325d7461b41ad231c0798801269b0f083c96455eb347714f6fc6fb5e96fdede30897b8753e46d514944f2ecf3fc097ccd719b637e1
-  data.tar.gz: dcd0da448d5b2ad4e686552b7cb9271fac36b58882cf3fd97761effde76851f4c193b1edbc8f50e46f1289499b4fe2c24cb06f6ba3093cab6a8e731982e60225
+  metadata.gz: 72337abbc9bd02e9289a9b4dad399741f066fc9dbaf01cd2fa8de80813f4042c8939313afb7aa248addf02ade1cdae379a93585618200f96c3e2d0dbafef9138
+  data.tar.gz: 263872146fb6654ecfef977b7a7075798b6439e06405eeb512ff48b67c7294387eb963421cbffed1fecf0e4863f7bfc82b0d6f88f3e92eb8cc06898d587c50b2

data/README.md

@@ -33,6 +33,9 @@ context = memory.retrieve("¿Qué preferencias tiene el usuario?", max_tokens: 2
 # Optionally consolidate current conversation into long-term (extract facts)
 memory.consolidate!
 
+# Compact short-term memory when it gets too large (summarizes old messages)
+memory.compact!(max_bytes: 8192)  # or use config default
+
 # Clear session (short-term) while keeping long-term intact
 memory.clear_session!
 ```
@@ -41,6 +44,7 @@ memory.clear_session!
 - **`messages`** — Returns the current conversation history.
 - **`retrieve(query, max_tokens: nil)`** — Returns combined context: recent conversation + relevant long-term memories.
 - **`consolidate!`** — Extracts facts from the current conversation and stores them in long-term.
+- **`compact!(max_bytes: nil)`** — Compacts short-term memory by summarizing old messages when byte size exceeds limit. Uses LLM to create a summary, keeping recent messages intact.
 - **`clear_session!`** — Clears short-term only.
 
 ## Configuration
@@ -59,6 +63,7 @@ Llmemory.configure do |config|
   config.time_decay_half_life_days = 30
   config.max_retrieval_tokens = 2000
   config.prune_after_days = 90
+  config.compact_max_bytes = 8192  # max bytes before compact! triggers
 end
 ```
 

data/lib/llmemory/configuration.rb

@@ -15,7 +15,25 @@ module Llmemory
                   :vector_store,
                   :time_decay_half_life_days,
                   :max_retrieval_tokens,
-                  :prune_after_days
+                  :prune_after_days,
+                  :compact_max_bytes,
+                  :memory_flush_enabled,
+                  :memory_flush_threshold_tokens,
+                  :hybrid_search_enabled,
+                  :bm25_weight,
+                  :mmr_enabled,
+                  :mmr_lambda,
+                  :prune_tool_results_enabled,
+                  :prune_tool_results_mode,
+                  :prune_tool_results_max_bytes,
+                  :context_window_tokens,
+                  :reserve_tokens,
+                  :keep_recent_tokens,
+                  :session_idle_minutes,
+                  :session_prune_after_days,
+                  :session_max_entries_per_user,
+                  :daily_logs_enabled,
+                  :auto_recall_enabled
 
     def initialize
       @llm_provider = :openai
@@ -32,6 +50,24 @@ module Llmemory
       @time_decay_half_life_days = 30
       @max_retrieval_tokens = 2000
       @prune_after_days = 90
+      @compact_max_bytes = 8192
+      @memory_flush_enabled = true
+      @memory_flush_threshold_tokens = 4000
+      @hybrid_search_enabled = true
+      @bm25_weight = 0.3
+      @mmr_enabled = false
+      @mmr_lambda = 0.7
+      @prune_tool_results_enabled = false
+      @prune_tool_results_mode = :soft_trim
+      @prune_tool_results_max_bytes = 2048
+      @context_window_tokens = 128_000
+      @reserve_tokens = 16_384
+      @keep_recent_tokens = 20_000
+      @session_idle_minutes = 60
+      @session_prune_after_days = 30
+      @session_max_entries_per_user = 500
+      @daily_logs_enabled = false
+      @auto_recall_enabled = false
     end
   end
 

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

@@ -18,6 +18,7 @@ module Llmemory
 
         def memorize(conversation_text)
           resource_id = save_resource(conversation_text)
+          append_to_daily_log(conversation_text) if Llmemory.configuration.daily_logs_enabled && @storage.respond_to?(:save_daily_log_entry)
           items = @extractor.extract_items(conversation_text)
           updates_by_category = {}
 
@@ -47,6 +48,7 @@ module Llmemory
           uid = user_id || @user_id
           items = @storage.search_items(uid, query)
           resources = @storage.search_resources(uid, query)
+          daily_logs = load_daily_logs_for_retrieval(uid) if Llmemory.configuration.daily_logs_enabled && @storage.respond_to?(:load_daily_logs)
           out = []
           items.first(top_k).each do |i|
             out << {
@@ -62,6 +64,11 @@ module Llmemory
               score: 0.9
             }
           end
+          if daily_logs
+            daily_logs.each do |log|
+              out << { text: log[:content], timestamp: log[:date].to_time, score: 0.85 }
+            end
+          end
           out
         end
 
@@ -77,6 +84,18 @@ module Llmemory
           content = item.is_a?(Hash) ? item["content"] || item[:content] : item.to_s
           @storage.save_item(@user_id, category: category, content: content, source_resource_id: source_resource_id)
         end
+
+        def append_to_daily_log(conversation_text)
+          summary = conversation_text.length > 500 ? "#{conversation_text[0..500]}..." : conversation_text
+          @storage.save_daily_log_entry(@user_id, Date.today, summary)
+        end
+
+        def load_daily_logs_for_retrieval(user_id)
+          today = Date.today
+          yesterday = today - 1
+          logs = @storage.load_daily_logs(user_id, from_date: yesterday, to_date: today)
+          logs.map { |l| { date: l[:date], content: "[#{l[:date]}] #{l[:content]}" } }
+        end
       end
     end
   end

data/lib/llmemory/long_term/file_based/storages/file_storage.rb

@@ -124,6 +124,29 @@ module Llmemory
             resource_ids.each { |id| File.delete(resource_path(user_id, id)) if File.file?(resource_path(user_id, id)) }
           end
 
+          def save_daily_log_entry(user_id, date, content)
+            ensure_user_dir(user_id, "memory")
+            path = daily_log_path(user_id, date)
+            existing = File.file?(path) ? File.read(path) : ""
+            entry = "#{Time.now.strftime('%H:%M')} #{content}\n"
+            File.write(path, existing + entry)
+            true
+          end
+
+          def load_daily_logs(user_id, from_date:, to_date:)
+            from_date = Date.parse(from_date.to_s) if from_date.is_a?(String)
+            to_date = Date.parse(to_date.to_s) if to_date.is_a?(String)
+            dir = user_path(user_id, "memory")
+            return [] unless Dir.exist?(dir)
+
+            (from_date..to_date).filter_map do |d|
+              path = daily_log_path(user_id, d)
+              next unless File.file?(path)
+
+              { date: d, content: File.read(path) }
+            end
+          end
+
           def list_users
             return [] unless Dir.exist?(@base_path)
             Dir.children(@base_path).select { |e| File.directory?(File.join(@base_path, e)) && !e.start_with?(".") }
@@ -162,6 +185,11 @@ module Llmemory
             File.join(user_path(user_id, "items"), "#{id}.json")
           end
 
+          def daily_log_path(user_id, date)
+            date_str = date.respond_to?(:strftime) ? date.strftime("%Y-%m-%d") : date.to_s
+            File.join(user_path(user_id, "memory"), "#{date_str}.md")
+          end
+
           def category_path(user_id, category_name)
             safe = category_name.to_s.gsub(%r{[^\w\-.]}, "_")
             File.join(user_path(user_id, "categories"), "#{safe}.md")

data/lib/llmemory/mcp/tools/memory_add_message.rb

@@ -10,7 +10,7 @@ module Llmemory
           properties: {
             user_id: { type: "string", description: "User identifier" },
             session_id: { type: "string", description: "Session identifier (default: 'default')" },
-            role: { type: "string", enum: ["user", "assistant", "system"], description: "Message role" },
+            role: { type: "string", enum: ["user", "assistant", "system", "tool", "tool_result"], description: "Message role" },
             content: { type: "string", description: "Message content" }
           },
           required: ["user_id", "role", "content"]

data/lib/llmemory/memory.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "short_term/checkpoint"
+require_relative "short_term/pruner"
 require_relative "long_term/file_based"
 require_relative "retrieval/engine"
 
@@ -34,11 +35,42 @@ module Llmemory
     end
 
     def retrieve(query, max_tokens: nil)
-      short_context = format_short_term_context(messages)
+      msgs = pruned_messages
+      short_context = format_short_term_context(msgs)
       long_context = @retrieval_engine.retrieve_for_inference(query, user_id: @user_id, max_tokens: max_tokens)
       combine_contexts(short_context, long_context)
     end
 
+    def recall_for(query: nil, max_tokens: nil)
+      return "" unless Llmemory.configuration.auto_recall_enabled
+
+      effective_query = query || last_user_message
+      return "" if effective_query.to_s.strip.empty?
+
+      retrieve(effective_query, max_tokens: max_tokens)
+    end
+
+    def last_user_message
+      msgs = messages
+      idx = msgs.rindex { |m| (m[:role] || m["role"]).to_s == "user" }
+      idx ? (msgs[idx][:content] || msgs[idx]["content"]).to_s : ""
+    end
+
+    def prune!(mode: nil)
+      return false unless Llmemory.configuration.prune_tool_results_enabled
+
+      msgs = messages
+      return false if msgs.empty?
+
+      mode ||= Llmemory.configuration.prune_tool_results_mode
+      pruner = ShortTerm::Pruner.new(
+        soft_trim_max_bytes: Llmemory.configuration.prune_tool_results_max_bytes
+      )
+      pruned = pruner.prune!(msgs, mode: mode)
+      save_state(messages: pruned)
+      true
+    end
+
     def consolidate!
       msgs = messages
       return true if msgs.empty?
@@ -52,12 +84,133 @@ module Llmemory
       true
     end
 
+    def compact!(max_bytes: nil)
+      max = max_bytes || Llmemory.configuration.compact_max_bytes
+      msgs = messages
+      current_bytes = messages_byte_size(msgs)
+      return false if current_bytes <= max
+
+      flush_memory_before_compaction!(msgs)
+
+      old_msgs, recent_msgs = split_messages_by_bytes(msgs, max)
+      return false if old_msgs.empty?
+
+      summary = summarize_messages(old_msgs)
+      compacted = [{ role: :system, content: summary }] + recent_msgs
+      save_state(messages: compacted)
+      true
+    end
+
+    def maybe_flush_memory!
+      return false unless Llmemory.configuration.memory_flush_enabled
+      msgs = messages
+      return false if msgs.empty?
+      return false if estimated_tokens(msgs) < Llmemory.configuration.memory_flush_threshold_tokens
+
+      consolidate!
+    end
+
+    def context_tokens
+      estimated_tokens(messages)
+    end
+
+    def should_auto_consolidate?
+      ctx = context_tokens
+      threshold = Llmemory.configuration.context_window_tokens - Llmemory.configuration.reserve_tokens
+      ctx >= threshold
+    end
+
+    def should_compact?
+      ctx = context_tokens
+      threshold = Llmemory.configuration.context_window_tokens - Llmemory.configuration.reserve_tokens
+      ctx >= threshold
+    end
+
+    def check_context_window!
+      return false if messages.empty?
+
+      flushed = false
+      if should_auto_consolidate? && Llmemory.configuration.memory_flush_enabled
+        consolidate!
+        flushed = true
+      end
+
+      compacted = false
+      if should_compact?
+        compacted = compact!
+      end
+
+      flushed || compacted
+    end
+
     def user_id
       @user_id
     end
 
     private
 
+    def summarize_messages(msgs)
+      conversation = msgs.map { |m| format_message(m) }.join("\n")
+      prompt = <<~PROMPT
+        Summarize the following conversation into a concise summary that preserves key information, decisions, and context. Write it as a brief narrative (max 200 words).
+
+        Conversation:
+        #{conversation}
+
+        Summary:
+      PROMPT
+      llm_client.invoke(prompt.strip).to_s.strip
+    rescue Llmemory::LLMError
+      msgs.map { |m| format_message(m) }.join("\n")[0..500]
+    end
+
+    def llm_client
+      @llm ||= Llmemory::LLM.client
+    end
+
+    def flush_memory_before_compaction!(msgs)
+      return unless Llmemory.configuration.memory_flush_enabled
+      return if msgs.empty?
+      return if estimated_tokens(msgs) < Llmemory.configuration.memory_flush_threshold_tokens
+
+      consolidate!
+    end
+
+    def estimated_tokens(msgs)
+      (messages_byte_size(msgs) / 4.0).ceil
+    end
+
+    def messages_byte_size(msgs)
+      msgs.sum { |m| message_byte_size(m) }
+    end
+
+    def message_byte_size(msg)
+      role = msg[:role] || msg["role"]
+      content = msg[:content] || msg["content"]
+      role.to_s.bytesize + content.to_s.bytesize
+    end
+
+    def split_messages_by_bytes(msgs, max_bytes)
+      target_recent_bytes = max_bytes / 2
+      recent_bytes = 0
+      split_index = msgs.size
+
+      (msgs.size - 1).downto(0) do |i|
+        msg_bytes = message_byte_size(msgs[i])
+        if recent_bytes + msg_bytes <= target_recent_bytes
+          recent_bytes += msg_bytes
+          split_index = i
+        else
+          break
+        end
+      end
+
+      split_index = [split_index, msgs.size - 1].min
+      split_index = [split_index, 1].max if msgs.size > 1
+
+      [msgs[0...split_index], msgs[split_index..]]
+    end
+
     def build_long_term(long_term_type)
       llm_opts = @llm ? { llm: @llm } : {}
       case long_term_type.to_s.to_sym
@@ -73,7 +226,17 @@ module Llmemory
     end
 
     def save_state(messages:)
-      @checkpoint.save_state(STATE_KEY_MESSAGES => messages)
+      state = { STATE_KEY_MESSAGES => messages, last_activity_at: Time.now }
+      @checkpoint.save_state(state)
+    end
+
+    def pruned_messages
+      return messages unless Llmemory.configuration.prune_tool_results_enabled
+
+      pruner = ShortTerm::Pruner.new(
+        soft_trim_max_bytes: Llmemory.configuration.prune_tool_results_max_bytes
+      )
+      pruner.prune!(messages, mode: Llmemory.configuration.prune_tool_results_mode)
     end
 
     def format_short_term_context(msgs)

data/lib/llmemory/retrieval/bm25_scorer.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module Retrieval
+    class Bm25Scorer
+      K1 = 1.5
+      B = 0.75
+
+      def initialize(k1: K1, b: B)
+        @k1 = k1
+        @b = b
+      end
+
+      def score_candidates(query, candidates)
+        return [] if candidates.empty?
+
+        query_tokens = tokenize(query)
+        return candidates.map { |c| c.merge(bm25_score: 0.0, normalized_bm25: 0.0) } if query_tokens.empty?
+
+        doc_tokens_list = candidates.map { |c| tokenize((c[:text] || c["text"]).to_s) }
+        avg_doc_len = doc_tokens_list.map(&:size).sum.to_f / [doc_tokens_list.size, 1].max
+        n_docs = candidates.size
+
+        doc_freq = Hash.new(0)
+        doc_tokens_list.each do |tokens|
+          tokens.uniq.each { |t| doc_freq[t] += 1 }
+        end
+
+        candidates.each_with_index.map do |c, i|
+          doc_tokens = doc_tokens_list[i]
+          doc_len = doc_tokens.size
+          bm25 = 0.0
+
+          query_tokens.uniq.each do |term|
+            tf = doc_tokens.count(term)
+            next if tf.zero?
+
+            n_qi = doc_freq[term]
+            idf = Math.log((n_docs - n_qi + 0.5) / (n_qi + 0.5) + 1.0)
+            numerator = tf * (@k1 + 1)
+            denom = tf + @k1 * (1 - @b + @b * doc_len.to_f / [avg_doc_len, 1].max)
+            bm25 += idf * numerator / denom
+          end
+
+          c.merge(bm25_score: bm25)
+        end.tap do |scored|
+          max_bm25 = scored.map { |s| s[:bm25_score] }.max.to_f
+          max_bm25 = 1.0 if max_bm25.zero?
+          scored.each { |s| s[:normalized_bm25] = s[:bm25_score] / max_bm25 }
+        end
+      end
+
+      private
+
+      def tokenize(text)
+        text.to_s.downcase.scan(/\b[a-z0-9]{2,}\b/)
+      end
+    end
+  end
+end

data/lib/llmemory/retrieval/engine.rb

@@ -2,6 +2,8 @@
 
 require_relative "temporal_ranker"
 require_relative "context_assembler"
+require_relative "bm25_scorer"
+require_relative "mmr_reranker"
 
 module Llmemory
   module Retrieval
@@ -13,15 +15,19 @@ module Llmemory
         @llm = llm || Llmemory::LLM.client
         @ranker = TemporalRanker.new
         @assembler = ContextAssembler.new
+        @bm25_scorer = Bm25Scorer.new
+        @mmr_reranker = MmrReranker.new(lambda: Llmemory.configuration.mmr_lambda)
       end
 
       def retrieve_for_inference(user_message, user_id: nil, max_tokens: nil)
         user_id ||= @memory.respond_to?(:user_id) ? @memory.user_id : nil
         search_query = generate_query(user_message)
         candidates = fetch_candidates(search_query, user_id)
+        candidates = apply_hybrid_scoring(candidates, search_query) if Llmemory.configuration.hybrid_search_enabled
 
         relevant = filter_by_relevance(candidates, user_message)
         ranked = @ranker.rank(relevant)
+        ranked = @mmr_reranker.rerank(ranked) if Llmemory.configuration.mmr_enabled
         @assembler.assemble(ranked, max_tokens: max_tokens)
       end
 
@@ -58,6 +64,21 @@ module Llmemory
         Time.now
       end
 
+      def apply_hybrid_scoring(candidates, query)
+        return candidates if candidates.empty?
+
+        scored = @bm25_scorer.score_candidates(query, candidates)
+        weight = Llmemory.configuration.bm25_weight.to_f
+        weight = 0.3 if weight < 0 || weight > 1
+
+        scored.map do |c|
+          vector_score = (c[:score] || c["score"] || 1.0).to_f
+          bm25_norm = (c[:normalized_bm25] || 0).to_f
+          hybrid = weight * bm25_norm + (1 - weight) * vector_score
+          c.merge(score: hybrid)
+        end
+      end
+
       def filter_by_relevance(candidates, user_message)
         return candidates if candidates.size <= 5
         user_lower = user_message.to_s.downcase

data/lib/llmemory/retrieval/mmr_reranker.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module Retrieval
+    class MmrReranker
+      def initialize(lambda: 0.7)
+        @lambda = lambda
+      end
+
+      def rerank(candidates, score_key: :temporal_score)
+        return candidates if candidates.size <= 1
+
+        selected = []
+        remaining = candidates.dup
+
+        while remaining.any?
+          best_idx = nil
+          best_mmr = -Float::INFINITY
+
+          remaining.each_with_index do |cand, i|
+            rel = (cand[score_key] || cand[score_key.to_s] || cand[:score] || cand["score"] || 0).to_f
+            max_sim = selected.map { |s| similarity(cand, s) }.max || 0
+            mmr = @lambda * rel - (1 - @lambda) * max_sim
+
+            if mmr > best_mmr
+              best_mmr = mmr
+              best_idx = i
+            end
+          end
+
+          break unless best_idx
+
+          selected << remaining.delete_at(best_idx)
+        end
+
+        selected
+      end
+
+      private
+
+      def similarity(a, b)
+        text_a = tokenize((a[:text] || a["text"]).to_s)
+        text_b = tokenize((b[:text] || b["text"]).to_s)
+        return 0.0 if text_a.empty? || text_b.empty?
+
+        intersection = (text_a & text_b).size
+        union = (text_a | text_b).size
+        union.zero? ? 0.0 : intersection.to_f / union
+      end
+
+      def tokenize(text)
+        text.downcase.scan(/\b[a-z0-9]{2,}\b/).uniq
+      end
+    end
+  end
+end

data/lib/llmemory/short_term/pruner.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module ShortTerm
+    class Pruner
+      DEFAULT_PRUNABLE_ROLES = %i[tool tool_result].freeze
+      PLACEHOLDER = "[Tool result pruned]"
+
+      def initialize(prunable_roles: nil, soft_trim_max_bytes: 2048, soft_trim_head_ratio: 0.4, soft_trim_tail_ratio: 0.2)
+        @prunable_roles = prunable_roles || DEFAULT_PRUNABLE_ROLES.map(&:to_s)
+        @soft_trim_max_bytes = soft_trim_max_bytes
+        @head_ratio = soft_trim_head_ratio
+        @tail_ratio = soft_trim_tail_ratio
+      end
+
+      def prune!(messages, mode: :soft_trim)
+        return messages.dup if messages.empty?
+
+        messages.map do |msg|
+          if prunable?(msg)
+            apply_prune(msg, mode)
+          else
+            msg.dup
+          end
+        end
+      end
+
+      private
+
+      def prunable?(msg)
+        role = (msg[:role] || msg["role"]).to_s
+        @prunable_roles.include?(role)
+      end
+
+      def apply_prune(msg, mode)
+        content = (msg[:content] || msg["content"]).to_s
+        new_content = case mode.to_s.to_sym
+        when :hard_clear
+          PLACEHOLDER
+        when :soft_trim
+          soft_trim(content)
+        else
+          content
+        end
+
+        result = msg.dup
+        result[:content] = new_content if result.key?(:content)
+        result["content"] = new_content if result.key?("content")
+        result
+      end
+
+      def soft_trim(content)
+        return content if content.bytesize <= @soft_trim_max_bytes
+
+        head_chars = (@soft_trim_max_bytes * @head_ratio).to_i
+        tail_chars = (@soft_trim_max_bytes * @tail_ratio).to_i
+
+        head = content.byteslice(0, head_chars)
+        tail = content.bytesize > (head_chars + tail_chars) ? content.byteslice(-tail_chars, tail_chars) : ""
+
+        "#{head}\n...\n#{tail}"
+      end
+    end
+  end
+end

data/lib/llmemory/short_term/session_lifecycle.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module ShortTerm
+    class SessionLifecycle
+      def initialize(store: nil)
+        @store = store || build_store
+      end
+
+      def cleanup_idle_sessions!(user_id:, idle_minutes: nil)
+        idle_minutes ||= Llmemory.configuration.session_idle_minutes
+        cutoff = Time.now - (idle_minutes * 60)
+        deleted = 0
+
+        @store.list_sessions(user_id: user_id).each do |session_id|
+          state = @store.load(user_id, session_id)
+          next unless state.is_a?(Hash)
+
+          last_activity = state[:last_activity_at] || state["last_activity_at"]
+          next if last_activity.nil?
+
+          last_time = last_activity.is_a?(Time) ? last_activity : Time.parse(last_activity.to_s)
+          if last_time < cutoff
+            @store.delete(user_id, session_id)
+            deleted += 1
+          end
+        end
+
+        deleted
+      end
+
+      def cleanup_stale_sessions!(user_id:, prune_after_days: nil)
+        prune_after_days ||= Llmemory.configuration.session_prune_after_days
+        cutoff = Time.now - (prune_after_days * 86400)
+        deleted = 0
+
+        @store.list_sessions(user_id: user_id).each do |session_id|
+          state = @store.load(user_id, session_id)
+          next unless state.is_a?(Hash)
+
+          last_activity = state[:last_activity_at] || state["last_activity_at"]
+          next if last_activity.nil?
+
+          last_time = last_activity.is_a?(Time) ? last_activity : Time.parse(last_activity.to_s)
+          if last_time < cutoff
+            @store.delete(user_id, session_id)
+            deleted += 1
+          end
+        end
+
+        deleted
+      end
+
+      def enforce_max_entries!(user_id:, max_entries: nil)
+        max_entries ||= Llmemory.configuration.session_max_entries_per_user
+        sessions = @store.list_sessions(user_id: user_id)
+        return 0 if sessions.size <= max_entries
+
+        session_ages = sessions.map do |session_id|
+          state = @store.load(user_id, session_id)
+          last_activity = state&.dig(:last_activity_at) || state&.dig("last_activity_at")
+          last_time = last_activity.is_a?(Time) ? last_activity : (last_activity ? Time.parse(last_activity.to_s) : Time.at(0))
+          [session_id, last_time]
+        end
+
+        session_ages.sort_by! { |_, t| t }
+        to_delete = session_ages.first(session_ages.size - max_entries).map(&:first)
+        to_delete.each { |sid| @store.delete(user_id, sid) }
+        to_delete.size
+      end
+
+      private
+
+      def build_store
+        case Llmemory.configuration.short_term_store.to_sym
+        when :memory then Stores::MemoryStore.new
+        when :redis then Stores::RedisStore.new
+        when :postgres then Stores::PostgresStore.new
+        when :active_record, :activerecord
+          require_relative "stores/active_record_store"
+          Stores::ActiveRecordStore.new
+        else
+          Stores::MemoryStore.new
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/short_term.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "short_term/checkpoint"
+require_relative "short_term/session_lifecycle"
 
 module Llmemory
   module ShortTerm

data/lib/llmemory/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Llmemory
-  VERSION = "0.1.12"
+  VERSION = "0.1.14"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llmemory
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.14
 platform: ruby
 authors:
 - llmemory
@@ -181,11 +181,15 @@ files:
 - lib/llmemory/mcp/tools/memory_timeline_context.rb
 - lib/llmemory/memory.rb
 - lib/llmemory/retrieval.rb
+- lib/llmemory/retrieval/bm25_scorer.rb
 - lib/llmemory/retrieval/context_assembler.rb
 - lib/llmemory/retrieval/engine.rb
+- lib/llmemory/retrieval/mmr_reranker.rb
 - lib/llmemory/retrieval/temporal_ranker.rb
 - lib/llmemory/short_term.rb
 - lib/llmemory/short_term/checkpoint.rb
+- lib/llmemory/short_term/pruner.rb
+- lib/llmemory/short_term/session_lifecycle.rb
 - lib/llmemory/short_term/stores/active_record_checkpoint.rb
 - lib/llmemory/short_term/stores/active_record_store.rb
 - lib/llmemory/short_term/stores/base.rb