active_genie 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '078409a35816dfb0870469dcf511a7b57bf216cd4665f0c50ef187e7be0c7707'
-  data.tar.gz: 108d56de78b375e23dfb0acc48db70175c6af0d457933cece70ff67f505c1203
+  metadata.gz: e7f834cd4da9f695c2a3f69b1d7d5516831afaa2d6830f89527b46e7e19bc6f9
+  data.tar.gz: 8e14a0011c2551b975105d2120506461fb5f0e9e33206a6960a9de544148016b
 SHA512:
-  metadata.gz: c5e7af633c6add150d098ebcd6589c564e570d1cad73a6937a0388b36ab418b4cf17ddda0dbed61d13ff6882c4a064e376caf3015d210ec70e884cba5951d71c
-  data.tar.gz: decbe01929b3412127fccbf5e0c08c8f96181348c35f2c8f13117385df7dbd42298783c69a11a1d990b320f8b01eb96d962a4a9546ee6df1d073cb42a13e1f84
+  metadata.gz: ed3662a287028dacf2f60bda458d0de38ad16d4666421e3b836780d9f2dbb469be935e0b6c3d1fff851f82282c4c4564bebc725354f2f213d0cf21e30ce5ce93
+  data.tar.gz: 50b0d666a061361322ec2bfb38ef0e49110d6b31be3c3b55e3873f6ca5389003d739f209c7a9e1b695e3901de703effe02344863fed80495c104e886b1d1fa3f

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/{requester → active_genie/clients}/openai.rb

@@ -1,10 +1,10 @@
 require 'json'
 require 'net/http'
 
-module ActiveGenie
+module ActiveGenie::Clients
   class Openai
     class << self
-      def function_calling(messages, function, options)
+      def function_calling(messages, function, options: {})
         app_config = ActiveGenie.config_by_model(options[:model])
 
         model = options[:model] || app_config[:model]
@@ -48,7 +48,6 @@ module ActiveGenie
 
     end
     
