llmemory 0.2.6 → 0.2.7

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, cipher: nil)
+        def initialize(user_id:, storage: nil, vector_store: nil, cipher: nil, forget_log_store: nil)
           @user_id = user_id
           @cipher = cipher || Llmemory.build_cipher
+          @forget_log_store = forget_log_store
           @storage = storage || Storages.build(cipher: @cipher)
           @vector_store = vector_store
           @vector_explicit = !vector_store.nil?
@@ -71,11 +72,13 @@ module Llmemory
         # recency (temporal decay) and importance (P3), with provenance (P10).
         # Hybrid (vector + keyword) when a vector store is active; otherwise
         # keyword-only.
+        KEYWORD_MATCH_SCORE = 0.6
+
         def search_candidates(query, user_id: nil, top_k: 20)
           uid = user_id || @user_id
           return [] unless uid == @user_id
 
-          keyword = @storage.search_episodes(uid, query).first(top_k).map { |e| candidate_for(e, 1.0) }
+          keyword = @storage.search_episodes(uid, query).first(top_k).map { |e| candidate_for(e, KEYWORD_MATCH_SCORE) }
           vs = vector_store
           return keyword unless vs
 

data/lib/llmemory/long_term/episodic/storages/active_record_storage.rb

@@ -5,6 +5,7 @@ require "securerandom"
 require "time"
 require_relative "base"
 require_relative "../../../crypto/field_helpers"
+require_relative "../../../active_record_helpers"
 
 module Llmemory
   module LongTerm
@@ -15,6 +16,7 @@ module Llmemory
         # handles. Mirrors the file-based ActiveRecordStorage pattern.
         class ActiveRecordStorage < Base
           include Llmemory::Crypto::FieldHelpers
+          include Llmemory::ActiveRecordHelpers
 
           def initialize(cipher: nil)
             @cipher = cipher || Llmemory.build_cipher
@@ -39,7 +41,7 @@ module Llmemory
             rec.search_text = enc(text)
             rec.search_tokens = search_tokens_for(text) if LlmemoryEpisode.column_names.include?("search_tokens")
             rec.created_at ||= Time.current
-            rec.save!
+            with_unique_retry { rec.save! }
             id
           end
 

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

@@ -13,9 +13,10 @@ module Llmemory
       class Memory
         include Llmemory::MemoryModule
 
-        def initialize(user_id:, storage: nil, llm: nil, extractor: nil)
+        def initialize(user_id:, storage: nil, llm: nil, extractor: nil, forget_log_store: nil)
           @user_id = user_id
           @storage = storage || Storages.build
+          @forget_log_store = forget_log_store
           @llm = llm || Llmemory::LLM.client
           @extractor = extractor || Llmemory::Extractors::FactExtractor.new(llm: @llm)
         end
@@ -27,12 +28,16 @@ module Llmemory
           resource_id = save_resource(text)
           append_to_daily_log(text) if Llmemory.configuration.daily_logs_enabled && @storage.respond_to?(:save_daily_log_entry)
           items = @extractor.extract_items(text)
+          contents = items.map do |item|
+            item.is_a?(Hash) ? (item["content"] || item[:content]).to_s : item.to_s
+          end
+          classifications = @extractor.classify_items(contents)
           updates_by_category = {}
 
           items.each do |item|
             content = item.is_a?(Hash) ? (item["content"] || item[:content]) : item.to_s
             importance = (item["importance"] || item[:importance] || 0.7).to_f
-            cat = @extractor.classify_item(content)
+            cat = classifications[content] || @extractor.classify_item(content)
             updates_by_category[cat] ||= []
             updates_by_category[cat] << content.to_s
             save_item(category: cat, item: item, source_resource_id: resource_id, importance: importance)
@@ -48,8 +53,8 @@ module Llmemory
         end
 
         def retrieve(query)
-          retrieval = Retrieval.new(user_id: @user_id, storage: @storage, llm: @llm)
-          retrieval.retrieve(query)
+          candidates = search_candidates(query, top_k: 20)
+          Llmemory::Retrieval::ContextAssembler.new.assemble(candidates)
         end
 
         def search_candidates(query, user_id: nil, top_k: 20)

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

