smart_rag 0.1.0

data/lib/smart_rag/models/embedding.rb

@@ -0,0 +1,140 @@
+require_relative 'model_base'
+require 'sequel/plugins/validation_helpers'
+
+module SmartRAG
+  module Models
+    # Embedding model for storing vector embeddings of document sections
+    class Embedding < Sequel::Model
+      include FactoryBotHelpers
+      plugin :validation_helpers
+      plugin :timestamps
+
+      # Set dataset after database is connected
+      def self.set_dataset_from_db
+        set_dataset(:embeddings)
+      end
+
+      # Add bang methods for FactoryBot compatibility
+      def self.create!(attributes = {})
+        instance = new(attributes)
+        instance.save! || raise(Sequel::ValidationFailed, instance.errors.full_messages.join(', '))
+        instance
+      end
+
+      # Relationships
+      many_to_one :section, class: '::SmartRAG::Models::SourceSection', key: :source_id
+
+      # Validation
+      def validate
+        super
+        validates_presence %i[source_id vector]
+      end
+
+      # Class methods
+      class << self
+        # Find embeddings by source section
+        def by_section(section_id)
+          where(source_id: section_id).all
+        end
+
+        # Find embeddings by multiple sections
+        def by_sections(section_ids)
+          where(source_id: section_ids).all
+        end
+
+        # Find similar embeddings using cosine distance (pgvector)
+        def similar_to(query_vector, limit: 10, threshold: 0.3)
+          server_version = db.server_version
+
+          # Format vector for pgvector
+          formatted_vector = if query_vector.is_a?(Array)
+                               "[#{query_vector.join(',')}]"
+                             else
+                               query_vector.to_s
+                             end
+
+          distance_threshold = 1 - threshold
+
+          dataset = if server_version >= 120_000 # PostgreSQL 12+
+                      where(Sequel.lit('(vector <=> ?) < ?', formatted_vector, distance_threshold))
+                        .order(Sequel.lit('vector <=> ?', formatted_vector))
+                        .limit(limit)
+                    else
+                      where(Sequel.lit('cosine_distance(vector, ?) < ?', formatted_vector, distance_threshold))
+                        .order(Sequel.lit('cosine_distance(vector, ?)', formatted_vector))
+                        .limit(limit)
+                    end
+
+          dataset.all
+        end
+
+        # Find nearest embeddings without a threshold fallback
+        def nearest_to(query_vector, limit: 10)
+          server_version = db.server_version
+
+          formatted_vector = if query_vector.is_a?(Array)
+                               "[#{query_vector.join(',')}]"
+                             else
+                               query_vector.to_s
+                             end
+
+          dataset = if server_version >= 120_000 # PostgreSQL 12+
+                      order(Sequel.lit('vector <=> ?', formatted_vector))
+                        .limit(limit)
+                    else
+                      order(Sequel.lit('cosine_distance(vector, ?)', formatted_vector))
+                        .limit(limit)
+                    end
+
+          dataset.all
+        end
+
+        # Batch insert embeddings
+        def batch_insert(embedding_data)
+          db.transaction do
+            dataset.multi_insert(embedding_data)
+          end
+        end
+
+        # Delete embeddings by section
+        def delete_by_section(section_id)
+          where(source_id: section_id).delete
+        end
+
+        # Delete old embeddings (cleanup)
+        def delete_old_embeddings(days: 30)
+          where(Sequel.lit('created_at < ?', Time.now - (days * 24 * 60 * 60))).delete
+        end
+      end
+
+      # Instance methods
+
+      # Return vector as array of floats
+      def vector_array
+        return nil unless vector
+
+        # Convert pgvector to array
+        vector.to_s.gsub(/[<>]/, '').split(',').map(&:to_f)
+      end
+
+      # Calculate similarity to another vector
+      def similarity_to(other_vector)
+        vector_array = self.vector_array
+        vector_array_cosine_similarity(vector_array, other_vector)
+      end
+
+      private
+
+      def vector_array_cosine_similarity(v1, v2)
+        return 0.0 if v1.nil? || v2.nil? || v1.empty? || v2.empty?
+
+        dot_product = v1.zip(v2).map { |a, b| a * b }.sum
+        magnitude1 = Math.sqrt(v1.map { |x| x * x }.sum)
+        magnitude2 = Math.sqrt(v2.map { |x| x * x }.sum)
+        return 0.0 if magnitude1 == 0 || magnitude2 == 0
+
+        dot_product / (magnitude1 * magnitude2)
+      end
+    end
+  end
+end

