active_cortex 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 378a610d894ec96ee6766021538255b8498db655792a1b6878d0720e09e0bb44
-  data.tar.gz: 0a0091e2980aa8326f26e4f0935fd7169cfda06627afa15c1f8014a587ef6fa6
+  metadata.gz: ca05346fe4261874164f6fbf48a473b4e310f2cafa206721b2f0ddb2dcfdff5c
+  data.tar.gz: 2a0163d3e56f87d416a56a105ad3c29af488de955445180d0adafa347d7d1c99
 SHA512:
-  metadata.gz: ee5d5959224b4e2fe7cb4bcb68f1a430320fa7a9071c85b87a10f14048a6d549f7f40fba24a8a497ebfaf8b6d94192c90e8bdfe6b4ab698a1bd84f767844a749
-  data.tar.gz: 0ab90dea7be949e3efe2280280aafcee93a2a66acc7ca63df8a2024097f54a1419d4377316243d58de96f37bb695f075e375cc16a4fd23271c9c5cfa36cf9784
+  metadata.gz: 5f4b74059e5887c179f7c330dd1a47aa87e68521b3e63a1283359ae4067cac187097890a52bd4b931b5b0cbcb6bdbecae16e985a9c16a708ecc3b78b77be6554
+  data.tar.gz: c585a12f113acf4086389fe67f20a1558e054c9f1ad3aa6e87ffb22de42f31e385ce9c883b2041a3a619bfdb95feab2d4ada8f54e0ea6b43f53713742d3d24f8

data/README.md

@@ -2,6 +2,35 @@
 
 Easily add AI-generated fields to your Rails models.
 
+## Motivation
+
+ActiveCortex is born out of the need to easily integrate OpenAI into Rails.
+
+Integrating with OpenAI is kind of a pain. It requires a lot of boilerplate: a
+service object, dealing with OpenAI errors, defining custom functions, etc.
+Also, OpenAI is constantly releasing new features, and keeping up-to-date is a
+hassle.
+
+Many developers aren't following OpenAI's best practices because they don't
+have the time to develop the functionality required to follow them. For
+example, it's a best practice to split complicated tasks into multiple prompts,
+but some developers will avoid doing that to simplify their implementation.
+This results in worse outputs. What if you could effortlessly write multi-stage
+prompts and debug their performance?
+
+We often write custom functions defining how to create a model we already have
+a schema for! What if you could tell ChatGPT to provide its response in a
+format that matches an ActiveRecord class?
+
+Finally, we have to consider errors. OpenAI has downtime, sometimes returns
+server errors, and ChatGPT sometimes bugs out and returns "Sorry, I can't help
+you with that". What if you could remove the error handling logic from your
+system?
+
+ActiveCortex cleans up Rails codebases by providing a macro that deals with the
+interface to OpenAI. (I'm still working on the above features, but that's the
+vision for this gem!)
+
 ## Usage
 
 ```ruby
@@ -13,6 +42,14 @@ class Document < ApplicationRecord
   # (or)
   ai_generated :summary, prompt: :generate_summary_prompt
 
+  # Generate has_many associations
+  has_many :reviews
+
+  # This will look at the Review class and pass its schema to OpenAI.
+  ai_generated :reviews,
+    prompt: -> (doc) { "Register three reviews for #{doc.title}" },
+    max_results: 3
+
   private
 
   def generate_summary_prompt
@@ -24,6 +61,9 @@ end
 doc = Document.new(text: "Call me Ishmael...")
 doc.generate_summary!
 doc.summary # => an AI-generated summary of `text`
+
+doc.generate_reviews!
+doc.reviews # => [#<Review id: nil content: "Wonderful! The way...", rating: 5>, ...]
 ```
 
 ## Installation
@@ -48,7 +88,7 @@ And set an OpenAI key
 
 ```ruby
 # config/initializers/active_cortex.rb
-ActiveCortex.config.openai_key = ENV.fetch("OPENAI_ACCESS_TOKEN")
+ActiveCortex.config.openai_access_token = ENV.fetch("OPENAI_ACCESS_TOKEN")
 ```
 
 ## Contributing

data/lib/active_cortex/generator/has_many.rb

