rcrewai-rails 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d07d3c8b88c4bf9326dc8fc588cc58d0b02112d8c92d4d6eccc25a3da98d58a2
+  data.tar.gz: 1ce7c0563541bc473d6d1d3a092063d0ec86d7617d314fe733e444d37f761bfc
+SHA512:
+  metadata.gz: 267b55d87d5ef72a12560a689459cc82cc93e99e55200b2c6128e492d4736f3911717c07b8616cb623baf8c595398084d9f57c0375e95deaf220b6f695c8c50a
+  data.tar.gz: 899ce8199ad7727e3bca13bf07362cf5184ba3ccc1431e35bd2564c57e91597c67db9744d9286c1caa115c9bd54cb2d7fb27fc29859d0b044d6bcd2fd6d6b034

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2024 RcrewAI Rails Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,222 @@
+# RcrewAI Rails
+
+Rails engine for integrating RcrewAI into your Rails applications. Provides ActiveRecord persistence, background job integration, generators, and a web UI for managing AI crews and agents.
+
+## Features
+
+- **ActiveRecord Integration**: Persist crews, agents, tasks, and executions in your database
+- **Background Job Support**: Works with any ActiveJob adapter (Sidekiq, Resque, Delayed Job, etc.)
+- **Rails Generators**: Quickly scaffold new crews and agents
+- **Web UI**: Monitor and manage crews through a built-in interface
+- **Rails-Specific Tools**: Pre-built tools for ActiveRecord, ActionMailer, Rails cache, and more
+- **Configuration**: Flexible configuration through Rails initializers
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rcrewai-rails'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Run the installation generator:
+
+```bash
+$ rails generate rcrewai:rails:install
+$ rails db:migrate
+```
+
+This will:
+- Create the necessary database migrations
+- Add an initializer file for configuration
+- Mount the engine routes
+
+## Configuration
+
+Configure RcrewAI Rails in `config/initializers/rcrewai.rb`:
+
+```ruby
+RcrewAI::Rails.configure do |config|
+  # ActiveJob queue for background processing
+  config.job_queue_name = "default"
+  
+  # Enable/disable web UI
+  config.enable_web_ui = true
+  
+  # Use async execution by default
+  config.async_execution = true
+  
+  # Default LLM settings
+  config.default_llm_provider = "openai"
+  config.default_llm_model = "gpt-4"
+  
+  # Logging
+  config.enable_logging = true
+  config.log_level = :info
+end
+
+# Configure the base RcrewAI gem
+RcrewAI.configure do |config|
+  config.openai_api_key = ENV["OPENAI_API_KEY"]
+  # Add other LLM provider keys as needed
+end
+```
+
+## Usage
+
+### Creating a Crew with Generators
+
+Generate a new crew with agents:
+
+```bash
+$ rails generate rcrewai:rails:crew research_team sequential \
+    --agents researcher analyst writer \
+    --description "Research team for market analysis"
+```
+
+This creates a crew class in `app/crews/research_team_crew.rb`.
+
+### Creating a Crew Programmatically
+
+```ruby
+class ResearchCrew
+  include RcrewAI::Rails::CrewBuilder
+  
+  crew_name "research_team"
+  crew_description "AI-powered research team"
+  process_type :sequential
+  memory_enabled true
+  
+  def setup_agents
+    @researcher = create_agent("researcher",
+      role: "Senior Research Analyst",
+      goal: "Uncover insights and trends",
+      backstory: "Expert researcher with years of experience"
+    )
+    
+    @writer = create_agent("writer", 
+      role: "Content Writer",
+      goal: "Create compelling reports",
+      backstory: "Skilled writer specializing in technical content"
+    )
+  end
+  
+  def setup_tasks
+    @research_task = create_task("Research latest AI trends",
+      expected_output: "Comprehensive research report",
+      position: 1
+    )
+    assign_agent_to_task(@researcher, @research_task)
+    
+    @writing_task = create_task("Write executive summary",
+      expected_output: "2-page executive summary",
+      position: 2  
+    )
+    assign_agent_to_task(@writer, @writing_task)
+    add_task_dependency(@writing_task, @research_task)
+  end
+end
+
+# Execute the crew
+crew = ResearchCrew.new
+execution = crew.execute(topic: "AI in Healthcare")
+```
+
+### Using Rails-Specific Tools
+
+```ruby
+class DataAnalystAgent
+  include RcrewAI::Rails::AgentBuilder
+  
+  agent_role "Data Analyst"
+  agent_goal "Analyze application data"
+  
+  tools [
+    RcrewAI::Rails::Tools::ActiveRecordTool.new(
+      model_class: User,
+      allowed_methods: [:count, :where, :pluck]
+    ),
+    RcrewAI::Rails::Tools::RailsCacheTool.new,
+    RcrewAI::Rails::Tools::ActionMailerTool.new(
+      mailer_class: ReportMailer,
+      allowed_methods: [:send_report]
+    )
+  ]
+end
+```
+
+### Monitoring Executions
+
+Access the web UI at `/rcrewai` to:
+- View all crews and their configurations
+- Monitor execution status and logs
+- Start new executions
+- View execution history and results
+
+### Using with ActiveJob
+
+Executions run through ActiveJob by default, using whatever adapter your Rails app is configured with:
+
+```ruby
+# Async execution (default)
+crew.execute_async(inputs)
+
+# Sync execution
+crew.execute_sync(inputs)
+
+# Custom job options
+CrewExecutionJob.set(wait: 5.minutes).perform_later(crew, inputs)
+```
+
+## Database Models
+
+The gem provides these ActiveRecord models:
+
+- `RcrewAI::Rails::Crew` - Crew configurations
+- `RcrewAI::Rails::Agent` - Agent definitions
+- `RcrewAI::Rails::Task` - Task definitions
+- `RcrewAI::Rails::Execution` - Execution history
+- `RcrewAI::Rails::ExecutionLog` - Detailed execution logs
+
+## API Endpoints
+
+The engine provides JSON API endpoints:
+
+```
+GET    /rcrewai/api/v1/crews
+GET    /rcrewai/api/v1/crews/:id
+POST   /rcrewai/api/v1/crews/:id/execute
+GET    /rcrewai/api/v1/executions
+GET    /rcrewai/api/v1/executions/:id
+GET    /rcrewai/api/v1/executions/:id/status
+GET    /rcrewai/api/v1/executions/:id/logs
+```
+
+## Development
+
+After checking out the repo, run:
+
+```bash
+$ bundle install
+$ bundle exec rspec
+```
+
+To install this gem onto your local machine:
+
+```bash
+$ bundle exec rake install
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub.
+
+## License
+
+The gem is available as open source under the terms of the MIT License.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/app/controllers/rcrewai/rails/application_controller.rb

@@ -0,0 +1,17 @@
+module RcrewAI
+  module Rails
+    class ApplicationController < ActionController::Base
+      protect_from_forgery with: :exception
+      
+      before_action :check_web_ui_enabled
+
+      private
+
+      def check_web_ui_enabled
+        unless RcrewAI::Rails.config.enable_web_ui
+          render plain: "RcrewAI Web UI is disabled", status: :forbidden
+        end
+      end
+    end
+  end
+end

data/app/controllers/rcrewai/rails/crews_controller.rb

@@ -0,0 +1,67 @@
+module RcrewAI
+  module Rails
+    class CrewsController < ApplicationController
+      before_action :set_crew, only: [:show, :edit, :update, :destroy, :execute]
+
+      def index
+        @crews = Crew.includes(:agents, :tasks).page(params[:page])
+      end
+
+      def show
+        @recent_executions = @crew.executions.recent.limit(10)
+        @agents = @crew.agents
+        @tasks = @crew.tasks.ordered
+      end
+
+      def new
+        @crew = Crew.new
+      end
+
+      def create
+        @crew = Crew.new(crew_params)
+        
+        if @crew.save
+          redirect_to @crew, notice: 'Crew was successfully created.'
+        else
+          render :new
+        end
+      end
+
+      def edit
+      end
+
+      def update
+        if @crew.update(crew_params)
+          redirect_to @crew, notice: 'Crew was successfully updated.'
+        else
+          render :edit
+        end
+      end
+
+      def destroy
+        @crew.destroy
+        redirect_to crews_url, notice: 'Crew was successfully destroyed.'
+      end
+
+      def execute
+        inputs = params[:inputs] || {}
+        execution = @crew.execute_async(inputs)
+        
+        redirect_to execution_path(execution), notice: 'Crew execution started.'
+      end
+
+      private
+
+      def set_crew
+        @crew = Crew.find(params[:id])
+      end
+
+      def crew_params
+        params.require(:crew).permit(
+          :name, :description, :process_type, :verbose,
+          :memory_enabled, :cache_enabled, :max_rpm, :manager_llm, :active
+        )
+      end
+    end
+  end
+end

data/app/controllers/rcrewai/rails/executions_controller.rb

@@ -0,0 +1,65 @@
+module RcrewAI
+  module Rails
+    class ExecutionsController < ApplicationController
+      before_action :set_execution, only: [:show, :cancel, :logs]
+
+      def index
+        @executions = Execution.includes(:crew)
+        @executions = @executions.where(crew_id: params[:crew_id]) if params[:crew_id]
+        @executions = @executions.where(status: params[:status]) if params[:status]
+        @executions = @executions.recent.page(params[:page])
+      end
+
+      def show
+        @logs = @execution.execution_logs.recent.page(params[:page])
+        
+        respond_to do |format|
+          format.html
+          format.json { render json: execution_json }
+          format.turbo_stream if request.headers["Turbo-Frame"]
+        end
+      end
+
+      def cancel
+        if @execution.running?
+          @execution.cancel!
+          redirect_to @execution, notice: 'Execution was cancelled.'
+        else
+          redirect_to @execution, alert: 'Execution cannot be cancelled.'
+        end
+      end
+
+      def logs
+        @logs = @execution.execution_logs
+        @logs = @logs.where(level: params[:level]) if params[:level]
+        @logs = @logs.recent.limit(params[:limit] || 100)
+        
+        respond_to do |format|
+          format.json { render json: @logs }
+          format.turbo_stream
+        end
+      end
+
+      private
+
+      def set_execution
+        @execution = Execution.find(params[:id])
+      end
+
+      def execution_json
+        {
+          id: @execution.id,
+          crew_name: @execution.crew.name,
+          status: @execution.status,
+          started_at: @execution.started_at,
+          completed_at: @execution.completed_at,
+          duration_seconds: @execution.duration_seconds,
+          inputs: @execution.inputs,
+          output: @execution.output,
+          error_message: @execution.error_message,
+          logs_count: @execution.execution_logs.count
+        }
+      end
+    end
+  end
+end

data/app/jobs/rcrewai/rails/crew_execution_job.rb

@@ -0,0 +1,82 @@
+module RcrewAI
+  module Rails
+    class CrewExecutionJob < ActiveJob::Base
+      queue_as { RcrewAI::Rails.config.job_queue_name }
+
+      retry_on StandardError, wait: :exponentially_longer, attempts: 3
+
+      def perform(crew, inputs = {})
+        execution = crew.executions.create!(
+          status: "pending",
+          inputs: inputs
+        )
+
+        begin
+          execution.start!
+          execution.log("info", "Starting crew execution", { crew_id: crew.id })
+
+          # Convert Rails models to RcrewAI objects
+          rcrew = crew.to_rcrew
+          
+          # Execute the crew with logging
+          result = execute_with_logging(rcrew, inputs, execution)
+          
+          execution.complete!(result)
+          execution.log("info", "Crew execution completed successfully", { result: result })
+          
+          # Trigger callbacks if configured
+          notify_completion(crew, execution, result)
+          
+          result
+        rescue => e
+          execution.fail!(e)
+          execution.log("error", "Crew execution failed", { 
+            error: e.message,
+            backtrace: e.backtrace.first(5)
+          })
+          
+          # Re-raise for ActiveJob retry mechanism
+          raise
+        end
+      end
+
+      private
+
+      def execute_with_logging(rcrew, inputs, execution)
+        # Set up logging callbacks
+        rcrew.before_task do |task|
+          execution.log("info", "Starting task: #{task.description}")
+        end
+
+        rcrew.after_task do |task, output|
+          execution.log("info", "Completed task: #{task.description}", { output: output })
+        end
+
+        # Execute the crew
+        rcrew.kickoff(inputs)
+      end
+
+      def notify_completion(crew, execution, result)
+        # Send notifications if configured
+        if crew.notification_webhook_url.present?
+          NotificationJob.perform_later(
+            crew.notification_webhook_url,
+            {
+              crew_id: crew.id,
+              execution_id: execution.id,
+              status: "completed",
+              result: result
+            }
+          )
+        end
+
+        # Trigger Rails events
+        ActiveSupport::Notifications.instrument("crew_execution.completed", {
+          crew: crew,
+          execution: execution,
+          result: result
+        })
+      end
+    end
+  end
+end

data/app/jobs/rcrewai/rails/task_execution_job.rb

@@ -0,0 +1,63 @@
+module RcrewAI
+  module Rails
+    class TaskExecutionJob < ActiveJob::Base
+      queue_as { RcrewAI::Rails.config.job_queue_name }
+
+      retry_on StandardError, wait: 5.seconds, attempts: 3
+
+      def perform(task, agent, inputs = {})
+        execution_log = {
+          task_id: task.id,
+          agent_id: agent.id,
+          started_at: Time.current
+        }
+
+        begin
+          # Convert to RcrewAI objects
+          rcrew_task = task.to_rcrew_task
+          rcrew_agent = agent.to_rcrew_agent
+
+          # Execute the task
+          result = rcrew_agent.execute_task(rcrew_task, context: inputs)
+
+          execution_log[:completed_at] = Time.current
+          execution_log[:status] = "completed"
+          execution_log[:result] = result
+
+          # Save result if configured
+          if task.output_file.present?
+            save_output_to_file(task.output_file, result)
+          end
+
+          # Log success
+          ::Rails.logger.info "Task #{task.id} completed successfully by agent #{agent.id}"
+
+          result
+        rescue => e
+          execution_log[:completed_at] = Time.current
+          execution_log[:status] = "failed"
+          execution_log[:error] = e.message
+
+          ::Rails.logger.error "Task #{task.id} failed: #{e.message}"
+          
+          raise
+        ensure
+          # Could save execution log to database if needed
+          log_task_execution(execution_log)
+        end
+      end
+
+      private
+
+      def save_output_to_file(filename, content)
+        output_path = ::Rails.root.join("tmp", "rcrewai_outputs", filename)
+        FileUtils.mkdir_p(File.dirname(output_path))
+        File.write(output_path, content)
+      end
+
+      def log_task_execution(log_data)
+        ActiveSupport::Notifications.instrument("task_execution.rcrewai", log_data)
+      end
+    end
+  end
+end

data/app/models/rcrewai/rails/agent.rb

@@ -0,0 +1,58 @@
+module RcrewAI
+  module Rails
+    class Agent < ApplicationRecord
+      self.table_name = "rcrewai_agents"
+      
+      belongs_to :crew
+      has_many :task_assignments, dependent: :destroy
+      has_many :tasks, through: :task_assignments
+
+      validates :name, presence: true
+      validates :role, presence: true
+
+      serialize :tools, coder: JSON, type: Array
+      serialize :llm_config, coder: JSON
+
+      scope :active, -> { where(active: true) }
+
+      def to_rcrew_agent
+        RCrewAI::Agent.new(
+          role: role,
+          goal: goal,
+          backstory: backstory,
+          memory: memory_enabled,
+          verbose: verbose,
+          allow_delegation: allow_delegation,
+          tools: instantiated_tools,
+          max_iter: max_iterations,
+          max_rpm: max_rpm,
+          llm: llm_config
+        )
+      end
+
+      def instantiated_tools
+        return [] if tools.blank?
+
+        tools.map do |tool_config|
+          tool_class = tool_config["class"].constantize
+          tool_params = tool_config["params"] || {}
+          tool_class.new(**tool_params.symbolize_keys)
+        end
+      end
+
+      def add_tool(tool_class, params = {})
+        self.tools ||= []
+        self.tools << {
+          "class" => tool_class.to_s,
+          "params" => params
+        }
+        save
+      end
+
+      def remove_tool(tool_class)
+        self.tools = tools.reject { |t| t["class"] == tool_class.to_s }
+        save
+      end
+    end
+  end
+end

data/app/models/rcrewai/rails/application_record.rb

@@ -0,0 +1,8 @@
+module RcrewAI
+  module Rails
+    class ApplicationRecord < ActiveRecord::Base
+      self.abstract_class = true
+      self.table_name_prefix = "rcrewai_"
+    end
+  end
+end

data/app/models/rcrewai/rails/crew.rb

@@ -0,0 +1,65 @@
+module RcrewAI
+  module Rails
+    class Crew < ApplicationRecord
+      self.table_name = "rcrewai_crews"
+      
+      has_many :agents, dependent: :destroy
+      has_many :tasks, dependent: :destroy
+      has_many :executions, dependent: :destroy
+
+      validates :name, presence: true
+      validates :process_type, inclusion: { in: %w[sequential hierarchical] }
+
+      serialize :config, coder: JSON
+      serialize :memory, coder: JSON
+
+      scope :active, -> { where(active: true) }
+      scope :with_agents, -> { includes(:agents) }
+
+      def to_rcrew
+        crew = RCrewAI::Crew.new(
+          name: name,
+          description: description,
+          process: process_type.to_sym,
+          verbose: verbose,
+          memory: memory_enabled,
+          cache: cache_enabled,
+          max_rpm: max_rpm,
+          manager_llm: manager_llm
+        )
+
+        agents.each do |agent|
+          crew.add_agent(agent.to_rcrew_agent)
+        end
+
+        tasks.each do |task|
+          crew.add_task(task.to_rcrew_task)
+        end
+
+        crew
+      end
+
+      def execute_async(inputs = {})
+        CrewExecutionJob.perform_later(self, inputs)
+      end
+
+      def execute_sync(inputs = {})
+        CrewExecutionJob.perform_now(self, inputs)
+      end
+
+      def last_execution
+        executions.order(created_at: :desc).first
+      end
+
+      def execution_stats
+        {
+          total: executions.count,
+          successful: executions.successful.count,
+          failed: executions.failed.count,
+          pending: executions.pending.count,
+          average_duration: executions.successful.average(:duration_seconds)
+        }
+      end
+    end
+  end
+end