langchainrb 0.10.3 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14c9c33c905c2df744cc7006735dbc55b86b767cfff4b655b03103072c804bb1
-  data.tar.gz: e5076e7322ff375b16463ff14e5c504d7b106e05874f6860f9669a2269346d61
+  metadata.gz: '08b38ee39600716a9854a387fc0b54091290f27d7afa88b276a480651049bdd4'
+  data.tar.gz: 69d4292c129e751d9d4001912f5ab54ba23f9d9944a5e4294f4ba1dd426d401e
 SHA512:
-  metadata.gz: f590a6f2f2adec60ee777a94886e178abfaf0789c0141bbd278d0a008d9ace75cb9f69d6afdf3ae3d58f7307246acfaf7f0fef43d43065bf8c1d83aa0e51562d
-  data.tar.gz: 3fef869c24edf5a14ea4ddbdae8af919b2082e8f95b676ca36dd9e606ba67812e88dcd6d67f15156b9cce8daaaab26acd9c8602e3c894199dd7eae43d0926443
+  metadata.gz: 3f7d4403d11076fcff2975c88a236fa8b6ace079d83b774000af1d59c08f36794057eaef56769a51bb8e21ab462bba9dbf9df60d704f285b788af8a67b6977ea
+  data.tar.gz: 5d14c72130cada67dadfe880b2a0d723b312d8c27e7ef46452aa4ad65dce1055b66d8459b24c4b6d3f1adb5eeacf30c9fdc686b0190809ef051d393c33d3d33d

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [0.11.0]
+- Langchain::Tool::Vectorsearch that wraps Langchain::Vectorsearch::* classes. This allows the Assistant to call the tool and inject data from vector DBs.
+
+## [0.11.0]
+- Delete previously deprecated `Langchain::Agent::ReActAgent` and `Langchain::Agent::SQLQueryAgent` classes
+- New `Langchain::Agent::FileSystem` tool that can read files, write to files, and list the contents of a directory
+
 ## [0.10.3]
 - Bump dependencies
 - Ollama#complete fix

data/README.md

