langchainrb 0.6.3 → 0.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73f980d6a7dd67d0112038a8266a05f8b5697e05c98e61a94598d38406de7c8b
-  data.tar.gz: 8abc93ad6da8ad05d76ac35eff9aaab963c33549acb94bda4dd83daddeb71f4d
+  metadata.gz: 3404535e036c3efe68fd12706d2ebb269caed87b562fc38434122b1be01a356d
+  data.tar.gz: e3be77b32cf754235e8895fb1af60edca54cb5acb84278bfa2e39b6ed7c2abbe
 SHA512:
-  metadata.gz: 7b5450e51ee732a1e2414e3db5f8a46d113d0b537b561f95556756e2854c9bb9175c898388acc2bb8672b2479e647625d3166580b7b1b25eb6cdc86ff6d42aee
-  data.tar.gz: b5843004533f952782946e6a753aa5306c6ad4a5f97887416f8f10f4192ca1f88d00d30624cd62581022314649e5d291d9c1ab46f2bab31f9455860fc533c83d
+  metadata.gz: b3fae04c73176c758c2d2d32c3ac538f3e094eb10f378b9a8befbbdcc62b60e55941a1bfefcb61eac7daca43ef91d0e57306dbc26bd59afbdad6ab4efff2ba89
+  data.tar.gz: 626bb4a226112ee6fe709077a6d49ba91c0483fee657848153e9cff61693183709aede5844237c24cc02c561f59be82ea1fd296fe1c3f4ee4d971494ee4dcd75

data/.env.example

@@ -1,10 +1,13 @@
 AI21_API_KEY=
 CHROMA_URL=
 COHERE_API_KEY=
+GOOGLE_PALM_API_KEY=
 HUGGING_FACE_API_KEY=
+LLAMACPP_MODEL_PATH=
+LLAMACPP_N_THREADS=
+LLAMACPP_N_GPU_LAYERS=
 MILVUS_URL=
 OPENAI_API_KEY=
-GOOGLE_PALM_API_KEY=
 OPEN_WEATHER_API_KEY=
 PINECONE_API_KEY=
 PINECONE_ENVIRONMENT=

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.6.4] - 2023-07-01
+- Fix `Langchain::Vectorsearch::Qdrant#add_texts()`
+- Introduce `ConversationMemory`
+- Allow loading multiple files from a directory
+- Add `get_default_schema()`, `create_default_schema()`, `destroy_default_schema()` missing methods to `Langchain::Vectorsearch::*` classes
+
 ## [0.6.3] - 2023-06-25
 - Add #destroy_default_schema() to Langchain::Vectorsearch::* classes
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    langchainrb (0.6.3)
+    langchainrb (0.6.5)
       baran (~> 0.1.6)
       colorize (~> 0.8.1)
       json-schema (~> 4.0.0)
@@ -153,6 +153,7 @@ GEM
       addressable (>= 2.8)
     language_server-protocol (3.17.0.3)
     lint_roller (1.0.0)
+    llama_cpp (0.3.0)
     loofah (2.21.1)
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
@@ -327,6 +328,7 @@ DEPENDENCIES
   hnswlib (~> 0.8.1)
   hugging-face (~> 0.3.4)
   langchainrb!
+  llama_cpp
   milvus (~> 0.9.0)
   nokogiri (~> 1.13)
   open-weather-ruby-client (~> 0.3.0)

data/README.md

