langchainrb 0.13.4 → 0.13.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7877086b6c4d0bba6c1fc4cafc156ff476ad83eb30df1a39b279885b224bf35d
-  data.tar.gz: 3a22b060896725308c5ce137ee5617a44a75355cfc7878ce6080e6b200722c51
+  metadata.gz: d7eac7a6ba7767f6a3f84ee808fa4810eaa1843776695ab0225ddd6b77cf7a73
+  data.tar.gz: e9f7c0170fc2a8dbf443f1bac24874878ee0fbba7e0495bf65a8df969d3d86e6
 SHA512:
-  metadata.gz: 05606b99693c0e81f3785a027e155205a3ffce8f4f236868395de837e2bc6f71661c39f6a2cc062e3c0a57a6c8295e13b6910df296a9092f2f7d0596e1c969b0
-  data.tar.gz: 00d478f82be9984a95a1d11676982dec79dea2a6c0bf92ceb1ab0e3309edac2ecee115a3dd46ca060f040e44d9b7c8623ffd27ba1d5fcd8182832f933eaf2815
+  metadata.gz: e4d14ac64e54e5c7245a9586dfb4899154793ea466f9564a510eb3dfe17a3a7229cf61e408445b38fec37500065b5e1ee725afa634284bea5538abac0766237f
+  data.tar.gz: e8fe3e1639a3f2ed087436610dd1653e775703c1c6cc83f7f52eb7d3fb46db554e7be790bc6bc2ddf18ec4e3c26dddbe1ec72e8f25603db1192e5a111d0f9543

data/CHANGELOG.md

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

data/lib/langchain/assistants/assistant.rb

@@ -15,7 +15,7 @@ module Langchain
     extend Forwardable
     def_delegators :thread, :messages, :messages=
 
