langchainrb 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68900cd116cf0fb1b77376a4906e5551f0d578ee2bb47c7ec86d32bf44f84e33
-  data.tar.gz: f68782c3cdc856799778618d78b6411a85b0c69adf6a4d33489b8025fdca3dce
+  metadata.gz: dde504e05b1cbb32c857569bf71301537fed2deb468f1bdd69a7ef900a41c085
+  data.tar.gz: '08659cddd6f0bb285e167c7a35dbd2f83c2e9bb51a69206217ea91649e99839c'
 SHA512:
-  metadata.gz: 158410fd769caaf9074eddc1143ddee9256ac5a466a510c32b74d337eba62fab80b676661cbf1673604d236014a5cb4defdd4743e71abb713a659ddea0fe5e8c
-  data.tar.gz: 2e956356a443ff37ad711f6c42f8c4940925bcee4be075b403c78c3f702b487c12790dca9ba7d68a01acaf1c245b2910650b3f938e80cedd1fc2d5af14f7ffa8
+  metadata.gz: ce4dd091498659a2d8dda4b54e9e9584dc19be5f390dc5f1d98efa054a264134dc3510f2f83c65bdf23edfbd7344587b91113e69c2ea1fea2cdc157317735799
+  data.tar.gz: a6df110aa7d96c87402164f67aadab0a97e2a62b68b7466cf630fe79dd0611a1740ae11163361eef9c98fc816f7ba12d7bfc0aa2225759cc8191f59fead8fcbd

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [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

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,8 +35,8 @@ 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

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

data/lib/langchain/llm/unified_parameters.rb

@@ -77,8 +77,8 @@ module Langchain::LLM
       @parameters.to_h
     end
 
-    def each(&)
-      to_params.each(&)
+    def each(&block)
+      to_params.each(&block)
     end
 
     def <=>(other)

data/lib/langchain/tool/calculator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Langchain::Tool
+  #
+  # A calculator tool that falls back to the Google calculator widget
+  #
+  # Gem requirements:
+  #     gem "eqn", "~> 1.6.5"
+  #     gem "google_search_results", "~> 2.0.0"
+  #
+  # Usage:
+  #     calculator = Langchain::Tool::Calculator.new
+  #
+  class Calculator
+    extend Langchain::ToolDefinition
+    include Langchain::DependencyHelper
+
+    define_function :execute, description: "Evaluates a pure math expression or if equation contains non-math characters (e.g.: \"12F in Celsius\") then it uses the google search calculator to evaluate the expression" do
+      property :input, type: "string", description: "Math expression", required: true
+    end
+
+    def initialize
+      depends_on "eqn"
+    end
+
+    # Evaluates a pure math expression or if equation contains non-math characters (e.g.: "12F in Celsius") then it uses the google search calculator to evaluate the expression
+    #
+    # @param input [String] math expression
+    # @return [String] Answer
+    def execute(input:)
+      Langchain.logger.info("Executing \"#{input}\"", for: self.class)
+
+      Eqn::Calculator.calc(input)
+    rescue Eqn::ParseError, Eqn::NoVariableValueError
+      "\"#{input}\" is an invalid mathematical expression"
+    end
+  end
+end