langchainrb 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f29aad35bc35dc95eb8673b11578b51c7449a19818989d9da5e640c6fb219c7
-  data.tar.gz: 4d0c4d3d424a82c7f02fb9e49ca52a5bdca5dfbce19fbfa22f2d74ef46d81eb7
+  metadata.gz: b146eb8568d30ae12aca93a25818fcff7421b7ee2e968330f3a68c5e523da148
+  data.tar.gz: 33f88d7ba03501606706314dce58f626fa0df5aab50639b5f5db3df527ee6520
 SHA512:
-  metadata.gz: 91b6f4fc5056308eab9119dcfda1be16857e6e9e6e531977148b1e8f31b72090794b67e6855afb95633b8f836b8d20921bc5a069afdc745d1114892143a177e1
-  data.tar.gz: f7a7949ab2efd960eacf3a93f7beaa9104403a93619b8c95ea094901c2d3d19b89980c81d293ae16035c5ff51fe021a09f2e81e2c0ed6854bff87d30e6def925
+  metadata.gz: 6518e30de12653426280f6f8cf05f37a6d4b311ad4219af52276bace8a75ec6440b8f42c208d9d5c07bb4218f3259cc95ea9edd77f8ba037e7a1600a7dfa3170
+  data.tar.gz: 7f881a4347866c8b52161adaf6b98b669e38b4e2fd1ac513f02efd1dcfe73b2552ad8e65acdd02e9e002769ad3b394850f720e0971774632c2f489c25d9ce076

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [Unreleased]
 
+## [0.13.0] - 2024-05-14
+- New 🛠️ `Langchain::Tool::NewsRetriever` tool to fetch news via newsapi.org
+- Langchain::Assistant works with `Langchain::LLM::GoogleVertexAI` and `Langchain::LLM::GoogleGemini` llms
+- [BREAKING] Introduce new `Langchain::Messages::Base` abstraction
+
+## [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/README.md

