langchainrb 0.18.0 → 0.19.1

data/lib/langchain/assistant/messages/openai_message.rb

@@ -50,32 +50,14 @@ module Langchain
         #
         # @return [Hash] The message as an OpenAI API-compatible hash
         def to_hash
-          {}.tap do |h|
-            h[:role] = role
-
-            if tool_calls.any?
-              h[:tool_calls] = tool_calls
-            else
-              h[:tool_call_id] = tool_call_id if tool_call_id
-
-              h[:content] = []
-
-              if content && !content.empty?
-                h[:content] << {
-                  type: "text",
-                  text: content
-                }
-              end
-
-              if image_url
-                h[:content] << {
-                  type: "image_url",
-                  image_url: {
-                    url: image_url
-                  }
-                }
-              end
-            end
+          if assistant?
+            assistant_hash
+          elsif system?
+            system_hash
+          elsif tool?
+            tool_hash
+          elsif user?
+            user_hash
           end
         end
 
@@ -99,6 +81,76 @@ module Langchain
         def tool?
           role == "tool"
         end
+
+        def user?
+          role == "user"
+        end
+
+        # Convert the message to an OpenAI API-compatible hash
+        # @return [Hash] The message as an OpenAI API-compatible hash, with the role as "assistant"
+        def assistant_hash
+          if tool_calls.any?
+            {
+              role: "assistant",
+              tool_calls: tool_calls
+            }
+          else
+            {
+              role: "assistant",
+              content: build_content_array
+            }
+          end
+        end
+
+        # Convert the message to an OpenAI API-compatible hash
+        # @return [Hash] The message as an OpenAI API-compatible hash, with the role as "system"
+        def system_hash
+          {
+            role: "system",
+            content: build_content_array
+          }
+        end
+
+        # Convert the message to an OpenAI API-compatible hash
+        # @return [Hash] The message as an OpenAI API-compatible hash, with the role as "tool"
+        def tool_hash
+          {
+            role: "tool",
+            tool_call_id: tool_call_id,
+            content: build_content_array
+          }
+        end
+
+        # Convert the message to an OpenAI API-compatible hash
+        # @return [Hash] The message as an OpenAI API-compatible hash, with the role as "user"
+        def user_hash
+          {
+            role: "user",
+            content: build_content_array
+          }
+        end
+
+        # Builds the content value for the message hash
+        # @return [Array<Hash>] An array of content hashes, with keys :type and :text or :image_url.
+        def build_content_array
+          content_details = []
+          if content && !content.empty?
+            content_details << {
+              type: "text",
+              text: content
+            }
+          end
+
+          if image_url
+            content_details << {
+              type: "image_url",
+              image_url: {
+                url: image_url
+              }
+            }
+          end
+          content_details
+        end
       end
     end
   end

data/lib/langchain/assistant.rb

@@ -196,7 +196,7 @@ module Langchain
 
       if @llm_adapter.support_system_message?
         # TODO: Should we still set a system message even if @instructions is "" or nil?
-        replace_system_message!(content: new_instructions) if @instructions
+        replace_system_message!(content: new_instructions)
       end
     end
 
@@ -217,6 +217,7 @@ module Langchain
     # @return [Array<Langchain::Message>] The messages
     def replace_system_message!(content:)
       messages.delete_if(&:system?)
+      return if content.nil?
 
       message = build_message(role: "system", content: content)
       messages.unshift(message)

data/lib/langchain/llm/anthropic.rb

@@ -13,16 +13,16 @@ module Langchain::LLM
   class Anthropic < Base
     DEFAULTS = {
       temperature: 0.0,
-      completion_model_name: "claude-2.1",
-      chat_completion_model_name: "claude-3-5-sonnet-20240620",
-      max_tokens_to_sample: 256
+      completion_model: "claude-2.1",
+      chat_model: "claude-3-5-sonnet-20240620",
+      max_tokens: 256
     }.freeze
 
     # Initialize an Anthropic LLM instance
     #
     # @param api_key [String] The API key to use
     # @param llm_options [Hash] Options to pass to the Anthropic client
