langchainrb 0.13.2 → 0.13.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30a8890d61255a8d937f2e2996f2b32de8ff432697a4a946afb08e853d383e2a
-  data.tar.gz: ee561cd2fac6b60308c07bfa300f09b6d1f8092ca669f2712f81a5b36814dd31
+  metadata.gz: d39fd55aeaa36e9d2a0009dac4808743d97941bd139bc9373eafb153cfb7854e
+  data.tar.gz: ddf8757341169f2e38bb076a9dfb5f5328a0de4e01ce58ec5b3263fdd3c47105
 SHA512:
-  metadata.gz: 3ab2bf6b1e57754497165b931e366d9c46051d829d3c05f23f73d3f20017eb91c86bf586cc318e7329e7990ae69002b0ad16638f5f41b3b0d141560a56c7236a
-  data.tar.gz: e621507bece6ff42ee80788bb9fb486dbd685b33d0f3893a9affca3d2edaf2a55441e98278bb056b290dcb2102d12a6eac5faea1c29d36a6e6f61118c43ee121
+  metadata.gz: 243d774a05c2d5bfa27c8f98f51adac3ff13252cb108de085d8ac21b65977b8e8c7f9b78f4a58872b2a299c1e615b9fa6852cf27b564b567f6fa3d15dea2cf26
+  data.tar.gz: 6665f726069148c0adc24947d570b67d2f56f00ad5ffeeb6653fe745401f14768b324c67711cdaf023e782a3fa61c2787050ed2087db6ca34410a65a5e02a8ec

data/CHANGELOG.md

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

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,8 +2,19 @@
 
 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
 
@@ -22,21 +33,22 @@ 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)

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/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

@@ -12,7 +12,7 @@ module Langchain::LLM
 
     def chat_completion
       chat_completion = chat_completions.find { |h| h["type"] == "text" }
-      chat_completion.dig("text")
+      chat_completion&.dig("text")
     end
 
     def tool_calls

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/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.2"
+  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.2
+  version: 0.13.3
 platform: ruby
 authors:
 - Andrei Bondarev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-20 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
@@ -683,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
@@ -814,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
@@ -864,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