langchainrb 0.6.17 → 0.6.19

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Langchain::LLM
+  class AnthropicResponse < BaseResponse
+    def model
+      raw_response.dig("model")
+    end
+
+    def completion
+      completions.first
+    end
+
+    def completions
+      [raw_response.dig("completion")]
+    end
+
+    def stop_reason
+      raw_response.dig("stop_reason")
+    end
+
+    def stop
+      raw_response.dig("stop")
+    end
+
+    def log_id
+      raw_response.dig("log_id")
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Langchain
+  module LLM
+    class BaseResponse
+      attr_reader :raw_response, :model
+
+      def initialize(raw_response, model: nil)
+        @raw_response = raw_response
+        @model = model
+      end
+
+      # Returns the completion text
+      #
+      # @return [String]
+      #
+      def completion
+        raise NotImplementedError
+      end
+
+      # Returns the chat completion text
+      #
+      # @return [String]
+      #
+      def chat_completion
+        raise NotImplementedError
+      end
+
+      # Return the first embedding
+      #
+      # @return [Array<Float>]
+      def embedding
+        raise NotImplementedError
+      end
+
+      # Return the completion candidates
+      #
+      # @return [Array]
+      def completions
+        raise NotImplementedError
+      end
+
+      # Return the chat completion candidates
+      #
+      # @return [Array]
+      def chat_completions
+        raise NotImplementedError
+      end
+
+      # Return the embeddings
+      #
+      # @return [Array<Array>]
+      def embeddings
+        raise NotImplementedError
+      end
+
+      # Number of tokens utilized in the prompt
+      #
+      # @return [Integer]
+      def prompt_tokens
+        raise NotImplementedError
+      end
+
+      # Number of tokens utilized to generate the completion
+      #
+      # @return [Integer]
+      def completion_tokens
+        raise NotImplementedError
+      end
+
+      # Total number of tokens utilized
+      #
+      # @return [Integer]
+      def total_tokens
+        raise NotImplementedError
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Langchain::LLM
+  class CohereResponse < BaseResponse
+    def embedding
+      embeddings.first
+    end
+
+    def embeddings
+      raw_response.dig("embeddings")
+    end
+
+    def completions
+      raw_response.dig("generations")
+    end
+
+    def completion
+      completions&.dig(0, "text")
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Langchain::LLM
+  class GooglePalmResponse < BaseResponse
+    attr_reader :prompt_tokens
+
+    def initialize(raw_response, model: nil, prompt_tokens: nil)
+      @prompt_tokens = prompt_tokens
+      super(raw_response, model: model)
+    end
+
+    def completion
+      completions&.dig(0, "output")
+    end
+
+    def embedding
+      embeddings.first
+    end
+
+    def completions
+      raw_response.dig("candidates")
+    end
+
+    def chat_completion
+      chat_completions&.dig(0, "content")
+    end
+
+    def chat_completions
+      raw_response.dig("candidates")
+    end
+
+    def embeddings
+      [raw_response.dig("embedding", "value")]
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Langchain::LLM
+  class HuggingFaceResponse < BaseResponse
+    def embeddings
+      [raw_response]
+    end
+
+    def embedding
+      embeddings.first
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Langchain::LLM
+  class OllamaResponse < BaseResponse
+    def initialize(raw_response, model: nil, prompt_tokens: nil)
+      @prompt_tokens = prompt_tokens
+      super(raw_response, model: model)
+    end
+
+    def completion
+      raw_response.first
+    end
+
+    def completions
+      raw_response.is_a?(String) ? [raw_response] : []
+    end
+
+    def embedding
+      embeddings.first
+    end
+
+    def embeddings
+      [raw_response&.dig("embedding")]
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Langchain::LLM
+  class OpenAIResponse < BaseResponse
+    def model
+      raw_response["model"]
+    end
+
+    def created_at
+      if raw_response.dig("created")
+        Time.at(raw_response.dig("created"))
+      end
+    end
+
+    def completion
+      completions&.dig(0, "message", "content")
+    end
+
+    def chat_completion
+      completion
+    end
+
+    def embedding
+      embeddings&.first
+    end
+
+    def completions
+      raw_response.dig("choices")
+    end
+
+    def chat_completions
+      raw_response.dig("choices")
+    end
+
+    def embeddings
+      raw_response.dig("data")&.map { |datum| datum.dig("embedding") }
+    end
+
+    def prompt_tokens
+      raw_response.dig("usage", "prompt_tokens")
+    end
+
+    def completion_tokens
+      raw_response.dig("usage", "completion_tokens")
+    end
+
+    def total_tokens
+      raw_response.dig("usage", "total_tokens")
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Langchain::LLM
+  class ReplicateResponse < BaseResponse
+    def completions
+      # Response comes back as an array of strings, e.g.: ["Hi", "how ", "are ", "you?"]
+      # The first array element is missing a space at the end, so we add it manually
+      raw_response.output[0] += " "
+      [raw_response.output.join]
+    end
+
+    def completion
+      completions.first
+    end
+
+    def created_at
+      Time.parse(raw_response.created_at)
+    end
+
+    def embedding
+      embeddings.first
+    end
+
+    def embeddings
+      [raw_response.output]
+    end
+  end
+end

