langchainrb 0.12.0 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f29aad35bc35dc95eb8673b11578b51c7449a19818989d9da5e640c6fb219c7
-  data.tar.gz: 4d0c4d3d424a82c7f02fb9e49ca52a5bdca5dfbce19fbfa22f2d74ef46d81eb7
+  metadata.gz: 6f106f178a5641f17ca723eec7272d120fbdd0e3046e44152eaf575af2985724
+  data.tar.gz: 417d5b671a6783d0854c05c43871b1e931133eaf65e6d39ac6ac4989a0124e36
 SHA512:
-  metadata.gz: 91b6f4fc5056308eab9119dcfda1be16857e6e9e6e531977148b1e8f31b72090794b67e6855afb95633b8f836b8d20921bc5a069afdc745d1114892143a177e1
-  data.tar.gz: f7a7949ab2efd960eacf3a93f7beaa9104403a93619b8c95ea094901c2d3d19b89980c81d293ae16035c5ff51fe021a09f2e81e2c0ed6854bff87d30e6def925
+  metadata.gz: 184b139d3e9d54fcd42665e25692d9fdb14e92c3d0bb23713647dfa2f1a87854215b13cc9573f10872d3e2e09d042e8c05640356276bc69a32423119e99c129b
+  data.tar.gz: 4503a8498018b53a9068345186efe03a72da4340d82a0f7806d4007e220c748814ab2da49194e09fd11ef33de3a35f38048e835dd43cee2c0b967bb810bfb512

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [0.12.1] - 2024-05-13
+- Langchain::LLM::Ollama now uses `llama3` by default
+- Langchain::LLM::Anthropic#complete() now uses `claude-2.1` by default
+- Updated with new OpenAI models, including `gpt-4o`
+- New `Langchain::LLM::Cohere#chat()` method.
+- Introducing `UnifiedParameters` to unify parameters across LLM classes
+
 ## [0.12.0] - 2024-04-22
 - [BREAKING] Rename `dimension` parameter to `dimensions` everywhere
 

data/lib/langchain/llm/anthropic.rb

@@ -13,7 +13,7 @@ module Langchain::LLM
   class Anthropic < Base
     DEFAULTS = {
       temperature: 0.0,
-      completion_model_name: "claude-2",
+      completion_model_name: "claude-2.1",
       chat_completion_model_name: "claude-3-sonnet-20240229",
       max_tokens_to_sample: 256
     }.freeze
@@ -32,6 +32,15 @@ module Langchain::LLM
 
       @client = ::Anthropic::Client.new(access_token: api_key, **llm_options)
       @defaults = DEFAULTS.merge(default_options)
+      chat_parameters.update(
+        model: {default: @defaults[:chat_completion_model_name]},
+        temperature: {default: @defaults[:temperature]},
+        max_tokens: {default: @defaults[:max_tokens_to_sample]},
+        metadata: {},
+        system: {}
+      )
+      chat_parameters.ignore(:n, :user)
+      chat_parameters.remap(stop: :stop_sequences)
     end
 
     # Generate a completion for a given prompt
@@ -72,66 +81,35 @@ module Langchain::LLM
       parameters[:metadata] = metadata if metadata
       parameters[:stream] = stream if stream
 
-      # TODO: Implement token length validator for Anthropic
-      # parameters[:max_tokens_to_sample] = validate_max_tokens(prompt, parameters[:completion_model_name])
-
       response = client.complete(parameters: parameters)
       Langchain::LLM::AnthropicResponse.new(response)
     end
 
     # Generate a chat completion for given messages
     #
