langchainrb 0.12.0 → 0.13.0

data/lib/langchain/llm/base.rb

@@ -11,7 +11,8 @@ module Langchain::LLM
   # - {Langchain::LLM::Azure}
   # - {Langchain::LLM::Cohere}
   # - {Langchain::LLM::GooglePalm}
-  # - {Langchain::LLM::GoogleVertexAi}
+  # - {Langchain::LLM::GoogleVertexAI}
+  # - {Langchain::LLM::GoogleGemini}
   # - {Langchain::LLM::HuggingFace}
   # - {Langchain::LLM::LlamaCpp}
   # - {Langchain::LLM::OpenAI}
@@ -24,6 +25,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 +71,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/google_gemini.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Langchain::LLM
+  # Usage:
+  #     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",
+      temperature: 0.0
+    }
+
+    attr_reader :defaults, :api_key
+
+    def initialize(api_key:, default_options: {})
+      @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(
+        messages: :contents,
+        system: :system_instruction,
+        tool_choice: :tool_config
+      )
+    end
+
+    # Generate a chat completion for a given prompt
+    #
+    # @param messages [Array<Hash>] List of messages comprising the conversation so far
+    # @param model [String] The model to use
+    # @param tools [Array<Hash>] A list of Tools the model may use to generate the next response
+    # @param tool_choice [String] Specifies the mode in which function calling should execute. If unspecified, the default value will be set to AUTO. Possible values: AUTO, ANY, NONE
+    # @param system [String] Developer set system instruction
+    def chat(params = {})
+      params[:system] = {parts: [{text: params[:system]}]} if params[:system]
+      params[:tools] = {function_declarations: params[:tools]} if params[:tools]
+      params[:tool_choice] = {function_calling_config: {mode: params[:tool_choice].upcase}} if params[:tool_choice]
+
+      raise ArgumentError.new("messages argument is required") if Array(params[:messages]).empty?
+
+      parameters = chat_parameters.to_params(params)
+      parameters[:generation_config] = {temperature: parameters.delete(:temperature)} if parameters[:temperature]
+
+      uri = URI("https://generativelanguage.googleapis.com/v1beta/models/#{parameters[:model]}:generateContent?key=#{api_key}")
+
+      request = Net::HTTP::Post.new(uri)
+      request.content_type = "application/json"
+      request.body = parameters.to_json
+
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+        http.request(request)
+      end
+
+      parsed_response = JSON.parse(response.body)
+
+      wrapped_response = Langchain::LLM::GoogleGeminiResponse.new(parsed_response, model: parameters[:model])
+
+      if wrapped_response.chat_completion || Array(wrapped_response.tool_calls).any?
+        wrapped_response
+      else
+        raise StandardError.new(response)
+      end
+    end
+  end
+end

data/lib/langchain/llm/google_vertex_ai.rb

@@ -2,150 +2,106 @@
 
 module Langchain::LLM
   #
-  # Wrapper around the Google Vertex AI APIs: https://cloud.google.com/vertex-ai?hl=en
+  # Wrapper around the Google Vertex AI APIs: https://cloud.google.com/vertex-ai
   #
   # Gem requirements:
-  #     gem "google-apis-aiplatform_v1", "~> 0.7"
+  #     gem "googleauth"
   #
   # Usage:
-  #     google_palm = Langchain::LLM::GoogleVertexAi.new(project_id: ENV["GOOGLE_VERTEX_AI_PROJECT_ID"])
+  #     llm = Langchain::LLM::GoogleVertexAI.new(project_id: ENV["GOOGLE_VERTEX_AI_PROJECT_ID"], region: "us-central1")
   #
