orchestra_ai 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bc16033f35561a6926f78cd55986bb3ac690fa6232a687b1de69c2595dc7141f
+  data.tar.gz: 80d83b10e78ddc0b67b15bf0a2efeaa9e4bd01d4c356cff29043979cc3ca7b8e
+SHA512:
+  metadata.gz: bf2eaad561ed358d645304a01e8092d86e82012b001e656fd5008d19e75721f2bb6e53f1f408060cd8bcd8350663aa046aea0703f634da27159f40f39cd6ad66
+  data.tar.gz: 28b03b211b0030b386adcdffcb639c215c72a12c57f1af6dd1e87780dcccc3634bdde2e11fac5b086010bfc207b547888161efc3600a7d077edac90191335cc1

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+## [Unreleased]
+
+## [0.1.1] - 2025-04-11
+
+- Added message history inteface to the agent
+
+## [0.1.0] - 2025-04-11
+
+- Initial release

data/README.md

@@ -0,0 +1,83 @@
+# OrchestraAI
+
+OrchestraAI is a Ruby library that allows you to create and manage workflows for LLMs (Large Language Models) using a simple and intuitive syntax. It provides a way to define instruments (actions) and orchestrate them in a structured manner, making it easier to build complex applications that leverage the power of LLMs.
+
+## Features
+
+- Define instruments (actions) with arguments and perform them in a structured manner
+- Orchestrate multiple instruments to create complex workflows
+- Zero dependencies
+- Can reuse your current LLM client
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add orchestra_ai
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install orchestra_ai
+```
+
+## Usage
+
+```ruby
+require 'orchestra_ai'
+
+class CreateNoteInstrument < OrchestraAI::Instrument
+  argument :title, String
+  argument :content, String
+  argument :folder_id, Integer
+
+  def perform(title:, content:, folder_id:)
+    Post.create(title:, content:, folder_id:)
+  end
+end
+
+class CreateFolderInstrument < OrchestraAI::Instrument
+  argument :name, String
+  argument :path, String
+
+  def perform(name:, path:)
+    Folder.create(name:, path:)
+  end
+end
+
+class WikiOrchestra < OrchestraAI::Orchestra
+  instrument CreateNoteInstrument
+  instrument CreateFolderInstrument
+end
+
+chat = RubyLLM.chat
+
+WikiOrchestra.play(
+<<~TEXT
+  - Create a folder named "My Documents"
+  - Create a post titled "My First Post" with content "Hello, world!" in the folder "My Documents"
+TEXT
+) do |prompt|
+  chat.ask(prompt) do |chunk|
+    puts chunk.content
+  end
+
+  chat.messages.last.content
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/moekiorg/orchestra_ai. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/orchestra_ai/orchestra_ai/blob/main/CODE_OF_CONDUCT.md).
+
+## Code of Conduct
+
+Everyone interacting in the He project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/orchestra_ai/orchestra_ai/blob/main/CODE_OF_CONDUCT.md).

data/lib/orchestra_ai/instrument.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module OrchestraAI
+  class Instrument
+    class << self
+      attr_accessor :arguments
+
+      def argument(name, type)
+        @arguments ||= []
+        @arguments << {name:, type:}
+      end
+    end
+
+    def perform(**args)
+      raise NotImplementedError, "You must implement the perform method"
+    end
+
+    def key
+      self.class.name
+    end
+  end
+end

data/lib/orchestra_ai/message.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module OrchestraAI
+  class Message
+    attr_accessor :messages
+
+    def initialize
+      @messages = []
+    end
+
+    def <<(message)
+      @messages << message
+    end
+
+    def to_s
+      @messages.join("\n")
+    end
+
+    def clear
+      @messages.clear
+    end
+  end
+end