@@ -16,9 +16,14 @@ module Llmemory
       module Storages
         def self.build(store: nil, base_path: nil, database_url: nil, cipher: nil)
           resolved_cipher = cipher || Llmemory.build_cipher
-          case (store || Llmemory.configuration.long_term_store).to_s.to_sym
+          store_type = (store || Llmemory.configuration.long_term_store).to_s.to_sym
+          case store_type
           when :memory
-            MemoryStorage.new
+            if Llmemory.configuration.shared_memory_stores
+              shared_memory_storage
+            else
+              MemoryStorage.new
+            end
           when :file
             FileStorage.new(
               base_path: base_path || Llmemory.configuration.long_term_storage_path,
@@ -36,6 +41,14 @@ module Llmemory
             MemoryStorage.new
           end
         end
+
+        def self.shared_memory_storage
+          @shared_memory_storage ||= MemoryStorage.new
+        end
+
+        def self.reset_shared_singletons!
+          @shared_memory_storage = nil
+        end
       end
     end
   end

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

@@ -3,6 +3,7 @@
 require "securerandom"
 require_relative "base"
 require_relative "../../../crypto/field_helpers"
+require_relative "../../../active_record_helpers"
 
 module Llmemory
   module LongTerm
@@ -10,6 +11,7 @@ module Llmemory
       module Storages
         class ActiveRecordStorage < Base
           include Llmemory::Crypto::FieldHelpers
+          include Llmemory::ActiveRecordHelpers
 
           def initialize(cipher: nil)
             @cipher = cipher || Llmemory.build_cipher
@@ -64,7 +66,7 @@ module Llmemory
             rec = LlmemoryCategory.find_or_initialize_by(user_id: user_id, category_name: category_name)
             rec.content = enc(content)
             rec.updated_at = Time.current
-            rec.save!
+            with_unique_retry { rec.save! }
             true
           end
 

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "set"
 require_relative "node"
 require_relative "edge"
 require_relative "knowledge_graph"
@@ -14,9 +15,10 @@ module Llmemory
       class Memory
         include Llmemory::MemoryModule
 
-        def initialize(user_id:, storage: nil, vector_store: nil, llm: nil, extractor: nil, cipher: nil)
+        def initialize(user_id:, storage: nil, vector_store: nil, llm: nil, extractor: nil, cipher: nil, forget_log_store: nil)
           @user_id = user_id
           @cipher = cipher || Llmemory.build_cipher
+          @forget_log_store = forget_log_store
           @graph_storage = storage || Storages.build(cipher: @cipher)
           @kg = KnowledgeGraph.new(user_id: user_id, storage: @graph_storage)
           @conflict_resolver = ConflictResolver.new(@kg)
@@ -105,6 +107,7 @@ module Llmemory
           # store only exposes soft archive_edge). Both modes route to archive
           # for now; behavior is the same — kept for API uniformity.
           archived = Array(ids).map(&:to_s).select { |edge_id| @kg.archive_edge(edge_id) }
+          remove_edge_embeddings(archived)
           forget_log.record(@user_id, memory_type: "graph_based", ids: archived, reason: reason)
           Llmemory::Instrumentation.instrument(:memory_forget, memory_type: "graph_based", user_id: @user_id, count: archived.size, mode: mode)
           archived.size
@@ -147,6 +150,14 @@ module Llmemory
             subject_id = name_to_id[subject] || @kg.add_node(entity_type: "concept", name: subject, properties: { "provenance" => provenance })
             object_id = name_to_id[object] || @kg.add_node(entity_type: "concept", name: object, properties: { "provenance" => provenance })
 
+            existing = @kg.find_edges(
+              subject: subject_id,
+              predicate: predicate,
+              object: object_id,
+              include_archived: false
+            )
+            next if existing.any?
+
             edge = Edge.new(
               id: nil,
               user_id: @user_id,
@@ -157,7 +168,8 @@ module Llmemory
               created_at: Time.now,
               archived_at: nil
             )
-            @conflict_resolver.resolve(edge)
+            archived_ids = @conflict_resolver.resolve(edge)
+            remove_edge_embeddings(archived_ids)
             edge_id = @kg.add_edge(subject: subject_id, predicate: predicate, object: object_id, properties: { "provenance" => provenance })
 
             edge_text = "#{subject} #{predicate} #{object}"
@@ -180,8 +192,10 @@ module Llmemory
             vector_results = @vector_store.search(emb, top_k: top_k, user_id: @user_id)
           end
 
-          out = vector_results.map do |v|
+          out = vector_results.filter_map do |v|
             id = v[:id] || v["id"]
+            next unless active_edge?(id)
+
             meta = v[:metadata] || v["metadata"] || {}
             { id: id, text: meta["text"] || meta[:text] || id.to_s, score: v[:score] || v["score"] || 1.0, created_at: meta["created_at"] || meta[:created_at] }
           end
@@ -217,9 +231,14 @@ module Llmemory
 
         def extract_node_ids_from_text(text)
           return [] if text.to_s.empty?
+
+          query_tokens = Llmemory::Tokenizer.tokenize(text).to_set
           ids = []
-          @kg.list_nodes.each do |n|
-            ids << n.id if text.to_s.include?(n.name.to_s)
+          @kg.list_nodes.each do |node|
+            name_tokens = Llmemory::Tokenizer.tokenize(node.name.to_s)
+            next if name_tokens.empty?
+
+            ids << node.id if name_tokens.all? { |token| query_tokens.include?(token) }
           end
           ids
         end
@@ -244,6 +263,21 @@ module Llmemory
             store: Llmemory::ShortTerm::Stores.build(cipher: @cipher)
           )
         end