@@ -274,6 +274,106 @@ prompt = Langchain::Prompt.load_from_path(file_path: "spec/fixtures/prompt/promp
 prompt.input_variables #=> ["adjective", "content"]
 ```
 
+### Using Output Parsers 
+
+Parse LLM text responses into structured output, such as JSON.
+
+#### Structured Output Parser
+
+You can use the `StructuredOutputParser` to generate a prompt that instructs the LLM to provide a JSON response adhering to a specific JSON schema:
+
+```ruby
+json_schema = {
+  type: "object",
+  properties: {
+    name: {
+      type: "string",
+      description: "Persons name"
+    },
+    age: {
+      type: "number",
+      description: "Persons age"
+    },
+    interests: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          interest: {
+            type: "string",
+            description: "A topic of interest"
+          },
+          levelOfInterest: {
+            type: "number",
+            description: "A value between 0 and 100 of how interested the person is in this interest"
+          }
+        },
+        required: ["interest", "levelOfInterest"],
+        additionalProperties: false
+      },
+      minItems: 1,
+      maxItems: 3,
+      description: "A list of the person's interests"
+    }
+  },
+  required: ["name", "age", "interests"],
+  additionalProperties: false
+}
+parser = Langchain::OutputParsers::StructuredOutputParser.from_json_schema(json_schema)
+prompt = Langchain::Prompt::PromptTemplate.new(template: "Generate details of a fictional character.\n{format_instructions}\nCharacter description: {description}", input_variables: ["description", "format_instructions"])
+prompt_text = prompt.format(description: "Korean chemistry student", format_instructions: parser.get_format_instructions)
+# Generate details of a fictional character.
+# You must format your output as a JSON value that adheres to a given "JSON Schema" instance.
+# ...
+```
+
+Then parse the llm response:
+
+```ruby
+llm = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"])
+llm_response = llm.chat(prompt: prompt_text)
+parser.parse(llm_response)
+# {
+#   "name" => "Kim Ji-hyun",
+#   "age" => 22,
+#   "interests" => [
+#     {
+#       "interest" => "Organic Chemistry",
+#       "levelOfInterest" => 85
+#     },
+#     ...
+#   ]
+# }
+```
+
+If the parser fails to parse the LLM response, you can use the `OutputFixingParser`. It sends an error message, prior output, and the original prompt text to the LLM, asking for a "fixed" response:
+
+```ruby
+begin
+  parser.parse(llm_response)
+rescue Langchain::OutputParsers::OutputParserException => e
+  fix_parser = Langchain::OutputParsers::OutputFixingParser.from_llm(
+    llm: llm,
+    parser: parser
+  )
+  fix_parser.parse(llm_response)
+end
+```
+
+Alternatively, if you don't need to handle the `OutputParserException`, you can simplify the code:
+
+```ruby
+# we already have the `OutputFixingParser`:
+# parser = Langchain::OutputParsers::StructuredOutputParser.from_json_schema(json_schema)
+fix_parser = Langchain::OutputParsers::OutputFixingParser.from_llm(
+  llm: llm,
+  parser: parser
+)
+fix_parser.parse(llm_response)
+```
+
+See [here](https://github.com/andreibondarev/langchainrb/tree/main/examples/create_and_manage_prompt_templates_using_structured_output_parser.rb) for a concrete example
+
 ### Using 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.
 

data/examples/conversation_with_openai.rb

@@ -0,0 +1,52 @@
+require "langchain"
+require "reline"
+
+# gem install reline
+# or add `gem "reline"` to your Gemfile
+
+openai = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"])
+
+chat = Langchain::Conversation.new(llm: openai)
+chat.set_context("You are a chatbot from the future")
+
+DONE = %w[done end eof exit].freeze
+
+puts "Welcome to the chatbot from the future!"
+
+def prompt_for_message
+  puts "(multiline input; type 'end' on its own line when done. or exit to exit)"
+
+  user_message = Reline.readmultiline("Question: ", true) do |multiline_input|
+    last = multiline_input.split.last
+    DONE.include?(last)
+  end
+
+  return :noop unless user_message
+
+  lines = user_message.split("\n")
+  if lines.size > 1 && DONE.include?(lines.last)
+    # remove the "done" from the message
+    user_message = lines[0..-2].join("\n")
+  end
+
+  return :exit if DONE.include?(user_message.downcase)
+
+  user_message
+end
+
+begin
+  loop do
+    user_message = prompt_for_message
+
+    case user_message
+    when :noop
+      next
+    when :exit
+      break
+    end
+
+    puts chat.message(user_message)
+  end
+rescue Interrupt
+  exit 0
+end

data/examples/create_and_manage_prompt_templates_using_structured_output_parser.rb

@@ -58,6 +58,11 @@ prompt.format(description: "Korean chemistry student", format_instructions: pars
 
 # Character description: Korean chemistry student
 
+llm = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"])
+# llm_response = llm.chat(
+#   prompt: prompt.format(description: "Korean chemistry student", format_instructions: parser.get_format_instructions)
+# )
+
 # LLM example response:
 llm_example_response = <<~RESPONSE
   Here is your character:
@@ -83,7 +88,14 @@ llm_example_response = <<~RESPONSE
   ```
 RESPONSE
 
