langchainrb 0.13.1 → 0.13.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31daa3b09f92561f783122c10c1b48482bba75eac67e01550c71f7d76af36551
-  data.tar.gz: 355e21f33fbc3d21ac364ce046b0d2908ef111d2aa17996605df953ca25d0640
+  metadata.gz: d39fd55aeaa36e9d2a0009dac4808743d97941bd139bc9373eafb153cfb7854e
+  data.tar.gz: ddf8757341169f2e38bb076a9dfb5f5328a0de4e01ce58ec5b3263fdd3c47105
 SHA512:
-  metadata.gz: f2bbf794a223f9b0da303f9b65a1a309213db00d45227ce6e9d5a9bc039d1150e06b786ff9730c1e4f2f2fd6d6566687d4a04d3c39f5dcd8d9e66c8e84e097ba
-  data.tar.gz: b406738ff1be88c7c545ec284d3050a3b5c0bb34a747f345ff18cbaeb63a3abf9763ec723913bd58ddd62be261c6abd88a87448fd2b9d3bde00eb53d795931e2
+  metadata.gz: 243d774a05c2d5bfa27c8f98f51adac3ff13252cb108de085d8ac21b65977b8e8c7f9b78f4a58872b2a299c1e615b9fa6852cf27b564b567f6fa3d15dea2cf26
+  data.tar.gz: 6665f726069148c0adc24947d570b67d2f56f00ad5ffeeb6653fe745401f14768b324c67711cdaf023e782a3fa61c2787050ed2087db6ca34410a65a5e02a8ec

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [0.13.3] - 2024-06-03
+- New 🛠️  `Langchain::Tool::Tavily` to execute search (better than the GoogleSearch tool)
+- Remove `activesupport` dependency
+- Misc fixes and improvements
+
+## [0.13.2] - 2024-05-20
+- New `Langchain::LLM::GoogleGemini#embed()` method
+- `Langchain::Assistant` works with `Langchain::LLM::Anthropic` llm
+- New XLS file processor
+- Fixes and improvements
+
 ## [0.13.1] - 2024-05-14
 - Better error handling for `Langchain::LLM::GoogleVertexAI`
 

data/README.md