data/lib/smart_rag/models/model_base.rb

@@ -0,0 +1,106 @@
+require 'sequel'
+
+module SmartRAG
+  module Models
+    # Module to add FactoryBot compatibility methods to Sequel models
+    module FactoryBotHelpers
+      # Save! method for compatibility with FactoryBot and ActiveRecord style
+      def save!(*args)
+        save(*args) || raise(Sequel::ValidationFailed, errors.full_messages.join(', '))
+      end
+
+      # Create! class method for compatibility with FactoryBot
+      def self.included(base)
+        base.class_eval do
+          def self.create!(attributes = {})
+            instance = new(attributes)
+            instance.save! || raise(Sequel::ValidationFailed, instance.errors.full_messages.join(', '))
+            instance
+          end
+        end
+      end
+
+      def to_hash
+        values
+      end
+
+      def to_json(*args)
+        to_hash.to_json(*args)
+      end
+    end
+
+    # Stub database class that allows models to be loaded without connection
+    class DelayedConnection
+      # Allow any method calls during model class definition
+      def method_missing(method_name, *args, &block)
+        # Return a stub object that accepts any method call
+        # This allows Sequel's internal setup to proceed
+        StubDataset.new(self)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        true  # Pretend to respond to everything
+      end
+
+      def kind_of?(other)
+        other == Sequel::Database || super
+      end
+
+      # Sequel needs these methods during model class definition
+      def schema(*args)
+        []  # Return empty schema
+      end
+
+      def tables(*args)
+        []  # Return empty tables list
+      end
+
+      def transaction(*args)
+        yield
+      end
+
+      def class_scope(*args)
+        self
+      end
+
+      def from(*args)
+        StubDataset.new(self)
+      end
+    end
+
+    # Stub dataset class for delayed connection
+    class StubDataset
+      def initialize(db)
+        @db = db
+      end
+
+      def method_missing(method_name, *args, **kwargs, &block)
+        # Return self to chain calls
+        self
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        true
+      end
+
+      def clone(*args, **kwargs)
+        self
+      end
+    end
+
+    # Set a stub database connection so Sequel::Model subclasses can be defined
+    # This will be replaced with a real connection when SmartRAG::Models.db= is called
+    begin
+      Sequel::Model.db
+    rescue Sequel::Error
+      # No database set yet, set our stub connection
+      Sequel::Model.db = DelayedConnection.new
+    end
+
+    # Base class placeholder - models inherit directly from Sequel::Model
+    # This class is just for organization and documentation
+    module ModelBase
+    end
+  end
+end
+

data/lib/smart_rag/models/research_topic.rb