@@ -0,0 +1,90 @@
+class ActiveCortex::Generator::HasMany < ActiveCortex::Generator
+  def self.accepts?(record:, field_name:)
+    record.class.reflect_on_association(field_name)&.collection?
+  end
+
+  def save_generation
+    record.send(field_name).push(generation)
+  end
+
+  def generation
+    generate_tool_calls.map do |tool_call|
+      build_record_from_tool_call(tool_call)
+    end
+  end
+
+  private
+
+  def klass
+    record.class.reflect_on_association(field_name).klass
+  end
+
+  def klass_attributes_for_tool_call
+    klass.attribute_types
+      .reject { |name, _| ["id", "created_at", "updated_at"].include?(name) }
+      .reject { |name, _| name.end_with?("_id") }
+      .map    { |name, type| [name, { type: type.type }] }
+      .to_h
+  end
+
+  def build_messages_from_tool_calls(tool_calls)
+    [{ role: "user", content: prompt }] + tool_calls.map do |tool_call|
+      [{
+        role: "assistant",
+        content: nil,
+        tool_calls: [tool_call]
+      },{
+        tool_call_id: tool_call["id"],
+        role: "tool",
+        name: tool_call["function"]["name"],
+        content: "OK"
+      }]
+    end.flatten
+  end
+
+  def schema_for_register_function
+    {
+      type: "function",
+      function: {
+        description: "Register a #{klass.name.singularize}", # TODO: test
+        name: "register_#{klass.name.singularize.underscore}", # TODO: test
+        parameters: {
+          type: "object",
+          properties: klass_attributes_for_tool_call
+        }
+      }
+    }
+  end
+
+  def build_record_from_tool_call(tool_call)
+    attrs_json = tool_call["function"]["arguments"]
+    attrs = JSON.parse(attrs_json)
+
+    if attrs.is_a?(Array)
+      attrs.map { |a| klass.new(a) }
+    else
+      klass.new(attrs)
+    end
+  end
+
+  def generate_tool_calls(tool_calls=[])
+    res = openai_client.chat(parameters: {
+      model: model,
+      messages: build_messages_from_tool_calls(tool_calls),
+      tools: [schema_for_register_function]
+    })
+
+    raise ActiveCortex::Error, res["error"] if res["error"]
+
+    added_tool_calls = res["choices"][0]["message"]["tool_calls"]
+    return tool_calls if added_tool_calls.blank?
+
+    tool_calls += added_tool_calls
+
+    if max_results && tool_calls.count >= max_results
+      tool_calls
+    else
+      generate_tool_calls(tool_calls)
+    end
+  end
+end

data/lib/active_cortex/generator/text.rb

@@ -0,0 +1,34 @@
+class ActiveCortex::Generator::Text < ActiveCortex::Generator
+  def self.accepts?(record:, field_name:)
+    record.class.attribute_types[field_name.to_s].type == :string
+  end
+
+  def save_generation
+    record.send("#{field_name}=", generation)
+  end
+
+  def generation
+    openai_content || raise(ActiveCortex::Error, openai_error_message)
+  end
+
+  private
+
+  def openai_content
+    openai_response["choices"][0]["message"]["content"]
+  rescue
+    nil
+  end
+
+  def openai_error_message
+    "Error from OpenAI. " + { response: openai_response }.to_json
+  end
+
+  def openai_response
+    @openai_response ||= openai_client.chat(parameters: {
+      model: model,
+      messages: [
+        { role: "user", content: prompt }
+      ],
+    })
+  end
+end

data/lib/active_cortex/generator.rb

@@ -0,0 +1,59 @@
+class ActiveCortex::Generator
+  # This is a factory method that returns an instance of a subclass of
+  # ActiveCortex::Generator. The subclass is chosen based on the type of the
+  # field that is being generated: text or has_many.
+  #
+  # The subclass is responsible for generating the result and saving it to the
+  # database.
+
+  def self.generate(**)
+    find_generator_class(**).new(**).save_generation
+  end
+
+  attr_reader :record, :field_name, :prompt, :max_results, :model
+
+  def initialize(record:, field_name:, prompt:, max_results:, model:)
+    @record = record
+    @field_name = field_name
+    @prompt = prompt
+    @max_results = max_results
+    @model = model
+
+    raise ArgumentError, "Invalid model provided must be " \
+      "e.g. 'gpt-3.5-turbo', was #{model.inspect}" unless valid_model?
+  end
+
+  def generation
+    raise NotImplementedError
+  end
+
+  def save_generation
+    raise NotImplementedError
+  end
+
+  private
+
+  def self.find_generator_class(record:, field_name:, **)
+    subclasses.find do |subclass|
+      subclass.accepts?(record:, field_name:)
+    end or raise(ActiveCortex::Error, "No generator found for '#{field_name}'")
+  end
+
+  def prompt
+    case @prompt
+    when Symbol then @record.send(@prompt)
+    when Proc then @prompt.call(@record)
+    else
+      raise ActiveCortex::Error,
+        "Prompt must be a symbol or a proc, got #{@prompt.inspect}"
+    end
+  end
+
+  def openai_client
+    @openai_client ||= OpenAI::Client.new(access_token: ActiveCortex.config.openai_access_token)
+  end
+
+  def valid_model?
+    model.present? && model.is_a?(String)
+  end
+end

