active_genie 0.0.19 → 0.0.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12c5c526a10f93e649ca39c4789a21065c0f2d329bd57248260b1fd997507296
-  data.tar.gz: 6fc9074a5282f1b9759c41dd98aaa31a179bc495964839e8bfc42e891b15e7d2
+  metadata.gz: a9c9c17c2c02f617c53edd6177ff72e0e2da34a4faf6bbeb9f9698b3858e4b69
+  data.tar.gz: 777620b958c17c9a439fcf5b8bdb3195564005e5becd8c41955c1c255c1a6ad3
 SHA512:
-  metadata.gz: 76672044e7a1a88779100b9b0f32d75547ac1105031f5ca40d6bbce71a34edecadb63e0dda99c6ca23ee03647bf5dd09a3b3bc98a38faad3a07fdbc245f87dc4
-  data.tar.gz: 2ac5ed0ae70edbf7a736e7b7bc3408a16c76628c7efecb277291641bb8b04e8ea633a36c16dc0e86851bbf3c40d82c3f4456af0e7e3ea1beea057bb60660ad6a
+  metadata.gz: c3bee8941701e3516f48106d96165d78ea279cea1c7e5623515aed3361b5a337e191c85a3e4774a9526e3412a4b11f4c4f5d766e7f5a0e827cc74d869bd1ca54
+  data.tar.gz: a489c2f042aee21501697dfac47d0a37bd1a8bf50d990472dda2f7f8567615c3efd4422500653ac798c425a65df7bc065afaa3337f08a16305d4ef8f0b254a05

data/README.md