-parser.parse(llm_example_response)
+fix_parser = Langchain::OutputParsers::OutputFixingParser.from_llm(
+  llm: llm,
+  parser: parser
+)
+# The OutputFixingParser wraps the StructuredOutputParser such that if initial
+# LLM response does not conform to the schema, will call out the LLM to fix
+# the error
+fix_parser.parse(llm_example_response)
 # {
 #   "name" => "Kim Ji-hyun",
 #   "age" => 22,

data/examples/llama_cpp.rb

@@ -0,0 +1,24 @@
+require "langchain"
+
+llm = Langchain::LLM::LlamaCpp.new(
+  model_path: ENV["LLAMACPP_MODEL_PATH"],
+  n_gpu_layers: Integer(ENV["LLAMACPP_N_GPU_LAYERS"]),
+  n_threads: Integer(ENV["LLAMACPP_N_THREADS"])
+)
+
+instructions = [
+  "Tell me about the creator of Ruby",
+  "Write a story about a pony who goes to the store to buy some apples."
+]
+
+template = Langchain::Prompt::PromptTemplate.new(
+  template: "{instruction}\n\n### Response:",
+  input_variables: %w[instruction]
+)
+
+instructions.each do |instruction|
+  puts "USER: #{instruction}"
+  prompt = template.format(instruction: instruction)
+  response = llm.complete prompt: prompt, n_predict: 1024
+  puts "ASSISTANT: #{response}"
+end

data/lib/langchain/conversation.rb

@@ -17,10 +17,7 @@ module Langchain
   #     end
   #
   class Conversation
-    attr_reader :context, :examples, :messages
-
-    # The least number of tokens we want to be under the limit by
-    TOKEN_LEEWAY = 20
+    attr_reader :options
 
     # Intialize Conversation with a LLM
     #
@@ -31,7 +28,11 @@ module Langchain
       @llm = llm
       @context = nil
       @examples = []
-      @messages = options.delete(:messages) || []
+      @memory = ConversationMemory.new(
+        llm: llm,
+        messages: options.delete(:messages) || [],
+        strategy: options.delete(:memory_strategy)
+      )
       @options = options
       @block = block
     end
@@ -39,59 +40,50 @@ module Langchain
     # Set the context of the conversation. Usually used to set the model's persona.
     # @param message [String] The context of the conversation
     def set_context(message)
-      @context = message
+      @memory.set_context message
     end
 
     # Add examples to the conversation. Used to give the model a sense of the conversation.
     # @param examples [Array<Hash>] The examples to add to the conversation
     def add_examples(examples)
-      @examples.concat examples
+      @memory.add_examples examples
     end
 
     # Message the model with a prompt and return the response.
     # @param message [String] The prompt to message the model with
     # @return [String] The response from the model
     def message(message)
-      append_user_message(message)
+      @memory.append_user_message(message)
       response = llm_response(message)
-      append_ai_message(response)
+      @memory.append_ai_message(response)
       response
     end
 
-    private
-
-    def llm_response(prompt)
-      @llm.chat(messages: @messages, context: @context, examples: @examples, **@options, &@block)
-    rescue Langchain::Utils::TokenLength::TokenLimitExceeded => exception
-      raise exception if @messages.size == 1
-
-      reduce_messages(exception.token_overflow)
-      retry
+    # Messages from conversation memory
+    # @return [Array<Hash>] The messages from the conversation memory
+    def messages
+      @memory.messages
     end
 
-    def reduce_messages(token_overflow)
-      @messages = @messages.drop_while do |message|
-        proceed = token_overflow > -TOKEN_LEEWAY
-        token_overflow -= token_length(message.to_json, model_name, llm: @llm)
-
-        proceed
-      end
+    # Context from conversation memory
+    # @return [String] Context from conversation memory
+    def context
+      @memory.context
     end
 
-    def append_ai_message(message)
-      @messages << {role: "ai", content: message}
+    # Examples from conversation memory
+    # @return [Array<Hash>] Examples from the conversation memory
+    def examples
+      @memory.examples
     end
 