data/lib/orchestra_ai/orchestra.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module OrchestraAI
+  class Orchestra
+    class << self
+      attr_reader :instruments
+
+      def instrument(klass)
+        @instruments ||= []
+        @instruments << klass
+      end
+
+      def play(message, &block)
+        results = []
+        loop do
+          creation = Step::CreateTask.new(
+            instruments: instruments.map(&:new),
+            message:,
+            block:,
+            results:
+          )
+          creation.perform
+          task = creation.task
+          result = task.result
+          results << result
+          if creation.metadata[:continuation].to_s == "false"
+            break
+          end
+        end
+        summarize = Step::Summarize.new(
+          results:,
+          block:
+        )
+        summarize.perform
+      end
+    end
+  end
+end

data/lib/orchestra_ai/prompt/create_task.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module OrchestraAI
+  module Prompt
+    class CreateTask
+      def initialize(instruments:, results:)
+        @instruments = instruments
+        @results = results
+      end
+
+      def to_s
+        <<~XML
+          <Instructions>
+            You are a workflow agent. Your task is to create a workflow based on the user's instructions.
+            `<Message>` tags contain your message to the user.
+            `<Metadata>` tags contain metadata about the workflow. If the workflow will continue, set the `continuation` key to `true`. If you think that the workflow is finished when the task is completed, set the `continuation` key to `false`.
+            `<Task>` tags contain the tasks to be performed. This tag must be present one time. Task must contain object not array.
+          </Instructions>
+
+          <Options>
+            #{
+              @instruments.map { |instrument|
+                {
+                  key: instrument.key,
+                  params: instrument.class.arguments.map { _1.transform_values { |v| v.name } }
+                }
+              }.to_json
+            }
+          </Options>
+
+          <Example type="success">
+            <Message>
+              I will create a folder named "My Folder".
+            </Message>
+
+            <Metadata>
+              { "continuation": false | true }
+            </Metadata>
+
+            <Task>
+              {
+                "id": 1,
+                "key": "create_folder",
+                "params": {
+                  "name": "My Folder",
+                  "path": "My Folder"
+                }
+              }
+            </Task>
+          </Example>
+
+          <Example type="error">
+            <Error>
+              <Message>There was an error creating the folder</Message>
+            </Error>
+          </Example>
+        XML
+      end
+    end
+  end
+end

data/lib/orchestra_ai/prompt/summarize.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module OrchestraAI
+  module Prompt
+    class Summarize
+      def initialize(results:)
+        @results = results
+      end
+
+      def to_s
+        <<~XML
+          <Instruction>
+            <Item>
+              The workflow has been executed. Here are the results:
+              #{
+                @results.map { |r|
+                  "Task: #{r.action.key}, Params: #{r.action.class.arguments.to_json}, Result: #{r.result}"
+                }.join("\n")
+              }
+              Now, please summarize the results in a single JSON object
+            </Item>
+          </Instruction>
+
+          <Example type="success">
+            <Message>
+              I have created a folder named "My Folder" and a post titled "My Post" with content "This is my post" in the folder "My Folder"
+            </Message>
+          </Example>
+        XML
+      end
+    end
+  end
+end

data/lib/orchestra_ai/result.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module OrchestraAI
+  class Result
+    attr_reader :action, :result
+
+    def initialize(action:, result:)
+      @action = action
+      @result = result
+    end
+
+    def self.find(all, id)
+      all.find { |r| r.action.id == id.to_i }
+    end
+  end
+end

