raif 1.0.0

data/config/locales/en.yml

@@ -0,0 +1,50 @@
+---
+en:
+  raif:
+    agents:
+      errors:
+        available_model_tools:
+          too_short: must have at least 1 tool
+    common:
+      send: Send
+      there_was_an_error_generating_this_response: There was an error generating this response
+      tools: Tools
+      type_your_message: Type your message...
+    conversation:
+      initial_chat_message: Hello, how can I help you today?
+    languages:
+      ar: Arabic
+      da: Danish
+      de: German
+      en: English
+      es: Spanish
+      fi: Finnish
+      fr: French
+      he: Hebrew
+      hi: Hindi
+      it: Italian
+      ja: Japanese
+      ko: Korean
+      nl: Dutch
+      pl: Polish
+      pt: Portuguese
+      ru: Russian
+      sv: Swedish
+      th: Thai
+      tr: Turkish
+      uk: Ukrainian
+      vi: Vietnamese
+      zh: Chinese
+    model_names:
+      anthropic_claude_3_5_haiku: Anthropic Claude 3.5 Haiku
+      anthropic_claude_3_5_sonnet: Anthropic Claude 3.5 Sonnet
+      anthropic_claude_3_7_sonnet: Anthropic Claude 3.7 Sonnet
+      anthropic_claude_3_opus: Anthropic Claude 3 Opus
+      bedrock_claude_3_5_haiku: Anthropic Claude 3.5 Haiku (via AWS Bedrock)
+      bedrock_claude_3_5_sonnet: Anthropic Claude 3.5 Sonnet (via AWS Bedrock)
+      bedrock_claude_3_7_sonnet: Anthropic Claude 3.7 Sonnet (via AWS Bedrock)
+      bedrock_claude_3_opus: Anthropic Claude 3 Opus (via AWS Bedrock)
+      open_ai_gpt_3_5_turbo: OpenAI GPT-3.5 Turbo
+      open_ai_gpt_4o: OpenAI GPT-4o
+      open_ai_gpt_4o_mini: OpenAI GPT-4o Mini
+      raif_test_llm: Raif Test LLM

data/config/routes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+Raif::Engine.routes.draw do
+  resources :conversations,
+    only: [:index, :show],
+    controller: "/#{Raif.config.conversations_controller.constantize.controller_path}" do
+    resources :conversation_entries,
+      only: [:new, :create],
+      as: :entries,
+      path: "entries",
+      controller: "/#{Raif.config.conversation_entries_controller.constantize.controller_path}"
+  end
+
+  namespace :admin do
+    root to: redirect("admin/model_completions")
+    resources :tasks, only: [:index, :show]
+    resources :conversations, only: [:index, :show]
+    resources :model_completions, only: [:index, :show]
+    resources :agents, only: [:index, :show]
+    resources :model_tool_invocations, only: [:index, :show]
+  end
+end