-    # @param messages [Array<String>] Input messages
-    # @param model [String] The model that will complete your prompt
-    # @param max_tokens [Integer] Maximum number of tokens to generate before stopping
-    # @param metadata [Hash] Object describing metadata about the request
-    # @param stop_sequences [Array<String>] Custom text sequences that will cause the model to stop generating
-    # @param stream [Boolean] Whether to incrementally stream the response using server-sent events
-    # @param system [String] System prompt
-    # @param temperature [Float] Amount of randomness injected into the response
-    # @param tools [Array<String>] Definitions of tools that the model may use
-    # @param top_k [Integer] Only sample from the top K options for each subsequent token
-    # @param top_p [Float] Use nucleus sampling.
+    # @param [Hash] params unified chat parmeters from [Langchain::LLM::Parameters::Chat::SCHEMA]
+    # @option params [Array<String>] :messages Input messages
+    # @option params [String] :model The model that will complete your prompt
+    # @option params [Integer] :max_tokens Maximum number of tokens to generate before stopping
+    # @option params [Hash] :metadata Object describing metadata about the request
+    # @option params [Array<String>] :stop_sequences Custom text sequences that will cause the model to stop generating
+    # @option params [Boolean] :stream Whether to incrementally stream the response using server-sent events
+    # @option params [String] :system System prompt
+    # @option params [Float] :temperature Amount of randomness injected into the response
+    # @option params [Array<String>] :tools Definitions of tools that the model may use
+    # @option params [Integer] :top_k Only sample from the top K options for each subsequent token
+    # @option params [Float] :top_p Use nucleus sampling.
     # @return [Langchain::LLM::AnthropicResponse] The chat completion
-    def chat(
-      messages: [],
-      model: @defaults[:chat_completion_model_name],
-      max_tokens: @defaults[:max_tokens_to_sample],
-      metadata: nil,
-      stop_sequences: nil,
-      stream: nil,
-      system: nil,
-      temperature: @defaults[:temperature],
-      tools: [],
-      top_k: nil,
-      top_p: nil
-    )
-      raise ArgumentError.new("messages argument is required") if messages.empty?
-      raise ArgumentError.new("model argument is required") if model.empty?
-      raise ArgumentError.new("max_tokens argument is required") if max_tokens.nil?
+    def chat(params = {})
+      parameters = chat_parameters.to_params(params)
 
-      parameters = {
-        messages: messages,
-        model: model,
-        max_tokens: max_tokens,
-        temperature: temperature
-      }
-      parameters[:metadata] = metadata if metadata
-      parameters[:stop_sequences] = stop_sequences if stop_sequences
-      parameters[:stream] = stream if stream
-      parameters[:system] = system if system
-      parameters[:tools] = tools if tools.any?
-      parameters[:top_k] = top_k if top_k
-      parameters[:top_p] = top_p if top_p
+      raise ArgumentError.new("messages argument is required") if Array(parameters[:messages]).empty?
+      raise ArgumentError.new("model argument is required") if parameters[:model].empty?
+      raise ArgumentError.new("max_tokens argument is required") if parameters[:max_tokens].nil?
 
       response = client.messages(parameters: parameters)
 
       Langchain::LLM::AnthropicResponse.new(response)
     end
-
-    # TODO: Implement token length validator for Anthropic
-    # def validate_max_tokens(messages, model)
-    #   LENGTH_VALIDATOR.validate_max_tokens!(messages, model)
-    # end
   end
 end

data/lib/langchain/llm/aws_bedrock.rb

@@ -59,6 +59,17 @@ module Langchain::LLM
       @defaults = DEFAULTS.merge(default_options)
         .merge(completion_model_name: completion_model)
         .merge(embedding_model_name: embedding_model)
+
+      chat_parameters.update(
+        model: {default: @defaults[:chat_completion_model_name]},
+        temperature: {},
+        max_tokens: {default: @defaults[:max_tokens_to_sample]},
+        metadata: {},
+        system: {},
+        anthropic_version: {default: "bedrock-2023-05-31"}
+      )
+      chat_parameters.ignore(:n, :user)
+      chat_parameters.remap(stop: :stop_sequences)
     end
 
     #
@@ -113,43 +124,28 @@ module Langchain::LLM
     # Generate a chat completion for a given prompt
     # Currently only configured to work with the Anthropic provider and
     # the claude-3 model family
