boxcars 0.1.0

data/lib/boxcars/conductor.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Boxcars
+  # @abstract
+  class Conductor
+    attr_reader :engine, :boxcars, :name, :description, :prompt, :engine_boxcar, :return_values
+
+    # A Conductor will use a engine to run a series of boxcars.
+    # @param engine [Boxcars::Engine] The engine to use for this conductor.
+    # @param boxcars [Array<Boxcars::Boxcar>] The boxcars to run.
+    # @abstract
+    def initialize(engine:, boxcars:, prompt:, name: nil, description: nil)
+      @engine = engine
+      @boxcars = boxcars
+      @prompt = prompt
+      @name = name || self.class.name
+      @description = description
+      @return_values = [:output]
+      @engine_boxcar = EngineBoxcar.new(prompt: prompt, engine: engine)
+    end
+
+    # Get an answer from the conductor.
+    # @param question [String] The question to ask the conductor.
+    # @return [String] The answer to the question.
+    def run(question)
+      raise NotImplementedError
+    end
+
+    # Extract the boxcar name and input from the text.
+    def extract_boxcar_and_input(text)
+    end
+
+    def stop
+      ["\n#{observation_prefix}"]
+    end
+
+    def construct_scratchpad(intermediate_steps)
+      thoughts = ""
+      intermediate_steps.each do |action, observation|
+        thoughts += action.is_a?(String) ? action : action.log
+        thoughts += "\n#{observation_prefix}#{observation}\n#{engine_prefix}"
+      end
+      thoughts
+    end
+
+    def get_next_action(full_inputs)
+      full_output = engine_boxcar.predict(**full_inputs)
+      parsed_output = extract_boxcar_and_input(full_output)
+      while parsed_output.nil?
+        full_output = _fix_text(full_output)
+        full_inputs[:agent_scratchpad] += full_output
+        output = engine_boxcar.predict(**full_inputs)
+        full_output += output
+        parsed_output = extract_boxcar_and_input(full_output)
+      end
+      ConductorAction.new(boxcar: parsed_output[0], boxcar_input: parsed_output[1], log: full_output)
+    end
+
+    # Given input, decided what to do.
+    # @param intermediate_steps [Array<Hash>] The intermediate steps taken so far along with observations.
+    # @param kwargs [Hash] User inputs.
+    # @return [Boxcars::Action] Action specifying what boxcar to use.
+    def plan(intermediate_steps, **kwargs)
+      thoughts = construct_scratchpad(intermediate_steps)
+      new_inputs = { agent_scratchpad: thoughts, stop: stop }
+      full_inputs = kwargs.merge(new_inputs)
+      action = get_next_action(full_inputs)
+      return ConductorFinish.new({ output: action.boxcar_input }, log: action.log) if action.boxcar == finish_boxcar_name
+
+      action
+    end
+
+    # Prepare the agent for new call, if needed
+    def prepare_for_new_call
+    end
+
+    # Name of the boxcar to use to finish the chain
+    def finish_boxcar_name
+      "Final Answer"
+    end
+
+    def input_keys
+      # Return the input keys
+      list = prompt.input_variables
+      list.delete(:agent_scratchpad)
+      list
+    end
+
+    # Check that all inputs are present.
+    def validate_inputs(inputs:)
+      missing_keys = input_keys - inputs.keys
+      raise "Missing some input keys: #{missing_keys}" if missing_keys.any?
+    end
+
+    def validate_prompt(values: Dict)
+      prompt = values["engine_chain"].prompt
+      unless prompt.input_variables.include?(:agent_scratchpad)
+        logger.warning("`agent_scratchpad` should be a variable in prompt.input_variables. Not found, adding it at the end.")
+        prompt.input_variables.append(:agent_scratchpad)
+        case prompt
+        when PromptTemplate
+          prompt.template += "\n%<agent_scratchpad>s"
+        when FewShotPromptTemplate
+          prompt.suffix += "\n%<agent_scratchpad>s"
+        else
+          raise ValueError, "Got unexpected prompt type #{type(prompt)}"
+        end
+      end
+      values
+    end
+
+    def return_stopped_response(early_stopping_method, intermediate_steps, **kwargs)
+      case early_stopping_method
+      when "force"
+        ConductorFinish({ output: "Agent stopped due to max iterations." }, "")
+      when "generate"
+        thoughts = ""
+        intermediate_steps.each do |action, observation|
+          thoughts += action.log
+          thoughts += "\n#{observation_prefix}#{observation}\n#{engine_prefix}"
+        end
+        thoughts += "\n\nI now need to return a final answer based on the previous steps:"
+        new_inputs = { agent_scratchpad: thoughts, stop: _stop }
+        full_inputs = kwargs.merge(new_inputs)
+        full_output = engine_boxcar.predict(**full_inputs)
+        parsed_output = extract_boxcar_and_input(full_output)
+        if parsed_output.nil?
+          ConductorFinish({ output: full_output }, full_output)
+        else
+          boxcar, boxcar_input = parsed_output
+          if boxcar == finish_boxcar_name
+            ConductorFinish({ output: boxcar_input }, full_output)
+          else
+            ConductorFinish({ output: full_output }, full_output)
+          end
+        end
+      else
+        raise "early_stopping_method should be one of `force` or `generate`, got #{early_stopping_method}"
+      end
+    end
+  end
+end
+
+require "boxcars/conductor/conductor_action"
+require "boxcars/conductor/conductor_finish"
+require "boxcars/conductor/conductor_executer"
+require "boxcars/conductor/zero_shot"

