htm 0.0.10 → 0.0.14

data/lib/htm/configuration.rb

@@ -57,13 +57,35 @@ class HTM
   #   end
   #
   class Configuration
-    attr_accessor :embedding_generator, :tag_extractor, :token_counter
+    attr_accessor :embedding_generator, :tag_extractor, :proposition_extractor, :token_counter
     attr_accessor :embedding_model, :embedding_provider, :embedding_dimensions
     attr_accessor :tag_model, :tag_provider
-    attr_accessor :embedding_timeout, :tag_timeout, :connection_timeout
+    attr_accessor :proposition_model, :proposition_provider, :extract_propositions
+    attr_accessor :embedding_timeout, :tag_timeout, :proposition_timeout, :connection_timeout
     attr_accessor :logger
     attr_accessor :job_backend
     attr_accessor :week_start
+    attr_accessor :telemetry_enabled  # Enable OpenTelemetry metrics (default: false)
+
+    # Limit configuration
+    attr_accessor :max_embedding_dimension  # Max vector dimensions (default: 2000)
+    attr_accessor :max_tag_depth            # Max tag hierarchy depth (default: 4)
+
+    # Chunking configuration (for file loading)
+    attr_accessor :chunk_size               # Max characters per chunk (default: 1024)
+    attr_accessor :chunk_overlap            # Character overlap between chunks (default: 64)
+
+    # Circuit breaker configuration
+    attr_accessor :circuit_breaker_failure_threshold   # Failures before opening (default: 5)
+    attr_accessor :circuit_breaker_reset_timeout       # Seconds before half-open (default: 60)
+    attr_accessor :circuit_breaker_half_open_max_calls # Successes to close (default: 3)
+
+    # Relevance scoring weights (must sum to 1.0)
+    attr_accessor :relevance_semantic_weight  # Vector similarity weight (default: 0.5)
+    attr_accessor :relevance_tag_weight       # Tag overlap weight (default: 0.3)
+    attr_accessor :relevance_recency_weight   # Temporal freshness weight (default: 0.1)
+    attr_accessor :relevance_access_weight    # Access frequency weight (default: 0.1)
+    attr_accessor :relevance_recency_half_life_hours  # Decay half-life in hours (default: 168 = 1 week)
 
     # Provider-specific API keys and endpoints
     attr_accessor :openai_api_key, :openai_organization, :openai_project
@@ -97,48 +119,77 @@ class HTM
 
     def initialize
       # Default configuration - Ollama for local development
-      @embedding_provider = :ollama
-      @embedding_model = 'nomic-embed-text:latest'  # Include tag for Ollama models
-      @embedding_dimensions = 768
+      # All settings can be overridden via HTM_* environment variables
+      @embedding_provider                  = ENV.fetch('HTM_EMBEDDING_PROVIDER', 'ollama').to_sym
+      @embedding_model                     = ENV.fetch('HTM_EMBEDDING_MODEL', 'nomic-embed-text:latest')
+      @embedding_dimensions                = ENV.fetch('HTM_EMBEDDING_DIMENSIONS', 768).to_i
+
+      @tag_provider                        = ENV.fetch('HTM_TAG_PROVIDER', 'ollama').to_sym
+      @tag_model                           = ENV.fetch('HTM_TAG_MODEL', 'gemma3:latest')
 
-      @tag_provider = :ollama
-      @tag_model = 'gemma3:latest'  # Include tag for Ollama models
+      @proposition_provider                = ENV.fetch('HTM_PROPOSITION_PROVIDER', 'ollama').to_sym
+      @proposition_model                   = ENV.fetch('HTM_PROPOSITION_MODEL', 'gemma3:latest')
+      @extract_propositions                = ENV.fetch('HTM_EXTRACT_PROPOSITIONS', 'false').downcase == 'true'
 
       # Provider credentials from environment variables
