langchainrb 0.13.4 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7877086b6c4d0bba6c1fc4cafc156ff476ad83eb30df1a39b279885b224bf35d
-  data.tar.gz: 3a22b060896725308c5ce137ee5617a44a75355cfc7878ce6080e6b200722c51
+  metadata.gz: 68900cd116cf0fb1b77376a4906e5551f0d578ee2bb47c7ec86d32bf44f84e33
+  data.tar.gz: f68782c3cdc856799778618d78b6411a85b0c69adf6a4d33489b8025fdca3dce
 SHA512:
-  metadata.gz: 05606b99693c0e81f3785a027e155205a3ffce8f4f236868395de837e2bc6f71661c39f6a2cc062e3c0a57a6c8295e13b6910df296a9092f2f7d0596e1c969b0
-  data.tar.gz: 00d478f82be9984a95a1d11676982dec79dea2a6c0bf92ceb1ab0e3309edac2ecee115a3dd46ca060f040e44d9b7c8623ffd27ba1d5fcd8182832f933eaf2815
+  metadata.gz: 158410fd769caaf9074eddc1143ddee9256ac5a466a510c32b74d337eba62fab80b676661cbf1673604d236014a5cb4defdd4743e71abb713a659ddea0fe5e8c
+  data.tar.gz: 2e956356a443ff37ad711f6c42f8c4940925bcee4be075b403c78c3f702b487c12790dca9ba7d68a01acaf1c245b2910650b3f938e80cedd1fc2d5af14f7ffa8

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [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
+- Misc fixes and improvements
+
 ## [0.13.4] - 2024-06-16
 - Fix Chroma#remove_texts() method
 - Fix NewsRetriever Tool returning non UTF-8 characters

data/README.md

@@ -343,7 +343,7 @@ You can instantiate any other supported vector search database:
 client = Langchain::Vectorsearch::Chroma.new(...)   # `gem "chroma-db", "~> 0.6.0"`
 client = Langchain::Vectorsearch::Epsilla.new(...)  # `gem "epsilla-ruby", "~> 0.0.3"`
 client = Langchain::Vectorsearch::Hnswlib.new(...)  # `gem "hnswlib", "~> 0.8.1"`
-client = Langchain::Vectorsearch::Milvus.new(...)   # `gem "milvus", "~> 0.9.2"`
+client = Langchain::Vectorsearch::Milvus.new(...)   # `gem "milvus", "~> 0.9.3"`
 client = Langchain::Vectorsearch::Pinecone.new(...) # `gem "pinecone", "~> 0.1.6"`
 client = Langchain::Vectorsearch::Pgvector.new(...) # `gem "pgvector", "~> 0.2"`
 client = Langchain::Vectorsearch::Qdrant.new(...)   # `gem "qdrant-ruby", "~> 0.9.3"`
@@ -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

@@ -15,14 +15,16 @@ module Langchain
     extend Forwardable
     def_delegators :thread, :messages, :messages=
 
-    attr_reader :llm, :thread, :instructions
+    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
+      Langchain::LLM::GoogleVertexAI,
+      Langchain::LLM::Ollama,
+      Langchain::LLM::OpenAI
     ]
 
     # Create a new assistant
@@ -40,20 +42,26 @@ module Langchain
       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"
+      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
       @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
 
