rager 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b4311f3da8c6cf4e479c8c951322e329b4f4d697a8f78c6b2945b89793a2903
-  data.tar.gz: b92e1be42bcf7a769da8d1164f0dcd0d3108249bf3e1266cf1f2b0612bdab69f
+  metadata.gz: 32cd931dd6c3c714456232f7aeb15743580a605330051a31c4167a0435e8d766
+  data.tar.gz: bd28897b484c9b6d0972b229b6fe834eb532b1027baf855b33ac9940df303c8a
 SHA512:
-  metadata.gz: 7bb128546a71dc3e61e28d7c7ffbbfaa7dfdbf1f3b5236de89eb7c9069cb94d45ca5b3336650ee4e7d29a9cfbb8b4a88ead87134ff0b781aba08c3c90ce5b00d
-  data.tar.gz: bcdb5dbd47c1fc6f7014e321349aa95102c6cd1492872755afe5ca32101d7cd9aa68b24c4eb98021c2cd19edc44479121c01f5ce118f4b539ffc39a5979019cb
+  metadata.gz: 9b98958d909a001eb2f21a65e1186a473fa5c11e1e86255e0d9c9cfdd535b3ce6131c90c1fa9b5665fe4831f168860d49e399b9b25d0bcd179b2a022e9db8d7a
+  data.tar.gz: 70d77abac363b663d6b82636b93af19bddf02f37570599e6df71e6a2f0f30fbb309d87b2f8431bdf4106bf9e3559448579b66ac8cd2cb34eca2b3ccca0f98bbe

data/README.md

@@ -1,6 +1,9 @@
 # rager_rb
 