@@ -15,7 +15,7 @@ Available for paid consulting engagements! [Email me](mailto:andrei@sourcelabs.i
 
 ## Use Cases
 * Retrieval Augmented Generation (RAG) and vector search
-* [Assistants](#assistants) (chat bots) & [AI Agents](https://github.com/andreibondarev/langchainrb/tree/main/lib/langchain/agent/agents.md)
+* [Assistants](#assistants) (chat bots)
 
 ## Table of Contents
 
@@ -55,19 +55,22 @@ require "langchain"
 Langchain.rb wraps supported LLMs in a unified interface allowing you to easily swap out and test out different models.
 
 #### Supported LLMs and features:
-| LLM providers                                                                                   | `embed()`            | `complete()`         | `chat()`              | `summarize()`        | Notes              |
+| LLM providers                                                                                   | `embed()`          | `complete()`       | `chat()`            | `summarize()`      | Notes              |
 | --------                                                                                        |:------------------:| :-------:          | :-----------------: | :-------:          | :----------------- |
 | [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)                        | ❌                 | ✅                 | ❌                  | ❌                 |                    |
+| [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 |
-| [Cohere](https://cohere.com/?utm_source=langchainrb&utm_medium=github)                     | ✅                 | ✅                 | ✅                  | ✅                 |                    |
+| [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) | ✅                 | ✅                 | ❌                  | ✅                 |                    |
 | [HuggingFace](https://huggingface.co/?utm_source=langchainrb&utm_medium=github)                 | ✅                 | ❌                 | ❌                  | ❌                 |                    |
+| [Mistral AI](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)                    | ✅                 | ✅                 | ✅                  | ✅                 |                    |
 
+
+
 #### Using standalone LLMs:
 
 #### OpenAI
@@ -400,6 +403,22 @@ client.ask(question: "...")
 ## Assistants
 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.
 
+### Available Tools 🛠️
+
+| Name         | Description                                        | ENV Requirements                                              | Gem Requirements                          |
+| ------------ | :------------------------------------------------: | :-----------------------------------------------------------: | :---------------------------------------: |
+| "calculator" | Useful for getting the result of a math expression |                                                               | `gem "eqn", "~> 1.6.5"`                   |
+| "database"   | Useful for querying a SQL database |                                                               | `gem "sequel", "~> 5.68.0"`                   |
+| "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"` |
+| "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)
+
 ### Creating an Assistant
 1. Instantiate an LLM of your choice
 ```ruby

data/lib/langchain/assistants/assistant.rb

@@ -50,6 +50,11 @@ module Langchain
     # @param auto_tool_execution [Boolean] Whether or not to automatically run tools
     # @return [Array<Langchain::Message>] The messages in the thread
     def run(auto_tool_execution: false)
+      if thread.messages.empty?
+        Langchain.logger.warn("No messages in the thread")
+        return
+      end
+
       running = true
 
       while running

data/lib/langchain/llm/openai.rb

@@ -21,9 +21,9 @@ module Langchain::LLM
     }.freeze
 
     EMBEDDING_SIZES = {
-      "text-embedding-ada-002": 1536,
-      "text-embedding-3-large": 3072,
-      "text-embedding-3-small": 1536
+      "text-embedding-ada-002" => 1536,
+      "text-embedding-3-large" => 3072,
+      "text-embedding-3-small" => 1536
     }.freeze
 
     LENGTH_VALIDATOR = Langchain::Utils::TokenLength::OpenAIValidator
@@ -54,7 +54,7 @@ module Langchain::LLM
       model: defaults[:embeddings_model_name],
       encoding_format: nil,
       user: nil,
-      dimensions: EMBEDDING_SIZES.fetch(model.to_sym, nil)
+      dimensions: nil
     )
       raise ArgumentError.new("text argument is required") if text.empty?
       raise ArgumentError.new("model argument is required") if model.empty?
@@ -67,8 +67,10 @@ module Langchain::LLM
       parameters[:encoding_format] = encoding_format if encoding_format
       parameters[:user] = user if user
 
-      if ["text-embedding-3-small", "text-embedding-3-large"].include?(model)
-        parameters[:dimensions] = EMBEDDING_SIZES[model.to_sym] if EMBEDDING_SIZES.key?(model.to_sym)
+      if dimensions
+        parameters[:dimensions] = dimensions
+      elsif EMBEDDING_SIZES.key?(model)
+        parameters[:dimensions] = EMBEDDING_SIZES[model]
       end
 
       validate_max_tokens(text, parameters[:model])
@@ -183,7 +185,7 @@ module Langchain::LLM
     end
 
     def default_dimension
-      @defaults[:dimension] || EMBEDDING_SIZES.fetch(defaults[:embeddings_model_name].to_sym)
+      @defaults[:dimension] || EMBEDDING_SIZES.fetch(defaults[:embeddings_model_name])
     end
 
     private

data/lib/langchain/tool/base.rb

@@ -9,6 +9,7 @@ module Langchain::Tool
   #
   # - {Langchain::Tool::Calculator}: calculate the result of a math expression
   # - {Langchain::Tool::Database}: executes SQL queries
+  # - {Langchain::Tool::FileSystem}: interacts with files
   # - {Langchain::Tool::GoogleSearch}: search on Google (via SerpAPI)
   # - {Langchain::Tool::RubyCodeInterpreter}: runs ruby code
   # - {Langchain::Tool::Weather}: gets current weather data
@@ -29,8 +30,9 @@ module Langchain::Tool
   #
   # 3. Pass the tools when Agent is instantiated.
   #
-  #     agent = Langchain::Agent::ReActAgent.new(
-  #       llm: Langchain::LLM::OpenAI.new(api_key: "YOUR_API_KEY"), # or other like Cohere, Hugging Face, Google Palm or Replicate
+  #     agent = Langchain::Assistant.new(
+  #       llm: Langchain::LLM::OpenAI.new(api_key: "YOUR_API_KEY"), # or other LLM that supports function calling (coming soon)
+  #       thread: Langchain::Thread.new,
   #       tools: [
   #         Langchain::Tool::GoogleSearch.new(api_key: "YOUR_API_KEY"),
   #         Langchain::Tool::Calculator.new,
@@ -42,9 +44,10 @@ module Langchain::Tool
   #
   # 1. Create a new file in lib/langchain/tool/your_tool_name.rb
   # 2. Create a class in the file that inherits from {Langchain::Tool::Base}
-  # 3. Add `NAME=` and `DESCRIPTION=` constants in your Tool class
-  # 4. Implement `execute(input:)` method in your tool class
-  # 5. Add your tool to the {file:README.md}
+  # 3. Add `NAME=` and `ANNOTATIONS_PATH=` constants in your Tool class
+  # 4. Implement various methods in your tool class
+  # 5. Create a sidecar .json file in the same directory as your tool file annotating the methods in the Open API format
+  # 6. Add your tool to the {file:README.md}
   class Base
     include Langchain::DependencyHelper
 
@@ -61,30 +64,6 @@ module Langchain::Tool
       }
     end
 
-    # Returns the DESCRIPTION constant of the tool
-    #
-    # @return [String] tool description
-    def description
-      self.class.const_get(:DESCRIPTION)
-    end
-
-    # Sets the DESCRIPTION constant of the tool
-    #
-    # @param value [String] tool description
-    def self.description(value)
-      const_set(:DESCRIPTION, value.tr("\n", " ").strip)
-    end
-
-    # Instantiates and executes the tool and returns the answer
-    #
-    # @param input [String] input to the tool
-    # @return [String] answer
-    def self.execute(input:)
-      warn "DEPRECATED: `#{self}.execute` is deprecated, and will be removed in the next major version."
-
-      new.execute(input: input)
-    end
-
     # Returns the tool as a list of OpenAI formatted functions
     #
     # @return [Hash] tool as an OpenAI tool
@@ -92,15 +71,6 @@ module Langchain::Tool
       method_annotations
     end
 
-    # Executes the tool and returns the answer
-    #
-    # @param input [String] input to the tool
-    # @return [String] answer
-    # @raise NotImplementedError when not implemented
-    def execute(input:)
-      raise NotImplementedError, "Your tool must implement the `#execute(input:)` method that returns a string"
-    end
-
     # Return tool's method annotations as JSON
     #
     # @return [Hash] Tool's method annotations
@@ -111,16 +81,5 @@ module Langchain::Tool
         )
       )
     end
-
-    # Validates the list of tools or raises an error
-    #
-    # @param tools [Array<Langchain::Tool>] list of tools to be used
-    # @raise [ArgumentError] If any of the tools are not supported
-    def self.validate_tools!(tools:)
-      # Check if the tool count is equal to unique tool count
-      if tools.count != tools.map(&:name).uniq.count
-        raise ArgumentError, "Either tools are not unique or are conflicting with each other"
-      end
-    end
   end
 end

data/lib/langchain/tool/calculator/calculator.rb

@@ -15,17 +15,6 @@ module Langchain::Tool
     NAME = "calculator"
     ANNOTATIONS_PATH = Langchain.root.join("./langchain/tool/#{NAME}/#{NAME}.json").to_path
 
-    description <<~DESC
-      Useful for getting the result of a math expression.
-
-      The input to this tool should be a valid mathematical expression that could be executed by a simple calculator.
-      Usage:
-        Action Input: 1 + 1
-        Action Input: 3 * 2 / 4
-        Action Input: 9 - 7
-        Action Input: (4.1 + 2.3) / (2.0 - 5.6) * 3
-    DESC
-
     def initialize
       depends_on "eqn"
     end

data/lib/langchain/tool/database/database.rb

@@ -12,12 +12,6 @@ module Langchain::Tool
     NAME = "database"
     ANNOTATIONS_PATH = Langchain.root.join("./langchain/tool/#{NAME}/#{NAME}.json").to_path
 
-    description <<~DESC
-      Useful for getting the result of a database query.
-
-      The input to this tool should be valid SQL.
-    DESC
-
     attr_reader :db, :requested_tables, :excluded_tables
 
     # Establish a database connection

data/lib/langchain/tool/file_system/file_system.json

@@ -0,0 +1,57 @@
+[
+  {
+    "type": "function",
+    "function": {
+      "name": "file_system-list_directory",
+      "description": "File System Tool: Lists out the content of a specified directory",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "directory_path": {
+            "type": "string",
+            "description": "Directory path to list"
+          }
+        },
+        "required": ["directory_path"]
+      }
+    }
+  },
+  {
+    "type": "function",
+    "function": {
+      "name": "file_system-read_file",
+      "description": "File System Tool: Reads the contents of a file",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "file_path": {
+            "type": "string",
+            "description": "Path to the file to read from"
+          }
+        },
+        "required": ["file_path"]
+      }
+    }
+  },
+  {
+    "type": "function",
+    "function": {
+      "name": "file_system-write_to_file",
+      "description": "File System Tool: Write content to a file",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "file_path": {
+            "type": "string",
+            "description": "Path to the file to write"
+          },
+          "content": {
+            "type": "string",
+            "description": "Content to write to the file"
+          }
+        },
+        "required": ["file_path", "content"]
+      }
+    }
+  }    
+]

