raif 1.0.0 → 1.1.0

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

@@ -1,74 +1,87 @@
 # 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
+  # For example tool implementations, see:
+  # Wikipedia Search Tool: https://github.com/CultivateLabs/raif/blob/main/app/models/raif/model_tools/wikipedia_search.rb
+  # Fetch URL Tool: https://github.com/CultivateLabs/raif/blob/main/app/models/raif/model_tools/fetch_url.rb
+
+  tool_description do
+    "Description of your tool that will be provided to the LLM so it knows when to invoke it"
+  end
+
+  # Define the schema for the arguments that the LLM should use when invoking your tool.
+  # 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.
+  #
+  # All attributes will be required and additionalProperties will be set to false.
+  tool_arguments_schema do
+    # string :title, description: "The title of the operation", minLength: 3
+    #
+    # object :widget, description: "A widget's description" do
+    #   boolean :is_red, description: "Whether the widget is red"
+    #   integer :rating, description: "A rating of the widget from 1 to 10", minimum: 1, maximum: 10
+    #   array :tags, description: "Associated tags" do
+    #     items type: "string"
+    #   end
+    # end
+    #
+    # array :products, description: "List of products" do
+    #   object do
+    #     integer :id, description: "Product identifier"
+    #     string :name, description: "Product name"
+    #     number :price, description: "Product price", minimum: 0
+    #   end
+    # end
+  end
 
   # 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