data/db/migrate/20250224234252_create_raif_tables.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+class CreateRaifTables < ActiveRecord::Migration[8.0]
+  def change
+    json_column_type = if connection.adapter_name.downcase.include?("postgresql")
+      :jsonb
+    else
+      :json
+    end
+
+    create_table :raif_tasks do |t|
+      t.string :type, null: false, index: true
+      t.text :prompt
+      t.text :raw_response
+      t.references :creator, polymorphic: true, null: false, index: true
+      t.text :system_prompt
+      t.string :requested_language_key
+      t.integer :response_format, default: 0, null: false
+      t.datetime :started_at
+      t.datetime :completed_at
+      t.datetime :failed_at
+      t.send json_column_type, :available_model_tools, null: false
+      t.string :llm_model_key, null: false
+
+      t.timestamps
+    end
+
+    create_table :raif_conversations do |t|
+      t.string :llm_model_key, null: false
+      t.references :creator, polymorphic: true, null: false, index: true
+      t.string :requested_language_key
+      t.string :type, null: false
+      t.text :system_prompt
+      t.send json_column_type, :available_model_tools, null: false
+      t.send json_column_type, :available_user_tools, null: false
+      t.integer :conversation_entries_count, default: 0, null: false
+
+      t.timestamps
+    end
+
+    create_table :raif_conversation_entries do |t|
+      t.references :raif_conversation, null: false, foreign_key: true
+      t.references :creator, polymorphic: true, null: false, index: true
+      t.datetime :started_at
+      t.datetime :completed_at
+      t.datetime :failed_at
+      t.text :user_message
+      t.text :raw_response
+      t.text :model_response_message
+
+      t.timestamps
+    end
+
+    create_table :raif_model_tool_invocations do |t|
+      t.references :source, polymorphic: true, null: false, index: true
+      t.string :tool_type, null: false
+      t.send json_column_type, :tool_arguments, null: false
+      t.send json_column_type, :result, null: false
+      t.datetime :completed_at
+      t.datetime :failed_at
+
+      t.timestamps
+    end
+
+    create_table :raif_user_tool_invocations do |t|
+      t.references :raif_conversation_entry, null: false, foreign_key: true
+      t.string :type, null: false
+      t.send json_column_type, :tool_settings, null: false
+
+      t.timestamps
+    end
+
+    create_table :raif_agents do |t|
+      t.string :type, null: false
+      t.string :llm_model_key, null: false
+      t.text :task
+      t.text :system_prompt
+      t.text :final_answer
+      t.integer :max_iterations, default: 10, null: false
+      t.integer :iteration_count, default: 0, null: false
+      t.send json_column_type, :available_model_tools, null: false
+      t.references :creator, polymorphic: true, null: false, index: true
+      t.string :requested_language_key
+      t.datetime :started_at
+      t.datetime :completed_at
+      t.datetime :failed_at
+      t.text :failure_reason
+      t.send json_column_type, :conversation_history, null: false
+
+      t.timestamps
+    end
+
+    create_table :raif_model_completions do |t|
+      t.references :source, polymorphic: true, index: true
+      t.string :llm_model_key, null: false
+      t.string :model_api_name, null: false
+      t.send json_column_type, :available_model_tools, null: false
+      t.send json_column_type, :messages, null: false
+      t.text :system_prompt
+      t.integer :response_format, default: 0, null: false
+      t.string :response_format_parameter
+      t.decimal :temperature, precision: 5, scale: 3
+      t.integer :max_completion_tokens
+      t.integer :completion_tokens
+      t.integer :prompt_tokens
+      t.text :raw_response
+      t.send json_column_type, :response_tool_calls
+      t.integer :total_tokens
+
+      t.timestamps
+    end
+  end
+
+end

data/lib/generators/raif/agent/agent_generator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Raif
+  class AgentGenerator < Rails::Generators::NamedBase
+    source_root File.expand_path("templates", __dir__)
+    desc "Creates a new Raif::Agent subclass in app/models/raif/agents"
+
+    def create_agent
+      template "agent.rb.tt", "app/models/raif/agents/#{file_name}.rb"
+    end
+
+  private
+
+    def class_name
+      name.classify
+    end
+
+    def file_name
+      name.underscore
+    end
+  end
+end

data/lib/generators/raif/agent/templates/agent.rb.tt

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Raif
+  module Agents
+    class <%= class_name %> < Raif::Agent
+      # If you want to always include a certain set of model tools with this agent type,
+      # uncomment this callback to populate the available_model_tools attribute with your desired model tools.
+      # before_create -> {
+      #   self.available_model_tools ||= [
+      #     Raif::ModelTools::WikipediaSearchTool,
+      #     Raif::ModelTools::FetchUrlTool
+      #   ]
+      # }
+
+      # Enter your agent's system prompt here. Alternatively, you can change your agent's superclass
+      # to an existing agent types (like Raif::Agents::ReActAgent) to utilize an existing system prompt.
+      def build_system_prompt
+        # TODO: Implement your system prompt here
+      end
+
+      # Each iteration of the agent loop will generate a new Raif::ModelCompletion record and
+      # then call this method with it as an argument.
+      def process_iteration_model_completion(model_completion)
+        # TODO: Implement your iteration processing here
+      end
+    end
+  end
+end

data/lib/generators/raif/conversation/conversation_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Raif
+  module Generators
+    class ConversationGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates a new conversation type in the app/models/raif/conversations directory"
+
+      def create_conversation_file
+        template "conversation.rb.tt", File.join("app/models/raif/conversations", "#{file_name}.rb")
+      end
+
+      def create_directory
+        empty_directory "app/models/raif/conversations" unless File.directory?("app/models/raif/conversations")
+      end
+
+      def success_message
+        say_status :success, "Conversation type created successfully", :green
+        say "\nYou can now implement your conversation type in:"
+        say "  app/models/raif/conversations/#{file_name}.rb\n\n"
+        say "\nDon't forget to add it to the config.conversation_types in your Raif configuration"
+        say "For example: config.conversation_types += ['Raif::Conversations::#{class_name}']\n\n"
+      end
+    end
+  end
+end