-    # @param messages [Array] The messages to generate a completion for
-    # @param system [String] The system prompt to provide instructions
-    # @param model [String] The model to use for completion defaults to @defaults[:chat_completion_model_name]
-    # @param max_tokens [Integer] The maximum number of tokens to generate
-    # @param stop_sequences [Array] The stop sequences to use for completion
-    # @param temperature [Float] The temperature to use for completion
-    # @param top_p [Float] The top p to use for completion
-    # @param top_k [Integer] The top k to use for completion
+    #
+    # @param [Hash] params unified chat parmeters from [Langchain::LLM::Parameters::Chat::SCHEMA]
+    # @option params [Array<String>] :messages The messages to generate a completion for
+    # @option params [String] :system The system prompt to provide instructions
+    # @option params [String] :model The model to use for completion defaults to @defaults[:chat_completion_model_name]
+    # @option params [Integer] :max_tokens The maximum number of tokens to generate defaults to @defaults[:max_tokens_to_sample]
+    # @option params [Array<String>] :stop The stop sequences to use for completion
+    # @option params [Array<String>] :stop_sequences The stop sequences to use for completion
+    # @option params [Float] :temperature The temperature to use for completion
+    # @option params [Float] :top_p Use nucleus sampling.
+    # @option params [Integer] :top_k Only sample from the top K options for each subsequent token
     # @return [Langchain::LLM::AnthropicMessagesResponse] Response object
-    def chat(
-      messages: [],
-      system: nil,
-      model: defaults[:completion_model_name],
-      max_tokens: defaults[:max_tokens_to_sample],
-      stop_sequences: nil,
-      temperature: nil,
-      top_p: nil,
-      top_k: nil
-    )
-      raise ArgumentError.new("messages argument is required") if messages.empty?
-
-      raise "Model #{model} does not support chat completions." unless Langchain::LLM::AwsBedrock::SUPPORTED_CHAT_COMPLETION_PROVIDERS.include?(completion_provider)
-
-      inference_parameters = {
-        messages: messages,
-        max_tokens: max_tokens,
-        anthropic_version: @defaults[:anthropic_version]
-      }
-      inference_parameters[:system] = system if system
-      inference_parameters[:stop_sequences] = stop_sequences if stop_sequences
-      inference_parameters[:temperature] = temperature if temperature
-      inference_parameters[:top_p] = top_p if top_p
-      inference_parameters[:top_k] = top_k if top_k
+    def chat(params = {})
+      parameters = chat_parameters.to_params(params)
+
+      raise ArgumentError.new("messages argument is required") if Array(parameters[:messages]).empty?
+
+      raise "Model #{parameters[:model]} does not support chat completions." unless Langchain::LLM::AwsBedrock::SUPPORTED_CHAT_COMPLETION_PROVIDERS.include?(completion_provider)
 
       response = client.invoke_model({
-        model_id: model,
-        body: inference_parameters.to_json,
+        model_id: parameters[:model],
+        body: parameters.except(:model).to_json,
         content_type: "application/json",
         accept: "application/json"
       })

data/lib/langchain/llm/azure.rb

@@ -32,6 +32,12 @@ module Langchain::LLM
         **llm_options
       )
       @defaults = DEFAULTS.merge(default_options)
+      chat_parameters.update(
+        logprobs: {},
+        top_logprobs: {},
+        user: {}
+      )
+      chat_parameters.ignore(:top_k)
     end
 
     def embed(...)

data/lib/langchain/llm/base.rb

@@ -24,6 +24,15 @@ module Langchain::LLM
     # A client for communicating with the LLM
     attr_reader :client
 
+    # Ensuring backward compatibility after https://github.com/patterns-ai-core/langchainrb/pull/586
+    # TODO: Delete this method later
+    def default_dimension
+      default_dimensions
+    end
+
+    # Returns the number of vector dimensions used by DEFAULTS[:chat_completion_model_name]
+    #
+    # @return [Integer] Vector dimensions
     def default_dimensions
       self.class.const_get(:DEFAULTS).dig(:dimensions)
     end
@@ -61,5 +70,14 @@ module Langchain::LLM
     def summarize(...)
       raise NotImplementedError, "#{self.class.name} does not support summarization"
     end
+
+    #
+    # Returns an instance of Langchain::LLM::Parameters::Chat
+    #
+    def chat_parameters(params = {})
+      @chat_parameters ||= Langchain::LLM::Parameters::Chat.new(
+        parameters: params
+      )
+    end
   end
 end