data/lib/langchain/vectorsearch/base.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "forwardable"
-
 module Langchain::Vectorsearch
   # = Vector Databases
   # A vector database a type of database that stores data as high-dimensional vectors, which are mathematical representations of features or attributes. Each vector has a certain number of dimensions, which can range from tens to thousands, depending on the complexity and granularity of the data.
@@ -9,11 +7,13 @@ module Langchain::Vectorsearch
   # == Available vector databases
   #
   # - {Langchain::Vectorsearch::Chroma}
+  # - {Langchain::Vectorsearch::Elasticsearch}
+  # - {Langchain::Vectorsearch::Hnswlib}
   # - {Langchain::Vectorsearch::Milvus}
+  # - {Langchain::Vectorsearch::Pgvector}
   # - {Langchain::Vectorsearch::Pinecone}
   # - {Langchain::Vectorsearch::Qdrant}
   # - {Langchain::Vectorsearch::Weaviate}
-  # - {Langchain::Vectorsearch::Pgvector}
   #
   # == Usage
   #
@@ -150,9 +150,6 @@ module Langchain::Vectorsearch
       raise NotImplementedError, "#{self.class.name} does not support asking questions"
     end
 
-    def_delegators :llm,
-      :default_dimension
-
     # HyDE-style prompt
     #
     # @param [String] User's question
@@ -184,7 +181,7 @@ module Langchain::Vectorsearch
         .flatten
         .map do |path|
           data = Langchain::Loader.new(path)&.load&.chunks
-          data.map { |chunk| chunk[:text] }
+          data.map { |chunk| chunk.text }
         end
 
       texts.flatten!

data/lib/langchain/vectorsearch/chroma.rb

@@ -5,7 +5,8 @@ module Langchain::Vectorsearch
     #
     # Wrapper around Chroma DB
     #
-    # Gem requirements: gem "chroma-db", "~> 0.6.0"
+    # Gem requirements:
+    #     gem "chroma-db", "~> 0.6.0"
     #
     # Usage:
     # chroma = Langchain::Vectorsearch::Chroma.new(url:, index_name:, llm:, llm_api_key:, api_key: nil)
@@ -28,15 +29,16 @@ module Langchain::Vectorsearch
     end
 
     # Add a list of texts to the index
-    # @param texts [Array] The list of texts to add
+    # @param texts [Array<String>] The list of texts to add
+    # @param ids [Array<String>] The list of ids to use for the texts (optional)
+    # @param metadatas [Array<Hash>] The list of metadata to use for the texts (optional)
     # @return [Hash] The response from the server
-    def add_texts(texts:, ids: [])
+    def add_texts(texts:, ids: [], metadatas: [])
       embeddings = Array(texts).map.with_index do |text, i|
         ::Chroma::Resources::Embedding.new(
           id: ids[i] ? ids[i].to_s : SecureRandom.uuid,
-          embedding: llm.embed(text: text),
-          # TODO: Add support for passing metadata
-          metadata: {}, # metadatas[index],
+          embedding: llm.embed(text: text).embedding,
+          metadata: metadatas[i] || {},
           document: text # Do we actually need to store the whole original document?
         )
       end
@@ -45,13 +47,12 @@ module Langchain::Vectorsearch
       collection.add(embeddings)
     end
 
-    def update_texts(texts:, ids:)
+    def update_texts(texts:, ids:, metadatas: [])
       embeddings = Array(texts).map.with_index do |text, i|
         ::Chroma::Resources::Embedding.new(
           id: ids[i].to_s,
-          embedding: llm.embed(text: text),
-          # TODO: Add support for passing metadata
-          metadata: [], # metadatas[index],
+          embedding: llm.embed(text: text).embedding,
+          metadata: metadatas[i] || {},
           document: text # Do we actually need to store the whole original document?
         )
       end
@@ -85,7 +86,7 @@ module Langchain::Vectorsearch
       query:,
       k: 4
     )
