activeai 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 364516f172adcee466de83976b85b58e1b261b3f3f32367c09e4663119b9e165
-  data.tar.gz: e187d3303baceae837ed6671b797315648301bacf96f283caa840d883c15d0f8
+  metadata.gz: d5a985f1783335da05fa3165fbe352823a431d206c2586a334eff561874e88d2
+  data.tar.gz: bce08aa0e01e59e780ad8a47fd632e10567ae7c25dd8d88b295f61344d4a044c
 SHA512:
-  metadata.gz: 86f81a968aa3955afca6f92f4f671047969180ccba3cb93e5da3eb77820aaf292c2245bc157f2614718aa4203fb4ad0797c7c2dbb86942058a96ff94af238892
-  data.tar.gz: 51579d5f47efb0bbbd97be0f71d1ac51d997e30c659246c1f58f64224763cee55144098ee5f69eb18ea28aaf6288bd9cca74dc7d3c5a805b801bea277b7cf9d0
+  metadata.gz: db6b75600a2cf40c9b872c62a64316ffd36c69bd53856b3b05aed9865332450ed54c4b16690c7225ec313fb86d1634a6baade87cec4ab11464e0f9b4fb48be09
+  data.tar.gz: 383a17006039e02b64507bba0c95648bef990a17ce7f2ad676ab21fd0505f62a9eada8c5484e7a170215200a770d58e27c924e1a00be397f382d4c4364f39d59

data/Gemfile.lock

@@ -0,0 +1,75 @@
+PATH
+  remote: .
+  specs:
+    activeai (0.1.0)
+      faraday
+      true
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    diff-lcs (1.5.0)
+    faraday (2.7.2)
+      faraday-net_http (>= 2.0, < 3.1)
+      ruby2_keywords (>= 0.0.4)
+    faraday-net_http (3.0.2)
+    ffi (1.15.5)
+    json (2.6.3)
+    parallel (1.22.1)
+    parser (3.1.3.0)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    rb-fsevent (0.11.2)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
+    regexp_parser (2.6.1)
+    rexml (3.2.5)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.0)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    rubocop (1.41.1)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.1.2.1)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.23.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.24.1)
+      parser (>= 3.1.1.0)
+    ruby-progressbar (1.11.0)
+    ruby2_keywords (0.0.5)
+    sass (3.7.4)
+      sass-listen (~> 4.0.0)
+    sass-listen (4.0.0)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+    true (2.2.2)
+      sass (~> 3.4)
+    unicode-display_width (2.3.0)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  activeai!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rubocop (~> 1.21)
+
+BUNDLED WITH
+   2.3.20

data/README.md

@@ -2,6 +2,132 @@
 
 ## AI AS COMPUTE
 
-Artificial Intelligence adapters, the Rails way.
+Artificial Intelligence the Rails way.
 