+
+        def remove_edge_embeddings(edge_ids)
+          return unless @vector_store.respond_to?(:delete)
+
+          Array(edge_ids).each do |edge_id|
+            @vector_store.delete(id: edge_id, user_id: @user_id)
+          end
+        end
+
+        def active_edge?(edge_id)
+          return false if edge_id.nil?
+
+          @kg.find_edges(subject: nil, predicate: nil, object: nil, include_archived: false)
+            .any? { |edge| edge.id.to_s == edge_id.to_s }
+        end
       end
     end
   end

data/lib/llmemory/long_term/graph_based/storage.rb

@@ -9,9 +9,14 @@ module Llmemory
       module Storages
         def self.build(store: nil, cipher: nil)
           resolved_cipher = cipher || Llmemory.build_cipher
-          case (store || Llmemory.configuration.long_term_store).to_s.to_sym
+          store_type = (store || Llmemory.configuration.long_term_store).to_s.to_sym
+          case store_type
           when :memory
-            MemoryStorage.new
+            if Llmemory.configuration.shared_memory_stores
+              shared_memory_storage
+            else
+              MemoryStorage.new
+            end
           when :active_record, :activerecord
             require_relative "storages/active_record_storage"
             ActiveRecordStorage.new(cipher: resolved_cipher)
@@ -21,6 +26,14 @@ module Llmemory
                   "graph_based long-term memory supports long_term_store :memory or :active_record; got #{store_name.inspect}"
           end
         end
+
+        def self.shared_memory_storage
+          @shared_memory_storage ||= MemoryStorage.new
+        end
+
+        def self.reset_shared_singletons!
+          @shared_memory_storage = nil
+        end
       end
     end
   end

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

@@ -22,9 +22,10 @@ module Llmemory
 
         attr_reader :user_id, :storage
 
-        def initialize(user_id:, storage: nil, vector_store: nil, cipher: nil)
+        def initialize(user_id:, storage: nil, vector_store: nil, cipher: nil, forget_log_store: nil)
           @user_id = user_id
           @cipher = cipher || Llmemory.build_cipher
+          @forget_log_store = forget_log_store
           @storage = storage || Storages.build(cipher: @cipher)
           @vector_store = vector_store
           @vector_explicit = !vector_store.nil?
@@ -71,11 +72,13 @@ module Llmemory
         # Retrieval Engine integration: skills ranked by relevance, recency and
         # proven utility (success rate exposed as importance). Hybrid (vector +
         # keyword) when a vector store is active; otherwise keyword-only.
+        KEYWORD_MATCH_SCORE = 0.6
+
         def search_candidates(query, user_id: nil, top_k: 20)
           uid = user_id || @user_id
           return [] unless uid == @user_id
 