data/lib/langchain/llm/cohere.rb

@@ -8,22 +8,34 @@ module Langchain::LLM
   #     gem "cohere-ruby", "~> 0.9.6"
   #
   # Usage:
-  #     cohere = Langchain::LLM::Cohere.new(api_key: ENV["COHERE_API_KEY"])
+  #     llm = Langchain::LLM::Cohere.new(api_key: ENV["COHERE_API_KEY"])
   #
   class Cohere < Base
     DEFAULTS = {
       temperature: 0.0,
       completion_model_name: "command",
+      chat_completion_model_name: "command-r-plus",
       embeddings_model_name: "small",
       dimensions: 1024,
       truncate: "START"
     }.freeze
 
-    def initialize(api_key, default_options = {})
+    def initialize(api_key:, default_options: {})
       depends_on "cohere-ruby", req: "cohere"
 
-      @client = ::Cohere::Client.new(api_key)
+      @client = ::Cohere::Client.new(api_key: api_key)
       @defaults = DEFAULTS.merge(default_options)
+      chat_parameters.update(
+        model: {default: @defaults[:chat_completion_model_name]},
+        temperature: {default: @defaults[:temperature]}
+      )
+      chat_parameters.remap(
+        system: :preamble,
+        messages: :chat_history,
+        stop: :stop_sequences,
+        top_k: :k,
+        top_p: :p
+      )
     end
 
     #
@@ -68,9 +80,29 @@ module Langchain::LLM
       Langchain::LLM::CohereResponse.new response, model: @defaults[:completion_model_name]
     end
 
-    # TODO: Implement chat method: https://github.com/andreibondarev/cohere-ruby/issues/11
-    # def chat
-    # end
+    # Generate a chat completion for given messages
+    #
+    # @param [Hash] params unified chat parmeters from [Langchain::LLM::Parameters::Chat::SCHEMA]
+    # @option params [Array<String>] :messages Input messages
+    # @option params [String] :model The model that will complete your prompt
+    # @option params [Integer] :max_tokens Maximum number of tokens to generate before stopping
+    # @option params [Array<String>] :stop Custom text sequences that will cause the model to stop generating
+    # @option params [Boolean] :stream Whether to incrementally stream the response using server-sent events
+    # @option params [String] :system System prompt
+    # @option params [Float] :temperature Amount of randomness injected into the response
+    # @option params [Array<String>] :tools Definitions of tools that the model may use
+    # @option params [Integer] :top_k Only sample from the top K options for each subsequent token
+    # @option params [Float] :top_p Use nucleus sampling.
+    # @return [Langchain::LLM::CohereResponse] The chat completion
+    def chat(params = {})
+      raise ArgumentError.new("messages argument is required") if Array(params[:messages]).empty?
+
+      parameters = chat_parameters.to_params(params)
+
+      response = client.chat(**parameters)
+
+      Langchain::LLM::CohereResponse.new(response)
+    end
 
     # Generate a summary in English for a given text
     #

data/lib/langchain/llm/mistral_ai.rb

@@ -23,28 +23,19 @@ module Langchain::LLM
       )
 
       @defaults = DEFAULTS.merge(default_options)
+      chat_parameters.update(
+        model: {default: @defaults[:chat_completion_model_name]},
+        n: {default: @defaults[:n]},
+        safe_prompt: {}
+      )
+      chat_parameters.remap(seed: :random_seed)
+      chat_parameters.ignore(:n, :top_k)
     end
 
-    def chat(
-      messages:,
-      model: defaults[:chat_completion_model_name],
-      temperature: nil,
-      top_p: nil,
-      max_tokens: nil,
-      safe_prompt: nil,
-      random_seed: nil
-    )
-      params = {
-        messages: messages,
-        model: model
-      }
-      params[:temperature] = temperature if temperature
-      params[:top_p] = top_p if top_p
-      params[:max_tokens] = max_tokens if max_tokens
-      params[:safe_prompt] = safe_prompt if safe_prompt
-      params[:random_seed] = random_seed if random_seed
+    def chat(params = {})
+      parameters = chat_parameters.to_params(params)
 
