langchainrb 0.12.1 → 0.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f106f178a5641f17ca723eec7272d120fbdd0e3046e44152eaf575af2985724
-  data.tar.gz: 417d5b671a6783d0854c05c43871b1e931133eaf65e6d39ac6ac4989a0124e36
+  metadata.gz: 31daa3b09f92561f783122c10c1b48482bba75eac67e01550c71f7d76af36551
+  data.tar.gz: 355e21f33fbc3d21ac364ce046b0d2908ef111d2aa17996605df953ca25d0640
 SHA512:
-  metadata.gz: 184b139d3e9d54fcd42665e25692d9fdb14e92c3d0bb23713647dfa2f1a87854215b13cc9573f10872d3e2e09d042e8c05640356276bc69a32423119e99c129b
-  data.tar.gz: 4503a8498018b53a9068345186efe03a72da4340d82a0f7806d4007e220c748814ab2da49194e09fd11ef33de3a35f38048e835dd43cee2c0b967bb810bfb512
+  metadata.gz: f2bbf794a223f9b0da303f9b65a1a309213db00d45227ce6e9d5a9bc039d1150e06b786ff9730c1e4f2f2fd6d6566687d4a04d3c39f5dcd8d9e66c8e84e097ba
+  data.tar.gz: b406738ff1be88c7c545ec284d3050a3b5c0bb34a747f345ff18cbaeb63a3abf9763ec723913bd58ddd62be261c6abd88a87448fd2b9d3bde00eb53d795931e2

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [0.13.1] - 2024-05-14
+- Better error handling for `Langchain::LLM::GoogleVertexAI`
+
+## [0.13.0] - 2024-05-14
+- New 🛠️ `Langchain::Tool::NewsRetriever` tool to fetch news via newsapi.org
+- Langchain::Assistant works with `Langchain::LLM::GoogleVertexAI` and `Langchain::LLM::GoogleGemini` llms
+- [BREAKING] Introduce new `Langchain::Messages::Base` abstraction
+
 ## [0.12.1] - 2024-05-13
 - Langchain::LLM::Ollama now uses `llama3` by default
 - Langchain::LLM::Anthropic#complete() now uses `claude-2.1` by default

data/README.md