-      @openai_api_key = ENV['OPENAI_API_KEY']
-      @openai_organization = ENV['OPENAI_ORGANIZATION']
-      @openai_project = ENV['OPENAI_PROJECT']
-      @anthropic_api_key = ENV['ANTHROPIC_API_KEY']
-      @gemini_api_key = ENV['GEMINI_API_KEY']
-      @azure_api_key = ENV['AZURE_OPENAI_API_KEY']
-      @azure_endpoint = ENV['AZURE_OPENAI_ENDPOINT']
-      @azure_api_version = ENV['AZURE_OPENAI_API_VERSION'] || '2024-02-01'
-      @ollama_url = ENV['OLLAMA_API_BASE'] || ENV['OLLAMA_URL'] || 'http://localhost:11434'
-      @huggingface_api_key = ENV['HUGGINGFACE_API_KEY']
-      @openrouter_api_key = ENV['OPENROUTER_API_KEY']
-      @bedrock_access_key = ENV['AWS_ACCESS_KEY_ID']
-      @bedrock_secret_key = ENV['AWS_SECRET_ACCESS_KEY']
-      @bedrock_region = ENV['AWS_REGION'] || 'us-east-1'
-      @deepseek_api_key = ENV['DEEPSEEK_API_KEY']
+      # These use standard provider env var names for compatibility
+      @openai_api_key                      = ENV.fetch('HTM_OPENAI_API_KEY', ENV['OPENAI_API_KEY'])
+      @openai_organization                 = ENV.fetch('HTM_OPENAI_ORGANIZATION', ENV['OPENAI_ORGANIZATION'])
+      @openai_project                      = ENV.fetch('HTM_OPENAI_PROJECT', ENV['OPENAI_PROJECT'])
+      @anthropic_api_key                   = ENV.fetch('HTM_ANTHROPIC_API_KEY', ENV['ANTHROPIC_API_KEY'])
+      @gemini_api_key                      = ENV.fetch('HTM_GEMINI_API_KEY', ENV['GEMINI_API_KEY'])
+      @azure_api_key                       = ENV.fetch('HTM_AZURE_API_KEY', ENV['AZURE_OPENAI_API_KEY'])
+      @azure_endpoint                      = ENV.fetch('HTM_AZURE_ENDPOINT', ENV['AZURE_OPENAI_ENDPOINT'])
+      @azure_api_version                   = ENV.fetch('HTM_AZURE_API_VERSION', ENV.fetch('AZURE_OPENAI_API_VERSION', '2024-02-01'))
+      @ollama_url                          = ENV.fetch('HTM_OLLAMA_URL', ENV['OLLAMA_API_BASE'] || ENV['OLLAMA_URL'] || 'http://localhost:11434')
+      @huggingface_api_key                 = ENV.fetch('HTM_HUGGINGFACE_API_KEY', ENV['HUGGINGFACE_API_KEY'])
+      @openrouter_api_key                  = ENV.fetch('HTM_OPENROUTER_API_KEY', ENV['OPENROUTER_API_KEY'])
+      @bedrock_access_key                  = ENV.fetch('HTM_BEDROCK_ACCESS_KEY', ENV['AWS_ACCESS_KEY_ID'])
+      @bedrock_secret_key                  = ENV.fetch('HTM_BEDROCK_SECRET_KEY', ENV['AWS_SECRET_ACCESS_KEY'])
+      @bedrock_region                      = ENV.fetch('HTM_BEDROCK_REGION', ENV.fetch('AWS_REGION', 'us-east-1'))
+      @deepseek_api_key                    = ENV.fetch('HTM_DEEPSEEK_API_KEY', ENV['DEEPSEEK_API_KEY'])
 
       # Timeout settings (in seconds) - apply to all LLM providers
