llmemory 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63dd1fafe3af80e9a86be5da51e3ef4dbb6254cc0ebad341bed240875f539ebf
-  data.tar.gz: 6da8ed10591ed7c88a1be6b33ba30eff780d388cf146750f070518a1748f9f92
+  metadata.gz: 81446e0a05a3028dbcd9bb4745295714304eab3c5b7b898ebd0bb72aa0e48c4e
+  data.tar.gz: 43a8426f108c3c927e72540738fb1b2f946395ad12e01eaba3183e28a38382e4
 SHA512:
-  metadata.gz: 527c5e19c2f53299e966c7c8d8e2b004375a99ab58f726d50b23bac88d015a3c8eb48ddbb00da1f536522122c782c754110dedb77f698a721a058227cb5e8bee
-  data.tar.gz: e7cd4cfbb1dcb805687de7217b84299f130ac941edd97a39de4d7deba784a3e45e4944e2ae6fd07ff0da433bdc6f2c7227b7fc84130be1848adc7ccbc888fda9
+  metadata.gz: '0396292691b3f8705988d9b86fe33f4f84caee8fcafc498f18631042dff94895175060fd876f6400668effc2e87ae061af60c6bee28c10b69526fab36bfdbdcd'
+  data.tar.gz: 6b7706873ad15231dc70e22c96b89090b9beb36c5fb9b0630e6f5112f125a83e5014964448e37ec59e3e5b248593b55279b2c99f1228218c86f59fd9de8cbec0

data/README.md