-    attr_reader :llm, :thread, :instructions
+    attr_reader :llm, :thread, :instructions, :state
     attr_accessor :tools
 
     SUPPORTED_LLMS = [
@@ -46,6 +46,7 @@ module Langchain
       @thread = thread || Langchain::Thread.new
       @tools = tools
       @instructions = instructions
+      @state = :ready
 
       raise ArgumentError, "Thread must be an instance of Langchain::Thread" unless @thread.is_a?(Langchain::Thread)
 
@@ -66,7 +67,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 +80,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 +106,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,6 +137,114 @@ 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
+    #
+    # @param state [Symbol] The current 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
+    #
+    # @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
+    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
+      add_message(role: response.role, content: response.chat_completion, tool_calls: response.tool_calls)
+
+      if response.tool_calls.any?
+        :in_progress
+      elsif response.chat_completion
+        :completed
+      else
+        Langchain.logger.error("LLM response does not contain tool calls or chat completion")
+        :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::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
+
     # Call to the LLM#chat() method
     #
     # @return [Langchain::LLM::BaseResponse] The LLM response object
@@ -232,14 +294,6 @@ module Langchain
 
         submit_tool_output(tool_call_id: tool_call_id, output: output)
       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
     end
 
     # Extract the tool call information from the OpenAI tool call hash

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/llm/google_gemini.rb

@@ -18,7 +18,9 @@ module Langchain::LLM
 
       chat_parameters.update(
         model: {default: @defaults[:chat_completion_model_name]},
-        temperature: {default: @defaults[:temperature]}
+        temperature: {default: @defaults[:temperature]},
+        generation_config: {default: nil},
+        safety_settings: {default: nil}
       )
       chat_parameters.remap(
         messages: :contents,
@@ -42,13 +44,25 @@ module Langchain::LLM
       raise ArgumentError.new("messages argument is required") if Array(params[:messages]).empty?
 
       parameters = chat_parameters.to_params(params)
-      parameters[:generation_config] = {temperature: parameters.delete(:temperature)} if parameters[:temperature]
+      parameters[:generation_config] ||= {}
+      parameters[:generation_config][:temperature] ||= parameters[:temperature] if parameters[:temperature]
+      parameters.delete(:temperature)
+      parameters[:generation_config][:top_p] ||= parameters[:top_p] if parameters[:top_p]
+      parameters.delete(:top_p)
+      parameters[:generation_config][:top_k] ||= parameters[:top_k] if parameters[:top_k]
+      parameters.delete(:top_k)
+      parameters[:generation_config][:max_output_tokens] ||= parameters[:max_tokens] if parameters[:max_tokens]
+      parameters.delete(:max_tokens)
+      parameters[:generation_config][:response_mime_type] ||= parameters[:response_format] if parameters[:response_format]
+      parameters.delete(:response_format)
+      parameters[:generation_config][:stop_sequences] ||= parameters[:stop] if parameters[:stop]
+      parameters.delete(:stop)
 
       uri = URI("https://generativelanguage.googleapis.com/v1beta/models/#{parameters[:model]}:generateContent?key=#{api_key}")
 
       request = Net::HTTP::Post.new(uri)
       request.content_type = "application/json"
-      request.body = parameters.to_json
+      request.body = Langchain::Utils::HashTransformer.deep_transform_keys(parameters) { |key| Langchain::Utils::HashTransformer.camelize_lower(key.to_s).to_sym }.to_json
 
       response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
         http.request(request)

data/lib/langchain/llm/replicate.rb

@@ -64,7 +64,7 @@ module Langchain::LLM
     # Generate a completion for a given prompt
     #
     # @param prompt [String] The prompt to generate a completion for
-    # @return [Langchain::LLM::ReplicateResponse] Reponse object
+    # @return [Langchain::LLM::ReplicateResponse] Response object
     #
     def complete(prompt:, **params)
       response = completion_model.predict(prompt: prompt)

data/lib/langchain/loader.rb

@@ -90,7 +90,9 @@ module Langchain
     private
 
     def load_from_url
-      URI.parse(URI::DEFAULT_PARSER.escape(@path)).open
+      unescaped_url = URI.decode_www_form_component(@path)
+      escaped_url = URI::DEFAULT_PARSER.escape(unescaped_url)
+      URI.parse(escaped_url).open
     end
 
     def load_from_path

data/lib/langchain/utils/hash_transformer.rb

@@ -0,0 +1,25 @@
+module Langchain
+  module Utils
+    class HashTransformer
+      # Converts a string to camelCase
+      def self.camelize_lower(str)
+        str.split("_").inject([]) { |buffer, e| buffer.push(buffer.empty? ? e : e.capitalize) }.join
+      end
+
+      # Recursively transforms the keys of a hash to camel case
+      def self.deep_transform_keys(hash, &block)
+        case hash
+        when Hash
+          hash.each_with_object({}) do |(key, value), result|
+            new_key = block.call(key)
+            result[new_key] = deep_transform_keys(value, &block)
+          end
+        when Array
+          hash.map { |item| deep_transform_keys(item, &block) }
+        else
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/langchain/vectorsearch/chroma.rb

@@ -64,7 +64,9 @@ module Langchain::Vectorsearch
     # @param ids [Array<String>] The list of ids to remove
     # @return [Hash] The response from the server
     def remove_texts(ids:)
-      collection.delete(ids: ids)
+      collection.delete(
+        ids: ids.map(&:to_s)
+      )
     end
 
     # Create the collection with the default schema

data/lib/langchain/vectorsearch/milvus.rb

@@ -6,7 +6,7 @@ module Langchain::Vectorsearch
     # Wrapper around Milvus REST APIs.
     #
     # Gem requirements:
-    #     gem "milvus", "~> 0.9.2"
+    #     gem "milvus", "~> 0.9.3"
     #
     # Usage:
     # milvus = Langchain::Vectorsearch::Milvus.new(url:, index_name:, llm:, api_key:)
@@ -39,6 +39,21 @@ module Langchain::Vectorsearch
       )
     end
 
+    # Deletes a list of texts in the index
+    #
+    # @param ids [Array<Integer>] The ids of texts to delete
+    # @return [Boolean] The response from the server
+    def remove_texts(ids:)
+      raise ArgumentError, "ids must be an array" unless ids.is_a?(Array)
+      # Convert ids to integers if strings are passed
+      ids = ids.map(&:to_i)
+
+      client.entities.delete(
+        collection_name: index_name,
+        expression: "id in #{ids}"
+      )
+    end
+
     # TODO: Add update_texts method
 
     # Create default schema
@@ -83,7 +98,7 @@ module Langchain::Vectorsearch
     # @return [Boolean] The response from the server
     def create_default_index
       client.indices.create(
-        collection_name: "Documents",
+        collection_name: index_name,
         field_name: "vectors",
         extra_params: [
           {key: "metric_type", value: "L2"},

data/lib/langchain/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Langchain
-  VERSION = "0.13.4"
+  VERSION = "0.13.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: langchainrb
 version: !ruby/object:Gem::Version
-  version: 0.13.4
+  version: 0.13.5
 platform: ruby
 authors:
 - Andrei Bondarev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-16 00:00:00.000000000 Z
+date: 2024-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: baran
@@ -408,14 +408,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: 0.9.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: 0.9.3
 - !ruby/object:Gem::Dependency
   name: llama_cpp
   requirement: !ruby/object:Gem::Requirement
@@ -809,6 +809,7 @@ files:
 - lib/langchain/tool/wikipedia/wikipedia.json
 - lib/langchain/tool/wikipedia/wikipedia.rb
 - lib/langchain/utils/cosine_similarity.rb
+- lib/langchain/utils/hash_transformer.rb
 - lib/langchain/utils/token_length/ai21_validator.rb
 - lib/langchain/utils/token_length/base_validator.rb
 - lib/langchain/utils/token_length/cohere_validator.rb
@@ -852,7 +853,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.14
 signing_key:
 specification_version: 4
 summary: Build LLM-backed Ruby applications with Ruby's Langchain.rb