@@ -412,6 +412,7 @@ Assistants are Agent-like objects that leverage helpful instructions, LLMs, tool
 | "file_system"   | Interacts with the file system |                                                               |       |
 | "ruby_code_interpreter" | Interprets Ruby expressions             |                                                               | `gem "safe_ruby", "~> 1.0.4"`             |
 | "google_search"     | A wrapper around Google Search                     | `ENV["SERPAPI_API_KEY"]` (https://serpapi.com/manage-api-key) | `gem "google_search_results", "~> 2.0.0"` |
+| "news_retriever"     | A wrapper around NewsApi.org                     | `ENV["NEWS_API_KEY"]` (https://newsapi.org/) |  |
 | "weather"  | Calls Open Weather API to retrieve the current weather        |      `ENV["OPEN_WEATHER_API_KEY"]` (https://home.openweathermap.org/api_keys)               | `gem "open-weather-ruby-client", "~> 0.3.0"`    |
 | "wikipedia"  | Calls Wikipedia API to retrieve the summary        |                                                               | `gem "wikipedia-client", "~> 1.17.0"`     |
 
@@ -445,14 +446,14 @@ assistant = Langchain::Assistant.new(
   thread: thread,
   instructions: "You are a Meteorologist Assistant that is able to pull the weather for any location",
   tools: [
-    Langchain::Tool::GoogleSearch.new(api_key: ENV["SERPAPI_API_KEY"])
+    Langchain::Tool::Weather.new(api_key: ENV["OPEN_WEATHER_API_KEY"])
   ]
 )
 ```
 ### Using an Assistant
 You can now add your message to an Assistant.
 ```ruby
-assistant.add_message content: "What's the weather in New York City?"
+assistant.add_message content: "What's the weather in New York, New York?"
 ```
 
 Run the Assistant to generate a response. 

data/lib/langchain/assistants/assistant.rb

@@ -7,6 +7,12 @@ module Langchain
     attr_reader :llm, :thread, :instructions
     attr_accessor :tools
 
+    SUPPORTED_LLMS = [
+      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
@@ -19,7 +25,9 @@ module Langchain
       tools: [],
       instructions: nil
     )
-      raise ArgumentError, "Invalid LLM; currently only Langchain::LLM::OpenAI is supported" unless llm.instance_of?(Langchain::LLM::OpenAI)
+      unless SUPPORTED_LLMS.include?(llm.class)
+        raise ArgumentError, "Invalid LLM; currently only #{SUPPORTED_LLMS.join(", ")} are supported"
+      end
       raise ArgumentError, "Thread must be an instance of Langchain::Thread" unless thread.is_a?(Langchain::Thread)
       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) }
 
@@ -30,7 +38,10 @@ module Langchain
 
       # 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?
-      add_message(role: "system", content: instructions) if instructions
+      if llm.is_a?(Langchain::LLM::OpenAI)
+        add_message(role: "system", content: instructions) if instructions
+      end
+      # For Google Gemini, system instructions are added to the `system:` param in the `chat` method
     end
 
     # Add a user message to the thread
@@ -59,11 +70,12 @@ module Langchain
 
       while running
         # TODO: I think we need to look at all messages and not just the last one.
-        case (last_message = thread.messages.last).role
-        when "system"
+        last_message = thread.messages.last
+
+        if last_message.system?
           # Do nothing
           running = false
-        when "assistant"
+        elsif last_message.llm?
           if last_message.tool_calls.any?
             if auto_tool_execution
               run_tools(last_message.tool_calls)
@@ -76,11 +88,11 @@ module Langchain
             # Do nothing
             running = false
           end
-        when "user"
+        elsif last_message.user?
           # Run it!
           response = chat_with_llm
 
-          if response.tool_calls
+          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)
@@ -89,12 +101,12 @@ module Langchain
             running = false
             add_message(role: response.role, content: response.chat_completion)
           end
-        when "tool"
+        elsif last_message.tool?
           # Run it!
           response = chat_with_llm
           running = true
 
-          if response.tool_calls
+          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)
@@ -121,8 +133,14 @@ 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:)
-      # TODO: Validate that `tool_call_id` is valid
-      add_message(role: "tool", content: output, tool_call_id: tool_call_id)
+      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
+      end
+
+      # 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)
     end
 
     # Delete all messages in the thread
@@ -156,10 +174,15 @@ module Langchain
     def chat_with_llm
       Langchain.logger.info("Sending a call to #{llm.class}", for: self.class)
 
-      params = {messages: thread.openai_messages}
+      params = {messages: thread.array_of_message_hashes}
 
       if tools.any?
-        params[:tools] = tools.map(&:to_openai_tools).flatten
+        if llm.is_a?(Langchain::LLM::OpenAI)
+          params[:tools] = tools.map(&:to_openai_tools).flatten
+        elsif [Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI].include?(llm.class)
+          params[:tools] = tools.map(&:to_google_gemini_tools).flatten
+          params[:system] = instructions if instructions
+        end
         # TODO: Not sure that tool_choice should always be "auto"; Maybe we can let the user toggle it.
         params[:tool_choice] = "auto"
       end
@@ -173,11 +196,11 @@ 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_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 = 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)
+        end
 
         tool_instance = tools.find do |t|
           t.name == tool_name
@@ -190,13 +213,41 @@ module Langchain
 
       response = chat_with_llm
 
-      if response.tool_calls
+      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
+    #
+    # @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 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
@@ -205,7 +256,11 @@ 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)
-      Message.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+      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)
+      end
     end
 
     # TODO: Fix the message truncation when context window is exceeded

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Langchain
+  module Messages
+    class Base
+      attr_reader :role, :content, :tool_calls, :tool_call_id
+
+      # Check if the message came from a user
+      #
+      # @param [Boolean] true/false whether the message came from a user
+      def user?
+        role == "user"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Langchain
+  module Messages
+    class GoogleGeminiMessage < Base
+      # Google Gemini uses the following roles:
+      ROLES = [
+        "user",
+        "model",
+        "function"
+      ].freeze
+
+      TOOL_ROLE = "function"
+
+      # Initialize a new Google Gemini 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
+
+      # Check if the message came from an LLM
+      #
+      # @return [Boolean] true/false whether this message was produced by an LLM
+      def llm?
+        model?
+      end
+
+      # Convert the message to a Google Gemini API-compatible hash
+      #
+      # @return [Hash] The message as a Google Gemini API-compatible hash
+      def to_hash
+        {}.tap do |h|
+          h[:role] = role
+          h[:parts] = if function?
+            [{
+              functionResponse: {
+                name: tool_call_id,
+                response: {
+                  name: tool_call_id,
+                  content: content
+                }
+              }
+            }]
+          elsif tool_calls.any?
+            tool_calls
+          else
+            [{text: content}]
+          end
+        end
+      end
+
+      # Google Gemini does not implement system prompts
+      def system?
+        false
+      end
+
+      # Check if the message is a tool call
+      #
+      # @return [Boolean] true/false whether this message is a tool call
+      def tool?
+        function?
+      end
+
+      # Check if the message is a tool call
+      #
+      # @return [Boolean] true/false whether this message is a tool call
+      def function?
+        role == "function"
+      end
+
+      # Check if the message came from an LLM
+      #
+      # @return [Boolean] true/false whether this message was produced by an LLM
+      def model?
+        role == "model"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Langchain
+  module Messages
+    class OpenAIMessage < 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) # TODO: Implement image_file: reference (https://platform.openai.com/docs/api-reference/messages/object#messages/object-content)
+        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
+
+      # Check if the message came from an LLM
+      #
+      # @return [Boolean] true/false whether this message was produced by an LLM
+      def llm?
+        assistant?
+      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 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

@@ -8,16 +8,16 @@ module Langchain
 
     # @param messages [Array<Langchain::Message>]
     def initialize(messages: [])
-      raise ArgumentError, "messages array must only contain Langchain::Message instance(s)" unless messages.is_a?(Array) && messages.all? { |m| m.is_a?(Langchain::Message) }
+      raise ArgumentError, "messages array must only contain Langchain::Message instance(s)" unless messages.is_a?(Array) && messages.all? { |m| m.is_a?(Langchain::Messages::Base) }
 
       @messages = messages
     end
 
-    # Convert the thread to an OpenAI API-compatible array of hashes
+    # Convert the thread to an LLM APIs-compatible array of hashes
     #
     # @return [Array<Hash>] The thread as an OpenAI API-compatible array of hashes
-    def openai_messages
-      messages.map(&:to_openai_format)
+    def array_of_message_hashes
+      messages.map(&:to_hash)
     end
 
     # Add a message to the thread
@@ -25,7 +25,7 @@ module Langchain
     # @param message [Langchain::Message] The message to add
     # @return [Array<Langchain::Message>] The updated messages array
     def add_message(message)
-      raise ArgumentError, "message must be a Langchain::Message instance" unless message.is_a?(Langchain::Message)
+      raise ArgumentError, "message must be a Langchain::Message instance" unless message.is_a?(Langchain::Messages::Base)
 
       # Prepend the message to the thread
       messages << message

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

@@ -42,6 +42,8 @@ module Langchain
 
         def count_verified_statements(verifications)
           match = verifications.match(/Final verdict for each statement in order:\s*(.*)/)
+          return 0.0 unless match # no verified statements found
+
           verdicts = match.captures.first
           verdicts
             .split(".")

data/lib/langchain/llm/base.rb

@@ -11,7 +11,8 @@ module Langchain::LLM
   # - {Langchain::LLM::Azure}
   # - {Langchain::LLM::Cohere}
   # - {Langchain::LLM::GooglePalm}
-  # - {Langchain::LLM::GoogleVertexAi}
+  # - {Langchain::LLM::GoogleVertexAI}
+  # - {Langchain::LLM::GoogleGemini}
   # - {Langchain::LLM::HuggingFace}
   # - {Langchain::LLM::LlamaCpp}
   # - {Langchain::LLM::OpenAI}

data/lib/langchain/llm/google_gemini.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Langchain::LLM
+  # Usage:
+  #     llm = Langchain::LLM::GoogleGemini.new(api_key: ENV['GOOGLE_GEMINI_API_KEY'])
+  class GoogleGemini < Base
+    DEFAULTS = {
+      chat_completion_model_name: "gemini-1.5-pro-latest",
+      temperature: 0.0
+    }
+
+    attr_reader :defaults, :api_key
+
+    def initialize(api_key:, 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]}
+      )
+      chat_parameters.remap(
+        messages: :contents,
+        system: :system_instruction,
+        tool_choice: :tool_config
+      )
+    end
+
+    # Generate a chat completion for a given prompt
+    #
+    # @param messages [Array<Hash>] List of messages comprising the conversation so far
+    # @param model [String] The model to use
+    # @param tools [Array<Hash>] A list of Tools the model may use to generate the next response
+    # @param tool_choice [String] Specifies the mode in which function calling should execute. If unspecified, the default value will be set to AUTO. Possible values: AUTO, ANY, NONE
+    # @param system [String] Developer set system instruction
+    def chat(params = {})
+      params[:system] = {parts: [{text: params[:system]}]} if params[:system]
+      params[:tools] = {function_declarations: params[:tools]} if params[:tools]
+      params[:tool_choice] = {function_calling_config: {mode: params[:tool_choice].upcase}} if params[:tool_choice]
+
+      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]
+
+      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
+
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+        http.request(request)
+      end
+
+      parsed_response = JSON.parse(response.body)
+
+      wrapped_response = Langchain::LLM::GoogleGeminiResponse.new(parsed_response, model: parameters[:model])
+
+      if wrapped_response.chat_completion || Array(wrapped_response.tool_calls).any?
+        wrapped_response
+      else
+        raise StandardError.new(response)
+      end
+    end
+  end
+end