activeai 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: deea25fb847c585d5722d3ca53c369dd0af13864615fdc82013db1f70fa17e8e
-  data.tar.gz: 0c6612d1caaff492e04862947a7d3a1b3aeebb747068be7e0a4dc18b8c6faaf0
+  metadata.gz: a327faafb1ed168dfbbfce2c3f5beed3b6090c8ed5c95d24913d988e39227143
+  data.tar.gz: f3bb5b04eabc7838193f099e649f5dbe48ae3f151537b28469d1b6738848fb00
 SHA512:
-  metadata.gz: d540bd977bddbb80203bd79855bc62938981c073a0b787d7d8f0fb51db7ec20496e32b1f094b0626dce6d260efab368749aa11f69d25feefec36c09b9c5f4885
-  data.tar.gz: 4de73f333f06560b445b453ec47520f759fd6c43da4fd56f8d03ed16b330c5ece5ff9b0d307ea6b9c4d0180061f24c2e3118545916a4c7c9c9bb22e36c09d4e4
+  metadata.gz: c3530fdce13cab64414b9b921a49672cd2dae8c170e6f50af5486fe30b33055403a1ef37b6a8c2e3172178ff61ac8c4d26292a3708877111d329cecb0dc59a72
+  data.tar.gz: 9dc7550488f4dab988b11719a065f0e7fd0c17afa2712c6670b97e8300969fb9d218ac47e2939d295134e5313594f00f45e8838c34c5d9fb178237e3292adcce

data/README.md

@@ -39,6 +39,12 @@ puts result
 #=> 'tomatoes, jam'
 ```
 
+### Behavior: WriteFunctionCall
+
+#### TODO
+
+This lets you use `code-davinci-002` or `code-cushman-001` to run logic. The router uses this internally. Supply a list of example pairs that are a "description" and "code", and then you can complete another one.
+
 ### TODO: with other patterns
 
 ### TODO: auto-detected behavior pattern from config
@@ -47,29 +53,34 @@ puts result
 
 **This is the fun part!**
 
+Suppose you have the following files:
+
 ### config/routes/bank.yml
 
 ```
 instruction:
-  For a given Match request, choose where to send it via the "To" field and choose the params that fit best.
-  If nothing matches, the "To" field should be None.
+  For a given Match request, choose where to send it via the "Route" field and choose the params that fit best.
+  If nothing matches, the "Route" field should be None.
 examples:
   - Match: Check the weather
-    To: none
+    Route: none
   - Match: Send R100 to Jomiro
-    To: bank#transfer_money
+    Route: bank#transfer_money
     Params: { beneficiaryId: 12345, amount: 100.0 }
   - Match: Pay Mom R245 for groceries
-    To: bank#transfer_money
+    Route: bank#transfer_money
     Params: { beneficiaryId: 98765, amount: 245.0, reference: "Groceries <3" }
   - Match: What's my bank balance?
-    To: bank#check_balance
+    Route: bank#check_balance
 ```
 
 ### controllers/bank_controller.rb
 
 ```
 class BankController < ActiveAI::Controller
+  auto_load_routing # loads routing config from config/routes/bank.yml
+  load_routing(config) # alternatively, loads routing config from a hash
+
   def check_balance
     # Make an API request to GET bank.com/balance and return some useful data
   end