-      @embedding_timeout = 120      # 2 minutes for embedding generation
-      @tag_timeout = 180            # 3 minutes for tag generation (LLM inference)
-      @connection_timeout = 30      # 30 seconds for initial connection
+      @embedding_timeout                   = ENV.fetch('HTM_EMBEDDING_TIMEOUT', 120).to_i
+      @tag_timeout                         = ENV.fetch('HTM_TAG_TIMEOUT', 180).to_i
+      @proposition_timeout                 = ENV.fetch('HTM_PROPOSITION_TIMEOUT', 180).to_i
+      @connection_timeout                  = ENV.fetch('HTM_CONNECTION_TIMEOUT', 30).to_i
+
+      # Limit settings
+      @max_embedding_dimension             = ENV.fetch('HTM_MAX_EMBEDDING_DIMENSION', 2000).to_i
+      @max_tag_depth                       = ENV.fetch('HTM_MAX_TAG_DEPTH', 4).to_i
+
+      # Chunking settings (for file loading)
+      @chunk_size                          = ENV.fetch('HTM_CHUNK_SIZE', 1024).to_i
+      @chunk_overlap                       = ENV.fetch('HTM_CHUNK_OVERLAP', 64).to_i
+
+      # Circuit breaker settings
+      @circuit_breaker_failure_threshold   = ENV.fetch('HTM_CIRCUIT_BREAKER_FAILURE_THRESHOLD', 5).to_i
+      @circuit_breaker_reset_timeout       = ENV.fetch('HTM_CIRCUIT_BREAKER_RESET_TIMEOUT', 60).to_i
+      @circuit_breaker_half_open_max_calls = ENV.fetch('HTM_CIRCUIT_BREAKER_HALF_OPEN_MAX_CALLS', 3).to_i
+
+      # Relevance scoring weights (should sum to 1.0)
+      @relevance_semantic_weight           = ENV.fetch('HTM_RELEVANCE_SEMANTIC_WEIGHT', 0.5).to_f
+      @relevance_tag_weight                = ENV.fetch('HTM_RELEVANCE_TAG_WEIGHT', 0.3).to_f
+      @relevance_recency_weight            = ENV.fetch('HTM_RELEVANCE_RECENCY_WEIGHT', 0.1).to_f
+      @relevance_access_weight             = ENV.fetch('HTM_RELEVANCE_ACCESS_WEIGHT', 0.1).to_f
+      @relevance_recency_half_life_hours   = ENV.fetch('HTM_RELEVANCE_RECENCY_HALF_LIFE_HOURS', 168.0).to_f
 
       # Default logger (STDOUT with INFO level)
-      @logger = default_logger
+      @logger                              = default_logger
 
-      # Auto-detect job backend based on environment
-      @job_backend = detect_job_backend
+      # Job backend: inline, thread, active_job, sidekiq (auto-detected if not set)
+      @job_backend                         = ENV['HTM_JOB_BACKEND'] ? ENV['HTM_JOB_BACKEND'].to_sym : detect_job_backend
 
-      # Timeframe parsing configuration
-      # :sunday (default) or :monday for week start day
-      @week_start = :sunday
+      # Timeframe parsing configuration: sunday or monday
+      @week_start                          = ENV.fetch('HTM_WEEK_START', 'sunday').to_sym
+
+      # Telemetry (OpenTelemetry metrics)
+      @telemetry_enabled                   = ENV.fetch('HTM_TELEMETRY_ENABLED', 'false').downcase == 'true'
 
       # Thread-safe Ollama model refresh tracking
-      @ollama_models_refreshed = false
-      @ollama_refresh_mutex = Mutex.new
+      @ollama_models_refreshed             = false
+      @ollama_refresh_mutex                = Mutex.new
 
       # Set default implementations
       reset_to_defaults
@@ -148,6 +199,7 @@ class HTM
     def reset_to_defaults
       @embedding_generator = default_embedding_generator
       @tag_extractor = default_tag_extractor
+      @proposition_extractor = default_proposition_extractor
       @token_counter = default_token_counter
     end
 
@@ -161,6 +213,10 @@ class HTM
         raise HTM::ValidationError, "tag_extractor must be callable (proc, lambda, or object responding to :call)"
       end
 
