deepsearch-rb 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 435d04eb1b8c5a7d2d8e86cd17b863766559f82ffe4f194597e9b05a087b5ae0
-  data.tar.gz: 1f394f33996d8f85b17e17709a3178debb8ccad84d8268bd7590b532ac0d9fa7
+  metadata.gz: 51ef2b5c1780ff68752d82960a651443f6b0d5f7de38f9d0313acd17bdaaa144
+  data.tar.gz: 16af241a4eff83e5a5290832dc4ad14f4f8ed724f7c91abbfa060b4bf8c44ddb
 SHA512:
-  metadata.gz: 30634e66e50d377e755fe82354255d8b1e265578aca7e8f4c4833e8959ff33277a9a120c56b96c93efb13ea6e890cec8ddbf06d5952c0ef384efaceb3f8f8839
-  data.tar.gz: fca34ac34b09e4a8c5558c8114853dfec7c982fdf4bb9f630068c8ebf60bc398b1f711d5443b4e30aedc04c78539de24dcbf8a33761a719eb9815d8b38e37499
+  metadata.gz: 3172fe8597368c0ba863f6593f6c080a41b73de0890a3a02ca49f8e1dbcbf33bc17ab4c4a06a1b557dc324a949e9cabb2ee307752b8af8afd16872398c1dcaeb
+  data.tar.gz: eb185bd46ca110d9bbcb9134872dae8dab0c76db52841d4c85e38ec4a98f1c41033ab620930c4f9a22ec2238f2fa6f6d421b65bb7811492fccd8097c03cc099a

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [Pending]
+
+## [0.1.1] - 2025-07-12
+
+### Added
+- Minor specs improvements and examples cleanup
+
 ## [Released]
 
 ## [0.1.0] - 2025-07-12

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

@@ -47,7 +47,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

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.1"
 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.1
 platform: ruby
 authors:
 - Alexander Shagov
@@ -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