+  example_model_invocation do
     {
       "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
+  class << self
+    # 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 observation_for_invocation(tool_invocation)
+      return "No results found" unless tool_invocation.result.present?
 
-  def self.tool_description
-    "Description of your tool that will be provided to the LLM so it knows when to invoke it"
-  end
+      JSON.pretty_generate(tool_invocation.result)
+    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 your tool is invoked in a Raif::Conversation, should the result be automatically provided back to the model?
+    # When true, observation_for_invocation will be used to produce the observation provided to the model
+    def triggers_observation_to_model?
+      false
+    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
+    # 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 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
 
 end

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

@@ -6,39 +6,50 @@ module Raif
       # Set the response format for the task. Options are :html, :text, or :json.
       llm_response_format :<%= options[:response_format] %>
 
+      # Set the temperature for the task
+      # llm_temperature 0.7
+
+      # Optional: Set the allowed tags for the task. Only relevant if response_format is :html.
+      # Defaults to Rails::HTML5::SafeListSanitizer.allowed_tags
+      # llm_response_allowed_tags %w[p b i div strong]
+
+      # Optional: Set the allowed attributes for the task. Only relevant if response_format is :html.
+      # Defaults to Rails::HTML5::SafeListSanitizer.allowed_attributes
+      # llm_response_allowed_attributes %w[style]
+
       # 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
+      # Define a JSON schema that the model's response should adhere to
+      #
+      # All attributes will be required and additionalProperties will be set to false.
+      json_response_schema do
+        # string :title, description: "The title of the operation", minLength: 3
+        #
+        # object :widget, description: "A widget's description" do
+        #   boolean :is_red, description: "Whether the widget is red"
+        #   integer :rating, description: "A rating of the widget from 1 to 10", minimum: 1, maximum: 10
+        #   array :tags, description: "Associated tags" do
+        #     items type: "string"
+        #   end
+        # end
+        #
+        # array :products, description: "List of products" do
+        #   object do
+        #     integer :id, description: "Product identifier"
+        #     string :name, description: "Product name"
+        #     number :price, description: "Product price", minimum: 0
+        #   end
+        # end
+      end
       <%- end -%>
 
       def build_prompt
         # Implement the LLM prompt for this task.
-        raise NotImplementedError, "Implement #build_prompt in #{self.class}"
+        raise NotImplementedError, "Implement #build_prompt in #{self.class.name}"
       end
 
       # Optional: Override build_system_prompt if you need custom system instructions.

data/lib/raif/configuration.rb

@@ -10,16 +10,25 @@ module Raif
       :authorize_controller_action,
       :aws_bedrock_model_name_prefix,
       :aws_bedrock_region,
+      :aws_bedrock_titan_embedding_models_enabled,
       :conversation_entries_controller,
       :conversation_system_prompt_intro,
       :conversation_types,
       :conversations_controller,
       :current_user_method,
+      :default_embedding_model_key,
       :default_llm_model_key,
       :llm_api_requests_enabled,
+      :llm_request_max_retries,
+      :llm_request_retriable_exceptions,
       :model_superclass,
       :open_ai_api_key,
+      :open_ai_embedding_models_enabled,
       :open_ai_models_enabled,
+      :open_router_api_key,
+      :open_router_models_enabled,
+      :open_router_app_name,
+      :open_router_site_url,
       :task_system_prompt_intro,
       :user_tool_types
 
@@ -27,23 +36,36 @@ module Raif
       # Set default config
       @agent_types = Set.new(["Raif::Agents::ReActAgent", "Raif::Agents::NativeToolCallingAgent"])
       @anthropic_api_key = ENV["ANTHROPIC_API_KEY"]
-      @anthropic_bedrock_models_enabled = true
-      @anthropic_models_enabled = true
+      @anthropic_bedrock_models_enabled = false
+      @anthropic_models_enabled = ENV["ANTHROPIC_API_KEY"].present?
       @authorize_admin_controller_action = ->{ false }
       @authorize_controller_action = ->{ false }
       @aws_bedrock_region = "us-east-1"
       @aws_bedrock_model_name_prefix = "us"
+      @aws_bedrock_titan_embedding_models_enabled = false
       @task_system_prompt_intro = "You are a helpful assistant."
       @conversation_entries_controller = "Raif::ConversationEntriesController"
       @conversation_system_prompt_intro = "You are a helpful assistant who is collaborating with a teammate."
       @conversation_types = Set.new(["Raif::Conversation"])
       @conversations_controller = "Raif::ConversationsController"
       @current_user_method = :current_user
+      @default_embedding_model_key = "open_ai_text_embedding_3_small"
       @default_llm_model_key = "open_ai_gpt_4o"
       @llm_api_requests_enabled = true
+      @llm_request_max_retries = 2
+      @llm_request_retriable_exceptions = [
+        Faraday::ConnectionFailed,
+        Faraday::TimeoutError,
+        Faraday::ServerError,
+      ]
       @model_superclass = "ApplicationRecord"
       @open_ai_api_key = ENV["OPENAI_API_KEY"]
-      @open_ai_models_enabled = true
+      @open_ai_embedding_models_enabled = ENV["OPENAI_API_KEY"].present?
+      @open_ai_models_enabled = ENV["OPENAI_API_KEY"].present?
+      @open_router_api_key = ENV["OPENROUTER_API_KEY"]
+      @open_router_models_enabled = ENV["OPENROUTER_API_KEY"].present?
+      @open_router_app_name = nil
+      @open_router_site_url = nil
       @user_tool_types = []
     end
 
@@ -53,6 +75,11 @@ module Raif
           "Raif.config.default_llm_model_key was set to #{default_llm_model_key}, but must be one of: #{Raif.available_llm_keys.join(", ")}"
       end
 
+      unless Raif.available_embedding_model_keys.include?(default_embedding_model_key.to_sym)
+        raise Raif::Errors::InvalidConfigError,
+          "Raif.config.default_embedding_model_key was set to #{default_embedding_model_key}, but must be one of: #{Raif.available_embedding_model_keys.join(", ")}" # rubocop:disable Layout/LineLength
+      end
+
       if authorize_controller_action.respond_to?(:call)
         authorize_controller_action.freeze
       else
@@ -72,10 +99,20 @@ module Raif
           "Raif.config.open_ai_api_key is required when Raif.config.open_ai_models_enabled is true. Set it via Raif.config.open_ai_api_key or ENV[\"OPENAI_API_KEY\"]" # rubocop:disable Layout/LineLength
       end
 
+      if open_ai_embedding_models_enabled && open_ai_api_key.blank?
+        raise Raif::Errors::InvalidConfigError,
+          "Raif.config.open_ai_api_key is required when Raif.config.open_ai_embedding_models_enabled is true. Set it via Raif.config.open_ai_api_key or ENV[\"OPENAI_API_KEY\"]" # rubocop:disable Layout/LineLength
+      end
+
       if anthropic_models_enabled && anthropic_api_key.blank?
         raise Raif::Errors::InvalidConfigError,
           "Raif.config.anthropic_api_key is required when Raif.config.anthropic_models_enabled is true. Set it via Raif.config.anthropic_api_key or ENV['ANTHROPIC_API_KEY']" # rubocop:disable Layout/LineLength
       end
+
+      if open_router_models_enabled && open_router_api_key.blank?
+        raise Raif::Errors::InvalidConfigError,
+          "Raif.config.open_router_api_key is required when Raif.config.open_router_models_enabled is true. Set it via Raif.config.open_router_api_key or ENV['OPENROUTER_API_KEY']" # rubocop:disable Layout/LineLength
+      end
     end
 
   end

data/lib/raif/embedding_model_registry.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Raif
+  class << self
+    attr_accessor :embedding_model_registry
+  end
+
+  def self.generate_embedding!(input, dimensions: nil)
+    embedding_model = embedding_model(default_embedding_model_key.to_sym)
+    embedding_model.generate_embedding!(input, dimensions:)
+  end
+
+  def self.default_embedding_model_key
+    Rails.env.test? ? :raif_test_embedding_model : Raif.config.default_embedding_model_key
+  end
+
+  def self.register_embedding_model(embedding_model_class, embedding_model_config)
+    embedding_model = embedding_model_class.new(**embedding_model_config)
+
+    unless embedding_model.valid?
+      raise ArgumentError, "The embedding model you tried to register is invalid: #{embedding_model.errors.full_messages.join(", ")}"
+    end
+
+    @embedding_model_registry ||= {}
+    @embedding_model_registry[embedding_model.key] = embedding_model_config.merge(embedding_model_class: embedding_model_class)
+  end
+
+  def self.embedding_model(model_key)
+    embedding_model_config = embedding_model_registry[model_key]
+
+    if embedding_model_config.nil?
+      raise ArgumentError, "No embedding model found for model key: #{model_key}. Available models: #{available_embedding_model_keys.join(", ")}"
+    end
+
+    embedding_model_class = embedding_model_config[:embedding_model_class]
+    embedding_model_class.new(**embedding_model_config.except(:embedding_model_class))
+  end
+
+  def self.available_embedding_models
+    embedding_model_registry.values
+  end
+
+  def self.available_embedding_model_keys
+    embedding_model_registry.keys
+  end
+
+  def self.embedding_model_config(model_key)
+    embedding_model_registry[model_key]
+  end
+
+  def self.default_embedding_models
+    {
+      Raif::EmbeddingModels::OpenAi => [
+        {
+          key: :open_ai_text_embedding_3_large,
+          api_name: "text-embedding-3-large",
+          input_token_cost: 0.13 / 1_000_000,
+          default_output_vector_size: 3072,
+        },
+        {
+          key: :open_ai_text_embedding_3_small,
+          api_name: "text-embedding-3-small",
+          input_token_cost: 0.02 / 1_000_000,
+          default_output_vector_size: 1536,
+        },
+        {
+          key: :open_ai_text_embedding_ada_002,
+          api_name: "text-embedding-ada-002",
+          input_token_cost: 0.01 / 1_000_000,
+          default_output_vector_size: 1536,
+        },
+      ],
+      Raif::EmbeddingModels::BedrockTitan => [
+        {
+          key: :bedrock_titan_embed_text_v2,
+          api_name: "amazon.titan-embed-text-v2:0",
+          input_token_cost: 0.01 / 1_000_000,
+          default_output_vector_size: 1024,
+        },
+      ]
+    }
+  end
+end

data/lib/raif/engine.rb

@@ -34,6 +34,14 @@ module Raif
       end
     end
 
+    config.after_initialize do
+      next unless Raif.config.open_ai_embedding_models_enabled
+
+      Raif.default_embedding_models[Raif::EmbeddingModels::OpenAi].each do |embedding_model_config|
+        Raif.register_embedding_model(Raif::EmbeddingModels::OpenAi, **embedding_model_config)
+      end
+    end
+
     config.after_initialize do
       next unless Raif.config.anthropic_models_enabled
 
@@ -45,7 +53,6 @@ module Raif
     config.after_initialize do
       next unless Raif.config.anthropic_bedrock_models_enabled
 
-      require "aws-sdk-bedrock"
       require "aws-sdk-bedrockruntime"
 
       Raif.default_llms[Raif::Llms::BedrockClaude].each do |llm_config|
@@ -53,6 +60,24 @@ module Raif
       end
     end
 
+    config.after_initialize do
+      next unless Raif.config.open_router_models_enabled
+
+      Raif.default_llms[Raif::Llms::OpenRouter].each do |llm_config|
+        Raif.register_llm(Raif::Llms::OpenRouter, **llm_config)
+      end
+    end
+
+    config.after_initialize do
+      next unless Raif.config.aws_bedrock_titan_embedding_models_enabled
+
+      require "aws-sdk-bedrockruntime"
+
+      Raif.default_embedding_models[Raif::EmbeddingModels::BedrockTitan].each do |embedding_model_config|
+        Raif.register_embedding_model(Raif::EmbeddingModels::BedrockTitan, **embedding_model_config)
+      end
+    end
+
     config.after_initialize do
       next unless Rails.env.test?
 
@@ -60,6 +85,14 @@ module Raif
 
       require "#{Raif::Engine.root}/spec/support/test_llm"
       Raif.register_llm(Raif::Llms::Test, key: :raif_test_llm, api_name: "raif-test-llm")
+
+      require "#{Raif::Engine.root}/spec/support/test_embedding_model"
+      Raif.register_embedding_model(
+        Raif::EmbeddingModels::Test,
+        key: :raif_test_embedding_model,
+        api_name: "raif-test-embedding-model",
+        default_output_vector_size: 1536
+      )
     end
 
     config.after_initialize do

data/lib/raif/errors/{open_ai/api_error.rb → invalid_model_file_input_error.rb}

@@ -2,9 +2,7 @@
 
 module Raif
   module Errors
-    module OpenAi
-      class ApiError < StandardError
-      end
+    class InvalidModelFileInputError < StandardError
     end
   end
 end

data/lib/raif/errors/{anthropic/api_error.rb → invalid_model_image_input_error.rb}

@@ -2,9 +2,7 @@
 
 module Raif
   module Errors
-    module Anthropic
-      class ApiError < StandardError
-      end
+    class InvalidModelImageInputError < StandardError
     end
   end
 end

data/lib/raif/errors/unsupported_feature_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Raif
+  module Errors
+    class UnsupportedFeatureError < StandardError
+    end
+  end
+end

data/lib/raif/errors.rb

@@ -5,5 +5,6 @@ require "raif/errors/action_not_authorized_error"
 require "raif/errors/invalid_user_tool_type_error"
 require "raif/errors/invalid_conversation_type_error"
 require "raif/errors/open_ai/json_schema_error"
-require "raif/errors/open_ai/api_error"
-require "raif/errors/anthropic/api_error"
+require "raif/errors/invalid_model_image_input_error"
+require "raif/errors/invalid_model_file_input_error"
+require "raif/errors/unsupported_feature_error"

data/lib/raif/json_schema_builder.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Raif
+  class JsonSchemaBuilder
+    attr_reader :properties, :required_properties, :items_schema
+
+    def initialize
+      @properties = {}
+      @required_properties = []
+      @items_schema = nil
+    end
+
+    def string(name, options = {})
+      add_property(name, "string", options)
+    end
+
+    def integer(name, options = {})
+      add_property(name, "integer", options)
+    end
+
+    def number(name, options = {})
+      add_property(name, "number", options)
+    end
+
+    def boolean(name, options = {})
+      add_property(name, "boolean", options)
+    end
+
+    def object(name = nil, options = {}, &block)
+      schema = {}
+
+      if block_given?
+        nested_builder = self.class.new
+        nested_builder.instance_eval(&block)
+
+        schema[:properties] = nested_builder.properties
+        schema[:additionalProperties] = false
+
+        # We currently use strict mode, which means that all properties are required
+        schema[:required] = nested_builder.required_properties
+      end
+
+      # If name is nil, we're inside an array and should return the schema directly
+      if name.nil?
+        @items_schema = { type: "object" }.merge(schema)
+      else
+        add_property(name, "object", options.merge(schema))
+      end
+    end
+
+    def array(name, options = {}, &block)
+      items_schema = options.delete(:items) || {}
+
+      if block_given?
+        nested_builder = self.class.new
+        nested_builder.instance_eval(&block)
+
+        # If items were directly set using the items method
+        if nested_builder.items_schema.present?
+          items_schema = nested_builder.items_schema
+        # If there are properties defined, it's an object schema
+        elsif nested_builder.properties.any?
+          items_schema = {
+            type: "object",
+            properties: nested_builder.properties,
+            additionalProperties: false
+          }
+
+          # We currently use strict mode, which means that all properties are required
+          items_schema[:required] = nested_builder.required_properties
+        end
+      end
+
+      options[:items] = items_schema unless items_schema.empty?
+      add_property(name, "array", options)
+    end
+
+    # Allow setting array items directly
+    def items(options = {})
+      @items_schema = options
+    end
+
+    def to_schema
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: @properties,
+        required: @required_properties
+      }
+    end
+
+  private
+
+    def add_property(name, type, options = {})
+      property = { type: type }
+
+      # We currently use strict mode, which means that all properties are required
+      @required_properties << name.to_s
+
+      property.merge!(options)
+      @properties[name] = property
+    end
+  end
+end