langchainrb 0.7.5 → 0.12.0

data/lib/langchain/llm/openai.rb

@@ -4,223 +4,196 @@ module Langchain::LLM
   # LLM interface for OpenAI APIs: https://platform.openai.com/overview
   #
   # Gem requirements:
-  #    gem "ruby-openai", "~> 5.2.0"
+  #    gem "ruby-openai", "~> 6.3.0"
   #
   # Usage:
-  #    openai = Langchain::LLM::OpenAI.new(api_key:, llm_options: {})
-  #
+  #    openai = Langchain::LLM::OpenAI.new(
+  #      api_key: ENV["OPENAI_API_KEY"],
+  #      llm_options: {}, # Available options: https://github.com/alexrudall/ruby-openai/blob/main/lib/openai/client.rb#L5-L13
+  #      default_options: {}
+  #    )
   class OpenAI < Base
     DEFAULTS = {
       n: 1,
       temperature: 0.0,
-      completion_model_name: "gpt-3.5-turbo",
       chat_completion_model_name: "gpt-3.5-turbo",
-      embeddings_model_name: "text-embedding-ada-002",
-      dimension: 1536
+      embeddings_model_name: "text-embedding-3-small"
     }.freeze
 
-    LEGACY_COMPLETION_MODELS = %w[
-      ada
-      babbage
-      curie
-      davinci
-    ].freeze
+    EMBEDDING_SIZES = {
+      "text-embedding-ada-002" => 1536,
+      "text-embedding-3-large" => 3072,
+      "text-embedding-3-small" => 1536
+    }.freeze
 
     LENGTH_VALIDATOR = Langchain::Utils::TokenLength::OpenAIValidator
 
-    attr_accessor :functions
-    attr_accessor :response_chunks
+    attr_reader :defaults
 
+    # Initialize an OpenAI LLM instance
+    #
+    # @param api_key [String] The API key to use
+    # @param client_options [Hash] Options to pass to the OpenAI::Client constructor
     def initialize(api_key:, llm_options: {}, default_options: {})
       depends_on "ruby-openai", req: "openai"
 
       @client = ::OpenAI::Client.new(access_token: api_key, **llm_options)
+
       @defaults = DEFAULTS.merge(default_options)
     end
 
-    #
     # Generate an embedding for a given text
     #
     # @param text [String] The text to generate an embedding for
-    # @param params extra parameters passed to OpenAI::Client#embeddings
+    # @param model [String] ID of the model to use
+    # @param encoding_format [String] The format to return the embeddings in. Can be either float or base64.
+    # @param user [String] A unique identifier representing your end-user
     # @return [Langchain::LLM::OpenAIResponse] Response object
-    #
-    def embed(text:, **params)
-      parameters = {model: @defaults[:embeddings_model_name], input: text}
+    def embed(
+      text:,
+      model: defaults[:embeddings_model_name],
+      encoding_format: nil,
+      user: nil,
+      dimensions: @defaults[:dimensions]
+    )
+      raise ArgumentError.new("text argument is required") if text.empty?
+      raise ArgumentError.new("model argument is required") if model.empty?
+      raise ArgumentError.new("encoding_format must be either float or base64") if encoding_format && %w[float base64].include?(encoding_format)
+
+      parameters = {
+        input: text,
+        model: model
+      }
+      parameters[:encoding_format] = encoding_format if encoding_format
+      parameters[:user] = user if user
+
+      if dimensions
+        parameters[:dimensions] = dimensions
+      elsif EMBEDDING_SIZES.key?(model)
+        parameters[:dimensions] = EMBEDDING_SIZES[model]
+      end
 
       validate_max_tokens(text, parameters[:model])
 
       response = with_api_error_handling do
-        client.embeddings(parameters: parameters.merge(params))
+        client.embeddings(parameters: parameters)
       end
 
       Langchain::LLM::OpenAIResponse.new(response)
     end
 
-    #
+    # rubocop:disable Style/ArgumentsForwarding
     # Generate a completion for a given prompt
     #
     # @param prompt [String] The prompt to generate a completion for
-    # @param params  extra parameters passed to OpenAI::Client#complete
-    # @return [Langchain::LLM::Response::OpenaAI] Response object
-    #
+    # @param params [Hash] The parameters to pass to the `chat()` method
+    # @return [Langchain::LLM::OpenAIResponse] Response object
     def complete(prompt:, **params)
