langchainrb 0.5.5 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9781999daf45e5fedb0c7a905268866fbefd4581fd35a1a512ebb5844598f2c7
-  data.tar.gz: 93e2161a331151218cb94706827ab1ca2d94cb363613a5117ef7ce0c36cb9469
+  metadata.gz: 045a900e70f73ac0c969ea0e7cb0130d12219ad869583a55d5f5857ceccac618
+  data.tar.gz: f6202d34280eeda69026add6cb0bcadb1625da58ed729e1b4ca02c2cfdbd76b4
 SHA512:
-  metadata.gz: 58255ecc90b645cf6b276bee83a385d567122fb8b90ad7a075f4b2ec90ba2f6871156c6e5762b0bd67b259371d1c35b3973fd6b4e631be858ea8a368aac163b7
-  data.tar.gz: ffcaba1dc980b1f3175269a223ebe522bae1a3e17931b1f911adf387f8fc4a32692d45712ab0032e5a9c273ba304d97ca0ce2086978381d17e716efa1941072a
+  metadata.gz: b5cd3983b8a7389baace3befd24751d1c2974b94da29868fac6bfcd048681d2b6cc603d13f791d7ca4bffbc18b9278704c3db188112b51f1c71ac528c6c04f70
+  data.tar.gz: c061c1a877bc94488177ef79a46ed558540ba664a001a463a95fbe7f1f5f50c8895f359ab06fce26bb7dedf8cd246713b96e553fdfa55ca5b68c78f124e87a2a

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [0.5.6] - 2023-06-18
+- If used with OpenAI, Langchain::Conversation responses can now be streamed.
+- Improved logging
+- Langchain::Tool::SerpApi has been renamed to Langchain::Tool::GoogleSearch
+- JSON prompt templates have been converted to YAML
+- Langchain::Chunker::Text is introduced to provide simple text chunking functionality
+- Misc fixes and improvements
+
 ## [0.5.5] - 2023-06-12
 - [BREAKING] Rename `Langchain::Chat` to `Langchain::Conversation`
 - 🛠️ Tools

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    langchainrb (0.5.5)
+    langchainrb (0.5.6)
+      baran (~> 0.1.6)
       colorize (~> 0.8.1)
       tiktoken_ruby (~> 0.0.5)
 
@@ -32,6 +33,7 @@ GEM
     afm (0.2.2)
     ai21 (0.2.0)
     ast (2.4.2)
+    baran (0.1.6)
     builder (3.2.4)
     byebug (11.1.3)
     childprocess (4.1.0)

data/README.md