@@ -79,3 +90,50 @@ class BankController < ActiveAI::Controller
   end
 end
 ```
+
+### How to use it
+
+#### Running a controller directly
+
+Using the routing yml file and an LLM, the controller will turn any text request into an action to run, with parameters to supply, and then execute it.
+
+```ruby
+controller = BankController.new
+controller.call("Pay Mom R127 for groceries")
+# => responds with the result of an action that ran with params
+```
+
+#### Routing an unknown request with multiple controllers
+
+It's possible to instantiate an `ActiveAI::Router`, load up the examples from multiple controllers, and then have it handle many types of requests. It does this in a similar way to how the controller uses an LLM to map to action and params, but it concatenates all controller routing examples and strips out the parameter preparation step for efficiency, since the controller handles this.
+
+```ruby
+router = ActiveAI::Router.new
+
+# load all auto-detected routes:
+router.auto_load_routing(Rails.root.join('config','routes')) # loads all .yml files as controller examples
+
+# or, load config via path or manually from a config hash:
+router.add_controller_routing_from_path(Rails.root.join("config", "routes", "bank.yml"))
+slack_routing = YAML::load(File.read(Rails.root.join("config", "routes", "slack.yml"))
+router.add_controller_routing(slack_routing)
+```
+
+Once the routes are loaded, requests will be passed to a matched controller, if any matches. You can match and run requests like this:
+
+```ruby
+router.call("Send a Slack message saying 'Hey everyone!") # returns the successful action
+router.call("Transfer R5,000 to savings") # returns the successful action
+router.call("Visit grandma") # returns nil
+```
+
+Or if you just want to find the controller:
+
+```ruby
+router.find_controller("Transfer money out of savings")
+# => BankController
+```
+
+# Please help make this better!
+
+This is an experiment to push the boundaries of "AI as compute" and it would be awesome to have more eager explorers to play with!

data/SESSIONS.md

@@ -3,15 +3,21 @@
 ## What I did
 
 - Fix active_ai/controller.rb to reflect on the correct detected path name
-- Ran a full test with thinkspawn creating DALLE art - it's really cool!
-
-TODO
-
-- publish v0.1.1 that actually works!
+- Ran a full test with thinkspawn creating DALLE art and sending Slack messages - it's really cool!
+- Released v0.1.1!!
 
 ## What I learned
 
 - Gonna need a master router and make the sub-routers just about param prep
+- Curie doesn't do great with routing many controllers. I had to rename e.g. slack.notify to slack.send_message because that seemed to be Curie's default.. DaVinci works better but also some issues i think
+
+## What I could do next
+
+- add whisper as a neural network via replicate.com
+- add embeddings as a concept - not sure what/how yet
+- make better examples for routing, it's a bit iffy right now
+- add a better way in code to test controllers test cases etc.
+- test out if the code models work better than the text ones
 
 # 30 December 2022
 
@@ -20,7 +26,7 @@ TODO
 - Built a basic gem!
 - Added behaviors, specifically for structured trained examples
 - Added rails controllers and routers which use structured trained examples
-- Added a cool prototype conversation structure, and a cool idea on how to make operators ponder!
+- Added a cool prototype conversation/chat structure, and a cool idea on how to make operators ponder!
 
 ## What I learned
 
@@ -36,5 +42,4 @@ TODO
 - Publish v0.1.1
 - Update the configuration.rb mechanic a bit
 - Load up all OpenAI's examples as instances of one of a couple of behavior types
-- Build a chat behavior
 - Add session contexts to the router registration so it's flexible

data/lib/activeai/behavior/llm/conversation.rb

@@ -20,7 +20,7 @@ class ActiveAI::Behavior::LLM::Conversation < ActiveAI::Behavior::LLM
         # TODO use the label key they provide in the yml file
       end,
       "Conversation:\n" + @state['conversation']
-    ].join(SEPARATOR)
+    ].join(LINE_SEPARATOR)
   end
 
   def add(speaker, message)

data/lib/activeai/behavior/llm/follow_structured_examples.rb

@@ -15,12 +15,12 @@ class ActiveAI::Behavior::LLM::FollowStructuredExamples < ActiveAI::Behavior::LL
         example.map do |key, value|
           "#{key}: #{value}"
         end.join("\n")
-      end.join(SEPARATOR)
-    ].join(SEPARATOR)
+      end.join(LINE_SEPARATOR)
+    ].join(LINE_SEPARATOR)
   end
 
   def call(input={}, extract: []) # TODO cool splat stuff?
-    prompt = base_prompt + SEPARATOR
+    prompt = base_prompt + LINE_SEPARATOR
 
     prompt += input.map do |key, value|
       "#{key}: #{value}"

data/lib/activeai/behavior/llm/write_function_call.rb

@@ -0,0 +1,35 @@
+class ActiveAI::Behavior::LLM::WriteFunctionCall < ActiveAI::Behavior::LLM
+  def initialize(llm, state)
+    super(llm)
+    @state = state
+    # TODO raise errors if not expected thingies available in the config
+  end
+
+  def base_prompt
+    @state[:examples].map do |example|
+      [
+        "// #{example[:description]}",
+        example[:code]
+      ].join("\n")
+    end.join("\n\n") + "\n\n"
+  end
+
+  def call(comment)
+    prompt = base_prompt + "\n\n"
+    prompt += "//#{comment}\n"
+    complete_result = complete(prompt, stop: "\n")
+
+    # TODO stop \n works for the router but not for other stuff, later
+
+    completion = complete_result['choices'][0]['text']
+
+    matcher = /(.*)\((.*)\)/
+    matches = matcher.match(completion)
+
+    return {
+      text: completion.strip,
+      path: matches[1],
+      params: matches[2].presence && JSON.parse(matches[2])
+    }
+  end
+end

data/lib/activeai/behavior/llm.rb

@@ -7,7 +7,7 @@ class ActiveAI::Behavior::LLM < ActiveAI::Behavior::Base
     @llm.complete(prompt: prompt, stop: stop)
   end
 
-  SEPARATOR = "\n\n###\n\n"
+  LINE_SEPARATOR = "\n\n###\n\n"
 
   def extract_keys(completion, extract)
     matcher_string = extract.map{ |key| "#{key}:(.*)" }.join
@@ -25,5 +25,6 @@ class ActiveAI::Behavior::LLM < ActiveAI::Behavior::Base
 end
 
 require_relative "llm/conversation"
-require_relative "llm/unstructured"
 require_relative "llm/follow_structured_examples"
+require_relative "llm/unstructured"
+require_relative "llm/write_function_call"

data/lib/activeai/controller.rb

@@ -1,19 +1,59 @@
 class ActiveAI::Controller
-  # auto-loads a router from current file when inherited
-  class_attribute :router
 
-  def self.inherited(base)
-    # TODO I'm sure there's a proper way to do this but it works for now
-    routes_path = Rails.root.join('config', 'routes', base.to_s.underscore.gsub('_controller', '.yml'))
+  class_attribute :routing_behavior
+
+  def self.auto_load_routing
+    routes_path = Rails.root.join('config', 'routes', self.to_s.underscore.gsub('_controller', '.yml'))
     routes_config = YAML::load(File.read(routes_path))
-    # convert routes_config params into JSON?
-    router = ActiveAI::Router.new(routes_config, controller: base)
+    self.load_routing(routes_config)
+  end
+
+  def self.load_routing(routes_config)
+    @llm = ActiveAI::NeuralNetwork::GPT3.new(ActiveAI.config[:gpt3_token], model: 'code-davinci-002', temperature: 0.2)
+
+    examples = ActiveAI.route_examples_to_function_call_examples(routes_config['examples'])
+    self.routing_behavior = ActiveAI::Behavior::LLM::WriteFunctionCall.new(@llm, { examples: examples })
   end
 
   attr_accessor :params
 
-  def call(method_name, params)
+  def prepare_action(request)
+    # samples to parse:
+    #   plugins.slack.send_message({ \"channel\": \"#general\", \"text\": \"Hi\" })
+    #   unmatched()
+
+    function = self.class.routing_behavior.call(request)
+    *controller_path, action_name = function[:path].split(".")
+    controller_name = controller_path.join("/").presence
+
+    # TODO verify it's the right controller and the action name exists and it's not a reserved / internal thing
+
+    if controller_name.present?
+      return {
+        action: action_name,
+        params: function[:params]
+      }
+    else
+      return nil
+    end
+  end
+
+  def call(request)
+    mapped_request = prepare_action(request)
+    
+    if mapped_request
+      return run_action(mapped_request[:action], mapped_request[:params])
+    else
+      return nil
+    end
+  end
+
+  def run_action(action_name, params)
     @params = params
-    send(method_name)
+    response = send(action_name)
+    # handle response somehow, or do we just dump JSON back?
   end
+
+  # surely this is where the magic prep loading and unloading happens?
+  # i.e. the params deal with this
 end

data/lib/activeai/router.rb

@@ -1,74 +1,79 @@
 class ActiveAI::Router
-  INSTRUCTION_ALL = 'For a given Match request, choose where to send it via the "To" field. If nothing matches, the "To" field should be None.'
-  UNMATCHED_ALL = { 'Match' => 'Create a NASA space program', 'To' => 'None' }
-  INSTRUCTION_INSTANCE = 'For a given Match request, choose where to send it via the "To" field. Also choose the params that fit best. If nothing matches, the "To" field should be None.'
+  INSTRUCTION = 'For a given Match request, choose where to send it via the "Route" field. If nothing matches, the "Route" field should be None.'
+  UNMATCHED = { 'Match' => 'Create a NASA space program', 'Route' => 'None' }
 
-  # TODO could load a "session" or "context" for current user which handles router registration and stuff
-  # keeps it flexi for thinkspawn while not breaking things on this layer
-
-  class_attribute :routers
-  self.routers = []
+  def initialize
+    @routings = []
+    @llm = ActiveAI::NeuralNetwork::GPT3.new(ActiveAI.config[:gpt3_token], model: 'code-davinci-002', temperature: 0.2)
+  end
 
-  def self.application_router # TODO use this
-    new({
-      'instruction' => INSTRUCTION_ALL,
-      'examples' => routers.map do |router|
-        router.config['examples'].select do |example|
-          example['To'] != 'None'
-        end.map do |example|
-          example.slice('Match', 'To')
-        end << UNMATCHED_ALL
-      end.flatten
-    })
+  def add_controller_routing(routing)
+    @routings << routing
   end
 
-  def self.call_all(request)
-    # this shouldn't be the thing, something just decides if it matches or not
-    # we actually ask a master router where to go, and then ask the specific router what the params are
-    # -- might hit the token limit though, so why not just do each one? less web requests? but infinite scale
+  def add_controller_routing_from_path(path)
+    routing = YAML::load(File.read(path))
+    add_controller_routing(routing)
+  end
 
-    routers.each do |router|
-      response = router.call(request)
-      return response if response
+  def auto_load_routing(folder)
+    paths = Dir[folder.join("**", "*.yml")]
+    paths.each do |path|
+      add_controller_routing_from_path(path)
     end
   end
 
-  attr_accessor :config
+  def behavior
+    raw_examples = [UNMATCHED] + @routings.map do |routing|
+      routing['examples'].reject do |example|
+        example['Route'] == 'None'
+      end.map do |example|
+        example.slice('Match', 'Route')
+      end
+    end.flatten
+    examples = ActiveAI.route_examples_to_function_call_examples(raw_examples)
+
+    ActiveAI::Behavior::LLM::WriteFunctionCall.new(@llm, { examples: examples })
+  end
+
+  # def behavior_via_structured_examples
+  #   config = {
+  #     'instruction' => INSTRUCTION,
+  #     'examples' => [UNMATCHED] + @routings.map do |routing|
+  #       routing['examples'].reject do |example|
+  #         example['Route'] == 'None'
+  #       end.map do |example|
+  #         example.slice('Match', 'Route')
+  #       end
+  #     end.flatten
+  #   }
 
-  def initialize(config, controller: nil)
-    self.class.routers ||= []
+  #   ActiveAI::Behavior::LLM::FollowStructuredExamples.new(@llm, config)
+  # end
 
-    @config = config
-    @config['instruction'] ||= INSTRUCTION_INSTANCE
+  def find_controller(request)
+    function = behavior.call(request) # TODO maybe the behavior should return function and params as well. seems right
+    
+    *controller_path, action_name = function[:path].split(".")
+    controller_name = controller_path.join("/").presence
 
-    llm = ActiveAI::NeuralNetwork::GPT3.new(ActiveAI.config[:gpt3_token], model: 'text-curie-001')
-    @behavior = ActiveAI::Behavior::LLM::FollowStructuredExamples.new(llm, config)
+    # TODO verify it's the right controller and the action name exists and it's not a reserved / internal thing
 
-    if controller
-      self.class.routers << self
-      @controller = controller.new
+    if controller_name.blank? || action_name.blank? || action_name == 'unmatched'
+      return nil
+    else
+      return (controller_name + "_controller").classify.constantize
+      # TODO need protection (somewhere) from using controllers that aren't allowed
+      # maybe router has a whitelist? since we're taking user input
+      # idk problem for later not now
     end
   end
 
   def call(request)
-    routing = @behavior.call({ 'Request' => request }, extract: %W[To Params]) # TODO might not have params returned, will break?
-
-    controller_name, method_name = routing['To'].split('#')
-
-    if [controller_name, method_name].any?(&:blank?)
-      # unmatched
-      nil
+    if controller = find_controller(request)
+      controller.new.call(request)
     else
-      params = JSON.parse(routing['Params']) # TODO cast as JSON earlier? e.g. in config of the behavior?
-      puts "Calling #{method_name} with params: #{params}." # but only if matched
-
-      if @controller.is_a?(ActiveAI::Controller)
-        return @controller.call(method_name, params)
-      else
-        # it could be a dynamic user-generated script or something to call out to somehow
-        # TODO later later
-        return true
-      end
+      return nil
     end
   end
 end

data/lib/activeai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveAI
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/activeai.rb

@@ -16,5 +16,17 @@ module ActiveAI
     }
   end
 
+  def self.route_examples_to_function_call_examples(examples)
+    examples.map do |example|
+      function = example['Route'].gsub('/','.').gsub('#','.')
+      function = "unmatched" if function == "None"
+      
+      {
+        description: example['Match'],
+        code: "#{function}(#{example['Params']&.strip})"
+      }
+    end
+  end
+
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activeai
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - jeriko
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-31 00:00:00.000000000 Z
+date: 2023-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -64,6 +64,7 @@ files:
 - lib/activeai/behavior/llm/conversation.rb
 - lib/activeai/behavior/llm/follow_structured_examples.rb
 - lib/activeai/behavior/llm/unstructured.rb
+- lib/activeai/behavior/llm/write_function_call.rb
 - lib/activeai/configuration.rb
 - lib/activeai/controller.rb
 - lib/activeai/neural_network.rb