-      parameters = compose_parameters @defaults[:completion_model_name], params
+      warn "DEPRECATED: `Langchain::LLM::OpenAI#complete` is deprecated, and will be removed in the next major version. Use `Langchain::LLM::OpenAI#chat` instead."
 
-      return legacy_complete(prompt, parameters) if is_legacy_model?(parameters[:model])
-
-      parameters[:messages] = compose_chat_messages(prompt: prompt)
-      parameters[:max_tokens] = validate_max_tokens(parameters[:messages], parameters[:model], parameters[:max_tokens])
-
-      response = with_api_error_handling do
-        client.chat(parameters: parameters)
+      if params[:stop_sequences]
+        params[:stop] = params.delete(:stop_sequences)
       end
-
-      Langchain::LLM::OpenAIResponse.new(response)
+      # Should we still accept the `messages: []` parameter here?
+      messages = [{role: "user", content: prompt}]
+      chat(messages: messages, **params)
     end
+    # rubocop:enable Style/ArgumentsForwarding
+
+    # Generate a chat completion for given messages.
+    #
+    # @param messages [Array<Hash>] List of messages comprising the conversation so far
+    # @param model [String] ID of the model to use
+    def chat(
+      messages: [],
+      model: defaults[:chat_completion_model_name],
+      frequency_penalty: nil,
+      logit_bias: nil,
+      logprobs: nil,
+      top_logprobs: nil,
+      max_tokens: nil,
+      n: defaults[:n],
+      presence_penalty: nil,
+      response_format: nil,
+      seed: nil,
+      stop: nil,
+      stream: nil,
+      temperature: defaults[:temperature],
+      top_p: nil,
+      tools: [],
+      tool_choice: nil,
+      user: nil,
+      &block
+    )
+      raise ArgumentError.new("messages argument is required") if messages.empty?
+      raise ArgumentError.new("model argument is required") if model.empty?
+      raise ArgumentError.new("'tool_choice' is only allowed when 'tools' are specified.") if tool_choice && tools.empty?
+
+      parameters = {
+        messages: messages,
+        model: model
+      }
+      parameters[:frequency_penalty] = frequency_penalty if frequency_penalty
+      parameters[:logit_bias] = logit_bias if logit_bias
+      parameters[:logprobs] = logprobs if logprobs
+      parameters[:top_logprobs] = top_logprobs if top_logprobs
+      # TODO: Fix max_tokens validation to account for tools/functions
+      parameters[:max_tokens] = max_tokens if max_tokens # || validate_max_tokens(parameters[:messages], parameters[:model])
+      parameters[:n] = n if n
+      parameters[:presence_penalty] = presence_penalty if presence_penalty
+      parameters[:response_format] = response_format if response_format
+      parameters[:seed] = seed if seed
+      parameters[:stop] = stop if stop
+      parameters[:stream] = stream if stream
+      parameters[:temperature] = temperature if temperature
+      parameters[:top_p] = top_p if top_p
+      parameters[:tools] = tools if tools.any?
+      parameters[:tool_choice] = tool_choice if tool_choice
+      parameters[:user] = user if user
+
+      # TODO: Clean this part up
+      if block
+        @response_chunks = []
+        parameters[:stream] = proc do |chunk, _bytesize|
+          chunk_content = chunk.dig("choices", 0)
+          @response_chunks << chunk
+          yield chunk_content
+        end
+      end
 
