langchainrb 0.14.0 → 0.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68900cd116cf0fb1b77376a4906e5551f0d578ee2bb47c7ec86d32bf44f84e33
-  data.tar.gz: f68782c3cdc856799778618d78b6411a85b0c69adf6a4d33489b8025fdca3dce
+  metadata.gz: a8a7ebf84076b609719daddc97e448f4d4fe987e8ee1eeaddb70df667f163d02
+  data.tar.gz: d52a9619b5913e8ce51563697e38841f9798e04f3caf294d7f331ff159eb70cb
 SHA512:
-  metadata.gz: 158410fd769caaf9074eddc1143ddee9256ac5a466a510c32b74d337eba62fab80b676661cbf1673604d236014a5cb4defdd4743e71abb713a659ddea0fe5e8c
-  data.tar.gz: 2e956356a443ff37ad711f6c42f8c4940925bcee4be075b403c78c3f702b487c12790dca9ba7d68a01acaf1c245b2910650b3f938e80cedd1fc2d5af14f7ffa8
+  metadata.gz: 2354d82608942a1744be426f23277b18fee508f539613327c9ed6f784d7da18f317d2266d356f3124eef93ea5052fe237f3fc639ff56db4b86060b08f16df1d2
+  data.tar.gz: 282873b85e832e9a872f007a5a6bf35400e22639c5c7f26ac535da4f06370f35d6de35a44d434ec81fedfcff1143a448440cf8bf76ae38e01d0ad5ec15f08dc7

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [0.15.1] - 2024-08-19
+- Drop `to_bool` gem in favour of custom util class
+- Drop `colorize` which is GPL-licensed in favour of `rainbow`
+- Improve Langchain::Tool::Weather tool
+
+## [0.15.0] - 2024-08-14
+- Fix Langchain::Assistant when llm is Anthropic
+- Fix GoogleGemini#chat method
+- Langchain::LLM::Weaviate initializer does not require api_key anymore
+- [BREAKING] Langchain::LLM::OpenAI#chat() uses `gpt-4o-mini` by default instead of `gpt-3.5-turbo` previously.
+- [BREAKING] Assistant works with a number of open-source models via Ollama.
+- [BREAKING] Introduce new `Langchain::ToolDefinition` module to define tools. This replaces the previous reliance on subclassing from `Langchain::Tool::Base`.
+
 ## [0.14.0] - 2024-07-12
 - Removed TokenLength validators
 - Assistant works with a Mistral LLM now
@@ -127,7 +140,7 @@
 - AWS Bedrock is available as an LLM provider. Available models from AI21, Cohere, AWS, and Anthropic.
 
 ## [0.7.3] - 2023-11-08
-- LLM response passes through the context in RAG cases 
+- LLM response passes through the context in RAG cases
 - Fix gpt-4 token length validation
 
 ## [0.7.2] - 2023-11-02
@@ -172,7 +185,7 @@
 
 ## [0.6.13] - 2023-08-23
 - Add `k:` parameter to all `ask()` vector search methods
-- Bump Faraday to 2.x 
+- Bump Faraday to 2.x
 
 ## [0.6.12] - 2023-08-13
 

data/lib/langchain/assistants/assistant.rb

@@ -19,14 +19,6 @@ module Langchain
     attr_reader :total_prompt_tokens, :total_completion_tokens, :total_tokens
     attr_accessor :tools
 
-    SUPPORTED_LLMS = [
-      Langchain::LLM::Anthropic,
-      Langchain::LLM::GoogleGemini,
-      Langchain::LLM::GoogleVertexAI,
-      Langchain::LLM::Ollama,
-      Langchain::LLM::OpenAI
-    ]
-
     # Create a new assistant
     #
     # @param llm [Langchain::LLM::Base] LLM instance that the assistant will use
@@ -39,15 +31,12 @@ module Langchain
       tools: [],
       instructions: nil
     )
-      unless SUPPORTED_LLMS.include?(llm.class)
-        raise ArgumentError, "Invalid LLM; currently only #{SUPPORTED_LLMS.join(", ")} are supported"
-      end
-      if llm.is_a?(Langchain::LLM::Ollama)
-        raise ArgumentError, "Currently only `mistral:7b-instruct-v0.3-fp16` model is supported for Ollama LLM" unless llm.defaults[:completion_model_name] == "mistral:7b-instruct-v0.3-fp16"
+      unless tools.is_a?(Array) && tools.all? { |tool| tool.class.singleton_class.included_modules.include?(Langchain::ToolDefinition) }
+        raise ArgumentError, "Tools must be an array of objects extending Langchain::ToolDefinition"
       end