-  class GoogleVertexAi < Base
+  class GoogleVertexAI < Base
     DEFAULTS = {
-      temperature: 0.1, # 0.1 is the default in the API, quite low ("grounded")
+      temperature: 0.1,
       max_output_tokens: 1000,
       top_p: 0.8,
       top_k: 40,
       dimensions: 768,
-      completion_model_name: "text-bison", # Optional: tect-bison@001
-      embeddings_model_name: "textembedding-gecko"
+      embeddings_model_name: "textembedding-gecko",
+      chat_completion_model_name: "gemini-1.0-pro"
     }.freeze
 
-    # TODO: Implement token length validation
-    # LENGTH_VALIDATOR = Langchain::Utils::TokenLength::...
-
     # Google Cloud has a project id and a specific region of deployment.
     # For GenAI-related things, a safe choice is us-central1.
-    attr_reader :project_id, :client, :region
-
-    def initialize(project_id:, default_options: {})
-      depends_on "google-apis-aiplatform_v1"
+    attr_reader :defaults, :url, :authorizer
 
-      @project_id = project_id
-      @region = default_options.fetch :region, "us-central1"
+    def initialize(project_id:, region:, default_options: {})
+      depends_on "googleauth"
 
-      @client = Google::Apis::AiplatformV1::AiplatformService.new
-
-      # TODO: Adapt for other regions; Pass it in via the constructor
-      # For the moment only us-central1 available so no big deal.
-      @client.root_url = "https://#{@region}-aiplatform.googleapis.com/"
-      @client.authorization = Google::Auth.get_application_default
+      @authorizer = ::Google::Auth.get_application_default
+      proj_id = project_id || @authorizer.project_id || @authorizer.quota_project_id
+      @url = "https://#{region}-aiplatform.googleapis.com/v1/projects/#{proj_id}/locations/#{region}/publishers/google/models/"
 
       @defaults = DEFAULTS.merge(default_options)
+
+      chat_parameters.update(
+        model: {default: @defaults[:chat_completion_model_name]},
+        temperature: {default: @defaults[:temperature]}
+      )
+      chat_parameters.remap(
+        messages: :contents,
+        system: :system_instruction,
+        tool_choice: :tool_config
+      )
     end
 
     #
     # Generate an embedding for a given text
     #
     # @param text [String] The text to generate an embedding for
-    # @return [Langchain::LLM::GoogleVertexAiResponse] Response object
+    # @param model [String] ID of the model to use
+    # @return [Langchain::LLM::GoogleGeminiResponse] Response object
     #
-    def embed(text:)
-      content = [{content: text}]
-      request = Google::Apis::AiplatformV1::GoogleCloudAiplatformV1PredictRequest.new(instances: content)
-
-      api_path = "projects/#{@project_id}/locations/us-central1/publishers/google/models/#{@defaults[:embeddings_model_name]}"
-
-      # puts("api_path: #{api_path}")
-
-      response = client.predict_project_location_publisher_model(api_path, request)
+    def embed(
+      text:,
+      model: @defaults[:embeddings_model_name]
+    )
+      params = {instances: [{content: text}]}
+
+      response = HTTParty.post(
+        "#{url}#{model}:predict",
+        body: params.to_json,
+        headers: {
+          "Content-Type" => "application/json",
+          "Authorization" => "Bearer #{@authorizer.fetch_access_token!["access_token"]}"
+        }
+      )
 
-      Langchain::LLM::GoogleVertexAiResponse.new(response.to_h, model: @defaults[:embeddings_model_name])
+      Langchain::LLM::GoogleGeminiResponse.new(response, model: model)
     end
 
+    # Generate a chat completion for given messages
     #
