langchainrb 0.13.5 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7eac7a6ba7767f6a3f84ee808fa4810eaa1843776695ab0225ddd6b77cf7a73
-  data.tar.gz: e9f7c0170fc2a8dbf443f1bac24874878ee0fbba7e0495bf65a8df969d3d86e6
+  metadata.gz: dde504e05b1cbb32c857569bf71301537fed2deb468f1bdd69a7ef900a41c085
+  data.tar.gz: '08659cddd6f0bb285e167c7a35dbd2f83c2e9bb51a69206217ea91649e99839c'
 SHA512:
-  metadata.gz: e4d14ac64e54e5c7245a9586dfb4899154793ea466f9564a510eb3dfe17a3a7229cf61e408445b38fec37500065b5e1ee725afa634284bea5538abac0766237f
-  data.tar.gz: e8fe3e1639a3f2ed087436610dd1653e775703c1c6cc83f7f52eb7d3fb46db554e7be790bc6bc2ddf18ec4e3c26dddbe1ec72e8f25603db1192e5a111d0f9543
+  metadata.gz: ce4dd091498659a2d8dda4b54e9e9584dc19be5f390dc5f1d98efa054a264134dc3510f2f83c65bdf23edfbd7344587b91113e69c2ea1fea2cdc157317735799
+  data.tar.gz: a6df110aa7d96c87402164f67aadab0a97e2a62b68b7466cf630fe79dd0611a1740ae11163361eef9c98fc816f7ba12d7bfc0aa2225759cc8191f59fead8fcbd

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [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
+- Assistant keeps track of tokens used
+- Misc fixes and improvements
+
 ## [0.13.5] - 2024-07-01
 - Add Milvus#remove_texts() method
 - Langchain::Assistant has a `state` now

data/README.md

@@ -428,25 +428,10 @@ Assistants are Agent-like objects that leverage helpful instructions, LLMs, tool
 ```ruby
 llm = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"])
 ```
-2. Instantiate a Thread. Threads keep track of the messages in the Assistant conversation.
-```ruby
-thread = Langchain::Thread.new
-```
-You can pass old message from previously using the Assistant:
-```ruby
-thread.messages = messages
-```
-Messages contain the conversation history and the whole message history is sent to the LLM every time. A Message belongs to 1 of the 4 roles:
-* `Message(role: "system")` message usually contains the instructions.
-* `Message(role: "user")` messages come from the user.
-* `Message(role: "assistant")` messages are produced by the LLM.
-* `Message(role: "tool")` messages are sent in response to tool calls with tool outputs.
-
-3. Instantiate an Assistant
+2. Instantiate an Assistant
 ```ruby
 assistant = Langchain::Assistant.new(
   llm: llm,
-  thread: thread,
   instructions: "You are a Meteorologist Assistant that is able to pull the weather for any location",
   tools: [
     Langchain::Tool::Weather.new(api_key: ENV["OPEN_WEATHER_API_KEY"])
@@ -482,7 +467,7 @@ assistant.add_message_and_run content: "What about Sacramento, CA?", auto_tool_e
 ### Accessing Thread messages
 You can access the messages in a Thread by calling `assistant.thread.messages`.
 ```ruby
-assistant.thread.messages
+assistant.messages
 ```
 
 The Assistant checks the context window limits before every request to the LLM and remove oldest thread messages one by one if the context window is exceeded.

data/lib/langchain/assistants/assistant.rb

@@ -16,15 +16,9 @@ module Langchain
     def_delegators :thread, :messages, :messages=
 
     attr_reader :llm, :thread, :instructions, :state
+    attr_reader :total_prompt_tokens, :total_completion_tokens, :total_tokens
     attr_accessor :tools
 
-    SUPPORTED_LLMS = [
-      Langchain::LLM::Anthropic,
-      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
@@ -37,24 +31,26 @@ module Langchain
       tools: [],
       instructions: nil
     )
-      unless SUPPORTED_LLMS.include?(llm.class)
-        raise ArgumentError, "Invalid LLM; currently only #{SUPPORTED_LLMS.join(", ")} are supported"
+      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
       @state = :ready
 
+      @total_prompt_tokens = 0
+      @total_completion_tokens = 0
+      @total_tokens = 0
+
       raise ArgumentError, "Thread must be an instance of Langchain::Thread" unless @thread.is_a?(Langchain::Thread)
 
       # 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?
-      if llm.is_a?(Langchain::LLM::OpenAI)
-        add_message(role: "system", content: instructions) if instructions
-      end
+      initialize_instructions
       # For Google Gemini, and Anthropic system instructions are added to the `system:` param in the `chat` method
     end
 
@@ -150,7 +146,6 @@ module Langchain
 
     # Handle the current state and transition to the next state
     #
-    # @param state [Symbol] The current state
     # @return [Symbol] The next state
     def handle_state
       case @state
@@ -189,7 +184,6 @@ module Langchain
 
     # Handle LLM message scenario
     #
-    # @param auto_tool_execution [Boolean] Flag to indicate if tools should be executed automatically
     # @return [Symbol] The next state
     def handle_llm_message
       thread.messages.last.tool_calls.any? ? :requires_action : :completed
@@ -208,14 +202,22 @@ module Langchain
     # @return [Symbol] The next state
     def handle_user_or_tool_message
       response = chat_with_llm
+
       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)
+    end
 
+    def set_state_for(response:)
       if response.tool_calls.any?
         :in_progress
       elsif response.chat_completion
         :completed
+      elsif response.completion # Currently only used by Ollama
+        :completed
       else
-        Langchain.logger.error("LLM response does not contain tool calls or chat completion")
+        Langchain.logger.error("LLM response does not contain tool calls, chat or completion response")
         :failed
       end
     end
@@ -227,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
 
@@ -236,6 +238,8 @@ module Langchain
     # @return [String] The tool role
     def determine_tool_role
       case llm
+      when Langchain::LLM::Ollama
+        Langchain::Messages::OllamaMessage::TOOL_ROLE
       when Langchain::LLM::OpenAI
         Langchain::Messages::OpenAIMessage::TOOL_ROLE
       when Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI
@@ -245,31 +249,24 @@ module Langchain
       end
     end
 
+    def initialize_instructions
+      if llm.is_a?(Langchain::LLM::OpenAI)
+        add_message(role: "system", content: instructions) if instructions
+      end
+    end
+
     # Call to the LLM#chat() method
     #
     # @return [Langchain::LLM::BaseResponse] The LLM response object
     def chat_with_llm
       Langchain.logger.info("Sending a call to #{llm.class}", for: self.class)
 
-      params = {messages: thread.array_of_message_hashes}
-
-      if tools.any?
-        if llm.is_a?(Langchain::LLM::OpenAI)
-          params[:tools] = tools.map(&:to_openai_tools).flatten
-          params[:tool_choice] = "auto"
-        elsif llm.is_a?(Langchain::LLM::Anthropic)
-          params[:tools] = tools.map(&:to_anthropic_tools).flatten
-          params[:system] = instructions if instructions
-          params[:tool_choice] = {type: "auto"}
-        elsif [Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI].include?(llm.class)
-          params[:tools] = tools.map(&:to_google_gemini_tools).flatten
-          params[:system] = instructions if instructions
-          params[:tool_choice] = "auto"
-        end
-        # TODO: Not sure that tool_choice should always be "auto"; Maybe we can let the user toggle it.
-      end
-
-      llm.chat(**params)
+      params = @llm_adapter.build_chat_params(
+        tools: @tools,
+        instructions: @instructions,
+        messages: thread.array_of_message_hashes
+      )
+      @llm.chat(**params)
     end
 
     # Run the tools automatically
@@ -278,16 +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::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)
@@ -296,65 +287,189 @@ module Langchain
       end
     end
 
-    # Extract the tool call information from the OpenAI tool call hash
+    # Build a message
     #
-    # @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]
+    # @param role [String] The role of the message
+    # @param content [String] The content of the message
+    # @param tool_calls [Array<Hash>] The tool calls to include in the message
+    # @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)
+      @llm_adapter.build_message(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
+    # Increment the tokens count based on the last interaction with the LLM
     #
-    # @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")
+    # @param prompt_tokens [Integer] The number of used prmopt tokens
+    # @param completion_tokens [Integer] The number of used completion tokens
+    # @param total_tokens [Integer] The total number of used tokens
+    # @return [Integer] The current total tokens count
+    def record_used_tokens(prompt_tokens, completion_tokens, total_tokens_from_operation)
+      @total_prompt_tokens += prompt_tokens if prompt_tokens
+      @total_completion_tokens += completion_tokens if completion_tokens
+      @total_tokens += total_tokens_from_operation if total_tokens_from_operation
+    end
 
-      function_name = tool_call.dig("name")
-      tool_name, method_name = function_name.split("__")
-      tool_arguments = tool_call.dig("input").transform_keys(&:to_sym)
+    # TODO: Fix the message truncation when context window is exceeded
 
-      [tool_call_id, tool_name, method_name, tool_arguments]
-    end
+    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
 
-    # 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")
+      module Adapters
+        class Base
+          def build_chat_params(tools:, instructions:, messages:)
+            raise NotImplementedError, "Subclasses must implement build_chat_params"
+          end
 
-      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)
+          def extract_tool_call_args(tool_call:)
+            raise NotImplementedError, "Subclasses must implement extract_tool_call_args"
+          end
 
-      [tool_call_id, tool_name, method_name, tool_arguments]
-    end
+          def build_message(role:, content: nil, tool_calls: [], tool_call_id: nil)
+            raise NotImplementedError, "Subclasses must implement build_message"
+          end
+        end
 
-    # Build a message
-    #
-    # @param role [String] The role of the message
-    # @param content [String] The content of the message
-    # @param tool_calls [Array<Hash>] The tool calls to include in the message
-    # @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::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)
+        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
-
-    # TODO: Fix the message truncation when context window is exceeded
   end
 end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Langchain
+  module Messages
+    class OllamaMessage < 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)
+        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
+
+      # 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 llm?
+        assistant?
+      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

@@ -17,7 +17,14 @@ module Langchain
     #
     # @return [Array<Hash>] The thread as an OpenAI API-compatible array of hashes
     def array_of_message_hashes
-      messages.map(&:to_hash)
+      messages
+        .map(&:to_hash)
+        .compact
+    end
+
+    # Only used by the Assistant when it calls the LLM#complete() method
+    def prompt_of_concatenated_messages
+      messages.map(&:to_s).join
     end
 
     # Add a message to the thread

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/ai21.rb

@@ -16,8 +16,6 @@ module Langchain::LLM
       model: "j2-ultra"
     }.freeze
 
-    LENGTH_VALIDATOR = Langchain::Utils::TokenLength::AI21Validator
-
     def initialize(api_key:, default_options: {})
       depends_on "ai21"
 
@@ -35,8 +33,6 @@ module Langchain::LLM
     def complete(prompt:, **params)
       parameters = complete_parameters params
 
-      parameters[:maxTokens] = LENGTH_VALIDATOR.validate_max_tokens!(prompt, parameters[:model], {llm: client})
-
       response = client.complete(prompt, parameters)
       Langchain::LLM::AI21Response.new response, model: parameters[:model]
     end

data/lib/langchain/llm/anthropic.rb

@@ -5,10 +5,10 @@ module Langchain::LLM
   # Wrapper around Anthropic APIs.
   #
   # Gem requirements:
-  #   gem "anthropic", "~> 0.1.0"
+  #   gem "anthropic", "~> 0.3.0"
   #
   # Usage:
-  #     anthorpic = Langchain::LLM::Anthropic.new(api_key: ENV["ANTHROPIC_API_KEY"])
+  #     anthropic = Langchain::LLM::Anthropic.new(api_key: ENV["ANTHROPIC_API_KEY"])
   #
   class Anthropic < Base
     DEFAULTS = {
@@ -18,9 +18,6 @@ module Langchain::LLM
       max_tokens_to_sample: 256
     }.freeze
 
-    # TODO: Implement token length validator for Anthropic
-    # LENGTH_VALIDATOR = Langchain::Utils::TokenLength::AnthropicValidator
-
     # Initialize an Anthropic LLM instance
     #
     # @param api_key [String] The API key to use
@@ -81,7 +78,10 @@ module Langchain::LLM
       parameters[:metadata] = metadata if metadata
       parameters[:stream] = stream if stream
 
-      response = client.complete(parameters: parameters)
+      response = with_api_error_handling do
+        client.complete(parameters: parameters)
+      end
+
       Langchain::LLM::AnthropicResponse.new(response)
     end
 
@@ -114,6 +114,15 @@ module Langchain::LLM
       Langchain::LLM::AnthropicResponse.new(response)
     end
 
+    def with_api_error_handling
+      response = yield
+      return if response.empty?
+
+      raise Langchain::LLM::ApiError.new "Anthropic API error: #{response.dig("error", "message")}" if response&.dig("error")
+
+      response
+    end
+
     private
 
     def set_extra_headers!

data/lib/langchain/llm/azure.rb

@@ -42,17 +42,17 @@ module Langchain::LLM
 
     def embed(...)
       @client = @embed_client
-      super(...)
+      super
     end
 
     def complete(...)
       @client = @chat_client
-      super(...)
+      super
     end
 
     def chat(...)
       @client = @chat_client
-      super(...)
+      super
     end
   end
 end