@@ -0,0 +1,171 @@
+require_relative "model_base"
+require "sequel/plugins/validation_helpers"
+
+module SmartRAG
+  module Models
+    # ResearchTopic model for organizing content by topics
+    class ResearchTopic < Sequel::Model
+      # Set dataset after database is connected
+      def self.set_dataset_from_db
+        set_dataset(:research_topics)
+      end
+      include FactoryBotHelpers
+      plugin :validation_helpers
+      plugin :timestamps, update_on_create: true
+
+      # Add bang methods for FactoryBot compatibility
+      def self.create!(attributes = {})
+        instance = new(attributes)
+        instance.save! || raise(Sequel::ValidationFailed, instance.errors.full_messages.join(", "))
+        instance
+      end
+
+      # Relationships
+      one_to_many :research_topic_sections, class: '::SmartRAG::Models::ResearchTopicSection', key: :research_topic_id
+      one_to_many :research_topic_tags, class: '::SmartRAG::Models::ResearchTopicTag', key: :research_topic_id
+      many_to_many :sections, class: '::SmartRAG::Models::SourceSection',
+                   join_table: :research_topic_sections,
+                   left_key: :research_topic_id,
+                   right_key: :section_id
+      many_to_many :tags, class: '::SmartRAG::Models::Tag',
+                   join_table: :research_topic_tags,
+                   left_key: :research_topic_id,
+                   right_key: :tag_id
+
+      # Validation
+      def validate
+        super
+        validates_presence :name
+        validates_max_length 500, :name
+        validates_presence :description, allow_nil: true
+      end
+
+      # Class methods
+      class << self
+        # Find topic by name
+        def find_by_name(name)
+          where(Sequel.ilike(:name, name)).first
+        end
+
+        # Search topics by name or description
+        def search(query)
+          where(Sequel.ilike(:name, "%#{query}%"))
+            .or(Sequel.ilike(:description, "%#{query}%"))
+        end
+
+        # Get topics with section count
+        def with_section_count
+          select(Sequel[:research_topics].*).select_append(Sequel.function(:count, :research_topic_sections__section_id).as(:section_count))
+            .left_join(:research_topic_sections, research_topic_id: :id)
+            .group(:research_topics__id)
+            .order(Sequel.desc(:section_count))
+        end
+
+        # Get topics by tag
+        def by_tag(tag_id)
+          where(id: db[:research_topic_tags].select(:research_topic_id).where(tag_id: tag_id))
+        end
+
+        # Get recently used topics
+        def recent(limit: 10)
+          order(Sequel.desc(:created_at)).limit(limit)
+        end
+
+        # Batch create topics
+        def batch_create(topics)
+          db.transaction do
+            topics.map { |topic_data| create(topic_data) }
+          end
+        end
+      end
+
+      # Instance methods
+
+      # Add section to topic
+      def add_section(section)
+        unless sections.include?(section)
+          self.add_section(section)
+        end
+      end
+
+      # Remove section from topic
+      def remove_section(section)
+        if sections.include?(section)
+          self.remove_section(section)
+        end
+      end
+
+      # Add tag to topic
+      def add_tag(tag)
+        unless tags.include?(tag)
+          self.add_tag(tag)
+        end
+      end
+
+      # Remove tag from topic
+      def remove_tag(tag)
+        if tags.include?(tag)
+          self.remove_tag(tag)
+        end
+      end
+
+      # Count sections for this topic
+      def section_count
+        sections.count
+      end
+
+      # Count tags for this topic
+      def tag_count
+        tags.count
+      end
+
+      # Get related topics (share sections or tags)
+      def related_topics(limit: 5)
+        topic_ids = db[:research_topic_sections]
+                    .select(:research_topic_id)
+                    .where(section_id: sections.map(&:id))
+                    .where.not(research_topic_id: id)
+                    .group(:research_topic_id)
+                    .order(Sequel.desc(Sequel.function(:count, :*)))
+                    .limit(limit)
+
+        self.class.where(id: topic_ids).all
+      end
+
+      # Get topics info
+      def info
+        {
+          id: id,
+          name: name,
+          section_count: section_count,
+          tag_count: tag_count,
+          created_at: created_at
+        }
+      end
+
+      # String representation
+      def to_s
+        "<ResearchTopic: #{id} - #{name} (#{section_count} sections, #{tag_count} tags)>"
+      end
+
+      # Alias name as title for API compatibility
+      def title
+        name
+      end
+
+      def title=(value)
+        self.name = value
+      end
+
+      # Alias created_at as updated_at for API compatibility
+      def updated_at
+        @updated_at || created_at
+      end
+
+      # Allow updated_at= for API compatibility (stored in memory only, not DB)
+      def updated_at=(value)
+        @updated_at = value
+      end
+    end
+  end
+end

data/lib/smart_rag/models/research_topic_section.rb