-Supported by the gamebreakers community. https://gamebreakers.org
+Supported by [gamebreakers community](https://gamebreakers.org) - AI is for everyone <3
+
+# Usage
+
+## L0: Interacting directly with neural networks
+
+### GPT3
+
+```
+gpt3 = ActiveAI::NeuralNetwork::GPT3.new(ENV['OPEN_AI_TOKEN'])
+prompt = "Never gonna give you up, never gonna"
+puts gpt3.complete(prompt: prompt)['choices'].first['text']
+#=> 'let you down, never gonna run around and hurt you.'
+```
+
+### TODO: others
+
+## L1: Using behavior patterns to interact with neural networks
+
+### With structured examples
+
+```
+llm = ActiveAI::NeuralNetwork::GPT3.new(ENV['OPEN_AI_TOKEN'], model: 'text-curie-001')
+behavior = ActiveAI::Behavior::LLM::FollowStructuredExamples.new(llm, {
+  instruction: 'Write a comma-separated list of nouns in the following sentences:',
+  examples: [
+    { sentence: 'I have some veggie burgers in the freezer!', nouns: 'burgers, freezer' }
+    # a couple of examples improves performance!
+  ]
+})
+result = behavior.call({ sentence: 'My tomatoes are in bloom this summer, time for jam!' }, extract: %W[nouns])
+puts result
+#=> 'tomatoes, jam'
+```
+
+### TODO: with other patterns
+
+### TODO: auto-detected behavior pattern from config
+
+## L2: Rails magic for neural networks
+
+**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 "Route" field and choose the params that fit best.
+  If nothing matches, the "Route" field should be None.
+examples:
+  - Match: Check the weather
+    Route: none
+  - Match: Send R100 to Jomiro
+    Route: bank#transfer_money
+    Params: { beneficiaryId: 12345, amount: 100.0 }
+  - Match: Pay Mom R245 for groceries
+    Route: bank#transfer_money
+    Params: { beneficiaryId: 98765, amount: 245.0, reference: "Groceries <3" }
+  - Match: What's my bank 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
+
+  def transfer_money
+    # Make an API request to POST bank.com/transfer with params and return some useful data
+  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

@@ -0,0 +1,45 @@
+# 31 December 2022
+
+## 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 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
+
+## What I did
+
+- 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/chat structure, and a cool idea on how to make operators ponder!
+
+## What I learned
+
+- I need to learn more about modules, classes and gem structuring
+- Rails Engines is going to be a thing, probably, maybe
+- ActiveAI is a boring name. How about something that's more expansive, welcoming, inclusive, social?
+
+## What I could do next
+
+- Run a real example via thinkspawn and get it all working
+- Make active_ai/behavior.rb#from_config with a sensible default behavior and test a few others
+- Make the code work like the readme says it does for rails stuff (controller naming and folder structure etc.) - might need a Railtie?
+- 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
+- Add session contexts to the router registration so it's flexible

data/activeai.gemspec

@@ -30,9 +30,6 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
-
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.add_dependency 'faraday'
+  spec.add_dependency gem 'faraday-multipart'  
 end

data/lib/activeai/behavior/base.rb

@@ -0,0 +1,4 @@
+class ActiveAI::Behavior::Base
+end
+
+require_relative "llm"

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

@@ -0,0 +1,41 @@
+class ActiveAI::Behavior::LLM::Conversation < ActiveAI::Behavior::LLM
+  # i need alerts if this stuff gets caught in a loop! like pondering->noticing and never stopping or something
+
+  def initialize(llm, state)
+    super(llm)
+    @state = state
+    # TODO raise errors if not expected thingies available in the config
+    @state['conversation'] ||= ""
+  end
+
+  def history
+    @state['conversation']
+  end
+
+  def prompt
+    [
+      @state['instruction'],
+      @state['examples'].map do |example|
+        "Example Conversation:\n" + example['conversation']
+        # TODO use the label key they provide in the yml file
+      end,
+      "Conversation:\n" + @state['conversation']
+    ].join(SEPARATOR)
+  end
+
+  def add(speaker, message)
+    comms = "#{speaker}: #{message.strip}"
+    @state['conversation'] += comms + "\n"
+  end
+
+  def get_reply(prefix: nil)
+    @state['conversation'] += prefix if prefix
+
+    complete_result = complete(prompt, stop: "\n")
+    completion = complete_result['choices'][0]['text']
+
+    @state['conversation'] += completion + "\n"
+
+    completion
+  end
+end

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

@@ -0,0 +1,34 @@
+class ActiveAI::Behavior::LLM::FollowStructuredExamples < ActiveAI::Behavior::LLM
+  # state is an instruction, and a list of examples with key/value pairs
+  # would be nice to do casting, but not now i dont think..
+
+  def initialize(llm, state)
+    super(llm)
+    @state = state
+    # TODO raise errors if not expected thingies available in the config
+  end
+
+  def base_prompt
+    [
+      @state['instruction'],
+      @state['examples'].map do |example|
+        example.map do |key, value|
+          "#{key}: #{value}"
+        end.join("\n")
+      end.join(SEPARATOR)
+    ].join(SEPARATOR)
+  end
+
+  def call(input={}, extract: []) # TODO cool splat stuff?
+    prompt = base_prompt + SEPARATOR
+
+    prompt += input.map do |key, value|
+      "#{key}: #{value}"
+    end.join("\n")
+
+    complete_result = complete(prompt)
+    completion = complete_result['choices'][0]['text']
+
+    return extract_keys(completion, extract)
+  end
+end

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

@@ -0,0 +1,3 @@
+class ActiveAI::Behavior::LLM::Unstructured < ActiveAI::Behavior::LLM
+  #  just takes a text blob as configuration
+end

data/lib/activeai/behavior/llm.rb

@@ -0,0 +1,29 @@
+class ActiveAI::Behavior::LLM < ActiveAI::Behavior::Base
+  def initialize(llm)
+    @llm = llm
+  end
+  
+  def complete(prompt, stop: nil)
+    @llm.complete(prompt: prompt, stop: stop)
+  end
+
+  SEPARATOR = "\n\n###\n\n"
+
+  def extract_keys(completion, extract)
+    matcher_string = extract.map{ |key| "#{key}:(.*)" }.join
+    matches = completion.match(/#{matcher_string}/m)
+
+    if matches
+      matches[1..-1].map.with_index do |value, index|
+        # TODO this seems hacky, gotta be a better way to extract?
+        [extract[index], value.strip]
+      end.to_h
+    else
+      nil
+    end
+  end
+end
+
+require_relative "llm/conversation"
+require_relative "llm/unstructured"
+require_relative "llm/follow_structured_examples"

data/lib/activeai/behavior.rb

@@ -0,0 +1,9 @@
+class ActiveAI::Behavior
+  def self.from_config(config)
+    # TODO detect and load the right pattern
+    # right now it's just "structuredexamples"
+    # this is just syntactic sugar, it's fine for now until you _need_ it
+  end
+end
+
+require_relative "behavior/base"

data/lib/activeai/configuration.rb

@@ -0,0 +1,7 @@
+class ActiveAI::Configuration
+
+
+  def after_run
+    # can be specified to do stuff
+  end
+end

data/lib/activeai/controller.rb

@@ -0,0 +1,46 @@
+class ActiveAI::Controller
+
+  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))
+    self.load_routing(routes_config)
+  end
+
+  def self.load_routing(routes_config)
+    @llm = ActiveAI::NeuralNetwork::GPT3.new(ActiveAI.config[:gpt3_token], model: 'text-curie-001', temperature: 0.2)
+    self.routing_behavior = ActiveAI::Behavior::LLM::FollowStructuredExamples.new(@llm, routes_config)
+  end
+
+  attr_accessor :params
+
+  def prepare_action(request)
+    routing = self.class.routing_behavior.call({ 'Request' => request }, extract: %W[Route Params])
+    controller_name, action_name = routing['Route'].split('#')
+    # TODO verify it's the right controller and the action name exists and it's not a reserved / internal thing
+    return {
+      action: action_name,
+      params: JSON.parse(routing['Params']) # TODO cast as JSON earlier? e.g. in config of the behavior? 
+    }
+  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
+    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/neural_network/gpt3.rb