data/lib/orchestra_ai/step/create_task.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module OrchestraAI
+  module Step
+    class CreateTask
+      def initialize(instruments:, message:, results:, block: nil)
+        @message = message
+        @results = results
+        @block = block
+        @instruments = instruments
+        @response = nil
+      end
+
+      def perform
+        @response = @block.call(
+          [
+            @message,
+            Prompt::CreateTask.new(instruments: @instruments, results: @results).to_s
+          ].join
+        )
+
+        if @response.match?(/<Error>/)
+          raise Error, "Error: #{@response.match(/<Message>(.+)<\/Message>/m)[1]}"
+        end
+
+        unless @response.match?(/<Message>(.+)<\/Message>/m)
+          raise NoMessageError, "Error: No message found in the response"
+        end
+
+        unless @response.match?(/<Task>(.+)<\/Task>/m)
+          raise NoTaskError, "Error: No task found in the response"
+        end
+
+        @response
+      end
+
+      def task
+        Task.new(**JSON.parse(@response.match(/<Task>(.+)<\/Task>/m)[1], symbolize_names: true))
+      end
+
+      def message
+        @response.match(/<Message>(.+)<\/Message>/m)[1]
+      end
+
+      def metadata
+        if /<Metadata>(.+)<\/Metadata>/m.match?(@response)
+          JSON.parse(@response.match(/<Metadata>(.+)<\/Metadata>/m)[1], symbolize_names: true)
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/orchestra_ai/step/summarize.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module OrchestraAI
+  module Step
+    class Summarize
+      def initialize(results:, block: nil)
+        @block = block
+        @results = results
+      end
+
+      def perform
+        prompt = Prompt::Summarize.new(results: @results)
+        @response = @block.call(prompt.to_s)
+
+        if @response.match?(/<Error>/)
+          raise Error, "Error: #{@response.match(/<Message>(.+)<\/Message>/m)[1]}"
+        end
+
+        unless @response.match?(/<Message>(.+)<\/Message>/m)
+          raise NoMessageError, "Error: No message found in the response"
+        end
+
+        @response
+      end
+
+      def message
+        @response.match(/<Message>(.+)<\/Message>/m)[1]
+      end
+    end
+  end
+end

data/lib/orchestra_ai/task.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module OrchestraAI
+  class Task
+    attr_accessor :id, :key, :params
+
+    def initialize(id:, key:, params: {})
+      @id = id
+      @key = key
+      @params = params
+    end
+
+    def result
+      action = Object.const_get(key).new
+      Result.new(action:, result: action.perform(**@params))
+    end
+  end
+end

data/lib/orchestra_ai/version.rb

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

data/lib/orchestra_ai.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "orchestra_ai/version"
+require_relative "orchestra_ai/prompt/summarize"
+require_relative "orchestra_ai/step/summarize"
+require_relative "orchestra_ai/prompt/create_task"
+require_relative "orchestra_ai/step/create_task"
+require_relative "orchestra_ai/orchestra"
+require_relative "orchestra_ai/task"
+require_relative "orchestra_ai/message"
+require_relative "orchestra_ai/result"
+require_relative "orchestra_ai/instrument"
+
+module OrchestraAI
+  class Error < StandardError; end
+
+  class NoMessageError < StandardError; end
+
+  class NoTaskError < StandardError; end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: orchestra_ai
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- KAWAKAMI Moeki
+bindir: exe
+cert_chain: []
+date: 2025-04-12 00:00:00.000000000 Z
+dependencies: []
+description: OrchestraAI is a Ruby library that allows you to create and manage workflows
+  using LLMs (Large Language Models). It provides a simple and intuitive interface
+  for defining tasks, managing dependencies, and executing workflows.
+email:
+- hi@moeki.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- lib/orchestra_ai.rb
+- lib/orchestra_ai/instrument.rb
+- lib/orchestra_ai/message.rb
+- lib/orchestra_ai/orchestra.rb
+- lib/orchestra_ai/prompt/create_task.rb
+- lib/orchestra_ai/prompt/summarize.rb
+- lib/orchestra_ai/result.rb
+- lib/orchestra_ai/step/create_task.rb
+- lib/orchestra_ai/step/summarize.rb
+- lib/orchestra_ai/task.rb
+- lib/orchestra_ai/version.rb
+homepage: https://github.com/moekiorg/orchestra_ai
+licenses: []
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.6
+specification_version: 4
+summary: LLM Workflow Agent for Ruby
+test_files: []