data/lib/langchain/tool/file_system/file_system.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Langchain::Tool
+  class FileSystem < Base
+    #
+    # A tool that wraps the Ruby file system classes.
+    #
+    # Usage:
+    #    file_system = Langchain::Tool::FileSystem.new
+    #
+    NAME = "file_system"
+    ANNOTATIONS_PATH = Langchain.root.join("./langchain/tool/#{NAME}/#{NAME}.json").to_path
+
+    def list_directory(directory_path:)
+      Dir.entries(directory_path)
+    rescue Errno::ENOENT
+      "No such directory: #{directory_path}"
+    end
+
+    def read_file(file_path:)
+      File.read(file_path)
+    rescue Errno::ENOENT
+      "No such file: #{file_path}"
+    end
+
+    def write_to_file(file_path:, content:)
+      File.write(file_path, content)
+    rescue Errno::EACCES
+      "Permission denied: #{file_path}"
+    end
+  end
+end

data/lib/langchain/tool/google_search/google_search.rb

@@ -15,12 +15,6 @@ module Langchain::Tool
     NAME = "google_search"
     ANNOTATIONS_PATH = Langchain.root.join("./langchain/tool/#{NAME}/#{NAME}.json").to_path
 
-    description <<~DESC
-      A wrapper around SerpApi's Google Search API.
-
-      Useful for when you need to answer questions about current events. Always one of the first options when you need to find information on internet. Input should be a search query.
-    DESC
-
     attr_reader :api_key
 
     #