-    #
-    # Generate a chat completion for a given prompt or messages.
-    #
-    # == Examples
-    #
-    #     # simplest case, just give a prompt
-    #     openai.chat prompt: "When was Ruby first released?"
-    #
-    #     # prompt plus some context about how to respond
-    #     openai.chat context: "You are RubyGPT, a helpful chat bot for helping people learn Ruby", prompt: "Does Ruby have a REPL like IPython?"
-    #
-    #     # full control over messages that get sent, equivilent to the above
-    #     openai.chat messages: [
-    #       {
-    #         role: "system",
-    #         content: "You are RubyGPT, a helpful chat bot for helping people learn Ruby", prompt: "Does Ruby have a REPL like IPython?"
-    #       },
-    #       {
-    #         role: "user",
-    #         content: "When was Ruby first released?"
-    #       }
-    #     ]
-    #
-    #     # few-short prompting with examples
-    #     openai.chat prompt: "When was factory_bot released?",
-    #       examples: [
-    #         {
-    #           role: "user",
-    #           content: "When was Ruby on Rails released?"
-    #         }
-    #         {
-    #           role: "assistant",
-    #           content: "2004"
-    #         },
-    #       ]
-    #
-    # @param prompt [String] The prompt to generate a chat completion for
-    # @param messages [Array<Hash>] The messages that have been sent in the conversation
-    # @param context [String] An initial context to provide as a system message, ie "You are RubyGPT, a helpful chat bot for helping people learn Ruby"
-    # @param examples [Array<Hash>] Examples of messages to provide to the model. Useful for Few-Shot Prompting
-    # @param options [Hash] extra parameters passed to OpenAI::Client#chat
-    # @yield [Hash] Stream responses back one token at a time
-    # @return [Langchain::LLM::OpenAIResponse] Response object
-    #
-    def chat(prompt: "", messages: [], context: "", examples: [], **options, &block)
-      raise ArgumentError.new(":prompt or :messages argument is expected") if prompt.empty? && messages.empty?
-
-      parameters = compose_parameters @defaults[:chat_completion_model_name], options, &block
-      parameters[:messages] = compose_chat_messages(prompt: prompt, messages: messages, context: context, examples: examples)
-
-      if functions
-        parameters[:functions] = functions
-      else
-        parameters[:max_tokens] = validate_max_tokens(parameters[:messages], parameters[:model], parameters[:max_tokens])
+      response = with_api_error_handling do
+        client.chat(parameters: parameters)
       end
 
-      response = with_api_error_handling { client.chat(parameters: parameters) }
       response = response_from_chunks if block
+      reset_response_chunks
+
       Langchain::LLM::OpenAIResponse.new(response)
     end
 
-    #
     # Generate a summary for a given text
     #
     # @param text [String] The text to generate a summary for
     # @return [String] The summary
-    #
     def summarize(text:)
       prompt_template = Langchain::Prompt.load_from_path(
         file_path: Langchain.root.join("langchain/llm/prompts/summarize_template.yaml")
       )
       prompt = prompt_template.format(text: text)
 
-      complete(prompt: prompt, temperature: @defaults[:temperature])
-      # Should this return a Langchain::LLM::OpenAIResponse as well?
-    end
-
-    private
-
-    def is_legacy_model?(model)
-      LEGACY_COMPLETION_MODELS.any? { |legacy_model| model.include?(legacy_model) }
+      complete(prompt: prompt)
     end
 
-    def legacy_complete(prompt, parameters)
-      Langchain.logger.warn "DEPRECATION WARNING: The model #{parameters[:model]} is deprecated. Please use gpt-3.5-turbo instead. Details: https://platform.openai.com/docs/deprecations/2023-07-06-gpt-and-embeddings"
-
-      parameters[:prompt] = prompt
-      parameters[:max_tokens] = validate_max_tokens(prompt, parameters[:model])
-
-      response = with_api_error_handling do
-        client.completions(parameters: parameters)
-      end
-      response.dig("choices", 0, "text")
-    end
-
-    def compose_parameters(model, params, &block)
-      default_params = {model: model, temperature: @defaults[:temperature], n: @defaults[:n]}
-      default_params[:stop] = params.delete(:stop_sequences) if params[:stop_sequences]
-      parameters = default_params.merge(params)
-
-      if block
-        @response_chunks = []
-        parameters[:stream] = proc do |chunk, _bytesize|
-          chunk_content = chunk.dig("choices", 0)
-          @response_chunks << chunk
-          yield chunk_content
-        end
-      end
-
-      parameters
+    def default_dimensions
+      @defaults[:dimensions] || EMBEDDING_SIZES.fetch(defaults[:embeddings_model_name])
     end
 
-    def compose_chat_messages(prompt:, messages: [], context: "", examples: [])
-      history = []
-
-      history.concat transform_messages(examples) unless examples.empty?
-
-      history.concat transform_messages(messages) unless messages.empty?
-
-      unless context.nil? || context.empty?
-        history.reject! { |message| message[:role] == "system" }
-        history.prepend({role: "system", content: context})
-      end
-
-      unless prompt.empty?
-        if history.last && history.last[:role] == "user"
-          history.last[:content] += "\n#{prompt}"
-        else
-          history.append({role: "user", content: prompt})
-        end
-      end
+    private
 
-      history
-    end
+    attr_reader :response_chunks
 
-    def transform_messages(messages)
-      messages.map do |message|
-        {
-          role: message[:role],
-          content: message[:content]
-        }
-      end
+    def reset_response_chunks
+      @response_chunks = []
     end
 
     def with_api_error_handling