@@ -0,0 +1,86 @@
+require_relative "model_base"
+require "sequel/plugins/validation_helpers"
+
+module SmartRAG
+  module Models
+    # ResearchTopicSection model for many-to-many relationship
+    class ResearchTopicSection < Sequel::Model(:research_topic_sections)
+      include FactoryBotHelpers
+      plugin :validation_helpers
+      plugin :timestamps, update_on_create: false
+
+      # Allow mass assignment of primary keys
+      unrestrict_primary_key
+
+      # Add bang methods for FactoryBot compatibility
+      def self.create!(attributes = {})
+        instance = new(attributes)
+        instance.save! || raise(Sequel::ValidationFailed, instance.errors.full_messages.join(", "))
+        instance
+      end
+
+      # Relationships
+      many_to_one :research_topic, class: '::SmartRAG::Models::ResearchTopic', key: :research_topic_id
+      many_to_one :section, class: '::SmartRAG::Models::SourceSection', key: :section_id
+
+      # Validation
+      def validate
+        super
+        validates_presence [:research_topic_id, :section_id]
+        validates_unique [:research_topic_id, :section_id]
+      end
+
+      # Class methods
+      class << self
+        # Find by topic and section
+        def find_by_topic_and_section(topic_id, section_id)
+          where(research_topic_id: topic_id, section_id: section_id).first
+        end
+
+        # Get all sections for a topic
+        def sections_for_topic(topic_id)
+          where(research_topic_id: topic_id).all
+        end
+
+        # Get all topics for a section
+        def topics_for_section(section_id)
+          where(section_id: section_id).all
+        end
+
+        # Delete all sections for a topic
+        def delete_all_for_topic(topic_id)
+          where(research_topic_id: topic_id).delete
+        end
+
+        # Delete all topics for a section
+        def delete_all_for_section(section_id)
+          where(section_id: section_id).delete
+        end
+
+        # Bulk create associations
+        def bulk_create(associations)
+          db.transaction do
+            dataset.multi_insert(associations)
+          end
+        end
+
+        # Check if section belongs to topic
+        def in_topic?(topic_id, section_id)
+          where(research_topic_id: topic_id, section_id: section_id).count > 0
+        end
+
+        # Get recent associations
+        def recent(limit: 50)
+          order(Sequel.desc(:created_at)).limit(limit)
+        end
+      end
+
+      # Instance methods
+
+      # String representation
+      def to_s
+        "<ResearchTopicSection: topic:#{research_topic_id} => section:#{section_id}>"
+      end
+    end
+  end
+end

data/lib/smart_rag/models/research_topic_tag.rb

@@ -0,0 +1,89 @@
+require_relative "model_base"
+require "sequel/plugins/validation_helpers"
+
+module SmartRAG
+  module Models
+    # ResearchTopicTag model for many-to-many relationship between topics and tags
+    class ResearchTopicTag < Sequel::Model(:research_topic_tags)
+      include FactoryBotHelpers
+      plugin :validation_helpers
+      plugin :timestamps, update_on_create: false
+      # Allow mass assignment of composite primary key
+      unrestrict_primary_key
+
+      # Add bang methods for FactoryBot compatibility
+      def self.create!(attributes = {})
+        instance = new(attributes)
+        instance.save! || raise(Sequel::ValidationFailed, instance.errors.full_messages.join(", "))
+        instance
+      end
+
+      # Relationships
+      many_to_one :research_topic, class: '::SmartRAG::Models::ResearchTopic', key: :research_topic_id
+      many_to_one :tag, class: '::SmartRAG::Models::Tag', key: :tag_id
+
+      # Validation
+      def validate
+        super
+        validates_presence [:research_topic_id, :tag_id]
+        validates_unique [:research_topic_id, :tag_id]
+      end
+
+      # Class methods
+      class << self
+        # Find by topic and tag
+        def find_by_topic_and_tag(topic_id, tag_id)
+          where(research_topic_id: topic_id, tag_id: tag_id).first
+        end
+
+        # Get all tags for a topic
+        def tags_for_topic(topic_id)
+          where(research_topic_id: topic_id).all
+        end
+
+        # Get all topics for a tag
+        def topics_for_tag(tag_id)
+          where(tag_id: tag_id).all
+        end
+
+        # Delete all tags for a topic
+        def delete_all_for_topic(topic_id)
+          where(research_topic_id: topic_id).delete
+        end
+
+        # Delete all topics for a tag
+        def delete_all_for_tag(tag_id)
+          where(tag_id: tag_id).delete
+        end
+
+        # Bulk create associations
+        def bulk_create(associations)
+          db.transaction do
+            dataset.multi_insert(associations)
+          end
+        end
+
+        # Check if topic has a specific tag
+        def has_tag?(topic_id, tag_id)
+          where(research_topic_id: topic_id, tag_id: tag_id).count > 0
+        end
+
+        # Get popular tags for topics
+        def popular_tags(limit: 20)
+          db[:research_topic_tags]
+            .select(:tag_id, Sequel.function(:count, :research_topic_id).as(:topic_count))
+            .group(:tag_id)
+            .order(Sequel.desc(:topic_count))
+            .limit(limit)
+        end
+      end
+
+      # Instance methods
+
+      # String representation
+      def to_s
+        "<ResearchTopicTag: topic:#{research_topic_id} => tag:#{tag_id}>"
+      end
+    end
+  end
+end