-      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) }
 
       @llm = llm
+      @llm_adapter = LLM::Adapter.build(llm)
       @thread = thread || Langchain::Thread.new
       @tools = tools
       @instructions = instructions
@@ -214,14 +203,7 @@ module Langchain
     def handle_user_or_tool_message
       response = chat_with_llm
 
-      # With Ollama, we're calling the `llm.complete()` method
-      content = if llm.is_a?(Langchain::LLM::Ollama)
-        response.completion
-      else
-        response.chat_completion
-      end
-
-      add_message(role: response.role, content: content, tool_calls: response.tool_calls)
+      add_message(role: response.role, content: response.chat_completion, tool_calls: response.tool_calls)
       record_used_tokens(response.prompt_tokens, response.completion_tokens, response.total_tokens)
 
       set_state_for(response: response)
@@ -247,7 +229,7 @@ module Langchain
       run_tools(thread.messages.last.tool_calls)
       :in_progress
     rescue => e
-      Langchain.logger.error("Error running tools: #{e.message}")
+      Langchain.logger.error("Error running tools: #{e.message}; #{e.backtrace.join('\n')}")
       :failed
     end
 
@@ -268,17 +250,7 @@ module Langchain
     end
 
     def initialize_instructions
-      if llm.is_a?(Langchain::LLM::Ollama)
-        content = String.new # rubocop: disable Performance/UnfreezeString
-        if tools.any?
-          content << %([AVAILABLE_TOOLS] #{tools.map(&:to_openai_tools).flatten}[/AVAILABLE_TOOLS])
-        end
-        if instructions
-          content << "[INST] #{instructions}[/INST]"
-        end
-
-        add_message(role: "system", content: content)
-      elsif llm.is_a?(Langchain::LLM::OpenAI)
+      if llm.is_a?(Langchain::LLM::OpenAI)
         add_message(role: "system", content: instructions) if instructions
       end
     end
@@ -289,36 +261,12 @@ module Langchain
     def chat_with_llm
       Langchain.logger.info("Sending a call to #{llm.class}", for: self.class)
 
-      params = {}
-
-      if llm.is_a?(Langchain::LLM::OpenAI)
-        if tools.any?
-          params[:tools] = tools.map(&:to_openai_tools).flatten
-          params[:tool_choice] = "auto"
-        end
-      elsif llm.is_a?(Langchain::LLM::Anthropic)
-        if tools.any?
-          params[:tools] = tools.map(&:to_anthropic_tools).flatten
-          params[:tool_choice] = {type: "auto"}
-        end
-        params[:system] = instructions if instructions
-      elsif [Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI].include?(llm.class)
-        if tools.any?
-          params[:tools] = tools.map(&:to_google_gemini_tools).flatten
-          params[:system] = instructions if instructions
-          params[:tool_choice] = "auto"
-        end
-      end
-      # TODO: Not sure that tool_choice should always be "auto"; Maybe we can let the user toggle it.
-
-      if llm.is_a?(Langchain::LLM::Ollama)
-        params[:raw] = true
-        params[:prompt] = thread.prompt_of_concatenated_messages
-        llm.complete(**params)
-      else
-        params[:messages] = thread.array_of_message_hashes
-        llm.chat(**params)
-      end
+      params = @llm_adapter.build_chat_params(
+        tools: @tools,
+        instructions: @instructions,
+        messages: thread.array_of_message_hashes
+      )
+      @llm.chat(**params)
     end
 
     # Run the tools automatically
@@ -327,18 +275,10 @@ 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_name, method_name, tool_arguments = if llm.is_a?(Langchain::LLM::Ollama)
-          extract_ollama_tool_call(tool_call: tool_call)
-        elsif 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)
-        elsif llm.is_a?(Langchain::LLM::Anthropic)
-          extract_anthropic_tool_call(tool_call: tool_call)
-        end
+        tool_call_id, tool_name, method_name, tool_arguments = @llm_adapter.extract_tool_call_args(tool_call: tool_call)
 
         tool_instance = tools.find do |t|
-          t.name == tool_name
+          t.class.tool_name == tool_name
         end or raise ArgumentError, "Tool not found in assistant.tools"
 
         output = tool_instance.send(method_name, **tool_arguments)
@@ -347,54 +287,6 @@ module Langchain
       end
     end
 
