legion-llm 0.5.10 → 0.5.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6cff6f387230b6d2905a8e6a9a375cd99f35b983b932470c62978f1dc6203614
-  data.tar.gz: 144ead2b968bfd62687ade350b64082beb6d8192cfcd07171fa6084659196ba9
+  metadata.gz: 66044d638a0a53f9694fe2c208092bd62f980e46ffe6c94e11a2e4e1189faff1
+  data.tar.gz: 2c59beb39f98553ed9727adb0efb36cb1c7327780e27b7c39aa8fc39a8a1998f
 SHA512:
-  metadata.gz: dcf8fcd4d3f75a6d0d363bc75302d3717fc14c43747c40cd5a05f5787db2041bc7d73506c55e18a310d61f03e271faa8db7e12d0612f712386f781c927a9b888
-  data.tar.gz: 5b51860f5255efd71b5bb6d0565cb6b7db9795cd84cc9b23edaf749489966596b801490e9382cc30b5897ade6407c72860ba68e20deef003e66c17c4ae621b2f
+  metadata.gz: 13026e19ff1630411693f56fd4cd1a122fc85b4796aa5c9361c443464a5ef2a46c1bdc07106f1d104d015e75532bc43af70e56eb4e8a094c3afe48c700032bb4
+  data.tar.gz: 0dbd5234f42d24ae82c893c11ee3446fae3a74146246cbc42417ec129112ea140dc3788231ab6629357a3634ccc72715fb11b8e4c8b4749aa04cd14886c8efa0

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Legion LLM Changelog
 
+## [0.5.11] - 2026-03-25
+
+### Added
+- `Legion::LLM.can_embed?` — cached boolean for embedding capability
+- `Legion::LLM.embedding_provider` — current embedding provider symbol
+- `Legion::LLM.embedding_model` — current embedding model string
+- Boot-time embedding detection with configurable provider fallback chain (ollama -> bedrock -> openai)
+- 1024-dimension enforcement on all embedding responses (truncate if larger, reject if smaller)
+- Runtime failover: if cached embedding provider fails, walks fallback chain for next available
+- `llm.embedding.*` settings block with `provider_fallback`, `provider_models`, `ollama_preferred`, `dimension`, `enforce_dimension`
+
+### Changed
+- `Embeddings.generate` now uses cached provider/model from boot detection when no explicit provider given
+- `Embeddings.generate` enforces exactly 1024 dimensions by default (configurable via `enforce_dimension: false`)
+- Bedrock Titan model updated to `amazon.titan-embed-text-v2:0`
+
 ## [0.5.10] - 2026-03-25
 
 ### Added

data/lib/legion/llm/embeddings.rb

@@ -2,9 +2,11 @@
 
 module Legion
   module LLM
+    class EmbeddingUnavailableError < LLMError; end
+
     module Embeddings
       PROVIDER_EMBEDDING_MODELS = {
-        bedrock:   'amazon.titan-embed-text-v2',
+        bedrock:   'amazon.titan-embed-text-v2:0',
         anthropic: nil,
         openai:    'text-embedding-3-small',
         gemini:    'text-embedding-004',
@@ -12,37 +14,32 @@ module Legion
         ollama:    'mxbai-embed-large'
       }.freeze
 
+      TARGET_DIMENSION = 1024
+
       class << self
         def generate(text:, model: nil, provider: nil, dimensions: nil)
+          return { vector: nil, model: model, provider: provider, error: 'LLM not started' } unless LLM.started?
+
           provider ||= resolve_provider
           model    ||= resolve_model(provider)
-          opts = { model: model }
-          opts[:provider]   = provider if provider
-          opts[:dimensions] = dimensions if dimensions
-
-          response = RubyLLM.embed(text, **opts)
-          {
-            vector:     response.vectors.first,
-            model:      model,
-            provider:   provider,
-            dimensions: response.vectors.first&.size || 0,
-            tokens:     response.input_tokens
-          }
+          response   = RubyLLM.embed(text, **build_opts(model, provider, dimensions))
+          vector     = apply_dimension_enforcement(response.vectors.first, provider)
+          return dimension_error(model, provider, vector) if vector.is_a?(String)
+
+          { vector: vector, model: model, provider: provider, dimensions: vector&.size || 0, tokens: response.input_tokens }
         rescue StandardError => e
           Legion::Logging.warn "Embedding failed (#{provider}/#{model}): #{e.message}" if defined?(Legion::Logging)
-          { vector: nil, model: model, provider: provider, error: e.message }
+          handle_embed_failure(e, text: text, failed_provider: provider, failed_model: model)
         end
 
         def generate_batch(texts:, model: nil, provider: nil, dimensions: nil)
