red-candle 1.2.1 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15a070c7424707802e4e82d00ef5532691d76d7627d28ab0a4b5f0ac7522471f
-  data.tar.gz: 112d038f09eda1a6b1751935057bfefbc2355d7b4962c85461de192e3c667980
+  metadata.gz: 2d5cfca9bb05ab3dd9e8b1f1d92db4d94190b9acf473a41c7eb8a35c51a1a94a
+  data.tar.gz: aa2028e08fde8be4d9fd55b9719beab8ee8afabdc240900f176d88f7888bae6f
 SHA512:
-  metadata.gz: cf43744df320c1d69773dad4713bb41e6fa9bd0f75359d3651aa53e429ac48615705682a61e793487d4a09a1f0d5a4aa28df18b3375de63916d9d1b91b2c98b2
-  data.tar.gz: 81fbfe62ba6135b22b34cfeb8ea99b39b12b3dbb2e4c56ac76a758903554ff9f1911132f0be86e8ca130077d6e44997cfcf61a96d48452c8e13995acf76c7e88
+  metadata.gz: 16426f08f0cf7fd5ec1353adb139702c662df714a9d6fa7c3ed4d8feac81ba0313dcb58874c13b76c47ef6d8ca6acf6e22c8818888bf1affbcbc3d3b3a6fde96
+  data.tar.gz: 82f161767e7214ed97f36127d979da634507584f3c8110aa4672876d78edd6c9af0494f473e1a22f83311f7ebdf7e7ab8c41ec6451e5cf433b6a5acdc2ea603f

data/Cargo.lock

@@ -2999,9 +2999,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "slab"
-version = "0.4.10"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04dc19736151f35336d325007ac991178d504a119863a2fcb3758cdb5e52c50d"
+checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
 [[package]]
 name = "smallvec"

data/LICENSE

@@ -1,7 +1,7 @@
 MIT License
 
 Copyright (c) 2023 kojix2
-Copyright (c) 2024 Christopher Petersen
+Copyright (c) 2024, 2025 Christopher Petersen
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,6 +1,6 @@
 <img src="/docs/assets/logo-title.png" alt="red-candle" height="80px">
 