-          keyword = @storage.search_skills(uid, query).first(top_k).map { |raw| candidate_for(raw, 1.0) }
+          keyword = @storage.search_skills(uid, query).first(top_k).map { |raw| candidate_for(raw, KEYWORD_MATCH_SCORE) }
           vs = vector_store
           return keyword unless vs
 

data/lib/llmemory/long_term/procedural/storages/active_record_storage.rb

@@ -5,6 +5,7 @@ require "securerandom"
 require "time"
 require_relative "base"
 require_relative "../../../crypto/field_helpers"
+require_relative "../../../active_record_helpers"
 
 module Llmemory
   module LongTerm
@@ -15,6 +16,7 @@ module Llmemory
         # handles. Mirrors the file-based ActiveRecordStorage pattern.
         class ActiveRecordStorage < Base
           include Llmemory::Crypto::FieldHelpers
+          include Llmemory::ActiveRecordHelpers
 
           def initialize(cipher: nil)
             @cipher = cipher || Llmemory.build_cipher
@@ -41,7 +43,7 @@ module Llmemory
             name = (data["name"] || data[:name]).to_s
             rec.name_det = enc_det(name) if LlmemorySkill.column_names.include?("name_det")
             rec.created_at ||= Time.current
-            rec.save!
+            with_unique_retry { rec.save! }
             id
           end
 

data/lib/llmemory/maintenance/consolidator.rb

@@ -43,12 +43,16 @@ module Llmemory
 
       def merge_items(group)
         contents = group.map { |i| i[:content].to_s }.uniq
+        importances = group.map { |i| (i[:importance] || i["importance"]).to_f }.compact
+        provenances = group.filter_map { |i| i[:provenance] || i["provenance"] }
         {
           id: "merged_#{SecureRandom.hex(4)}",
           category: group.first[:category],
           content: contents.join("; "),
-          source_resource_id: group.first[:source_resource_id]
-        }
+          source_resource_id: group.first[:source_resource_id],
+          importance: importances.empty? ? nil : importances.max,
+          provenance: provenances.last
+        }.compact
       end
     end
   end

data/lib/llmemory/mcp/authentication.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "cgi"
+
 module Llmemory
   module MCP
     # Rack middleware for token-based authentication
@@ -17,10 +19,8 @@ module Llmemory
       end
 
       def call(env)
-        # If no token is configured, skip authentication
         return @app.call(env) unless @token
 
-        # Check for valid token
         return UNAUTHORIZED_RESPONSE unless valid_token?(env)
 
         @app.call(env)
@@ -50,7 +50,9 @@ module Llmemory
       def parse_query_string(query_string)
         query_string.split("&").each_with_object({}) do |pair, hash|
           key, value = pair.split("=", 2)
-          hash[key] = value if key
+          next unless key
+
+          hash[CGI.unescape(key)] = CGI.unescape(value.to_s)
         end
       end
 

data/lib/llmemory/mcp/server.rb

@@ -39,7 +39,10 @@ module Llmemory
         transport.open
       end
 
-      def run_http(port: 3100, host: "0.0.0.0", ssl_cert: nil, ssl_key: nil)
+      def run_http(port: 3100, host: "127.0.0.1", ssl_cert: nil, ssl_key: nil)
+        require "socket"
+        validate_http_bind!(host)
+
         require "webrick"
 
         @http_transport = ::MCP::Server::Transports::StreamableHTTPTransport.new(@server)
@@ -96,13 +99,25 @@ module Llmemory
 
       def build_rack_app(transport)
         app = ->(env) { transport.handle_request(RackRequest.new(env)) }
+        app = Authentication.new(app)
+        app
+      end
 
-        # Wrap with authentication if MCP_TOKEN is set
-        if ENV["MCP_TOKEN"]
-          app = Authentication.new(app)
-        end
+      def validate_http_bind!(host)
+        return if loopback_host?(host)
+        return if ENV["MCP_TOKEN"] && !ENV["MCP_TOKEN"].to_s.empty?
 
-        app
+        raise Llmemory::ConfigurationError,
+              "MCP HTTP server cannot bind to #{host} without MCP_TOKEN; use 127.0.0.1 or set MCP_TOKEN"
+      end
+
+      def loopback_host?(host)
+        case host.to_s
+        when "127.0.0.1", "localhost", "::1"
+          true
+        else
+          false
+        end
       end
 
       def build_rack_env(req)

