deepsearch-rb 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 435d04eb1b8c5a7d2d8e86cd17b863766559f82ffe4f194597e9b05a087b5ae0
-  data.tar.gz: 1f394f33996d8f85b17e17709a3178debb8ccad84d8268bd7590b532ac0d9fa7
+  metadata.gz: 91d4780990957a409d46cf941454353f54645dcdda52e7dcd5a89e393dd58a27
+  data.tar.gz: b1761828c3b3c263ed9970cfc7ed44bb99883f8f08bce1a3a5309c3135f0bc5a
 SHA512:
-  metadata.gz: 30634e66e50d377e755fe82354255d8b1e265578aca7e8f4c4833e8959ff33277a9a120c56b96c93efb13ea6e890cec8ddbf06d5952c0ef384efaceb3f8f8839
-  data.tar.gz: fca34ac34b09e4a8c5558c8114853dfec7c982fdf4bb9f630068c8ebf60bc398b1f711d5443b4e30aedc04c78539de24dcbf8a33761a719eb9815d8b38e37499
+  metadata.gz: 5750aeb0a5c696adde1466eaa8f103f15774bd57c92ca2c93bcd933b47d2238b2e9a975eea2a20eadfa6ae517e625e8fbe0c1d0f130020ed532c264426b32209
+  data.tar.gz: 472b52a34a5a07209693ff92f40d03ffcd7b90d2d01df31d608b3947c3ac39a29e04745f2de7d6ef051104c27762a072f7e5ed8a8b17e5ef17c316553dc61276

data/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Released]
 
+## [0.1.2] - 2025-09-17
+
+### Fixed
+- Fixed compatibility with a new version of RubyLLM 
+
+## [Released]
+
+## [0.1.1] - 2025-07-20
+
+### Added
+- Calls to embedding API are now executed async
+- Added multi-step-chain example
+
+## [Released]
+
 ## [0.1.0] - 2025-07-12
 
 ### Added

data/README.md