-      
     API_URL = 'https://api.openai.com/v1/chat/completions'.freeze
     DEFAULT_HEADERS = {
       'Content-Type': 'application/json',

data/lib/{requester/requester.rb → active_genie/clients/router.rb}

@@ -1,23 +1,23 @@
 require_relative './openai'
 
-module ActiveGenie
-  class Requester    
+module ActiveGenie::Clients
+  class Router
     class << self
-      def function_calling(messages, function, options = {})
+      def function_calling(messages, function, options: {})
         app_config = ActiveGenie.config_by_model(options[:model])
-        
+
         provider = options[:provider] || app_config[:provider]
-        provider_sdk = PROVIDER_TO_SDK[provider&.to_sym&.downcase]
-        raise "Provider #{provider} not supported" unless provider_sdk
+        client = PROVIDER_TO_CLIENT[provider&.downcase&.strip&.to_sym]
+        raise "Provider \"#{provider}\" not supported" unless client
 
-        response = provider_sdk.function_calling(messages, function, options)
+        response = client.function_calling(messages, function, options:)
 
         clear_invalid_values(response)
       end
 
       private
 
-      PROVIDER_TO_SDK = {
+      PROVIDER_TO_CLIENT = {
         openai: Openai,
       }
 

data/lib/active_genie/data_extractor/README.md

@@ -0,0 +1,132 @@
+# Data Extractor
+Extract structured data from text using AI-powered analysis, handling informal language and complex expressions.
+
+## ✨ Features
+- Structured data extraction - Extract typed data from unstructured text using predefined schemas
+- Informal text analysis - Identifies and handles informal language patterns, including litotes
+- Explanation tracking - Provides reasoning for each extracted data point
+
+## Basic Usage
+
+Extract structured data from text using predefined schemas:
+
+```ruby
+text = "John Doe is 25 years old"
+schema = {
+  name: { type: 'string', description: 'Full name of the person' },
+  age: { type: 'integer', description: 'Age in years' }
+}
+result = ActiveGenie::DataExtractor.call(text, schema)
+# => { 
+#      name: "John Doe", 
+#      name_explanation: "Found directly in text",
+#      age: 25, 
+#      age_explanation: "Explicitly stated as 25 years old" 
+#    }
+
+product = "Nike Air Max 90 - Size 42 - $199.99"
+schema = {
+  brand: { 
+    type: 'string',
+    enum: ["Nike", "Adidas", "Puma"]
+  },
+  price: { 
+    type: 'number',
+    minimum: 0
+  },
+  currency: { 
+    type: 'string',
+    enum: ["USD", "EUR"]
+  },
+  size: {
+    type: 'integer',
+    minimum: 35,
+    maximum: 46
+  }
+}
+
+result = ActiveGenie::DataExtractor.call(product, schema)
+# => { 
+#      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",
+#      currency: "USD",
+#      currency_explanation: "Derived from $ symbol"
+#    }
+```
+
+## Informal Text Processing
+
+The `from_informal` method extends the basic extraction by analyzing rhetorical devices and informal language patterns like:
+
+- Litotes ("not bad", "isn't terrible")
+- Affirmative expressions ("sure", "no problem")
+- Negative expressions ("nah", "not really")
+- Hedging ("maybe", "I guess")
+
+### Example
+
+```ruby
+text = "The weather isn't bad today"
+schema = { 
+  mood: { type: 'string', description: 'The mood of the message' } 
+}
+
+result = ActiveGenie::DataExtractor.from_informal(text, schema)
+# => { 
+#      mood: "positive",
+#      mood_explanation: "Speaker views weather favorably",
+#      message_litote: true,
+#      litote_rephrased: "The weather is good today"
+#    }
+```
+
+### Usage Notes
+- Best suited for processing conversational user inputs
+- Automatically detects and interprets litotes
+- Provides rephrased positive statements for litotes
+- May require more processing time due to rhetorical analysis
+- Accuracy depends on context clarity
+
+⚠️ Performance Impact: This method performs additional rhetorical analysis, which can increase processing time.
+
+## Interface
+
+### `.call(text, data_to_extract, options = {})`
+Extracts structured data from text based on a predefined schema.
+
+#### Parameters
+| Name | Type | Description | Required | Example |
+| --- | --- | --- | --- | --- |
+| `text` | `String` | The text to analyze and extract data from | Yes | "John Doe is 25 years old" |
+| `data_to_extract` | `Hash` | Schema defining the data structure to extract | Yes | `{ name: { type: 'string' } }` |
+| `options` | `Hash` | Additional extraction configuration | No | `{ model: "gpt-4" }` |
+
+#### Options
+| Name | Type | Description |
+| --- | --- | --- |
+| `model` | `String` | The model to use for the extraction |
+| `api_key` | `String` | The API key to use for the extraction |
+
+#### Returns
+`Hash` containing:
+- Extracted values matching the schema structure
+- Explanation field for each extracted value
+- Additional analysis fields when using `from_informal`
+
+### `.from_informal(text, data_to_extract, options = {})`
+Extends basic extraction with rhetorical analysis, particularly for litotes.
+
+#### Additional Return Fields
+| Name | Type | Description |
+| --- | --- | --- |
+| `message_litote` | `Boolean` | Whether the text contains a litote |
+| `litote_rephrased` | `String` | Positive rephrasing of any detected litote |
+
+⚠️ Performance Considerations
+- Both methods may require multiple AI model calls
+- Informal processing requires additional rhetorical analysis
+- Consider background processing for production use

data/lib/active_genie/data_extractor/basic.rb

@@ -0,0 +1,88 @@
+require_relative '../clients/router.rb'
+
+module ActiveGenie::DataExtractor
+  class Basic
+    def self.call(text, data_to_extract, options: {})
+      new(text, data_to_extract, options:).call
+    end
+
+    # Extracts structured data from text based on a predefined schema.
+    #
+    # @param text [String] The input text to analyze and extract data from
+    # @param data_to_extract [Hash] Schema defining the data structure to extract.
+    #   Each key in the hash represents a field to extract, and its value defines the expected type and constraints.
+    # @param options [Hash] Additional options for the extraction process
+    #   @option options [String] :model The model to use for the extraction
+    #   @option options [String] :api_key The API key to use for the extraction
+    #
+    # @return [Hash] The extracted data matching the schema structure. Each field will include
+    #   both the extracted value and an explanation of how it was derived.
+    #
+    # @example Extract a person's details
+    #   schema = {
+    #     name: { type: 'string', description: 'Full name of the person' },
+    #     age: { type: 'integer', description: 'Age in years' }
+    #   }
+    #   text = "John Doe is 25 years old"
+    #   DataExtractor.call(text, schema)
+    #   # => { name: "John Doe", name_explanation: "Found directly in text",
+    #   #      age: 25, age_explanation: "Explicitly stated as 25 years old" }
+    def initialize(text, data_to_extract, options: {})
+      @text = text
+      @data_to_extract = data_to_extract
+      @options = options
+    end
+
+    def call
+      messages = [
+        {  role: 'system', content: PROMPT },
+        {  role: 'user', content: @text }
+      ]
+      function = {
+        name: 'data_extractor',
+        description: 'Extract structured and typed data from user messages.',
+        schema: {
+          type: "object",
+          properties: data_to_extract_with_explaination
+        }
+      }
+
+      ::ActiveGenie::Clients::Router.function_calling(messages, function, options: @options)
+    end
+
+    private
+
+    PROMPT = <<~PROMPT
+    Extract structured and typed data from user messages.
+    Identify relevant information within user messages and categorize it into predefined data fields with specific data types.
+
+    # Steps
+    1. **Identify Data Types**: Determine the types of data to collect, such as names, dates, email addresses, phone numbers, etc.
+    2. **Extract Information**: Use pattern recognition and language understanding to identify and extract the relevant pieces of data from the user message.
+    3. **Categorize Data**: Assign the extracted data to the appropriate predefined fields.
+    4. **Structure Data**: Format the extracted and categorized data in a structured format, such as JSON.
+
+    # Output Format
+    The output should be a JSON object containing fields with their corresponding extracted values. If a value is not found, the field should still be included with a null value.
+
+    # Notes
+    - Handle missing or partial information gracefully.
+    - Manage multiple occurrences of similar data points by prioritizing the first one unless specified otherwise.
+    - Be flexible to handle variations in data format and language clues.
+    PROMPT
+
+    def data_to_extract_with_explaination
+      with_explaination = {}
+  
+      @data_to_extract.each do |key, value|
+        with_explaination[key] = value
+        with_explaination["#{key}_explanation"] = {
+          type: 'string',
+          description: "The chain of thought that led to the conclusion about: #{key}. Can be blank if the user didn't provide any context",
+        }
+      end
+      
+      with_explaination
+    end
+  end
+end

data/lib/active_genie/data_extractor/from_informal.rb

@@ -0,0 +1,58 @@
+module ActiveGenie::DataExtractor
+  class FromInformal
+    def self.call(text, data_to_extract, options: {})
+      new(text, data_to_extract, options:).call()
+    end
+
+    # Extracts data from informal text while also detecting litotes and their meanings.
+    # This method extends the basic extraction by analyzing rhetorical devices.
+    #
+    # @param text [String] The informal text to analyze
+    # @param data_to_extract [Hash] Schema defining the data structure to extract
+    # @param options [Hash] Additional options for the extraction process
+    #
+    # @return [Hash] The extracted data including litote analysis. In addition to the
+    #   schema-defined fields, includes:
+    #   - message_litote: Whether the text contains a litote
+    #   - litote_rephrased: The positive rephrasing of any detected litote
+    #
+    # @example Analyze text with litote
+    #   text = "The weather isn't bad today"
+    #   schema = { mood: { type: 'string', description: 'The mood of the message' } }
+    #   DataExtractor.from_informal(text, schema)
+    #   # => { mood: "positive", mood_explanation: "Speaker views weather favorably",
+    #   #      message_litote: true,
+    #   #      litote_rephrased: "The weather is good today" }
+    def initialize(text, data_to_extract, options: {})
+      @text = text
+      @data_to_extract = data_to_extract
+      @options = options
+    end
+
+    def call
+      response = Basic.call(@text, data_to_extract_with_litote, options: @options)
+
+      if response['message_litote']
+        response = Basic.call(response['litote_rephrased'], @data_to_extract, options: @options)
+      end
+
+      response
+    end
+
+    private
+
+    def data_to_extract_with_litote
+      {
+        **@data_to_extract,
+        message_litote: {
+          type: 'boolean',
+          description: 'Return true if the message is a litote. A litote is a figure of speech that uses understatement to emphasize a point by stating a negative to further affirm a positive, often incorporating double negatives for effect.'
+        },
+        litote_rephrased: {
+          type: 'string',
+          description: 'The true meaning of the litote. Rephrase the message to a positive and active statement.'
+        }
+      }
+    end
+  end
+end

data/lib/active_genie/data_extractor.rb

@@ -0,0 +1,17 @@
+require_relative 'data_extractor/basic'
+require_relative 'data_extractor/from_informal'
+
+module ActiveGenie
+  # Extract structured data from text using AI-powered analysis, handling informal language and complex expressions.
+  module DataExtractor
+    module_function
+
+    def basic(text, data_to_extract, options: {})
+      Basic.call(text, data_to_extract, options:)
+    end
+
+    def from_informal(text, data_to_extract, options: {})
+      FromInformal.call(text, data_to_extract, options:)
+    end
+  end
+end

data/lib/active_genie/scoring/README.md

@@ -0,0 +1,80 @@
+# Scoring
+Text evaluation system that provides detailed scoring and feedback using multiple expert reviewers.
+
+## Features
+- Multi-reviewer evaluation - Get scores and feedback from multiple AI-powered expert reviewers
+- Automatic reviewer selection - Smart recommendation of reviewers based on content and criteria
+- Detailed feedback - Comprehensive reasoning for each reviewer's score
+- Customizable weights - Adjust the importance of different reviewers' scores
+- Flexible criteria - Score text against any specified evaluation criteria
+
+## Basic Usage
+
+Score text using predefined reviewers:
+
+```ruby
+text = "The code implements a binary search algorithm with O(log n) complexity"
+criteria = "Evaluate technical accuracy and clarity"
+reviewers = ["Algorithm Expert", "Technical Writer"]
+
+result = ActiveGenie::Scoring::Basic.call(text, criteria, reviewers)
+# => {
+#      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
+#    }
+```
+
+## Automatic Reviewer Selection
+
+When no reviewers are specified, the system automatically recommends appropriate reviewers:
+
+```ruby
+text = "The patient shows signs of improved cardiac function"
+criteria = "Evaluate medical accuracy and clarity"
+
+result = ActiveGenie::Scoring::Basic.call(text, criteria)
+# => {
+#      cardiologist_score: 88,
+#      cardiologist_reasoning: "Accurate assessment of cardiac improvement",
+#      medical_writer_score: 85,
+#      medical_writer_reasoning: "Clear communication of medical findings",
+#      general_practitioner_score: 90,
+#      general_practitioner_reasoning: "Well-structured medical observation",
+#      final_score: 87.7
+#    }
+```
+
+## Interface
+
+### `Basic.call(text, criteria, reviewers = [], options: {})`
+Main interface for scoring text content.
+
+#### Parameters
+- `text` [String] - The text content to be evaluated
+- `criteria` [String] - The evaluation criteria or rubric to assess against
+- `reviewers` [Array<String>] - Optional list of specific reviewers
+- `options` [Hash] - Additional configuration options
+  - `:detailed_feedback` [Boolean] - Request more detailed feedback (WIP)
+  - `:reviewer_weights` [Hash] - Custom weights for different reviewers (WIP)
+
+### `RecommendedReviews.call(text, criteria, options: {})`
+Recommends appropriate reviewers based on content and criteria.
+
+#### Parameters
+- `text` [String] - The text content to analyze
+- `criteria` [String] - The evaluation criteria
+- `options` [Hash] - Additional configuration options
+  - `:prefer_technical` [Boolean] - Favor technical expertise (WIP)
+  - `:prefer_domain` [Boolean] - Favor domain expertise (WIP)
+
+### Usage Notes
+- Best suited for objective evaluation of text content
+- Provides balanced scoring through multiple reviewers
+- Automatically handles reviewer selection when needed
+- Supports custom weighting of reviewer scores
+- Returns detailed reasoning for each score
+
+Performance Impact: Using multiple reviewers or requesting detailed feedback may increase processing time.

data/lib/active_genie/scoring/basic.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative '../clients/router'
+
+module ActiveGenie::Scoring
+  # The Basic class provides a foundation for scoring text content against specified criteria
+  # using AI-powered evaluation. It supports both single and multiple reviewer scenarios,
+  # with the ability to automatically recommend reviewers when none are specified.
+  #
+  # The scoring process evaluates text based on given criteria and returns detailed feedback
+  # including individual reviewer scores, reasoning, and a final aggregated score.
+  #
+  # @example Basic usage with a single reviewer
+  #   Basic.call("Sample text", "Evaluate grammar and clarity", ["Grammar Expert"])
+  #
+  # @example Usage with automatic reviewer recommendation
+  #   Basic.call("Sample text", "Evaluate technical accuracy")
+  #
+  class Basic
+    def self.call(text, criteria, reviewers = [], options: {})
+      new(text, criteria, reviewers, options:).call
+    end
+
+    # Initializes a new scoring evaluation instance
+    #
+    # @param text [String] The text content to be evaluated
+    # @param criteria [String] The evaluation criteria or rubric to assess against
+    # @param reviewers [Array<String>] Optional list of specific reviewers. If empty,
+    #   reviewers will be automatically recommended based on the content and criteria
+    # @param options [Hash] Additional configuration options that modify the scoring behavior
+    # @option options [Boolean] :detailed_feedback Request more detailed feedback in the reasoning
+    # @option options [Hash] :reviewer_weights Custom weights for different reviewers
+    def initialize(text, criteria, reviewers = [], options: {})
+      @text = text
+      @criteria = criteria
+      @reviewers = Array(reviewers).compact.uniq
+      @options = options
+    end
+
+    def call
+      messages = [
+        {  role: 'system', content: PROMPT },
+        {  role: 'user', content: "Scoring criteria: #{@criteria}" },
+        {  role: 'user', content: "Text to score: #{@text}" }, 
+      ]
+
+      properties = {}
+      get_or_recommend_reviewers.each do |reviewer|
+        properties["#{reviewer}_reasoning"] = {
+          type: 'string',
+          description: "The reasoning of the scoring process by #{reviewer}.",
+        }
+        properties["#{reviewer}_score"] = {
+          type: 'number',
+          description: "The score given by #{reviewer}.",
+          min: 0,
+          max: 100
+        }
+      end
+
+      function = {
+        name: 'scoring',
+        description: 'Score the text based on the given criteria.',
+        schema: {
+          type: "object",
+          properties: {
+            **properties,
+            final_score: {
+              type: 'number',
+              description: 'The final score based on the previous reviewers',
+            },
+            final_reasoning: {
+              type: 'string',
+              description: 'The final reasoning based on the previous reviewers',
+            }
+          }
+        }
+      }
+
+      ::ActiveGenie::Clients::Router.function_calling(messages, function, options: @options)
+    end
+
+    private
+
+    def get_or_recommend_reviewers
+      @get_or_recommend_reviewers ||= if @reviewers.count > 0 
+        @reviewers
+      else
+        recommended_reviews = RecommendedReviews.call(@text, @criteria, options: @options)
+
+        [recommended_reviews[:reviewer1], recommended_reviews[:reviewer2], recommended_reviews[:reviewer3]]
+      end
+    end
+
+    PROMPT = <<~PROMPT
+    Evaluate and score the provided text based on predefined criteria, which may include rules, keywords, or patterns. Use a scoring range of 0 to 100, with 100 representing the highest possible score. Follow the instructions below to ensure an accurate and objective assessment.
+
+    # Evaluation Process
+    1. **Analysis**: Thoroughly compare the text against each criterion to ensure comprehensive evaluation.
+    2. **Document Deviations**: Clearly identify and document any areas where the content does not align with the specified criteria.
+    3. **Highlight Strengths**: Emphasize notable features or elements that enhance the overall quality or effectiveness of the content.
+    4. **Identify Weaknesses**: Specify areas where the content fails to meet the criteria or where improvements could be made.
+
+    # Output Requirements
+    Provide a detailed review, including:
+      - A final score (0-100)
+      - Specific reasoning for the assigned score, covering all evaluated criteria.
+      - Ensure the reasoning includes both positive aspects and suggested improvements.
+
+    # Guidelines
+    - Maintain objectivity, avoiding biases or preconceived notions.
+    - Deconstruct each criterion into actionable components for a systematic evaluation.
+    - If the text lacks information, apply reasonable judgment to assign a score while clearly explaining the rationale.
+    PROMPT
+  end
+end

data/lib/active_genie/scoring/recommended_reviews.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative '../clients/router.rb'
+
+module ActiveGenie::Scoring
+  # The RecommendedReviews class intelligently suggests appropriate reviewer roles
+  # for evaluating text content based on specific criteria. It uses AI to analyze
+  # the content and criteria to identify the most suitable subject matter experts.
+  #
+  # The class ensures a balanced and comprehensive review process by recommending
+  # three distinct reviewer roles with complementary expertise and perspectives.
+  #
+  # @example Getting recommended reviewers for technical content
+  #   RecommendedReviews.call("Technical documentation about API design", 
+  #                           "Evaluate technical accuracy and clarity")
+  #   # => { reviewer1: "API Architect", reviewer2: "Technical Writer", 
+  #   #      reviewer3: "Developer Advocate", reasoning: "..." }
+  #
+  class RecommendedReviews
+    def self.call(text, criteria, options: {})
+      new(text, criteria, options:).call
+    end
+
+    # Initializes a new reviewer recommendation instance
+    #
+    # @param text [String] The text content to analyze for reviewer recommendations
+    # @param criteria [String] The evaluation criteria that will guide reviewer selection
+    # @param options [Hash] Additional configuration options that modify the recommendation process
+    # @option options [Boolean] :prefer_technical Whether to favor technical expertise
+    # @option options [Boolean] :prefer_domain Whether to favor domain expertise
+    def initialize(text, criteria, options: {})
+      @text = text
+      @criteria = criteria
+      @options = options
+    end
+
+    def call
+      messages = [
+        {  role: 'system', content: PROMPT },
+        {  role: 'user', content: "Scoring criteria: #{@criteria}" },
+        {  role: 'user', content: "Text to score: #{@text}" },
+      ]
+
+      function = {
+        name: 'identify_reviewers',
+        description: 'Discover reviewers based on the text and given criteria.',
+        schema: {
+          type: "object",
+          properties: {
+            reasoning: { type: 'string' },
+            reviewer1: { type: 'string' },
+            reviewer2: { type: 'string' },
+            reviewer3: { type: 'string' },
+          }
+        }
+      }
+
+      ::ActiveGenie::Clients::Router.function_calling(messages, function, options:)
+    end
+
+    private
+
+    PROMPT = <<~PROMPT
+    Identify the top 3 suitable reviewer titles or roles based on the provided text and criteria. Selected reviewers must possess subject matter expertise, offer valuable insights, and ensure diverse yet aligned perspectives on the content.
+
+    # Instructions
+    1. **Analyze the Text and Criteria**: Examine the content and criteria to identify relevant reviewer titles or roles.
+    2. **Determine Subject Matter Expertise**: Select reviewers with substantial knowledge or experience in the subject area.
+    3. **Evaluate Insight Contribution**: Prioritize titles or roles capable of providing meaningful and actionable feedback on the content.
+    4. **Incorporate Perspective Diversity**: Ensure the selection includes reviewers with varied but complementary viewpoints while maintaining alignment with the criteria.
+
+    # Constraints
+    - Selected reviewers must align with the content’s subject matter and criteria.
+    - Include reasoning for how each choice supports a thorough and insightful review.
+    - Avoid redundant or overly similar titles/roles to maintain diversity.
+    PROMPT
+  end
+end

data/lib/active_genie/scoring.rb

@@ -0,0 +1,17 @@
+require_relative 'scoring/basic'
+require_relative 'scoring/recommended_reviews'
+
+module ActiveGenie
+  # Text evaluation system that provides detailed scoring and feedback using multiple expert reviewers
+  module Scoring
+    module_function
+
+    def basic(text, criteria, reviewers = [], options: {})
+      Basic.call(text, criteria, reviewers, options:)
+    end
+
+    def recommended_reviews(text, criteria, options: {})
+      RecommendedReviews.call(text, criteria, options:)
+    end
+  end
+end

data/lib/active_genie.rb

@@ -1,5 +1,6 @@
 module ActiveGenie
-  autoload :DataExtractor, File.join(__dir__, 'data_extractor/data_extractor')
+  autoload :DataExtractor, File.join(__dir__, 'active_genie/data_extractor')
+  autoload :Scoring, File.join(__dir__, 'active_genie/scoring')
   autoload :Configuration, File.join(__dir__, 'active_genie/configuration')
 
   class << self
@@ -16,7 +17,7 @@ module ActiveGenie
     end
 
     def config_by_model(model)
-      config.values[model&.to_s] || config.values.values.first || {}
+      config.values[model&.to_s&.downcase&.strip] || config.values.values.first || {}
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_genie
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Radamés Roriz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-01-23 00:00:00.000000000 Z
+date: 2025-01-25 00:00:00.000000000 Z
 dependencies: []
 description: |2
       ActiveGenie provides a robust toolkit for integrating AI capabilities into Ruby applications.
@@ -27,11 +27,17 @@ files:
 - README.md
 - VERSION
 - lib/active_genie.rb
+- lib/active_genie/clients/openai.rb
+- lib/active_genie/clients/router.rb
 - lib/active_genie/configuration.rb
-- lib/data_extractor/README.md
-- lib/data_extractor/data_extractor.rb
-- lib/requester/openai.rb
-- lib/requester/requester.rb
+- lib/active_genie/data_extractor.rb
+- lib/active_genie/data_extractor/README.md
+- lib/active_genie/data_extractor/basic.rb
+- lib/active_genie/data_extractor/from_informal.rb
+- lib/active_genie/scoring.rb
+- lib/active_genie/scoring/README.md
+- lib/active_genie/scoring/basic.rb
+- lib/active_genie/scoring/recommended_reviews.rb
 - lib/tasks/install.rake
 - lib/tasks/templates/active_ai.yml
 homepage: https://github.com/Roriz/active_genie
@@ -41,7 +47,6 @@ metadata:
   homepage_uri: https://github.com/Roriz/active_genie
   documentation_uri: https://github.com/Roriz/active_genie/wiki
   changelog_uri: https://github.com/Roriz/active_genie/blob/master/CHANGELOG.md
-  source_code_uri: https://github.com/Roriz/active_genie
   bug_tracker_uri: https://github.com/Roriz/active_genie/issues
   rubygems_mfa_required: 'true'
 post_install_message: 

data/lib/data_extractor/README.md

@@ -1,103 +0,0 @@
-# Data Extractor
-Extract structured data from text using LLM-powered analysis, handling informal language and complex expressions.
-
-## ✨ Features
-- Simple extraction   - Extract structured data from unstructured text
-- Informal extraction - Identifies and handles informal language patterns
-
-## Basic Usage
-
-Extract structured data from text using predefined schemas:
-
-```ruby
-text = "iPhone 14 Pro Max"
-schema = {
-  brand: { type: 'string' },
-  model: { type: 'string' }
-}
-result = ActiveGenie::DataExtractor.call(text, schema)
-# => { brand: "iPhone", model: "14 Pro Max" }
-
-product = "Nike Air Max 90 - Size 42 - $199.99"
-schema = {
-  brand: { 
-    type: 'string',
-    enum: ["Nike", "Adidas", "Puma"]
-  },
-  price: { 
-    type: 'number',
-    minimum: 0
-  },
-  currency: { 
-    type: 'string',
-    enum: ["USD", "EUR"]
-  },
-  size: {
-    type: 'integer',
-    minimum: 35,
-    maximum: 46
-  }
-}
-
-result = ActiveGenie::DataExtractor.call(product, schema)
-# => { brand: "Nike", price: 199.99, size: 42, currency: "USD" }
-```
-
-## Informal Text Processing
-
-The `from_informal` method helps extract structured data from casual, conversational text by interpreting common informal expressions and linguistic patterns like:
-
-- Affirmative expressions ("sure", "no problem", "you bet")
-- Negative expressions ("nah", "not really", "pass")
-- Hedging ("maybe", "I guess", "probably")
-- Litotes ("not bad", "not the worst")
-
-### Example
-
-```ruby
-text = <<~TEXT
-  system: Would you like to proceed with the installation?
-  user: not bad
-TEXT
-
-data_to_extract = {
-  user_consent: { type: 'boolean' }
-}
-
-result = ActiveGenie::DataExtractor.from_informal(text, data_to_extract)
-puts result # => { user_consent: true }
-```
-
-### Usage Notes
-- Best suited for processing conversational user inputs
-- Handles ambiguous or indirect responses
-- Useful for chatbots and conversational interfaces
-- May require more processing time and tokens
-- Accuracy depends on context clarity
-
-⚠️ Performance Impact: This method uses additional language processing, which can increase token usage and processing time. 
-
-## Interface
-`.call(text, data_to_extract, options = {})`
-Extracts structured data from text based on a schema.
-
-### Parameters
-| Name | Type | Description | Required | Example | Default |
-| --- | --- | --- | --- | --- | --- |
-| `text` | `String` | The text to extract data from. Max 1000 chars. | Yes | "These Nike shoes are red" | - |
-| `data_to_extract` | `Hash` | [JSON Schema object](https://json-schema.org/understanding-json-schema/reference/object) defining data structure | Yes | `{ category: { type: 'string', enum: ["shoes"] } }` | - |
-| `options` | `Hash` | Additional provider configuration options | No | `{ model: "gpt-4" }` | `{}` |
-
-### Returns
-`Hash` - Dynamic hash based on the `data_to_extract` schema.
-
-### Options
-| Name | Type | Description | Default |
-| --- | --- | --- | --- |
-| `model` | `String` | The model name | `YAML.load_file(config_file).first.model` |
-| `api_key` | `String` | The API key to use or api_key from model on config.yml | `YAML.load_file(config_file).first.api_key` |
-
-⚠️ Performance Considerations
-- Processes may require multiple LLM calls
-- Expect ~100 tokens per request + the text from input
-- Consider background processing for production use

data/lib/data_extractor/data_extractor.rb

@@ -1,88 +0,0 @@
-require_relative '../requester/requester.rb'
-
-module ActiveGenie
-  class DataExtractor    
-    class << self
-      # Extracts data from user_texts based on the schema defined in data_to_extract.
-      # @param text [String] The text to extract data from.
-      # @param data_to_extract [Hash] The schema to extract data from the text.
-      # @param options [Hash] The options to pass to the function.
-      # @return [Hash] The extracted data.
-      def call(text, data_to_extract, options: {})
-        messages = [
-          {  role: 'system', content: PROMPT },
-          {  role: 'user', content: text[0..1000] }
-        ]
-        function = {
-          name: 'data_extractor',
-          description: 'Extract structured and typed data from user messages.',
-          schema: {
-            type: "object",
-            properties: data_to_extract_with_explaination(data_to_extract)
-          }
-        }
-
-        ::ActiveGenie::Requester.function_calling(messages, function, options)
-      end
-
-      def from_informal(text, data_to_extract, options = {})
-        messages = [
-          {  role: 'system', content: PROMPT },
-          {  role: 'user', content: text }
-        ]
-        properties = data_to_extract_with_explaination(data_to_extract)
-        properties[:message_litote] = {
-          type: 'boolean',
-          description: 'Return true if the message is a litote. A litote is a figure of speech that uses understatement to emphasize a point by stating a negative to further affirm a positive, often incorporating double negatives for effect.'
-        }
-        properties[:litote_rephrased] = {
-          type: 'string',
-          description: 'The true meaning of the litote. Rephrase the message to a positive statement.'
-        }
-
-        function = {
-          name: 'data_extractor',
-          description: 'Extract structured and typed data from user messages.',
-          schema: { type: "object", properties: }
-        }
-
-        ::ActiveGenie::Requester.function_calling(messages, function, options)
-      end
-
-      private
-
-      PROMPT = <<~PROMPT
-      Extract structured and typed data from user messages.
-      Identify relevant information within user messages and categorize it into predefined data fields with specific data types.
-
-      # Steps
-      1. **Identify Data Types**: Determine the types of data to collect, such as names, dates, email addresses, phone numbers, etc.
-      2. **Extract Information**: Use pattern recognition and language understanding to identify and extract the relevant pieces of data from the user message.
-      3. **Categorize Data**: Assign the extracted data to the appropriate predefined fields.
-      4. **Structure Data**: Format the extracted and categorized data in a structured format, such as JSON.
-
-      # Output Format
-      The output should be a JSON object containing fields with their corresponding extracted values. If a value is not found, the field should still be included with a null value.
-
-      # Notes
-      - Handle missing or partial information gracefully.
-      - Manage multiple occurrences of similar data points by prioritizing the first one unless specified otherwise.
-      - Be flexible to handle variations in data format and language clues.
-      PROMPT
-
-      def data_to_extract_with_explaination(data_to_extract)
-        with_explaination = {}
-    
-        data_to_extract.each do |key, value|
-          with_explaination[key] = value
-          with_explaination["#{key}_explanation"] = {
-            type: 'string',
-            description: "The chain of thought that led to the conclusion about: #{key}. Can be blank if the user didn't provide any context",
-          }
-        end
-        
-        with_explaination
-      end
-    end
-  end
-end