boxcars 0.7.1 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f737b8f862a6054265b74b7705a9779d301ceba197737c5b85aed4fc96733867
-  data.tar.gz: ffb896560aab128f2bcf685082755ce6400174d38b7d8b5294feea51808d0e17
+  metadata.gz: 32da67348d02e7e369d6b7ae465679220134c2abbfd7fbf8ff952bf51151e1bf
+  data.tar.gz: 23658aa847e993e68d5bfc71ba40a686b764478e8d21b8c313b4f8bf6a6023f0
 SHA512:
-  metadata.gz: 2f9afcd76b2efda7fc9f35f2ae02882256a03f935d8a94a10149daa10ad8180c5d91db34e11296310074a1ec9d5d4863a10e74ddc41b19cd9d250d2da64bdff2
-  data.tar.gz: 17860c296d8cb4a167e4e4bc58835b3bb9da867bb65e38b89cc08d884f88bf09707bc64b4a36195848d7ee995592c4f32ede29752744a7dee4135dd90338285f
+  metadata.gz: b4cf6bbc8b99d96fa3dc20bf15b07d3a04f6d8ceee9e7a224c67f5ba7ca114f7a58acf3d00b973ab2243b8d09c0d5b5959e90ec7dc67ed819443d140f63c7660
+  data.tar.gz: 11691020363325c0567e812dbde560290ec69f0d213aa585b71f76492ee09656f005f49661c32be8a96cf78435ee8ef8a66596ebf1896239a4cca9da7b592854

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    boxcars (0.7.1)
+    boxcars (0.7.3)
       anthropic (~> 0.3)
       google_search_results (~> 2.2)
       gpt4all (~> 0.0.5)
@@ -295,4 +295,4 @@ DEPENDENCIES
   webmock (~> 3.24.0)
 
 BUNDLED WITH
-   2.5.23
+   2.5.20

data/lib/boxcars/boxcar/json_engine_boxcar.rb

@@ -35,7 +35,7 @@ module Boxcars
             %<wanted_data>s
           }
       SYSPR