data/lib/generators/raif/conversation/templates/conversation.rb.tt

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Raif
+  module Conversations
+    class <%= class_name %> < Raif::Conversation
+      # If you want to always include a certain set of model tools with this conversation type, 
+      # uncomment this callback to populate the available_model_tools attribute with your desired model tools.
+      # before_create -> { self.available_model_tools = ["Raif::ModelTools::Example"] }
+
+      # Override the methods below to customize the system prompt for this conversation type. 
+      # Raif::Conversation expects a JSON response with a message key from the model, so make sure your system prompt instructs the model to respond accordingly.
+      # def system_prompt_intro
+      #   Raif.config.conversation_system_prompt_intro
+      # end
+      
+      # def build_system_prompt
+      #   <<~PROMPT
+      #     #{system_prompt_intro}
+      #
+      #     # Your Responses
+      #     Your responses should always be in JSON format with a "message" field containing your response to your collaborator. For example:
+      #     {
+      #       "message": "Your response message"
+      #     }
+      #     #{tool_usage_system_prompt}
+      #     #{system_prompt_reminders}
+      #     #{system_prompt_language_preference}
+      #   PROMPT
+      # end
+
+      # Override this method to set the initial message shown to the user.
+      # def initial_chat_message
+      #   I18n.t("#{self.class.name.underscore.gsub("/", ".")}.initial_chat_message")
+      # end
+    end
+  end
+end 

data/lib/generators/raif/install/install_generator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/migration"
+
+module Raif
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      def self.next_migration_number(path)
+        next_migration_number = current_migration_number(path) + 1
+        ActiveRecord::Migration.next_migration_number(next_migration_number)
+      end
+
+      def copy_initializer
+        template "initializer.rb", "config/initializers/raif.rb"
+      end
+
+      def install_migrations
+        rake "raif:install:migrations"
+      end
+
+      def add_engine_route
+        route 'mount Raif::Engine => "/raif"'
+      end
+    end
+  end
+end

data/lib/generators/raif/install/templates/initializer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+Raif.configure do |config|
+  # Your OpenAI API key. Defaults to ENV["OPENAI_API_KEY"]
+  # config.open_ai_api_key = ENV["OPENAI_API_KEY"]
+
+  # Whether OpenAI models are enabled. Defaults to true
+  # config.open_ai_models_enabled = true
+
+  # Your Anthropic API key. Defaults to ENV["ANTHROPIC_API_KEY"]
+  # config.anthropic_api_key = ENV["ANTHROPIC_API_KEY"]
+
+  # Whether Anthropic models are enabled. Defaults to true
+  # config.anthropic_models_enabled = true
+
+  # Whether Anthropic models via AWS Bedrock are enabled. Defaults to true
+  # config.anthropic_bedrock_models_enabled = true
+
+  # The AWS Bedrock region to use. Defaults to "us-east-1"
+  # config.aws_bedrock_region = "us-east-1"
+
+  # The default LLM model to use. Defaults to "open_ai_gpt_4o"
+  # Available keys:
+  #   open_ai_gpt_4o_mini
+  #   open_ai_gpt_4o
+  #   open_ai_gpt_3_5_turbo
+  #   anthropic_claude_3_7_sonnet
+  #   anthropic_claude_3_5_sonnet
+  #   anthropic_claude_3_5_haiku
+  #   anthropic_claude_3_opus
+  #   bedrock_claude_3_5_sonnet
+  #   bedrock_claude_3_7_sonnet
+  #   bedrock_claude_3_5_haiku
+  #   bedrock_claude_3_opus
+  # config.default_llm_model_key = "open_ai_gpt_4o"
+
+  # A lambda that returns true if the current user is authorized to access admin controllers.
+  # By default it returns false, so you must implement this in your application to use the admin controllers.
+  # If your application's user model has an admin? method, you could use something like this:
+  # config.authorize_admin_controller_action = ->{ current_user&.admin? }
+
+  # A lambda that returns true if the current user is authorized to access non-admin controllers.
+  # By default it returns false, so you must implement this in your application to use the non-admin controllers.
+  # If you wanted to allow access to all logged in users, you could use something like this:
+  # config.authorize_controller_action = ->{ current_user.present? }
+
+  # The system prompt intro for Raif::Task instances. Defaults to "You are a helpful assistant."
+  # config.task_system_prompt_intro = "You are a helpful assistant."
+
+  # The system prompt intro for Raif::Conversation instances. Defaults to "You are a helpful assistant who is collaborating with a teammate."
+  # config.conversation_system_prompt_intro = "You are a helpful assistant who is collaborating with a teammate."
+
+  # The conversation types that are available. Defaults to ["Raif::Conversation"]
+  # If you want to use custom conversation types that inherits from Raif::Conversation, you can add them here.
+  # config.conversation_types += ["Raif::MyConversation"]
+
+  # The controller class for conversations. Defaults to "Raif::ConversationsController"
+  # If you want to use a custom controller that inherits from Raif::ConversationsController, you can set it here.
+  # config.conversations_controller = "Raif::ConversationsController"
+
+  # The controller class for conversation entries. Defaults to "Raif::ConversationEntriesController"
+  # If you want to use a custom controller that inherits from Raif::ConversationEntriesController, you can set it here.
+  # config.conversation_entries_controller = "Raif::ConversationEntriesController"
+
+  # The method to call to get the current user. Defaults to :current_user
+  # config.current_user_method = :current_user
+
+  # The agent types that are available. Defaults to Set.new(["Raif::Agents::ReActAgent", "Raif::Agents::NativeToolCallingAgent"])
+  # If you want to use custom agent types that inherits from Raif::Agent, you can add them here.
+  # config.agent_types += ["MyAgent"]
+
+  # The superclass for Raif models. Defaults to "ApplicationRecord"
+  # config.model_superclass = "ApplicationRecord"
+
+  # The user tool types that are available. Defaults to []
+  # config.user_tool_types = []
+
+  # Whether LLM API requests are enabled. Defaults to true.
+  # Use this to globally disable requests to LLM APIs.
+  # config.llm_api_requests_enabled = true
+end