+          return texts.map { |_| { vector: nil, error: 'LLM not started' } } unless LLM.started?
+
           provider ||= resolve_provider
           model    ||= resolve_model(provider)
-          opts = { model: model }
-          opts[:provider]   = provider if provider
-          opts[:dimensions] = dimensions if dimensions
-
-          response = RubyLLM.embed(texts, **opts)
+          response   = RubyLLM.embed(texts, **build_opts(model, provider, dimensions))
           response.vectors.each_with_index.map do |vec, i|
-            { vector: vec, model: model, provider: provider, dimensions: vec&.size || 0, index: i }
+            build_batch_entry(vec, model, provider, i)
           end
         rescue StandardError => e
           Legion::Logging.warn("Batch embedding failed (#{provider}/#{model}): #{e.message}") if defined?(Legion::Logging)
@@ -55,8 +52,89 @@ module Legion
 
         private
 
+        def build_opts(model, provider, dimensions)
+          target_dim = enforce_dimension? ? TARGET_DIMENSION : dimensions
+          opts = { model: model }
+          opts[:provider]   = provider if provider
+          opts[:dimensions] = target_dim if target_dim && provider&.to_sym == :openai
+          opts
+        end
+
+        def apply_dimension_enforcement(vector, provider)
+          return vector unless enforce_dimension? && vector.is_a?(Array)
+
+          enforce_dimensions(vector, provider)
+        end
+
+        def dimension_error(model, provider, message)
+          { vector: nil, model: model, provider: provider, error: "incompatible dimension: #{message}" }
+        end
+
+        def build_batch_entry(vec, model, provider, index)
+          vec = enforce_dimensions(vec, provider) if enforce_dimension? && vec.is_a?(Array)
+          { vector: vec.is_a?(String) ? nil : vec, model: model, provider: provider,
+            dimensions: vec.is_a?(Array) ? vec.size : 0, index: index }
+        end
+
+        def enforce_dimension?
+          embedding_settings[:enforce_dimension] != false
+        end
+
+        def enforce_dimensions(vector, _provider)
+          return vector if vector.size == TARGET_DIMENSION
+          return vector.first(TARGET_DIMENSION) if vector.size > TARGET_DIMENSION
+
+          "got #{vector.size}, need #{TARGET_DIMENSION} (provider cannot upscale)"
+        end
+
+        def handle_embed_failure(error, text:, failed_provider:, failed_model:)
+          fallback = find_fallback_provider(failed_provider)
+          if fallback
+            Legion::Logging.info "Embedding failover: #{failed_provider} -> #{fallback[:provider]}" if defined?(Legion::Logging)
+            LLM.instance_variable_set(:@embedding_provider, fallback[:provider])
+            LLM.instance_variable_set(:@embedding_model, fallback[:model])
+            generate(text: text, model: fallback[:model], provider: fallback[:provider])
+          else
+            { vector: nil, model: failed_model, provider: failed_provider, error: error.message }
+          end
+        end
+
+        def find_fallback_provider(failed_provider)
+          chain = embedding_settings[:provider_fallback] || %w[ollama bedrock openai]
+          models = embedding_settings[:provider_models] || {}
+          started = false
+
+          chain.each do |name|
+            sym = name.to_sym
+            if sym == failed_provider
+              started = true
+              next
+            end
+            next unless started
+
+            available = probe_fallback_provider(sym)
+            next unless available
+
+            model = available.is_a?(String) ? available : (models[name] || models[sym])&.to_s
+            return { provider: sym, model: model }
+          end
+          nil
+        end
+
+        def probe_fallback_provider(sym)
+          case sym
+          when :ollama
+            LLM.send(:detect_ollama_embedding,
+                     embedding_settings[:ollama_preferred] || %w[mxbai-embed-large])
+          else
+            LLM.send(:detect_cloud_embedding, sym)
+          end
+        end
+
         def resolve_provider
-          configured = Legion::Settings.dig(:llm, :embeddings, :provider)
+          return LLM.embedding_provider if LLM.embedding_provider
+
+          configured = embedding_settings[:provider]
           return configured&.to_sym if configured
 
           Legion::Settings.dig(:llm, :default_provider)&.to_sym
@@ -65,15 +143,31 @@ module Legion
         end
 
         def resolve_model(provider)
-          configured = Legion::Settings.dig(:llm, :embeddings, :default_model)
+          return LLM.embedding_model if LLM.embedding_model && provider == LLM.embedding_provider
+
+          configured = embedding_settings[:default_model]
           return configured if configured
 
+          resolve_model_from_settings(provider)
+        rescue StandardError
+          'text-embedding-3-small'
+        end
+
+        def resolve_model_from_settings(provider)
+          models = embedding_settings[:provider_models] || {}
+          pm = models[provider&.to_sym] || models[provider.to_s]
+          return pm.to_s if pm
+
           provider_default = PROVIDER_EMBEDDING_MODELS[provider&.to_sym] if provider
           return provider_default if provider_default
 
           'text-embedding-3-small'