-    def append_user_message(message)
-      @messages << {role: "user", content: message}
-    end
-
-    def model_name
-      @options[:model] || @llm.class::DEFAULTS[:chat_completion_model_name]
-    end
+    private
 
-    def token_length(content, model_name, options)
-      @llm.class::LENGTH_VALIDATOR.token_length(content, model_name, options)
+    def llm_response(prompt)
+      @llm.chat(messages: @memory.messages, context: @memory.context, examples: @memory.examples, **@options, &@block)
+    rescue Langchain::Utils::TokenLength::TokenLimitExceeded => exception
+      @memory.reduce_messages(exception)
+      retry
     end
   end
 end

data/lib/langchain/conversation_memory.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Langchain
+  class ConversationMemory
+    attr_reader :examples, :messages
+
+    # The least number of tokens we want to be under the limit by
+    TOKEN_LEEWAY = 20
+
+    def initialize(llm:, messages: [], **options)
+      @llm = llm
+      @context = nil
+      @summary = nil
+      @examples = []
+      @messages = messages
+      @strategy = options.delete(:strategy) || :truncate
+      @options = options
+    end
+
+    def set_context(message)
+      @context = message
+    end
+
+    def add_examples(examples)
+      @examples.concat examples
+    end
+
+    def append_ai_message(message)
+      @messages << {role: "ai", content: message}
+    end
+
+    def append_user_message(message)
+      @messages << {role: "user", content: message}
+    end
+
+    def reduce_messages(exception)
+      case @strategy
+      when :truncate
+        truncate_messages(exception)
+      when :summarize
+        summarize_messages
+      else
+        raise "Unknown strategy: #{@options[:strategy]}"
+      end
+    end
+
+    def context
+      return if @context.nil? && @summary.nil?
+
+      [@context, @summary].compact.join("\n")
+    end
+
+    private
+
+    def truncate_messages(exception)
+      raise exception if @messages.size == 1
+
+      token_overflow = exception.token_overflow
+
+      @messages = @messages.drop_while do |message|
+        proceed = token_overflow > -TOKEN_LEEWAY
+        token_overflow -= token_length(message.to_json, model_name, llm: @llm)
+
+        proceed
+      end
+    end
+
+    def summarize_messages
+      history = [@summary, @messages.to_json].compact.join("\n")
+      partitions = [history[0, history.size / 2], history[history.size / 2, history.size]]
+
+      @summary = partitions.map { |messages| @llm.summarize(text: messages.to_json) }.join("\n")
+
+      @messages = [@messages.last]
+    end
+
+    def partition_messages
+    end
+
+    def model_name
+      @llm.class::DEFAULTS[:chat_completion_model_name]
+    end
+
+    def token_length(content, model_name, options)
+      @llm.class::LENGTH_VALIDATOR.token_length(content, model_name, options)
+    end
+  end
+end

data/lib/langchain/llm/base.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module Langchain::LLM
+  class ApiError < StandardError; end
+
   # A LLM is a language model consisting of a neural network with many parameters (typically billions of weights or more), trained on large quantities of unlabeled text using self-supervised learning or semi-supervised learning.
   #
   # Langchain.rb provides a common interface to interact with all supported LLMs:
@@ -9,6 +11,7 @@ module Langchain::LLM
   # - {Langchain::LLM::Cohere}
   # - {Langchain::LLM::GooglePalm}
   # - {Langchain::LLM::HuggingFace}
+  # - {Langchain::LLM::LlamaCpp}
   # - {Langchain::LLM::OpenAI}
   # - {Langchain::LLM::Replicate}
   #

data/lib/langchain/llm/cohere.rb

@@ -5,7 +5,7 @@ module Langchain::LLM
   # Wrapper around the Cohere API.
   #
   # Gem requirements:
-  #     gem "cohere-ruby", "~> 0.9.4"
+  #     gem "cohere-ruby", "~> 0.9.5"
   #
   # Usage:
   #     cohere = Langchain::LLM::Cohere.new(api_key: "YOUR_API_KEY")