+      unless @proposition_extractor.respond_to?(:call)
+        raise HTM::ValidationError, "proposition_extractor must be callable (proc, lambda, or object responding to :call)"
+      end
+
       unless @token_counter.respond_to?(:call)
         raise HTM::ValidationError, "token_counter must be callable (proc, lambda, or object responding to :call)"
       end
@@ -185,6 +241,10 @@ class HTM
       if @tag_provider && !SUPPORTED_PROVIDERS.include?(@tag_provider)
         raise HTM::ValidationError, "tag_provider must be one of: #{SUPPORTED_PROVIDERS.join(', ')} (got #{@tag_provider.inspect})"
       end
+
+      if @proposition_provider && !SUPPORTED_PROVIDERS.include?(@proposition_provider)
+        raise HTM::ValidationError, "proposition_provider must be one of: #{SUPPORTED_PROVIDERS.join(', ')} (got #{@proposition_provider.inspect})"
+      end
     end
 
     # Normalize Ollama model name to include tag if missing
@@ -207,7 +267,9 @@ class HTM
     # @param provider [Symbol] The provider to configure (:openai, :anthropic, etc.)
     #
     def configure_ruby_llm(provider = nil)
-      require 'ruby_llm' unless defined?(RubyLLM)
+      # Always require ruby_llm to ensure full module is loaded
+      # (require is idempotent, and defined?(RubyLLM) can be true before configure method exists)
+      require 'ruby_llm'
 
       provider ||= @embedding_provider
 
@@ -400,57 +462,68 @@ class HTM
         model = @tag_provider == :ollama ? normalize_ollama_model(@tag_model) : @tag_model
 
         # Build prompt
-        ontology_context = if existing_ontology.any?
+        taxonomy_context = if existing_ontology.any?
           sample_tags = existing_ontology.sample([existing_ontology.size, 20].min)
-          "Existing ontology includes: #{sample_tags.join(', ')}\n"
+          "Existing taxonomy paths: #{sample_tags.join(', ')}\n\nPrefer reusing these paths when the text matches their domain."
         else
-          "This is a new ontology - create appropriate hierarchical tags.\n"
+          "This is a new taxonomy - establish clear root categories."
         end
 
         prompt = <<~PROMPT
-          Extract hierarchical topic tags from the following text.
+          Extract classification tags for this text using a HIERARCHICAL TAXONOMY.
 
-          #{ontology_context}
-          Format: root:level1:level2:level3 (use colons to separate levels)
+          A hierarchical taxonomy is a tree where each concept has exactly ONE parent path:
 
-          Rules:
-          - Use lowercase letters, numbers, and hyphens only
-          - Maximum depth: 4 levels (to prevent excessive nesting)
-          - Return 2-5 tags per text
-          - Tags should be reusable and consistent
-          - Prefer existing ontology tags when applicable
-          - Use hyphens for multi-word terms (e.g., natural-language-processing)
-
-          CRITICAL CONSTRAINTS:
-          - NO CIRCULAR REFERENCES: A concept cannot appear at both the root and leaf of the same path
-          - NO REDUNDANT DUPLICATES: Do not create the same concept in multiple branches
-            Example (WRONG): database:postgresql vs database-management:relational-databases:postgresql
-            Example (RIGHT): Choose ONE primary location
-          - CONSISTENT DEPTH: Similar concept types should be at similar depth levels
-            Example (WRONG): age:numeric vs name:individual:specific-name:john
-            Example (RIGHT): Both should be at similar depths under personal-data
-          - NO SELF-CONTAINMENT: A parent concept should never contain itself as a descendant
-            Example (WRONG): age:personal-information:personal-data:age
-            Example (RIGHT): personal-information:personal-data:age
-          - AVOID AMBIGUOUS CROSS-DOMAIN CONCEPTS: Each concept should have ONE primary parent
-            If a concept truly belongs in multiple domains, use the most specific/primary domain
+              domain
+              ├── category
+              │   ├── subcategory
+              │   │   └── specific-term
+              │   └── subcategory
+              └── category
+
+          #{taxonomy_context}
+
+          TAG FORMAT: domain:category:subcategory:term (colon-separated, max 4 levels)
+
+          LEVEL GUIDELINES:
+          - Level 1 (domain): Broad field (database, ai, web, security, devops)
+          - Level 2 (category): Major subdivision (database:relational, ai:machine-learning)
+          - Level 3 (subcategory): Specific area (database:relational:postgresql)
+          - Level 4 (term): Fine detail, use sparingly (database:relational:postgresql:extensions)
+
+          RULES:
+          1. Each concept belongs to ONE path only (no duplicates across branches)
+          2. Use lowercase, hyphens for multi-word terms (natural-language-processing)
+          3. Return 2-5 tags that best classify this text
+          4. Match existing taxonomy paths when applicable
+          5. More general tags are often better than overly specific ones
+
+          GOOD EXAMPLES:
+          - database:postgresql
+          - ai:machine-learning:embeddings
+          - web:api:rest
+          - programming:ruby:gems
+
+          BAD EXAMPLES:
+          - postgresql (missing domain - where does it belong?)
+          - database:postgresql AND data:storage:postgresql (duplicate concept)
+          - ai:ml:nlp:transformers:bert:embeddings (too deep)
 
           TEXT: #{text}
 