data/lib/active_cortex/model.rb

@@ -3,37 +3,59 @@ require "openai"
 module ActiveCortex::Model
   extend ActiveSupport::Concern
 
+  DEFAULT_MODEL = "gpt-3.5-turbo"
+
   class_methods do
-    def ai_generated(field, prompt: nil)
-      define_method("generate_#{field}!") do
-        self[field] = generate_content_for_field(field, prompt:)
+    # Macro to add methods to a model to generate content for a field.
+    #
+    # For has_many associations, the macro will generate a method that appends an array of
+    # generated objects to the association.
+    #
+    # Example:
+    #
+    #     class Post < ApplicationRecord
+    #       ai_generated :title, prompt: -> (post) { "Write a title for a post about #{post.topic}" }
+    #     end
+    #
+    #     post = Post.new(topic: "cats")
+    #     post.generate_title!
+    #     post.title # => "Cats are the best"
+    #
+    # Example with has_many association:
+    #
+    #    class Post < ApplicationRecord
+    #      has_many :comments
+    #      ai_generated :comments,
+    #        prompt: -> (post) { "Register a comment on #{post.title}" },
+    #        max_results: 3
+    #    end
+    #
+    #    post = Post.new(title: "Cats are the best")
+    #    post.generate_comments!
+    #    post.comments # => [#<Comment id: 1, content: "I love cats">, ...]
+    #
+    # Options:
+    #
+    #   * prompt: a symbol or a proc that returns a string to use as the prompt
+    #   * model: the ChatGPT model to use for generating content
+    #   * max_results: for has_many associations, the maximum number of results to generate
+    def ai_generated(field_name, prompt:, max_results: nil, model: DEFAULT_MODEL)
+      validate_arguments!(field_name, prompt, max_results, model)
+
+      define_method "generate_#{field_name}!" do
+        ActiveCortex::Generator.generate(
+          record: self, field_name:, prompt:, max_results:, model:
+        )
       end
     end
-  end
 
-  private
+    private
 
-  def generate_content_for_field(field, prompt: nil)
-    content = case prompt
-              when Symbol then send(prompt)
-              when Proc then prompt.call(self)
-              else
-                raise ActiveCortex::Error, "prompt must be a symbol or a proc"
-              end
-
-    query_chatgpt_with(content)
-  rescue => e
-    raise ActiveCortex::Error, e.message
-  end
-
-  def query_chatgpt_with(content)
-    openai_client.chat(parameters: {
-      model: "gpt-3.5-turbo",
-      messages: [{ role: "user", content: content }], 
-    })["choices"][0]["message"]["content"]
-  end
-
-  def openai_client
-    @openai_client ||= OpenAI::Client.new(access_token: ActiveCortex.config.openai_access_token)
+    def validate_arguments!(field_name, prompt, max_results, model)
+      raise ArgumentError, "field_name must be a symbol or string" unless field_name.is_a?(Symbol) || field_name.is_a?(String)
+      raise ArgumentError, "prompt must be a proc" unless prompt.is_a?(Proc)
+      raise ArgumentError, "max_results must be a number" unless max_results.nil? || max_results.is_a?(Integer)
+      raise ArgumentError, "model must be a string" unless model.is_a?(String)
+    end
   end
 end

data/lib/active_cortex/version.rb

@@ -1,3 +1,3 @@
 module ActiveCortex
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/active_cortex.rb

@@ -1,6 +1,9 @@
 require "active_cortex/version"
 require "active_cortex/config"
 require "active_cortex/railtie"
+require "active_cortex/generator"
+require "active_cortex/generator/text"
+require "active_cortex/generator/has_many"
 require "active_cortex/model"
 
 module ActiveCortex

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: active_cortex
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ori Marash
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-31 00:00:00.000000000 Z
+date: 2023-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 7.0.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 7.0.8
 - !ruby/object:Gem::Dependency
   name: dry-configurable
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
   name: ruby-openai
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '5.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '5.1'
 description: Easily add AI-generated fields to your Raila models.
@@ -64,6 +64,9 @@ files:
 - Rakefile
 - lib/active_cortex.rb
 - lib/active_cortex/config.rb
+- lib/active_cortex/generator.rb
+- lib/active_cortex/generator/has_many.rb
+- lib/active_cortex/generator/text.rb
 - lib/active_cortex/model.rb
 - lib/active_cortex/railtie.rb
 - lib/active_cortex/version.rb
@@ -89,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Easily add AI-generated fields to your Rails models.