@@ -10,6 +10,8 @@
 [![Gem Version](https://badge.fury.io/rb/langchainrb.svg)](https://badge.fury.io/rb/langchainrb)
 [![Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/gems/langchainrb)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/andreibondarev/langchainrb/blob/main/LICENSE.txt)
+[![](https://dcbadge.vercel.app/api/server/WWqjwxMv?compact=true&style=flat)](https://discord.gg/WWqjwxMv)
+
 
 Langchain.rb is a library that's an abstraction layer on top many emergent AI, ML and other DS tools. The goal is to abstract complexity and difficult concepts to make building AI/ML-supercharged applications approachable for traditional software engineers.
 
@@ -264,7 +266,7 @@ Agents are semi-autonomous bots that can respond to user questions and use avail
 Add `gem "ruby-openai"`, `gem "eqn"`, and `gem "google_search_results"` to your Gemfile
 
 ```ruby
-search_tool = Langchain::Tool::SerpApi.new(api_key: ENV["SERPAPI_API_KEY"])
+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"])
@@ -275,7 +277,7 @@ agent = Langchain::Agent::ChainOfThoughtAgent.new(
 )
 
 agent.tools
-# => ["search", "calculator"]
+# => ["google_search", "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?")
@@ -308,7 +310,7 @@ agent.run(question: "How many users have a name with length greater than 5 in th
 | "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"`             |
-| "search"     | A wrapper around Google Search                     | `ENV["SERPAPI_API_KEY"]` (https://serpapi.com/manage-api-key) | `gem "google_search_results", "~> 2.0.0"` |
+| "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"`     |
 
@@ -364,8 +366,8 @@ Langchain.logger.level = :info
 4. `bin/console` to load the gem in a REPL session. Feel free to add your own instances of LLMs, Tools, Agents, etc. and experiment with them.
 5. Optionally, install lefthook git hooks for pre-commit to auto lint: `gem install lefthook && lefthook install -f`
 
-## Community
-Join us in the [Ruby AI Builders](https://discord.gg/SBmjAnKT) Discord community in #langchainrb
+## Discord
+Join us in the [Langchain.rb](https://discord.gg/hXutDWGDd) Discord server.
 
 ## Core Contributors
 [<img style="border-radius:50%" alt="Andrei Bondarev" src="https://avatars.githubusercontent.com/u/541665?v=4" width="80" height="80" class="avatar">](https://github.com/andreibondarev)

data/examples/store_and_query_with_pinecone.rb

@@ -3,7 +3,7 @@ require "langchain"
 # gem install pinecone
 # or add `gem "pinecone"` to your Gemfile
 
-# Instantiate the Qdrant client
+# Instantiate the Pinecone client
 pinecone = Langchain::Vectorsearch::Pinecone.new(
   environment: ENV["PINECONE_ENVIRONMENT"],
   api_key: ENV["PINECONE_API_KEY"],
@@ -12,6 +12,7 @@ pinecone = Langchain::Vectorsearch::Pinecone.new(
 )
 
 # Create the default schema.
+# If you are using the free Pinecone tier, ensure there is not an existing schema/index
 pinecone.create_default_schema
 
 # Set up an array of text strings
@@ -20,7 +21,7 @@ recipes = [
   "Heat oven to 190C/fan 170C/gas 5. Heat 1 tbsp oil and the butter in a frying pan, then add the onion and fry for 5 mins until softened. Cool slightly. Tip the sausagemeat, lemon zest, breadcrumbs, apricots, chestnuts and thyme into a bowl. Add the onion and cranberries, and mix everything together with your hands, adding plenty of pepper and a little salt. Cut each chicken breast into three fillets lengthwise and season all over with salt and pepper. Heat the remaining oil in the frying pan, and fry the chicken fillets quickly until browned, about 6-8 mins. Roll out two-thirds of the pastry to line a 20-23cm springform or deep loose-based tart tin. Press in half the sausage mix and spread to level. Then add the chicken pieces in one layer and cover with the rest of the sausage. Press down lightly. Roll out the remaining pastry. Brush the edges of the pastry with beaten egg and cover with the pastry lid. Pinch the edges to seal, then trim. Brush the top of the pie with egg, then roll out the trimmings to make holly leaf shapes and berries. Decorate the pie and brush again with egg. Set the tin on a baking sheet and bake for 50-60 mins, then cool in the tin for 15 mins. Remove and leave to cool completely. Serve with a winter salad and pickles."
 ]
 
-# Add data to the index. Weaviate will use OpenAI to generate embeddings behind the scene.
+# Add data to the index. Pinecone will use OpenAI to generate embeddings behind the scene.
 pinecone.add_texts(
   texts: recipes
 )
@@ -33,10 +34,10 @@ pinecone.similarity_search(
 
 # Interact with your index through Q&A
 pinecone.ask(
-  question: "What is the best recipe for chicken?"
+  question: "What is a good recipe for chicken?"
 )
 
-# Generate your an embedding and search by it
+# Generate an embedding and search by it
 openai = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"])
 embedding = openai.embed(text: "veggie")
 

data/lib/langchain/agent/base.rb

@@ -10,5 +10,10 @@ module Langchain::Agent
   #
   # @abstract
   class Base
+    def self.logger_options
+      {
+        color: :red
+      }
+    end
   end
 end

data/lib/langchain/agent/chain_of_thought_agent/chain_of_thought_agent.rb

@@ -7,28 +7,30 @@ module Langchain::Agent
   #
   #     agent = Langchain::Agent::ChainOfThoughtAgent.new(
   #       llm: llm,
-  #       tools: ["search", "calculator", "wikipedia"]
+  #       tools: ["google_search", "calculator", "wikipedia"]
   #     )
   #
   #     agent.tools
-  #     # => ["search", "calculator", "wikipedia"]
+  #     # => ["google_search", "calculator", "wikipedia"]
   #
   #     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 ChainOfThoughtAgent < Base
-    attr_reader :llm, :tools
+    attr_reader :llm, :tools, :max_iterations
 
     # Initializes the Agent
     #
     # @param llm [Object] The LLM client to use
     # @param tools [Array] The tools to use
+    # @param max_iterations [Integer] The maximum number of iterations to run
     # @return [ChainOfThoughtAgent] The Agent::ChainOfThoughtAgent instance
-    def initialize(llm:, tools: [])
+    def initialize(llm:, tools: [], max_iterations: 10)
       Langchain::Tool::Base.validate_tools!(tools: tools)
 
       @tools = tools
 
       @llm = llm
+      @max_iterations = max_iterations
     end
 
     # Validate tools when they're re-assigned
@@ -51,8 +53,9 @@ module Langchain::Agent
         tools: tools
       )
 
-      loop do
-        Langchain.logger.info("[#{self.class.name}]".red + ": Sending the prompt to the #{llm.class} LLM")
+      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:"])
 
@@ -68,7 +71,7 @@ module Langchain::Agent
 
           # Find the Tool and call `execute`` with action_input as the input
           tool = tools.find { |tool| tool.tool_name == action.strip }
-          Langchain.logger.info("[#{self.class.name}]".red + ": Invoking \"#{tool.class}\" Tool with \"#{action_input}\"")
+          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)
@@ -81,9 +84,12 @@ module Langchain::Agent
           end
         else
           # Return the final answer
-          break response.match(/Final Answer: (.*)/)&.send(:[], -1)
+          final_response = response.match(/Final Answer: (.*)/)&.send(:[], -1)
+          break
         end
       end
+
+      final_response || raise(MaxIterationsReachedError.new(max_iterations))
     end
 
     private
@@ -107,12 +113,18 @@ module Langchain::Agent
       )
     end
 
-    # Load the PromptTemplate from the JSON file
+    # 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/chain_of_thought_agent/chain_of_thought_agent_prompt.json")
+        file_path: Langchain.root.join("langchain/agent/chain_of_thought_agent/chain_of_thought_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/chain_of_thought_agent/chain_of_thought_agent_prompt.yaml

@@ -0,0 +1,26 @@
+_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/sql_query_agent/sql_query_agent.rb

@@ -26,15 +26,15 @@ module Langchain::Agent
       prompt = create_prompt_for_sql(question: question)
 
       # Get the SQL string to execute
-      Langchain.logger.info("[#{self.class.name}]".red + ":  Passing the inital prompt to the #{llm.class} LLM")
+      Langchain.logger.info("Passing the inital prompt to the #{llm.class} LLM", for: self.class)
       sql_string = llm.complete(prompt: prompt)
 
       # Execute the SQL string and collect the results
-      Langchain.logger.info("[#{self.class.name}]".red + ":  Passing the SQL to the Database: #{sql_string}")
+      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("[#{self.class.name}]".red + ":  Passing the synthesize prompt to the #{llm.class} LLM with results: #{results}")
+      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)
     end
@@ -52,11 +52,11 @@ module Langchain::Agent
       )
     end
 
-    # Load the PromptTemplate from the JSON file
+    # 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.json")
+        file_path: Langchain.root.join("langchain/agent/sql_query_agent/sql_query_agent_sql_prompt.yaml")
       )
     end
 
@@ -71,11 +71,11 @@ module Langchain::Agent
       )
     end
 