-    # @param default_options [Hash] Default options to use on every call to LLM, e.g.: { temperature:, completion_model_name:, chat_completion_model_name:, max_tokens_to_sample: }
+    # @param default_options [Hash] Default options to use on every call to LLM, e.g.: { temperature:, completion_model:, chat_model:, max_tokens: }
     # @return [Langchain::LLM::Anthropic] Langchain::LLM::Anthropic instance
     def initialize(api_key:, llm_options: {}, default_options: {})
       depends_on "anthropic"
@@ -30,9 +30,9 @@ 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]},
+        model: {default: @defaults[:chat_model]},
         temperature: {default: @defaults[:temperature]},
-        max_tokens: {default: @defaults[:max_tokens_to_sample]},
+        max_tokens: {default: @defaults[:max_tokens]},
         metadata: {},
         system: {}
       )
@@ -54,8 +54,8 @@ module Langchain::LLM
     # @return [Langchain::LLM::AnthropicResponse] The completion
     def complete(
       prompt:,
-      model: @defaults[:completion_model_name],
-      max_tokens_to_sample: @defaults[:max_tokens_to_sample],
+      model: @defaults[:completion_model],
+      max_tokens: @defaults[:max_tokens],
       stop_sequences: nil,
       temperature: @defaults[:temperature],
       top_p: nil,
@@ -64,12 +64,12 @@ module Langchain::LLM
       stream: nil
     )
       raise ArgumentError.new("model argument is required") if model.empty?
-      raise ArgumentError.new("max_tokens_to_sample argument is required") if max_tokens_to_sample.nil?
+      raise ArgumentError.new("max_tokens argument is required") if max_tokens.nil?
 
       parameters = {
         model: model,
         prompt: prompt,
-        max_tokens_to_sample: max_tokens_to_sample,
+        max_tokens_to_sample: max_tokens,
         temperature: temperature
       }
       parameters[:stop_sequences] = stop_sequences if stop_sequences

data/lib/langchain/llm/aws_bedrock.rb

@@ -7,51 +7,40 @@ module Langchain::LLM
   #    gem 'aws-sdk-bedrockruntime', '~> 1.1'
   #
   # Usage:
-  #    llm = Langchain::LLM::AwsBedrock.new(llm_options: {})
+  #    llm = Langchain::LLM::AwsBedrock.new(default_options: {})
   #
   class AwsBedrock < Base
     DEFAULTS = {
-      chat_completion_model_name: "anthropic.claude-v2",
-      completion_model_name: "anthropic.claude-v2",
-      embeddings_model_name: "amazon.titan-embed-text-v1",
+      chat_model: "anthropic.claude-3-5-sonnet-20240620-v1:0",
+      completion_model: "anthropic.claude-v2:1",
+      embedding_model: "amazon.titan-embed-text-v1",
       max_tokens_to_sample: 300,
       temperature: 1,
       top_k: 250,
       top_p: 0.999,
       stop_sequences: ["\n\nHuman:"],
-      anthropic_version: "bedrock-2023-05-31",
-      return_likelihoods: "NONE",
-      count_penalty: {
-        scale: 0,
-        apply_to_whitespaces: false,
-        apply_to_punctuations: false,
-        apply_to_numbers: false,
-        apply_to_stopwords: false,
-        apply_to_emojis: false
-      },
-      presence_penalty: {
-        scale: 0,
-        apply_to_whitespaces: false,
-        apply_to_punctuations: false,
-        apply_to_numbers: false,
-        apply_to_stopwords: false,
-        apply_to_emojis: false
-      },
-      frequency_penalty: {
-        scale: 0,
-        apply_to_whitespaces: false,
-        apply_to_punctuations: false,
-        apply_to_numbers: false,
-        apply_to_stopwords: false,
-        apply_to_emojis: false
-      }
+      return_likelihoods: "NONE"
     }.freeze
 
     attr_reader :client, :defaults
 