-      response = client.chat_completions(params)
+      response = client.chat_completions(parameters)
 
       Langchain::LLM::MistralAIResponse.new(response.to_h)
     end

data/lib/langchain/llm/ollama.rb

@@ -7,22 +7,24 @@ module Langchain::LLM
   # Available models: https://ollama.ai/library
   #
   # Usage:
-  #    ollama = Langchain::LLM::Ollama.new(url: ENV["OLLAMA_URL"], default_options: {})
+  #    llm = Langchain::LLM::Ollama.new
+  #    llm = Langchain::LLM::Ollama.new(url: ENV["OLLAMA_URL"], default_options: {})
   #
   class Ollama < Base
     attr_reader :url, :defaults
 
     DEFAULTS = {
       temperature: 0.8,
-      completion_model_name: "llama2",
-      embeddings_model_name: "llama2",
-      chat_completion_model_name: "llama2"
+      completion_model_name: "llama3",
+      embeddings_model_name: "llama3",
+      chat_completion_model_name: "llama3"
     }.freeze
 
     EMBEDDING_SIZES = {
       codellama: 4_096,
       "dolphin-mixtral": 4_096,
       llama2: 4_096,
+      llama3: 4_096,
       llava: 4_096,
       mistral: 4_096,
       "mistral-openorca": 4_096,
@@ -33,10 +35,17 @@ module Langchain::LLM
     # @param url [String] The URL of the Ollama instance
     # @param default_options [Hash] The default options to use
     #
-    def initialize(url:, default_options: {})
+    def initialize(url: "http://localhost:11434", default_options: {})
       depends_on "faraday"
       @url = url
       @defaults = DEFAULTS.deep_merge(default_options)
+      chat_parameters.update(
+        model: {default: @defaults[:chat_completion_model_name]},
+        temperature: {default: @defaults[:temperature]},
+        template: {},
+        stream: {default: false}
+      )
+      chat_parameters.remap(response_format: :format)
     end
 
     # Returns the # of vector dimensions for the embeddings
@@ -150,33 +159,20 @@ module Langchain::LLM
 
     # Generate a chat completion
     #
-    # @param model [String] Model name
-    # @param messages [Array<Hash>] Array of messages
-    # @param format [String] Format to return a response in. Currently the only accepted value is `json`
-    # @param temperature [Float] The temperature to use
-    # @param template [String] The prompt template to use (overrides what is defined in the `Modelfile`)
-    # @param stream [Boolean] Streaming the response. If false the response will be returned as a single response object, rather than a stream of objects
+    # @param [Hash] params unified chat parmeters from [Langchain::LLM::Parameters::Chat::SCHEMA]
+    # @option params [String] :model Model name
+    # @option params [Array<Hash>] :messages Array of messages
+    # @option params [String] :format Format to return a response in. Currently the only accepted value is `json`
+    # @option params [Float] :temperature The temperature to use
+    # @option params [String] :template The prompt template to use (overrides what is defined in the `Modelfile`)
+    # @option params [Boolean] :stream Streaming the response. If false the response will be returned as a single response object, rather than a stream of objects
     #
     # The message object has the following fields:
     #   role: the role of the message, either system, user or assistant
     #   content: the content of the message
     #   images (optional): a list of images to include in the message (for multimodal models such as llava)
-    def chat(
-      model: defaults[:chat_completion_model_name],
-      messages: [],
-      format: nil,
-      temperature: defaults[:temperature],
-      template: nil,
-      stream: false # TODO: Fix streaming.
-    )
-      parameters = {
-        model: model,
-        messages: messages,
-        format: format,
-        temperature: temperature,
-        template: template,
-        stream: stream
-      }.compact
+    def chat(params = {})
+      parameters = chat_parameters.to_params(params)
 
       response = client.post("api/chat") do |req|
         req.body = parameters

data/lib/langchain/llm/openai.rb

@@ -40,6 +40,15 @@ module Langchain::LLM
       @client = ::OpenAI::Client.new(access_token: api_key, **llm_options)
 
       @defaults = DEFAULTS.merge(default_options)
+      chat_parameters.update(
+        model: {default: @defaults[:chat_completion_model_name]},
+        logprobs: {},
+        top_logprobs: {},
+        n: {default: @defaults[:n]},
+        temperature: {default: @defaults[:temperature]},
+        user: {}
+      )
+      chat_parameters.ignore(:top_k)
     end
 
     # Generate an embedding for a given text
@@ -102,54 +111,17 @@ module Langchain::LLM
 
     # 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
+    # @param [Hash] params unified chat parmeters from [Langchain::LLM::Parameters::Chat::SCHEMA]
+    # @option params [Array<Hash>] :messages List of messages comprising the conversation so far
+    # @option params [String] :model ID of the model to use
+    def chat(params = {}, &block)
+      parameters = chat_parameters.to_params(params)
+
+      raise ArgumentError.new("messages argument is required") if Array(parameters[:messages]).empty?
+      raise ArgumentError.new("model argument is required") if parameters[:model].to_s.empty?
+      if parameters[:tool_choice] && Array(parameters[:tools]).empty?
+        raise ArgumentError.new("'tool_choice' is only allowed when 'tools' are specified.")
+      end
 
       # TODO: Clean this part up
       if block

data/lib/langchain/llm/parameters/chat.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module Langchain::LLM::Parameters
+  class Chat < SimpleDelegator
+    # TODO: At the moment, the UnifiedParamters only considers keys.  In the
+    # future, we may consider ActiveModel-style validations and further typed
+    # options here.
+    SCHEMA = {
+      # Either "messages" or "prompt" is required
+      messages: {},
+      model: {},
+      prompt: {},
+
+      # System instructions. Used by Cohere, Anthropic and Google Gemini.
+      system: {},
+
+      # Allows to force the model to produce specific output format.
+      response_format: {},
+
+      stop: {}, # multiple types (e.g. OpenAI also allows Array, null)
+      stream: {}, # Enable streaming
+
+      max_tokens: {}, # Range: [1, context_length)
+      temperature: {}, # Range: [0, 2]
+      top_p: {}, # Range: (0, 1]
+      top_k: {}, # Range: [1, Infinity) Not available for OpenAI models
+      frequency_penalty: {}, # Range: [-2, 2]
+      presence_penalty: {}, # Range: [-2, 2]
+      repetition_penalty: {}, # Range: (0, 2]
+      seed: {}, # OpenAI only
+
+      # Function-calling
+      tools: {default: []},
+      tool_choice: {},
+
+      # Additional optional parameters
+      logit_bias: {}
+    }
+
+    def initialize(parameters: {})
+      super(
+        ::Langchain::LLM::UnifiedParameters.new(
+          schema: SCHEMA.dup,
+          parameters: parameters
+        )
+      )
+    end
+  end
+end

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

@@ -45,14 +45,14 @@ module Langchain
 
       # Return the completion candidates
       #
-      # @return [Array]
+      # @return [Array<String>]
       def completions
         raise NotImplementedError
       end
 
       # Return the chat completion candidates
       #
-      # @return [Array]
+      # @return [Array<String>]
       def chat_completions
         raise NotImplementedError
       end

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

@@ -17,5 +17,21 @@ module Langchain::LLM
     def completion
       completions&.dig(0, "text")
     end
+
+    def chat_completion
+      raw_response.dig("text")
+    end
+
+    def role
+      raw_response.dig("chat_history").last["role"]
+    end
+
+    def prompt_tokens
+      raw_response.dig("meta", "billed_units", "input_tokens")
+    end
+
+    def completion_tokens
+      raw_response.dig("meta", "billed_units", "output_tokens")
+    end
   end
 end

data/lib/langchain/llm/unified_parameters.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Langchain::LLM
+  class UnifiedParameters
+    include Enumerable
+
+    attr_reader :schema, :aliases, :parameters, :ignored, :remapped
+
+    class Null < self
+      def initialize(parameters: {})
+        super(schema: {}, parameters: parameters)
+      end
+    end
+
+    def initialize(schema:, parameters: {})
+      @schema = schema || {}
+      @aliases = {}
+      @remapped = {}
+      @ignored = Set.new
+      @schema.each do |name, param|
+        @aliases[name] = Set.new(Array(param[:aliases])) if param[:aliases]
+      end
+      @parameters = to_params(parameters.to_h) if !parameters.to_h.empty?
+    end
+
+    def to_params(params = {})
+      # if params are provided, reset any previously initialized
+      @parameters = params if !params.empty?
+      @parameters = (@parameters || {}).merge!(params).slice(*schema.keys)
+      @aliases.each do |field, aliased_keys|
+        # favor existing keys in case of conflicts,
+        # and check for multiples
+        aliased_keys.each do |alias_key|
+          @parameters[field] ||= params[alias_key] if value_present?(params[alias_key])
+        end
+      end
+      @schema.each do |field, param_options|
+        param_options ||= {}
+        default = param_options[:default]
+        @parameters[field] ||= default if value_present?(default)
+      end
+      @remapped.each do |field, renamed_field|
+        @parameters[renamed_field] = @parameters[field] if value_present?(@parameters[field])
+      end
+      @parameters = @parameters.except(*@ignored + @remapped.keys)
+    end
+
+    def remap(field_map)
+      @remapped ||= {}
+      @remapped.merge!(field_map)
+      field_map.each do |field, renamed_field|
+        @schema[renamed_field] = @schema[field]
+      end
+    end
+
+    def update(schema = {})
+      @schema.merge!(schema)
+      schema.each do |name, param|
+        if param[:aliases]
+          @aliases[name] ||= Set.new
+          @aliases[name] << param[:aliases]
+        end
+      end
+      self
+    end
+
+    def ignore(*field_names)
+      @ignored.merge(field_names)
+    end
+
+    def alias_field(field_name, as:)
+      @aliases[field_name] ||= Set.new
+      @aliases[field_name] << as
+    end
+
+    def to_h
+      @parameters.to_h
+    end
+
+    def each(&)
+      to_params.each(&)
+    end
+
+    def <=>(other)
+      to_params.<=>(other.to_params)
+    end
+
+    def [](key)
+      to_params[key]
+    end
+
+    private
+
+    def value_present?(value)
+      !value.nil? && (!value.is_a?(Enumerable) || !value.empty?)
+    end
+  end
+end

data/lib/langchain/loader.rb

@@ -29,9 +29,11 @@ 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 [Data] data loaded from path
+    # rubocop:disable Style/ArgumentsForwarding
     def self.load(path, options = {}, &block)
       new(path, options).load(&block)
     end
+    # rubocop:enable Style/ArgumentsForwarding
 
     # Initialize Langchain::Loader
     # @param path [String | Pathname] path to file or URL
@@ -76,12 +78,14 @@ module Langchain
     # @yieldreturn [String] parsed data, as a String
     #
     # @return [Data] data that was loaded
+    # rubocop:disable Style/ArgumentsForwarding
     def load(&block)
       return process_data(load_from_url, &block) if url?
       return load_from_directory(&block) if directory?
 
       process_data(load_from_path, &block)
     end
+    # rubocop:enable Style/ArgumentsForwarding
 
     private
 
@@ -95,6 +99,7 @@ module Langchain
       raise FileNotFound, "File #{@path} does not exist"
     end
 
+    # rubocop:disable Style/ArgumentsForwarding
     def load_from_directory(&block)
       Dir.glob(File.join(@path, "**/*")).map do |file|
         # Only load and add to result files with supported extensions
@@ -103,6 +108,7 @@ module Langchain
         UnknownFormatError nil
       end.flatten.compact
     end
+    # rubocop:enable Style/ArgumentsForwarding
 
     def process_data(data, &block)
       @raw_data = data

data/lib/langchain/tool/base.rb

@@ -3,13 +3,13 @@
 module Langchain::Tool
   # = Tools
   #
-  # Tools are used by Agents to perform specific tasks. Basically anything is possible with enough code!
+  # Tools are used by Agents to perform specific tasks. A 'Tool' is a collection of functions ("methods").
   #
   # == Available Tools
   #
   # - {Langchain::Tool::Calculator}: calculate the result of a math expression
   # - {Langchain::Tool::Database}: executes SQL queries
-  # - {Langchain::Tool::FileSystem}: interacts with files
+  # - {Langchain::Tool::FileSystem}: interacts with the file system
   # - {Langchain::Tool::GoogleSearch}: search on Google (via SerpAPI)
   # - {Langchain::Tool::RubyCodeInterpreter}: runs ruby code
   # - {Langchain::Tool::Weather}: gets current weather data
@@ -42,10 +42,10 @@ module Langchain::Tool
   #
   # == Adding Tools
   #
-  # 1. Create a new file in lib/langchain/tool/your_tool_name.rb
-  # 2. Create a class in the file that inherits from {Langchain::Tool::Base}
+  # 1. Create a new folder in lib/langchain/tool/your_tool_name/
+  # 2. Inside of this folder create a file with a class YourToolName that inherits from {Langchain::Tool::Base}
   # 3. Add `NAME=` and `ANNOTATIONS_PATH=` constants in your Tool class
-  # 4. Implement various methods in your tool class
+  # 4. Implement various public methods in your tool class
   # 5. Create a sidecar .json file in the same directory as your tool file annotating the methods in the Open API format
   # 6. Add your tool to the {file:README.md}
   class Base

data/lib/langchain/utils/token_length/openai_validator.rb

@@ -28,10 +28,11 @@ module Langchain
           "text-embedding-3-large" => 8191,
           "text-embedding-3-small" => 8191,
           "text-embedding-ada-002" => 8191,
-          "gpt-3.5-turbo" => 4096,
+          "gpt-3.5-turbo" => 16385,
           "gpt-3.5-turbo-0301" => 4096,
           "gpt-3.5-turbo-0613" => 4096,
           "gpt-3.5-turbo-1106" => 16385,
+          "gpt-3.5-turbo-0125" => 16385,
           "gpt-3.5-turbo-16k" => 16384,
           "gpt-3.5-turbo-16k-0613" => 16384,
           "text-davinci-003" => 4097,
@@ -44,9 +45,13 @@ module Langchain
           "gpt-4-32k-0314" => 32768,
           "gpt-4-32k-0613" => 32768,
           "gpt-4-1106-preview" => 128000,
+          "gpt-4-turbo" => 128000,
+          "gpt-4-turbo-2024-04-09" => 128000,
           "gpt-4-turbo-preview" => 128000,
           "gpt-4-0125-preview" => 128000,
           "gpt-4-vision-preview" => 128000,
+          "gpt-4o" => 128000,
+          "gpt-4o-2024-05-13" => 128000,
           "text-curie-001" => 2049,
           "text-babbage-001" => 2049,
           "text-ada-001" => 2049,

data/lib/langchain/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Langchain
-  VERSION = "0.12.0"
+  VERSION = "0.12.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: langchainrb
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.12.1
 platform: ruby
 authors:
 - Andrei Bondarev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-22 00:00:00.000000000 Z
+date: 2024-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -238,16 +238,16 @@ dependencies:
   name: anthropic
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: aws-sdk-bedrockruntime
   requirement: !ruby/object:Gem::Requirement
@@ -282,14 +282,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.8
+        version: 0.9.10
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.8
+        version: 0.9.10
 - !ruby/object:Gem::Dependency
   name: docx
   requirement: !ruby/object:Gem::Requirement
@@ -742,6 +742,7 @@ files:
 - lib/langchain/llm/mistral_ai.rb
 - lib/langchain/llm/ollama.rb
 - lib/langchain/llm/openai.rb
+- lib/langchain/llm/parameters/chat.rb
 - lib/langchain/llm/prompts/ollama/summarize_template.yaml
 - lib/langchain/llm/prompts/summarize_template.yaml
 - lib/langchain/llm/replicate.rb
@@ -758,6 +759,7 @@ files:
 - lib/langchain/llm/response/ollama_response.rb
 - lib/langchain/llm/response/openai_response.rb
 - lib/langchain/llm/response/replicate_response.rb
+- lib/langchain/llm/unified_parameters.rb
 - lib/langchain/loader.rb
 - lib/langchain/output_parsers/base.rb
 - lib/langchain/output_parsers/output_fixing_parser.rb