-          Return ONLY the topic tags, one per line, no explanations.
+          Return ONLY tags, one per line.
         PROMPT
 
         system_prompt = <<~SYSTEM.strip
-          You are a precise topic extraction system that prevents ontological errors.
+          You are a taxonomy classifier that assigns texts to a hierarchical classification tree.
 
-          Your job is to:
-          1. Extract hierarchical tags in format: root:subtopic:detail
-          2. Maintain consistency with existing ontology (no duplicates)
-          3. Prevent circular references and self-containing concepts
-          4. Keep hierarchies at consistent depth levels
-          5. Choose PRIMARY locations for concepts (no multi-parent confusion)
+          Core principle: Each concept has ONE canonical location in the tree. If "postgresql" exists under "database", never create it elsewhere.
 
-          Output ONLY topic tags, one per line.
+          Your task:
+          1. Identify the domains/topics present in the text
+          2. Build paths from general (root) to specific (leaf)
+          3. Reuse existing taxonomy branches when they fit
+          4. Output 2-5 classification paths, one per line
         SYSTEM
 
         # Use RubyLLM chat for tag extraction
@@ -474,6 +547,115 @@ class HTM
       end
     end
 
+    # Default proposition extractor using RubyLLM chat
+    #
+    # @return [Proc] Callable that takes text and returns array of propositions
+    #
+    def default_proposition_extractor
+      lambda do |text|
+        require 'ruby_llm' unless defined?(RubyLLM)
+
+        # Configure RubyLLM for the proposition provider
+        configure_ruby_llm(@proposition_provider)
+
+        # Refresh models for Ollama to discover local models (thread-safe)
+        if @proposition_provider == :ollama
+          @ollama_refresh_mutex.synchronize do
+            unless @ollama_models_refreshed
+              RubyLLM.models.refresh!
+              @ollama_models_refreshed = true
+            end
+          end
+        end
+
+        # Normalize Ollama model name (ensure it has a tag like :latest)
+        model = @proposition_provider == :ollama ? normalize_ollama_model(@proposition_model) : @proposition_model
+
+        # Build prompt
+        prompt = <<~PROMPT
+          Extract all ATOMIC factual propositions from the following text.
+
+          An atomic proposition expresses exactly ONE relationship or fact. If a statement combines multiple pieces of information (what, where, when, who, why), split it into separate propositions.
+
+          CRITICAL: Each proposition must contain only ONE of these:
+          - ONE subject-verb relationship
+          - ONE attribute or property
+          - ONE location, time, or qualifier
+
+          Example input: "Todd Warren plans to pursue a PhD in Music at the University of Texas."
+
+          CORRECT atomic output:
+          - Todd Warren plans to pursue a PhD.
+          - Todd Warren plans to study Music.
+          - Todd Warren plans to attend the University of Texas.
+          - The University of Texas offers a PhD program in Music.
+
+          WRONG (not atomic - combines multiple facts):
+          - Todd Warren plans to pursue a PhD in Music at the University of Texas.
+
+          Example input: "In 1969, Neil Armstrong became the first person to walk on the Moon during the Apollo 11 mission."
+
+          CORRECT atomic output:
+          - Neil Armstrong was an astronaut.
+          - Neil Armstrong walked on the Moon.
+          - Neil Armstrong walked on the Moon in 1969.
+          - Neil Armstrong was the first person to walk on the Moon.
+          - The Apollo 11 mission occurred in 1969.
+          - Neil Armstrong participated in the Apollo 11 mission.
+
+          Rules:
+          1. Split compound statements into separate atomic facts
+          2. Each proposition = exactly one fact
+          3. Use full names, never pronouns
+          4. Make each proposition understandable in isolation
+          5. Prefer more propositions over fewer
+
+          TEXT: #{text}
+
+          Return ONLY atomic propositions, one per line. Use a dash (-) prefix for each.
+        PROMPT
+
+        system_prompt = <<~SYSTEM.strip
+          You are an atomic fact extraction system. Your goal is maximum decomposition.
+
+          IMPORTANT: Break every statement into its smallest possible factual units.
+
+          A statement like "John bought a red car in Paris" contains FOUR facts:
+          - John bought a car.
+          - The car John bought is red.
+          - John made a purchase in Paris.
+          - John bought a car in Paris.
+
+          Always ask: "Can this be split further?" If yes, split it.
+
+          Rules:
+          1. ONE fact per proposition (subject-predicate or subject-attribute)
+          2. Never combine location + action + time in one proposition
+          3. Never combine multiple attributes in one proposition
+          4. Use full names, never pronouns
+          5. Each proposition must stand alone without context
+
+          Output ONLY propositions, one per line, prefixed with a dash (-).
+        SYSTEM
+
+        # Use RubyLLM chat for proposition extraction
+        chat = RubyLLM.chat(model: model)
+        chat.with_instructions(system_prompt)
+        response = chat.ask(prompt)
+
+        # Extract text from response
+        response_text = extract_text_from_response(response)
+
+        # Parse propositions (remove dash prefix, filter empty lines)
+        response_text.to_s
+          .split("\n")
+          .map(&:strip)
+          .map { |line| line.sub(/^[-*•]\s*/, '') }
+          .map(&:strip)
+          .reject(&:empty?)
+      end
+    end
+
     # Extract text content from RubyLLM chat response
     #
     # @param response [Object] RubyLLM chat response
