ActiveGenie 🧞‍♂️

gem 'active_genie'

ActiveGenie.configure do |config|
  config.openai.api_key = ENV['OPENAI_API_KEY']
end

text = "Nike Air Max 90 - Size 42 - $199.99"
schema = {
  brand: { 
    type: 'string',
    enum: ["Nike", "Adidas", "Puma"]
  },
  price: { 
    type: 'number',
    minimum: 0
  },
  size: {
    type: 'number',
    minimum: 35,
    maximum: 46
  }
}

result = ActiveGenie::DataExtractor.call(
  text,
  schema,
  config: { provider: :openai, model: 'gpt-4o-mini' } # optional
)
# => { 
#      brand: "Nike", 
#      brand_explanation: "Brand name found at start of text",
#      price: 199.99,
#      price_explanation: "Price found in USD format at end",
#      size: 42,
#      size_explanation: "Size explicitly stated in the middle"
#    }

text = "The code implements a binary search algorithm with O(log n) complexity"
criteria = "Evaluate technical accuracy and clarity"

result = ActiveGenie::Scoring.basic(
  text,
  criteria,
  config: { provider: :anthropic, model: 'claude-3-5-haiku-20241022' } # optional
)
# => {
#      algorithm_expert_score: 95,
#      algorithm_expert_reasoning: "Accurately describes binary search and its complexity",
#      technical_writer_score: 90,
#      technical_writer_reasoning: "Clear and concise explanation of the algorithm",
#      final_score: 92.5
#    }

require 'active_genie'

player_1 = "Implementation uses dependency injection for better testability"
player_2 = "Code has high test coverage but tightly coupled components"
criteria = "Evaluate code quality and maintainability"

result = ActiveGenie::Battle.call(
  player_1,
  player_2,
  criteria,
  config: { provider: :google, model: 'gemini-2.0-flash-lite' } # optional
)
# => {
#      winner_player: "Implementation uses dependency injection for better testability",
#      reasoning: "Player 1 implementation demonstrates better maintainability through dependency injection, 
#                 which allows for easier testing and component replacement. While Player 2 has good test coverage, 
#                 the tight coupling makes the code harder to maintain and modify.",
#      what_could_be_changed_to_avoid_draw: "Focus on specific architectural patterns and design principles"
#    }

require 'active_genie'

players = ['REST API', 'GraphQL API', 'SOAP API', 'gRPC API', 'Websocket API']
criteria = "Best one to be used into a high changing environment"

result = ActiveGenie::Ranking.call(
  players,
  criteria,
  config: { provider: :google, model: 'gemini-2.0-flash-lite' } # optional
)
# => {
#      winner_player: "gRPC API",
#      reasoning: "gRPC API is the best one to be used into a high changing environment",
#    }

# Run all benchmarks
bundle exec rake active_genie:benchmark

# Run benchmarks for a specific module
bundle exec rake active_genie:benchmark[data_extractor]

# 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 || 'http://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

# 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