@@ -233,27 +206,22 @@ module Langchain::LLM
     end
 
     def validate_max_tokens(messages, model, max_tokens = nil)
-      LENGTH_VALIDATOR.validate_max_tokens!(messages, model, max_tokens: max_tokens)
-    end
-
-    def extract_response(response)
-      results = response.dig("choices").map { |choice| choice.dig("message", "content") }
-      (results.size == 1) ? results.first : results
+      LENGTH_VALIDATOR.validate_max_tokens!(messages, model, max_tokens: max_tokens, llm: self)
     end
 
     def response_from_chunks
-      @response_chunks.first&.slice("id", "object", "created", "model")&.merge(
+      grouped_chunks = @response_chunks.group_by { |chunk| chunk.dig("choices", 0, "index") }
+      final_choices = grouped_chunks.map do |index, chunks|
         {
-          "choices" => [
-            {
-              "message" => {
-                "role" => "assistant",
-                "content" => @response_chunks.map { |chunk| chunk.dig("choices", 0, "delta", "content") }.join
-              }
-            }
-          ]
+          "index" => index,
+          "message" => {
+            "role" => "assistant",
+            "content" => chunks.map { |chunk| chunk.dig("choices", 0, "delta", "content") }.join
+          },
+          "finish_reason" => chunks.last.dig("choices", 0, "finish_reason")
         }
-      )
+      end
+      @response_chunks.first&.slice("id", "object", "created", "model")&.merge({"choices" => final_choices})
     end
   end
 end

data/lib/langchain/llm/prompts/ollama/summarize_template.yaml

@@ -0,0 +1,9 @@
+_type: prompt
+input_variables:
+  - text
+template: |
+  Write a concise summary of the following TEXT. Do not include the word summary, just provide the summary.
+
+  TEXT: {text}
+
+  CONCISE SUMMARY:

data/lib/langchain/llm/replicate.rb

@@ -24,7 +24,7 @@ module Langchain::LLM
       # TODO: Design the interface to pass and use different models
       completion_model_name: "replicate/vicuna-13b",
       embeddings_model_name: "creatorrr/all-mpnet-base-v2",
-      dimension: 384
+      dimensions: 384
     }.freeze
 
     #
@@ -77,12 +77,6 @@ module Langchain::LLM
       Langchain::LLM::ReplicateResponse.new(response, model: @defaults[:completion_model_name])
     end
 
-    # Cohere does not have a dedicated chat endpoint, so instead we call `complete()`
-    def chat(...)
-      response_text = complete(...)
-      ::Langchain::Conversation::Response.new(response_text)
-    end
-
     #
     # Generate a summary for a given text
     #

data/lib/langchain/llm/response/anthropic_response.rb

@@ -10,6 +10,10 @@ module Langchain::LLM
       completions.first
     end
 
+    def chat_completion
+      raw_response.dig("content", 0, "text")
+    end
+
     def completions
       [raw_response.dig("completion")]
     end
@@ -25,5 +29,21 @@ module Langchain::LLM
     def log_id
       raw_response.dig("log_id")
     end
+
+    def prompt_tokens
+      raw_response.dig("usage", "input_tokens").to_i
+    end
+
+    def completion_tokens
+      raw_response.dig("usage", "output_tokens").to_i
+    end
+
+    def total_tokens
+      prompt_tokens + completion_tokens
+    end
+
+    def role
+      raw_response.dig("role")
+    end
   end
 end

data/lib/langchain/llm/response/base_response.rb

@@ -13,6 +13,13 @@ module Langchain
         @model = model
       end
 
+      # Returns the timestamp when the response was created
+      #
+      # @return [Time]
+      def created_at
+        raise NotImplementedError
+      end
+
       # Returns the completion text
       #
       # @return [String]

data/lib/langchain/llm/response/google_palm_response.rb

@@ -32,5 +32,9 @@ module Langchain::LLM
     def embeddings
       [raw_response.dig("embedding", "value")]
     end
+
+    def role
+      "assistant"
+    end
   end
 end