-[![test](https://github.com/mvkvc/rager_rb/actions/workflows/test.yaml/badge.svg)](https://github.com/mvkvc/rager_rb/actions/workflows/test.yaml)
+[![gem](https://badge.fury.io/rb/rager.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/rager)
+[![publish](https://github.com/mvkvc/rager_rb/actions/workflows/publish.yml/badge.svg?branch=main)](https://github.com/mvkvc/rager_rb/actions/workflows/publish.yml)
+[![test](https://github.com/mvkvc/rager_rb/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/mvkvc/rager_rb/actions/workflows/test.yml)
+[![lint](https://github.com/mvkvc/rager_rb/actions/workflows/lint.yml/badge.svg?branch=main)](https://github.com/mvkvc/rager_rb/actions/workflows/lint.yml)
 
 Build continuously improving AI applications.
 
@@ -15,7 +18,7 @@ bundle add rager
 Otherwise you can add it to your Gemfile directly:
 
 ```Ruby
-gem "rager", "~> 0.1.0"
+gem "rager", "~> 0.2.0"
 ```
 
 ## License

data/lib/rager/chat/providers/openai.rb

@@ -23,7 +23,7 @@ module Rager
           raise Rager::Errors::MissingCredentialsError.new("OpenAI", "OPENAI_API_KEY") if api_key.nil?
 
           url = options.url || ENV["OPENAI_URL"] || "https://api.openai.com/v1/chat/completions"
-          model = options.model || "gpt-4o"
+          model = options.model || "gpt-4.1"
 
           openai_messages = build_openai_messages(messages, options.history, options.system_prompt)
 

data/lib/rager/context.rb

@@ -44,6 +44,25 @@ module Rager
       ) { |options| Chat.chat(messages, options) }
     end
 
+    sig do
+      params(
+        text: T.any(String, T::Array[String]),
+        kwargs: T.untyped
+      ).returns(Rager::Result)
+    end
+    def embed(text, **kwargs)
+      if text.is_a?(String)
+        text = [text]
+      end
+
+      execute(
+        Rager::Operation::Embed,
+        Rager::Embed::Options,
+        kwargs,
+        text
+      ) { |options| Embed.embed(text, options) }
+    end
+
     sig do
       params(
         prompt: String,
@@ -74,6 +93,51 @@ module Rager
       ) { |options| MeshGen.mesh_gen(prompt, options) }
     end
 
+    sig do
+      params(
+        query: Rager::Rerank::Query,
+        kwargs: T.untyped
+      ).returns(Rager::Result)
+    end
+    def rerank(query, **kwargs)
+      execute(
+        Rager::Operation::Rerank,
+        Rager::Rerank::Options,
+        kwargs,
+        query
+      ) { |options| Rager::Rerank.rerank(query, options) }
+    end
+
+    sig do
+      params(
+        query: String,
+        kwargs: T.untyped
+      ).returns(Rager::Result)
+    end
+    def search(query, **kwargs)
+      execute(
+        Rager::Operation::Search,
+        Rager::Search::Options,
+        kwargs,
+        query
+      ) { |options| Search.search(query, options) }
+    end
+
+    sig do
+      params(
+        input: Rager::Template::Input,
+        kwargs: T.untyped
+      ).returns(Rager::Result)
+    end
+    def template(input, **kwargs)
+      execute(
+        Rager::Operation::Template,
+        Rager::Template::Options,
+        kwargs,
+        input
+      ) { |options| Template.template(input, options) }
+    end
+
     private
 
     sig do
@@ -81,11 +145,13 @@ module Rager
         operation: Rager::Operation,
         options_struct: T::Class[Rager::Options],
         kwargs: T.untyped,
-        input: T.any(String, T::Array[Rager::Chat::Message]),
+        input: Rager::Types::Input,
         block: T.proc.params(options: T.untyped).returns(T.untyped)
       ).returns(Rager::Result)
     end
     def execute(operation, options_struct, kwargs, input, &block)
+      input_ids = kwargs.delete(:input_ids)
+
       options = options_struct.new(**kwargs)
       options.validate
 
@@ -94,6 +160,7 @@ module Rager
       output = yield(options)
 
       Result.new(
+        id: @id,
         context_id: @id,
         hash: @hash,
         operation: operation,
@@ -101,12 +168,11 @@ module Rager
         options: options,
         start_time: start_time.to_i,
         end_time: Time.now.to_i,
-        output: output
-      ).tap { |r| r.log }
+        output: output,
+        input_ids: input_ids
+      ).tap(&:log)
     end
 
-    private
-
     sig { returns(T.nilable(String)) }
     def lookup_git_hash
       result = `git rev-parse HEAD`

data/lib/rager/embed/options.rb

@@ -0,0 +1,30 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Embed
+    class Options < T::Struct
+      extend T::Sig
+      include Rager::Options
+
+      const :provider, String, default: "openai"
+      const :url, T.nilable(String)
+      const :model, T.nilable(String)
+      const :api_key, T.nilable(String)
+      const :seed, T.nilable(Integer)
+
+      sig { override.returns(T::Hash[String, T.untyped]) }
+      def serialize_safe
+        result = serialize
+        result["api_key"] = "[REDACTED]" if result.key?("api_key")
+        result
+      end
+
+      sig { override.void }
+      def validate
+      end
+    end
+  end
+end

data/lib/rager/embed/providers/abstract.rb

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Embed
+    module Providers
+      class Abstract
+        extend T::Sig
+        extend T::Helpers
+        abstract!
+
+        sig do
+          abstract.params(
+            text: T::Array[String],
+            options: Rager::Embed::Options
+          ).returns(Rager::Types::EmbedOutput)
+        end
+        def embed(text, options)
+        end
+      end
+    end
+  end
+end

data/lib/rager/embed/providers/openai.rb

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "json"
+require "sorbet-runtime"
+
+module Rager
+  module Embed
+    module Providers
+      class Openai < Rager::Embed::Providers::Abstract
+        extend T::Sig
+
+        sig do
+          override.params(
+            text: T::Array[String],
+            options: Rager::Embed::Options
+          ).returns(Rager::Types::EmbedOutput)
+        end
+        def embed(text, options)
+          api_key = options.api_key || ENV["OPENAI_API_KEY"]
+          raise Rager::Errors::MissingCredentialsError.new("OpenAI", "OPENAI_API_KEY") if api_key.nil?
+
+          url = options.url || ENV["OPENAI_URL"] || "https://api.openai.com/v1/embeddings"
+          model = options.model || "text-embedding-3-large"
+
+          headers = {
+            "Content-Type" => "application/json"
+          }
+          headers["Authorization"] = "Bearer #{api_key}" if api_key
+
+          body = {
+            model: model,
+            input: text
+          }
+
+          request = Rager::Http::Request.new(
+            verb: Rager::Http::Verb::Post,
+            url: url,
+            headers: headers,
+            body: body.to_json
+          )
+
+          http_adapter = Rager.config.http_adapter
+          response = http_adapter.make_request(request)
+          response_body = T.cast(T.must(response.body), String)
+
+          if response.status != 200
+            raise Rager::Errors::HttpError.new(
+              http_adapter,
+              response.status,
+              response_body
+            )
+          end
+
+          parsed_response = JSON.parse(response_body)
+          parsed_response["data"].map { |item| item["embedding"] }
+        end
+      end
+    end
+  end
+end

data/lib/rager/embed.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Embed
+    extend T::Sig
+
+    sig do
+      params(
+        text: T::Array[String],
+        options: Rager::Embed::Options
+      ).returns(Rager::Types::EmbedOutput)
+    end
+    def self.embed(text, options = Rager::Embed::Options.new)
+      provider = get_provider(options.provider)
+      provider.embed(text, options)
+    end
+
+    sig do
+      params(
+        key: String
+      ).returns(Rager::Embed::Providers::Abstract)
+    end
+    def self.get_provider(key)
+      case key.downcase
+      when "openai"
+        Rager::Embed::Providers::Openai.new
+      else
+        raise Rager::Errors::UnknownProviderError.new(Rager::Operation::Embed, key)
+      end
+    end
+  end
+end

data/lib/rager/errors/template_error.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Errors
+    class TemplateError < Rager::Error
+      extend T::Sig
+
+      sig { params(input: Rager::Template::Input, message: String).void }
+      def initialize(input, message)
+        message = "Template Error: #{message} in #{input.template}"
+        super(message)
+      end
+    end
+  end
+end

data/lib/rager/http/adapters/async_http.rb

@@ -35,7 +35,9 @@ module Rager
               response.headers["content-type"]&.downcase&.include?("text/event-stream")
             body_enum(response)
           else
-            response.body.read
+            body_parts = []
+            response.body.each { |chunk| body_parts << chunk }
+            body_parts.join.force_encoding("UTF-8")
           end
 
           Response.new(

data/lib/rager/operation.rb

@@ -7,8 +7,12 @@ module Rager
   class Operation < T::Enum
     enums do
       Chat = new("chat")
+      Embed = new("embed")
       ImageGen = new("image_gen")
       MeshGen = new("mesh_gen")
+      Rerank = new("rerank")
+      Search = new("search")
+      Template = new("template")
     end
   end
 end

data/lib/rager/rerank/options.rb

@@ -0,0 +1,30 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Rerank
+    class Options < T::Struct
+      extend T::Sig
+      include Rager::Options
+
+      const :provider, String, default: "cohere"
+      const :url, T.nilable(String)
+      const :model, T.nilable(String)
+      const :n, T.nilable(Integer)
+      const :api_key, T.nilable(String)
+
+      sig { override.returns(T::Hash[String, T.untyped]) }
+      def serialize_safe
+        result = serialize
+        result["api_key"] = "[REDACTED]" if result.key?("api_key")
+        result
+      end
+
+      sig { override.void }
+      def validate
+      end
+    end
+  end
+end

data/lib/rager/rerank/providers/abstract.rb

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Rerank
+    module Providers
+      class Abstract
+        extend T::Sig
+        extend T::Helpers
+        abstract!
+
+        sig do
+          abstract.params(
+            query: Rager::Rerank::Query,
+            options: Rager::Rerank::Options
+          ).returns(Rager::Types::RerankOutput)
+        end
+        def rerank(query, options)
+        end
+      end
+    end
+  end
+end

data/lib/rager/rerank/providers/cohere.rb

@@ -0,0 +1,73 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "json"
+require "sorbet-runtime"
+
+module Rager
+  module Rerank
+    module Providers
+      class Cohere < Rager::Rerank::Providers::Abstract
+        extend T::Sig
+
+        sig do
+          override.params(
+            query: Rager::Rerank::Query,
+            options: Rager::Rerank::Options
+          ).returns(Rager::Types::RerankOutput)
+        end
+        def rerank(query, options)
+          api_key = options.api_key || ENV["COHERE_API_KEY"]
+          raise Rager::Errors::MissingCredentialsError.new("Cohere", "COHERE_API_KEY") if api_key.nil?
+
+          url = options.url || ENV["COHERE_URL"] || "https://api.cohere.com/v2/rerank"
+          model = options.model || "rerank-v3.5"
+
+          headers = {
+            "Content-Type" => "application/json"
+          }
+          headers["Authorization"] = "Bearer #{api_key}" if api_key
+
+          body = {
+            model: model,
+            query: query.query,
+            documents: query.documents
+          }
+          body[:top_n] = options.n if options.n
+
+          request = Rager::Http::Request.new(
+            verb: Rager::Http::Verb::Post,
+            url: url,
+            headers: headers,
+            body: body.to_json
+          )
+
+          http_adapter = Rager.config.http_adapter
+          response = http_adapter.make_request(request)
+          response_body = T.cast(T.must(response.body), String)
+
+          if response.status != 200
+            raise Rager::Errors::HttpError.new(
+              http_adapter,
+              response.status,
+              response_body
+            )
+          end
+
+          parsed_response = JSON.parse(response_body)
+
+          results = parsed_response["results"] || []
+          results.map do |result|
+            index = result["index"]
+            score = result["relevance_score"]
+
+            Rager::Rerank::Result.new(
+              score: score,
+              index: index
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rager/rerank/query.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Rerank
+    class Query < T::Struct
+      const :query, String
+      const :documents, T::Array[String]
+    end
+  end
+end

data/lib/rager/rerank/result.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Rerank
+    class Result < T::Struct
+      const :score, Float
+      const :index, Integer
+    end
+  end
+end

data/lib/rager/rerank.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Rerank
+    extend T::Sig
+
+    sig do
+      params(
+        query: Rager::Rerank::Query,
+        options: Rager::Rerank::Options
+      ).returns(Rager::Types::RerankOutput)
+    end
+    def self.rerank(query, options = Rager::Rerank::Options.new)
+      provider = get_provider(options.provider)
+      provider.rerank(query, options)
+    end
+
+    sig do
+      params(
+        key: String
+      ).returns(Rager::Rerank::Providers::Abstract)
+    end
+    def self.get_provider(key)
+      case key.downcase
+      when "cohere"
+        Rager::Rerank::Providers::Cohere.new
+      else
+        raise Rager::Errors::UnknownProviderError.new(Rager::Operation::Rerank, key)
+      end
+    end
+  end
+end

data/lib/rager/result.rb

@@ -9,6 +9,9 @@ module Rager
   class Result
     extend T::Sig
 
+    sig { returns(String) }
+    attr_reader :id
+
     sig { returns(Rager::Operation) }
     attr_reader :operation
 
@@ -33,8 +36,12 @@ module Rager
     sig { returns(T.nilable(String)) }
     attr_reader :hash
 
+    sig { returns(T.nilable(T::Array[String])) }
+    attr_reader :input_ids
+
     sig do
       params(
+        id: String,
         operation: Rager::Operation,
         options: Rager::Options,
         input: Rager::Types::Input,
@@ -42,10 +49,12 @@ module Rager
         start_time: Integer,
         end_time: Integer,
         context_id: T.nilable(String),
-        hash: T.nilable(String)
+        hash: T.nilable(String),
+        input_ids: T.nilable(T::Array[String])
       ).void
     end
     def initialize(
+      id:,
       operation:,
       options:,
       input:,
@@ -53,8 +62,10 @@ module Rager
       start_time:,
       end_time:,
       context_id: nil,
-      hash: nil
+      hash: nil,
+      input_ids: nil
     )
+      @id = id
       @operation = operation
       @options = options
       @input = input
@@ -67,6 +78,7 @@ module Rager
       @result_id = T.let(SecureRandom.uuid, T.nilable(String))
       @context_id = T.let(context_id, T.nilable(String))
       @hash = T.let(hash, T.nilable(String))
+      @input_ids = T.let(input_ids, T.nilable(T::Array[String]))
     end
 
     sig { returns(T::Boolean) }
@@ -117,13 +129,31 @@ module Rager
         .map { |_, content| content }
     end
 
-    sig { returns(T.any(String, T::Array[T::Hash[String, T.untyped]])) }
+    sig do
+      returns(
+        T.any(
+          String,
+          T::Hash[String, T.untyped],
+          T::Array[T.untyped]
+        )
+      )
+    end
     def serialize_input
       case @input
       when String
         @input
+      when Rager::Rerank::Query
+        @input.serialize
+      when Rager::Template::Input
+        @input.serialize
       when Array
-        @input.map(&:serialize)
+        @input.map do |item|
+          if !item.is_a?(String)
+            item.serialize
+          else
+            item
+          end
+        end
       end
     end
 
@@ -141,6 +171,7 @@ module Rager
     sig { returns(T::Hash[String, T.untyped]) }
     def to_h
       {
+        id: @id,
         operation: @operation.serialize,
         options: @options.serialize_safe,
         input: serialize_input,
@@ -155,7 +186,8 @@ module Rager
         end_time: @end_time,
         result_id: @result_id,
         context_id: @context_id,
-        hash: @hash
+        hash: @hash,
+        input_ids: @input_ids
       }
     end
 
@@ -167,7 +199,7 @@ module Rager
 
       case Rager.config.logger
       when Rager::Logger::Stdout
-        puts "LOG: #{json}"
+        puts "\nLOG: #{json}"
       when Rager::Logger::Remote
         http_adapter = Rager.config.http_adapter
         url = Rager.config.url

data/lib/rager/search/options.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Search
+    class Options < T::Struct
+      extend T::Sig
+      include Rager::Options
+
+      const :provider, String, default: "brave"
+      const :n, T.nilable(Integer)
+      const :api_key, T.nilable(String)
+
+      sig { override.returns(T::Hash[String, T.untyped]) }
+      def serialize_safe
+        result = serialize
+        result["api_key"] = "[REDACTED]" if result.key?("api_key")
+        result
+      end
+
+      sig { override.void }
+      def validate
+      end
+    end
+  end
+end

data/lib/rager/search/providers/abstract.rb

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Search
+    module Providers
+      class Abstract
+        extend T::Sig
+        extend T::Helpers
+        abstract!
+
+        sig do
+          abstract.params(
+            query: String,
+            options: Rager::Search::Options
+          ).returns(Rager::Types::SearchOutput)
+        end
+        def search(query, options)
+        end
+      end
+    end
+  end
+end

data/lib/rager/search/providers/brave.rb

@@ -0,0 +1,76 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require "sorbet-runtime"
+
+module Rager
+  module Search
+    module Providers
+      class Brave < Rager::Search::Providers::Abstract
+        extend T::Sig
+
+        sig do
+          override.params(
+            query: String,
+            options: Rager::Search::Options
+          ).returns(Rager::Types::SearchOutput)
+        end
+        def search(query, options)
+          api_key = options.api_key || ENV["BRAVE_API_KEY"]
+          raise Rager::Errors::MissingCredentialsError.new("Brave", "BRAVE_API_KEY") if api_key.nil?
+
+          params = {"q" => query}
+          params["count"] = options.n.to_s if options.n
+
+          query_string = URI.encode_www_form(params)
+          url = "https://api.search.brave.com/res/v1/web/search?#{query_string}"
+
+          headers = {
+            "Accept" => "application/json",
+            "Accept-Encoding" => "gzip",
+            "x-subscription-token" => api_key
+          }
+
+          request = Rager::Http::Request.new(
+            verb: Rager::Http::Verb::Get,
+            url: url,
+            headers: headers
+          )
+
+          http_adapter = Rager.config.http_adapter
+          response = http_adapter.make_request(request)
+          response_body = T.cast(T.must(response.body), String)
+
+          if response.status != 200
+            raise Rager::Errors::HttpError.new(
+              http_adapter,
+              response.status,
+              response_body
+            )
+          end
+
+          parsed_response = JSON.parse(response_body)
+
+          results = []
+
+          if parsed_response["web"] && parsed_response["web"]["results"]
+            web_results = parsed_response["web"]["results"]
+            web_results.each do |result|
+              next unless result["title"] && result["url"] && result["description"]
+
+              results << Rager::Search::Result.new(
+                title: result["title"],
+                url: result["url"],
+                description: result["description"]
+              )
+            end
+          end
+
+          results
+        end
+      end
+    end
+  end
+end

data/lib/rager/search/result.rb

@@ -0,0 +1,14 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Search
+    class Result < T::Struct
+      const :title, String
+      const :url, String
+      const :description, String
+    end
+  end
+end

data/lib/rager/search.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Search
+    extend T::Sig
+
+    sig do
+      params(
+        query: String,
+        options: Rager::Search::Options
+      ).returns(Rager::Types::SearchOutput)
+    end
+    def self.search(query, options = Rager::Search::Options.new)
+      provider = get_provider(options.provider)
+      provider.search(query, options)
+    end
+
+    sig do
+      params(
+        key: String
+      ).returns(Rager::Search::Providers::Abstract)
+    end
+    def self.get_provider(key)
+      case key.downcase
+      when "brave"
+        Rager::Search::Providers::Brave.new
+      else
+        raise Rager::Errors::UnknownProviderError.new(Rager::Operation::Search, key)
+      end
+    end
+  end
+end

data/lib/rager/template/input.rb

@@ -0,0 +1,11 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Rager
+  module Template
+    class Input < T::Struct
+      const :template, String
+      const :variables, T::Hash[Symbol, T.untyped]
+    end
+  end
+end

data/lib/rager/template/options.rb

@@ -0,0 +1,22 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Rager
+  module Template
+    class Options < T::Struct
+      include Rager::Options
+      extend T::Sig
+
+      const :provider, String, default: "erb"
+
+      sig { override.returns(T::Hash[String, T.untyped]) }
+      def serialize_safe
+        serialize.transform_keys(&:to_s)
+      end
+
+      sig { override.void }
+      def validate
+      end
+    end
+  end
+end

data/lib/rager/template/providers/abstract.rb

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Template
+    module Providers
+      class Abstract
+        extend T::Sig
+        extend T::Helpers
+
+        abstract!
+
+        sig do
+          abstract.params(
+            input: Rager::Template::Input,
+            options: Rager::Template::Options
+          ).returns(Rager::Types::TemplateOutput)
+        end
+        def template(input, options)
+        end
+      end
+    end
+  end
+end

data/lib/rager/template/providers/erb.rb

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "erb"
+require "ostruct"
+
+module Rager
+  module Template
+    module Providers
+      class Erb < Rager::Template::Providers::Abstract
+        extend T::Sig
+
+        sig do
+          override.params(
+            input: Rager::Template::Input,
+            options: Rager::Template::Options
+          ).returns(Rager::Types::TemplateOutput)
+        end
+        def template(input, options)
+          scope = OpenStruct.new(input.variables)
+          ERB.new(input.template).result(scope.instance_eval { binding })
+        end
+      end
+    end
+  end
+end

data/lib/rager/template.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Template
+    extend T::Sig
+
+    sig do
+      params(
+        input: Rager::Template::Input,
+        options: Rager::Template::Options
+      ).returns(Rager::Types::TemplateOutput)
+    end
+    def self.template(input, options = Rager::Template::Options.new)
+      provider = get_provider(options.provider)
+      provider.template(input, options)
+    end
+
+    sig do
+      params(
+        key: String
+      ).returns(Rager::Template::Providers::Abstract)
+    end
+    def self.get_provider(key)
+      case key.downcase
+      when "erb"
+        Rager::Template::Providers::Erb.new
+      else
+        raise Rager::Errors::UnknownProviderError.new(Rager::Operation::Template, key)
+      end
+    end
+  end
+end

data/lib/rager/types.rb

@@ -5,40 +5,63 @@ module Rager
   module Types
     extend T::Sig
 
-    ChatInput = T.type_alias { T.any(String, T::Array[Rager::Chat::Message]) }
+    ChatInput = T.type_alias { T::Array[Rager::Chat::Message] }
+    EmbedInput = T.type_alias { T::Array[String] }
     ImageGenInput = T.type_alias { String }
     MeshGenInput = T.type_alias { String }
+    RerankInput = T.type_alias { Rager::Rerank::Query }
+    SearchInput = T.type_alias { String }
+    TemplateInput = T.type_alias { Rager::Template::Input }
     Input = T.type_alias {
       T.any(
         ChatInput,
+        EmbedInput,
         ImageGenInput,
-        MeshGenInput
+        MeshGenInput,
+        RerankInput,
+        SearchInput,
+        TemplateInput
       )
     }
 
+    ChatNonStream = T.type_alias { T::Array[String] }
+
     ChatStream = T.type_alias { T::Enumerator[Rager::Chat::MessageDelta] }
     Stream = T.type_alias { ChatStream }
 
     ChatBuffer = T.type_alias { T::Array[Rager::Chat::MessageDelta] }
     Buffer = T.type_alias { ChatBuffer }
 
-    ChatOutput = T.type_alias { T.any(T::Array[String], ChatStream) }
+    ChatOutput = T.type_alias { T.any(ChatNonStream, ChatStream) }
+    EmbedOutput = T.type_alias { T::Array[T::Array[Float]] }
     ImageGenOutput = T.type_alias { String }
     MeshGenOutput = T.type_alias { String }
+    RerankOutput = T.type_alias { T::Array[Rager::Rerank::Result] }
+    SearchOutput = T.type_alias { T::Array[Rager::Search::Result] }
+    TemplateOutput = T.type_alias { String }
     Output = T.type_alias {
       T.any(
         ChatOutput,
+        EmbedOutput,
         ImageGenOutput,
-        MeshGenOutput
+        MeshGenOutput,
+        RerankOutput,
+        SearchOutput,
+        TemplateOutput
       )
     }
 
-    ChatNonStreamOutput = T.type_alias { T::Array[String] }
+    ChatNonStreamOutput = T.type_alias { ChatNonStream }
+
     NonStreamOutput = T.type_alias {
       T.any(
         ChatNonStreamOutput,
+        EmbedOutput,
         ImageGenOutput,
-        MeshGenOutput
+        MeshGenOutput,
+        RerankOutput,
+        SearchOutput,
+        TemplateOutput
       )
     }
   end

data/lib/rager/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Rager
-  VERSION = "0.1.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rager
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - mvkvc
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.2
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -73,11 +87,16 @@ files:
 - lib/rager/chat/schema.rb
 - lib/rager/config.rb
 - lib/rager/context.rb
+- lib/rager/embed.rb
+- lib/rager/embed/options.rb
+- lib/rager/embed/providers/abstract.rb
+- lib/rager/embed/providers/openai.rb
 - lib/rager/error.rb
 - lib/rager/errors/http_error.rb
 - lib/rager/errors/missing_credentials_error.rb
 - lib/rager/errors/options_error.rb
 - lib/rager/errors/parse_error.rb
+- lib/rager/errors/template_error.rb
 - lib/rager/errors/unknown_provider_error.rb
 - lib/rager/http/adapters/abstract.rb
 - lib/rager/http/adapters/async_http.rb
@@ -96,7 +115,23 @@ files:
 - lib/rager/mesh_gen/providers/replicate.rb
 - lib/rager/operation.rb
 - lib/rager/options.rb
+- lib/rager/rerank.rb
+- lib/rager/rerank/options.rb
+- lib/rager/rerank/providers/abstract.rb
+- lib/rager/rerank/providers/cohere.rb
+- lib/rager/rerank/query.rb
+- lib/rager/rerank/result.rb
 - lib/rager/result.rb
+- lib/rager/search.rb
+- lib/rager/search/options.rb
+- lib/rager/search/providers/abstract.rb
+- lib/rager/search/providers/brave.rb
+- lib/rager/search/result.rb
+- lib/rager/template.rb
+- lib/rager/template/input.rb
+- lib/rager/template/options.rb
+- lib/rager/template/providers/abstract.rb
+- lib/rager/template/providers/erb.rb
 - lib/rager/types.rb
 - lib/rager/version.rb
 homepage: https://github.com/mvkvc/rager_ruby