-    # Load the PromptTemplate from the JSON file
+    # 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.json")
+        file_path: Langchain.root.join("langchain/agent/sql_query_agent/sql_query_agent_answer_prompt.yaml")
       )
     end
   end

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

@@ -0,0 +1,11 @@
+_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

@@ -0,0 +1,21 @@
+_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/chunker/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Langchain
+  module Chunker
+    # = Chunkers
+    # Chunkers are used to split documents into smaller chunks before indexing into vector search databases.
+    # Otherwise large documents, when retrieved and passed to LLMs, may hit the context window limits.
+    #
+    # == Available chunkers
+    #
+    # - {Langchain::Chunker::Text}
+    class Base
+    end
+  end
+end

data/lib/langchain/chunker/text.rb

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

data/lib/langchain/contextual_logger.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Langchain
+  class ContextualLogger
+    MESSAGE_COLOR_OPTIONS = {
+      debug: {
+        color: :white
+      },
+      error: {
+        color: :red
+      },
+      fatal: {
+        color: :red,
+        background: :white,
+        mode: :bold
+      },
+      unknown: {
+        color: :white
+      },
+      info: {
+        color: :white
+      },
+      warn: {
+        color: :yellow,
+        mode: :bold
+      }
+    }
+
+    def initialize(logger)
+      @logger = logger
+      @levels = Logger::Severity.constants.map(&:downcase)
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      @logger.respond_to?(method, include_private)
+    end
+
+    def method_missing(method, *args, **kwargs, &block)
+      return @logger.send(method, *args, **kwargs, &block) unless @levels.include?(method)
+
+      for_class = kwargs.delete(:for)
+      for_class_name = for_class&.name
+
+      log_line_parts = []
+      log_line_parts << "[LangChain.rb]".colorize(color: :yellow)
+      log_line_parts << if for_class.respond_to?(:logger_options)
+        "[#{for_class_name}]".colorize(for_class.logger_options) + ":"
+      elsif for_class_name
+        "[#{for_class_name}]:"
+      end
+      log_line_parts << args.first.colorize(MESSAGE_COLOR_OPTIONS[method])
+      log_line = log_line_parts.compact.join(" ")
+
+      @logger.send(
+        method,
+        log_line
+      )
+    end
+  end
+end