-    SUPPORTED_COMPLETION_PROVIDERS = %i[anthropic ai21 cohere meta].freeze
-    SUPPORTED_CHAT_COMPLETION_PROVIDERS = %i[anthropic].freeze
-    SUPPORTED_EMBEDDING_PROVIDERS = %i[amazon cohere].freeze
+    SUPPORTED_COMPLETION_PROVIDERS = %i[
+      anthropic
+      ai21
+      cohere
+      meta
+    ].freeze
+
+    SUPPORTED_CHAT_COMPLETION_PROVIDERS = %i[
+      anthropic
+      ai21
+      mistral
+    ].freeze
+
+    SUPPORTED_EMBEDDING_PROVIDERS = %i[
+      amazon
+      cohere
+    ].freeze
 
     def initialize(aws_client_options: {}, default_options: {})
       depends_on "aws-sdk-bedrockruntime", req: "aws-sdk-bedrockruntime"
@@ -60,12 +49,11 @@ module Langchain::LLM
       @defaults = DEFAULTS.merge(default_options)
 
       chat_parameters.update(
-        model: {default: @defaults[:chat_completion_model_name]},
+        model: {default: @defaults[:chat_model]},
         temperature: {},
         max_tokens: {default: @defaults[:max_tokens_to_sample]},
         metadata: {},
-        system: {},
-        anthropic_version: {default: "bedrock-2023-05-31"}
+        system: {}
       )
       chat_parameters.ignore(:n, :user)
       chat_parameters.remap(stop: :stop_sequences)
@@ -84,7 +72,7 @@ module Langchain::LLM
       parameters = compose_embedding_parameters params.merge(text:)
 
       response = client.invoke_model({
-        model_id: @defaults[:embeddings_model_name],
+        model_id: @defaults[:embedding_model],
         body: parameters.to_json,
         content_type: "application/json",
         accept: "application/json"
@@ -100,23 +88,25 @@ module Langchain::LLM
     # @param params  extra parameters passed to Aws::BedrockRuntime::Client#invoke_model
     # @return [Langchain::LLM::AnthropicResponse], [Langchain::LLM::CohereResponse] or [Langchain::LLM::AI21Response] Response object
     #
-    def complete(prompt:, **params)
-      raise "Completion provider #{completion_provider} is not supported." unless SUPPORTED_COMPLETION_PROVIDERS.include?(completion_provider)
+    def complete(
+      prompt:,
+      model: @defaults[:completion_model],
+      **params
+    )
+      raise "Completion provider #{model} is not supported." unless SUPPORTED_COMPLETION_PROVIDERS.include?(provider_name(model))
 
-      raise "Model #{@defaults[:completion_model_name]} only supports #chat." if @defaults[:completion_model_name].include?("claude-3")
-
-      parameters = compose_parameters params
+      parameters = compose_parameters(params, model)
 
       parameters[:prompt] = wrap_prompt prompt
 
       response = client.invoke_model({
-        model_id: @defaults[:completion_model_name],
+        model_id: model,
         body: parameters.to_json,
         content_type: "application/json",
         accept: "application/json"
       })
 
-      parse_response response
+      parse_response(response, model)
     end
 
     # Generate a chat completion for a given prompt
@@ -126,7 +116,7 @@ module Langchain::LLM
     # @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 [String] :model The model to use for completion defaults to @defaults[:chat_model]
     # @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
@@ -137,10 +127,11 @@ module Langchain::LLM
     # @return [Langchain::LLM::AnthropicResponse] Response object
     def chat(params = {}, &block)
       parameters = chat_parameters.to_params(params)
+      parameters = compose_parameters(parameters, parameters[:model])
 
-      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)
+      unless SUPPORTED_CHAT_COMPLETION_PROVIDERS.include?(provider_name(parameters[:model]))
+        raise "Chat provider #{parameters[:model]} is not supported."
+      end
 
       if block
         response_chunks = []
@@ -168,18 +159,32 @@ module Langchain::LLM
           accept: "application/json"
         })
 
-        parse_response response
+        parse_response(response, parameters[:model])
       end
     end
 
     private
 