data/lib/llmemory/mcp/store_helpers.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module MCP
+    # Shared store resolution for MCP tools. Respects global configuration and
+    # long_term_type when selecting backends.
+    module StoreHelpers
+      module_function
+
+      def short_term_store
+        ShortTerm::Stores.build
+      end
+
+      def long_term_storage
+        if graph_based?
+          LongTerm::GraphBased::Storages.build
+        else
+          LongTerm::FileBased::Storages.build
+        end
+      end
+
+      def long_term_memory(user_id:)
+        if graph_based?
+          LongTerm::GraphBased::Memory.new(user_id: user_id, storage: long_term_storage)
+        else
+          LongTerm::FileBased::Memory.new(user_id: user_id, storage: long_term_storage)
+        end
+      end
+
+      def graph_based?
+        Llmemory.configuration.long_term_type.to_sym == :graph_based
+      end
+    end
+  end
+end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../store_helpers"
+
 module Llmemory
   module MCP
     module Tools
@@ -20,20 +22,21 @@ module Llmemory
 
         class << self
           def call(user_id:, content:, category: nil, server_context: nil)
-            storage = build_storage
-
-            # If no category provided, use a default
             cat = category || "observations"
 
-            # Generate a simple resource ID for tracking
-            resource_id = "mcp_#{Time.now.to_i}_#{rand(1000)}"
-
-            storage.save_item(
-              user_id,
-              category: cat,
-              content: content,
-              source_resource_id: resource_id
-            )
+            if StoreHelpers.graph_based?
+              memory = StoreHelpers.long_term_memory(user_id: user_id)
+              memory.remember_fact(content: content, category: cat)
+            else
+              storage = StoreHelpers.long_term_storage
+              resource_id = "mcp_#{Time.now.to_i}_#{rand(1000)}"
+              storage.save_item(
+                user_id,
+                category: cat,
+                content: content,
+                source_resource_id: resource_id
+              )
+            end
 
             ::MCP::Tool::Response.new([{
               type: "text",
@@ -45,12 +48,6 @@ module Llmemory
               text: "Error saving memory: #{e.message}"
             }], error: true)
           end
-
-          private
-
-          def build_storage
-            LongTerm::FileBased::Storages.build
-          end
         end
       end
     end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../store_helpers"
+
 module Llmemory
   module MCP
     module Tools
@@ -48,7 +50,7 @@ module Llmemory
           private
 
           def search_short_term(user_id, query, limit)
-            store = build_short_term_store
+            store = StoreHelpers.short_term_store
             sessions = store.list_sessions(user_id: user_id)
             results = []
             query_lower = query.downcase
@@ -74,9 +76,21 @@ module Llmemory
           end
 
           def search_long_term(user_id, query, limit)
-            storage = build_long_term_storage
             results = []
 
+            if StoreHelpers.graph_based?
+              memory = StoreHelpers.long_term_memory(user_id: user_id)
+              memory.search_candidates(query, user_id: user_id, top_k: limit).each do |item|
+                results << {
+                  type: "long_term_fact",
+                  content: item[:text] || item["text"] || item[:id] || item["id"],
+                  created_at: item[:timestamp] || item["timestamp"]
+                }
+              end
+              return results
+            end
+
+            storage = StoreHelpers.long_term_storage
             items = storage.search_items(user_id, query)
             items.first(limit).each do |item|
               results << {
@@ -90,23 +104,6 @@ module Llmemory
             results
           end
 
-          def build_short_term_store
-            case Llmemory.configuration.short_term_store.to_sym
-            when :memory then ShortTerm::Stores::MemoryStore.new
-            when :redis then ShortTerm::Stores::RedisStore.new
-            when :postgres then ShortTerm::Stores::PostgresStore.new
-            when :active_record, :activerecord
-              require_relative "../../short_term/stores/active_record_store"
-              ShortTerm::Stores::ActiveRecordStore.new
-            else
-              ShortTerm::Stores::MemoryStore.new
-            end
-          end
-
-          def build_long_term_storage
-            LongTerm::FileBased::Storages.build
-          end
-
           def format_results(results)
             return "No memories found matching the query." if results.empty?