data/lib/langchain/conversation.rb

@@ -11,20 +11,29 @@ module Langchain
   #     chat.set_context("You are a chatbot from the future")
   #     chat.message("Tell me about future technologies")
   #
+  # To stream the chat response:
+  #     chat = Langchain::Conversation.new(llm: llm) do |chunk|
+  #       print(chunk)
+  #     end
+  #
   class Conversation
     attr_reader :context, :examples, :messages
 
+    # The least number of tokens we want to be under the limit by
+    TOKEN_LEEWAY = 20
+
     # Intialize Conversation with a LLM
     #
     # @param llm [Object] The LLM to use for the conversation
     # @param options [Hash] Options to pass to the LLM, like temperature, top_k, etc.
     # @return [Langchain::Conversation] The Langchain::Conversation instance
-    def initialize(llm:, **options)
+    def initialize(llm:, **options, &block)
       @llm = llm
-      @options = options
       @context = nil
       @examples = []
-      @messages = []
+      @messages = options.delete(:messages) || []
+      @options = options
+      @block = block
     end
 
     # Set the context of the conversation. Usually used to set the model's persona.
@@ -52,7 +61,21 @@ module Langchain
     private
 
     def llm_response(prompt)
-      @llm.chat(messages: @messages, context: @context, examples: @examples, **@options)
+      @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
+    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
     end
 
     def append_ai_message(message)
@@ -62,5 +85,13 @@ module Langchain
     def append_user_message(message)
       @messages << {role: "user", content: message}
     end
+
+    def model_name
+      @options[:model] || @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/data.rb

@@ -12,5 +12,9 @@ module Langchain
     def value
       @data
     end
+
+    def chunks(opts = {})
+      Langchain::Chunker::Text.new(@data, **opts).chunks
+    end
   end
 end

data/lib/langchain/llm/google_palm.rb

@@ -24,6 +24,7 @@ module Langchain::LLM
       temperature: 0.0,
       dimension: 768 # This is what the `embedding-gecko-001` model generates
     }.freeze
+    LENGTH_VALIDATOR = Langchain::Utils::TokenLength::GooglePalmValidator
 
     def initialize(api_key:)
       depends_on "google_palm_api"
@@ -90,7 +91,7 @@ module Langchain::LLM
         examples: compose_examples(examples)
       }
 
-      Langchain::Utils::TokenLength::GooglePalmValidator.validate_max_tokens!(self, default_params[:messages], "chat-bison-001")
+      LENGTH_VALIDATOR.validate_max_tokens!(default_params[:messages], "chat-bison-001", llm: self)
 
       if options[:stop_sequences]
         default_params[:stop] = options.delete(:stop_sequences)