@@ -412,6 +412,7 @@ Assistants are Agent-like objects that leverage helpful instructions, LLMs, tool
 | "file_system"   | Interacts with the file system |                                                               |       |
 | "ruby_code_interpreter" | Interprets Ruby expressions             |                                                               | `gem "safe_ruby", "~> 1.0.4"`             |
 | "google_search"     | A wrapper around Google Search                     | `ENV["SERPAPI_API_KEY"]` (https://serpapi.com/manage-api-key) | `gem "google_search_results", "~> 2.0.0"` |
+| "news_retriever"     | A wrapper around NewsApi.org                     | `ENV["NEWS_API_KEY"]` (https://newsapi.org/) |  |
 | "weather"  | Calls Open Weather API to retrieve the current weather        |      `ENV["OPEN_WEATHER_API_KEY"]` (https://home.openweathermap.org/api_keys)               | `gem "open-weather-ruby-client", "~> 0.3.0"`    |
 | "wikipedia"  | Calls Wikipedia API to retrieve the summary        |                                                               | `gem "wikipedia-client", "~> 1.17.0"`     |
 
@@ -445,14 +446,14 @@ assistant = Langchain::Assistant.new(
   thread: thread,
   instructions: "You are a Meteorologist Assistant that is able to pull the weather for any location",
   tools: [
-    Langchain::Tool::GoogleSearch.new(api_key: ENV["SERPAPI_API_KEY"])
+    Langchain::Tool::Weather.new(api_key: ENV["OPEN_WEATHER_API_KEY"])
   ]
 )
 ```
 ### Using an Assistant
 You can now add your message to an Assistant.
 ```ruby
-assistant.add_message content: "What's the weather in New York City?"
+assistant.add_message content: "What's the weather in New York, New York?"
 ```
 
 Run the Assistant to generate a response. 

data/lib/langchain/assistants/assistant.rb

@@ -7,6 +7,12 @@ module Langchain
     attr_reader :llm, :thread, :instructions
     attr_accessor :tools
 
+    SUPPORTED_LLMS = [
+      Langchain::LLM::OpenAI,
+      Langchain::LLM::GoogleGemini,
+      Langchain::LLM::GoogleVertexAI
+    ]
+
     # Create a new assistant
     #
     # @param llm [Langchain::LLM::Base] LLM instance that the assistant will use
@@ -19,7 +25,9 @@ module Langchain
       tools: [],
       instructions: nil
     )
-      raise ArgumentError, "Invalid LLM; currently only Langchain::LLM::OpenAI is supported" unless llm.instance_of?(Langchain::LLM::OpenAI)
+      unless SUPPORTED_LLMS.include?(llm.class)
+        raise ArgumentError, "Invalid LLM; currently only #{SUPPORTED_LLMS.join(", ")} are supported"
+      end
       raise ArgumentError, "Thread must be an instance of Langchain::Thread" unless thread.is_a?(Langchain::Thread)
       raise ArgumentError, "Tools must be an array of Langchain::Tool::Base instance(s)" unless tools.is_a?(Array) && tools.all? { |tool| tool.is_a?(Langchain::Tool::Base) }
 
@@ -30,7 +38,10 @@ module Langchain
 
       # The first message in the thread should be the system instructions
       # TODO: What if the user added old messages and the system instructions are already in there? Should this overwrite the existing instructions?
-      add_message(role: "system", content: instructions) if instructions
+      if llm.is_a?(Langchain::LLM::OpenAI)
+        add_message(role: "system", content: instructions) if instructions
+      end
+      # For Google Gemini, system instructions are added to the `system:` param in the `chat` method
     end
 
     # Add a user message to the thread
@@ -59,11 +70,12 @@ module Langchain
 
       while running
         # TODO: I think we need to look at all messages and not just the last one.
-        case (last_message = thread.messages.last).role
-        when "system"
+        last_message = thread.messages.last
+
+        if last_message.system?
           # Do nothing
           running = false
-        when "assistant"
+        elsif last_message.llm?
           if last_message.tool_calls.any?
             if auto_tool_execution
               run_tools(last_message.tool_calls)
@@ -76,11 +88,11 @@ module Langchain
             # Do nothing
             running = false
           end
-        when "user"
+        elsif last_message.user?
           # Run it!
           response = chat_with_llm
 
-          if response.tool_calls
+          if response.tool_calls.any?
             # Re-run the while(running) loop to process the tool calls
             running = true
             add_message(role: response.role, tool_calls: response.tool_calls)
@@ -89,12 +101,12 @@ module Langchain
             running = false
             add_message(role: response.role, content: response.chat_completion)
           end
-        when "tool"
+        elsif last_message.tool?
           # Run it!
           response = chat_with_llm
           running = true
 
-          if response.tool_calls
+          if response.tool_calls.any?
             add_message(role: response.role, tool_calls: response.tool_calls)
           elsif response.chat_completion
             add_message(role: response.role, content: response.chat_completion)
@@ -121,8 +133,14 @@ module Langchain
     # @param output [String] The output of the tool
     # @return [Array<Langchain::Message>] The messages in the thread
     def submit_tool_output(tool_call_id:, output:)
-      # TODO: Validate that `tool_call_id` is valid
-      add_message(role: "tool", content: output, tool_call_id: tool_call_id)
+      tool_role = if llm.is_a?(Langchain::LLM::OpenAI)
+        Langchain::Messages::OpenAIMessage::TOOL_ROLE
+      elsif [Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI].include?(llm.class)
+        Langchain::Messages::GoogleGeminiMessage::TOOL_ROLE
+      end
+
+      # TODO: Validate that `tool_call_id` is valid by scanning messages and checking if this tool call ID was invoked
+      add_message(role: tool_role, content: output, tool_call_id: tool_call_id)
     end
 
     # Delete all messages in the thread
@@ -156,10 +174,15 @@ module Langchain
     def chat_with_llm
       Langchain.logger.info("Sending a call to #{llm.class}", for: self.class)
 
-      params = {messages: thread.openai_messages}
+      params = {messages: thread.array_of_message_hashes}
 
       if tools.any?
-        params[:tools] = tools.map(&:to_openai_tools).flatten
+        if llm.is_a?(Langchain::LLM::OpenAI)
+          params[:tools] = tools.map(&:to_openai_tools).flatten
+        elsif [Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI].include?(llm.class)
+          params[:tools] = tools.map(&:to_google_gemini_tools).flatten
+          params[:system] = instructions if instructions
+        end
         # TODO: Not sure that tool_choice should always be "auto"; Maybe we can let the user toggle it.
         params[:tool_choice] = "auto"
       end
@@ -173,11 +196,11 @@ module Langchain
     def run_tools(tool_calls)
       # Iterate over each function invocation and submit tool output
       tool_calls.each do |tool_call|
-        tool_call_id = tool_call.dig("id")
-
-        function_name = tool_call.dig("function", "name")
-        tool_name, method_name = function_name.split("-")
-        tool_arguments = JSON.parse(tool_call.dig("function", "arguments"), symbolize_names: true)
+        tool_call_id, tool_name, method_name, tool_arguments = if llm.is_a?(Langchain::LLM::OpenAI)
+          extract_openai_tool_call(tool_call: tool_call)
+        elsif [Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI].include?(llm.class)
+          extract_google_gemini_tool_call(tool_call: tool_call)
+        end
 
         tool_instance = tools.find do |t|
           t.name == tool_name
@@ -190,13 +213,41 @@ module Langchain
 
       response = chat_with_llm
 
-      if response.tool_calls
+      if response.tool_calls.any?
         add_message(role: response.role, tool_calls: response.tool_calls)
       elsif response.chat_completion
         add_message(role: response.role, content: response.chat_completion)
       end
     end
 
+    # Extract the tool call information from the OpenAI tool call hash
+    #
+    # @param tool_call [Hash] The tool call hash
+    # @return [Array] The tool call information
+    def extract_openai_tool_call(tool_call:)
+      tool_call_id = tool_call.dig("id")
+
+      function_name = tool_call.dig("function", "name")
+      tool_name, method_name = function_name.split("__")
+      tool_arguments = JSON.parse(tool_call.dig("function", "arguments"), symbolize_names: true)
+
+      [tool_call_id, tool_name, method_name, tool_arguments]
+    end
+
+    # Extract the tool call information from the Google Gemini tool call hash
+    #
+    # @param tool_call [Hash] The tool call hash, format: {"functionCall"=>{"name"=>"weather__execute", "args"=>{"input"=>"NYC"}}}
+    # @return [Array] The tool call information
+    def extract_google_gemini_tool_call(tool_call:)
+      tool_call_id = tool_call.dig("functionCall", "name")
+
+      function_name = tool_call.dig("functionCall", "name")
+      tool_name, method_name = function_name.split("__")
+      tool_arguments = tool_call.dig("functionCall", "args").transform_keys(&:to_sym)
+
+      [tool_call_id, tool_name, method_name, tool_arguments]
+    end
+
     # Build a message
     #
     # @param role [String] The role of the message
@@ -205,7 +256,11 @@ module Langchain
     # @param tool_call_id [String] The ID of the tool call to include in the message
     # @return [Langchain::Message] The Message object
     def build_message(role:, content: nil, tool_calls: [], tool_call_id: nil)
-      Message.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+      if llm.is_a?(Langchain::LLM::OpenAI)
+        Langchain::Messages::OpenAIMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+      elsif [Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI].include?(llm.class)
+        Langchain::Messages::GoogleGeminiMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+      end
     end
 
     # TODO: Fix the message truncation when context window is exceeded

data/lib/langchain/assistants/messages/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Langchain
+  module Messages
+    class Base
+      attr_reader :role, :content, :tool_calls, :tool_call_id
+
+      # Check if the message came from a user
+      #
+      # @param [Boolean] true/false whether the message came from a user
+      def user?
+        role == "user"
+      end
+    end
+  end
+end

data/lib/langchain/assistants/messages/google_gemini_message.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Langchain
+  module Messages
+    class GoogleGeminiMessage < Base
+      # Google Gemini uses the following roles:
+      ROLES = [
+        "user",
+        "model",
+        "function"
+      ].freeze
+
+      TOOL_ROLE = "function"
+
+      # Initialize a new Google Gemini message
+      #
+      # @param [String] The role of the message
+      # @param [String] The content of the message
+      # @param [Array<Hash>] The tool calls made in the message
+      # @param [String] The ID of the tool call
+      def initialize(role:, content: nil, tool_calls: [], tool_call_id: nil)
+        raise ArgumentError, "Role must be one of #{ROLES.join(", ")}" unless ROLES.include?(role)
+        raise ArgumentError, "Tool calls must be an array of hashes" unless tool_calls.is_a?(Array) && tool_calls.all? { |tool_call| tool_call.is_a?(Hash) }
+
+        @role = role
+        # Some Tools return content as a JSON hence `.to_s`
+        @content = content.to_s
+        @tool_calls = tool_calls
+        @tool_call_id = tool_call_id
+      end
+
+      # Check if the message came from an LLM
+      #
+      # @return [Boolean] true/false whether this message was produced by an LLM
+      def llm?
+        model?
+      end
+
+      # Convert the message to a Google Gemini API-compatible hash
+      #
+      # @return [Hash] The message as a Google Gemini API-compatible hash
+      def to_hash
+        {}.tap do |h|
+          h[:role] = role
+          h[:parts] = if function?
+            [{
+              functionResponse: {
+                name: tool_call_id,
+                response: {
+                  name: tool_call_id,
+                  content: content
+                }
+              }
+            }]
+          elsif tool_calls.any?
+            tool_calls
+          else
+            [{text: content}]
+          end
+        end
+      end
+
+      # Google Gemini does not implement system prompts
+      def system?
+        false
+      end
+
+      # Check if the message is a tool call
+      #
+      # @return [Boolean] true/false whether this message is a tool call
+      def tool?
+        function?
+      end
+
+      # Check if the message is a tool call
+      #
+      # @return [Boolean] true/false whether this message is a tool call
+      def function?
+        role == "function"
+      end
+
+      # Check if the message came from an LLM
+      #
+      # @return [Boolean] true/false whether this message was produced by an LLM
+      def model?
+        role == "model"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Langchain
+  module Messages
+    class OpenAIMessage < Base
+      # OpenAI uses the following roles:
+      ROLES = [
+        "system",
+        "assistant",
+        "user",
+        "tool"
+      ].freeze
+
+      TOOL_ROLE = "tool"
+
+      # Initialize a new OpenAI message
+      #
+      # @param [String] The role of the message
+      # @param [String] The content of the message
+      # @param [Array<Hash>] The tool calls made in the message
+      # @param [String] The ID of the tool call
+      def initialize(role:, content: nil, tool_calls: [], tool_call_id: nil) # TODO: Implement image_file: reference (https://platform.openai.com/docs/api-reference/messages/object#messages/object-content)
+        raise ArgumentError, "Role must be one of #{ROLES.join(", ")}" unless ROLES.include?(role)
+        raise ArgumentError, "Tool calls must be an array of hashes" unless tool_calls.is_a?(Array) && tool_calls.all? { |tool_call| tool_call.is_a?(Hash) }
+
+        @role = role
+        # Some Tools return content as a JSON hence `.to_s`
+        @content = content.to_s
+        @tool_calls = tool_calls
+        @tool_call_id = tool_call_id
+      end
+
+      # Check if the message came from an LLM
+      #
+      # @return [Boolean] true/false whether this message was produced by an LLM
+      def llm?
+        assistant?
+      end
+
+      # Convert the message to an OpenAI API-compatible hash
+      #
+      # @return [Hash] The message as an OpenAI API-compatible hash
+      def to_hash
+        {}.tap do |h|
+          h[:role] = role
+          h[:content] = content if content # Content is nil for tool calls
+          h[:tool_calls] = tool_calls if tool_calls.any?
+          h[:tool_call_id] = tool_call_id if tool_call_id
+        end
+      end
+
+      # Check if the message came from an LLM
+      #
+      # @return [Boolean] true/false whether this message was produced by an LLM
+      def assistant?
+        role == "assistant"
+      end
+
+      # Check if the message are system instructions
+      #
+      # @return [Boolean] true/false whether this message are system instructions
+      def system?
+        role == "system"
+      end
+
+      # Check if the message is a tool call
+      #
+      # @return [Boolean] true/false whether this message is a tool call
+      def tool?
+        role == "tool"
+      end
+    end
+  end
+end

data/lib/langchain/assistants/thread.rb

@@ -8,16 +8,16 @@ module Langchain
 
     # @param messages [Array<Langchain::Message>]
     def initialize(messages: [])
-      raise ArgumentError, "messages array must only contain Langchain::Message instance(s)" unless messages.is_a?(Array) && messages.all? { |m| m.is_a?(Langchain::Message) }
+      raise ArgumentError, "messages array must only contain Langchain::Message instance(s)" unless messages.is_a?(Array) && messages.all? { |m| m.is_a?(Langchain::Messages::Base) }
 
       @messages = messages
     end
 
-    # Convert the thread to an OpenAI API-compatible array of hashes
+    # Convert the thread to an LLM APIs-compatible array of hashes
     #
     # @return [Array<Hash>] The thread as an OpenAI API-compatible array of hashes
-    def openai_messages
-      messages.map(&:to_openai_format)
+    def array_of_message_hashes
+      messages.map(&:to_hash)
     end
 
     # Add a message to the thread
@@ -25,7 +25,7 @@ module Langchain
     # @param message [Langchain::Message] The message to add
     # @return [Array<Langchain::Message>] The updated messages array
     def add_message(message)
-      raise ArgumentError, "message must be a Langchain::Message instance" unless message.is_a?(Langchain::Message)
+      raise ArgumentError, "message must be a Langchain::Message instance" unless message.is_a?(Langchain::Messages::Base)
 
       # Prepend the message to the thread
       messages << message

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(...)