langchainrb 0.6.4 → 0.6.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78810f63a496c6b98208a9c838cbdae41a8c944879e68f16fc4362de90c49110
-  data.tar.gz: c95d357da62c8120a2a105a94b219ca1f3552f85fff30bb7cb3d40def336baeb
+  metadata.gz: a9949f3ffd0338c90274f13b9862b0a6b9ec7b717b14b7ccaa8b6b8e0115f621
+  data.tar.gz: 43ebcb26d51b286278d5098ba50defef0c8bd1a897fa744c4519cfa10bdfdf58
 SHA512:
-  metadata.gz: ee0c549ecebd98ce940b6dc05c8aa2783c265d7cb3903ca30448be0f906e89f353e419b2bb862178fe9081baa002b42fd7aaf88ec244a63beec9bc862e3a9410
-  data.tar.gz: a4b67c5b0d268d6b96622209fe3201c8585bf44d1d44dca0bc061de3f1ba1797e87df61111ddc6565b0d75b23a06677aa3bad6e41fbd4a119ff69f6b11e756ee
+  metadata.gz: c95f6e104aaa9a8dab30c9e78e342fdf960ccfef332a2737218f3cc186521369e6f03216d5ccd08329d5110cd15ef10e10a3f460caecc02dd50e32b1b60ff8b3
+  data.tar.gz: c8c059c760b361975ea7ba8eb8a7aa24c1dd7dde5264d7d8bdf20da4f7ec80fe3f1cf4f60dd16dd8028638f3335b1e1632b655ae6c4bdd01912d33371892b5a3

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,14 @@
 ## [Unreleased]
 
+## [0.6.6] - 2023-07-13
+- Langchain::Chunker::RecursiveText
+- Fixes
+
+## [0.6.5] - 2023-07-06
+- 🗣️ LLMs
+  - Introducing Llama.cpp support
+- Langchain::OutputParsers::OutputFixingParser to wrap a Langchain::OutputParser and handle invalid response
+
 ## [0.6.4] - 2023-07-01
 - Fix `Langchain::Vectorsearch::Qdrant#add_texts()`
 - Introduce `ConversationMemory`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    langchainrb (0.6.4)
+    langchainrb (0.6.6)
       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