data/lib/boxcars/engine/engine_result.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Boxcars
+  # Class that contains all the relevant information for a engine result
+  class EngineResult
+    attr_accessor :generations, :engine_output
+
+    def initialize(generations: nil, engine_output: nil)
+      @generations = generations
+      @engine_output = engine_output
+    end
+  end
+end

data/lib/boxcars/engine/openai.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+# Boxcars is a framework for running a series of tools to get an answer to a question.
+module Boxcars
+  # A engine that uses OpenAI's API.
+  class Openai < Engine
+    attr_reader :prompts, :open_ai_params, :model_kwargs, :batch_size
+
+    DEFAULT_PARAMS = {
+      model: "text-davinci-003",
+      temperature: 0.7,
+      max_tokens: 256
+    }.freeze
+
+    DEFAULT_NAME = "OpenAI engine"
+    DEFAULT_DESCRIPTION = "useful for when you need to use AI to answer questions. " \
+                          "You should ask targeted questions"
+
+    # A engine is a container for a single tool to run.
+    # @param name [String] The name of the engine. Defaults to "OpenAI engine".
+    # @param description [String] A description of the engine. Defaults to:
+    #        useful for when you need to use AI to answer questions. You should ask targeted questions".
+    # @param prompts [Array<String>] The prompts to use when asking the engine. Defaults to [].
+    # @param batch_size [Integer] The number of prompts to send to the engine at once. Defaults to 20.
+    def initialize(name: DEFAULT_NAME, description: DEFAULT_DESCRIPTION, prompts: [], batch_size: 20, **kwargs)
+      @open_ai_params = DEFAULT_PARAMS.merge(kwargs)
+      @prompts = prompts
+      @batch_size = batch_size
+      super(description: description, name: name)
+    end
+
+    # Get an answer from the engine.
+    # @param question [String] The question to ask the engine.
+    # @param kwargs [Hash] Additional parameters to pass to the engine if wanted.
+    def client(prompt:, openai_access_token: 'not set', **kwargs)
+      access_token = Boxcars.configuration.openai_access_token(openai_access_token: openai_access_token)
+      organization_id = Boxcars.configuration.organization_id
+      clnt = ::OpenAI::Client.new(access_token: access_token, organization_id: organization_id)
+      the_params = { prompt: prompt }.merge(open_ai_params).merge(kwargs)
+      clnt.completions(parameters: the_params)
+    end
+
+    # get an answer from the engine for a question.
+    # @param question [String] The question to ask the engine.
+    # @param kwargs [Hash] Additional parameters to pass to the engine if wanted.
+    def run(question, **kwargs)
+      response = client(prompt: question, **kwargs)
+      answer = response["choices"].map { |c| c["text"] }.join("\n").strip
+      puts answer
+      answer
+    end
+
+    # Build extra kwargs from additional params that were passed in.
+    def build_extra(values:)
+      values[:model_kw_args] = @open_ai_params.merge(values)
+      values
+    end
+
+    def default_params
+      open_ai_params
+    end
+
+    def generation_info(sub_choices)
+      sub_choices.map do |choice|
+        Generation.new(
+          text: choice["text"],
+          generation_info: {
+            finish_reason: choice.fetch("finish_reason", nil),
+            logprobs: choice.fetch("logprobs", nil)
+          }
+        )
+      end
+    end
+
+    # Call out to OpenAI's endpoint with k unique prompts.
+
+    #   Args:
+    #     prompts: The prompts to pass into the model.
+    #     stop: Optional list of stop words to use when generating.
+
+    #   Returns:
+    #     The full engine output.
+
+    #   Example:
+    #     .. code-block:: ruby
+
+    #       response = openai.generate(["Tell me a joke."])
+    def generate(prompts:, stop: nil)
+      params = {}
+      params[:stop] = stop if stop
+      choices = []
+      token_usage = {}
+      # Get the token usage from the response.
+      # Includes prompt, completion, and total tokens used.
+      inkeys = %w[completion_tokens prompt_tokens total_tokens].freeze
+      sub_prompts = prompts.each_slice(batch_size).to_a
+      sub_prompts.each do |sprompts|
+        response = client(prompt: sprompts, **params)
+        choices.concat(response["choices"])
+        keys_to_use = inkeys & response["usage"].keys
+        keys_to_use.each { |key| token_usage[key] = token_usage[key].to_i + response["usage"][key] }
+      end
+
+      n = params.fetch(:n, 1)
+      generations = []
+      prompts.each_with_index do |_prompt, i|
+        sub_choices = choices[i * n, (i + 1) * n]
+        generations.push(generation_info(sub_choices))
+      end
+      EngineResult.new(generations: generations, engine_output: { token_usage: token_usage })
+    end
+    # rubocop:enable Metrics/AbcSize
+  end
+
+  def identifying_params
+    params = { model_name: model_name }
+    params.merge!(default_params)
+    params
+  end
+
+  def engine_type
+    "openai"
+  end
+
+  # calculate the number of tokens used
+  def get_num_tokens(text:)
+    text.split.length
+  end
+
+  def modelname_to_contextsize(modelname)
+    model_lookup = {
+      'text-davinci-003': 4097,
+      'text-curie-001': 2048,
+      'text-babbage-001': 2048,
+      'text-ada-001': 2048,
+      'code-davinci-002': 8000,
+      'code-cushman-001': 2048
+    }.freeze
+    model_lookup[modelname] || 4097
+  end
+
+  # Calculate the maximum number of tokens possible to generate for a prompt.
+
+  #   Args:
+  #     prompt: The prompt to use.
+
+  #   Returns:
+  #     The maximum number of tokens possible to generate for a prompt.
+  def max_tokens_for_prompt(prompt)
+    num_tokens = get_num_tokens(prompt)
+
+    # get max context size for model by name
+    max_size = modelname_to_contextsize(model_name)
+    max_size - num_tokens
+  end
+end