data/lib/langchain/llm/llama_cpp.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Langchain::LLM
+  # A wrapper around the LlamaCpp.rb library
+  #
+  # Gem requirements:
+  #     gem "llama_cpp"
+  #
+  # Usage:
+  #     llama = Langchain::LLM::LlamaCpp.new(
+  #       model_path: ENV["LLAMACPP_MODEL_PATH"],
+  #       n_gpu_layers: Integer(ENV["LLAMACPP_N_GPU_LAYERS"]),
+  #       n_threads: Integer(ENV["LLAMACPP_N_THREADS"])
+  #     )
+  #
+  class LlamaCpp < Base
+    attr_accessor :model_path, :n_gpu_layers, :n_ctx, :seed
+    attr_writer :n_threads
+
+    # @param model_path [String] The path to the model to use
+    # @param n_gpu_layers [Integer] The number of GPU layers to use
+    # @param n_ctx [Integer] The number of context tokens to use
+    # @param n_threads [Integer] The CPU number of threads to use
+    # @param seed [Integer] The seed to use
+    def initialize(model_path:, n_gpu_layers: 1, n_ctx: 2048, n_threads: 1, seed: -1)
+      depends_on "llama_cpp"
+      require "llama_cpp"
+
+      @model_path = model_path
+      @n_gpu_layers = n_gpu_layers
+      @n_ctx = n_ctx
+      @n_threads = n_threads
+      @seed = seed
+    end
+
+    # @params text [String] The text to embed
+    # @params n_threads [Integer] The number of CPU threads to use
+    # @return [Array] The embedding
+    def embed(text:, n_threads: nil)
+      # contexts are kinda stateful when it comes to embeddings, so allocate one each time
+      context = embedding_context
+
+      embedding_input = context.tokenize(text: text, add_bos: true)
+      return unless embedding_input.size.positive?
+
+      n_threads ||= self.n_threads
+
+      context.eval(tokens: embedding_input, n_past: 0, n_threads: n_threads)
+      context.embeddings
+    end
+
+    # @params prompt [String] The prompt to complete
+    # @params n_predict [Integer] The number of tokens to predict
+    # @params n_threads [Integer] The number of CPU threads to use
+    # @return [String] The completed prompt
+    def complete(prompt:, n_predict: 128, n_threads: nil)
+      n_threads ||= self.n_threads
+      # contexts do not appear to be stateful when it comes to completion, so re-use the same one
+      context = completion_context
+      ::LLaMACpp.generate(context, prompt, n_threads: n_threads, n_predict: n_predict)
+    end
+
+    private
+
+    def n_threads
+      # Use the maximum number of CPU threads available, if not configured
+      @n_threads ||= `sysctl -n hw.ncpu`.strip.to_i
+    end
+
+    def build_context_params(embeddings: false)
+      context_params = ::LLaMACpp::ContextParams.new
+
+      context_params.seed = seed
+      context_params.n_ctx = n_ctx
+      context_params.n_gpu_layers = n_gpu_layers
+      context_params.embedding = embeddings
+
+      context_params
+    end
+
+    def build_model(embeddings: false)
+      return @model if defined?(@model)
+      @model = ::LLaMACpp::Model.new(model_path: model_path, params: build_context_params(embeddings: embeddings))
+    end
+
+    def build_completion_context
+      ::LLaMACpp::Context.new(model: build_model)
+    end
+
+    def build_embedding_context
+      ::LLaMACpp::Context.new(model: build_model(embeddings: true))
+    end
+
+    def completion_context
+      @completion_context ||= build_completion_context
+    end
+
+    def embedding_context
+      @embedding_context ||= build_embedding_context
+    end
+  end
+end

data/lib/langchain/llm/openai.rb

@@ -125,7 +125,7 @@ module Langchain::LLM
 
       response = client.chat(parameters: parameters)
 
-      raise "Chat completion failed: #{response}" if !response.empty? && response.dig("error")
+      raise Langchain::LLM::ApiError.new "Chat completion failed: #{response.dig("error", "message")}" if !response.empty? && response.dig("error")
 
       unless streaming
         response.dig("choices", 0, "message", "content")

data/lib/langchain/loader.rb

@@ -51,6 +51,13 @@ module Langchain
       !!(@path =~ URI_REGEX)
     end
 
+    # Is the path a directory
+    #
+    # @return [Boolean] true if path is a directory
+    def directory?
+      File.directory?(@path)
+    end
+
     # Load data from a file or URL
     #
     #    loader = Langchain::Loader.new("README.md")