data/lib/langchain/llm/response/google_vertex_ai_response.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Langchain::LLM
+  class GoogleVertexAiResponse < BaseResponse
+    attr_reader :prompt_tokens
+
+    def initialize(raw_response, model: nil)
+      @prompt_tokens = prompt_tokens
+      super(raw_response, model: model)
+    end
+
+    def completion
+      # completions&.dig(0, "output")
+      raw_response.predictions[0]["content"]
+    end
+
+    def embedding
+      embeddings.first
+    end
+
+    def completions
+      raw_response.predictions.map { |p| p["content"] }
+    end
+
+    def total_tokens
+      raw_response.dig(:predictions, 0, :embeddings, :statistics, :token_count)
+    end
+
+    def embeddings
+      [raw_response.dig(:predictions, 0, :embeddings, :values)]
+    end
+  end
+end

data/lib/langchain/llm/response/llama_cpp_response.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Langchain::LLM
+  class LlamaCppResponse < BaseResponse
+    def embedding
+      embeddings
+    end
+
+    def embeddings
+      raw_response.embeddings
+    end
+  end
+end

data/lib/langchain/llm/response/mistral_ai_response.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Langchain::LLM
+  class MistralAIResponse < BaseResponse
+    def model
+      raw_response["model"]
+    end
+
+    def chat_completion
+      raw_response.dig("choices", 0, "message", "content")
+    end
+
+    def role
+      raw_response.dig("choices", 0, "message", "role")
+    end
+
+    def embedding
+      raw_response.dig("data", 0, "embedding")
+    end
+
+    def prompt_tokens
+      raw_response.dig("usage", "prompt_tokens")
+    end
+
+    def total_tokens
+      raw_response.dig("usage", "total_tokens")
+    end
+
+    def completion_tokens
+      raw_response.dig("usage", "completion_tokens")
+    end
+
+    def created_at
+      if raw_response.dig("created_at")
+        Time.at(raw_response.dig("created_at"))
+      end
+    end
+  end
+end

data/lib/langchain/llm/response/ollama_response.rb

@@ -7,8 +7,18 @@ module Langchain::LLM
       super(raw_response, model: model)
     end
 
+    def created_at
+      if raw_response.dig("created_at")
+        Time.parse(raw_response.dig("created_at"))
+      end
+    end
+
+    def chat_completion
+      raw_response.dig("message", "content")
+    end
+
     def completion
-      raw_response.first
+      completions.first
     end
 
     def completions
@@ -22,5 +32,21 @@ module Langchain::LLM
     def embeddings
       [raw_response&.dig("embedding")]
     end
+
+    def role
+      "assistant"
+    end
+
+    def prompt_tokens
+      raw_response.dig("prompt_eval_count")
+    end
+
+    def completion_tokens
+      raw_response.dig("eval_count")
+    end
+
+    def total_tokens
+      prompt_tokens + completion_tokens
+    end
   end
 end

data/lib/langchain/llm/response/openai_response.rb

@@ -16,10 +16,18 @@ module Langchain::LLM
       completions&.dig(0, "message", "content")
     end
 
+    def role
+      completions&.dig(0, "message", "role")
+    end
+
     def chat_completion
       completion
     end
 
+    def tool_calls
+      chat_completions&.dig(0, "message", "tool_calls")
+    end
+
     def embedding
       embeddings&.first
     end

data/lib/langchain/loader.rb

@@ -37,9 +37,10 @@ module Langchain
     # @param path [String | Pathname] path to file or URL
     # @param options [Hash] options passed to the processor class used to process the data
     # @return [Langchain::Loader] loader instance
-    def initialize(path, options = {})
+    def initialize(path, options = {}, chunker: Langchain::Chunker::Text)
       @options = options
       @path = path
+      @chunker = chunker
     end
 
     # Is the path a URL?
@@ -112,7 +113,7 @@ module Langchain
         processor_klass.new(@options).parse(@raw_data)
       end
 
-      Langchain::Data.new(result)
+      Langchain::Data.new(result, source: @options[:source], chunker: @chunker)
     end
 
     def processor_klass

data/lib/langchain/output_parsers/base.rb

@@ -5,18 +5,15 @@ module Langchain::OutputParsers
   #
   # @abstract
   class Base
-    #
     # Parse the output of an LLM call.
     #
     # @param text - LLM output to parse.
     #
     # @return [Object] Parsed output.
-    #
     def parse(text:)
       raise NotImplementedError
     end
 
-    #
     # Return a string describing the format of the output.
     #
     # @return [String] Format instructions.
@@ -27,7 +24,6 @@ module Langchain::OutputParsers
     #  "foo": "bar"
     # }
     # ```
-    #
     def get_format_instructions
       raise NotImplementedError
     end