-    # Generate a completion for a given prompt
-    #
-    # @param prompt [String] The prompt to generate a completion for
-    # @param params extra parameters passed to GooglePalmAPI::Client#generate_text
-    # @return [Langchain::LLM::GooglePalmResponse] Response object
-    #
-    def complete(prompt:, **params)
-      default_params = {
-        prompt: prompt,
-        temperature: @defaults[:temperature],
-        top_k: @defaults[:top_k],
-        top_p: @defaults[:top_p],
-        max_output_tokens: @defaults[:max_output_tokens],
-        model: @defaults[:completion_model_name]
-      }
-
-      if params[:stop_sequences]
-        default_params[:stop_sequences] = params.delete(:stop_sequences)
+    # @param messages [Array<Hash>] Input messages
+    # @param model [String] The model that will complete your prompt
+    # @param tools [Array<Hash>] The tools to use
+    # @param tool_choice [String] The tool choice to use
+    # @param system [String] The system instruction to use
+    # @return [Langchain::LLM::GoogleGeminiResponse] Response object
+    def chat(params = {})
+      params[:system] = {parts: [{text: params[:system]}]} if params[:system]
+      params[:tools] = {function_declarations: params[:tools]} if params[:tools]
+      params[:tool_choice] = {function_calling_config: {mode: params[:tool_choice].upcase}} if params[:tool_choice]
+
+      raise ArgumentError.new("messages argument is required") if Array(params[:messages]).empty?
+
+      parameters = chat_parameters.to_params(params)
+      parameters[:generation_config] = {temperature: parameters.delete(:temperature)} if parameters[:temperature]
+
+      uri = URI("#{url}#{parameters[:model]}:generateContent")
+
+      request = Net::HTTP::Post.new(uri)
+      request.content_type = "application/json"
+      request["Authorization"] = "Bearer #{@authorizer.fetch_access_token!["access_token"]}"
+      request.body = parameters.to_json
+
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+        http.request(request)
       end
 
-      if params[:max_output_tokens]
-        default_params[:max_output_tokens] = params.delete(:max_output_tokens)
-      end
-
-      # to be tested
-      temperature = params.delete(:temperature) || @defaults[:temperature]
-      max_output_tokens = default_params.fetch(:max_output_tokens, @defaults[:max_output_tokens])
-
-      default_params.merge!(params)
-
-      # response = client.generate_text(**default_params)
-      request = Google::Apis::AiplatformV1::GoogleCloudAiplatformV1PredictRequest.new \
-        instances: [{
-          prompt: prompt # key used to be :content, changed to :prompt
-        }],
-        parameters: {
-          temperature: temperature,
-          maxOutputTokens: max_output_tokens,
-          topP: 0.8,
-          topK: 40
-        }
-
-      response = client.predict_project_location_publisher_model \
-        "projects/#{project_id}/locations/us-central1/publishers/google/models/#{@defaults[:completion_model_name]}",
-        request
-
-      Langchain::LLM::GoogleVertexAiResponse.new(response, model: default_params[:model])
-    end
+      parsed_response = JSON.parse(response.body)
 
-    #
-    # Generate a summarization for a given text
-    #
-    # @param text [String] The text to generate a summarization for
-    # @return [String] The summarization
-    #
-    # TODO(ricc): add params for Temp, topP, topK, MaxTokens and have it default to these 4 values.
-    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,
-        # For best temperature, topP, topK, MaxTokens for summarization: see
-        # https://cloud.google.com/vertex-ai/docs/samples/aiplatform-sdk-summarization
-        temperature: 0.2,
-        top_p: 0.95,
-        top_k: 40,
-        # Most models have a context length of 2048 tokens (except for the newest models, which support 4096).
-        max_output_tokens: 256
-      )
+      Langchain::LLM::GoogleGeminiResponse.new(parsed_response, model: parameters[:model])
     end
-
-    # def chat(...)
-    # https://cloud.google.com/vertex-ai/docs/samples/aiplatform-sdk-chathat
-    # Chat params: https://cloud.google.com/vertex-ai/docs/samples/aiplatform-sdk-chat
-    # \"temperature\": 0.3,\n"
-    #       + "  \"maxDecodeSteps\": 200,\n"
-    #       + "  \"topP\": 0.8,\n"
-    #       + "  \"topK\": 40\n"
-    #       + "}";
-    # end
   end
 end

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