@@ -553,6 +735,15 @@ class HTM
       HTM::TagService.extract(text, existing_ontology: existing_ontology)
     end
 
+    # Extract propositions using PropositionService
+    #
+    # @param text [String] Text to analyze
+    # @return [Array<String>] Extracted atomic propositions
+    #
+    def extract_propositions(text)
+      HTM::PropositionService.extract(text)
+    end
+
     # Count tokens using configured counter
     #
     # @param text [String] Text to count tokens for

data/lib/htm/database.rb

@@ -105,15 +105,19 @@ class HTM
         puts "=" * 100
       end
 
-      # Drop all HTM tables
+      # Drop all HTM tables (respects RAILS_ENV)
       #
-      # @param db_url [String] Database connection URL (uses ENV['HTM_DBURL'] if not provided)
+      # @param db_url [String] Database connection URL (uses default_config if not provided)
       # @return [void]
       #
       def drop(db_url = nil)
-        config = parse_connection_url(db_url || ENV['HTM_DBURL'])
+        config = db_url ? parse_connection_url(db_url) : default_config
         raise "Database configuration not found" unless config
 
+        env = ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+        puts "Environment: #{env}"
+        puts "Database: #{config[:dbname]}"
+
         conn = PG.connect(config)
 
         tables = ['nodes', 'node_tags', 'tags', 'robots', 'robot_nodes', 'file_sources', 'schema_migrations']