@@ -4,7 +4,7 @@
 [![Gem Version](https://badge.fury.io/rb/active_genie.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/active_genie)
 [![Ruby](https://github.com/roriz/active_genie/actions/workflows/benchmark.yml/badge.svg)](https://github.com/roriz/active_genie/actions/workflows/benchmark.yml)
 
-ActiveGenie is a Ruby gem that provides valuable solutions powered by Generative AI (GenAI) models. Just like Lodash or ActiveStorage, ActiveGenie brings a set of Modules reach real value fast and reliable.
+ActiveGenie is a Ruby gem that provides valuable solutions powered by Generative AI (GenAI) models. Just like Lodash or ActiveStorage, ActiveGenie brings a set of Modules to reach real value fast and reliably.
 ActiveGenie is backed by a custom benchmarking system that ensures consistent quality and performance across different models and providers in every release.
 
 ## Installation
@@ -137,7 +137,7 @@ result = ActiveGenie::Battle.call(
 #    }
 ```
 
-*Recommended model*: `gemini-2.0-flash-lite`
+*Recommended model*: `claude-3-5-haiku`
 
 Features:
 - Multi-reviewer evaluation with automatic expert selection
@@ -216,6 +216,64 @@ See the [Benchmark README](benchmark/README.md) for detailed results, methodolog
 
 > **Note:** Each module can append its own set of configuration, see the individual module documentation for details.
 
+## How to create a new provider
+
+ActiveGenie supports adding custom providers to integrate with different LLM services. To create a new provider:
+
+1. Create a configuration class for your provider in `lib/active_genie/configuration/providers/`:
+
+```ruby
+# Example: lib/active_genie/configuration/providers/internal_company_api_config.rb
+module ActiveGenie
+  module Configuration::Providers
+    class InternalCompanyApiConfig < BaseConfig
+      NAME = :internal_company_api
+      
+      # API key accessor with environment variable fallback
+      def api_key
+        @api_key || ENV['INTERNAL_COMPANY_API_KEY']
+      end
+      
+      # Base API URL
+      def api_url
+        @api_url || 'https://api.internal-company.com/v1'
+      end
+      
+      # Client instantiation
+      def client
+        @client ||= ::ActiveGenie::Clients::InternalCompanyApiClient.new(self)
+      end
+      
+      # Model tier definitions
+      def lower_tier_model
+        @lower_tier_model || 'internal-basic'
+      end
+      
+      def middle_tier_model
+        @middle_tier_model || 'internal-standard'
+      end
+      
+      def upper_tier_model
+        @upper_tier_model || 'internal-premium'
+      end
+    end
+  end
+end
+```
+
+2. Register your provider in your configuration:
+
+```ruby
+# In config/initializers/active_genie.rb
+ActiveGenie.configure do |config|
+  # Register your custom provider
+  config.providers.register(InternalCompanyApi::Configuration)
+  
+  # Configure your provider
+  config.internal_company_api.api_key = ENV['INTERNAL_COMPANY_API_KEY']
+end
+```
+
 ## Contributing
 
 1. Fork the repository

data/VERSION

@@ -1 +1 @@
-0.0.19
+0.0.21

data/lib/active_genie/battle/basic.rb

@@ -123,14 +123,7 @@ module ActiveGenie::Battle
             enum: ['player_1', 'player_2']
           },
         },
-        required: [
-          'player_1_sell_himself',
-          'player_2_sell_himself',
-          'player_1_arguments',
-          'player_2_counter',
-          'impartial_judge_winner_reasoning',
-          'impartial_judge_winner'
-        ]
+        required: %w[player_1_sell_himself player_2_sell_himself player_1_arguments player_2_counter impartial_judge_winner_reasoning impartial_judge_winner]
       }
     }
   end

data/lib/active_genie/configuration/providers/internal_company_api_config.rb

@@ -0,0 +1,54 @@
+require_relative '../../clients/internal_company_api_client'
+require_relative './base_config'
+
+module ActiveGenie
+  module Configuration::Providers
+    # Configuration class for the Internal Company API client.
+    # Manages API keys, URLs, model selections, and client instantiation.
+    class InternalCompanyApiConfig < BaseConfig
+      NAME = :internal_company_api
+
+      # Retrieves the API key.
+      # Falls back to the INTERNAL_COMPANY_API_KEY environment variable if not set.
+      # @return [String, nil] The API key.
+      def api_key
+        @api_key || ENV['INTERNAL_COMPANY_API_KEY']
+      end
+
+      # Retrieves the base API URL for Internal Company API.
+      # Defaults to 'https://api.internal-company.com/v1'.
+      # @return [String] The API base URL.
+      def api_url
+        @api_url || 'https://api.internal-company.com/v1'
+      end
+
+      # Lazily initializes and returns an instance of the InternalCompanyApiClient.
+      # Passes itself (the config object) to the client's constructor.
+      # @return [ActiveGenie::Clients::InternalCompanyApiClient] The client instance.
+      def client
+        @client ||= ::ActiveGenie::Clients::InternalCompanyApiClient.new(self)
+      end
+
+      # Retrieves the model name designated for the lower tier (e.g., cost-effective, faster).
+      # Defaults to 'internal-basic'.
+      # @return [String] The lower tier model name.
+      def lower_tier_model
+        @lower_tier_model || 'internal-basic'
+      end
+
+      # Retrieves the model name designated for the middle tier (e.g., balanced performance).
+      # Defaults to 'internal-standard'.
+      # @return [String] The middle tier model name.
+      def middle_tier_model
+        @middle_tier_model || 'internal-standard'
+      end
+
+      # Retrieves the model name designated for the upper tier (e.g., most capable).
+      # Defaults to 'internal-premium'.
+      # @return [String] The upper tier model name.
+      def upper_tier_model
+        @upper_tier_model || 'internal-premium'
+      end
+    end
+  end
+end

data/lib/active_genie/configuration/providers/openai_config.rb

@@ -33,21 +33,21 @@ module ActiveGenie
       # Defaults to 'gpt-4o-mini'.
       # @return [String] The lower tier model name.
       def lower_tier_model
-        @lower_tier_model || 'gpt-4o-mini'
+        @lower_tier_model || 'gpt-4.1-mini'
       end
 
       # Retrieves the model name designated for the middle tier (e.g., balanced performance).
       # Defaults to 'gpt-4o'.
       # @return [String] The middle tier model name.
       def middle_tier_model
-        @middle_tier_model || 'gpt-4o'
+        @middle_tier_model || 'gpt-4.1'
       end
 
       # Retrieves the model name designated for the upper tier (e.g., most capable).
       # Defaults to 'o1-preview'.
       # @return [String] The upper tier model name.
       def upper_tier_model
-        @upper_tier_model || 'o1-preview'
+        @upper_tier_model || 'o3-mini'
       end
     end
   end

data/lib/active_genie/ranking/README.md

@@ -40,4 +40,34 @@ The method processes the players through scoring, elimination, and ranking phase
 - Adjust initial criteria to ensure consistency
 - Adjust each player's content to ensure consistency
 - Support players with images or audio
-- Parallelize processing battles and scoring
+- Parallelize processing battles and scoring
+
+## Ranking Configuration
+
+| Config | Description | Default |
+|--------|-------------|---------|
+| `score_variation_threshold` | Threshold for eliminating players with inconsistent scores | `30` |
+
+## Ranking Callbacks
+Callbacks are optional and can be used to watch any changes in players, battles, or scoring.
+
+| Callback | Description |
+|--------|-------------|
+| `watch_players` | Callback to watch any changes in players |
+| `watch_battles` | Callback to watch any changes in battles |
+| `watch_scoring` | Callback to watch any changes in scoring |
+
+Example of callback usage:
+
+```ruby
+result = ActiveGenie::Ranking.call(
+  players,
+  criteria,
+  config: {
+    watch_players: ->(player) { puts player },
+    watch_battles: ->(battle) { puts battle },
+    watch_scoring: ->(scoring) { puts scoring }
+  }
+)
+```
+

data/lib/active_genie/ranking/elo_round.rb

@@ -76,6 +76,9 @@ module ActiveGenie::Ranking
           when 'draw' then [nil, nil]
         end
 
+        @config[:runtime][:watch_battle].call({ id: "#{player_1.id}_#{player_2.id}_#{elo_round_id}", player_1:, player_2:, winner:, loser:, reasoning: result['reasoning'] }) if @config[:runtime][:watch_battle]
+        @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
+
         [winner, loser]
       end
     end

data/lib/active_genie/ranking/free_for_all.rb

@@ -26,6 +26,8 @@ module ActiveGenie::Ranking
             winner.win!
             loser.lose!
           end
+          
+          @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
         end
       end
 
@@ -56,6 +58,7 @@ module ActiveGenie::Ranking
         when 'draw' then [nil, nil, result['reasoning']]
       end
 
+      @config[:runtime][:watch_battle].call({ id: "#{player_1.id}_#{player_2.id}_#{free_for_all_id}", player_1:, player_2:, winner:, loser:, reasoning: result['reasoning'] }) if @config[:runtime][:watch_battle]
       ActiveGenie::Logger.debug({
         code: :free_for_all_battle,
         player_ids: [player_1.id, player_2.id],

data/lib/active_genie/ranking/player.rb

@@ -6,6 +6,7 @@ module ActiveGenie::Ranking
       params = { content: params } if params.is_a?(String)
 
       @content = params.dig(:content) || params
+      @name = params.dig(:name) || params.dig(:content)[0..10]
       @id = params.dig(:id) || Digest::MD5.hexdigest(@content)
       @score = params.dig(:score) || nil
       @elo = params.dig(:elo) || nil
@@ -15,9 +16,8 @@ module ActiveGenie::Ranking
       @eliminated = params.dig(:eliminated) || nil
     end
 
-    attr_reader :id, :content, :score, :elo, 
-      :ffa_win_count, :ffa_lose_count, :ffa_draw_count,
-      :eliminated
+    attr_reader :id, :content, :score, :elo,  :ffa_win_count,
+      :ffa_lose_count, :ffa_draw_count, :eliminated
     attr_accessor :rank
 
     def score=(value)
@@ -51,15 +51,27 @@ module ActiveGenie::Ranking
       ActiveGenie::Logger.debug({ code: :new_ffa_score, player_id: id, result: 'lose', ffa_score: })
     end
 
+    def name
+      @name
+    end
+
     def ffa_score
       @ffa_win_count * 3 + @ffa_draw_count
     end
 
+    def sort_value
+      (ffa_score * 1000000) + ((elo || 0) * 100) + (score || 0)
+    end
+
+    def to_json
+      to_h.to_json
+    end
+
     def to_h
       {
-        id:, content:, score:, elo:,
+        id:, name:, content:, score:, elo:,
         ffa_win_count:, ffa_lose_count:, ffa_draw_count:,
-        eliminated:, ffa_score:
+        eliminated:, ffa_score:, sort_value:
       }
     end
 

data/lib/active_genie/ranking/players_collection.rb

@@ -41,10 +41,14 @@ module ActiveGenie::Ranking
     end
 
     def sorted
-      sorted_players = @players.sort_by { |p| [-p.ffa_score, -(p.elo || 0), -(p.score || 0)] }
+      sorted_players = @players.sort_by { |p| -p.sort_value }
       sorted_players.each_with_index { |p, i| p.rank = i + 1 }
       sorted_players
     end
+    
+    def to_json
+      to_h.to_json
+    end
 
     def to_h
       sorted.map { |p| p.to_h }

data/lib/active_genie/ranking/ranking.rb

@@ -67,7 +67,7 @@ module ActiveGenie::Ranking
 
     private
 
-    SCORE_VARIATION_THRESHOLD = 15
+    DEFAULT_SCORE_VARIATION_THRESHOLD = 30
     ELIMINATION_VARIATION = 'variation_too_high'
     ELIMINATION_RELEGATION = 'relegation_tier'
     
@@ -80,27 +80,36 @@ module ActiveGenie::Ranking
     end
 
     def set_initial_player_scores!
+      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
       RankingScoring.call(@players, @criteria, reviewers: @reviewers, config: @config)
+      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
     end
 
     def eliminate_obvious_bad_players!
-      while @players.coefficient_of_variation >= SCORE_VARIATION_THRESHOLD
+      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
+      while @players.coefficient_of_variation >= score_variation_threshold
         @players.eligible.last.eliminated = ELIMINATION_VARIATION
       end
+      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
     end
 
     def run_elo_round!
+      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
       @elo_rounds_played += 1
 
       elo_report = EloRound.call(@players, @criteria, config: @config)
 
       @elo_round_battle_count += elo_report[:battles_count]
 
+      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
       elo_report
     end
 
     def eliminate_relegation_players!
+      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
       @players.calc_relegation_tier.each { |player| player.eliminated = ELIMINATION_RELEGATION }
+      
+      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
     end
 
     def rebalance_players!(elo_report)
@@ -111,12 +120,19 @@ module ActiveGenie::Ranking
 
         player.elo += elo_report[:highest_elo_diff]
       end
+      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
     end
 
     def run_free_for_all!
+      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
       ffa_report = FreeForAll.call(@players, @criteria, config: @config)
 
       @free_for_all_battle_count += ffa_report[:battles_count]
+      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
+    end
+
+    def score_variation_threshold
+      @config[:runtime][:score_variation_threshold] || DEFAULT_SCORE_VARIATION_THRESHOLD
     end
 
     def report

data/lib/active_genie/ranking/ranking_scoring.rb

@@ -16,10 +16,27 @@ module ActiveGenie::Ranking
     def call
       ActiveGenie::Logger.with_context(log_context) do
         @reviewers = generate_reviewers
+        
+        players_to_score = players_without_score
+        until players_to_score.empty?
+          threads = []
+          mutex = Mutex.new
+          
+          # Take up to 3 players for parallel processing
+          current_batch = players_to_score.shift(3)
 
-        players_without_score.each do |player|
-          # TODO: This can take a while, can be parallelized
-          player.score = generate_score(player)
+          current_batch.each do |player|
+            threads << Thread.new(player) do |p|
+              score = generate_score(p)
+
+              mutex.synchronize do
+                p.score = score
+              end
+            end
+          end
+
+          # Wait for all threads in this batch to complete
+          threads.each(&:join)
         end
       end
     end
@@ -39,6 +56,11 @@ module ActiveGenie::Ranking
       ).values_at('final_score', 'final_reasoning')
 
       ActiveGenie::Logger.debug({ code: :new_score, player_id: player.id, score:, reasoning: })
+      @config[:runtime][:watch_scoring].call({ 
+        player_id: player.id, 
+        player_name: player.content[0..10], 
+        score: player.score 
+      }) if @config[:runtime][:watch_scoring]
 
       score
     end
@@ -65,7 +87,7 @@ module ActiveGenie::Ranking
       player_ids = players_without_score.map(&:id).join(',')
       ranking_unique_key = [player_ids, @criteria, @config.to_json].join('-')
 
-      Digest::MD5.hexdigest(ranking_unique_key)
+      Digest::MD5.hexdigest(ranking_unique_key) + '-scoring'
     end
   end
 end

data/lib/active_genie/scoring/recommended_reviewers.rb

@@ -49,7 +49,8 @@ module ActiveGenie::Scoring
             reviewer1: { type: 'string' },
             reviewer2: { type: 'string' },
             reviewer3: { type: 'string' },
-          }
+          },
+          required: ['reasoning', 'reviewer1', 'reviewer2', 'reviewer3']
         }
       }
 

data/lib/tasks/templates/active_genie.rb

@@ -10,7 +10,7 @@ ActiveGenie.configure do |config|
   # config.providers.openai.client = ActiveGenie::Providers::Openai::Client.new(config)
 
   # example how add a new provider
-  # config.providers.register(:internal_company_api, InternalCompanyApi::Configuration)
+  # config.providers.register(InternalCompanyApi::Configuration)
 
   # Logs configuration
   # config.log_level = :debug # default is :info

metadata

@@ -1,103 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: active_genie
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.21
 platform: ruby
 authors:
 - Radamés Roriz
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-04-04 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: "# ActiveGenie \U0001F9DE‍♂️\n> The lodash for GenAI, stop reinventing
-  the wheel\n\n[![Gem Version](https://badge.fury.io/rb/active_genie.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/active_genie)\n[![Ruby](https://github.com/roriz/active_genie/actions/workflows/benchmark.yml/badge.svg)](https://github.com/roriz/active_genie/actions/workflows/benchmark.yml)\n\nActiveGenie
-  is a Ruby gem that provides valuable solutions powered by Generative AI (GenAI)
-  models. Just like Lodash or ActiveStorage, ActiveGenie brings a set of Modules reach
-  real value fast and reliable.\nActiveGenie is backed by a custom benchmarking system
-  that ensures consistent quality and performance across different models and providers
-  in every release.\n\n## Installation\n\n1. Add to your Gemfile:\n```ruby\ngem 'active_genie'\n```\n\n2.
-  Install the gem:\n```shell\nbundle install\n```\n\n3. Generate the configuration:\n```shell\necho
-  \"ActiveGenie.load_tasks\" >> Rakefile\nrails g active_genie:install\n```\n\n4.
-  Configure your credentials in `config/initializers/active_genie.rb`:\n```ruby\nActiveGenie.configure
-  do |config|\n  config.openai.api_key = ENV['OPENAI_API_KEY']\nend\n```\n\n## Quick
-  Start\n\n### Data Extractor\n\nExtract structured data from text using AI-powered
-  analysis, handling informal language and complex expressions.\n\n```ruby\ntext =
-  \"Nike Air Max 90 - Size 42 - $199.99\"\nschema = {\n  brand: { \n    type: 'string',\n
-  \   enum: [\"Nike\", \"Adidas\", \"Puma\"]\n  },\n  price: { \n    type: 'number',\n
-  \   minimum: 0\n  },\n  size: {\n    type: 'number',\n    minimum: 35,\n    maximum:
-  46\n  }\n}\n\nresult = ActiveGenie::DataExtractor.call(\n  text,\n  schema,\n  config:
-  { provider: :openai, model: 'gpt-4o-mini' } # optional\n)\n# => { \n#      brand:
-  \"Nike\", \n#      brand_explanation: \"Brand name found at start of text\",\n#
-  \     price: 199.99,\n#      price_explanation: \"Price found in USD format at end\",\n#
-  \     size: 42,\n#      size_explanation: \"Size explicitly stated in the middle\"\n#
-  \   }\n```\n\n*Recommended model*: `gpt-4o-mini`\n\nFeatures:\n- Structured data
-  extraction with type validation\n- Schema-based extraction with custom constraints\n-
-  Informal text analysis (litotes, hedging)\n- Detailed explanations for extracted
-  values\n\nSee the [Data Extractor README](lib/active_genie/data_extractor/README.md)
-  for informal text processing, advanced schemas, and detailed interface documentation.\n\n###
-  Scoring\nText evaluation system that provides detailed scoring and feedback using
-  multiple expert reviewers. Get balanced scoring through AI-powered expert reviewers
-  that automatically adapt to your content.\n\n```ruby\ntext = \"The code implements
-  a binary search algorithm with O(log n) complexity\"\ncriteria = \"Evaluate technical
-  accuracy and clarity\"\n\nresult = ActiveGenie::Scoring.basic(\n  text,\n  criteria,\n
-  \ config: { provider: :anthropic, model: 'claude-3-5-haiku-20241022' } # optional\n)\n#
-  => {\n#      algorithm_expert_score: 95,\n#      algorithm_expert_reasoning: \"Accurately
-  describes binary search and its complexity\",\n#      technical_writer_score: 90,\n#
-  \     technical_writer_reasoning: \"Clear and concise explanation of the algorithm\",\n#
-  \     final_score: 92.5\n#    }\n```\n\n*Recommended model*: `claude-3-5-haiku-20241022`\n\nFeatures:\n-
-  Multi-reviewer evaluation with automatic expert selection\n- Detailed feedback with
-  scoring reasoning\n- Customizable reviewer weights\n- Flexible evaluation criteria\n\nSee
-  the [Scoring README](lib/active_genie/scoring/README.md) for advanced usage, custom
-  reviewers, and detailed interface documentation.\n\n### Battle\nAI-powered battle
-  evaluation system that determines winners between two players based on specified
-  criteria.\n\n```ruby\nrequire 'active_genie'\n\nplayer_1 = \"Implementation uses
-  dependency injection for better testability\"\nplayer_2 = \"Code has high test coverage
-  but tightly coupled components\"\ncriteria = \"Evaluate code quality and maintainability\"\n\nresult
-  = ActiveGenie::Battle.call(\n  player_1,\n  player_2,\n  criteria,\n  config: {
-  provider: :google, model: 'gemini-2.0-flash-lite' } # optional\n)\n# => {\n#      winner_player:
-  \"Implementation uses dependency injection for better testability\",\n#      reasoning:
-  \"Player 1 implementation demonstrates better maintainability through dependency
-  injection, \n#                 which allows for easier testing and component replacement.
-  While Player 2 has good test coverage, \n#                 the tight coupling makes
-  the code harder to maintain and modify.\",\n#      what_could_be_changed_to_avoid_draw:
-  \"Focus on specific architectural patterns and design principles\"\n#    }\n```\n\n*Recommended
-  model*: `gemini-2.0-flash-lite`\n\nFeatures:\n- Multi-reviewer evaluation with automatic
-  expert selection\n- Detailed feedback with scoring reasoning\n- Customizable reviewer
-  weights\n- Flexible evaluation criteria\n\nSee the [Battle README](lib/active_genie/battle/README.md)
-  for advanced usage, custom reviewers, and detailed interface documentation.\n\n###
-  Ranking\nThe Ranking module provides competitive ranking through multi-stage evaluation:\n\n```ruby\nrequire
-  'active_genie'\n\nplayers = ['REST API', 'GraphQL API', 'SOAP API', 'gRPC API',
-  'Websocket API']\ncriteria = \"Best one to be used into a high changing environment\"\n\nresult
-  = ActiveGenie::Ranking.call(\n  players,\n  criteria,\n  config: { provider: :google,
-  model: 'gemini-2.0-flash-lite' } # optional\n)\n# => {\n#      winner_player: \"gRPC
-  API\",\n#      reasoning: \"gRPC API is the best one to be used into a high changing
-  environment\",\n#    }\n```\n\n*Recommended model*: `gemini-2.0-flash-lite`\n\n-
-  **Multi-phase ranking system** combining expert scoring and ELO algorithms\n- **Automatic
-  elimination** of inconsistent performers using statistical analysis\n- **Dynamic
-  ranking adjustments** based on simulated pairwise battles, from bottom to top\n\nSee
-  the [Ranking README](lib/active_genie/ranking/README.md) for implementation details,
-  configuration, and advanced ranking strategies.\n\n### Text Summarizer (Future)\n###
-  Categorizer (Future)\n### Language detector (Future)\n### Translator (Future)\n###
-  Sentiment analyzer (Future)\n\n## Benchmarking \U0001F9EA\n\nActiveGenie includes
-  a comprehensive benchmarking system to ensure consistent, high-quality outputs across
-  different LLM models and providers.\n\n```ruby\n# Run all benchmarks\nbundle exec
-  rake active_genie:benchmark\n\n# Run benchmarks for a specific module\nbundle exec
-  rake active_genie:benchmark[data_extractor]\n```\n\n### Latest Results\n\n| Model
-  | Overall Precision |\n|-------|-------------------|\n| claude-3-5-haiku-20241022
-  | 92.25% |\n| gemini-2.0-flash-lite | 84.25% |\n| gpt-4o-mini | 62.75% |\n| deepseek-chat
-  | 57.25% |\n\nSee the [Benchmark README](benchmark/README.md) for detailed results,
-  methodology, and how to contribute to our test suite.\n\n## Configuration\n\n| Config
-  | Description | Default |\n|--------|-------------|---------|\n| `provider` | LLM
-  provider (openai, anthropic, etc) | `nil` |\n| `model` | Model to use | `nil` |\n|
-  `api_key` | Provider API key | `nil` |\n| `timeout` | Request timeout in seconds
-  | `5` |\n| `max_retries` | Maximum retry attempts | `3` |\n\n> **Note:** Each module
-  can append its own set of configuration, see the individual module documentation
-  for details.\n\n## Contributing\n\n1. Fork the repository\n2. Create your feature
-  branch (`git checkout -b feature/amazing-feature`)\n3. Commit your changes (`git
-  commit -m 'Add amazing feature'`)\n4. Push to the branch (`git push origin feature/amazing-feature`)\n5.
-  Open a Pull Request\n\n## License\n\nThis project is licensed under the Apache License
-  2.0 License - see the [LICENSE](LICENSE) file for details.\n"
+  the wheel\n\nActiveGenie is a Ruby gem that provides valuable solutions powered
+  by Generative AI (GenAI) models. Just like Lodash or ActiveStorage, ActiveGenie
+  brings a set of Modules to reach real value fast and reliably.\nActiveGenie is backed
+  by a custom benchmarking system that ensures consistent quality and performance
+  across different models and providers in every release.\n\n## Features\n\n* **Data
+  Extractor:** Extract structured data from text using AI-powered analysis\n* **Scoring:**
+  Text evaluation system with detailed scoring and feedback\n* **Battle:** AI-powered
+  battle evaluation system between two players\n* **Ranking:** Multi-phase ranking
+  system for multiple options\n\n### Performance Breakdown\n\n| ActiveGenie Module
+  | Best Precision | Worst Precision | Recommended Model |\n|--------------------|-------------------|-------------------|-------------------|\n|
+  data_extractor | 100% | 86% | `gpt-4o-mini` |\n| battle | 100% | 10% | `gemini-2.0-flash-lite`
+  |\n| scoring | 69% | 61% | `claude-3-5-haiku-20241022` |\n| ranking | 100% | 0%
+  | `gemini-2.0-flash-lite` |\n\nSee the [GitHub repository](https://github.com/Roriz/active_genie)
+  for complete documentation and examples.\n"
 email:
 - radames@roriz.dev
 executables: []
@@ -124,6 +50,7 @@ files:
 - lib/active_genie/configuration/providers/base_config.rb
 - lib/active_genie/configuration/providers/deepseek_config.rb
 - lib/active_genie/configuration/providers/google_config.rb
+- lib/active_genie/configuration/providers/internal_company_api_config.rb
 - lib/active_genie/configuration/providers/openai_config.rb
 - lib/active_genie/configuration/providers_config.rb
 - lib/active_genie/configuration/runtime_config.rb
@@ -156,7 +83,6 @@ metadata:
   changelog_uri: https://github.com/Roriz/active_genie/blob/master/CHANGELOG.md
   bug_tracker_uri: https://github.com/Roriz/active_genie/issues
   rubygems_mfa_required: 'true'
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -171,8 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Transform your Ruby application with powerful, production-ready GenAI features
 test_files: []