@@ -0,0 +1,48 @@
+require 'faraday'
+require 'faraday/net_http'
+require 'faraday/multipart'
+Faraday.default_adapter = :net_http
+
+class ActiveAI::NeuralNetwork::GPT3 < ActiveAI::NeuralNetwork
+
+  DEFAULTS = {
+    model: 'text-davinci-003',
+    temperature: 0.7,
+    max_tokens: 1000
+  }
+
+  def initialize(token, uuid: 'system', max_tokens: DEFAULTS[:max_tokens], temperature: DEFAULTS[:temperature], model: DEFAULTS[:model])
+    @token = token
+    @uuid = uuid
+    @max_tokens = max_tokens
+    @temperature = temperature
+    @model = model
+  end
+
+  def json_connection
+    @json_connection ||= Faraday.new(
+      url: 'https://api.openai.com',
+      headers: { 'Authorization' => "Bearer #{@token}" }
+    ) do |f|
+      f.request :json
+      f.response :json
+    end
+  end
+
+  def post(path, params={})
+    response = json_connection.post(path, params.merge({ user: @uuid }))
+    response.body
+  end
+
+  def complete(prompt:, stop: nil, suffix: nil) # TODO move the other stuff besides prompt out?
+    post("v1/completions", {
+      model: @model,
+      prompt: prompt,
+      suffix: suffix, # NOTE: doesn't work for fine-tuned models
+      stop: stop,
+      max_tokens: @max_tokens,
+      temperature: @temperature,
+      user: @uuid
+    })
+  end
+end