data/lib/langchain/tool/ruby_code_interpreter/ruby_code_interpreter.rb

@@ -14,10 +14,6 @@ module Langchain::Tool
     NAME = "ruby_code_interpreter"
     ANNOTATIONS_PATH = Langchain.root.join("./langchain/tool/#{NAME}/#{NAME}.json").to_path
 
-    description <<~DESC
-      A Ruby code interpreter. Use this to execute ruby expressions. Input should be a valid ruby expression. If you want to see the output of the tool, make sure to return a value.
-    DESC
-
     def initialize(timeout: 30)
       depends_on "safe_ruby"
 

data/lib/langchain/tool/vectorsearch/vectorsearch.json

@@ -0,0 +1,24 @@
+[
+  {
+    "type": "function",
+    "function": {
+      "name": "vectorsearch-similarity_search",
+      "description": "Vectorsearch: Retrieves relevant document for the query",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "query": {
+            "type": "string",
+            "description": "Query to find similar documents for"
+          },
+          "k": {
+            "type": "integer",
+            "description": "Number of similar documents to retrieve",
+            "default": 4
+          }
+        },
+        "required": ["query"]
+      }
+    }
+  }
+]

data/lib/langchain/tool/vectorsearch/vectorsearch.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Langchain::Tool
+  class Vectorsearch < Base
+    #
+    # A tool wraps vectorsearch classes
+    #
+    # Usage:
+    #    # Initialize the LLM that will be used to generate embeddings
+    #    ollama = Langchain::LLM::Ollama.new(url: ENV["OLLAMA_URL"]
+    #    chroma = Langchain::Vectorsearch::Chroma.new(url: ENV["CHROMA_URL"], index_name: "my_index", llm: ollama)
+    #
+    #    # This tool can now be used by the Assistant
+    #    vectorsearch_tool = Langchain::Tool::Vectorsearch.new(vectorsearch: chroma)
+    #
+    NAME = "vectorsearch"
+    ANNOTATIONS_PATH = Langchain.root.join("./langchain/tool/#{NAME}/#{NAME}.json").to_path
+
+    attr_reader :vectorsearch
+
+    # Initializes the Vectorsearch tool
+    #
+    # @param vectorsearch [Langchain::Vectorsearch::Base] Vectorsearch instance to use
+    def initialize(vectorsearch:)
+      @vectorsearch = vectorsearch
+    end
+
+    # Executes the vector search and returns the results
+    #
+    # @param query [String] The query to search for
+    # @param k [Integer] The number of results to return
+    def similarity_search(query:, k: 4)
+      vectorsearch.similarity_search(query:, k: 4)
+    end
+  end
+end

data/lib/langchain/tool/weather/weather.rb

@@ -19,17 +19,6 @@ module Langchain::Tool
     NAME = "weather"
     ANNOTATIONS_PATH = Langchain.root.join("./langchain/tool/#{NAME}/#{NAME}.json").to_path
 
