activeai 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 364516f172adcee466de83976b85b58e1b261b3f3f32367c09e4663119b9e165
-  data.tar.gz: e187d3303baceae837ed6671b797315648301bacf96f283caa840d883c15d0f8
+  metadata.gz: deea25fb847c585d5722d3ca53c369dd0af13864615fdc82013db1f70fa17e8e
+  data.tar.gz: 0c6612d1caaff492e04862947a7d3a1b3aeebb747068be7e0a4dc18b8c6faaf0
 SHA512:
-  metadata.gz: 86f81a968aa3955afca6f92f4f671047969180ccba3cb93e5da3eb77820aaf292c2245bc157f2614718aa4203fb4ad0797c7c2dbb86942058a96ff94af238892
-  data.tar.gz: 51579d5f47efb0bbbd97be0f71d1ac51d997e30c659246c1f58f64224763cee55144098ee5f69eb18ea28aaf6288bd9cca74dc7d3c5a805b801bea277b7cf9d0
+  metadata.gz: d540bd977bddbb80203bd79855bc62938981c073a0b787d7d8f0fb51db7ec20496e32b1f094b0626dce6d260efab368749aa11f69d25feefec36c09b9c5f4885
+  data.tar.gz: 4de73f333f06560b445b453ec47520f759fd6c43da4fd56f8d03ed16b330c5ece5ff9b0d307ea6b9c4d0180061f24c2e3118545916a4c7c9c9bb22e36c09d4e4

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,80 @@
 
 ## 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!**
+
+### 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.
+examples:
+  - Match: Check the weather
+    To: none
+  - Match: Send R100 to Jomiro
+    To: bank#transfer_money
+    Params: { beneficiaryId: 12345, amount: 100.0 }
+  - Match: Pay Mom R245 for groceries
+    To: bank#transfer_money
+    Params: { beneficiaryId: 98765, amount: 245.0, reference: "Groceries <3" }
+  - Match: What's my bank balance?
+    To: bank#check_balance
+```
+
+### controllers/bank_controller.rb
+
+```
+class BankController < ActiveAI::Controller
+  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
+```

data/SESSIONS.md

@@ -0,0 +1,40 @@
+# 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 - it's really cool!
+
+TODO
+
+- publish v0.1.1 that actually works!
+
+## What I learned
+
+- Gonna need a master router and make the sub-routers just about param prep
+
+# 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 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
+- Build a chat behavior
+- 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,19 @@
+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'))
+    routes_config = YAML::load(File.read(routes_path))
+    # convert routes_config params into JSON?
+    router = ActiveAI::Router.new(routes_config, controller: base)
+  end
+
+  attr_accessor :params
+
+  def call(method_name, params)
+    @params = params
+    send(method_name)
+  end
+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,74 @@
+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.'
+
+  # 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 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
+    })
+  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
+
+    routers.each do |router|
+      response = router.call(request)
+      return response if response
+    end
+  end
+
+  attr_accessor :config
+
+  def initialize(config, controller: nil)
+    self.class.routers ||= []
+
+    @config = config
+    @config['instruction'] ||= INSTRUCTION_INSTANCE
+
+    llm = ActiveAI::NeuralNetwork::GPT3.new(ActiveAI.config[:gpt3_token], model: 'text-curie-001')
+    @behavior = ActiveAI::Behavior::LLM::FollowStructuredExamples.new(llm, config)
+
+    if controller
+      self.class.routers << self
+      @controller = controller.new
+    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
+    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
+    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.1"
 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.1
 platform: ruby
 authors:
 - jeriko
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-30 00:00:00.000000000 Z
-dependencies: []
+date: 2022-12-31 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