data/lib/activeai/neural_network.rb

@@ -0,0 +1,4 @@
+class ActiveAI::NeuralNetwork
+end
+
+require_relative "neural_network/gpt3"

data/lib/activeai/router.rb

@@ -0,0 +1,63 @@
+class ActiveAI::Router
+  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' }
+
+  def initialize
+    @routings = []
+    @llm = ActiveAI::NeuralNetwork::GPT3.new(ActiveAI.config[:gpt3_token], model: 'text-curie-001', temperature: 0.2)
+  end
+
+  def add_controller_routing(routing)
+    @routings << routing
+  end
+
+  def add_controller_routing_from_path(path)
+    routing = YAML::load(File.read(path))
+    add_controller_routing(routing)
+  end
+
+  def auto_load_routing(folder)
+    paths = Dir[folder.join("**", "*.yml")]
+    paths.each do |path|
+      add_controller_routing_from_path(path)
+    end
+  end
+
+  def behavior
+    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
+    }
+
+    ActiveAI::Behavior::LLM::FollowStructuredExamples.new(@llm, config)
+  end
+
+  def find_controller(request)
+    # should return constantized maybe?
+    routing = behavior.call({ 'Request' => request }, extract: %W[Route])
+    controller_name, action_name = routing['Route'].split('#')
+    
+    if controller_name == "None" || action_name.blank?
+      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)
+    if controller = find_controller(request)
+      controller.new.call(request)
+    else
+      return nil
+    end
+  end
+end

data/lib/activeai/version.rb

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

data/lib/activeai.rb

@@ -1,8 +1,20 @@
 # frozen_string_literal: true
 
+require_relative "activeai/behavior"
+require_relative "activeai/configuration"
+require_relative "activeai/controller"
+require_relative "activeai/neural_network"
+require_relative "activeai/router"
 require_relative "activeai/version"
 
 module ActiveAI
   class Error < StandardError; end
-  # Your code goes here...
+  
+  def self.config
+    {
+      gpt3_token: ENV['OPEN_AI_TOKEN']
+    }
+  end
+
 end
+

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: activeai
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - jeriko
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-30 00:00:00.000000000 Z
-dependencies: []
+date: 2023-01-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: 'true'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A pack for building AI-backed routes and controllers, plus a collection
   of helpers for GPT3, DALLE, Whisper, Stable Diffusion and more
 email:
@@ -23,11 +51,24 @@ files:
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
+- SESSIONS.md
 - activeai.gemspec
 - lib/activeai.rb
+- lib/activeai/behavior.rb
+- lib/activeai/behavior/base.rb
+- lib/activeai/behavior/llm.rb
+- lib/activeai/behavior/llm/conversation.rb
+- lib/activeai/behavior/llm/follow_structured_examples.rb
+- lib/activeai/behavior/llm/unstructured.rb
+- lib/activeai/configuration.rb
+- lib/activeai/controller.rb
+- lib/activeai/neural_network.rb
+- lib/activeai/neural_network/gpt3.rb
+- lib/activeai/router.rb
 - lib/activeai/version.rb
 - sig/activeai.rbs
 homepage: https://github.com/gamebreakers-org/activeai