@@ -69,15 +76,10 @@ module Langchain
     #
     # @return [Data] data that was loaded
     def load(&block)
-      @raw_data = url? ? load_from_url : load_from_path
+      return process_data(load_from_url, &block) if url?
+      return load_from_directory(&block) if directory?
 
-      data = if block
-        yield @raw_data.read, @options
-      else
-        processor_klass.new(@options).parse(@raw_data)
-      end
-
-      Langchain::Data.new(data, source: @path)
+      process_data(load_from_path, &block)
     end
 
     private
@@ -92,6 +94,27 @@ module Langchain
       File.open(@path)
     end
 
+    def load_from_directory(&block)
+      Dir.glob(File.join(@path, "**/*")).map do |file|
+        # Only load and add to result files with supported extensions
+        Langchain::Loader.new(file, @options).load(&block)
+      rescue
+        UnknownFormatError nil
+      end.flatten.compact
+    end
+
+    def process_data(data, &block)
+      @raw_data = data
+
+      result = if block
+        yield @raw_data.read, @options
+      else
+        processor_klass.new(@options).parse(@raw_data)
+      end
+
+      Langchain::Data.new(result)
+    end
+
     def processor_klass
       raise UnknownFormatError unless (kind = find_processor)
 

data/lib/langchain/output_parsers/fix.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Langchain::OutputParsers
+  # = Output Fixing Parser
+  #
+  class OutputFixingParser < Base
+    attr_reader :llm, :parser, :prompt
+
+    #
+    # Initializes a new instance of the class.
+    #
+    # @param llm [Langchain::LLM] The LLM used in the fixing process
+    # @param parser [Langchain::OutputParsers] The parser originally used which resulted in parsing error
+    # @param prompt [Langchain::Prompt::PromptTemplate]
+    #
+    def initialize(llm:, parser:, prompt:)
+      raise ArgumentError.new("llm must be an instance of Langchain::LLM got: #{llm.class}") unless llm.is_a?(Langchain::LLM::Base)
+      raise ArgumentError.new("parser must be an instance of Langchain::OutputParsers got #{parser.class}") unless parser.is_a?(Langchain::OutputParsers::Base)
+      raise ArgumentError.new("prompt must be an instance of Langchain::Prompt::PromptTemplate got #{prompt.class}") unless prompt.is_a?(Langchain::Prompt::PromptTemplate)
+      @llm = llm
+      @parser = parser
+      @prompt = prompt
+    end
+
+    def to_h
+      {
+        _type: "OutputFixingParser",
+        parser: parser.to_h,
+        prompt: prompt.to_h
+      }
+    end
+
+    #
+    # calls get_format_instructions on the @parser
+    #
+    # @return [String] Instructions for how the output of a language model should be formatted
+    # according to the @schema.
+    #
+    def get_format_instructions
+      parser.get_format_instructions
+    end
+
+    #
+    # Parse the output of an LLM call, if fails with OutputParserException
+    # then call the LLM with a fix prompt in an attempt to get the correctly
+    # formatted response
+    #
+    # @param completion [String] Text output from the LLM call
+    #
+    # @return [Object] object that is succesfully parsed by @parser.parse
+    #
+    def parse(completion)
+      parser.parse(completion)
+    rescue OutputParserException => e
+      new_completion = llm.chat(
+        prompt: prompt.format(
+          instructions: parser.get_format_instructions,
+          completion: completion,
+          error: e
+        )
+      )
+      parser.parse(new_completion)
+    end
+
+    #
+    # Creates a new instance of the class using the given JSON::Schema.
+    #
+    # @param schema [JSON::Schema] The JSON::Schema to use
+    #
+    # @return [Object] A new instance of the class
+    #
+    def self.from_llm(llm:, parser:, prompt: nil)
+      new(llm: llm, parser: parser, prompt: prompt || naive_fix_prompt)
+    end
+
+    private
+
+    private_class_method def self.naive_fix_prompt
+      Langchain::Prompt.load_from_path(
+        file_path: Langchain.root.join("langchain/output_parsers/prompts/naive_fix_prompt.yaml")
+      )
+    end
+  end
+end

data/lib/langchain/output_parsers/prompts/naive_fix_prompt.yaml