@@ -171,15 +175,15 @@ class HTM
         load seeds_file
       end
 
-      # Dump current database schema to db/schema.sql
+      # Dump current database schema to db/schema.sql (respects RAILS_ENV)
       #
       # Uses pg_dump to create a clean SQL schema file without data
       #
-      # @param db_url [String] Database connection URL (uses ENV['HTM_DBURL'] if not provided)
+      # @param db_url [String] Database connection URL (uses default_config if not provided)
       # @return [void]
       #
       def dump_schema(db_url = nil)
-        config = parse_connection_url(db_url || ENV['HTM_DBURL'])
+        config = db_url ? parse_connection_url(db_url) : default_config
         raise "Database configuration not found" unless config
 
         schema_file = File.expand_path('../../db/schema.sql', __dir__)
@@ -231,15 +235,15 @@ class HTM
         puts "  Size: #{File.size(schema_file)} bytes"
       end
 
-      # Load schema from db/schema.sql
+      # Load schema from db/schema.sql (respects RAILS_ENV)
       #
       # Uses psql to load the schema file
       #
-      # @param db_url [String] Database connection URL (uses ENV['HTM_DBURL'] if not provided)
+      # @param db_url [String] Database connection URL (uses default_config if not provided)
       # @return [void]
       #
       def load_schema(db_url = nil)
-        config = parse_connection_url(db_url || ENV['HTM_DBURL'])
+        config = db_url ? parse_connection_url(db_url) : default_config
         raise "Database configuration not found" unless config
 
         schema_file = File.expand_path('../../db/schema.sql', __dir__)
@@ -356,22 +360,25 @@ class HTM
         puts "  open #{doc_path}/README.md"
       end
 
-      # Show database info
+      # Show database info (respects RAILS_ENV)
       #
-      # @param db_url [String] Database connection URL (uses ENV['HTM_DBURL'] if not provided)
+      # @param db_url [String] Database connection URL (uses default_config if not provided)
       # @return [void]
       #
       def info(db_url = nil)
-        config = parse_connection_url(db_url || ENV['HTM_DBURL'])
+        config = db_url ? parse_connection_url(db_url) : default_config
         raise "Database configuration not found" unless config
 
+        env = ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+
         conn = PG.connect(config)
 
-        puts "\nHTM Database Information"
+        puts "\nHTM Database Information (#{env})"
         puts "=" * 80
 
         # Connection info
         puts "\nConnection:"
+        puts "  Environment: #{env}"
         puts "  Host: #{config[:host]}"
         puts "  Port: #{config[:port]}"
         puts "  Database: #{config[:dbname]}"
@@ -468,18 +475,35 @@ class HTM
         }
       end
 
-      # Get default database configuration
+      # Get default database configuration (respects RAILS_ENV)
       #
-      # @return [Hash, nil] Connection configuration hash
+      # Uses ActiveRecordConfig which reads from config/database.yml
+      # and respects RAILS_ENV for environment-specific database selection.
+      #
+      # @return [Hash, nil] Connection configuration hash with PG-style keys
       #
       def default_config
-        # Prefer HTM_DBURL if available
-        if ENV['HTM_DBURL']
-          parse_connection_url(ENV['HTM_DBURL'])
-        elsif ENV['HTM_DBNAME']
-          parse_connection_params
-        else
-          nil
+        require_relative 'active_record_config'
+
+        begin
+          ar_config = HTM::ActiveRecordConfig.load_database_config
+
+          # Convert ActiveRecord config keys to PG-style keys
+          {
+            host: ar_config[:host],
+            port: ar_config[:port],
+            dbname: ar_config[:database],
+            user: ar_config[:username],
+            password: ar_config[:password],
+            sslmode: ar_config[:sslmode] || 'prefer'
+          }
+        rescue StandardError
+          # Fallback to legacy behavior if ActiveRecordConfig fails
+          if ENV['HTM_DBURL']
+            parse_connection_url(ENV['HTM_DBURL'])
+          elsif ENV['HTM_DBNAME']
+            parse_connection_params
+          end
         end
       end
 