@@ -66,7 +74,10 @@ module Langchain
     # @return [Array<Langchain::Message>] The messages in the thread
     def add_message(content: nil, role: "user", tool_calls: [], tool_call_id: nil)
       message = build_message(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
-      thread.add_message(message)
+      messages = thread.add_message(message)
+      @state = :ready
+
+      messages
     end
 
     # Run the assistant
@@ -76,56 +87,12 @@ module Langchain
     def run(auto_tool_execution: false)
       if thread.messages.empty?
         Langchain.logger.warn("No messages in the thread")
+        @state = :completed
         return
       end
 
-      running = true
-
-      while running
-        # TODO: I think we need to look at all messages and not just the last one.
-        last_message = thread.messages.last
-
-        if last_message.system?
-          # Do nothing
-          running = false
-        elsif last_message.llm?
-          if last_message.tool_calls.any?
-            if auto_tool_execution
-              run_tools(last_message.tool_calls)
-            else
-              # Maybe log and tell the user that there's outstanding tool calls?
-              running = false
-            end
-          else
-            # Last message was from the assistant without any tools calls.
-            # Do nothing
-            running = false
-          end
-        elsif last_message.user?
-          # Run it!
-          response = chat_with_llm
-
-          if response.tool_calls.any?
-            # Re-run the while(running) loop to process the tool calls
-            running = true
-            add_message(role: response.role, tool_calls: response.tool_calls)
-          elsif response.chat_completion
-            # Stop the while(running) loop and add the assistant's response to the thread
-            running = false
-            add_message(role: response.role, content: response.chat_completion)
-          end
-        elsif last_message.tool?
-          # Run it!
-          response = chat_with_llm
-          running = true
-
-          if response.tool_calls.any?
-            add_message(role: response.role, tool_calls: response.tool_calls)
-          elsif response.chat_completion
-            add_message(role: response.role, content: response.chat_completion)
-          end
-        end
-      end
+      @state = :in_progress
+      @state = handle_state until run_finished?(auto_tool_execution)
 
       thread.messages
     end
@@ -146,13 +113,7 @@ module Langchain
     # @param output [String] The output of the tool
     # @return [Array<Langchain::Message>] The messages in the thread
     def submit_tool_output(tool_call_id:, output:)
-      tool_role = if llm.is_a?(Langchain::LLM::OpenAI)
-        Langchain::Messages::OpenAIMessage::TOOL_ROLE
-      elsif [Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI].include?(llm.class)
-        Langchain::Messages::GoogleGeminiMessage::TOOL_ROLE
-      elsif llm.is_a?(Langchain::LLM::Anthropic)
-        Langchain::Messages::AnthropicMessage::TOOL_ROLE
-      end
+      tool_role = determine_tool_role
 
       # TODO: Validate that `tool_call_id` is valid by scanning messages and checking if this tool call ID was invoked
       add_message(role: tool_role, content: output, tool_call_id: tool_call_id)
@@ -183,31 +144,181 @@ module Langchain
 
     private
 
+    # Check if the run is finished
+    #
+    # @param auto_tool_execution [Boolean] Whether or not to automatically run tools
+    # @return [Boolean] Whether the run is finished
+    def run_finished?(auto_tool_execution)
+      finished_states = [:completed, :failed]
+
+      requires_manual_action = (@state == :requires_action) && !auto_tool_execution
+      finished_states.include?(@state) || requires_manual_action
+    end
+
+    # Handle the current state and transition to the next state
+    #
+    # @return [Symbol] The next state
+    def handle_state
+      case @state
+      when :in_progress
+        process_latest_message
+      when :requires_action
+        execute_tools
+      end
+    end
+
+    # Process the latest message in the thread
+    #
+    # @return [Symbol] The next state
+    def process_latest_message
+      last_message = thread.messages.last
+
+      case last_message.standard_role
+      when :system
+        handle_system_message
+      when :llm
+        handle_llm_message
+      when :user, :tool
+        handle_user_or_tool_message
+      else
+        handle_unexpected_message
+      end
+    end
+
+    # Handle system message scenario
+    #
+    # @return [Symbol] The completed state
+    def handle_system_message
+      Langchain.logger.warn("At least one user message is required after a system message")
+      :completed
+    end
+
+    # Handle LLM message scenario
+    #
+    # @return [Symbol] The next state
+    def handle_llm_message
+      thread.messages.last.tool_calls.any? ? :requires_action : :completed
+    end
+
+    # Handle unexpected message scenario
+    #
+    # @return [Symbol] The failed state
+    def handle_unexpected_message
+      Langchain.logger.error("Unexpected message role encountered: #{thread.messages.last.standard_role}")
+      :failed
+    end
+
+    # Handle user or tool message scenario by processing the LLM response
+    #
+    # @return [Symbol] The next state
+    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)
+      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, chat or completion response")
+        :failed
+      end
+    end
+
+    # Execute the tools based on the tool calls in the last message
+    #
+    # @return [Symbol] The next state
+    def execute_tools
+      run_tools(thread.messages.last.tool_calls)
+      :in_progress
+    rescue => e
+      Langchain.logger.error("Error running tools: #{e.message}")
+      :failed
+    end
+
+    # Determine the tool role based on the LLM type
+    #
+    # @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
+        Langchain::Messages::GoogleGeminiMessage::TOOL_ROLE
+      when Langchain::LLM::Anthropic
+        Langchain::Messages::AnthropicMessage::TOOL_ROLE
+      end
+    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)
+        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}
+      params = {}
 