@@ -60,12 +60,13 @@ Langchain.rb wraps supported LLMs in a unified interface allowing you to easily
 | [OpenAI](https://openai.com/?utm_source=langchainrb&utm_medium=github)                          | ✅                 | ✅                 | ✅                  | ❌                 | Including Azure OpenAI |
 | [AI21](https://ai21.com/?utm_source=langchainrb&utm_medium=github)                              | ❌                 | ✅                 | ❌                  | ✅                 |                    |
 | [Anthropic](https://anthropic.com/?utm_source=langchainrb&utm_medium=github)                    | ❌                 | ✅                 | ✅                  | ❌                 |                    |
-| [AWS Bedrock](https://aws.amazon.com/bedrock?utm_source=langchainrb&utm_medium=github)          | ✅                 | ✅                 | ✅                  | ❌                 | Provides AWS, Cohere, AI21, Antropic and Stability AI models |
+| [AwsBedrock](https://aws.amazon.com/bedrock?utm_source=langchainrb&utm_medium=github)          | ✅                 | ✅                 | ✅                  | ❌                 | Provides AWS, Cohere, AI21, Antropic and Stability AI models |
 | [Cohere](https://cohere.com/?utm_source=langchainrb&utm_medium=github)                          | ✅                 | ✅                 | ✅                  | ✅                 |                    |
 | [GooglePalm](https://ai.google/discover/palm2?utm_source=langchainrb&utm_medium=github)         | ✅                 | ✅                 | ✅                  | ✅                 |                    |
-| [Google Vertex AI](https://cloud.google.com/vertex-ai?utm_source=langchainrb&utm_medium=github) | ✅                 | ✅                 | ❌                  | ✅                 |                    |
+| [GoogleVertexAI](https://cloud.google.com/vertex-ai?utm_source=langchainrb&utm_medium=github) | ✅                 | ❌                 | ✅                  | ❌                 | Requires Google Cloud service auth                   |
+| [GoogleGemini](https://cloud.google.com/vertex-ai?utm_source=langchainrb&utm_medium=github) | ✅                 | ❌                 | ✅                  | ❌                 | Requires Gemini API Key (Limited to US) |
 | [HuggingFace](https://huggingface.co/?utm_source=langchainrb&utm_medium=github)                 | ✅                 | ❌                 | ❌                  | ❌                 |                    |
-| [Mistral AI](https://mistral.ai/?utm_source=langchainrb&utm_medium=github)                      | ✅                 | ❌                 | ✅                  | ❌                 |                    |
+| [MistralAI](https://mistral.ai/?utm_source=langchainrb&utm_medium=github)                      | ✅                 | ❌                 | ✅                  | ❌                 |                    |
 | [Ollama](https://ollama.ai/?utm_source=langchainrb&utm_medium=github)                           | ✅                 | ✅                 | ✅                  | ✅                 |                    |
 | [Replicate](https://replicate.com/?utm_source=langchainrb&utm_medium=github)                    | ✅                 | ✅                 | ✅                  | ✅                 |                    |
 
@@ -413,12 +414,14 @@ Assistants are Agent-like objects that leverage helpful instructions, LLMs, tool
 | "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/) |  |
+| "tavily"     | A wrapper around Tavily AI                     | `ENV["TAVILY_API_KEY"]` (https://tavily.com/) |  |
 | "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"`     |
 
 ### Demos
 1. [Building an AI Assistant that operates a simulated E-commerce Store](https://www.loom.com/share/83aa4fd8dccb492aad4ca95da40ed0b2)
 2. [New Langchain.rb Assistants interface](https://www.loom.com/share/e883a4a49b8746c1b0acf9d58cf6da36)
+3. [Langchain.rb Assistant demo with NewsRetriever and function calling on Gemini](https://youtu.be/-ieyahrpDpM&t=1477s) - [code](https://github.com/palladius/gemini-news-crawler)
 
 ### Creating an Assistant
 1. Instantiate an LLM of your choice

data/lib/langchain/assistants/assistant.rb

@@ -2,12 +2,24 @@
 
 module Langchain
   # Assistants are Agent-like objects that leverage helpful instructions, LLMs, tools and knowledge to respond to user queries.
-  # Assistants can be configured with an LLM of your choice (currently only OpenAI), any vector search database and easily extended with additional tools.
+  # Assistants can be configured with an LLM of your choice, any vector search database and easily extended with additional tools.
+  #
+  # Usage:
+  #     llm = Langchain::LLM::GoogleGemini.new(api_key: ENV["GOOGLE_GEMINI_API_KEY"])
+  #     assistant = Langchain::Assistant.new(
+  #       llm: llm,
+  #       instructions: "You're a News Reporter AI",
+  #       tools: [Langchain::Tool::NewsRetriever.new(api_key: ENV["NEWS_API_KEY"])]
+  #     )
   class Assistant
+    extend Forwardable
+    def_delegators :thread, :messages, :messages=
+
     attr_reader :llm, :thread, :instructions
     attr_accessor :tools
 
     SUPPORTED_LLMS = [
+      Langchain::LLM::Anthropic,
       Langchain::LLM::OpenAI,
       Langchain::LLM::GoogleGemini,
       Langchain::LLM::GoogleVertexAI
@@ -21,27 +33,28 @@ module Langchain
     # @param instructions [String] The system instructions to include in the thread
     def initialize(
       llm:,
-      thread:,
+      thread: nil,
       tools: [],
       instructions: nil
     )
       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) }
 
       @llm = llm
-      @thread = thread
+      @thread = thread || Langchain::Thread.new
       @tools = tools
       @instructions = instructions
 
+      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
-      # For Google Gemini, system instructions are added to the `system:` param in the `chat` method
+      # For Google Gemini, and Anthropic system instructions are added to the `system:` param in the `chat` method
     end
 
     # Add a user message to the thread
@@ -137,6 +150,8 @@ module Langchain
         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
 
       # TODO: Validate that `tool_call_id` is valid by scanning messages and checking if this tool call ID was invoked
@@ -179,12 +194,17 @@ module Langchain
       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.
-        params[:tool_choice] = "auto"
       end
 
       llm.chat(**params)
@@ -200,6 +220,8 @@ module Langchain
           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_instance = tools.find do |t|
@@ -234,6 +256,20 @@ module Langchain
       [tool_call_id, tool_name, method_name, tool_arguments]
     end
 
+    # Extract the tool call information from the Anthropic tool call hash
+    #
+    # @param tool_call [Hash] The tool call hash, format: {"type"=>"tool_use", "id"=>"toolu_01TjusbFApEbwKPRWTRwzadR", "name"=>"news_retriever__get_top_headlines", "input"=>{"country"=>"us", "page_size"=>10}}], "stop_reason"=>"tool_use"}
+    # @return [Array] The tool call information
+    def extract_anthropic_tool_call(tool_call:)
+      tool_call_id = tool_call.dig("id")
+
+      function_name = tool_call.dig("name")
+      tool_name, method_name = function_name.split("__")
+      tool_arguments = tool_call.dig("input").transform_keys(&:to_sym)
+
+      [tool_call_id, tool_name, method_name, tool_arguments]
+    end
+
     # Extract the tool call information from the Google Gemini tool call hash
     #
     # @param tool_call [Hash] The tool call hash, format: {"functionCall"=>{"name"=>"weather__execute", "args"=>{"input"=>"NYC"}}}
@@ -260,6 +296,8 @@ module Langchain
         Langchain::Messages::OpenAIMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
       elsif [Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI].include?(llm.class)
         Langchain::Messages::GoogleGeminiMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+      elsif llm.is_a?(Langchain::LLM::Anthropic)
+        Langchain::Messages::AnthropicMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
       end
     end
 

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Langchain
+  module Messages
+    class AnthropicMessage < Base
+      ROLES = [
+        "assistant",
+        "user",
+        "tool_result"
+      ].freeze
+
+      TOOL_ROLE = "tool_result"
+
+      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 Anthropic API-compatible hash
+      #
+      # @return [Hash] The message as an Anthropic API-compatible hash
+      def to_hash
+        {}.tap do |h|
+          h[:role] = tool? ? "user" : role
+
+          h[:content] = if tool?
+            [
+              {
+                type: "tool_result",
+                tool_use_id: tool_call_id,
+                content: content
+              }
+            ]
+          elsif tool_calls.any?
+            tool_calls
+          else
+            content
+          end
+        end
+      end
+
+      # Check if the message is a tool call
+      #
+      # @return [Boolean] true/false whether this message is a tool call
+      def tool?
+        role == "tool_result"
+      end
+
+      # Anthropic does not implement system prompts
+      def system?
+        false
+      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 came from an LLM
+      #
+      # @return [Boolean] true/false whether this message was produced by an LLM
+      def llm?
+        assistant?
+      end
+    end
+  end
+end

data/lib/langchain/llm/anthropic.rb

@@ -101,6 +101,8 @@ module Langchain::LLM
     # @option params [Float] :top_p Use nucleus sampling.
     # @return [Langchain::LLM::AnthropicResponse] The chat completion
     def chat(params = {})
+      set_extra_headers! if params[:tools]
+
       parameters = chat_parameters.to_params(params)
 
       raise ArgumentError.new("messages argument is required") if Array(parameters[:messages]).empty?
@@ -111,5 +113,11 @@ module Langchain::LLM
 
       Langchain::LLM::AnthropicResponse.new(response)
     end
+
+    private
+
+    def set_extra_headers!
+      ::Anthropic.configuration.extra_headers = {"anthropic-beta": "tools-2024-05-16"}
+    end
   end
 end

data/lib/langchain/llm/aws_bedrock.rb

@@ -135,22 +135,43 @@ module Langchain::LLM
     # @option params [Float] :temperature The temperature to use for completion
     # @option params [Float] :top_p Use nucleus sampling.
     # @option params [Integer] :top_k Only sample from the top K options for each subsequent token
-    # @return [Langchain::LLM::AnthropicMessagesResponse] Response object
-    def chat(params = {})
+    # @yield [Hash] Provides chunks of the response as they are received
+    # @return [Langchain::LLM::AnthropicResponse] Response object
+    def chat(params = {}, &block)
       parameters = chat_parameters.to_params(params)
 
       raise ArgumentError.new("messages argument is required") if Array(parameters[:messages]).empty?
 
       raise "Model #{parameters[:model]} does not support chat completions." unless Langchain::LLM::AwsBedrock::SUPPORTED_CHAT_COMPLETION_PROVIDERS.include?(completion_provider)
 
-      response = client.invoke_model({
-        model_id: parameters[:model],
-        body: parameters.except(:model).to_json,
-        content_type: "application/json",
-        accept: "application/json"
-      })
+      if block
+        response_chunks = []
 
-      parse_response response
+        client.invoke_model_with_response_stream(
+          model_id: parameters[:model],
+          body: parameters.except(:model).to_json,
+          content_type: "application/json",
+          accept: "application/json"
+        ) do |stream|
+          stream.on_event do |event|
+            chunk = JSON.parse(event.bytes)
+            response_chunks << chunk
+
+            yield chunk
+          end
+        end
+
+        response_from_chunks(response_chunks)
+      else
+        response = client.invoke_model({
+          model_id: parameters[:model],
+          body: parameters.except(:model).to_json,
+          content_type: "application/json",
+          accept: "application/json"
+        })
+
+        parse_response response
+      end
     end
 
     private
@@ -260,5 +281,37 @@ module Langchain::LLM
         }
       }
     end
+
+    def response_from_chunks(chunks)
+      raw_response = {}
+
+      chunks.group_by { |chunk| chunk["type"] }.each do |type, chunks|
+        case type
+        when "message_start"
+          raw_response = chunks.first["message"]
+        when "content_block_start"
+          raw_response["content"] = chunks.map { |chunk| chunk["content_block"] }
+        when "content_block_delta"
+          chunks.group_by { |chunk| chunk["index"] }.each do |index, deltas|
+            deltas.group_by { |delta| delta.dig("delta", "type") }.each do |type, deltas|
+              case type
+              when "text_delta"
+                raw_response["content"][index]["text"] = deltas.map { |delta| delta.dig("delta", "text") }.join
+              when "input_json_delta"
+                json_string = deltas.map { |delta| delta.dig("delta", "partial_json") }.join
+                raw_response["content"][index]["input"] = json_string.empty? ? {} : JSON.parse(json_string)
+              end
+            end
+          end
+        when "message_delta"
+          chunks.each do |chunk|
+            raw_response = raw_response.merge(chunk["delta"])
+            raw_response["usage"] = raw_response["usage"].merge(chunk["usage"]) if chunk["usage"]
+          end
+        end
+      end
+
+      Langchain::LLM::AnthropicResponse.new(raw_response)
+    end
   end
 end

data/lib/langchain/llm/google_gemini.rb

@@ -6,6 +6,7 @@ module Langchain::LLM
   class GoogleGemini < Base
     DEFAULTS = {
       chat_completion_model_name: "gemini-1.5-pro-latest",
+      embeddings_model_name: "text-embedding-004",
       temperature: 0.0
     }
 
@@ -63,5 +64,35 @@ module Langchain::LLM
         raise StandardError.new(response)
       end
     end
+
+    def embed(
+      text:,
+      model: @defaults[:embeddings_model_name]
+    )
+
+      params = {
+        content: {
+          parts: [
+            {
+              text: text
+            }
+          ]
+        }
+      }
+
+      uri = URI("https://generativelanguage.googleapis.com/v1beta/models/#{model}:embedContent?key=#{api_key}")
+
+      request = Net::HTTP::Post.new(uri)
+      request.content_type = "application/json"
+      request.body = params.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)
+
+      Langchain::LLM::GoogleGeminiResponse.new(parsed_response, model: model)
+    end
   end
 end

data/lib/langchain/llm/google_vertex_ai.rb

@@ -28,7 +28,10 @@ module Langchain::LLM
     def initialize(project_id:, region:, default_options: {})
       depends_on "googleauth"
 
-      @authorizer = ::Google::Auth.get_application_default
+      @authorizer = ::Google::Auth.get_application_default(scope: [
+        "https://www.googleapis.com/auth/cloud-platform",
+        "https://www.googleapis.com/auth/generative-language.retriever"
+      ])
       proj_id = project_id || @authorizer.project_id || @authorizer.quota_project_id
       @url = "https://#{region}-aiplatform.googleapis.com/v1/projects/#{proj_id}/locations/#{region}/publishers/google/models/"
 

data/lib/langchain/llm/hugging_face.rb

@@ -11,12 +11,12 @@ module Langchain::LLM
   #     hf = Langchain::LLM::HuggingFace.new(api_key: ENV["HUGGING_FACE_API_KEY"])
   #
   class HuggingFace < Base
-    # The gem does not currently accept other models:
-    # https://github.com/alchaplinsky/hugging-face/blob/main/lib/hugging_face/inference_api.rb#L32-L34
     DEFAULTS = {
-      temperature: 0.0,
-      embeddings_model_name: "sentence-transformers/all-MiniLM-L6-v2",
-      dimensions: 384 # Vector size generated by the above model
+      embeddings_model_name: "sentence-transformers/all-MiniLM-L6-v2"
+    }.freeze
+
+    EMBEDDING_SIZES = {
+      "sentence-transformers/all-MiniLM-L6-v2": 384
     }.freeze
 
     #
@@ -24,10 +24,21 @@ module Langchain::LLM
     #
     # @param api_key [String] The API key to use
     #
-    def initialize(api_key:)
+    def initialize(api_key:, default_options: {})
       depends_on "hugging-face", req: "hugging_face"
 
       @client = ::HuggingFace::InferenceApi.new(api_token: api_key)
+      @defaults = DEFAULTS.merge(default_options)
+    end
+
+    # Returns the # of vector dimensions for the embeddings
+    # @return [Integer] The # of vector dimensions
+    def default_dimensions
+      # since Huggin Face can run multiple models, look it up or generate an embedding and return the size
+      @default_dimensions ||= @defaults[:dimensions] ||
+        EMBEDDING_SIZES.fetch(@defaults[:embeddings_model_name].to_sym) do
+          embed(text: "test").embedding.size
+        end
     end
 
     #
@@ -39,9 +50,9 @@ module Langchain::LLM
     def embed(text:)
       response = client.embedding(
         input: text,
-        model: DEFAULTS[:embeddings_model_name]
+        model: @defaults[:embeddings_model_name]
       )
-      Langchain::LLM::HuggingFaceResponse.new(response, model: DEFAULTS[:embeddings_model_name])
+      Langchain::LLM::HuggingFaceResponse.new(response, model: @defaults[:embeddings_model_name])
     end
   end
 end

data/lib/langchain/llm/ollama.rb

@@ -65,8 +65,14 @@ module Langchain::LLM
     # @param model [String] The model to use
     #   For a list of valid parameters and values, see:
     #   https://github.com/jmorganca/ollama/blob/main/docs/modelfile.md#valid-parameters-and-values
+    # @option block [Proc] Receive the intermediate responses as a stream of +OllamaResponse+ objects.
     # @return [Langchain::LLM::OllamaResponse] Response object
     #
+    # Example:
+    #
+    #  final_resp = ollama.complete(prompt:) { |resp| print resp.completion }
+    #  final_resp.total_tokens
+    #
     def complete(
       prompt:,
       model: defaults[:completion_model_name],
@@ -75,7 +81,6 @@ module Langchain::LLM
       system: nil,
       template: nil,
       context: nil,
-      stream: nil,
       raw: nil,
       mirostat: nil,
       mirostat_eta: nil,
@@ -108,7 +113,7 @@ module Langchain::LLM
         system: system,
         template: template,
         context: context,
-        stream: stream,
+        stream: block.present?,
         raw: raw
       }.compact
 
@@ -132,53 +137,54 @@ module Langchain::LLM
       }
 
       parameters[:options] = llm_parameters.compact
+      responses_stream = []
 
-      response = ""
-
-      client.post("api/generate") do |req|
-        req.body = parameters
+      client.post("api/generate", parameters) do |req|
+        req.options.on_data = json_responses_chunk_handler do |parsed_chunk|
+          responses_stream << parsed_chunk
 
-        req.options.on_data = proc do |chunk, size|
-          chunk.split("\n").each do |line_chunk|
-            json_chunk = begin
-              JSON.parse(line_chunk)
-            # In some instance the chunk exceeds the buffer size and the JSON parser fails
-            rescue JSON::ParserError
-              nil
-            end
-
-            response += json_chunk.dig("response") unless json_chunk.blank?
-          end
-
-          yield json_chunk, size if block
+          block&.call(OllamaResponse.new(parsed_chunk, model: parameters[:model]))
         end
       end
 
-      Langchain::LLM::OllamaResponse.new(response, model: parameters[:model])
+      generate_final_completion_response(responses_stream, parameters)
     end
 
     # Generate a chat completion
     #
-    # @param [Hash] params unified chat parmeters from [Langchain::LLM::Parameters::Chat::SCHEMA]
-    # @option params [String] :model Model name
+    # @param messages [Array] The chat messages
+    # @param model [String] The model to use
+    # @param params [Hash] Unified chat parmeters from [Langchain::LLM::Parameters::Chat::SCHEMA]
     # @option params [Array<Hash>] :messages Array of messages
+    # @option params [String] :model Model name
     # @option params [String] :format Format to return a response in. Currently the only accepted value is `json`
     # @option params [Float] :temperature The temperature to use
     # @option params [String] :template The prompt template to use (overrides what is defined in the `Modelfile`)
-    # @option params [Boolean] :stream Streaming the response. If false the response will be returned as a single response object, rather than a stream of objects
+    # @option block [Proc] Receive the intermediate responses as a stream of +OllamaResponse+ objects.
+    # @return [Langchain::LLM::OllamaResponse] Response object
+    #
+    # Example:
+    #
+    #  final_resp = ollama.chat(messages:) { |resp| print resp.chat_completion }
+    #  final_resp.total_tokens
     #
     # The message object has the following fields:
     #   role: the role of the message, either system, user or assistant
     #   content: the content of the message
     #   images (optional): a list of images to include in the message (for multimodal models such as llava)
-    def chat(params = {})
-      parameters = chat_parameters.to_params(params)
+    def chat(messages:, model: nil, **params, &block)
+      parameters = chat_parameters.to_params(params.merge(messages:, model:, stream: block.present?))
+      responses_stream = []
 
-      response = client.post("api/chat") do |req|
-        req.body = parameters
+      client.post("api/chat", parameters) do |req|
+        req.options.on_data = json_responses_chunk_handler do |parsed_chunk|
+          responses_stream << parsed_chunk
+
+          block&.call(OllamaResponse.new(parsed_chunk, model: parameters[:model]))
+        end
       end
 
-      Langchain::LLM::OllamaResponse.new(response.body, model: parameters[:model])
+      generate_final_chat_completion_response(responses_stream, parameters)
     end
 
     #
@@ -239,7 +245,7 @@ module Langchain::LLM
         req.body = parameters
       end
 
-      Langchain::LLM::OllamaResponse.new(response.body, model: parameters[:model])
+      OllamaResponse.new(response.body, model: parameters[:model])
     end
 
     # Generate a summary for a given text
@@ -257,7 +263,6 @@ module Langchain::LLM
 
     private
 
-    # @return [Faraday::Connection] Faraday client
     def client
       @client ||= Faraday.new(url: url) do |conn|
         conn.request :json
@@ -265,5 +270,33 @@ module Langchain::LLM
         conn.response :raise_error
       end
     end
+
+    def json_responses_chunk_handler(&block)
+      proc do |chunk, _size|
+        chunk.split("\n").each do |chunk_line|
+          parsed_chunk = JSON.parse(chunk_line)
+          block.call(parsed_chunk)
+        end
+      end
+    end
+
+    def generate_final_completion_response(responses_stream, parameters)
+      final_response = responses_stream.last.merge(
+        "response" => responses_stream.map { |resp| resp["response"] }.join
+      )
+
+      OllamaResponse.new(final_response, model: parameters[:model])
+    end
+
+    def generate_final_chat_completion_response(responses_stream, parameters)
+      final_response = responses_stream.last.merge(
+        "message" => {
+          "role" => "assistant",
+          "content" => responses_stream.map { |resp| resp.dig("message", "content") }.join
+        }
+      )
+
+      OllamaResponse.new(final_response, model: parameters[:model])
+    end
   end
 end

data/lib/langchain/llm/openai.rb

@@ -26,8 +26,6 @@ module Langchain::LLM
       "text-embedding-3-small" => 1536
     }.freeze
 
-    LENGTH_VALIDATOR = Langchain::Utils::TokenLength::OpenAIValidator
-
     attr_reader :defaults
 
     # Initialize an OpenAI LLM instance
@@ -82,8 +80,6 @@ module Langchain::LLM
         parameters[:dimensions] = EMBEDDING_SIZES[model]
       end
 
-      validate_max_tokens(text, parameters[:model])
-
       response = with_api_error_handling do
         client.embeddings(parameters: parameters)
       end
@@ -177,10 +173,6 @@ module Langchain::LLM
       response
     end
 
-    def validate_max_tokens(messages, model, max_tokens = nil)
-      LENGTH_VALIDATOR.validate_max_tokens!(messages, model, max_tokens: max_tokens, llm: self)
-    end
-
     def response_from_chunks
       grouped_chunks = @response_chunks.group_by { |chunk| chunk.dig("choices", 0, "index") }
       final_choices = grouped_chunks.map do |index, chunks|
@@ -188,12 +180,31 @@ module Langchain::LLM
           "index" => index,
           "message" => {
             "role" => "assistant",
-            "content" => chunks.map { |chunk| chunk.dig("choices", 0, "delta", "content") }.join
-          },
+            "content" => chunks.map { |chunk| chunk.dig("choices", 0, "delta", "content") }.join,
+            "tool_calls" => tool_calls_from_choice_chunks(chunks)
+          }.compact,
           "finish_reason" => chunks.last.dig("choices", 0, "finish_reason")
         }
       end
       @response_chunks.first&.slice("id", "object", "created", "model")&.merge({"choices" => final_choices})
     end
+
+    def tool_calls_from_choice_chunks(choice_chunks)
+      tool_call_chunks = choice_chunks.select { |chunk| chunk.dig("choices", 0, "delta", "tool_calls") }
+      return nil if tool_call_chunks.empty?
+
+      tool_call_chunks.group_by { |chunk| chunk.dig("choices", 0, "delta", "tool_calls", 0, "index") }.map do |index, chunks|
+        first_chunk = chunks.first
+
+        {
+          "id" => first_chunk.dig("choices", 0, "delta", "tool_calls", 0, "id"),
+          "type" => first_chunk.dig("choices", 0, "delta", "tool_calls", 0, "type"),
+          "function" => {
+            "name" => first_chunk.dig("choices", 0, "delta", "tool_calls", 0, "function", "name"),
+            "arguments" => chunks.map { |chunk| chunk.dig("choices", 0, "delta", "tool_calls", 0, "function", "arguments") }.join
+          }
+        }
+      end
+    end
   end
 end

data/lib/langchain/llm/response/anthropic_response.rb

@@ -11,7 +11,17 @@ module Langchain::LLM
     end
 
     def chat_completion
-      raw_response.dig("content", 0, "text")
+      chat_completion = chat_completions.find { |h| h["type"] == "text" }
+      chat_completion&.dig("text")
+    end
+
+    def tool_calls
+      tool_call = chat_completions.find { |h| h["type"] == "tool_use" }
+      tool_call ? [tool_call] : []
+    end
+
+    def chat_completions
+      raw_response.dig("content")
     end
 
     def completions

data/lib/langchain/llm/response/google_gemini_response.rb

@@ -27,7 +27,11 @@ module Langchain::LLM
     end
 
     def embeddings
-      [raw_response.dig("predictions", 0, "embeddings", "values")]
+      if raw_response.key?("embedding")
+        [raw_response.dig("embedding", "values")]
+      else
+        [raw_response.dig("predictions", 0, "embeddings", "values")]
+      end
     end
 
     def prompt_tokens

data/lib/langchain/llm/response/ollama_response.rb

@@ -8,9 +8,7 @@ module Langchain::LLM
     end
 
     def created_at
-      if raw_response.dig("created_at")
-        Time.parse(raw_response.dig("created_at"))
-      end
+      Time.parse(raw_response.dig("created_at")) if raw_response.dig("created_at")
     end
 
     def chat_completion
@@ -18,11 +16,11 @@ module Langchain::LLM
     end
 
     def completion
-      completions.first
+      raw_response.dig("response")
     end
 
     def completions
-      raw_response.is_a?(String) ? [raw_response] : []
+      [completion].compact
     end
 
     def embedding
@@ -38,15 +36,21 @@ module Langchain::LLM
     end
 
     def prompt_tokens
-      raw_response.dig("prompt_eval_count")
+      raw_response.dig("prompt_eval_count") if done?
     end
 
     def completion_tokens
-      raw_response.dig("eval_count")
+      raw_response.dig("eval_count") if done?
     end
 
     def total_tokens
-      prompt_tokens + completion_tokens
+      prompt_tokens + completion_tokens if done?
+    end
+
+    private
+
+    def done?
+      !!raw_response["done"]
     end
   end
 end

data/lib/langchain/processors/xls.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Langchain
+  module Processors
+    class Xls < Base
+      EXTENSIONS = [".xls"].freeze
+      CONTENT_TYPES = ["application/vnd.ms-excel"].freeze
+
+      def initialize(*)
+        depends_on "roo"
+        depends_on "roo-xls"
+      end
+
+      # Parse the document and return the text
+      # @param [File] data
+      # @return [Array<Array<String>>] Array of rows, each row is an array of cells
+      def parse(data)
+        xls_file = Roo::Spreadsheet.open(data)
+        xls_file.each_with_pagename.flat_map do |_, sheet|
+          sheet.map do |row|
+            row.map { |i| i.to_s.strip }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/langchain/tool/base.rb

@@ -71,6 +71,18 @@ module Langchain::Tool
       method_annotations
     end
 
+    # Returns the tool as a list of Anthropic formatted functions
+    #
+    # @return [Array<Hash>] List of hashes representing the tool as Anthropic formatted functions
+    def to_anthropic_tools
+      method_annotations.map do |annotation|
+        # Slice out only the content of the "function" key
+        annotation["function"]
+          # Rename "parameters" to "input_schema" key
+          .transform_keys("parameters" => "input_schema")
+      end
+    end
+
     # Returns the tool as a list of Google Gemini formatted functions
     #
     # @return [Array<Hash>] List of hashes representing the tool as Google Gemini formatted functions

data/lib/langchain/tool/news_retriever/news_retriever.json

@@ -68,7 +68,8 @@
         "properties": {
           "country": {
             "type": "string",
-            "description": "The 2-letter ISO 3166-1 code of the country you want to get headlines for."
+            "description": "The 2-letter ISO 3166-1 code of the country you want to get headlines for.",
+            "enum": ["ae", "ar", "at", "au", "be", "bg", "br", "ca", "ch", "cn", "co", "cu", "cz", "de", "eg", "fr", "gb", "gr", "hk", "hu", "id", "ie", "il", "in", "it", "jp", "kr", "lt", "lv", "ma", "mx", "my", "ng", "nl", "no", "nz", "ph", "pl", "pt", "ro", "rs", "ru", "sa", "se", "sg", "si", "sk", "th", "tr", "tw", "ua", "us", "ve", "za"]
           },
           "category": {
             "type": "string",

data/lib/langchain/tool/tavily/tavily.json

@@ -0,0 +1,54 @@
+[
+  {
+    "type": "function",
+    "function": {
+      "name": "tavily__search",
+      "description": "Tavily Tool: Robust search API",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "query": {
+            "type": "string",
+            "description": "The search query string"
+          },
+          "search_depth": {
+            "type": "string",
+            "description": "The depth of the search: basic for quick results and advanced for indepth high quality results but longer response time",
+            "enum": ["basic", "advanced"]
+          },
+          "include_images": {
+            "type": "boolean",
+            "description": "Include a list of query related images in the response"
+          },
+          "include_answer": {
+            "type": "boolean",
+            "description": "Include answers in the search results"
+          },
+          "include_raw_content": {
+            "type": "boolean",
+            "description": "Include raw content in the search results"
+          },
+          "max_results": {
+            "type": "integer",
+            "description": "The number of maximum search results to return"
+          },
+          "include_domains": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "A list of domains to specifically include in the search results"
+          },
+          "exclude_domains": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "A list of domains to specifically exclude from the search results"
+          }
+        },
+        "required": ["query"]
+      }
+    }
+  }
+]

data/lib/langchain/tool/tavily/tavily.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Langchain::Tool
+  class Tavily < Base
+    #
+    # Tavily Search is a robust search API tailored specifically for LLM Agents.
+    # It seamlessly integrates with diverse data sources to ensure a superior, relevant search experience.
+    #
+    # Usage:
+    #    tavily = Langchain::Tool::Tavily.new(api_key: ENV["TAVILY_API_KEY"])
+    #
+    NAME = "tavily"
+    ANNOTATIONS_PATH = Langchain.root.join("./langchain/tool/#{NAME}/#{NAME}.json").to_path
+
+    def initialize(api_key:)
+      @api_key = api_key
+    end
+
+    # Search for data based on a query.
+    #
+    # @param query [String] The search query string.
+    # @param search_depth [String] The depth of the search. It can be basic or advanced. Default is basic for quick results and advanced for indepth high quality results but longer response time. Advanced calls equals 2 requests.
+    # @param include_images [Boolean] Include a list of query related images in the response. Default is False.
+    # @param include_answer [Boolean] Include answers in the search results. Default is False.
+    # @param include_raw_content [Boolean] Include raw content in the search results. Default is False.
+    # @param max_results [Integer] The number of maximum search results to return. Default is 5.
+    # @param include_domains [Array<String>] A list of domains to specifically include in the search results. Default is None, which includes all domains.
+    # @param exclude_domains [Array<String>] A list of domains to specifically exclude from the search results. Default is None, which doesn't exclude any domains.
+    #
+    # @return [String] The search results in JSON format.
+    def search(
+      query:,
+      search_depth: "basic",
+      include_images: false,
+      include_answer: false,
+      include_raw_content: false,
+      max_results: 5,
+      include_domains: [],
+      exclude_domains: []
+    )
+      uri = URI("https://api.tavily.com/search")
+      request = Net::HTTP::Post.new(uri)
+      request.content_type = "application/json"
+      request.body = {
+        api_key: @api_key,
+        query: query,
+        search_depth: search_depth,
+        include_images: include_images,
+        include_answer: include_answer,
+        include_raw_content: include_raw_content,
+        max_results: max_results,
+        include_domains: include_domains,
+        exclude_domains: exclude_domains
+      }.to_json
+
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+        http.request(request)
+      end
+      response.body
+    end
+  end
+end

data/lib/langchain/version.rb

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

data/lib/langchain.rb

@@ -34,6 +34,7 @@ loader.collapse("#{__dir__}/langchain/tool/file_system")
 loader.collapse("#{__dir__}/langchain/tool/google_search")
 loader.collapse("#{__dir__}/langchain/tool/ruby_code_interpreter")
 loader.collapse("#{__dir__}/langchain/tool/news_retriever")
+loader.collapse("#{__dir__}/langchain/tool/tavily")
 loader.collapse("#{__dir__}/langchain/tool/vectorsearch")
 loader.collapse("#{__dir__}/langchain/tool/weather")
 loader.collapse("#{__dir__}/langchain/tool/wikipedia")

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: langchainrb
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 0.13.3
 platform: ruby
 authors:
 - Andrei Bondarev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-15 00:00:00.000000000 Z
+date: 2024-06-03 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 7.0.8
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 7.0.8
 - !ruby/object:Gem::Dependency
   name: baran
   requirement: !ruby/object:Gem::Requirement
@@ -52,20 +38,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.1.0
-- !ruby/object:Gem::Dependency
-  name: tiktoken_ruby
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.0.8
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.0.8
 - !ruby/object:Gem::Dependency
   name: json-schema
   requirement: !ruby/object:Gem::Requirement
@@ -346,6 +318,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.6.5
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: googleauth
   requirement: !ruby/object:Gem::Requirement
@@ -598,6 +584,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.10.0
+- !ruby/object:Gem::Dependency
+  name: roo-xls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: ruby-openai
   requirement: !ruby/object:Gem::Requirement
@@ -669,33 +669,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.17.0
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: power_point_pptx
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
-  name: power_point_pptx
+  name: tiktoken_ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.0.9
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.0.9
 description: Build LLM-backed Ruby applications with Ruby's Langchain.rb
 email:
 - andrei.bondarev13@gmail.com
@@ -708,6 +708,7 @@ files:
 - README.md
 - lib/langchain.rb
 - lib/langchain/assistants/assistant.rb
+- lib/langchain/assistants/messages/anthropic_message.rb
 - lib/langchain/assistants/messages/base.rb
 - lib/langchain/assistants/messages/google_gemini_message.rb
 - lib/langchain/assistants/messages/openai_message.rb
@@ -779,6 +780,7 @@ files:
 - lib/langchain/processors/pdf.rb
 - lib/langchain/processors/pptx.rb
 - lib/langchain/processors/text.rb
+- lib/langchain/processors/xls.rb
 - lib/langchain/processors/xlsx.rb
 - lib/langchain/prompt.rb
 - lib/langchain/prompt/base.rb
@@ -798,6 +800,8 @@ files:
 - lib/langchain/tool/news_retriever/news_retriever.rb
 - lib/langchain/tool/ruby_code_interpreter/ruby_code_interpreter.json
 - lib/langchain/tool/ruby_code_interpreter/ruby_code_interpreter.rb
+- lib/langchain/tool/tavily/tavily.json
+- lib/langchain/tool/tavily/tavily.rb
 - lib/langchain/tool/vectorsearch/vectorsearch.json
 - lib/langchain/tool/vectorsearch/vectorsearch.rb
 - lib/langchain/tool/weather/weather.json
@@ -848,7 +852,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: Build LLM-backed Ruby applications with Ruby's Langchain.rb