+        end
+
+        def embedding_settings
+          Legion::Settings.dig(:llm, :embedding) || {}
         rescue StandardError
-          'text-embedding-3-small'
+          {}
         end
       end
     end

data/lib/legion/llm/settings.rb

@@ -20,7 +20,8 @@ module Legion
           arbitrage:        arbitrage_defaults,
           batch:            batch_defaults,
           scheduling:       scheduling_defaults,
-          rag:              rag_defaults
+          rag:              rag_defaults,
+          embedding:        embedding_defaults
         }
       end
 
@@ -127,6 +128,20 @@ module Legion
         }
       end
 
+      def self.embedding_defaults
+        {
+          dimension:         1024,
+          enforce_dimension: true,
+          provider_fallback: %w[ollama bedrock openai],
+          provider_models:   {
+            ollama:  'mxbai-embed-large',
+            bedrock: 'amazon.titan-embed-text-v2:0',
+            openai:  'text-embedding-3-small'
+          },
+          ollama_preferred:  %w[mxbai-embed-large bge-large snowflake-arctic-embed]
+        }
+      end
+
       def self.providers
         {
           bedrock:   {

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.5.10'
+    VERSION = '0.5.11'
   end
 end

data/lib/legion/llm.rb

@@ -43,6 +43,7 @@ module Legion
 
         configure_providers
         run_discovery
+        detect_embedding_capability
         set_defaults
 
         install_hooks
@@ -56,6 +57,9 @@ module Legion
       def shutdown
         Legion::Settings[:llm][:connected] = false
         @started = false
+        @can_embed = nil
+        @embedding_provider = nil
+        @embedding_model = nil
         Legion::Logging.info 'Legion::LLM shut down'
       end
 
@@ -63,6 +67,12 @@ module Legion
         @started == true
       end
 
+      def can_embed?
+        @can_embed == true
+      end
+
+      attr_reader :embedding_provider, :embedding_model
+
       def settings
         if Legion.const_defined?('Settings')
           Legion::Settings[:llm]
@@ -558,6 +568,68 @@ module Legion
         auto_configure_defaults
       end
 
+      def detect_embedding_capability
+        embedding_settings = settings[:embedding] || {}
+        found = find_embedding_provider(embedding_settings)
+        if found
+          @can_embed = true
+          @embedding_provider = found[:provider]
+          @embedding_model = found[:model]
+          Legion::Logging.info "Embedding available: #{@embedding_provider}:#{@embedding_model}"
+        else
+          @can_embed = false
+          Legion::Logging.info 'No embedding provider available'
+        end
+      rescue StandardError => e
+        @can_embed = false
+        Legion::Logging.warn "Embedding detection failed: #{e.message}" if defined?(Legion::Logging)
+      end
+
+      def find_embedding_provider(embedding_settings)
+        fallback = embedding_settings[:provider_fallback] || %w[ollama bedrock openai]
+        provider_models = embedding_settings[:provider_models] || {}
+        ollama_preferred = embedding_settings[:ollama_preferred] || %w[mxbai-embed-large bge-large snowflake-arctic-embed]
+
+        fallback.each do |provider_name|
+          provider = provider_name.to_sym
+          model = provider_models[provider_name] || provider_models[provider]
+          available = probe_embedding_provider(provider, ollama_preferred)
+          next unless available
+
+          resolved_model = available.is_a?(String) ? available : model&.to_s
+          return { provider: provider, model: resolved_model }
+        end
+        nil
+      end
+
+      def probe_embedding_provider(provider, ollama_preferred)
+        case provider
+        when :ollama then detect_ollama_embedding(ollama_preferred)
+        else              detect_cloud_embedding(provider)
+        end
+      end
+
+      def detect_ollama_embedding(preferred_models)
+        return nil unless defined?(Legion::LLM::Discovery::Ollama)
+        return nil unless settings.dig(:providers, :ollama, :enabled)
+
+        preferred_models.each do |model|
+          return model if Legion::LLM::Discovery::Ollama.model_available?(model)
+        end
+        nil
+      rescue StandardError
+        nil
+      end
+
+      def detect_cloud_embedding(provider)
+        provider_config = settings.dig(:providers, provider)
+        return nil unless provider_config.is_a?(Hash) && provider_config[:enabled]
+
+        true
+      rescue StandardError
+        nil
+      end
+
       def run_discovery
         return unless settings.dig(:providers, :ollama, :enabled)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.5.10
+  version: 0.5.11
 platform: ruby
 authors:
 - Esity