-      stock_prompt += "\n\nImportant:\n#{important}\n" if important.present?
+      stock_prompt += "\n\nImportant:\n#{important}\n" unless important.to_s.empty?
 
       sprompt = format(stock_prompt, wanted_data: wanted_data, data_description: data_description)
       ctemplate = [

data/lib/boxcars/boxcar.rb

@@ -166,7 +166,7 @@ module Boxcars
         output = call(inputs: inputs)
       rescue StandardError => e
         Boxcars.error "Error in #{name} boxcar#call: #{e}\nbt:#{e.backtrace[0..5].join("\n   ")}", :red
-        Boxcars.error("Response Body: #{e.response[:body]}", :red) if e.respond_to?(:response) && e.response.present?
+        Boxcars.error("Response Body: #{e.response[:body]}", :red) if e.respond_to?(:response) && !e.response.nil?
         raise e
       end
       validate_outputs(outputs: output.keys)

data/lib/boxcars/conversation.rb

@@ -95,7 +95,7 @@ module Boxcars
       raise KeyError, "Prompt format error: #{first_line}"
     end
 
-    def as_intelligence_conversation(inputs = nil)
+    def as_intelligence_conversation(inputs: nil)
       conversation = Intelligence::Conversation.new
       no_history.each do |ln|
         message = Intelligence::Message.new(ln[0])

data/lib/boxcars/conversation_prompt.rb

@@ -56,7 +56,7 @@ module Boxcars
     # @param inputs [Hash] The inputs to use for the prompt
     # @return [Intelligence::Conversation] The converted conversation
     def as_intelligence_conversation(inputs: nil)
-      conversation.to_intelligence_conversation(inputs: inputs)
+      conversation.as_intelligence_conversation(inputs: inputs)
     end
   end
 end

data/lib/boxcars/engine/cerebras.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
-require "intelligence"
 module Boxcars
   # A engine that uses Cerebras's API
-  class Cerebras < Engine
-    attr_reader :prompts, :cerebras_params, :model_kwargs, :batch_size
-
+  class Cerebras < IntelligenceBase
     # The default parameters to use when asking the engine
     DEFAULT_PARAMS = {
       model: "llama-3.3-70b",
@@ -18,92 +15,22 @@ module Boxcars
     DEFAULT_DESCRIPTION = "useful for when you need to use Cerebras to process complex content. " \
                           "Supports text, images, and other content types"
 
+    # A Cerebras 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.
+    # @param prompts [Array<Prompt>] The prompts to use for the Engine.
+    # @param batch_size [Integer] The number of prompts to send to the Engine at a time.
+    # @param kwargs [Hash] Additional parameters to pass to the Engine.
     def initialize(name: DEFAULT_NAME, description: DEFAULT_DESCRIPTION, prompts: [], batch_size: 20, **kwargs)
-      @cerebras_params = DEFAULT_PARAMS.merge(kwargs)
-      @prompts = prompts
-      @batch_size = batch_size
-      super(description: description, name: name)
-    end
-
-    # Get the Cerebras API client
-    def self.adapter(params:, api_key: nil)
-      api_key = Boxcars.configuration.cerebras_api_key(**params) if api_key.nil?
-      raise ArgumentError, "Cerebras API key not configured" unless api_key
-
-      Intelligence::Adapter[:cerebras].new(
-        { key: api_key, chat_options: params }
-      )
-    end
-
-    # Process different content types
-    def process_content(content)
-      case content
-      when String
-        { type: "text", text: content }
-      when Hash
-        validate_content(content)
-      when Array
-        content.map { |c| process_content(c) }
-      else
-        raise ArgumentError, "Unsupported content type: #{content.class}"
-      end
+      super(provider: :cerebras, description: description, name: name, prompts: prompts, batch_size: batch_size, **kwargs)
     end
 
-    # Validate content structure
-    def validate_content(content)
-      raise ArgumentError, "Content must have type and text fields" unless content[:type] && content[:text]
-
-      content
-    end
-
-    # Get an answer from the engine
-    def client(prompt:, inputs: {}, api_key: nil, **kwargs)
-      params = cerebras_params.merge(kwargs)
-      adapter = Cerebras.adapter(api_key: api_key, params: params)
-      raise Error, "OpenAI: No response from API" unless adapter
-
-      convo = prompt.as_intelligence_conversation(inputs: inputs)
-
-      # Add content processing
-      Boxcars.debug("Sending to Cerebras:\n#{convo}", :cyan) if Boxcars.configuration.log_prompts
-
-      # Make API call
-      request = Intelligence::ChatRequest.new(adapter: adapter)
-      response = request.chat(convo)
-      check_response(response)
-    rescue StandardError => e
-      Boxcars.error("Cerebras Error: #{e.message}", :red)
-      raise
-    end
-
-    # Run the engine with a question
-    def run(question, **kwargs)
-      prompt = Prompt.new(template: question)
-      response = client(prompt: prompt, **kwargs)
-      extract_answer(response)
-    end
-
-    private
-
-    def extract_answer(response)
-      # Handle different response formats
-      if response["choices"]
-        response["choices"].map { |c| c.dig("message", "content") || c["text"] }.join("\n").strip
-      else
-        response["output"] || response.to_s
-      end
-    end
-
-    def check_response(response)
-      return response.result.text if response.success?
-
-      raise KeyError, "CEREBRAS_API_KEY not valid" if response&.reason_phrase == "Unauthorized"
-
-      raise ValueError, "Cerebras error: #{response&.reason_phrase&.present? ? response.reason_phrase : response}"
+    def default_model_params
+      DEFAULT_PARAMS
     end
 
-    def conversation_model?(_model)
-      true
+    def lookup_provider_api_key(params:)
+      Boxcars.configuration.cerebras_api_key(**params)
     end
   end
 end

data/lib/boxcars/engine/google.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Boxcars
+  # A engine that uses Google's API
+  class Google < IntelligenceBase
+    # The default parameters to use when asking the engine
+    DEFAULT_PARAMS = {
+      model: "gemini-1.5-flash-latest",
+      temperature: 0.1
+    }.freeze
+
+    # the default name of the engine
+    DEFAULT_NAME = "Google Vertex AI engine"
+    # the default description of the engine
+    DEFAULT_DESCRIPTION = "useful for when you need to use Google Vertex AI to process complex content. " \
+                          "Supports text, images, and other content types"
+
+    # A Google 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.
+    # @param prompts [Array<Prompt>] The prompts to use for the Engine.
+    # @param batch_size [Integer] The number of prompts to send to the Engine at a time.
+    # @param kwargs [Hash] Additional parameters to pass to the Engine.
+    def initialize(name: DEFAULT_NAME, description: DEFAULT_DESCRIPTION, prompts: [], batch_size: 20, **kwargs)
+      super(provider: :google, description: description, name: name, prompts: prompts, batch_size: batch_size, **kwargs)
+    end
+
+    def default_model_params
+      DEFAULT_PARAMS
+    end
+
+    def lookup_provider_api_key(params:)
+      Boxcars.configuration.gemini_api_key(**params)
+    end
+  end
+end

data/lib/boxcars/engine/intelligence_base.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'intelligence'
+
+module Boxcars
+  # A Base class for all Intelligence Engines
+  class IntelligenceBase < Engine
+    attr_reader :provider, :all_params
+
+    # The base Intelligence Engine is used by other engines to generate output from prompts
+    # @param provider [String] The provider of the Engine implemented by the Intelligence gem.
+    # @param name [String] The name of the Engine. Defaults to classname.
+    # @param description [String] A description of the Engine.
+    # @param prompts [Array<Prompt>] The prompts to use for the Engine.
+    # @param batch_size [Integer] The number of prompts to send to the Engine at a time.
+    # @param kwargs [Hash] Additional parameters to pass to the Engine.
+    def initialize(provider:, description:, name:, prompts: [], batch_size: 20, **kwargs)
+      @provider = provider
+      @all_params = default_model_params.merge(kwargs)
+      super(description: description, name: name, prompts: prompts, batch_size: batch_size)
+    end
+
+    # can be overridden by provider subclass
+    def default_model_params
+      {}
+    end
+
+    def lookup_provider_api_key(params:)
+      raise NotImplementedError, "lookup_provider_api_key method must be implemented by subclass"
+    end
+
+    def adapter(params:, api_key:)
+      Intelligence::Adapter[provider].new(
+        { key: api_key, chat_options: params }
+      )
+    end
+
+    # Process different content types
+    def process_content(content)
+      case content
+      when String
+        { type: "text", text: content }
+      when Hash
+        validate_content(content)
+      when Array
+        content.map { |c| process_content(c) }
+      else
+        raise ArgumentError, "Unsupported content type: #{content.class}"
+      end
+    end
+
+    # Validate content structure
+    def validate_content(content)
+      raise ArgumentError, "Content must have type and text fields" unless content[:type] && content[:text]
+
+      content
+    end
+
+    # Get an answer from the engine
+    def client(prompt:, inputs: {}, api_key: nil, **kwargs)
+      params = all_params.merge(kwargs)
+      api_key ||= lookup_provider_api_key(params: params)
+      raise Error, "No API key found for #{provider}" unless api_key
+
+      adapter = adapter(api_key: api_key, params: params)
+      convo = prompt.as_intelligence_conversation(inputs: inputs)
+      request = Intelligence::ChatRequest.new(adapter: adapter)
+      response = request.chat(convo)
+      return JSON.parse(response.body) if response.success?
+
+      raise Error, (response&.reason_phrase || "No response from API #{provider}")
+    rescue StandardError => e
+      Boxcars.error("#{provider} Error: #{e.message}", :red)
+      raise
+    end
+
+    # Run the engine with a question
+    def run(question, **kwargs)
+      prompt = Prompt.new(template: question)
+      response = client(prompt: prompt, **kwargs)
+      extract_answer(response)
+    end
+
+    private
+
+    def extract_answer(response)
+      # Handle different response formats
+      if response["choices"]
+        response["choices"].map { |c| c.dig("message", "content") || c["text"] }.join("\n").strip
+      elsif response["candidates"]
+        response["candidates"].map { |c| c.dig("content", "parts", 0, "text") }.join("\n").strip
+      else
+        response["output"] || response.to_s
+      end
+    end
+
+    def check_response(response)
+      return if response.is_a?(Hash) && response.key?("choices")
+
+      raise Error, "Invalid response from #{provider}: #{response}"
+    end
+  end
+end

data/lib/boxcars/engine.rb

@@ -3,12 +3,18 @@
 module Boxcars
   # @abstract
   class Engine
+    attr_reader :prompts, :batch_size
+
     # 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)
+    # @param prompts [Array<Prompt>] The prompts to use for the Engine.
+    # @param batch_size [Integer] The number of prompts to send to the Engine at a time.
+    def initialize(description: 'Engine', name: nil, prompts: [], batch_size: 20)
       @name = name || self.class.name
       @description = description
+      @prompts = prompts
+      @batch_size = batch_size
     end
 
     # Get an answer from the Engine.
@@ -37,7 +43,7 @@ module Boxcars
       end
     end
 
-    # Call out to OpenAI's endpoint with k unique prompts.
+    # Call out to LLM's endpoint with k unique prompts.
     # @param prompts [Array<String>] The prompts to pass into the model.
     # @param inputs [Array<String>] The inputs to subsitite into the prompt.
     # @param stop [Array<String>] Optional list of stop words to use when generating.
@@ -80,4 +86,6 @@ require "boxcars/engine/openai"
 require "boxcars/engine/perplexityai"
 require "boxcars/engine/gpt4all_eng"
 require "boxcars/engine/gemini_ai"
+require "boxcars/engine/intelligence_base"
 require "boxcars/engine/cerebras"
+require "boxcars/engine/google"

data/lib/boxcars/version.rb

@@ -2,5 +2,5 @@
 
 module Boxcars
   # The current version of the gem.
-  VERSION = "0.7.1"
+  VERSION = "0.7.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boxcars
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.3
 platform: ruby
 authors:
 - Francis Sullivan
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-17 00:00:00.000000000 Z
+date: 2025-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: anthropic
@@ -169,10 +169,10 @@ files:
 - lib/boxcars/engine/cohere.rb
 - lib/boxcars/engine/engine_result.rb
 - lib/boxcars/engine/gemini_ai.rb
+- lib/boxcars/engine/google.rb
 - lib/boxcars/engine/gpt4all_eng.rb
 - lib/boxcars/engine/groq.rb
-- lib/boxcars/engine/intelligence.rb
-- lib/boxcars/engine/intelligence/client.rb
+- lib/boxcars/engine/intelligence_base.rb
 - lib/boxcars/engine/ollama.rb
 - lib/boxcars/engine/openai.rb
 - lib/boxcars/engine/perplexityai.rb
@@ -206,7 +206,6 @@ files:
 - lib/boxcars/vector_store/split_text.rb
 - lib/boxcars/version.rb
 - lib/boxcars/x_node.rb
-- perplexity_example.rb
 - run.json
 homepage: https://github.com/BoxcarsAI/boxcars
 licenses:
@@ -231,7 +230,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: Boxcars is a gem that enables you to create new systems with AI composability.

data/lib/boxcars/engine/intelligence/client.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module Boxcars
-  class Intelligence
-    # Client for interacting with the Intelligence API
-    class Client
-      BASE_URL = "https://api.intelligence.com/v1"
-      DEFAULT_TIMEOUT = 120
-
-      def initialize(api_key:)
-        @api_key = api_key
-        @connection = Faraday.new(
-          url: BASE_URL,
-          headers: {
-            "Content-Type" => "application/json",
-            "Authorization" => "Bearer #{@api_key}"
-          },
-          request: {
-            timeout: DEFAULT_TIMEOUT
-          }
-        )
-      end
-
-      # Generate a response from the Intelligence API
-      def generate(parameters:)
-        response = @connection.post("/generate") do |req|
-          req.body = parameters.to_json
-        end
-
-        handle_response(response)
-      end
-
-      # Stream a response from the Intelligence API
-      def stream(parameters:, &block)
-        @connection.post("/generate") do |req|
-          req.options.on_data = block
-          req.headers["Accept"] = "text/event-stream"
-          req.body = parameters.to_json
-        end
-      end
-
-      private
-
-      def handle_response(response)
-        case response.status
-        when 200
-          JSON.parse(response.body)
-        when 401
-          raise KeyError, "Invalid API key"
-        when 429
-          raise ValueError, "Rate limit exceeded"
-        when 400..499
-          raise ArgumentError, "Bad request: #{response.body}"
-        when 500..599
-          raise Error, "Intelligence API server error"
-        else
-          raise Error, "Unexpected response: #{response.status}"
-        end
-      end
-    end
-  end
-end

data/lib/boxcars/engine/intelligence.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-module Boxcars
-  # A engine that uses Intelligence's API
-  class Intelligence < Engine
-    attr_reader :prompts, :intelligence_params, :model_kwargs, :batch_size
-
-    # The default parameters to use when asking the engine
-    DEFAULT_PARAMS = {
-      model: "intelligence-1.0",
-      temperature: 0.1
-    }.freeze
-
-    # the default name of the engine
-    DEFAULT_NAME = "Intelligence engine"
-    # the default description of the engine
-    DEFAULT_DESCRIPTION = "useful for when you need to use Intelligence to process complex content. " \
-                          "Supports text, images, and other content types"
-
-    def initialize(name: DEFAULT_NAME, description: DEFAULT_DESCRIPTION, prompts: [], batch_size: 20, **kwargs)
-      begin
-        require 'intelligence'
-      rescue LoadError => _e
-        raise LoadError,
-              "The intelligence gem is required. Please add 'gem \"intelligence\"' to your Gemfile and run bundle install"
-      end
-
-      @intelligence_params = DEFAULT_PARAMS.merge(kwargs)
-      @prompts = prompts
-      @batch_size = batch_size
-      super(description: description, name: name)
-    end
-
-    # Get the Intelligence API client
-    def self.intelligence_client(api_key: nil)
-      api_key ||= Boxcars.configuration.intelligence_api_key
-      raise ArgumentError, "Intelligence API key not configured" unless api_key
-
-      Client.new(api_key: api_key)
-    end
-
-    # Stream responses from the Intelligence API
-    def stream(prompt:, inputs: {}, api_key: nil, &block)
-      client = Intelligence.intelligence_client(api_key: api_key)
-      params = intelligence_params.merge(stream: true)
-
-      processed_prompt = if conversation_model?(params[:model])
-                           prompt.as_messages(inputs)
-                         else
-                           { prompt: prompt.as_prompt(inputs: inputs) }
-                         end
-
-      processed_prompt[:content] = process_content(processed_prompt[:content]) if processed_prompt[:content]
-
-      client.stream(parameters: params.merge(processed_prompt), &block)
-    end
-
-    # Process different content types
-    def process_content(content)
-      case content
-      when String
-        { type: "text", text: content }
-      when Hash
-        validate_content(content)
-      when Array
-        content.map { |c| process_content(c) }
-      else
-        raise ArgumentError, "Unsupported content type: #{content.class}"
-      end
-    end
-
-    # Validate content structure
-    def validate_content(content)
-      raise ArgumentError, "Content must have type and text fields" unless content[:type] && content[:text]
-
-      content
-    end
-
-    # Get an answer from the engine
-    def client(prompt:, inputs: {}, api_key: nil, **kwargs)
-      client = Intelligence.intelligence_client(api_key: api_key)
-      params = intelligence_params.merge(kwargs)
-
-      processed_prompt = if conversation_model?(params[:model])
-                           prompt.as_messages(inputs)
-                         else
-                           { prompt: prompt.as_prompt(inputs: inputs) }
-                         end
-
-      # Add content processing
-      processed_prompt[:content] = process_content(processed_prompt[:content]) if processed_prompt[:content]
-
-      Boxcars.debug("Sending to Intelligence:\n#{processed_prompt}", :cyan) if Boxcars.configuration.log_prompts
-
-      # Make API call
-      response = client.generate(parameters: params.merge(processed_prompt))
-      check_response(response)
-      response
-    rescue StandardError => e
-      Boxcars.error("Intelligence Error: #{e.message}", :red)
-      raise
-    end
-
-    # Run the engine with a question
-    def run(question, **kwargs)
-      prompt = Prompt.new(template: question)
-      response = client(prompt: prompt, **kwargs)
-      extract_answer(response)
-    end
-
-    private
-
-    def extract_answer(response)
-      # Handle different response formats
-      if response["choices"]
-        response["choices"].map { |c| c.dig("message", "content") || c["text"] }.join("\n").strip
-      else
-        response["output"] || response.to_s
-      end
-    end
-
-    def check_response(response)
-      if response["error"]
-        code = response.dig("error", "code")
-        msg = response.dig("error", "message") || "unknown error"
-        raise KeyError, "INTELLIGENCE_API_KEY not valid" if code == "invalid_api_key"
-
-        raise ValueError, "Intelligence error: #{msg}"
-      end
-
-      # Validate response structure
-      return if response["choices"] || response["output"]
-
-      raise Error, "Invalid response format from Intelligence API"
-    end
-
-    def conversation_model?(_model)
-      true
-    end
-  end
-end

data/perplexity_example.rb

@@ -1,28 +0,0 @@
-require "debug"
-require "dotenv/load"
-require "boxcars"
-
-# Boxcars.configuration.logger = Logger.new($stdout)
-
-eng = Boxcars::Perplexityai.new
-# eng = Boxcars::Openai.new(model: "gpt-4")
-ctemplate = [
-  Boxcars::Boxcar.syst("The user will type in a city name. Your job is to evaluate if the given city is a good place to live. " \
-                       "Build a comprehensive report about livability, weather, cost of living, crime rate, drivability, " \
-                       "walkability, and bike ability, and direct flights. In the final answer, for the first paragraph, " \
-                       "summarize the pros and cons of living in the city followed by the background information and links " \
-                       "for the research. Finalize your answer with an overall grade from A to F on the city."),
-  Boxcars::Boxcar.user("%<input>s")
-]
-conv = Boxcars::Conversation.new(lines: ctemplate)
-
-conversation_prompt = Boxcars::ConversationPrompt.new(conversation: conv, input_variables: [:input], other_inputs: [],
-                                                      output_variables: [:answer])
-
-boxcar = Boxcars::EngineBoxcar.new(engine: eng, name: "City Helper", prompt: conversation_prompt,
-                                   description: "Evaluate if a city is a good place to live.")
-data = boxcar.run(ARGV.fetch(0, "San Francisco"))
-# train = Boxcars.train.new(boxcars: [boxcar])
-# data = train.run()
-# debugger
-puts data