data/lib/boxcars/engine.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Boxcars
+  # @abstract
+  class Engine
+    # An Engine is used by Boxcars to generate output from prompts
+    # @param name [String] The name of the Engine. Defaults to classname.
+    # @param description [String] A description of the Engine.
+    def initialize(description: 'Engine', name: nil)
+      @name = name || self.class.name
+      @description = description
+    end
+
+    # Get an answer from the Engine.
+    # @param question [String] The question to ask the Engine.
+    def run(question)
+      raise NotImplementedError
+    end
+  end
+end
+
+require "boxcars/engine/engine_result"
+require "boxcars/engine/openai"

data/lib/boxcars/generation.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Boxcars
+  # Output of a single generation
+  class Generation
+    attr_accessor :text, :generation_info
+
+    def initialize(text: nil, generation_info: nil)
+      @text = text
+      @generation_info = generation_info
+    end
+  end
+end

data/lib/boxcars/prompt.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Boxcars
+  # used by Boxcars that have engine's to create a prompt.
+  class Prompt
+    attr_reader :template, :input_variables, :output_variables
+
+    # @param template [String] The template to use for the prompt.
+    # @param input_variables [Array<Symbol>] The input vars to use for the prompt.
+    # @param output_variables [Array<Symbol>] The output vars to use for the prompt. Defaults to [:agent_scratchpad]
+    def initialize(template:, input_variables:, output_variables: [:agent_scratchpad])
+      @template = template
+      @input_variables = input_variables
+      @output_variables = output_variables
+    end
+
+    # format the prompt with the input variables
+    def format(inputs)
+      @template % inputs
+    end
+
+    # check if the template is valid
+    def template_is_valid?
+      @template.include?("%<input>s") && @template.include?("%<agent_scratchpad>s")
+    end
+
+    # create a prompt template from examples
+    # @param examples [String] or [Array<String>] The example(s) to use for the template.
+    # @param input_variables [Array<Symbol>] The input variables to use for the prompt.
+    # @param example_separator [String] The separator to use between the examples. Defaults to "\n\n"
+    # @param prefix [String] The prefix to use for the template. Defaults to ""
+    def self.from_examples(examples:, suffix:, input_variables:, example_separator: "\n\n", prefix: "")
+      template = [prefix, examples, suffix].join(example_separator)
+      Prompt.new(template: template, input_variables: input_variables)
+    end
+
+    # create a prompt template from a file
+    # @param path [String] The path to the file to use for the template.
+    # @param input_variables [Array<Symbol>] The input variables to use for the prompt.
+    def self.from_file(path:, input_variables:)
+      template = File.read(path)
+      Prompt.new(template: template, input_variables: input_variables)
+    end
+  end
+end