@@ -0,0 +1,22 @@
+_type: prompt
+input_variables:
+  - instructions
+  - completion
+  - error
+template: | 
+  Instructions:
+  --------------
+  {instructions}
+  --------------
+  Completion:
+  --------------
+  {completion}
+  --------------
+  
+  Above, the Completion did not satisfy the constraints given in the Instructions.
+  Error:
+  --------------
+  {error}
+  --------------
+  
+  Please try again. Please only respond with an answer that satisfies the constraints laid out in the Instructions:

data/lib/langchain/utils/token_length/google_palm_validator.rb

@@ -37,6 +37,9 @@ module Langchain
         #
         def self.token_length(text, model_name = "chat-bison-001", options)
           response = options[:llm].client.count_message_tokens(model: model_name, prompt: text)
+
+          raise Langchain::LLM::ApiError.new(response["error"]["message"]) unless response["error"].nil?
+
           response.dig("tokenCount")
         end
 

data/lib/langchain/vectorsearch/base.rb

@@ -98,6 +98,11 @@ module Langchain::Vectorsearch
       @llm = llm
     end
 
+    # Method supported by Vectorsearch DB to retrieve a default schema
+    def get_default_schema
+      raise NotImplementedError, "#{self.class.name} does not support retrieving a default schema"
+    end
+
     # Method supported by Vectorsearch DB to create a default schema
     def create_default_schema
       raise NotImplementedError, "#{self.class.name} does not support creating a default schema"

data/lib/langchain/vectorsearch/chroma.rb

@@ -67,10 +67,17 @@ module Langchain::Vectorsearch
       ::Chroma::Resources::Collection.create(index_name)
     end
 
-    # TODO: Uncomment and add the spec
-    # def destroy_default_schema
-    #   ::Chroma::Resources::Collection.delete(index_name)
-    # end
+    # Get the default schema
+    # @return [Hash] The response from the server
+    def get_default_schema
+      ::Chroma::Resources::Collection.get(index_name)
+    end
+
+    # Delete the default schema
+    # @return [Hash] The response from the server
+    def destroy_default_schema
+      ::Chroma::Resources::Collection.delete(index_name)
+    end
 
     # Search for similar texts
     # @param query [String] The text to search for

data/lib/langchain/vectorsearch/hnswlib.rb

@@ -10,8 +10,7 @@ module Langchain::Vectorsearch
     #     gem "hnswlib", "~> 0.8.1"
     #
     # Usage:
-    #     hnsw = Langchain::Vectorsearch::Hnswlib.new(llm:, url:, index_name:)
-    #
+    #     hnsw = Langchain::Vectorsearch::Hnswlib.new(llm:, path_to_index:)
 
     attr_reader :client, :path_to_index
 

data/lib/langchain/vectorsearch/milvus.rb

@@ -79,7 +79,17 @@ module Langchain::Vectorsearch
       )
     end
 
-    # TODO: Add destroy_default_schema method
+    # Get the default schema
+    # @return [Hash] The response from the server
+    def get_default_schema
+      client.collections.get(collection_name: index_name)
+    end
+
+    # Delete default schema
+    # @return [Hash] The response from the server
+    def destroy_default_schema
+      client.collections.delete(collection_name: index_name)
+    end
 
     def similarity_search(query:, k: 4)
       embedding = llm.embed(text: query)

data/lib/langchain/vectorsearch/pinecone.rb

@@ -85,6 +85,12 @@ module Langchain::Vectorsearch
       client.delete_index(index_name)
     end
 
+    # Get the default schema
+    # @return [Pinecone::Vector] The default schema
+    def get_default_schema
+      index
+    end
+
     # Search for similar texts
     # @param query [String] The text to search for
     # @param k [Integer] The number of results to return

data/lib/langchain/vectorsearch/qdrant.rb

@@ -32,11 +32,12 @@ module Langchain::Vectorsearch
     # Add a list of texts to the index
     # @param texts [Array] The list of texts to add
     # @return [Hash] The response from the server
-    def add_texts(texts:, ids:)
+    def add_texts(texts:, ids: [])
       batch = {ids: [], vectors: [], payloads: []}
 
       Array(texts).each_with_index do |text, i|
-        batch[:ids].push(ids[i] || SecureRandom.uuid)
+        id = ids[i] || SecureRandom.uuid
+        batch[:ids].push(id)
         batch[:vectors].push(llm.embed(text: text))
         batch[:payloads].push({content: text})
       end