data/lib/generators/raif/model_tool/model_tool_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Raif
+  module Generators
+    class ModelToolGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates a new model tool for the LLM to invoke in app/models/raif/model_tools"
+
+      def create_model_tool_file
+        template "model_tool.rb.tt", File.join("app/models/raif/model_tools", "#{file_name}.rb")
+      end
+
+      def success_message
+        say_status :success, "Model tool created successfully", :green
+        say "\nYou can now implement your model tool in:"
+        say "  app/models/raif/model_tools/#{file_name}.rb"
+        say "\nImportant methods to implement:"
+        say "  - example_model_invocation: An example of how to invoke the tool, to be provided to the LLM"
+        say "  - tool_arguments_schema: JSON schema for validating arguments when the tool is invoked"
+        say "  - tool_description: A brief description of what the tool does, to be provided to the LLM"
+        say "  - process_invocation: The main method that executes the tool's functionality"
+      end
+
+    end
+  end
+end

data/lib/generators/raif/model_tool/templates/model_tool.rb.tt

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+class Raif::ModelTools::<%= class_name %> < Raif::ModelTool
+  # For example tool implementations, see: 
+  # Wikipedia Search Tool: https://github.com/CultivateLabs/raif/blob/main/app/models/raif/model_tools/wikipedia_search_tool.rb
+  # Fetch URL Tool: https://github.com/CultivateLabs/raif/blob/main/app/models/raif/model_tools/fetch_url_tool.rb
+
+  # An example of how the LLM should invoke your tool. This should return a hash with name and arguments keys.
+  # `to_json` will be called on it and provided to the LLM as an example of how to invoke your tool.
+  def self.example_model_invocation
+    {
+      "name": tool_name,
+      "arguments": { }
+    }
+  end
+
+  # Define your tool's argument schema here. It should be a valid JSON schema.
+  # When the model invokes your tool, the arguments it provides will be validated
+  # against this schema using JSON::Validator from the json-schema gem.
+  def self.tool_arguments_schema
+    # For example:
+    # {
+    #   type: "object",
+    #   additionalProperties: false,
+    #   required: ["query"],
+    #   properties: {
+    #     query: {
+    #       type: "string",
+    #       description: "The query to search for"
+    #     }
+    #   }
+    # }
+    # Would expect the model to invoke your tool with an arguments JSON object like:
+    # { "query" : "some query here" }
+  end
+
+  def self.tool_description
+    "Description of your tool that will be provided to the LLM so it knows when to invoke it"
+  end
+
+  # When your tool is invoked by the LLM in a Raif::Agent loop, 
+  # the results of the tool invocation are provided back to the LLM as an observation.
+  # This method should return whatever you want provided to the LLM.
+  # For example, if you were implementing a GoogleSearch tool, this might return a JSON
+  # object containing search results for the query.
+  def self.observation_for_invocation(tool_invocation)
+    return "No results found" unless tool_invocation.result.present?
+
+    JSON.pretty_generate(tool_invocation.result)
+  end
+
+  # When the LLM invokes your tool, this method will be called with a `Raif::ModelToolInvocation` record as an argument.
+  # It should handle the actual execution of the tool. 
+  # For example, if you are implementing a GoogleSearch tool, this method should run the actual search
+  # and store the results in the tool_invocation's result JSON column.
+  def self.process_invocation(tool_invocation)
+    # Extract arguments from tool_invocation.tool_arguments
+    # query = tool_invocation.tool_arguments["query"]
+    #
+    # Process the invocation and perform the desired action
+    # ...
+    #
+    # Store the results in the tool_invocation
+    # tool_invocation.update!(
+    #   result: {
+    #     # Your result data structure
+    #   }
+    # )
+    #
+    # Return the result
+    # tool_invocation.result
+  end
+
+end

