Rails Generator for RubyLLM Models

README.md

@@ -121,6 +121,32 @@ See the [Installation Guide](https://rubyllm.com/installation) for full details.
 
 Add persistence to your chat models effortlessly:
 
+### Option 1: Rails Generate
+
+Simply run the generator to set up all required models:
+
+```bash
+rails generate ruby_llm:install
+```
+
+This creates all necessary migrations, models, and database tables. Then just use them:
+
+```ruby
+# In your controller
+chat = Chat.create!(model_id: "gpt-4o-mini")
+chat.ask("What's your favorite Ruby gem?") do |chunk|
+  Turbo::StreamsChannel.broadcast_append_to(
+    chat, target: "response", partial: "messages/chunk", locals: { chunk: chunk }
+  )
+end
+
+# That's it - chat history is automatically saved
+```
+
+### Option 2: Manually
+
+Or, add RubyLLM to your existing ActiveRecord models:
+
 ```ruby
 # app/models/chat.rb
 class Chat < ApplicationRecord

docs/guides/rails.md

@@ -58,9 +58,41 @@ This approach has one important consequence: **you cannot use `validates :conten
 
 ## Setting Up Your Rails Application
 
-### Database Migrations
+### Quick Setup with Generator
 
-First, generate migrations for your `Chat`, `Message`, and `ToolCall` models.
+The easiest way to get started is using the provided Rails generator:
+
+```bash
+rails generate ruby_llm:install
+```
+
+This generator automatically creates:
+- All required migrations (Chat, Message, ToolCall tables)
+- Model files with `acts_as_chat`, `acts_as_message`, and `acts_as_tool_call` configured
+- A RubyLLM initializer in `config/initializers/ruby_llm.rb`
+
+After running the generator:
+
+```bash
+rails db:migrate
+```
+
+You're ready to go! The generator handles all the setup complexity for you.
+
+#### Generator Options
+
+The generator supports custom model names if needed:
+
+```bash
+# Use custom model names
+rails generate ruby_llm:install --chat-model-name=Conversation --message-model-name=ChatMessage --tool-call-model-name=FunctionCall
+```
+
+This is useful if you already have models with these names or prefer different naming conventions.
+
+### Manual Setup
+
+If you prefer to set up manually or need custom table/model names, you can create the migrations yourself:
 
 ```bash
 # Generate basic models and migrations
@@ -69,7 +101,7 @@ rails g model Message chat:references role:string content:text model_id:string i
 rails g model ToolCall message:references tool_call_id:string:index name:string arguments:jsonb
 ```
 
-Adjust the migrations as needed (e.g., `null: false` constraints, `jsonb` type for PostgreSQL).
+Then adjust the migrations as needed (e.g., `null: false` constraints, `jsonb` type for PostgreSQL).
 
 ```ruby
 # db/migrate/YYYYMMDDHHMMSS_create_chats.rb

lib/generators/ruby_llm/install/templates/INSTALL_INFO.md.tt

@@ -0,0 +1,75 @@
+# RubyLLM Rails Setup Complete!
+
+Thanks for installing RubyLLM in your Rails application. Here's what was created:
+
+## Models
+
+- `<%= options[:chat_model_name] %>` - Stores chat sessions and their associated model ID
+- `<%= options[:message_model_name] %>` - Stores individual messages in a chat
+- `<%= options[:tool_call_model_name] %>` - Stores tool calls made by language models
+
+## Configuration Options
+
+The generator supports the following options to customize model names:
+
+```bash
+rails generate ruby_llm:install \
+  --chat-model-name=Conversation \
+  --message-model-name=ChatMessage \
+  --tool-call-model-name=FunctionCall
+```
+
+This is useful when you need to avoid namespace collisions with existing models in your application. Table names will be automatically derived from the model names following Rails conventions.
+
+## Next Steps
+
+1. **Run migrations:**
+   ```bash
+   rails db:migrate
+   ```
+
+2. **Set your API keys** in `config/initializers/ruby_llm.rb` or using environment variables:
+   ```ruby
+   # config/initializers/ruby_llm.rb
+   RubyLLM.configure do |config|
+     config.openai_api_key = ENV["OPENAI_API_KEY"]
+     config.anthropic_api_key = ENV["ANTHROPIC_API_KEY"]
+     # etc.
+   end
+   ```
+
+3. **Start using RubyLLM in your code:**
+   ```ruby
+   # In a background job
+   class ChatJob < ApplicationJob
+     def perform(chat_id, question)
+       chat = <%= options[:chat_model_name] %>.find(chat_id)
+       chat.ask(question) do |chunk|
+         Turbo::StreamsChannel.broadcast_append_to(
+           chat, target: "response", partial: "messages/chunk", locals: { chunk: chunk }
+         )
+       end
+     end
+   end
+
+   # Queue the job
+   chat = <%= options[:chat_model_name] %>.create!(model_id: "gpt-4o-mini")
+   ChatJob.perform_later(chat.id, "What's your favorite Ruby gem?")
+   ```
+
+4. **For streaming responses** with ActionCable or Turbo:
+   ```ruby
+   chat.ask("Tell me about Ruby on Rails") do |chunk|
+     Turbo::StreamsChannel.broadcast_append_to(
+       chat, target: "response", partial: "messages/chunk", locals: { chunk: chunk }
+     )
+   end
+   ```
+
+## Advanced Usage
+
+- Add more fields to your models as needed
+- Customize the views to match your application design
+- Create a controller for chat interactions
+
+For more information, visit the [RubyLLM Documentation](https://github.com/crmne/ruby_llm)

lib/generators/ruby_llm/install/templates/chat_model.rb.tt

@@ -0,0 +1,3 @@
+class <%= options[:chat_model_name] %> < ApplicationRecord
+  <%= acts_as_chat_declaration %>
+end

lib/generators/ruby_llm/install/templates/create_chats_migration.rb.tt

@@ -0,0 +1,8 @@
+class Create<%= options[:chat_model_name].pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= options[:chat_model_name].tableize %> do |t|
+      t.string :model_id
+      t.timestamps
+    end
+  end
+end

lib/generators/ruby_llm/install/templates/create_messages_migration.rb.tt

@@ -0,0 +1,15 @@
+# Migration for creating messages table with references to chats and tool_calls
+class Create<%= options[:message_model_name].pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= options[:message_model_name].tableize %> do |t|
+      t.references :<%= options[:chat_model_name].tableize.singularize %>, null: false, foreign_key: true
+      t.string :role
+      t.text :content
+      t.string :model_id
+      t.integer :input_tokens
+      t.integer :output_tokens
+      t.references :<%= options[:tool_call_model_name].tableize.singularize %>
+      t.timestamps
+    end
+  end
+end

lib/generators/ruby_llm/install/templates/create_tool_calls_migration.rb.tt

@@ -0,0 +1,14 @@
+<%#- # Migration for creating tool_calls table with database-specific JSON handling -%>
+class Create<%= options[:tool_call_model_name].pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= options[:tool_call_model_name].tableize %> do |t|
+      t.references :<%= options[:message_model_name].tableize.singularize %>, null: false, foreign_key: true
+      t.string :tool_call_id, null: false
+      t.string :name, null: false
+      t.<%= postgresql? ? 'jsonb' : 'json' %> :arguments, default: {}
+      t.timestamps
+    end
+
+    add_index :<%= options[:tool_call_model_name].tableize %>, :tool_call_id
+  end
+end

lib/generators/ruby_llm/install/templates/initializer.rb.tt

@@ -0,0 +1,14 @@
+# RubyLLM configuration
+RubyLLM.configure do |config|
+  # Set your API keys here or use environment variables
+  # config.openai_api_key = ENV["OPENAI_API_KEY"]
+  # config.anthropic_api_key = ENV["ANTHROPIC_API_KEY"]
+  # config.gemini_api_key = ENV["GEMINI_API_KEY"]
+  # config.deepseek_api_key = ENV["DEEPSEEK_API_KEY"]
+
+  # Uncomment to set a default model
+  # config.default_model = "gpt-4o-mini"
+
+  # Uncomment to set default options
+  # config.default_options = { temperature: 0.7 }
+end

lib/generators/ruby_llm/install/templates/message_model.rb.tt

@@ -0,0 +1,3 @@
+class <%= options[:message_model_name] %> < ApplicationRecord
+  <%= acts_as_message_declaration %>
+end

lib/generators/ruby_llm/install/templates/tool_call_model.rb.tt

@@ -0,0 +1,3 @@
+class <%= options[:tool_call_model_name] %> < ApplicationRecord
+  <%= acts_as_tool_call_declaration %>
+end

lib/generators/ruby_llm/install_generator.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module RubyLLM
+  # Generator for RubyLLM Rails models and migrations
+  class InstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+    namespace 'ruby_llm:install'
+
+    source_root File.expand_path('install/templates', __dir__)
+
+    class_option :chat_model_name, type: :string, default: 'Chat',
+                                   desc: 'Name of the Chat model class'
+    class_option :message_model_name, type: :string, default: 'Message',
+                                      desc: 'Name of the Message model class'
+    class_option :tool_call_model_name, type: :string, default: 'ToolCall',
+                                        desc: 'Name of the ToolCall model class'
+
+    desc 'Creates model files for Chat, Message, and ToolCall, and creates migrations for RubyLLM Rails integration'
+
+    def self.next_migration_number(dirname)
+      ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+    end
+
+    def migration_version
+      "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+    end
+
+    def postgresql?
+      ActiveRecord::Base.connection.adapter_name.downcase.include?('postgresql')
+    rescue StandardError
+      false
+    end
+
+    def acts_as_chat_declaration
+      acts_as_chat_params = []
+      acts_as_chat_params << "message_class: \"#{options[:message_model_name]}\"" if options[:message_model_name]
+      acts_as_chat_params << "tool_call_class: \"#{options[:tool_call_model_name]}\"" if options[:tool_call_model_name]
+      if acts_as_chat_params.any?
+        "acts_as_chat #{acts_as_chat_params.join(', ')}"
+      else
+        'acts_as_chat'
+      end
+    end
+
+    def acts_as_message_declaration
+      acts_as_message_params = []
+      acts_as_message_params << "chat_class: \"#{options[:chat_model_name]}\"" if options[:chat_model_name]
+      if options[:tool_call_model_name]
+        acts_as_message_params << "tool_call_class: \"#{options[:tool_call_model_name]}\""
+      end
+      if acts_as_message_params.any?
+        "acts_as_message #{acts_as_message_params.join(', ')}"
+      else
+        'acts_as_message'
+      end
+    end
+
+    def acts_as_tool_call_declaration
+      acts_as_tool_call_params = []
+      acts_as_tool_call_params << "message_class: \"#{options[:message_model_name]}\"" if options[:message_model_name]
+      if acts_as_tool_call_params.any?
+        "acts_as_tool_call #{acts_as_tool_call_params.join(', ')}"
+      else
+        'acts_as_tool_call'
+      end
+    end
+
+    def create_migration_files
+      # Create migrations with timestamps to ensure proper order
+      # First create chats table
+      timestamp = Time.now.utc
+      migration_template 'create_chats_migration.rb.tt', 
+                         "db/migrate/#{timestamp.strftime('%Y%m%d%H%M%S')}_create_#{options[:chat_model_name].tableize}.rb"
+
+      # Then create tool_calls table with timestamp + 1 second
+      timestamp += 1
+      migration_template 'create_tool_calls_migration.rb.tt',
+                         "db/migrate/#{timestamp.strftime('%Y%m%d%H%M%S')}_create_#{options[:tool_call_model_name].tableize}.rb"
+
+      # Finally create messages table with timestamp + 2 seconds
+      timestamp += 1
+      migration_template 'create_messages_migration.rb.tt',
+                         "db/migrate/#{timestamp.strftime('%Y%m%d%H%M%S')}_create_#{options[:message_model_name].tableize}.rb"
+    end
+
+    def create_model_files
+      template 'chat_model.rb.tt', "app/models/#{options[:chat_model_name].underscore}.rb"
+      template 'message_model.rb.tt', "app/models/#{options[:message_model_name].underscore}.rb"
+      template 'tool_call_model.rb.tt', "app/models/#{options[:tool_call_model_name].underscore}.rb"
+    end
+
+    def create_initializer
+      template 'initializer.rb.tt', 'config/initializers/ruby_llm.rb'
+    end
+
+    def show_install_info
+      content = ERB.new(File.read(source_paths.first + '/INSTALL_INFO.md.tt')).result(binding)
+      say content
+    end
+  end
+end

lib/ruby_llm.rb

@@ -23,6 +23,7 @@
 loader.ignore("#{__dir__}/tasks")
 loader.ignore("#{__dir__}/ruby_llm/railtie")
 loader.ignore("#{__dir__}/ruby_llm/active_record")
+loader.ignore("#{__dir__}/generators")
 loader.setup
 
 # A delightful Ruby interface to modern AI language models.

lib/ruby_llm/railtie.rb

@@ -8,5 +8,16 @@ class Railtie < Rails::Railtie
         include RubyLLM::ActiveRecord::ActsAs
       end
     end
+
+    # Include rake tasks
+    rake_tasks do
+      path = File.expand_path(__dir__)
+      Dir.glob("#{path}/tasks/**/*.rake").each { |f| load f }
+    end
+
+    # Register generators
+    generators do
+      require 'generators/ruby_llm/install_generator'
+    end
   end
 end