-      embedding = llm.embed(text: query)
+      embedding = llm.embed(text: query).embedding
 
       similarity_search_by_vector(
         embedding: embedding,
@@ -94,7 +95,7 @@ module Langchain::Vectorsearch
     end
 
     # Search for similar texts by embedding
-    # @param embedding [Array] The embedding to search for
+    # @param embedding [Array<Float>] The embedding to search for
     # @param k [Integer] The number of results to return
     # @return [Chroma::Resources::Embedding] The response from the server
     def similarity_search_by_vector(

data/lib/langchain/vectorsearch/elasticsearch.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Langchain::Vectorsearch
+  class Elasticsearch < Base
+    #
+    # Wrapper around Elasticsearch vector search capabilities.
+    #
+    # Setting up Elasticsearch:
+    # 1. Get Elasticsearch up and running with Docker: https://www.elastic.co/guide/en/elasticsearch/reference/current/docker.html
+    # 2. Copy the HTTP CA certificate SHA-256 fingerprint and set the ELASTICSEARCH_CA_FINGERPRINT environment variable
+    # 3. Set the ELASTICSEARCH_URL environment variable
+    #
+    # Gem requirements:
+    #     gem "elasticsearch", "~> 8.0.0"
+    #
+    # Usage:
+    #     llm = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"])
+    #     es = Langchain::Vectorsearch::Elasticsearch.new(
+    #       url: ENV["ELASTICSEARCH_URL"],
+    #       index_name: "docs",
+    #       llm: llm,
+    #       es_options: {
+    #         transport_options: {ssl: {verify: false}},
+    #         ca_fingerprint: ENV["ELASTICSEARCH_CA_FINGERPRINT"]
+    #       }
+    #     )
+    #
+    #     es.create_default_schema
+    #     es.add_texts(texts: ["..."])
+    #     es.similarity_search(text: "...")
+    #
+    attr_accessor :es_client, :index_name, :options
+
+    def initialize(url:, index_name:, llm:, api_key: nil, es_options: {})
+      require "elasticsearch"
+
+      @options = {
+        url: url,
+        request_timeout: 20,
+        log: false
+      }.merge(es_options)
+
+      @es_client = ::Elasticsearch::Client.new(**options)
+      @index_name = index_name
+
+      super(llm: llm)
+    end
+
+    def add_texts(texts: [])
+      body = texts.map do |text|
+        [
+          {index: {_index: index_name}},
+          {input: text, input_vector: llm.embed(text: text).embedding}
+        ]
+      end.flatten
+
+      es_client.bulk(body: body)
+    end
+
+    def update_texts(texts: [], ids: [])
+      body = texts.map.with_index do |text, i|
+        [
+          {index: {_index: index_name, _id: ids[i]}},
+          {input: text, input_vector: llm.embed(text: text).embedding}
+        ]
+      end.flatten
+
+      es_client.bulk(body: body)
+    end
+
+    def create_default_schema
+      es_client.indices.create(
+        index: index_name,
+        body: default_schema
+      )
+    end
+
+    def delete_default_schema
+      es_client.indices.delete(
+        index: index_name
+      )
+    end
+
+    def default_vector_settings
+      {type: "dense_vector", dims: llm.default_dimension}
+    end
+
+    def vector_settings
+      options[:vector_settings] || default_vector_settings
+    end
+
+    def default_schema
+      {
+        mappings: {
+          properties: {
+            input: {
+              type: "text"
+            },
+            input_vector: vector_settings
+          }
+        }
+      }
+    end
+
+    def default_query(query_vector)
+      {
+        script_score: {
+          query: {match_all: {}},
+          script: {
+            source: "cosineSimilarity(params.query_vector, 'input_vector') + 1.0",
+            params: {
+              query_vector: query_vector
+            }
+          }
+        }
+      }
+    end
+
+    # TODO: Implement this
+    # def ask()
+    # end
+
+    def similarity_search(text: "", k: 10, query: {})
+      if text.empty? && query.empty?
+        raise "Either text or query should pass as an argument"
+      end
+
+      if query.empty?
+        query_vector = llm.embed(text: text).embedding
+
+        query = default_query(query_vector)
+      end
+
+      es_client.search(body: {query: query, size: k}).body
+    end
+
+    def similarity_search_by_vector(embedding: [], k: 10, query: {})
+      if embedding.empty? && query.empty?
+        raise "Either embedding or query should pass as an argument"
+      end
+
+      query = default_query(embedding) if query.empty?
+
+      es_client.search(body: {query: query, size: k}).body
+    end
+  end
+end

data/lib/langchain/vectorsearch/hnswlib.rb

@@ -35,15 +35,15 @@ module Langchain::Vectorsearch
     #
     # Add a list of texts and corresponding IDs to the index
     #
-    # @param texts [Array] The list of texts to add
-    # @param ids [Array] The list of corresponding IDs (integers) to the texts
+    # @param texts [Array<String>] The list of texts to add
+    # @param ids [Array<Integer>] The list of corresponding IDs (integers) to the texts
     # @return [Boolean] The response from the HNSW library
     #
     def add_texts(texts:, ids:)
       resize_index(texts.size)
 
       Array(texts).each_with_index do |text, i|
-        embedding = llm.embed(text: text)
+        embedding = llm.embed(text: text).embedding
 
         client.add_point(embedding, ids[i])
       end
@@ -64,7 +64,7 @@ module Langchain::Vectorsearch
       query:,
       k: 4
     )
-      embedding = llm.embed(text: query)
+      embedding = llm.embed(text: query).embedding
 
       similarity_search_by_vector(
         embedding: embedding,
@@ -75,7 +75,7 @@ module Langchain::Vectorsearch
     #
     # Search for the K nearest neighbors of a given vector
     #
-    # @param embedding [Array] The embedding to search for
+    # @param embedding [Array<Float>] The embedding to search for
     # @param k [Integer] The number of results to return
     # @return [Array] Results in the format `[[id1, distance3], [id2, distance2]]`
     #

data/lib/langchain/vectorsearch/milvus.rb

@@ -5,7 +5,8 @@ module Langchain::Vectorsearch
     #
     # Wrapper around Milvus REST APIs.
     #
-    # Gem requirements: gem "milvus", "~> 0.9.2"
+    # Gem requirements:
+    #     gem "milvus", "~> 0.9.2"
     #
     # Usage:
     # milvus = Langchain::Vectorsearch::Milvus.new(url:, index_name:, llm:, api_key:)
@@ -32,7 +33,7 @@ module Langchain::Vectorsearch
           }, {
             field_name: "vectors",
             type: ::Milvus::DATA_TYPES["float_vector"],
-            field: Array(texts).map { |text| llm.embed(text: text) }
+            field: Array(texts).map { |text| llm.embed(text: text).embedding }
           }
         ]
       )