@@ -51,6 +52,12 @@ module Langchain::Vectorsearch
       add_texts(texts: texts, ids: ids)
     end
 
+    # Get the default schema
+    # @return [Hash] The response from the server
+    def get_default_schema
+      client.collections.get(collection_name: index_name)
+    end
+
     # Deletes the default schema
     # @return [Hash] The response from the server
     def destroy_default_schema
@@ -109,7 +116,7 @@ module Langchain::Vectorsearch
     def ask(question:)
       search_results = similarity_search(query: question)
 
-      context = search_results.dig("result").map do |result|
+      context = search_results.map do |result|
         result.dig("payload").to_s
       end
       context = context.join("\n---\n")

data/lib/langchain/vectorsearch/weaviate.rb

@@ -85,6 +85,12 @@ module Langchain::Vectorsearch
       )
     end
 
+    # Get default schema
+    # @return [Hash] The response from the server
+    def get_default_schema
+      client.schema.get(class_name: index_name)
+    end
+
     # Delete the index
     # @return [Boolean] Whether the index was deleted
     def destroy_default_schema

data/lib/langchain/version.rb

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

data/lib/langchain.rb

@@ -51,6 +51,7 @@ module Langchain
   autoload :Loader, "langchain/loader"
   autoload :Data, "langchain/data"
   autoload :Conversation, "langchain/conversation"
+  autoload :ConversationMemory, "langchain/conversation_memory"
   autoload :DependencyHelper, "langchain/dependency_helper"
   autoload :ContextualLogger, "langchain/contextual_logger"
 
@@ -133,6 +134,7 @@ module Langchain
     autoload :Cohere, "langchain/llm/cohere"
     autoload :GooglePalm, "langchain/llm/google_palm"
     autoload :HuggingFace, "langchain/llm/hugging_face"
+    autoload :LlamaCpp, "langchain/llm/llama_cpp"
     autoload :OpenAI, "langchain/llm/openai"
     autoload :Replicate, "langchain/llm/replicate"
   end
@@ -152,6 +154,7 @@ module Langchain
   module OutputParsers
     autoload :Base, "langchain/output_parsers/base"
     autoload :StructuredOutputParser, "langchain/output_parsers/structured"
+    autoload :OutputFixingParser, "langchain/output_parsers/fix"
   end
 
   module Errors

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: langchainrb
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.6.5
 platform: ruby
 authors:
 - Andrei Bondarev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-06-26 00:00:00.000000000 Z
+date: 2023-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: baran
@@ -262,6 +262,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: llama_cpp
+  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: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -474,9 +488,11 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/conversation_with_openai.rb
 - examples/create_and_manage_few_shot_prompt_templates.rb
 - examples/create_and_manage_prompt_templates.rb
 - examples/create_and_manage_prompt_templates_using_structured_output_parser.rb
+- examples/llama_cpp.rb
 - examples/pdf_store_and_query_with_chroma.rb
 - examples/store_and_query_with_pinecone.rb
 - examples/store_and_query_with_qdrant.rb
@@ -494,6 +510,7 @@ files:
 - lib/langchain/chunker/text.rb
 - lib/langchain/contextual_logger.rb
 - lib/langchain/conversation.rb
+- lib/langchain/conversation_memory.rb
 - lib/langchain/data.rb
 - lib/langchain/dependency_helper.rb
 - lib/langchain/llm/ai21.rb
@@ -501,11 +518,14 @@ files:
 - lib/langchain/llm/cohere.rb
 - lib/langchain/llm/google_palm.rb
 - lib/langchain/llm/hugging_face.rb
+- lib/langchain/llm/llama_cpp.rb
 - lib/langchain/llm/openai.rb
 - lib/langchain/llm/prompts/summarize_template.yaml
 - lib/langchain/llm/replicate.rb
 - lib/langchain/loader.rb
 - lib/langchain/output_parsers/base.rb
+- lib/langchain/output_parsers/fix.rb
+- lib/langchain/output_parsers/prompts/naive_fix_prompt.yaml
 - lib/langchain/output_parsers/structured.rb
 - lib/langchain/processors/base.rb
 - lib/langchain/processors/csv.rb