+    def parse_model_id(model_id)
+      model_id
+        .gsub("us.", "") # Meta append "us." to their model ids
+        .split(".")
+    end
+
+    def provider_name(model_id)
+      parse_model_id(model_id).first.to_sym
+    end
+
+    def model_name(model_id)
+      parse_model_id(model_id).last
+    end
+
     def completion_provider
-      @defaults[:completion_model_name].split(".").first.to_sym
+      @defaults[:completion_model].split(".").first.to_sym
     end
 
     def embedding_provider
-      @defaults[:embeddings_model_name].split(".").first.to_sym
+      @defaults[:embedding_model].split(".").first.to_sym
     end
 
     def wrap_prompt(prompt)
@@ -200,15 +205,17 @@ module Langchain::LLM
       end
     end
 
-    def compose_parameters(params)
-      if completion_provider == :anthropic
-        compose_parameters_anthropic params
-      elsif completion_provider == :cohere
-        compose_parameters_cohere params
-      elsif completion_provider == :ai21
-        compose_parameters_ai21 params
-      elsif completion_provider == :meta
-        compose_parameters_meta params
+    def compose_parameters(params, model_id)
+      if provider_name(model_id) == :anthropic
+        compose_parameters_anthropic(params)
+      elsif provider_name(model_id) == :cohere
+        compose_parameters_cohere(params)
+      elsif provider_name(model_id) == :ai21
+        params
+      elsif provider_name(model_id) == :meta
+        params
+      elsif provider_name(model_id) == :mistral
+        params
       end
     end
 
@@ -220,15 +227,17 @@ module Langchain::LLM
       end
     end
 
-    def parse_response(response)
-      if completion_provider == :anthropic
+    def parse_response(response, model_id)
+      if provider_name(model_id) == :anthropic
         Langchain::LLM::AnthropicResponse.new(JSON.parse(response.body.string))
-      elsif completion_provider == :cohere
+      elsif provider_name(model_id) == :cohere
         Langchain::LLM::CohereResponse.new(JSON.parse(response.body.string))
-      elsif completion_provider == :ai21
+      elsif provider_name(model_id) == :ai21
         Langchain::LLM::AI21Response.new(JSON.parse(response.body.string, symbolize_names: true))
-      elsif completion_provider == :meta
+      elsif provider_name(model_id) == :meta
         Langchain::LLM::AwsBedrockMetaResponse.new(JSON.parse(response.body.string))
+      elsif provider_name(model_id) == :mistral
+        Langchain::LLM::MistralAIResponse.new(JSON.parse(response.body.string))
       end
     end
 
@@ -276,61 +285,7 @@ module Langchain::LLM
     end
 
     def compose_parameters_anthropic(params)
-      default_params = @defaults.merge(params)
-
-      {
-        max_tokens_to_sample: default_params[:max_tokens_to_sample],
-        temperature: default_params[:temperature],
-        top_k: default_params[:top_k],
-        top_p: default_params[:top_p],
-        stop_sequences: default_params[:stop_sequences],
-        anthropic_version: default_params[:anthropic_version]
-      }
-    end
-
-    def compose_parameters_ai21(params)
-      default_params = @defaults.merge(params)
-
-      {
-        maxTokens: default_params[:max_tokens_to_sample],
-        temperature: default_params[:temperature],
-        topP: default_params[:top_p],
-        stopSequences: default_params[:stop_sequences],
-        countPenalty: {
-          scale: default_params[:count_penalty][:scale],
-          applyToWhitespaces: default_params[:count_penalty][:apply_to_whitespaces],
-          applyToPunctuations: default_params[:count_penalty][:apply_to_punctuations],
-          applyToNumbers: default_params[:count_penalty][:apply_to_numbers],
-          applyToStopwords: default_params[:count_penalty][:apply_to_stopwords],
-          applyToEmojis: default_params[:count_penalty][:apply_to_emojis]
-        },
-        presencePenalty: {
-          scale: default_params[:presence_penalty][:scale],
-          applyToWhitespaces: default_params[:presence_penalty][:apply_to_whitespaces],
-          applyToPunctuations: default_params[:presence_penalty][:apply_to_punctuations],
-          applyToNumbers: default_params[:presence_penalty][:apply_to_numbers],
-          applyToStopwords: default_params[:presence_penalty][:apply_to_stopwords],
-          applyToEmojis: default_params[:presence_penalty][:apply_to_emojis]
-        },
-        frequencyPenalty: {
-          scale: default_params[:frequency_penalty][:scale],
-          applyToWhitespaces: default_params[:frequency_penalty][:apply_to_whitespaces],
-          applyToPunctuations: default_params[:frequency_penalty][:apply_to_punctuations],
-          applyToNumbers: default_params[:frequency_penalty][:apply_to_numbers],
-          applyToStopwords: default_params[:frequency_penalty][:apply_to_stopwords],
-          applyToEmojis: default_params[:frequency_penalty][:apply_to_emojis]
-        }
-      }
-    end
-
-    def compose_parameters_meta(params)
-      default_params = @defaults.merge(params)
-
-      {
-        temperature: default_params[:temperature],
-        top_p: default_params[:top_p],
-        max_gen_len: default_params[:max_tokens_to_sample]
-      }
+      params.merge(anthropic_version: "bedrock-2023-05-31")
     end
 
     def response_from_chunks(chunks)