@@ -116,7 +117,7 @@ module Langchain::LLM
     #
     def summarize(text:)
       prompt_template = Langchain::Prompt.load_from_path(
-        file_path: Langchain.root.join("langchain/llm/prompts/summarize_template.json")
+        file_path: Langchain.root.join("langchain/llm/prompts/summarize_template.yaml")
       )
       prompt = prompt_template.format(text: text)
 

data/lib/langchain/llm/openai.rb

@@ -17,6 +17,7 @@ module Langchain::LLM
       embeddings_model_name: "text-embedding-ada-002",
       dimension: 1536
     }.freeze
+    LENGTH_VALIDATOR = Langchain::Utils::TokenLength::OpenAIValidator
 
     def initialize(api_key:, llm_options: {})
       depends_on "ruby-openai"
@@ -35,7 +36,7 @@ module Langchain::LLM
     def embed(text:, **params)
       parameters = {model: DEFAULTS[:embeddings_model_name], input: text}
 
-      Langchain::Utils::TokenLength::OpenAIValidator.validate_max_tokens!(text, parameters[:model])
+      validate_max_tokens(text, parameters[:model])
 
       response = client.embeddings(parameters: parameters.merge(params))
       response.dig("data").first.dig("embedding")
@@ -52,7 +53,7 @@ module Langchain::LLM
       parameters = compose_parameters DEFAULTS[:completion_model_name], params
 
       parameters[:prompt] = prompt
-      parameters[:max_tokens] = Langchain::Utils::TokenLength::OpenAIValidator.validate_max_tokens!(prompt, parameters[:model])
+      parameters[:max_tokens] = validate_max_tokens(prompt, parameters[:model])
 
       response = client.completions(parameters: parameters)
       response.dig("choices", 0, "text")
@@ -66,6 +67,7 @@ module Langchain::LLM
     # @param context [String] The context of the conversation
     # @param examples [Array] Examples of messages provide model with
     # @param options extra parameters passed to OpenAI::Client#chat
+    # @param block [Block] Pass the block to stream the response
     # @return [String] The chat completion
     #
     def chat(prompt: "", messages: [], context: "", examples: [], **options)
@@ -75,11 +77,19 @@ module Langchain::LLM
       parameters[:messages] = compose_chat_messages(prompt: prompt, messages: messages, context: context, examples: examples)
       parameters[:max_tokens] = validate_max_tokens(parameters[:messages], parameters[:model])
 
+      if (streaming = block_given?)
+        parameters[:stream] = proc do |chunk, _bytesize|
+          yield chunk.dig("choices", 0, "delta", "content")
+        end
+      end
+
       response = client.chat(parameters: parameters)
 
-      raise "Chat completion failed: #{response}" if response.dig("error")
+      raise "Chat completion failed: #{response}" if !response.empty? && response.dig("error")
 
-      response.dig("choices", 0, "message", "content")
+      unless streaming
+        response.dig("choices", 0, "message", "content")
+      end
     end
 
     #
@@ -90,7 +100,7 @@ module Langchain::LLM
     #
     def summarize(text:)
       prompt_template = Langchain::Prompt.load_from_path(
-        file_path: Langchain.root.join("langchain/llm/prompts/summarize_template.json")
+        file_path: Langchain.root.join("langchain/llm/prompts/summarize_template.yaml")
       )
       prompt = prompt_template.format(text: text)
 
@@ -140,7 +150,7 @@ module Langchain::LLM
     end
 
     def validate_max_tokens(messages, model)
-      Langchain::Utils::TokenLength::OpenAIValidator.validate_max_tokens!(messages, model)
+      LENGTH_VALIDATOR.validate_max_tokens!(messages, model)
     end
   end
 end

data/lib/langchain/llm/prompts/summarize_template.yaml

@@ -0,0 +1,9 @@
+_type: prompt
+input_variables:
+  - text
+template: |
+  Write a concise summary of the following:
+
+  {text}
+
+  CONCISE SUMMARY:

data/lib/langchain/llm/replicate.rb

@@ -94,7 +94,7 @@ module Langchain::LLM
     #
     def summarize(text:)
       prompt_template = Langchain::Prompt.load_from_path(
-        file_path: Langchain.root.join("langchain/llm/prompts/summarize_template.json")
+        file_path: Langchain.root.join("langchain/llm/prompts/summarize_template.yaml")
       )
       prompt = prompt_template.format(text: text)