@@ -70,7 +71,7 @@ module Langchain::Vectorsearch
             type_params: [
               {
                 key: "dim",
-                value: default_dimension.to_s
+                value: llm.default_dimension.to_s
               }
             ]
           }
@@ -111,7 +112,7 @@ module Langchain::Vectorsearch
     end
 
     def similarity_search(query:, k: 4)
-      embedding = llm.embed(text: query)
+      embedding = llm.embed(text: query).embedding
 
       similarity_search_by_vector(
         embedding: embedding,

data/lib/langchain/vectorsearch/pgvector.rb

@@ -5,10 +5,12 @@ module Langchain::Vectorsearch
     #
     # The PostgreSQL vector search adapter
     #
-    # Gem requirements: gem "pgvector", "~> 0.2"
+    # Gem requirements:
+    #     gem "sequel", "~> 5.68.0"
+    #     gem "pgvector", "~> 0.2"
     #
     # Usage:
-    # pgvector = Langchain::Vectorsearch::Pgvector.new(url:, index_name:, llm:, namespace: nil)
+    #     pgvector = Langchain::Vectorsearch::Pgvector.new(url:, index_name:, llm:, namespace: nil)
     #
 
     # The operators supported by the PostgreSQL vector search adapter
@@ -52,7 +54,7 @@ module Langchain::Vectorsearch
     # the added or updated texts.
     def upsert_texts(texts:, ids:)
       data = texts.zip(ids).flat_map do |(text, id)|
-        {id: id, content: text, vectors: llm.embed(text: text).to_s, namespace: namespace}
+        {id: id, content: text, vectors: llm.embed(text: text).embedding.to_s, namespace: namespace}
       end
       # @db[table_name.to_sym].multi_insert(data, return: :primary_key)
       @db[table_name.to_sym]
@@ -70,7 +72,7 @@ module Langchain::Vectorsearch
     def add_texts(texts:, ids: nil)
       if ids.nil? || ids.empty?
         data = texts.map do |text|
-          {content: text, vectors: llm.embed(text: text).to_s, namespace: namespace}
+          {content: text, vectors: llm.embed(text: text).embedding.to_s, namespace: namespace}
         end
 
         @db[table_name.to_sym].multi_insert(data, return: :primary_key)
@@ -91,7 +93,7 @@ module Langchain::Vectorsearch
     def create_default_schema
       db.run "CREATE EXTENSION IF NOT EXISTS vector"
       namespace_column = @namespace_column
-      vector_dimension = default_dimension
+      vector_dimension = llm.default_dimension
       db.create_table? table_name.to_sym do
         primary_key :id
         text :content
@@ -110,7 +112,7 @@ module Langchain::Vectorsearch
     # @param k [Integer] The number of top results to return
     # @return [Array<Hash>] The results of the search
     def similarity_search(query:, k: 4)
-      embedding = llm.embed(text: query)
+      embedding = llm.embed(text: query).embedding
 
       similarity_search_by_vector(
         embedding: embedding,
@@ -150,3 +152,7 @@ module Langchain::Vectorsearch
     end
   end
 end
+
+# Rails connection when configuring vectorsearch
+# Update READMEs
+# Rails migration to create a migration