-    description <<~DESC
-      Useful for getting current weather data
-
-      The input to this tool should be a city name followed by the units (imperial, metric, or standard)
-      Usage:
-        Action Input: St Louis, Missouri; metric
-        Action Input: Boston, Massachusetts; imperial
-        Action Input: Dubai, AE; imperial
-        Action Input: Kiev, Ukraine; metric
-    DESC
-
     attr_reader :client, :units
 
     # Initializes the Weather tool

data/lib/langchain/tool/wikipedia/wikipedia.rb

@@ -15,15 +15,6 @@ module Langchain::Tool
     NAME = "wikipedia"
     ANNOTATIONS_PATH = Langchain.root.join("./langchain/tool/#{NAME}/#{NAME}.json").to_path
 
-    description <<~DESC
-      A wrapper around Wikipedia.
-
-      Useful for when you need to answer general questions about
-      people, places, companies, facts, historical events, or other subjects.
-
-      Input should be a search query.
-    DESC
-
     # Initializes the Wikipedia tool
     def initialize
       depends_on "wikipedia-client", req: "wikipedia"

data/lib/langchain/vectorsearch/weaviate.rb

@@ -9,7 +9,7 @@ module Langchain::Vectorsearch
     #     gem "weaviate-ruby", "~> 0.8.9"
     #
     # Usage:
-    #     weaviate = Langchain::Vectorsearch::Weaviate.new(url:, api_key:, index_name:, llm:)
+    #     weaviate = Langchain::Vectorsearch::Weaviate.new(url: ENV["WEAVIATE_URL"], api_key: ENV["WEAVIATE_API_KEY"], index_name: "Docs", llm: llm)
     #
 
     # Initialize the Weaviate adapter
@@ -71,6 +71,22 @@ module Langchain::Vectorsearch
       end
     end
 
+    # Deletes a list of texts in the index
+    # @param ids [Array] The ids of texts to delete
+    # @return [Hash] The response from the server
+    def remove_texts(ids:)
+      raise ArgumentError, "ids must be an array" unless ids.is_a?(Array)
+
+      client.objects.batch_delete(
+        class_name: index_name,
+        where: {
+          path: ["__id"],
+          operator: "ContainsAny",
+          valueTextArray: ids
+        }
+      )
+    end
+
     # Create default schema
     # @return [Hash] The response from the server
     def create_default_schema

data/lib/langchain/version.rb

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

data/lib/langchain.rb

@@ -21,17 +21,17 @@ loader.inflector.inflect(
   "openai" => "OpenAI",
   "openai_validator" => "OpenAIValidator",
   "openai_response" => "OpenAIResponse",
-  "pdf" => "PDF",
-  "react_agent" => "ReActAgent",
-  "sql_query_agent" => "SQLQueryAgent"
+  "pdf" => "PDF"
 )
 loader.collapse("#{__dir__}/langchain/llm/response")
 loader.collapse("#{__dir__}/langchain/assistants")
 
 loader.collapse("#{__dir__}/langchain/tool/calculator")
 loader.collapse("#{__dir__}/langchain/tool/database")
+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/vectorsearch")
 loader.collapse("#{__dir__}/langchain/tool/weather")
 loader.collapse("#{__dir__}/langchain/tool/wikipedia")
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: langchainrb
 version: !ruby/object:Gem::Version
-  version: 0.10.3
+  version: 0.11.1
 platform: ruby
 authors:
 - Andrei Bondarev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-28 00:00:00.000000000 Z
+date: 2024-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.7
+        version: 0.0.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.7
+        version: 0.0.8
 - !ruby/object:Gem::Dependency
   name: json-schema
   requirement: !ruby/object:Gem::Requirement
@@ -693,13 +693,6 @@ files:
 - LICENSE.txt
 - README.md
 - lib/langchain.rb
-- lib/langchain/agent/agents.md
-- lib/langchain/agent/base.rb
-- lib/langchain/agent/react_agent.rb
-- lib/langchain/agent/react_agent/react_agent_prompt.yaml
-- lib/langchain/agent/sql_query_agent.rb
-- lib/langchain/agent/sql_query_agent/sql_query_agent_answer_prompt.yaml
-- lib/langchain/agent/sql_query_agent/sql_query_agent_sql_prompt.yaml
 - lib/langchain/assistants/assistant.rb
 - lib/langchain/assistants/message.rb
 - lib/langchain/assistants/thread.rb
@@ -777,10 +770,14 @@ files:
 - lib/langchain/tool/calculator/calculator.rb
 - lib/langchain/tool/database/database.json
 - lib/langchain/tool/database/database.rb