-      if tools.any?
-        if llm.is_a?(Langchain::LLM::OpenAI)
+      if llm.is_a?(Langchain::LLM::OpenAI)
+        if tools.any?
           params[:tools] = tools.map(&:to_openai_tools).flatten
           params[:tool_choice] = "auto"
-        elsif llm.is_a?(Langchain::LLM::Anthropic)
+        end
+      elsif llm.is_a?(Langchain::LLM::Anthropic)
+        if tools.any?
           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)
+        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
-        # TODO: Not sure that tool_choice should always be "auto"; Maybe we can let the user toggle it.
       end
-
-      llm.chat(**params)
+      # 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
     end
 
     # Run the tools automatically
@@ -216,7 +327,9 @@ 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)
+        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)
@@ -232,14 +345,12 @@ module Langchain
 
         submit_tool_output(tool_call_id: tool_call_id, output: output)
       end
+    end
 
-      response = chat_with_llm
-
-      if response.tool_calls.any?
-        add_message(role: response.role, tool_calls: response.tool_calls)
-      elsif response.chat_completion
-        add_message(role: response.role, content: response.chat_completion)
-      end
+    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
@@ -292,7 +403,9 @@ 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::OpenAI)
+      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)
@@ -301,6 +414,18 @@ module Langchain
       end
     end
 
+    # Increment the tokens count based on the last interaction with the LLM
+    #
+    # @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
+
     # TODO: Fix the message truncation when context window is exceeded
   end
 end

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

@@ -7,10 +7,44 @@ module Langchain
 
       # Check if the message came from a user
       #
-      # @param [Boolean] true/false whether the message came from a user
+      # @return [Boolean] true/false whether the message came from a user
       def user?
         role == "user"
       end
+
+      # Check if the message came from an LLM
+      #
+      # @raise NotImplementedError if the subclass does not implement this method
+      def llm?
+        raise NotImplementedError, "Class #{self.class.name} must implement the method 'llm?'"
+      end
+
+      # Check if the message is a tool call
+      #
+      # @raise NotImplementedError if the subclass does not implement this method
+      def tool?
+        raise NotImplementedError, "Class #{self.class.name} must implement the method 'tool?'"
+      end
+
+      # Check if the message is a system prompt
+      #
+      # @raise NotImplementedError if the subclass does not implement this method
+      def system?
+        raise NotImplementedError, "Class #{self.class.name} must implement the method 'system?'"
+      end
+
+      # Returns the standardized role symbol based on the specific role methods
+      #
+      # @return [Symbol] the standardized role symbol (:system, :llm, :tool, :user, or :unknown)
+      def standard_role
+        return :user if user?
+        return :llm if llm?
+        return :tool if tool?
+        return :system if system?
+
+        # TODO: Should we return :unknown or raise an error?
+        :unknown
+      end
     end
   end
 end

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

@@ -0,0 +1,86 @@
+# 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
+
+      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
+        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/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!