@@ -39,7 +39,7 @@ require "langchain"
 | [Hnswlib](https://github.com/nmslib/hnswlib/) | :white_check_mark: | :white_check_mark: | :white_check_mark: | WIP     | WIP               |
 | [Milvus](https://milvus.io/) | :white_check_mark: | :white_check_mark: | :white_check_mark: | WIP     | WIP               |
 | [Pinecone](https://www.pinecone.io/) | :white_check_mark: | :white_check_mark: | :white_check_mark: | WIP     | :white_check_mark: |
-| [Pgvector](https://github.com/pgvector/pgvector) | :white_check_mark: | :white_check_mark: | :white_check_mark: | WIP     | WIP               |
+| [Pgvector](https://github.com/pgvector/pgvector) | :white_check_mark: | :white_check_mark: | :white_check_mark: | WIP     | :white_check_mark: |
 | [Qdrant](https://qdrant.tech/) | :white_check_mark: | :white_check_mark: | :white_check_mark: | WIP     | :white_check_mark: |
 | [Weaviate](https://weaviate.io/) | :white_check_mark: | :white_check_mark: | :white_check_mark: | WIP     | :white_check_mark: |
 
@@ -54,7 +54,7 @@ Pick the vector search database you'll be using and instantiate the client:
 client = Langchain::Vectorsearch::Weaviate.new(
     url: ENV["WEAVIATE_URL"],
     api_key: ENV["WEAVIATE_API_KEY"],
-    index: "",
+    index_name: "",
     llm: Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"])
 )
 
@@ -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.
 
@@ -327,7 +427,7 @@ agent.run(question: "How many users have a name with length greater than 5 in th
 | "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"`    |
+| "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"`     |
 
 #### Loaders 🚚

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/chunker/recursive_text.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "baran"
+
+module Langchain
+  module Chunker
+    #
+    # Recursive text chunker. Preferentially splits on separators.
+    #
+    # Usage:
+    #     Langchain::Chunker::RecursiveText.new(text).chunks
+    #
+    class RecursiveText < Base
+      attr_reader :text, :chunk_size, :chunk_overlap, :separators
+
+      # @param [String] text
+      # @param [Integer] chunk_size
+      # @param [Integer] chunk_overlap
+      # @param [Array<String>] separators
+      def initialize(text, chunk_size: 1000, chunk_overlap: 200, separators: ["\n\n"])
+        @text = text
+        @chunk_size = chunk_size
+        @chunk_overlap = chunk_overlap
+        @separators = separators
+      end
+
+      # @return [Array<String>]
+      def chunks
+        splitter = Baran::RecursiveCharacterTextSplitter.new(
+          chunk_size: chunk_size,
+          chunk_overlap: chunk_overlap,
+          separators: separators
+        )
+        splitter.chunks(text)
+      end
+    end
+  end
+end

data/lib/langchain/llm/base.rb

@@ -11,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/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/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/vectorsearch/base.rb

@@ -161,12 +161,16 @@ module Langchain::Vectorsearch
     end
 
     def add_data(paths:)
-      raise ArgumentError, "Paths must be provided" if paths.to_a.empty?
+      raise ArgumentError, "Paths must be provided" if Array(paths).empty?
 
       texts = Array(paths)
         .flatten
-        .map { |path| Langchain::Loader.new(path)&.load&.value }
-        .compact
+        .map do |path|
+          data = Langchain::Loader.new(path)&.load&.chunks
+          data.map { |chunk| chunk[:text] }
+        end
+
+      texts.flatten!
 
       add_texts(texts: texts)
     end

data/lib/langchain/vectorsearch/pgvector.rb

@@ -40,20 +40,53 @@ module Langchain::Vectorsearch
       super(llm: llm)
     end
 
-    # Add a list of texts to the index
+    # Upsert a list of texts to the index
     # @param texts [Array<String>] The texts to add to the index
-    # @return [PG::Result] The response from the database
-    def add_texts(texts:)
-      data = texts.flat_map do |text|
-        [text, llm.embed(text: text)]
+    # @param ids [Array<Integer>] The ids of the objects to add to the index, in the same order as the texts
+    # @return [PG::Result] The response from the database including the ids of
+    # the added or updated texts.
+    def upsert_texts(texts:, ids:)
+      data = texts.zip(ids).flat_map do |(text, id)|
+        [id, text, llm.embed(text: text)]
       end
-      values = texts.length.times.map { |i| "($#{2 * i + 1}, $#{2 * i + 2})" }.join(",")
+      values = texts.length.times.map { |i| "($#{3 * i + 1}, $#{3 * i + 2}, $#{3 * i + 3})" }.join(",")
+      # see https://github.com/pgvector/pgvector#storing
       client.exec_params(
-        "INSERT INTO #{quoted_table_name} (content, vectors) VALUES #{values};",
+        "INSERT INTO #{quoted_table_name} (id, content, vectors) VALUES
+#{values} ON CONFLICT (id) DO UPDATE SET content = EXCLUDED.content, vectors = EXCLUDED.vectors RETURNING id;",
         data
       )
     end
 
+    # Add a list of texts to the index
+    # @param texts [Array<String>] The texts to add to the index
+    # @param ids [Array<String>] The ids to add to the index, in the same order as the texts
+    # @return [PG::Result] The response from the database including the ids of
+    # the added texts.
+    def add_texts(texts:, ids: nil)
+      if ids.nil? || ids.empty?
+        data = texts.flat_map do |text|
+          [text, llm.embed(text: text)]
+        end
+        values = texts.length.times.map { |i| "($#{2 * i + 1}, $#{2 * i + 2})" }.join(",")
+        client.exec_params(
+          "INSERT INTO #{quoted_table_name} (content, vectors) VALUES #{values} RETURNING id;",
+          data
+        )
+      else
+        upsert_texts(texts: texts, ids: ids)
+      end
+    end
+
+    # Update a list of ids and corresponding texts to the index
+    # @param texts [Array<String>] The texts to add to the index
+    # @param ids [Array<String>] The ids to add to the index, in the same order as the texts
+    # @return [PG::Result] The response from the database including the ids of
+    # the updated texts.
+    def update_texts(texts:, ids:)
+      upsert_texts(texts: texts, ids: ids)
+    end
+
     # Create default schema
     # @return [PG::Result] The response from the database
     def create_default_schema

data/lib/langchain/version.rb

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

data/lib/langchain.rb

@@ -82,6 +82,7 @@ module Langchain
   module Chunker
     autoload :Base, "langchain/chunker/base"
     autoload :Text, "langchain/chunker/text"
+    autoload :RecursiveText, "langchain/chunker/recursive_text"
   end
 
   module Tool
@@ -134,6 +135,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
@@ -153,6 +155,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.4
+  version: 0.6.6
 platform: ruby
 authors:
 - Andrei Bondarev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-01 00:00:00.000000000 Z
+date: 2023-07-14 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
@@ -478,6 +492,7 @@ files:
 - 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
@@ -492,6 +507,7 @@ files:
 - 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/chunker/base.rb
+- lib/langchain/chunker/recursive_text.rb
 - lib/langchain/chunker/text.rb
 - lib/langchain/contextual_logger.rb
 - lib/langchain/conversation.rb
@@ -503,11 +519,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