data/lib/langchain/llm/azure.rb

@@ -33,7 +33,7 @@ module Langchain::LLM
       )
       @defaults = DEFAULTS.merge(default_options)
       chat_parameters.update(
-        model: {default: @defaults[:chat_completion_model_name]},
+        model: {default: @defaults[:chat_model]},
         logprobs: {},
         top_logprobs: {},
         n: {default: @defaults[:n]},

data/lib/langchain/llm/base.rb

@@ -34,7 +34,7 @@ module Langchain::LLM
       default_dimensions
     end
 
-    # Returns the number of vector dimensions used by DEFAULTS[:chat_completion_model_name]
+    # Returns the number of vector dimensions used by DEFAULTS[:chat_model]
     #
     # @return [Integer] Vector dimensions
     def default_dimensions

data/lib/langchain/llm/cohere.rb

@@ -13,9 +13,9 @@ module Langchain::LLM
   class Cohere < Base
     DEFAULTS = {
       temperature: 0.0,
-      completion_model_name: "command",
-      chat_completion_model_name: "command-r-plus",
-      embeddings_model_name: "small",
+      completion_model: "command",
+      chat_model: "command-r-plus",
+      embedding_model: "small",
       dimensions: 1024,
       truncate: "START"
     }.freeze
@@ -26,7 +26,7 @@ module Langchain::LLM
       @client = ::Cohere::Client.new(api_key: api_key)
       @defaults = DEFAULTS.merge(default_options)
       chat_parameters.update(
-        model: {default: @defaults[:chat_completion_model_name]},
+        model: {default: @defaults[:chat_model]},
         temperature: {default: @defaults[:temperature]},
         response_format: {default: @defaults[:response_format]}
       )
@@ -48,10 +48,10 @@ module Langchain::LLM
     def embed(text:)
       response = client.embed(
         texts: [text],
-        model: @defaults[:embeddings_model_name]
+        model: @defaults[:embedding_model]
       )
 
-      Langchain::LLM::CohereResponse.new response, model: @defaults[:embeddings_model_name]
+      Langchain::LLM::CohereResponse.new response, model: @defaults[:embedding_model]
     end
 
     #
@@ -65,7 +65,7 @@ module Langchain::LLM
       default_params = {
         prompt: prompt,
         temperature: @defaults[:temperature],
-        model: @defaults[:completion_model_name],
+        model: @defaults[:completion_model],
         truncate: @defaults[:truncate]
       }
 
@@ -76,7 +76,7 @@ module Langchain::LLM
       default_params.merge!(params)
 
       response = client.generate(**default_params)
-      Langchain::LLM::CohereResponse.new response, model: @defaults[:completion_model_name]
+      Langchain::LLM::CohereResponse.new response, model: @defaults[:completion_model]
     end
 
     # Generate a chat completion for given messages

data/lib/langchain/llm/google_gemini.rb

@@ -5,8 +5,8 @@ module Langchain::LLM
   #     llm = Langchain::LLM::GoogleGemini.new(api_key: ENV['GOOGLE_GEMINI_API_KEY'])
   class GoogleGemini < Base
     DEFAULTS = {
-      chat_completion_model_name: "gemini-1.5-pro-latest",
-      embeddings_model_name: "text-embedding-004",
+      chat_model: "gemini-1.5-pro-latest",
+      embedding_model: "text-embedding-004",
       temperature: 0.0
     }
 
@@ -17,10 +17,10 @@ module Langchain::LLM
       @defaults = DEFAULTS.merge(default_options)
 
       chat_parameters.update(
-        model: {default: @defaults[:chat_completion_model_name]},
+        model: {default: @defaults[:chat_model]},
         temperature: {default: @defaults[:temperature]},
         generation_config: {default: nil},
-        safety_settings: {default: nil}
+        safety_settings: {default: @defaults[:safety_settings]}
       )
       chat_parameters.remap(
         messages: :contents,
@@ -72,9 +72,8 @@ module Langchain::LLM
 
     def embed(
       text:,
-      model: @defaults[:embeddings_model_name]
+      model: @defaults[:embedding_model]
     )
-
       params = {
         content: {
           parts: [

data/lib/langchain/llm/google_vertex_ai.rb

@@ -17,8 +17,8 @@ module Langchain::LLM
       top_p: 0.8,
       top_k: 40,
       dimensions: 768,
-      embeddings_model_name: "textembedding-gecko",
-      chat_completion_model_name: "gemini-1.0-pro"
+      embedding_model: "textembedding-gecko",
+      chat_model: "gemini-1.0-pro"
     }.freeze
 
     # Google Cloud has a project id and a specific region of deployment.
@@ -38,8 +38,9 @@ module Langchain::LLM
       @defaults = DEFAULTS.merge(default_options)
 
       chat_parameters.update(
-        model: {default: @defaults[:chat_completion_model_name]},
-        temperature: {default: @defaults[:temperature]}
+        model: {default: @defaults[:chat_model]},
+        temperature: {default: @defaults[:temperature]},
+        safety_settings: {default: @defaults[:safety_settings]}
       )
       chat_parameters.remap(
         messages: :contents,
@@ -57,7 +58,7 @@ module Langchain::LLM
     #
     def embed(
       text:,
-      model: @defaults[:embeddings_model_name]
+      model: @defaults[:embedding_model]
     )
       params = {instances: [{content: text}]}
 

data/lib/langchain/llm/hugging_face.rb

@@ -12,7 +12,7 @@ module Langchain::LLM
   #
   class HuggingFace < Base
     DEFAULTS = {
-      embeddings_model_name: "sentence-transformers/all-MiniLM-L6-v2"
+      embedding_model: "sentence-transformers/all-MiniLM-L6-v2"
     }.freeze
 
     EMBEDDING_SIZES = {
@@ -36,7 +36,7 @@ module Langchain::LLM
     def default_dimensions
       # since Huggin Face can run multiple models, look it up or generate an embedding and return the size
       @default_dimensions ||= @defaults[:dimensions] ||
-        EMBEDDING_SIZES.fetch(@defaults[:embeddings_model_name].to_sym) do
+        EMBEDDING_SIZES.fetch(@defaults[:embedding_model].to_sym) do
           embed(text: "test").embedding.size
         end
     end
@@ -50,9 +50,9 @@ module Langchain::LLM
     def embed(text:)
       response = client.embedding(
         input: text,
-        model: @defaults[:embeddings_model_name]
+        model: @defaults[:embedding_model]
       )
-      Langchain::LLM::HuggingFaceResponse.new(response, model: @defaults[:embeddings_model_name])
+      Langchain::LLM::HuggingFaceResponse.new(response, model: @defaults[:embedding_model])
     end
   end
 end