@@ -13,14 +13,8 @@ The only runtime dependencies are [ruby_llm](https://github.com/crmne/ruby_llm?t
 
 ---
 
-**NOTE**: You can implement your own chains in the way it works for you, BFS/DFS search on any topic. A draft code might look like: 
-
-```
-Deepsearch.search(initial search) -> 
-  LLM(Generate additional queries) ->
-    Async [for each additional query]{ Deepsearch.search(sub-query) } ->
-      Aggregate()
-```
+**NOTE**: You can also implement your own chains in the way it works for you, BFS/DFS search on any topic.
+See the draft implementation of multi-chain flow in `examples/multi-step-chain/script.rb`
 
 ## Installation
 

data/lib/deepsearch/configuration.rb

@@ -13,21 +13,38 @@ module Deepsearch
   #     config.ruby_llm.default_model = "gpt-4o-mini"
   #     config.ruby_llm.request_timeout = 90
   #   end
+  #
   class RubyLLMConfig
-    SUPPORTED_ATTRIBUTES = %i[
-      openai_api_key openai_organization_id openai_project_id
-      anthropic_api_key gemini_api_key deepseek_api_key openrouter_api_key
-      ollama_api_base bedrock_api_key bedrock_secret_key bedrock_region
-      bedrock_session_token openai_api_base default_model
-      default_embedding_model default_image_model request_timeout max_retries
-      retry_interval retry_backoff_factor retry_interval_randomness
-      http_proxy logger log_file log_level log_assume_model_exists
-    ].freeze
+    def self.supported_attributes
+      @supported_attributes ||= discover_attributes
+    end
+
+    def self.reset_supported_attributes!
+      @supported_attributes = nil
+    end
+
+    private
+
+    def self.discover_attributes
+      if defined?(RubyLLM::Configuration)
+        config_instance = RubyLLM::Configuration.new
+      else
+        require "ruby_llm"
+        config_instance = RubyLLM::Configuration.new
+      end
+      
+      # Getting all setter methods (ending with =) and remove the = suffix
+      config_instance.public_methods(false)
+        .select { |method| method.to_s.end_with?('=') }
+        .map { |method| method.to_s.chomp('=').to_sym }
+        .reject { |attr| [:configuration].include?(attr) }
+    end
+
+    public
 
-    attr_accessor(*SUPPORTED_ATTRIBUTES)
+    attr_accessor(*supported_attributes)
 
     def initialize
-      # Set some sensible defaults for Deepsearch's use case
       @default_model = "gpt-4o-mini"
       @default_embedding_model = "text-embedding-3-small"
       @request_timeout = 30 # seconds
@@ -35,7 +52,6 @@ module Deepsearch
     end
   end
 
-  # Configuration class for managing gem settings
   class Configuration
     # @!attribute listener
     #   An object that can listen to events from the Deepsearch pipeline.
@@ -47,7 +63,8 @@ module Deepsearch
     #       end
     #     end
     #     Deepsearch.configure { |c| c.listener = MyListener.new
-    attr_accessor :tavily_api_key, :serper_api_key, :search_adapter, :custom_search_adapter_class, :logger, :listener, :prompts
+    attr_accessor :tavily_api_key, :serper_api_key, :search_adapter, :custom_search_adapter_class, :logger, :listener,
+                  :prompts
     attr_reader :ruby_llm
 
     def initialize
@@ -61,7 +78,6 @@ module Deepsearch
       @prompts = PromptsConfig.new
     end
 
-    # Reset configuration to default values
     def reset!
       @tavily_api_key = nil
       @serper_api_key = nil
@@ -72,14 +88,13 @@ module Deepsearch
       @prompts = PromptsConfig.new
     end
 
-    # Configure RubyLLM with current settings from the `ruby_llm` config object.
+    # Configure RubyLLM with current settings from the `RubyLLMConfig` config object.
     def configure_llm!
-      require "ruby_llm"
+      require "ruby_llm" unless defined?(RubyLLM)
 
       RubyLLM.configure do |config|
-        RubyLLMConfig::SUPPORTED_ATTRIBUTES.each do |attr|
-          value = @ruby_llm.public_send(attr)
-          # Only set the value if it's not nil to avoid overriding RubyLLM's internal defaults.
+        RubyLLMConfig.supported_attributes.each do |attr|
+          value = @ruby_llm.public_send(attr)          
           config.public_send("#{attr}=", value) unless value.nil?
         end
       end

data/lib/deepsearch/engine/pipeline.rb

@@ -31,7 +31,6 @@ module Deepsearch
         #   - original_query [String] The unmodified input query
         #   - sub_queries [Array<String>] Generated subqueries (empty array on error)
         #   - error [String, nil] Error message if processing failed
-        
 
         parallel_search_options = {
           initial_query: query_preprocessing_result.cleaned_query,
@@ -42,7 +41,7 @@ module Deepsearch
 
         parallel_search_result = with_retry { Steps::ParallelSearch::Process.new(**parallel_search_options).execute }
         notify_listener(:step_completed, step: :parallel_search, result: parallel_search_result)
-        # [parallel_search_result] Contains:        
+        # [parallel_search_result] Contains:
         #   - websites [Array<ParallelSearch::Result>] Search results
         #     - ParallelSearch::Result objects with:
         #       - websites [Array<Hash#url>] Array of website URLs
@@ -51,18 +50,18 @@ module Deepsearch
 
         data_aggregation_result = with_retry do
           Steps::DataAggregation::Process.new(
-            websites: parallel_search_result.websites,
+            websites: parallel_search_result.websites
           ).execute
         end
         notify_listener(:step_completed, step: :data_aggregation, result: data_aggregation_result)
-        # [data_aggregation_result] Contains:        
+        # [data_aggregation_result] Contains:
         #   - parsed_websites [Array<DataAggregation::Result>]
         #     - DataAggregation::Result objects with:
         #       - url [String] Website URL
         #       - content [String] Parsed content from the website
         #   - success [Boolean] Whether search succeeded
         #   - error [String, nil] Error message if search failed
-        
+
         rag_result = with_retry do
           Steps::Rag::Process.new(
             query: query_preprocessing_result.cleaned_query,
@@ -92,7 +91,7 @@ module Deepsearch
 
       def notify_listener(event, **payload)
         listener = Deepsearch.configuration.listener
-        if !listener.respond_to?(:on_deepsearch_event)
+        unless listener.respond_to?(:on_deepsearch_event)
           Deepsearch.configuration.logger.debug("Attached listener does not respond to on_deepsearch_event, skipping notification")
           return
         end
@@ -110,15 +109,13 @@ module Deepsearch
           result = block.call
           # Handle "soft" failures from steps that return a result object with a #failure? method
           raise "Operation failed: #{result.error}" if result.respond_to?(:failure?) && result.failure?
-      
+
           result
-        rescue => e          
-          if (retries += 1) <= 1
-            Deepsearch.configuration.logger.debug("Retrying after error: #{e.message}")
-            retry
-          else
-            raise e
-          end
+        rescue StandardError => e
+          raise e unless (retries += 1) <= 1
+
+          Deepsearch.configuration.logger.debug("Retrying after error: #{e.message}")
+          retry
         end
       end
     end

data/lib/deepsearch/engine/steps/data_aggregation/parsed_website.rb

@@ -42,7 +42,7 @@ module Deepsearch
 
           def fetch_content!
             uri = URI.parse(@url)
-            
+
             unless %w[http https].include?(uri.scheme)
               @error = "Invalid URL scheme: #{uri.scheme}"
               return
@@ -65,7 +65,7 @@ module Deepsearch
             else
               @error = "HTTP #{response.code}"
             end
-          rescue => e
+          rescue StandardError => e
             @error = e.message
           end
 
@@ -111,7 +111,7 @@ module Deepsearch
           rescue StandardError
             # Fallback if Nokogiri fails. The raw_content is the problem. Sanitize it from binary to UTF-8.
             fallback_text = content.to_s.encode("UTF-8", "binary", invalid: :replace, undef: :replace, replace: "")
-            fallback_text.gsub(/<script\b[^>]*>.*?<\/script>/mi, "").gsub(/<style\b[^>]*>.*?<\/style>/mi, "").gsub(
+            fallback_text.gsub(%r{<script\b[^>]*>.*?</script>}mi, "").gsub(%r{<style\b[^>]*>.*?</style>}mi, "").gsub(
               /[[:space:]]+/, " "
             ).strip
           end
@@ -119,4 +119,4 @@ module Deepsearch
       end
     end
   end
-end
+end

data/lib/deepsearch/engine/steps/data_aggregation/result.rb

@@ -25,4 +25,4 @@ module Deepsearch
       end
     end
   end
-end
+end

data/lib/deepsearch/engine/steps/parallel_search/process.rb

@@ -14,9 +14,9 @@ module Deepsearch
           attr_reader :initial_query, :sub_queries, :search_adapter, :options
 
           def initialize(initial_query:,
-            sub_queries:,
-            search_adapter:,
-            **options)
+                         sub_queries:,
+                         search_adapter:,
+                         **options)
             @initial_query = initial_query
             @sub_queries = sub_queries
             @search_adapter = search_adapter

data/lib/deepsearch/engine/steps/parallel_search/result.rb

@@ -25,4 +25,4 @@ module Deepsearch
       end
     end
   end
-end
+end

data/lib/deepsearch/engine/steps/parallel_search/search.rb

@@ -44,11 +44,11 @@ module Deepsearch
 
             Sync do |task|
               semaphore = Async::Semaphore.new(MAX_CONCURRENCY, parent: task)
-              
+
               tasks = @all_queries.each_with_index.map do |query, index|
                 # Add a small delay for subsequent tasks to avoid overwhelming the search api
                 sleep(1) if index > 0
-                
+
                 semaphore.async do |sub_task|
                   sub_task.annotate("query ##{index + 1}: #{query}")
                   perform_search_with_retries(query, index + 1)
@@ -62,15 +62,14 @@ module Deepsearch
           def perform_search_with_retries(query, query_number)
             (MAX_RETRIES + 1).times do |attempt|
               @logger.debug("Task #{query_number}: Searching '#{query}' (Attempt #{attempt + 1})")
-              
+
               results = @search_adapter.search(query, @search_options)
               extracted = extract_results(results)
               @logger.debug("✓ Task #{query_number} completed with #{extracted.size} results for '#{query}'")
               return extracted
-
             rescue StandardError => e
               @logger.debug("✗ Task #{query_number} error for '#{query}': #{e.message}")
-              
+
               break if attempt >= MAX_RETRIES
 
               sleep_duration = (INITIAL_BACKOFF * (2**attempt)) + rand(0.1..0.5)
@@ -92,4 +91,4 @@ module Deepsearch
       end
     end
   end
-end
+end

data/lib/deepsearch/engine/steps/prepare_subqueries/process.rb

@@ -5,7 +5,7 @@ require_relative 'result'
 module Deepsearch
   class Engine
     module Steps
-      module PrepareSubqueries        
+      module PrepareSubqueries
         class Process
           def initialize(original_query)
             @original_query = original_query
@@ -26,15 +26,15 @@ module Deepsearch
           private
 
           def validate_input
-            unless @original_query && !@original_query.strip.empty?
-              raise StandardError, "Original query is required for preprocessing"
-            end
+            return if @original_query && !@original_query.strip.empty?
+
+            raise StandardError, "Original query is required for preprocessing"
           end
 
           def process_query
             cleaned_query = clean_query(@original_query)
             subqueries = generate_subqueries(cleaned_query)
-            
+
             PrepareSubqueries::Result.new(
               cleaned_query: cleaned_query,
               original_query: @original_query,
@@ -47,38 +47,34 @@ module Deepsearch
           end
 
           def generate_subqueries(query)
-            begin
-              Deepsearch.configuration.logger.debug("Attempting to generate subqueries using LLM...")
-              chat = RubyLLM.chat
-              
-              prompt = Deepsearch.configuration.prompts.subquery_prompt(query: query)
-              Deepsearch.configuration.logger.debug("Sending prompt to LLM...")
-              response = chat.ask(prompt)
-              
-              Deepsearch.configuration.logger.debug("Received response from LLM")
-              subqueries = parse_subqueries(response.content)
-              Deepsearch.configuration.logger.debug("Generated #{subqueries.size} subqueries")
-              subqueries
-            rescue StandardError => e
-              Deepsearch.configuration.logger.debug("Error generating subqueries: #{e.message}")
-              Deepsearch.configuration.logger.debug("Error class: #{e.class}")
-              Deepsearch.configuration.logger.debug("Backtrace: #{e.backtrace.first(3).join('\n')}")
-              []
-            end
+            Deepsearch.configuration.logger.debug("Attempting to generate subqueries using LLM...")
+            chat = RubyLLM.chat
+
+            prompt = Deepsearch.configuration.prompts.subquery_prompt(query: query)
+            Deepsearch.configuration.logger.debug("Sending prompt to LLM...")
+            response = chat.ask(prompt)
+
+            Deepsearch.configuration.logger.debug("Received response from LLM")
+            subqueries = parse_subqueries(response.content)
+            Deepsearch.configuration.logger.debug("Generated #{subqueries.size} subqueries")
+            subqueries
+          rescue StandardError => e
+            Deepsearch.configuration.logger.debug("Error generating subqueries: #{e.message}")
+            Deepsearch.configuration.logger.debug("Error class: #{e.class}")
+            Deepsearch.configuration.logger.debug("Backtrace: #{e.backtrace.first(3).join('\n')}")
+            []
           end
 
           def parse_subqueries(response_content)
             return [] unless response_content
 
-            subqueries = response_content.split("\n")
-                                      .map(&:strip)
-                                      .reject(&:empty?)
-                                      .map { |line| line.gsub(/^\d+\.\s*|^[-*]\s*/, '') }
-                                      .map { |query| query.gsub(/^["']|["']$/, '') }
-                                      .reject(&:empty?)
-                                      .first(5)
-
-            subqueries
+            response_content.split("\n")
+                            .map(&:strip)
+                            .reject(&:empty?)
+                            .map { |line| line.gsub(/^\d+\.\s*|^[-*]\s*/, '') }
+                            .map { |query| query.gsub(/^["']|["']$/, '') }
+                            .reject(&:empty?)
+                            .first(5)
           end
         end
       end

data/lib/deepsearch/engine/steps/prepare_subqueries/result.rb

@@ -27,4 +27,4 @@ module Deepsearch
       end
     end
   end
-end
+end

data/lib/deepsearch/engine/steps/rag/chunker.rb

@@ -28,4 +28,4 @@ module Deepsearch
       end
     end
   end
-end
+end

data/lib/deepsearch/engine/steps/rag/process.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'async'
+require 'async/semaphore'
+
 require_relative 'values/chunk'
 require_relative 'values/query'
 require_relative 'values/result'
@@ -13,63 +16,92 @@ module Deepsearch
         # Implements the core Retrieval-Augmented Generation (RAG) logic.
         # It takes a query and a set of parsed websites, then:
         # 1. Chunks the website content into smaller pieces.
-        # 2. Generates embeddings for all text chunks in batches.
+        # 2. Generates embeddings for all text chunks concurrently in batches.
         # 3. Uses a similarity search to find the chunks most relevant to the query.
         # 4. Returns a result containing the relevant chunks.
         class Process
           CHUNK_BATCH_SIZE = 100
           MAX_TOTAL_CHUNKS = 500
           MAX_CHUNKS_PER_WEBSITE = 15
+          MAX_EMBEDDING_CONCURRENCY = 3
 
           def initialize(query:, parsed_websites:)
             @query = Values::Query.new(text: query)
             @documents = parsed_websites.map do |website|
               { url: website.url, content: website.content }
             end
+            @logger = Deepsearch.configuration.logger
           end
 
           def execute
-            begin
-              chunker = Chunker.new
-              all_chunks = @documents.each_with_object([]) do |doc, chunks|
-                next if doc[:content].to_s.strip.empty?
-
-                doc_chunks = chunker.chunk(doc[:content])
-                if doc_chunks.count > MAX_CHUNKS_PER_WEBSITE
-                  Deepsearch.configuration.logger.debug("Truncating chunks for #{doc[:url]} from #{doc_chunks.count} to #{MAX_CHUNKS_PER_WEBSITE}")
-                  doc_chunks = doc_chunks.first(MAX_CHUNKS_PER_WEBSITE)
-                end
-                doc_chunks.each { |chunk| chunk.document_url = doc[:url] }
-                chunks.concat(doc_chunks)
+            chunker = Chunker.new
+            all_chunks = @documents.each_with_object([]) do |doc, chunks|
+              next if doc[:content].to_s.strip.empty?
+
+              doc_chunks = chunker.chunk(doc[:content])
+              if doc_chunks.count > MAX_CHUNKS_PER_WEBSITE
+                @logger.debug("Truncating chunks for #{doc[:url]} from #{doc_chunks.count} to #{MAX_CHUNKS_PER_WEBSITE}")
+                doc_chunks = doc_chunks.first(MAX_CHUNKS_PER_WEBSITE)
               end
+              doc_chunks.each { |chunk| chunk.document_url = doc[:url] }
+              chunks.concat(doc_chunks)
+            end
 
-              Deepsearch.configuration.logger.debug("Chunked #{@documents.count} documents into #{all_chunks.count} chunks")
+            @logger.debug("Chunked #{@documents.count} documents into #{all_chunks.count} chunks")
 
-              if all_chunks.count > MAX_TOTAL_CHUNKS
-                Deepsearch.configuration.logger.debug("Chunk count (#{all_chunks.count}) exceeds limit of #{MAX_TOTAL_CHUNKS}. Truncating.")
-                all_chunks = all_chunks.first(MAX_TOTAL_CHUNKS)
-              end
+            if all_chunks.count > MAX_TOTAL_CHUNKS
+              @logger.debug("Chunk count (#{all_chunks.count}) exceeds limit of #{MAX_TOTAL_CHUNKS}. Truncating.")
+              all_chunks = all_chunks.first(MAX_TOTAL_CHUNKS)
+            end
+
+            generate_embeddings_in_parallel(all_chunks)
+
+            @logger.debug('Finished embedding generation, initiating similarity match..')
+            chunks_with_embeddings = all_chunks.select(&:embedding)
+            relevant_chunks = Similarity.new.find_relevant(@query, chunks_with_embeddings)
+            @logger.debug("Found #{relevant_chunks.count} relevant chunks for query: '#{@query.text}'")
 
-              all_chunks.each_slice(CHUNK_BATCH_SIZE) do |batch|
-                texts = batch.map(&:text)
-                embeddings = RubyLLM.embed(texts).vectors
-                batch.each_with_index { |chunk, i| chunk.embedding = embeddings[i] }
+            Values::Result.new(
+              query: @query,
+              relevant_chunks: relevant_chunks
+            )
+          rescue StandardError => e
+            Values::Result.new(
+              query: @query,
+              relevant_chunks: [],
+              error: e.message
+            )
+          end
+
+          private
+
+          def generate_embeddings_in_parallel(chunks)
+            return if chunks.empty?
+
+            num_batches = (chunks.count.to_f / CHUNK_BATCH_SIZE).ceil
+            @logger.debug("Starting parallel embedding generation for #{num_batches} batches with max concurrency of #{MAX_EMBEDDING_CONCURRENCY}")
+
+            Sync do |task|
+              semaphore = Async::Semaphore.new(MAX_EMBEDDING_CONCURRENCY, parent: task)
+
+              tasks = chunks.each_slice(CHUNK_BATCH_SIZE).with_index.map do |batch, index|
+                semaphore.async do |sub_task|
+                  task_number = index + 1
+                  sub_task.annotate("Embedding batch #{task_number}/#{num_batches}")
+                  @logger.debug("Task #{task_number}: Generating embeddings for batch of #{batch.size} chunks")
+
+                  begin
+                    texts = batch.map(&:text)
+                    embeddings = RubyLLM.embed(texts).vectors
+                    batch.each_with_index { |chunk, i| chunk.embedding = embeddings[i] }
+                    @logger.debug("✓ Task #{task_number} completed.")
+                  rescue StandardError => e
+                    @logger.error("✗ Task #{task_number} error: #{e.message}")
+                  end
+                end
               end
 
-              Deepsearch.configuration.logger.debug("Generated embeddings for #{all_chunks.count} chunks, initiating similarity match..")
-              relevant_chunks = Similarity.new.find_relevant(@query, all_chunks)
-              Deepsearch.configuration.logger.debug("Found #{relevant_chunks.count} relevant chunks for query: '#{@query.text}'")
-
-              Values::Result.new(
-                query: @query,
-                relevant_chunks: relevant_chunks
-              )
-            rescue StandardError => e
-              Values::Result.new(
-                query: @query,
-                relevant_chunks: [],
-                error: e.message
-              )
+              tasks.map(&:wait)
             end
           end
         end

data/lib/deepsearch/engine/steps/rag/similarity.rb

@@ -24,10 +24,8 @@ module Deepsearch
             best_score = top_candidates.first.first
             cutoff_score = best_score * threshold
 
-            relevant_chunks = top_candidates.select { |score, _| score >= cutoff_score }
-                                            .map { |_, index| chunks[index] }
-
-            relevant_chunks
+            top_candidates.select { |score, _| score >= cutoff_score }
+                          .map { |_, index| chunks[index] }
           end
 
           private
@@ -51,10 +49,11 @@ module Deepsearch
             magnitude_b = Math.sqrt(vec_b.sum { |v| v**2 })
 
             return 0.0 if magnitude_a.zero? || magnitude_b.zero?
+
             dot_product / (magnitude_a * magnitude_b)
           end
         end
       end
     end
   end
-end
+end

data/lib/deepsearch/engine/steps/rag/values/chunk.rb

@@ -9,7 +9,7 @@ module Deepsearch
           # This is the fundamental unit of data used in the RAG process.
           class Chunk
             attr_accessor :text, :embedding, :document_url
-      
+
             def initialize(text:, embedding: nil, document_url: nil)
               @text = text
               @embedding = embedding
@@ -20,4 +20,4 @@ module Deepsearch
       end
     end
   end
-end
+end

data/lib/deepsearch/engine/steps/rag/values/query.rb

@@ -41,4 +41,4 @@ module Deepsearch
       end
     end
   end
-end
+end

data/lib/deepsearch/engine/steps/rag/values/result.rb

@@ -30,4 +30,4 @@ module Deepsearch
       end
     end
   end
-end
+end

data/lib/deepsearch/engine/steps/summarization/process.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'values/result'
+require_relative 'result'
 
 module Deepsearch
   class Engine
@@ -18,17 +18,17 @@ module Deepsearch
           end
 
           def execute
-            return Values::Result.new(summary: "No relevant content found to summarize.") if relevant_chunks.empty?
+            return Result.new(summary: "No relevant content found to summarize.") if relevant_chunks.empty?
 
             prompt = build_summary_prompt
             Deepsearch.configuration.logger.debug("Summarizing content with LLM...")
             response = RubyLLM.chat.ask(prompt)
             Deepsearch.configuration.logger.debug("Summarization complete.")
 
-            Values::Result.new(summary: response.content)
+            Result.new(summary: response.content)
           rescue StandardError => e
             Deepsearch.configuration.logger.debug("Error during summarization: #{e.message}")
-            Values::Result.new(summary: nil, error: e.message)
+            Result.new(summary: nil, error: e.message)
           end
 
           private
@@ -36,18 +36,19 @@ module Deepsearch
           def build_summary_prompt
             chunks_by_url = relevant_chunks.group_by(&:document_url)
             citation_map = chunks_by_url.keys.each_with_index.to_h { |url, i| [url, i + 1] }
- 
+
             context_text = chunks_by_url.map do |url, chunks|
               citation_number = citation_map[url]
               chunk_contents = chunks.map(&:text).join("\n\n")
               "Source [#{citation_number}]:\n#{chunk_contents}"
             end.join("\n\n---\n\n")
- 
+
             sources_list = citation_map.map { |url, number| "[#{number}]: #{url}" }.join("\n")
-            Deepsearch.configuration.prompts.summarization_prompt(query: @query.text, context_text: context_text, sources_list: sources_list)
+            Deepsearch.configuration.prompts.summarization_prompt(query: @query.text, context_text: context_text,
+                                                                  sources_list: sources_list)
           end
         end
       end
     end
   end
-end          
+end

data/lib/deepsearch/engine/steps/summarization/result.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Deepsearch
+  class Engine
+    module Steps
+      module Summarization
+        # Represents the result of the summarization step.
+        # It holds the final, synthesized summary and any potential error message.
+        class Result
+          attr_reader :summary, :error, :success
+
+          def initialize(summary: nil, error: nil)
+            @summary = summary
+            @success = error.nil?
+            @error = error
+          end
+
+          def success?
+            @success
+          end
+
+          def failure?
+            !success?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/deepsearch/logger.rb

@@ -29,4 +29,4 @@ module Deepsearch
       end
     end
   end
-end
+end

data/lib/deepsearch/prompts_config.rb

@@ -79,4 +79,4 @@ module Deepsearch
       PROMPT
     end
   end
-end
+end

data/lib/deepsearch/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Deepsearch
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/lib/deepsearch.rb

@@ -12,7 +12,7 @@ module Deepsearch
   # A generic error class for exceptions raised by the Deepsearch gem,
   # from which more specific errors can inherit.
   class Error < StandardError; end
-  
+
   class << self
     def configuration
       @configuration ||= Configuration.new

data/lib/search_adapters/mock_adapter.rb

@@ -9,7 +9,7 @@ module Deepsearch
       def initialize(api_key = nil); end
 
       def search(query, options = {})
-        return mock_results(query, options)
+        mock_results(query, options)
       end
 
       private
@@ -63,7 +63,8 @@ module Deepsearch
         }
 
         if include_answer
-          response["answer"] = "Ruby is a dynamic, open-source programming language with a focus on simplicity and productivity. It was created by Yukihiro Matsumoto in the mid-1990s and follows the principle that everything is an object. Ruby is particularly popular for web development, especially with the Ruby on Rails framework, but it's also used for automation, data processing, and various other applications."
+          response["answer"] =
+            "Ruby is a dynamic, open-source programming language with a focus on simplicity and productivity. It was created by Yukihiro Matsumoto in the mid-1990s and follows the principle that everything is an object. Ruby is particularly popular for web development, especially with the Ruby on Rails framework, but it's also used for automation, data processing, and various other applications."
         end
 
         response

data/lib/search_adapters/serper_adapter.rb

@@ -103,4 +103,4 @@ module Deepsearch
     # Custom error class for exceptions raised by the SerperAdapter.
     class SerperError < StandardError; end
   end
-end
+end

data/lib/search_adapters/tavily_adapter.rb

@@ -40,13 +40,11 @@ module Deepsearch
       private
 
       def validate_api_key!
-        if @api_key.nil? || @api_key.strip.empty?
-          raise TavilyError, "API key is required"
-        end
+        raise TavilyError, "API key is required" if @api_key.nil? || @api_key.strip.empty?
 
-        unless @api_key.start_with?('tvly-')
-          raise TavilyError, "Invalid API key format. Expected format: tvly-YOUR_API_KEY"
-        end
+        return if @api_key.start_with?('tvly-')
+
+        raise TavilyError, "Invalid API key format. Expected format: tvly-YOUR_API_KEY"
       end
 
       def build_payload(query, options)
@@ -78,9 +76,7 @@ module Deepsearch
 
         response = http.request(request)
 
-        unless response.is_a?(Net::HTTPSuccess)
-          handle_error_response(response)
-        end
+        handle_error_response(response) unless response.is_a?(Net::HTTPSuccess)
 
         response
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deepsearch-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Alexander Shagov
@@ -41,16 +41,16 @@ dependencies:
   name: ruby_llm
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -150,7 +150,7 @@ files:
 - lib/deepsearch/engine/steps/rag/values/query.rb
 - lib/deepsearch/engine/steps/rag/values/result.rb
 - lib/deepsearch/engine/steps/summarization/process.rb
-- lib/deepsearch/engine/steps/summarization/values/result.rb
+- lib/deepsearch/engine/steps/summarization/result.rb
 - lib/deepsearch/logger.rb
 - lib/deepsearch/prompts_config.rb
 - lib/deepsearch/version.rb

data/lib/deepsearch/engine/steps/summarization/values/result.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Deepsearch
-  class Engine
-    module Steps
-      module Summarization
-        module Values
-          # Represents the result of the summarization step.
-          # It holds the final, synthesized summary and any potential error message.
-          class Result
-            attr_reader :summary, :error, :success
-
-            def initialize(summary: nil, error: nil)
-              @summary = summary
-              @success = error.nil?
-              @error = error
-            end
-
-            def success?
-              @success
-            end
-
-            def failure?
-              !success?
-            end
-          end
-        end
-      end
-    end
-  end
-end