+- lib/langchain/tool/file_system/file_system.json
+- lib/langchain/tool/file_system/file_system.rb
 - lib/langchain/tool/google_search/google_search.json
 - lib/langchain/tool/google_search/google_search.rb
 - lib/langchain/tool/ruby_code_interpreter/ruby_code_interpreter.json
 - lib/langchain/tool/ruby_code_interpreter/ruby_code_interpreter.rb
+- lib/langchain/tool/vectorsearch/vectorsearch.json
+- lib/langchain/tool/vectorsearch/vectorsearch.rb
 - lib/langchain/tool/weather/weather.json
 - lib/langchain/tool/weather/weather.rb
 - lib/langchain/tool/wikipedia/wikipedia.json

data/lib/langchain/agent/agents.md

@@ -1,54 +0,0 @@
-
-### Agents 🤖
-Agents are semi-autonomous bots that can respond to user questions and use available to them Tools to provide informed replies. They break down problems into series of steps and define Actions (and Action Inputs) along the way that are executed and fed back to them as additional information. Once an Agent decides that it has the Final Answer it responds with it.
-
-#### ReAct Agent
-
-Add `gem "ruby-openai"`, `gem "eqn"`, and `gem "google_search_results"` to your Gemfile
-
-```ruby
-search_tool = Langchain::Tool::GoogleSearch.new(api_key: ENV["SERPAPI_API_KEY"])
-calculator = Langchain::Tool::Calculator.new
-
-openai = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"])
-
-agent = Langchain::Agent::ReActAgent.new(
-  llm: openai,
-  tools: [search_tool, calculator]
-)
-```
-```ruby
-agent.run(question: "How many full soccer fields would be needed to cover the distance between NYC and DC in a straight line?")
-#=> "Approximately 2,945 soccer fields would be needed to cover the distance between NYC and DC in a straight line."
-```
-
-#### SQL-Query Agent
-
-Add `gem "sequel"` to your Gemfile
-
-```ruby
-database = Langchain::Tool::Database.new(connection_string: "postgres://user:password@localhost:5432/db_name")
-
-agent = Langchain::Agent::SQLQueryAgent.new(llm: Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"]), db: database)
-```
-```ruby
-agent.run(question: "How many users have a name with length greater than 5 in the users table?")
-#=> "14 users have a name with length greater than 5 in the users table."
-```
-
-#### Demo
-![May-12-2023 13-09-13](https://github.com/andreibondarev/langchainrb/assets/541665/6bad4cd9-976c-420f-9cf9-b85bf84f7eaf)
-
-![May-12-2023 13-07-45](https://github.com/andreibondarev/langchainrb/assets/541665/9aacdcc7-4225-4ea0-ab96-7ee48826eb9b)
-
-#### Available Tools 🛠️
-
-| Name         | Description                                        | ENV Requirements                                              | Gem Requirements                          |
-| ------------ | :------------------------------------------------: | :-----------------------------------------------------------: | :---------------------------------------: |
-| "calculator" | Useful for getting the result of a math expression |                                                               | `gem "eqn", "~> 1.6.5"`                   |
-| "database"   | Useful for querying a SQL database |                                                               | `gem "sequel", "~> 5.68.0"`                   |
-| "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"` |
-| "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"`     |
-

data/lib/langchain/agent/base.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Langchain::Agent
-  # = Agents
-  #
-  # Agents are semi-autonomous bots that can respond to user questions and use available to them Tools to provide informed replies. They break down problems into series of steps and define Actions (and Action Inputs) along the way that are executed and fed back to them as additional information. Once an Agent decides that it has the Final Answer it responds with it.
-  #
-  # Available:
-  # - {Langchain::Agent::ReActAgent}
-  # - {Langchain::Agent::SQLQueryAgent}
-  #
-  # @abstract
-  class Base
-    def self.logger_options
-      {
-        color: :red
-      }
-    end
-  end
-end

data/lib/langchain/agent/react_agent/react_agent_prompt.yaml

@@ -1,26 +0,0 @@
-_type: prompt
-template: |
-  Today is {date} and you can use tools to get new information. Answer the following questions as best you can using the following tools:
-
-  {tools}
-
-  Use the following format:
-
-  Question: the input question you must answer
-  Thought: you should always think about what to do
-  Action: the action to take, should be one of {tool_names}
-  Action Input: the input to the action
-  Observation: the result of the action
-  ... (this Thought/Action/Action Input/Observation can repeat N times)
-  Thought: I now know the final answer
-  Final Answer: the final answer to the original input question
-
-  Begin!
-
-  Question: {question}
-  Thought:
-input_variables:
-  - date
-  - question
-  - tools
-  - tool_names

data/lib/langchain/agent/react_agent.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-module Langchain::Agent
-  # = ReAct Agent
-  #
-  #     llm = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"]) # or your choice of Langchain::LLM::Base implementation
-  #
-  #     agent = Langchain::Agent::ReActAgent.new(
-  #       llm: llm,
-  #       tools: [
-  #         Langchain::Tool::GoogleSearch.new(api_key: "YOUR_API_KEY"),
-  #         Langchain::Tool::Calculator.new,
-  #         Langchain::Tool::Wikipedia.new
-  #       ]
-  #     )
-  #
-  #     agent.run(question: "How many full soccer fields would be needed to cover the distance between NYC and DC in a straight line?")
-  #     #=> "Approximately 2,945 soccer fields would be needed to cover the distance between NYC and DC in a straight line."
-  class ReActAgent < Base
-    attr_reader :llm, :tools, :max_iterations
-
-    # Initializes the Agent
-    #
-    # @param llm [Object] The LLM client to use
-    # @param tools [Array<Tool>] The tools to use
-    # @param max_iterations [Integer] The maximum number of iterations to run
-    # @return [ReActAgent] The Agent::ReActAgent instance
-    def initialize(llm:, tools: [], max_iterations: 10)
-      warn "[DEPRECATION] `Langchain::Agent::ReActAgent` is deprecated. Please use `Langchain::Assistant` instead."
-
-      Langchain::Tool::Base.validate_tools!(tools: tools)
-
-      @tools = tools
-
-      @llm = llm
-      @max_iterations = max_iterations
-    end
-
-    # Validate tools when they're re-assigned
-    #
-    # @param value [Array<Tool>] The tools to use
-    # @return [Array<Tool>] The tools that will be used
-    def tools=(value)
-      Langchain::Tool::Base.validate_tools!(tools: value)
-      @tools = value
-    end
-
-    # Run the Agent!
-    #
-    # @param question [String] The question to ask
-    # @return [String] The answer to the question
-    def run(question:)
-      question = question.strip
-      prompt = create_prompt(
-        question: question,
-        tools: tools
-      )
-
-      final_response = nil
-      max_iterations.times do
-        Langchain.logger.info("Sending the prompt to the #{llm.class} LLM", for: self.class)
-
-        response = llm.complete(prompt: prompt, stop_sequences: ["Observation:"]).completion
-
-        # Append the response to the prompt
-        prompt += response
-
-        # Find the requested action in the "Action: search" format
-        action = response.match(/Action: (.*)/)&.send(:[], -1)
-
-        if action
-          # Find the input to the action in the "Action Input: [action_input]" format
-          action_input = response.match(/Action Input: "?(.*)"?/)&.send(:[], -1)
-
-          # Find the Tool and call `execute`` with action_input as the input
-          tool = tools.find { |tool| tool.name == action.strip }
-          Langchain.logger.info("Invoking \"#{tool.class}\" Tool with \"#{action_input}\"", for: self.class)
-
-          # Call `execute` with action_input as the input
-          result = tool.execute(input: action_input)
-
-          # Append the Observation to the prompt
-          prompt += if prompt.end_with?("Observation:")
-            " #{result}\nThought:"
-          else
-            "\nObservation: #{result}\nThought:"
-          end
-        elsif response.include?("Final Answer:")
-          # Return the final answer
-          final_response = response.split("Final Answer:")[-1]
-          break
-        end
-      end
-
-      final_response || raise(MaxIterationsReachedError.new(max_iterations))
-    end
-
-    private
-
-    # Create the initial prompt to pass to the LLM
-    # @param question [String] Question to ask
-    # @param tools [Array] Tools to use
-    # @return [String] Prompt
-    def create_prompt(question:, tools:)
-      tool_list = tools.map(&:name)
-
-      prompt_template.format(
-        date: Date.today.strftime("%B %d, %Y"),
-        question: question,
-        tool_names: "[#{tool_list.join(", ")}]",
-        tools: tools.map do |tool|
-          tool_name = tool.name
-          tool_description = tool.description
-          "#{tool_name}: #{tool_description}"
-        end.join("\n")
-      )
-    end
-
-    # Load the PromptTemplate from the YAML file
-    # @return [PromptTemplate] PromptTemplate instance
-    def prompt_template
-      @template ||= Langchain::Prompt.load_from_path(
-        file_path: Langchain.root.join("langchain/agent/react_agent/react_agent_prompt.yaml")
-      )
-    end
-
-    class MaxIterationsReachedError < Langchain::Errors::BaseError
-      def initialize(max_iterations)
-        super("Agent stopped after #{max_iterations} iterations")
-      end
-    end
-  end
-end

data/lib/langchain/agent/sql_query_agent/sql_query_agent_answer_prompt.yaml

@@ -1,11 +0,0 @@
-_type: prompt
-template: |
-  Given an input question and results of a SQL query, look at the results and return the answer. Use the following format:
-  Question: {question}
-  The SQL query: {sql_query}
-  Result of the SQLQuery: {results}
-  Final answer: Final answer here
-input_variables:
-  - question
-  - sql_query
-  - results

data/lib/langchain/agent/sql_query_agent/sql_query_agent_sql_prompt.yaml

@@ -1,21 +0,0 @@
-_type: prompt
-template: |
-  Given an input question, create a syntactically correct {dialect} query to run, then return the query in valid SQL.
-  Never query for all the columns from a specific table, only ask for a the few relevant columns given the question.
-  Pay attention to use only the column names that you can see in the schema description.
-  Be careful to not query for columns that do not exist.
-  Pay attention to which column is in which table.
-  Also, qualify column names with the table name when needed.
-
-  Only use the tables listed below.
-  {schema}
-
-  Use the following format:
-
-  Question: {question}
-
-  SQLQuery:
-input_variables:
-  - dialect
-  - schema
-  - question

data/lib/langchain/agent/sql_query_agent.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Langchain::Agent
-  class SQLQueryAgent < Base
-    attr_reader :llm, :db, :schema
-
-    #
-    # Initializes the Agent
-    #
-    # @param llm [Object] The LLM client to use
-    # @param db [Object] Database connection info
-    #
-    def initialize(llm:, db:)
-      warn "[DEPRECATION] `Langchain::Agent::ReActAgent` is deprecated. Please use `Langchain::Assistant` instead."
-
-      @llm = llm
-      @db = db
-      @schema = @db.dump_schema
-    end
-
-    #
-    # Ask a question and get an answer
-    #
-    # @param question [String] Question to ask the LLM/Database
-    # @return [String] Answer to the question
-    #
-    def run(question:)
-      prompt = create_prompt_for_sql(question: question)
-
-      # Get the SQL string to execute
-      Langchain.logger.info("Passing the inital prompt to the #{llm.class} LLM", for: self.class)
-      sql_string = llm.complete(prompt: prompt).completion
-
-      # Execute the SQL string and collect the results
-      Langchain.logger.info("Passing the SQL to the Database: #{sql_string}", for: self.class)
-      results = db.execute(input: sql_string)
-
-      # Pass the results and get the LLM to synthesize the answer to the question
-      Langchain.logger.info("Passing the synthesize prompt to the #{llm.class} LLM with results: #{results}", for: self.class)
-      prompt2 = create_prompt_for_answer(question: question, sql_query: sql_string, results: results)
-      llm.complete(prompt: prompt2).completion
-    end
-
-    private
-
-    # Create the initial prompt to pass to the LLM
-    # @param question[String] Question to ask
-    # @return [String] Prompt
-    def create_prompt_for_sql(question:)
-      prompt_template_sql.format(
-        dialect: "standard SQL",
-        schema: schema,
-        question: question
-      )
-    end
-
-    # Load the PromptTemplate from the YAML file
-    # @return [PromptTemplate] PromptTemplate instance
-    def prompt_template_sql
-      Langchain::Prompt.load_from_path(
-        file_path: Langchain.root.join("langchain/agent/sql_query_agent/sql_query_agent_sql_prompt.yaml")
-      )
-    end
-
-    # Create the second prompt to pass to the LLM
-    # @param question [String] Question to ask
-    # @return [String] Prompt
-    def create_prompt_for_answer(question:, sql_query:, results:)
-      prompt_template_answer.format(
-        question: question,
-        sql_query: sql_query,
-        results: results
-      )
-    end
-
-    # Load the PromptTemplate from the YAML file
-    # @return [PromptTemplate] PromptTemplate instance
-    def prompt_template_answer
-      Langchain::Prompt.load_from_path(
-        file_path: Langchain.root.join("langchain/agent/sql_query_agent/sql_query_agent_answer_prompt.yaml")
-      )
-    end
-  end
-end