data/lib/htm/embedding_service.rb

@@ -15,23 +15,31 @@ class HTM
   # The actual LLM call is delegated to HTM.configuration.embedding_generator
   #
   class EmbeddingService
-    MAX_DIMENSION = 2000  # Maximum dimension for pgvector HNSW index
-
     # Circuit breaker for embedding API calls
     @circuit_breaker = nil
     @circuit_breaker_mutex = Mutex.new
 
     class << self
+      # Maximum embedding dimension (configurable, default 2000)
+      #
+      # @return [Integer] Max dimensions for pgvector HNSW index
+      #
+      def max_dimension
+        HTM.configuration.max_embedding_dimension
+      end
+
       # Get or create the circuit breaker for embedding service
       #
       # @return [HTM::CircuitBreaker] The circuit breaker instance
       #
       def circuit_breaker
+        config = HTM.configuration
         @circuit_breaker_mutex.synchronize do
           @circuit_breaker ||= HTM::CircuitBreaker.new(
             name: 'embedding_service',
-            failure_threshold: 5,
-            reset_timeout: 60
+            failure_threshold: config.circuit_breaker_failure_threshold,
+            reset_timeout: config.circuit_breaker_reset_timeout,
+            half_open_max_calls: config.circuit_breaker_half_open_max_calls
           )
         end
       end
@@ -74,25 +82,26 @@ class HTM
       actual_dimension = raw_embedding.length
 
       # Check dimension limit
-      if actual_dimension > MAX_DIMENSION
-        HTM.logger.warn "EmbeddingService: Embedding dimension #{actual_dimension} exceeds max #{MAX_DIMENSION}, truncating"
-        raw_embedding = raw_embedding[0...MAX_DIMENSION]
-        actual_dimension = MAX_DIMENSION
+      max_dim = max_dimension
+      if actual_dimension > max_dim
+        HTM.logger.warn "EmbeddingService: Embedding dimension #{actual_dimension} exceeds max #{max_dim}, truncating"
+        raw_embedding = raw_embedding[0...max_dim]
+        actual_dimension = max_dim
       end
 
-      # Pad to 2000 dimensions for consistent storage
+      # Pad to max dimensions for consistent storage
       storage_embedding = pad_embedding(raw_embedding)
 
       # Format for database storage
       storage_string = format_for_storage(storage_embedding)
 
-      HTM.logger.debug "EmbeddingService: Generated #{actual_dimension}D embedding (padded to #{MAX_DIMENSION})"
+      HTM.logger.debug "EmbeddingService: Generated #{actual_dimension}D embedding (padded to #{max_dim})"
 
       {
         embedding: raw_embedding,
         dimension: actual_dimension,
         storage_embedding: storage_string,
-        storage_dimension: MAX_DIMENSION
+        storage_dimension: max_dim
       }
 
     rescue HTM::CircuitBreakerOpenError
@@ -129,15 +138,16 @@ class HTM
       end
     end
 
-    # Pad embedding to MAX_DIMENSION with zeros
+    # Pad embedding to max_dimension with zeros
     #
     # @param embedding [Array<Float>] Original embedding
     # @return [Array<Float>] Padded embedding
     #
     def self.pad_embedding(embedding)
-      return embedding if embedding.length >= MAX_DIMENSION
+      max_dim = max_dimension
+      return embedding if embedding.length >= max_dim
 
-      embedding + Array.new(MAX_DIMENSION - embedding.length, 0.0)
+      embedding + Array.new(max_dim - embedding.length, 0.0)
     end
 
     # Format embedding for database storage