@@ -214,24 +214,48 @@ Use `--store TYPE` where applicable to override the configured store (e.g. `memo
 
 If you use Rails and want a web UI to browse memory, load the dashboard and mount the engine. **Rails is not a dependency of the gem**; the dashboard is only loaded when you require it.
 
-1. In an initializer or early in boot (e.g. `config/initializers/llmemory.rb`):
+The dashboard must be **required early in boot** (in `config/application.rb`), not in an initializer, so that Rails registers the engine’s routes correctly (same as other engines like mailbin).
+
+**1. Require the dashboard in `config/application.rb`** (e.g. right after `Bundler.require`):
+
+```ruby
+# config/application.rb
+Bundler.require(*Rails.groups)
+
+require "llmemory/dashboard" if Rails.env.development?  # optional: only in development
+```
+
+**2. Configure llmemory** in `config/initializers/llmemory.rb` (store, LLM, etc.):
 
 ```ruby
-require "llmemory/dashboard"
+# config/initializers/llmemory.rb
+Llmemory.configure do |config|
+  config.llm_provider = :openai
+  config.llm_api_key = ENV["OPENAI_API_KEY"]
+  config.short_term_store = :active_record
+  config.long_term_type = :graph_based
+  config.long_term_store = :active_record
+  # ...
+end
 ```
 
-2. In `config/routes.rb`:
+**3. Mount the engine** in `config/routes.rb` (you can wrap it in a development check or behind auth):
 
 ```ruby
-mount Llmemory::Dashboard::Engine, at: "/llmemory"
+# config/routes.rb
+Rails.application.routes.draw do
+  # ...
+  mount Llmemory::Dashboard::Engine, at: "/llmemory" if Rails.env.development?
+end
 ```
 
-3. Visit `/llmemory`. You get:
-   - List of users with memory
-   - Short-term: conversation messages per session
-   - Long-term (file-based): resources, items by category, category summaries
-   - Long-term (graph-based): nodes and edges
-   - Search and stats
+**4. Visit** `/llmemory`. You get:
+
+- List of users with memory
+- Short-term: conversation messages per session
+- Long-term (file-based): resources, items by category, category summaries
+- Long-term (graph-based): nodes and edges
+- Search and stats
 
 The dashboard uses your existing `Llmemory.configuration` (short-term store, long-term store/type, etc.) and does not add any gem dependency; it only runs when Rails is present and you require `llmemory/dashboard`.
 

data/{lib/llmemory/dashboard/app → app}/controllers/llmemory/dashboard/application_controller.rb

@@ -3,7 +3,7 @@
 module Llmemory
   module Dashboard
     class ApplicationController < ActionController::Base
-      helper_method :short_term_store, :file_based_storage, :graph_based_storage
+      helper_method :short_term_store, :file_based_storage, :graph_based_storage, :file_based?, :graph_based?
 
       protected
 

data/lib/llmemory/extractors/entity_relation_extractor.rb

@@ -5,30 +5,96 @@ require "json"
 module Llmemory
   module Extractors
     class EntityRelationExtractor
+      # Long conversations often make the LLM return empty JSON; truncate for extraction.
+      MAX_CONVERSATION_CHARS = 2500
+
+      # JSON Schema for Structured Outputs (OpenAI response_format).
+      # Ensures valid entities/relations shape and avoids refusals or malformed JSON.
+      EXTRACTION_JSON_SCHEMA = {
+        name: "entity_relation_extraction",
+        schema: {
+          type: "object",
+          properties: {
+            entities: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  type: { type: "string", description: "Entity type: person, company, place, concept, etc." },
+                  name: { type: "string", description: "Entity name" }
+                },
+                required: ["type", "name"],
+                additionalProperties: false
+              },
+              description: "List of entities mentioned in the conversation"
+            },
+            relations: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  subject: { type: "string", description: "Subject entity (use 'User' when the user talks about themselves or their family)" },
+                  predicate: { type: "string", description: "Relation inferred from context, snake_case (e.g. has_son, works_at, likes, spouse)" },
+                  object: { type: "string", description: "Object entity (person name, place, concept)" }
+                },
+                required: ["subject", "predicate", "object"],
+                additionalProperties: false
+              },
+              description: "Subject-predicate-object relations extracted from the conversation"
+            }
+          },
+          required: ["entities", "relations"],
+          additionalProperties: false
+        }
+      }.freeze
+
       def initialize(llm: nil)
         @llm = llm || Llmemory::LLM.client
       end
 
       def extract(conversation_text)
+        text = conversation_text.to_s.strip
+        text = text[0, MAX_CONVERSATION_CHARS] + "\n[...]" if text.length > MAX_CONVERSATION_CHARS
         prompt = <<~PROMPT
-          Extract entities and relations from this conversation as a knowledge graph.
-          - Entities: people, companies, places, preferences, concepts (type and name).
-          - Relations: subject-predicate-object triplets (e.g. User works_at OpenAI).
-          Use "User" as subject when the user talks about themselves.
-          Predicates: works_at, lives_in, prefers, is_allergic_to, likes, knows, current_job, current_city, etc.
-          Return ONLY valid JSON with this shape:
-          {"entities": [{"type": "person", "name": "User"}, {"type": "company", "name": "OpenAI"}], "relations": [{"subject": "User", "predicate": "works_at", "object": "OpenAI"}]}
+          Infer entities and relations from this user-assistant conversation. Build a knowledge graph from what the user says, even when they don't state facts in formal language.
+          - Entities: people, places, companies, concepts (type and name).
+          - Relations: infer subject-predicate-object from context. Use "User" as subject when the user talks about themselves or people close to them.
+          Examples of inference: "mi hijo se llama Luis" → User has_son Luis; "trabajo en Acme" → User works_at Acme; "no me gustan las macros" → User prefers (or dislikes) Excel macros. Infer family (has_son, has_daughter, spouse), work (works_at, current_job), preferences (likes, prefers), and any other relation that clearly follows from the conversation. Use snake_case predicates.
+          Return empty arrays only if the conversation contains no extractable facts.
+
           Conversation:
-          #{conversation_text}
+          #{text}
         PROMPT
-        response = @llm.invoke(prompt.strip)
+
+        result = extract_once(prompt.strip)
+        # Retry with plain invoke() if API returned empty (avoids empty json_schema response)
+        if (result[:entities].empty? && result[:relations].empty?) && text.length > 50
+          result = parse_response(@llm.invoke(prompt.strip))
+        end
+        result
+      end
+
+      def extract_once(prompt)
+        if @llm.respond_to?(:invoke_with_json_schema)
+          begin
+            parsed = @llm.invoke_with_json_schema(prompt, EXTRACTION_JSON_SCHEMA)
+            if parsed.is_a?(Hash) && !parsed.empty?
+              result = parse_response(parsed)
+              return result if result[:entities].any? || result[:relations].any?
+            end
+          rescue Llmemory::LLMError
+            # Model may not support response_format json_schema; fall back to invoke + parse
+          end
+        end
+
+        response = @llm.invoke(prompt)
         parse_response(response)
       end
 
       private
 
       def parse_response(response)
-        json = extract_json(response)
+        json = response.is_a?(Hash) ? response : extract_json(response)
         return { entities: [], relations: [] } unless json.is_a?(Hash)
         entities = Array(json["entities"] || json[:entities]).map { |e| normalize_entity(e) }
         relations = Array(json["relations"] || json[:relations]).map { |r| normalize_relation(r) }

data/lib/llmemory/llm/base.rb

@@ -7,6 +7,12 @@ module Llmemory
         raise NotImplementedError, "#{self.class}#invoke must be implemented"
       end
 
+      # Optional: Structured Outputs (JSON schema). Override in providers that support it (e.g. OpenAI).
+      # When not overridden, returns nil and callers should fall back to invoke + parse.
+      def invoke_with_json_schema(_prompt, _json_schema)
+        nil
+      end
+
       protected
 
       def config

data/lib/llmemory/llm/openai.rb

@@ -32,6 +32,39 @@ module Llmemory
         body.dig("choices", 0, "message", "content")&.strip || ""
       end
 
+      # Calls the model with response_format json_schema (Structured Outputs).
+      # Returns the parsed JSON hash. Use when the model supports structured outputs
+      # (e.g. gpt-4o, gpt-4o-mini 2024-08-06 and later).
+      def invoke_with_json_schema(prompt, json_schema)
+        payload = {
+          model: @model,
+          messages: [{ role: "user", content: prompt }],
+          temperature: 0,
+          response_format: {
+            type: "json_schema",
+            json_schema: {
+              strict: true,
+              name: json_schema[:name] || "extraction",
+              schema: json_schema[:schema] || json_schema["schema"]
+            }
+          }
+        }
+        response = connection.post("chat/completions") do |req|
+          req.body = payload.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?
+
+        body = response.body.is_a?(Hash) ? response.body : JSON.parse(response.body.to_s)
+        content = body.dig("choices", 0, "message", "content")&.strip
+        return {} if content.nil? || content.empty?
+        JSON.parse(content)
+      rescue JSON::ParserError => e
+        raise Llmemory::LLMError, "Failed to parse JSON response: #{e.message}"
+      end
+
       private
 
       def connection

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

@@ -21,32 +21,48 @@ module Llmemory
         end
 
         def memorize(conversation_text)
-          data = @extractor.extract(conversation_text)
+          data = @extractor.extract(conversation_text) rescue { entities: [], relations: [] }
+          data = { entities: [], relations: [] } unless data.is_a?(Hash)
+          entities = Array(data[:entities] || data["entities"])
+          relations = Array(data[:relations] || data["relations"])
+
+          return true if entities.empty? && relations.empty?
+
           name_to_id = {}
 
-          data[:entities].each do |e|
-            id = @kg.add_node(entity_type: e[:type], name: e[:name], properties: {})
-            name_to_id[e[:name]] ||= id
+          entities.each do |e|
+            next unless e.is_a?(Hash)
+            entity_type = e[:type] || e["type"] || "concept"
+            name = e[:name] || e["name"]
+            next if name.nil? || name.to_s.strip.empty?
+            id = @kg.add_node(entity_type: entity_type, name: name.to_s.strip, properties: {})
+            name_to_id[name.to_s.strip] ||= id
           end
 
-          data[:relations].each do |r|
-            subject_id = name_to_id[r[:subject]] || @kg.add_node(entity_type: "concept", name: r[:subject], properties: {})
-            object_id = name_to_id[r[:object]] || @kg.add_node(entity_type: "concept", name: r[:object], properties: {})
+          relations.each do |r|
+            next unless r.is_a?(Hash)
+            subject = (r[:subject] || r["subject"]).to_s.strip
+            predicate = (r[:predicate] || r["predicate"]).to_s.strip
+            object = (r[:object] || r["object"]).to_s.strip
+            next if subject.empty? || predicate.empty? || object.empty?
+
+            subject_id = name_to_id[subject] || @kg.add_node(entity_type: "concept", name: subject, properties: {})
+            object_id = name_to_id[object] || @kg.add_node(entity_type: "concept", name: object, properties: {})
 
             edge = Edge.new(
               id: nil,
               user_id: @user_id,
               subject_id: subject_id,
-              predicate: r[:predicate],
+              predicate: predicate,
               target_id: object_id,
               properties: {},
               created_at: Time.now,
               archived_at: nil
             )
             @conflict_resolver.resolve(edge)
-            edge_id = @kg.add_edge(subject: subject_id, predicate: r[:predicate], object: object_id, properties: {})
+            edge_id = @kg.add_edge(subject: subject_id, predicate: predicate, object: object_id, properties: {})
 
-            text = "#{r[:subject]} #{r[:predicate]} #{r[:object]}"
+            text = "#{subject} #{predicate} #{object}"
             embedding = @vector_store.respond_to?(:embed) ? @vector_store.embed(text) : nil
             if embedding && @vector_store.respond_to?(:store)
               @vector_store.store(id: "edge_#{edge_id}", embedding: embedding, metadata: { text: text, created_at: Time.now }, user_id: @user_id)
@@ -84,7 +100,13 @@ module Llmemory
 
         def build_vector_store
           emb = Llmemory::VectorStore::OpenAIEmbeddings.new
-          Llmemory::VectorStore::MemoryStore.new(embedding_provider: emb)
+          store_type = (Llmemory.configuration.long_term_store || :memory).to_s.to_sym
+          if store_type == :active_record || store_type == :activerecord
+            require_relative "../../vector_store/active_record_store"
+            Llmemory::VectorStore::ActiveRecordStore.new(embedding_provider: emb)
+          else
+            Llmemory::VectorStore::MemoryStore.new(embedding_provider: emb)
+          end
         end
 
         def hybrid_search(query, top_k:)
@@ -115,6 +137,19 @@ module Llmemory
             end
           end
 
+          # When vector store is empty (e.g. in-memory not persisted), use graph edges as fallback
+          # so long-term context is still recovered from persisted nodes/edges.
+          if out.empty? && @graph_storage.respond_to?(:list_edges)
+            edges = @graph_storage.list_edges(@user_id, limit: top_k)
+            edges.each do |e|
+              subj = @kg.find_node_by_id(e.subject_id)
+              obj = @kg.find_node_by_id(e.target_id)
+              next unless subj && obj
+              edge_text = "#{subj.name} #{e.predicate} #{obj.name}"
+              out << { text: edge_text, score: 0.7, created_at: e.created_at }
+            end
+          end
+
           out.sort_by { |r| -(r[:score] || 0) }.first(top_k)
         end
 

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

@@ -8,7 +8,7 @@ module Llmemory
     module GraphBased
       module Storages
         def self.build(store: nil)
-          case (store || :memory).to_s.to_sym
+          case (store || Llmemory.configuration.long_term_store).to_s.to_sym
           when :memory
             MemoryStorage.new
           when :active_record, :activerecord

data/lib/llmemory/long_term/graph_based/storages/active_record_models.rb

@@ -5,14 +5,14 @@ module Llmemory
     module GraphBased
       module Storages
         class LlmemoryGraphNode < ::ActiveRecord::Base
-          self.table_name = "llmemory_graph_nodes"
+          self.table_name = "llmemory_nodes"
           self.primary_key = "id"
           has_many :out_edges, class_name: "Llmemory::LongTerm::GraphBased::Storages::LlmemoryGraphEdge", foreign_key: :subject_id
           has_many :in_edges, class_name: "Llmemory::LongTerm::GraphBased::Storages::LlmemoryGraphEdge", foreign_key: :object_id
         end
 
         class LlmemoryGraphEdge < ::ActiveRecord::Base
-          self.table_name = "llmemory_graph_edges"
+          self.table_name = "llmemory_edges"
           self.primary_key = "id"
           belongs_to :subject_node, class_name: "Llmemory::LongTerm::GraphBased::Storages::LlmemoryGraphNode", foreign_key: :subject_id, optional: true
           belongs_to :object_node, class_name: "Llmemory::LongTerm::GraphBased::Storages::LlmemoryGraphNode", foreign_key: :object_id, optional: true

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "securerandom"
 require_relative "base"
 require_relative "active_record_models"
 require_relative "../node"
@@ -33,15 +32,13 @@ module Llmemory
               rec.update!(properties: n.properties || {}, updated_at: Time.current)
               rec.id
             else
-              id = n.id || "node_#{SecureRandom.hex(8)}"
-              LlmemoryGraphNode.create!(
-                id: id,
+              rec = LlmemoryGraphNode.create!(
                 user_id: user_id,
                 entity_type: n.entity_type.to_s,
                 name: n.name.to_s,
                 properties: n.properties || {}
               )
-              id
+              rec.id
             end
           end
 
@@ -64,8 +61,11 @@ module Llmemory
 
           def save_edge(user_id, edge)
             e = edge.is_a?(Edge) ? edge : Edge.from_h(edge.to_h)
-            id = e.id || "edge_#{SecureRandom.hex(8)}"
-            rec = LlmemoryGraphEdge.find_by(user_id: user_id, id: id)
+            rec = if e.id && e.id.is_a?(Integer)
+              LlmemoryGraphEdge.find_by(user_id: user_id, id: e.id)
+            else
+              nil
+            end
             if rec
               rec.update!(
                 subject_id: e.subject_id,
@@ -73,17 +73,17 @@ module Llmemory
                 object_id: e.target_id,
                 properties: e.properties || {}
               )
+              rec.id
             else
-              LlmemoryGraphEdge.create!(
-                id: id,
+              rec = LlmemoryGraphEdge.create!(
                 user_id: user_id,
                 subject_id: e.subject_id,
                 predicate: e.predicate,
                 object_id: e.target_id,
                 properties: e.properties || {}
               )
+              rec.id
             end
-            id
           end
 
           def find_edges(user_id, subject_id: nil, predicate: nil, object_id: nil, include_archived: false)
@@ -110,6 +110,7 @@ module Llmemory
             scope = LlmemoryGraphEdge.where(user_id: user_id, archived_at: nil)
             scope = scope.where(subject_id: subject_id) if subject_id
             scope = scope.where(predicate: predicate) if predicate
+            scope = scope.order(created_at: :desc) if limit && limit.to_i.positive?
             scope = scope.limit(limit) if limit && limit.to_i.positive?
             scope.map { |r| record_to_edge(r) }
           end

data/lib/llmemory/memory.rb

@@ -42,7 +42,7 @@ module Llmemory
     def consolidate!
       msgs = messages
       return true if msgs.empty?
-      conversation_text = msgs.map { |m| "#{m[:role]}: #{m[:content]}" }.join("\n")
+      conversation_text = msgs.map { |m| format_message(m) }.join("\n")
       @long_term.memorize(conversation_text)
       true
     end
@@ -79,16 +79,19 @@ module Llmemory
     def format_short_term_context(msgs)
       return "" if msgs.empty?
       lines = ["=== RECENT CONVERSATION ===", ""]
-      msgs.each do |m|
-        role = m[:role] || m["role"]
-        content = m[:content] || m["content"]
-        lines << "#{role}: #{content}"
-      end
+      msgs.each { |m| lines << format_message(m) }
       lines << ""
       lines << "=== END RECENT CONVERSATION ==="
       lines.join("\n")
     end
 
+    # Formats a message hash, handling both symbol and string keys.
+    def format_message(m)
+      role = m[:role] || m["role"]
+      content = m[:content] || m["content"]
+      "#{role}: #{content}"
+    end
+
     def combine_contexts(short_context, long_context)
       parts = []
       parts << short_context if short_context.to_s.strip.length.positive?

data/lib/llmemory/vector_store/active_record_embedding.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module VectorStore
+    class ActiveRecordEmbedding < ::ActiveRecord::Base
+      self.table_name = "llmemory_embeddings"
+    end
+  end
+end

data/lib/llmemory/vector_store/active_record_store.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Llmemory
+  module VectorStore
+    # Persists embeddings in llmemory_embeddings (pgvector).
+    # Use when long_term_store is :active_record so hybrid search finds persisted embeddings.
+    class ActiveRecordStore < Base
+      def initialize(embedding_provider: nil)
+        self.class.load_model!
+        @embedding_provider = embedding_provider
+      end
+
+      def self.load_model!
+        return if @model_loaded
+        require "active_record"
+        require_relative "active_record_embedding"
+        @model_loaded = true
+      end
+
+      def embed(text)
+        return Array.new(1536, 0.0) unless @embedding_provider&.respond_to?(:embed)
+        @embedding_provider.embed(text)
+      end
+
+      def store(id:, embedding:, metadata: {}, user_id: nil)
+        return id if user_id.nil? || user_id.to_s.empty?
+        text_content = (metadata || {}).dig("text") || (metadata || {}).dig(:text)
+        rec = Llmemory::VectorStore::ActiveRecordEmbedding.find_or_initialize_by(
+          user_id: user_id.to_s,
+          source_type: "edge",
+          source_id: id.to_s
+        )
+        rec.embedding = embedding.to_a.map(&:to_f)
+        rec.text_content = text_content
+        rec.save!
+        id
+      end
+
+      def search(query_embedding, top_k: 10, user_id: nil)
+        return [] if user_id.nil? || user_id.to_s.empty?
+        vec = query_embedding.to_a.map(&:to_f)
+        return [] if vec.empty?
+        # Sanitize vector for pgvector (only floats allowed)
+        sanitized_vec = vec.map { |v| v.finite? ? v : 0.0 }
+        vector_literal = "[#{sanitized_vec.join(',')}]"
+        # pgvector cosine distance <=> (0 = same, 2 = opposite); score = 1 - distance for similarity
+        scope = Llmemory::VectorStore::ActiveRecordEmbedding.where(user_id: user_id.to_s)
+        rows = scope.select(
+          Llmemory::VectorStore::ActiveRecordEmbedding.arel_table[Arel.star],
+          Arel.sql("(embedding <=> '#{vector_literal}'::vector) AS distance")
+        ).order(Arel.sql("embedding <=> '#{vector_literal}'::vector")).limit(top_k)
+        rows.map do |r|
+          distance = r["distance"] || r.attributes["distance"] || 0.0
+          score = (1.0 - distance.to_f).clamp(-1.0, 1.0)
+          {
+            id: r.source_id,
+            score: score,
+            metadata: { "text" => r.text_content, "created_at" => r.created_at, "user_id" => r.user_id }
+          }
+        end
+      end
+
+      def search_by_text(query_text, top_k: 10, user_id: nil)
+        return [] if user_id.nil? || user_id.to_s.empty?
+        return [] unless @embedding_provider&.respond_to?(:embed)
+        query_embedding = @embedding_provider.embed(query_text)
+        search(query_embedding, top_k: top_k, user_id: user_id)
+      end
+    end
+  end
+end

data/lib/llmemory/vector_store/openai_embeddings.rb

@@ -17,7 +17,7 @@ module Llmemory
 
       def embed(text)
         return Array.new(DEFAULT_DIMS, 0.0) if text.to_s.strip.empty?
-        response = connection.post("/embeddings") do |req|
+        response = connection.post("embeddings") do |req|
           req.headers["Authorization"] = "Bearer #{@api_key}"
           req.headers["Content-Type"] = "application/json"
           req.body = { input: text.to_s.strip, model: @model }.to_json

data/lib/llmemory/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llmemory
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - llmemory
@@ -76,6 +76,23 @@ extra_rdoc_files: []
 files:
 - LICENSE.txt
 - README.md
+- app/controllers/llmemory/dashboard/application_controller.rb
+- app/controllers/llmemory/dashboard/graph_controller.rb
+- app/controllers/llmemory/dashboard/long_term_controller.rb
+- app/controllers/llmemory/dashboard/search_controller.rb
+- app/controllers/llmemory/dashboard/short_term_controller.rb
+- app/controllers/llmemory/dashboard/stats_controller.rb
+- app/controllers/llmemory/dashboard/users_controller.rb
+- app/views/layouts/application.html.erb
+- app/views/llmemory/dashboard/graph/index.html.erb
+- app/views/llmemory/dashboard/long_term/categories.html.erb
+- app/views/llmemory/dashboard/long_term/index.html.erb
+- app/views/llmemory/dashboard/search/index.html.erb
+- app/views/llmemory/dashboard/short_term/show.html.erb
+- app/views/llmemory/dashboard/stats/index.html.erb
+- app/views/llmemory/dashboard/users/index.html.erb
+- app/views/llmemory/dashboard/users/show.html.erb
+- config/routes.rb
 - exe/llmemory
 - lib/generators/llmemory/install/install_generator.rb
 - lib/generators/llmemory/install/templates/create_llmemory_tables.rb
@@ -95,23 +112,6 @@ files:
 - lib/llmemory/cli/commands/users.rb
 - lib/llmemory/configuration.rb
 - lib/llmemory/dashboard.rb
-- lib/llmemory/dashboard/app/controllers/llmemory/dashboard/application_controller.rb
-- lib/llmemory/dashboard/app/controllers/llmemory/dashboard/graph_controller.rb
-- lib/llmemory/dashboard/app/controllers/llmemory/dashboard/long_term_controller.rb
-- lib/llmemory/dashboard/app/controllers/llmemory/dashboard/search_controller.rb
-- lib/llmemory/dashboard/app/controllers/llmemory/dashboard/short_term_controller.rb
-- lib/llmemory/dashboard/app/controllers/llmemory/dashboard/stats_controller.rb
-- lib/llmemory/dashboard/app/controllers/llmemory/dashboard/users_controller.rb
-- lib/llmemory/dashboard/app/views/layouts/application.html.erb
-- lib/llmemory/dashboard/app/views/llmemory/dashboard/graph/index.html.erb
-- lib/llmemory/dashboard/app/views/llmemory/dashboard/long_term/categories.html.erb
-- lib/llmemory/dashboard/app/views/llmemory/dashboard/long_term/index.html.erb
-- lib/llmemory/dashboard/app/views/llmemory/dashboard/search/index.html.erb
-- lib/llmemory/dashboard/app/views/llmemory/dashboard/short_term/show.html.erb
-- lib/llmemory/dashboard/app/views/llmemory/dashboard/stats/index.html.erb
-- lib/llmemory/dashboard/app/views/llmemory/dashboard/users/index.html.erb
-- lib/llmemory/dashboard/app/views/llmemory/dashboard/users/show.html.erb
-- lib/llmemory/dashboard/config/routes.rb
 - lib/llmemory/dashboard/engine.rb
 - lib/llmemory/extractors.rb
 - lib/llmemory/extractors/entity_relation_extractor.rb
@@ -164,6 +164,8 @@ files:
 - lib/llmemory/short_term/stores/postgres_store.rb
 - lib/llmemory/short_term/stores/redis_store.rb
 - lib/llmemory/vector_store.rb
+- lib/llmemory/vector_store/active_record_embedding.rb
+- lib/llmemory/vector_store/active_record_store.rb
 - lib/llmemory/vector_store/base.rb
 - lib/llmemory/vector_store/memory_store.rb
 - lib/llmemory/vector_store/openai_embeddings.rb