-    def extract_ollama_tool_call(tool_call:)
-      tool_name, method_name = tool_call.dig("name").split("__")
-      tool_arguments = tool_call.dig("arguments").transform_keys(&:to_sym)
-      [nil, tool_name, method_name, tool_arguments]
-    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 Anthropic tool call hash
-    #
-    # @param tool_call [Hash] The tool call hash, format: {"type"=>"tool_use", "id"=>"toolu_01TjusbFApEbwKPRWTRwzadR", "name"=>"news_retriever__get_top_headlines", "input"=>{"country"=>"us", "page_size"=>10}}], "stop_reason"=>"tool_use"}
-    # @return [Array] The tool call information
-    def extract_anthropic_tool_call(tool_call:)
-      tool_call_id = tool_call.dig("id")
-
-      function_name = tool_call.dig("name")
-      tool_name, method_name = function_name.split("__")
-      tool_arguments = tool_call.dig("input").transform_keys(&:to_sym)
-
-      [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
@@ -403,15 +295,7 @@ 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)
-      if llm.is_a?(Langchain::LLM::Ollama)
-        Langchain::Messages::OllamaMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
-      elsif 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)
-      elsif llm.is_a?(Langchain::LLM::Anthropic)
-        Langchain::Messages::AnthropicMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
-      end
+      @llm_adapter.build_message(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
     end
 
     # Increment the tokens count based on the last interaction with the LLM
@@ -427,5 +311,165 @@ module Langchain
     end
 
     # TODO: Fix the message truncation when context window is exceeded
+
+    module LLM
+      class Adapter
+        def self.build(llm)
+          case llm
+          when Langchain::LLM::Ollama
+            Adapters::Ollama.new
+          when Langchain::LLM::OpenAI
+            Adapters::OpenAI.new
+          when Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI
+            Adapters::GoogleGemini.new
+          when Langchain::LLM::Anthropic
+            Adapters::Anthropic.new
+          else
+            raise ArgumentError, "Unsupported LLM type: #{llm.class}"
+          end
+        end
+      end
+
+      module Adapters
+        class Base
+          def build_chat_params(tools:, instructions:, messages:)
+            raise NotImplementedError, "Subclasses must implement build_chat_params"
+          end
+
+          def extract_tool_call_args(tool_call:)
+            raise NotImplementedError, "Subclasses must implement extract_tool_call_args"
+          end
+
+          def build_message(role:, content: nil, tool_calls: [], tool_call_id: nil)
+            raise NotImplementedError, "Subclasses must implement build_message"
+          end
+        end
+
+        class Ollama < Base
+          def build_chat_params(tools:, instructions:, messages:)
+            params = {messages: messages}
+            if tools.any?
+              params[:tools] = tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten
+            end
+            params
+          end
+
+          def build_message(role:, content: nil, tool_calls: [], tool_call_id: nil)
+            Langchain::Messages::OllamaMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+          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_tool_call_args(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 = tool_call.dig("function", "arguments")
+            tool_arguments = if tool_arguments.is_a?(Hash)
+              Langchain::Utils::HashTransformer.symbolize_keys(tool_arguments)
+            else
+              JSON.parse(tool_arguments, symbolize_names: true)
+            end
+
+            [tool_call_id, tool_name, method_name, tool_arguments]
+          end
+        end
+
+        class OpenAI < Base
+          def build_chat_params(tools:, instructions:, messages:)
+            params = {messages: messages}
+            if tools.any?
+              params[:tools] = tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten
+              params[:tool_choice] = "auto"
+            end
+            params
+          end
+
+          def build_message(role:, content: nil, tool_calls: [], tool_call_id: nil)
+            Langchain::Messages::OpenAIMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+          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_tool_call_args(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 = tool_call.dig("function", "arguments")
+            tool_arguments = if tool_arguments.is_a?(Hash)
+              Langchain::Utils::HashTransformer.symbolize_keys(tool_arguments)
+            else
+              JSON.parse(tool_arguments, symbolize_names: true)
+            end
+
+            [tool_call_id, tool_name, method_name, tool_arguments]
+          end
+        end
+
+        class GoogleGemini < Base
+          def build_chat_params(tools:, instructions:, messages:)
+            params = {messages: messages}
+            if tools.any?
+              params[:tools] = tools.map { |tool| tool.class.function_schemas.to_google_gemini_format }.flatten
+              params[:system] = instructions if instructions
+              params[:tool_choice] = "auto"
+            end
+            params
+          end
+
+          def build_message(role:, content: nil, tool_calls: [], tool_call_id: nil)
+            Langchain::Messages::GoogleGeminiMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+          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_tool_call_args(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
+        end
+
+        class Anthropic < Base
+          def build_chat_params(tools:, instructions:, messages:)
+            params = {messages: messages}
+            if tools.any?
+              params[:tools] = tools.map { |tool| tool.class.function_schemas.to_anthropic_format }.flatten
+              params[:tool_choice] = {type: "auto"}
+            end
+            params[:system] = instructions if instructions
+            params
+          end
+
+          def build_message(role:, content: nil, tool_calls: [], tool_call_id: nil)
+            Langchain::Messages::AnthropicMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+          end
+
+          # Extract the tool call information from the Anthropic tool call hash
+          #
+          # @param tool_call [Hash] The tool call hash, format: {"type"=>"tool_use", "id"=>"toolu_01TjusbFApEbwKPRWTRwzadR", "name"=>"news_retriever__get_top_headlines", "input"=>{"country"=>"us", "page_size"=>10}}], "stop_reason"=>"tool_use"}
+          # @return [Array] The tool call information
+          def extract_tool_call_args(tool_call:)
+            tool_call_id = tool_call.dig("id")
+            function_name = tool_call.dig("name")
+            tool_name, method_name = function_name.split("__")
+            tool_arguments = tool_call.dig("input").transform_keys(&:to_sym)
+            [tool_call_id, tool_name, method_name, tool_arguments]
+          end
+        end
+      end
+    end
   end
 end

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

@@ -30,27 +30,15 @@ module Langchain
         @tool_call_id = tool_call_id
       end
 
-      def to_s
-        send(:"to_#{role}_message_string")
-      end
-
-      def to_system_message_string
-        content
-      end
-
-      def to_user_message_string
-        "[INST] #{content}[/INST]"
-      end
-
-      def to_tool_message_string
-        "[TOOL_RESULTS] #{content}[/TOOL_RESULTS]"
-      end
-
-      def to_assistant_message_string
-        if tool_calls.any?
-          %("[TOOL_CALLS] #{tool_calls}")
-        else
-          content
+      # 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
 

data/lib/langchain/contextual_logger.rb

@@ -35,20 +35,20 @@ module Langchain
       @logger.respond_to?(method, include_private)
     end
 
-    def method_missing(method, *args, **kwargs, &)
-      return @logger.send(method, *args, **kwargs, &) unless @levels.include?(method)
+    def method_missing(method, *args, **kwargs, &block)
+      return @logger.send(method, *args, **kwargs, &block) unless @levels.include?(method)
 
       for_class = kwargs.delete(:for)
       for_class_name = for_class&.name
 
       log_line_parts = []
-      log_line_parts << "[Langchain.rb]".colorize(color: :yellow)
+      log_line_parts << colorize("[Langchain.rb]", color: :yellow)
       log_line_parts << if for_class.respond_to?(:logger_options)
-        "[#{for_class_name}]".colorize(for_class.logger_options) + ":"
+        colorize("[#{for_class_name}]", for_class.logger_options) + ":"
       elsif for_class_name
         "[#{for_class_name}]:"
       end
-      log_line_parts << args.first.colorize(MESSAGE_COLOR_OPTIONS[method])
+      log_line_parts << colorize(args.first, MESSAGE_COLOR_OPTIONS[method])
       log_line = log_line_parts.compact.join(" ")
 
       @logger.send(
@@ -56,5 +56,11 @@ module Langchain
         log_line
       )
     end
+
+    private
+
+    def colorize(line, options)
+      Langchain::Utils::Colorizer.colorize(line, options)
+    end
   end
 end

data/lib/langchain/evals/ragas/faithfulness.rb

@@ -47,7 +47,7 @@ module Langchain
           verdicts = match.captures.first
           verdicts
             .split(".")
-            .count { |value| value.strip.to_boolean }
+            .count { |value| to_boolean(value.strip) }
         end
 
         def statements_verification(statements:, context:)
@@ -79,6 +79,10 @@ module Langchain
             file_path: Langchain.root.join("langchain/evals/ragas/prompts/faithfulness_statements_extraction.yml")
           )
         end
+
+        def to_boolean(value)
+          Langchain::Utils::ToBoolean.new.to_bool(value)
+        end
       end
     end
   end

data/lib/langchain/llm/google_gemini.rb

@@ -62,7 +62,7 @@ module Langchain::LLM
 
       request = Net::HTTP::Post.new(uri)
       request.content_type = "application/json"
-      request.body = Langchain::Utils::HashTransformer.deep_transform_keys(parameters) { |key| Langchain::Utils::HashTransformer.camelize_lower(key.to_s).to_sym }.to_json
+      request.body = parameters.to_json
 
       response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
         http.request(request)

data/lib/langchain/llm/ollama.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/hash"
-
 module Langchain::LLM
   # Interface to Ollama API.
   # Available models: https://ollama.ai/library
@@ -15,9 +13,9 @@ module Langchain::LLM
 
     DEFAULTS = {
       temperature: 0.0,
-      completion_model_name: "llama3",
-      embeddings_model_name: "llama3",
-      chat_completion_model_name: "llama3"
+      completion_model_name: "llama3.1",
+      embeddings_model_name: "llama3.1",
+      chat_completion_model_name: "llama3.1"
     }.freeze
 
     EMBEDDING_SIZES = {
@@ -25,20 +23,24 @@ module Langchain::LLM
       "dolphin-mixtral": 4_096,
       llama2: 4_096,
       llama3: 4_096,
+      "llama3.1": 4_096,
       llava: 4_096,
       mistral: 4_096,
       "mistral-openorca": 4_096,
-      mixtral: 4_096
+      mixtral: 4_096,
+      tinydolphin: 2_048
     }.freeze
 
     # Initialize the Ollama client
     # @param url [String] The URL of the Ollama instance
+    # @param api_key [String] The API key to use. This is optional and used when you expose Ollama API using Open WebUI
     # @param default_options [Hash] The default options to use
     #
-    def initialize(url: "http://localhost:11434", default_options: {})
+    def initialize(url: "http://localhost:11434", api_key: nil, default_options: {})
       depends_on "faraday"
       @url = url
-      @defaults = DEFAULTS.deep_merge(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]},
@@ -113,7 +115,7 @@ module Langchain::LLM
         system: system,
         template: template,
         context: context,
-        stream: block.present?,
+        stream: block_given?, # rubocop:disable Performance/BlockGivenWithExplicitBlock
         raw: raw
       }.compact
 
@@ -173,7 +175,7 @@ module Langchain::LLM
     #   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(messages:, model: nil, **params, &block)
-      parameters = chat_parameters.to_params(params.merge(messages:, model:, stream: block.present?))
+      parameters = chat_parameters.to_params(params.merge(messages:, model:, stream: block_given?)) # rubocop:disable Performance/BlockGivenWithExplicitBlock
       responses_stream = []
 
       client.post("api/chat", parameters) do |req|
@@ -264,13 +266,20 @@ module Langchain::LLM
     private
 
     def client
-      @client ||= Faraday.new(url: url) do |conn|
+      @client ||= Faraday.new(url: url, headers: auth_headers) do |conn|
         conn.request :json
         conn.response :json
         conn.response :raise_error
+        conn.response :logger, nil, {headers: true, bodies: true, errors: true}
       end
     end
 
+    def auth_headers
+      return unless @api_key
+
+      {"Authorization" => "Bearer #{@api_key}"}
+    end
+
     def json_responses_chunk_handler(&block)
       proc do |chunk, _size|
         chunk.split("\n").each do |chunk_line|
@@ -288,13 +297,10 @@ module Langchain::LLM
       OllamaResponse.new(final_response, model: parameters[:model])
     end
 
+    # BUG: If streamed, this method does not currently return the tool_calls response.
     def generate_final_chat_completion_response(responses_stream, parameters)
-      final_response = responses_stream.last.merge(
-        "message" => {
-          "role" => "assistant",
-          "content" => responses_stream.map { |resp| resp.dig("message", "content") }.join
-        }
-      )
+      final_response = responses_stream.last
+      final_response["message"]["content"] = responses_stream.map { |resp| resp.dig("message", "content") }.join
 
       OllamaResponse.new(final_response, model: parameters[:model])
     end

data/lib/langchain/llm/openai.rb

@@ -16,7 +16,7 @@ module Langchain::LLM
     DEFAULTS = {
       n: 1,
       temperature: 0.0,
-      chat_completion_model_name: "gpt-3.5-turbo",
+      chat_completion_model_name: "gpt-4o-mini",
       embeddings_model_name: "text-embedding-3-small"
     }.freeze
 

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

@@ -48,21 +48,7 @@ module Langchain::LLM
     end
 
     def tool_calls
-      if chat_completion && (parsed_tool_calls = JSON.parse(chat_completion))
-        [parsed_tool_calls]
-      elsif completion&.include?("[TOOL_CALLS]") && (
-        parsed_tool_calls = JSON.parse(
-          completion
-            # Slice out the serialize JSON
-            .slice(/\{.*\}/)
-            # Replace hash rocket with colon
-            .gsub("=>", ":")
-        )
-      )
-        [parsed_tool_calls]
-      else
-        []
-      end
+      Array(raw_response.dig("message", "tool_calls"))
     end
 
     private