data/lib/boxcars/ruby_repl.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Boxcars
+  # used by Boxcars to run ruby code
+  class RubyREPL
+    def call(code:)
+      puts "RubyREPL: #{code}".colorize(:red)
+      output = ""
+      IO.popen("ruby", "r+") do |io|
+        io.puts code
+        io.close_write
+        output = io.read
+      end
+      puts "Answer: #{output}".colorize(:red, style: :bold)
+      output
+    end
+
+    def run(command)
+      call(code: command)
+    end
+  end
+end

data/lib/boxcars/version.rb

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

data/lib/boxcars.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+# Boxcars is a framework for running a series of tools to get an answer to a question.
+module Boxcars
+  # Error class for all Boxcars errors.
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class ArgumentError < Error; end
+  class ValueError < Error; end
+
+  # simple string colorization
+  class ::String
+    def colorize(color, options = {})
+      background = options[:background] || options[:bg] || false
+      style = options[:style]
+      offsets = %i[gray red green yellow blue magenta cyan white]
+      styles = %i[normal bold dark italic underline xx xx underline xx strikethrough]
+      start = background ? 40 : 30
+      color_code = start + (offsets.index(color) || 8)
+      style_code = styles.index(style) || 0
+      "\e[#{style_code};#{color_code}m#{self}\e[0m"
+    end
+  end
+
+  # Configuration contains gem settings
+  class Configuration
+    attr_writer :openai_access_token, :serpapi_api_key
+    attr_accessor :organization_id, :logger
+
+    def initialize
+      @organization_id = nil
+      @logger = Rails.logger if defined?(Rails)
+      @logger ||= Logger.new($stdout)
+    end
+
+    # @return [String] The OpenAI Access Token either from arg or env.
+    def openai_access_token(**kwargs)
+      key_lookup(:openai_access_token, kwargs)
+    end
+
+    # @return [String] The SerpAPI API key either from arg or env.
+    def serpapi_api_key(**kwargs)
+      key_lookup(:serpapi_api_key, kwargs)
+    end
+
+    private
+
+    def check_key(key, val)
+      return val unless val.nil? || val.empty?
+
+      error_text = ":#{key} missing! Please pass key, or set #{key.to_s.upcase} environment variable."
+      raise ConfigurationError, error_text
+    end
+
+    def key_lookup(key, kwargs)
+      rv = if kwargs.key?(key) && kwargs[key] != "not set"
+             # override with kwargs if present
+             kwargs[key]
+           elsif (set_val = instance_variable_get("@#{key}"))
+             # use saved value if present
+             set_val
+           else
+             # otherwise, dig out of the environment
+             new_key = ENV.fetch(key.to_s.upcase, nil)
+             send("#{key}=", new_key) if new_key
+             new_key
+           end
+      check_key(key, rv)
+    end
+  end
+
+  # @return [Boxcars::Configuration] The configuration object.
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Boxcars::Configuration.new
+  end
+
+  # Configure the gem.
+  def self.configure
+    yield(configuration)
+  end
+end
+
+require "boxcars/version"
+require "boxcars/prompt"
+require "boxcars/generation"
+require "boxcars/ruby_repl"
+require "boxcars/engine"
+require "boxcars/boxcar"
+require "boxcars/conductor"

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: boxcars
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Francis Sullivan
+- Tabrez Syed
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: google_search_results
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: ruby-openai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+description: You simply give a number of boxcars to a conductor, and it does the magic.
+email:
+- hi@boxcars.ai
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/boxcars.rb
+- lib/boxcars/boxcar.rb
+- lib/boxcars/boxcar/calculator.rb
+- lib/boxcars/boxcar/engine_boxcar.rb
+- lib/boxcars/boxcar/serp.rb
+- lib/boxcars/boxcar/sql.rb
+- lib/boxcars/conductor.rb
+- lib/boxcars/conductor/conductor_action.rb
+- lib/boxcars/conductor/conductor_executer.rb
+- lib/boxcars/conductor/conductor_finish.rb
+- lib/boxcars/conductor/zero_shot.rb
+- lib/boxcars/engine.rb
+- lib/boxcars/engine/engine_result.rb
+- lib/boxcars/engine/openai.rb
+- lib/boxcars/generation.rb
+- lib/boxcars/prompt.rb
+- lib/boxcars/ruby_repl.rb
+- lib/boxcars/version.rb
+homepage: https://github.com/BoxcarsAI/boxcars
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/BoxcarsAI/boxcars
+  source_code_uri: https://github.com/BoxcarsAI/boxcars
+  changelog_uri: https://github.com/BoxcarsAI/boxcars/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.32
+signing_key:
+specification_version: 4
+summary: Boxcars provide an API to connect together Boxcars and then conduct them.
+  Inspired by python langchain.
+test_files: []