-[![build](https://github.com/assaydepot/red-candle/actions/workflows/build.yml/badge.svg)](https://github.com/assaydepot/red-candle/actions/workflows/build.yml)
+[![build](https://github.com/scientist-labs/red-candle/actions/workflows/build.yml/badge.svg)](https://github.com/scientist-labs/red-candle/actions/workflows/build.yml)
 [![Gem Version](https://badge.fury.io/rb/red-candle.svg)](https://badge.fury.io/rb/red-candle)
 
 Run state-of-the-art **language models directly from Ruby**. No Python, no APIs, no external services - just Ruby with blazing-fast Rust under the hood. Hardware accelerated with **Metal (Mac)** and **CUDA (NVIDIA).** Red candle leverages the Rust ecosystem, notably [Candle](https://github.com/huggingface/candle) and [Magnus](https://github.com/matsadler/magnus), to provide a fast and efficient way to run LLMs in Ruby. See [Dependencies](#dependencies) for more.
@@ -363,6 +363,12 @@ require 'candle'
 # Initialize the reranker with a cross-encoder model
 reranker = Candle::Reranker.from_pretrained("cross-encoder/ms-marco-MiniLM-L-12-v2")
 
+# Or with custom max_length for truncation (default is 512)
+reranker = Candle::Reranker.from_pretrained(
+  "cross-encoder/ms-marco-MiniLM-L-12-v2",
+  max_length: 256  # Faster processing with less context
+)
+
 # Define your query and candidate documents
 query = "How many people live in London?"
 documents = [
@@ -469,6 +475,75 @@ The reranker uses a BERT-based architecture that:
 
 This joint processing allows cross-encoders to capture subtle semantic relationships between queries and documents, making them more accurate for reranking tasks, though at the cost of higher computational requirements.
 
+### Performance Considerations
+
+**Important**: The Reranker automatically truncates documents to ensure stable performance. The default maximum is 512 tokens, but this is configurable.
+
+#### Configurable Truncation
+
+You can adjust the `max_length` parameter to balance performance and context:
+
+```ruby
+# Default: 512 tokens (maximum context, ~300ms per doc on CPU)
+reranker = Candle::Reranker.from_pretrained(model_id)
+
+# Faster: 256 tokens (~60% faster, ~120ms per doc on CPU)
+reranker = Candle::Reranker.from_pretrained(model_id, max_length: 256)
+
+# Fastest: 128 tokens (~80% faster, ~60ms per doc on CPU)
+reranker = Candle::Reranker.from_pretrained(model_id, max_length: 128)
+```
+
+Choose based on your needs:
+- **512 tokens**: Maximum context for complex queries (default)
+- **256 tokens**: Good balance of speed and context
+- **128 tokens**: Fast processing for simple matching
+
+#### Performance Guidelines
+
+1. **Document Length**: Documents longer than ~400 words will be truncated
+   - The first 512 tokens (roughly 300-400 words) are used
+   - Consider splitting very long documents into chunks if full coverage is needed
+
+2. **Batch Size**: Process multiple documents in one call for efficiency
+   ```ruby
+   # Good: Single call with multiple documents
+   results = reranker.rerank(query, documents)
+
+   # Less efficient: Multiple calls
+   documents.map { |doc| reranker.rerank(query, [doc]) }
+   ```
+
+3. **Expected Performance**:
+   - **CPU**: ~0.3-0.5s per query-document pair
+   - **GPU (Metal/CUDA)**: ~0.05-0.1s per query-document pair
+   - Performance is consistent regardless of document length due to truncation
+
+4. **Chunking Strategy** for long documents:
+   ```ruby
+   def rerank_long_document(query, long_text, chunk_size: 300)
+     # Split into overlapping chunks
+     words = long_text.split
+     chunks = []
+
+     (0...words.length).step(chunk_size - 50) do |i|
+       chunk = words[i...(i + chunk_size)].join(" ")
+       chunks << chunk
+     end
+
+     # Rerank chunks
+     results = reranker.rerank(query, chunks)
+
+     # Return best chunk
+     results.max_by { |r| r[:score] }
+   end
+   ```
+
+5. **Memory Usage**:
+   - Model size: ~125MB
+   - Each batch processes all documents simultaneously
+   - Consider batching if you have many documents
+
 ## Tokenizer
 
 Red-Candle provides direct access to tokenizers for text preprocessing and analysis. This is useful for understanding how models process text, debugging issues, and building custom NLP pipelines.
@@ -874,7 +949,7 @@ Failed to load GGUF model: cannot find llama.attention.head_count in metadata (R
 FORK IT!
 
 ```
-git clone https://github.com/assaydepot/red-candle
+git clone https://github.com/scientist-labs/red-candle
 cd red-candle
 bundle
 bundle exec rake compile

data/ext/candle/src/ruby/reranker.rs

@@ -18,46 +18,48 @@ pub struct Reranker {
 }
 
 impl Reranker {
-    pub fn new(model_id: String, device: Option<Device>) -> Result<Self> {
+    pub fn new(model_id: String, device: Option<Device>, max_length: Option<usize>) -> Result<Self> {
         let device = device.unwrap_or(Device::best()).as_device()?;
-        Self::new_with_core_device(model_id, device)
+        let max_length = max_length.unwrap_or(512);  // Default to 512
+        Self::new_with_core_device(model_id, device, max_length)
     }
-        
-    fn new_with_core_device(model_id: String, device: CoreDevice) -> std::result::Result<Self, Error> {
+
+    fn new_with_core_device(model_id: String, device: CoreDevice, max_length: usize) -> std::result::Result<Self, Error> {
         let result = (|| -> std::result::Result<(BertModel, TokenizerWrapper, Linear, Linear), Box<dyn std::error::Error + Send + Sync>> {
             let api = Api::new()?;
             let repo = api.repo(Repo::new(model_id.clone(), RepoType::Model));
-            
+
             // Download model files
             let config_filename = repo.get("config.json")?;
             let tokenizer_filename = repo.get("tokenizer.json")?;
             let weights_filename = repo.get("model.safetensors")?;
-            
+
             // Load config
             let config = std::fs::read_to_string(config_filename)?;
             let config: Config = serde_json::from_str(&config)?;
 
-            // Setup tokenizer with padding
+            // Setup tokenizer with padding AND truncation
             let tokenizer = Tokenizer::from_file(tokenizer_filename)?;
             let tokenizer = TokenizerLoader::with_padding(tokenizer, None);
-            
+            let tokenizer = TokenizerLoader::with_truncation(tokenizer, max_length);
+
             // Load model weights
             let vb = unsafe {
                 VarBuilder::from_mmaped_safetensors(&[weights_filename], DType::F32, &device)?
             };
-            
+
             // Load BERT model
             let model = BertModel::load(vb.pp("bert"), &config)?;
-            
+
             // Load pooler layer (dense + tanh activation)
             let pooler = candle_nn::linear(config.hidden_size, config.hidden_size, vb.pp("bert.pooler.dense"))?;
-            
+
             // Load classifier layer for cross-encoder (single output score)
             let classifier = candle_nn::linear(config.hidden_size, 1, vb.pp("classifier"))?;
-            
+
             Ok((model, TokenizerWrapper::new(tokenizer), pooler, classifier))
         })();
-        
+
         match result {
             Ok((model, tokenizer, pooler, classifier)) => {
                 Ok(Self { model, tokenizer, pooler, classifier, device, model_id })
@@ -65,18 +67,18 @@ impl Reranker {
             Err(e) => Err(Error::new(magnus::exception::runtime_error(), format!("Failed to load model: {}", e))),
         }
     }
-    
+
     /// Extract CLS embeddings from the model output, handling Metal device workarounds
     fn extract_cls_embeddings(&self, embeddings: &Tensor) -> std::result::Result<Tensor, Error> {
         let cls_embeddings = if self.device.is_metal() {
             // Metal has issues with tensor indexing, use a different approach
             let (batch_size, seq_len, hidden_size) = embeddings.dims3()
                 .map_err(|e| Error::new(magnus::exception::runtime_error(), format!("Failed to get dims: {}", e)))?;
-            
+
             // Reshape to [batch * seq_len, hidden] then take first hidden vectors for each batch
             let reshaped = embeddings.reshape((batch_size * seq_len, hidden_size))
                 .map_err(|e| Error::new(magnus::exception::runtime_error(), format!("Failed to reshape: {}", e)))?;
-            
+
             // Extract CLS tokens (first token of each sequence)
             let mut cls_vecs = Vec::new();
             for i in 0..batch_size {
@@ -85,7 +87,7 @@ impl Reranker {
                     .map_err(|e| Error::new(magnus::exception::runtime_error(), format!("Failed to extract CLS: {}", e)))?;
                 cls_vecs.push(cls_vec);
             }
-            
+
             // Stack the CLS vectors
             Tensor::cat(&cls_vecs, 0)
                 .map_err(|e| Error::new(magnus::exception::runtime_error(), format!("Failed to cat CLS tokens: {}", e)))?
@@ -93,39 +95,39 @@ impl Reranker {
             embeddings.i((.., 0))
                 .map_err(|e| Error::new(magnus::exception::runtime_error(), format!("Failed to extract CLS token: {}", e)))?
         };
-        
+
         // Ensure tensor is contiguous for downstream operations
         cls_embeddings.contiguous()
             .map_err(|e| Error::new(magnus::exception::runtime_error(), format!("Failed to make CLS embeddings contiguous: {}", e)))
     }
-    
+
     pub fn debug_tokenization(&self, query: String, document: String) -> std::result::Result<magnus::RHash, Error> {
         // Create query-document pair for cross-encoder
         let query_doc_pair: EncodeInput = (query.clone(), document.clone()).into();
-        
+
         // Tokenize using the inner tokenizer for detailed info
         let encoding = self.tokenizer.inner().encode(query_doc_pair, true)
             .map_err(|e| Error::new(magnus::exception::runtime_error(), format!("Tokenization failed: {}", e)))?;
-        
+
         // Get token information
         let token_ids = encoding.get_ids().to_vec();
         let token_type_ids = encoding.get_type_ids().to_vec();
         let attention_mask = encoding.get_attention_mask().to_vec();
         let tokens = encoding.get_tokens().iter().map(|t| t.to_string()).collect::<Vec<_>>();
-        
+
         // Create result hash
         let result = magnus::RHash::new();
         result.aset("token_ids", RArray::from_vec(token_ids.iter().map(|&id| id as i64).collect::<Vec<_>>()))?;
         result.aset("token_type_ids", RArray::from_vec(token_type_ids.iter().map(|&id| id as i64).collect::<Vec<_>>()))?;
         result.aset("attention_mask", RArray::from_vec(attention_mask.iter().map(|&mask| mask as i64).collect::<Vec<_>>()))?;
         result.aset("tokens", RArray::from_vec(tokens))?;
-        
+
         Ok(result)
     }
-    
+
     pub fn rerank_with_options(&self, query: String, documents: RArray, pooling_method: String, apply_sigmoid: bool) -> std::result::Result<RArray, Error> {
         let documents: Vec<String> = documents.to_vec()?;
-        
+
         // Create query-document pairs for cross-encoder
         let query_and_docs: Vec<EncodeInput> = documents
             .iter()
@@ -135,13 +137,13 @@ impl Reranker {
         // Tokenize batch using inner tokenizer for access to token type IDs
         let encodings = self.tokenizer.inner().encode_batch(query_and_docs, true)
             .map_err(|e| Error::new(magnus::exception::runtime_error(), format!("Tokenization failed: {}", e)))?;
-        
+
         // Convert to tensors
         let token_ids = encodings
             .iter()
             .map(|e| e.get_ids().to_vec())
             .collect::<Vec<_>>();
-            
+
         let token_type_ids = encodings
             .iter()
             .map(|e| e.get_type_ids().to_vec())
@@ -153,11 +155,11 @@ impl Reranker {
             .map_err(|e| Error::new(magnus::exception::runtime_error(), format!("Failed to create token type ids tensor: {}", e)))?;
         let attention_mask = token_ids.ne(0u32)
             .map_err(|e| Error::new(magnus::exception::runtime_error(), format!("Failed to create attention mask: {}", e)))?;
-        
+
         // Forward pass through BERT
         let embeddings = self.model.forward(&token_ids, &token_type_ids, Some(&attention_mask))
             .map_err(|e| Error::new(magnus::exception::runtime_error(), format!("Model forward pass failed: {}", e)))?;
-        
+
         // Apply pooling based on the specified method
         let pooled_embeddings = match pooling_method.as_str() {
             "pooler" => {
@@ -181,10 +183,10 @@ impl Reranker {
                 (sum / (seq_len as f64))
                     .map_err(|e| Error::new(magnus::exception::runtime_error(), format!("Failed to compute mean: {}", e)))?
             },
-            _ => return Err(Error::new(magnus::exception::runtime_error(), 
+            _ => return Err(Error::new(magnus::exception::runtime_error(),
                 format!("Unknown pooling method: {}. Use 'pooler', 'cls', or 'mean'", pooling_method)))
         };
-        
+
         // Apply classifier to get relevance scores (raw logits)
         // Ensure tensor is contiguous before linear layer
         let pooled_embeddings = pooled_embeddings.contiguous()
@@ -193,7 +195,7 @@ impl Reranker {
             .map_err(|e| Error::new(magnus::exception::runtime_error(), format!("Classifier forward failed: {}", e)))?;
         let scores = logits.squeeze(1)
             .map_err(|e| Error::new(magnus::exception::runtime_error(), format!("Failed to squeeze tensor: {}", e)))?;
-        
+
         // Optionally apply sigmoid activation
         let scores = if apply_sigmoid {
             sigmoid(&scores)
@@ -201,7 +203,7 @@ impl Reranker {
         } else {
             scores
         };
-        
+
         let scores_vec: Vec<f32> = scores.to_vec1()
             .map_err(|e| Error::new(magnus::exception::runtime_error(), format!("Failed to convert scores to vec: {}", e)))?;
 
@@ -212,7 +214,7 @@ impl Reranker {
             .enumerate()
             .map(|(idx, (doc, score))| (doc, score, idx))
             .collect();
-        
+
         // Sort documents by relevance score (descending)
         ranked_docs.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
 
@@ -232,17 +234,17 @@ impl Reranker {
     pub fn tokenizer(&self) -> std::result::Result<crate::ruby::tokenizer::Tokenizer, Error> {
         Ok(crate::ruby::tokenizer::Tokenizer(self.tokenizer.clone()))
     }
-    
+
     /// Get the model_id
     pub fn model_id(&self) -> String {
         self.model_id.clone()
     }
-    
+
     /// Get the device
     pub fn device(&self) -> Device {
         Device::from_device(&self.device)
     }
-    
+
     /// Get all options as a hash
     pub fn options(&self) -> std::result::Result<magnus::RHash, Error> {
         let hash = magnus::RHash::new();
@@ -254,7 +256,7 @@ impl Reranker {
 
 pub fn init(rb_candle: RModule) -> std::result::Result<(), Error> {
     let c_reranker = rb_candle.define_class("Reranker", class::object())?;
-    c_reranker.define_singleton_method("_create", function!(Reranker::new, 2))?;
+    c_reranker.define_singleton_method("_create", function!(Reranker::new, 3))?;
     c_reranker.define_method("rerank_with_options", method!(Reranker::rerank_with_options, 4))?;
     c_reranker.define_method("debug_tokenization", method!(Reranker::debug_tokenization, 2))?;
     c_reranker.define_method("tokenizer", method!(Reranker::tokenizer, 0))?;

data/lib/candle/build_info.rb

@@ -3,8 +3,7 @@ module Candle
     def self.display_cuda_info
       info = Candle.build_info
       
-      # Only display CUDA info if running in development or if CANDLE_VERBOSE is set
-      return unless ENV['CANDLE_VERBOSE'] || ENV['CANDLE_DEBUG'] || $DEBUG
+      # CUDA info is now controlled by logger level
       
       if info["cuda_available"] == false
         # :nocov:
@@ -13,11 +12,11 @@ module Candle
                                    File.exist?('/usr/local/cuda') || File.exist?('/opt/cuda')
         
         if cuda_potentially_available
-          warn "=" * 80
-          warn "Red Candle: CUDA detected on system but not enabled in build."
-          warn "This may be due to CANDLE_DISABLE_CUDA being set during installation."
-          warn "To enable CUDA support, reinstall without CANDLE_DISABLE_CUDA set."
-          warn "=" * 80
+          Candle.logger.warn "=" * 80
+          Candle.logger.warn "Red Candle: CUDA detected on system but not enabled in build."
+          Candle.logger.warn "This may be due to CANDLE_DISABLE_CUDA being set during installation."
+          Candle.logger.warn "To enable CUDA support, reinstall without CANDLE_DISABLE_CUDA set."
+          Candle.logger.warn "=" * 80
         end
         # :nocov:
       end

data/lib/candle/device_utils.rb

@@ -3,7 +3,7 @@ module Candle
     # @deprecated Use {Candle::Device.best} instead
     # Get the best available device (Metal > CUDA > CPU)
     def self.best_device
-      warn "[DEPRECATION] `DeviceUtils.best_device` is deprecated. Please use `Device.best` instead."
+      Candle.logger.warn "[DEPRECATION] `DeviceUtils.best_device` is deprecated. Please use `Device.best` instead."
       Device.best
     end
   end

data/lib/candle/llm.rb

@@ -78,7 +78,7 @@ module Candle
         JSON.parse(json_content)
       rescue JSON::ParserError => e
         # Return the raw string if parsing fails
-        warn "Warning: Generated output is not valid JSON: #{e.message}" if options[:warn_on_parse_error]
+        Candle.logger.warn "Generated output is not valid JSON: #{e.message}" if options[:warn_on_parse_error]
         result
       end
     end
@@ -261,7 +261,7 @@ module Candle
           if e.message.include?("No tokenizer found")
             # Auto-detect tokenizer
             detected_tokenizer = guess_tokenizer(model_id)
-            warn "No tokenizer found in GGUF repo. Using tokenizer from: #{detected_tokenizer}"
+            Candle.logger.info "No tokenizer found in GGUF repo. Using tokenizer from: #{detected_tokenizer}"
             model_str = "#{model_str}@@#{detected_tokenizer}"
             _from_pretrained(model_str, device)
           else

data/lib/candle/logger.rb

@@ -0,0 +1,149 @@
+require 'logger'
+
+module Candle
+  # Logging functionality for the Red Candle gem
+  class << self
+    # Get the current logger instance
+    # @return [Logger] The logger instance
+    def logger
+      @logger ||= create_default_logger
+    end
+
+    # Set a custom logger instance
+    # @param custom_logger [Logger] A custom logger instance
+    def logger=(custom_logger)
+      @logger = custom_logger
+    end
+
+    # Configure logging with a block
+    # @yield [config] Configuration object
+    def configure_logging
+      config = LoggerConfig.new
+      yield config if block_given?
+      @logger = config.build_logger
+    end
+
+    private
+
+    # Create the default logger with CLI-friendly settings
+    # @return [Logger] Configured logger instance
+    def create_default_logger
+      logger = Logger.new($stderr)
+      logger.level = default_log_level
+      logger.formatter = cli_friendly_formatter
+      logger
+    end
+
+    # Determine default log level based on environment variables
+    # @return [Integer] Logger level constant
+    def default_log_level
+      # Support legacy CANDLE_VERBOSE for backward compatibility, but prefer explicit configuration
+      return Logger::DEBUG if ENV['CANDLE_VERBOSE']
+      Logger::WARN  # CLI-friendly: only show warnings/errors by default
+    end
+
+    # CLI-friendly formatter that outputs just the message
+    # @return [Proc] Formatter proc
+    def cli_friendly_formatter
+      proc { |severity, datetime, progname, msg| "#{msg}\n" }
+    end
+  end
+
+  # Configuration helper for logger setup
+  class LoggerConfig
+    attr_accessor :level, :output, :formatter
+
+    def initialize
+      @level = :warn
+      @output = $stderr
+      @formatter = :simple
+    end
+
+    # Build a logger from the configuration
+    # @return [Logger] Configured logger
+    def build_logger
+      logger = Logger.new(@output)
+      logger.level = normalize_level(@level)
+      logger.formatter = build_formatter(@formatter)
+      logger
+    end
+
+    # Set log level to debug (verbose output)
+    def verbose!
+      @level = :debug
+    end
+
+    # Set log level to info  
+    def info!
+      @level = :info
+    end
+
+    # Set log level to warn (default)
+    def quiet!
+      @level = :warn
+    end
+
+    # Set log level to error (minimal output)
+    def silent!
+      @level = :error
+    end
+
+    # Log to stdout instead of stderr
+    def log_to_stdout!
+      @output = $stdout
+    end
+
+    # Log to a file
+    # @param file_path [String] Path to log file
+    def log_to_file!(file_path)
+      @output = file_path
+    end
+
+    # Disable logging completely
+    def disable!
+      @output = File::NULL
+    end
+
+    private
+
+    # Convert symbol/string level to Logger constant
+    # @param level [Symbol, String, Integer] Log level
+    # @return [Integer] Logger level constant
+    def normalize_level(level)
+      case level.to_s.downcase
+      when 'debug' then Logger::DEBUG
+      when 'info' then Logger::INFO
+      when 'warn', 'warning' then Logger::WARN
+      when 'error' then Logger::ERROR
+      when 'fatal' then Logger::FATAL
+      else Logger::WARN
+      end
+    end
+
+    # Build formatter based on type
+    # @param formatter_type [Symbol] Type of formatter
+    # @return [Proc] Formatter proc
+    def build_formatter(formatter_type)
+      case formatter_type
+      when :simple, :cli
+        proc { |severity, datetime, progname, msg| "#{msg}\n" }
+      when :detailed
+        proc do |severity, datetime, progname, msg|
+          "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] #{severity}: #{msg}\n"
+        end
+      when :json
+        require 'json'
+        proc do |severity, datetime, progname, msg|
+          JSON.generate({
+            timestamp: datetime.iso8601,
+            level: severity,
+            message: msg,
+            program: progname
+          }) + "\n"
+        end
+      else
+        proc { |severity, datetime, progname, msg| "#{msg}\n" }
+      end
+    end
+  end
+end

data/lib/candle/ner.rb

@@ -196,7 +196,7 @@ module Candle
       # This is especially important for Ruby < 3.2
       max_length = 1_000_000  # 1MB of text
       if text.length > max_length
-        warn "PatternEntityRecognizer: Text truncated from #{text.length} to #{max_length} chars for safety"
+        Candle.logger.warn "PatternEntityRecognizer: Text truncated from #{text.length} to #{max_length} chars for safety"
         text = text[0...max_length]
       end
       

data/lib/candle/reranker.rb

@@ -6,18 +6,20 @@ module Candle
     # Load a pre-trained reranker model from HuggingFace
     # @param model_id [String] HuggingFace model ID (defaults to cross-encoder/ms-marco-MiniLM-L-12-v2)
     # @param device [Candle::Device] The device to use for computation (defaults to best available)
+    # @param max_length [Integer] Maximum sequence length for truncation (defaults to 512)
     # @return [Reranker] A new Reranker instance
-    def self.from_pretrained(model_id = DEFAULT_MODEL_PATH, device: Candle::Device.best)
-      _create(model_id, device)
+    def self.from_pretrained(model_id = DEFAULT_MODEL_PATH, device: Candle::Device.best, max_length: 512)
+      _create(model_id, device, max_length)
     end
     
     # Constructor for creating a new Reranker with optional parameters
     # @deprecated Use {.from_pretrained} instead
     # @param model_path [String, nil] The path to the model on Hugging Face
     # @param device [Candle::Device, Candle::Device.cpu] The device to use for computation
-    def self.new(model_path: DEFAULT_MODEL_PATH, device: Candle::Device.best)
+    # @param max_length [Integer] Maximum sequence length for truncation (defaults to 512)
+    def self.new(model_path: DEFAULT_MODEL_PATH, device: Candle::Device.best, max_length: 512)
       $stderr.puts "[DEPRECATION] `Reranker.new` is deprecated. Please use `Reranker.from_pretrained` instead."
-      _create(model_path, device)
+      _create(model_path, device, max_length)
     end
 
     # Returns documents ranked by relevance using the specified pooling method.

data/lib/candle/version.rb

@@ -1,5 +1,5 @@
 # :nocov:
 module Candle
-  VERSION = "1.2.1"
+  VERSION = "1.2.3"
 end
 # :nocov:

data/lib/candle.rb

@@ -1,3 +1,4 @@
+require_relative "candle/logger"
 require_relative "candle/candle"
 require_relative "candle/tensor"
 require_relative "candle/device_utils"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: red-candle
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.3
 platform: ruby
 authors:
 - Christopher Petersen
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-11 00:00:00.000000000 Z
+date: 2025-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -218,13 +218,14 @@ files:
 - lib/candle/embedding_model.rb
 - lib/candle/embedding_model_type.rb
 - lib/candle/llm.rb
+- lib/candle/logger.rb
 - lib/candle/ner.rb
 - lib/candle/reranker.rb
 - lib/candle/tensor.rb
 - lib/candle/tokenizer.rb
 - lib/candle/version.rb
 - lib/red-candle.rb
-homepage: https://github.com/assaydepot/red-candle
+homepage: https://github.com/scientist-labs/red-candle
 licenses:
 - MIT
 metadata: {}