data/lib/generators/raif/task/task_generator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Raif
+  module Generators
+    class TaskGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      class_option :response_format,
+        type: :string,
+        default: "text",
+        desc: "Response format for the task (text, html, or json)"
+
+      def create_application_task
+        template "application_task.rb.tt", "app/models/raif/application_task.rb" unless File.exist?("app/models/raif/application_task.rb")
+      end
+
+      def create_task_file
+        template "task.rb.tt", File.join("app/models/raif/tasks", class_path, "#{file_name}.rb")
+      end
+
+    private
+
+      def task_class_name
+        class_name
+      end
+    end
+  end
+end

data/lib/generators/raif/task/templates/application_task.rb.tt

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Raif
+  class ApplicationTask < Raif::Task
+    # Add any shared task behavior here
+  end
+end

data/lib/generators/raif/task/templates/task.rb.tt

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Raif
+  module Tasks
+    class <%= task_class_name %> < Raif::ApplicationTask
+      # Set the response format for the task. Options are :html, :text, or :json.
+      llm_response_format :<%= options[:response_format] %>
+
+      # Define any attributes that are needed for the task.
+      # You can then pass them when running the task and they will be available in build_prompt:
+      # Raif::Tasks::<%= task_class_name %>.run(your_attribute: "some value")
+      # attr_accessor :your_attribute
+
+      <%- if options[:response_format] == "json" -%>
+      # Define a JSON schema that the response should adhere to
+      # def self.json_response_schema
+      #   {
+      #     type: "object",
+      #     additionalProperties: false,
+      #     required: ["your_key_here"],
+      #     properties: {
+      #       your_key_here: {
+      #         type: "array",
+      #         items: {
+      #           type: "object",
+      #           additionalProperties: false,
+      #           required: ["query", "rationale"],
+      #           properties: {
+      #             query: { type: "string" },
+      #             rationale: { type: "string" }
+      #           }
+      #         }
+      #       }
+      #     }
+      #   }
+      # end
+      <%- end -%>
+
+      def build_prompt
+        # Implement the LLM prompt for this task.
+        raise NotImplementedError, "Implement #build_prompt in #{self.class}"
+      end
+
+      # Optional: Override build_system_prompt if you need custom system instructions.
+      # The default implementation, which you'll get if you call super, will use Raif.config.task_system_prompt_intro 
+      # and append the system_prompt_language_preference if the task's requested_language_key is set.
+      # def build_system_prompt
+      #   super + "\nAdditional system instructions..."
+      # end
+    end
+  end
+end

data/lib/generators/raif/views_generator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Raif
+  class ViewsGenerator < Rails::Generators::Base
+    source_root File.expand_path("../../../app/views/raif", __dir__)
+
+    desc "Copies Raif conversation views to your application for customization"
+
+    def copy_views
+      directory "conversations", "app/views/raif/conversations"
+      directory "conversation_entries", "app/views/raif/conversation_entries"
+    end
+
+    def success_message
+      say_status :success, "Raif conversation views have been copied to your application", :green
+      say "\nYou can now customize these views in:"
+      say "  app/views/raif/conversations/"
+      say "  app/views/raif/conversation_entries/"
+      say "\nNote: These views will now override the default Raif engine views."
+    end
+  end
+end