langchainrb 0.7.5 → 0.12.0

data/lib/langchain/assistants/thread.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Langchain
+  # Langchain::Thread keeps track of messages in a conversation.
+  # TODO: Add functionality to persist to the thread to disk, DB, storage, etc.
+  class Thread
+    attr_accessor :messages
+
+    # @param messages [Array<Langchain::Message>]
+    def initialize(messages: [])
+      raise ArgumentError, "messages array must only contain Langchain::Message instance(s)" unless messages.is_a?(Array) && messages.all? { |m| m.is_a?(Langchain::Message) }
+
+      @messages = messages
+    end
+
+    # Convert the thread to an OpenAI API-compatible array of hashes
+    #
+    # @return [Array<Hash>] The thread as an OpenAI API-compatible array of hashes
+    def openai_messages
+      messages.map(&:to_openai_format)
+    end
+
+    # Add a message to the thread
+    #
+    # @param message [Langchain::Message] The message to add
+    # @return [Array<Langchain::Message>] The updated messages array
+    def add_message(message)
+      raise ArgumentError, "message must be a Langchain::Message instance" unless message.is_a?(Langchain::Message)
+
+      # Prepend the message to the thread
+      messages << message
+    end
+  end
+end

data/lib/langchain/chunker/markdown.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "baran"
+
+module Langchain
+  module Chunker
+    # Simple text chunker
+    #
+    # Usage:
+    #     Langchain::Chunker::Markdown.new(text).chunks
+    class Markdown < Base
+      attr_reader :text, :chunk_size, :chunk_overlap
+
+      # @param [String] text
+      # @param [Integer] chunk_size
+      # @param [Integer] chunk_overlap
+      # @param [String] separator
+      def initialize(text, chunk_size: 1000, chunk_overlap: 200)
+        @text = text
+        @chunk_size = chunk_size
+        @chunk_overlap = chunk_overlap
+      end
+
+      # @return [Array<Langchain::Chunk>]
+      def chunks
+        splitter = Baran::MarkdownSplitter.new(
+          chunk_size: chunk_size,
+          chunk_overlap: chunk_overlap
+        )
+
+        splitter.chunks(text).map do |chunk|
+          Langchain::Chunk.new(text: chunk[:text])
+        end
+      end
+    end
+  end
+end

data/lib/langchain/chunker/recursive_text.rb

@@ -4,12 +4,10 @@ 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
 

data/lib/langchain/chunker/semantic.rb

@@ -2,7 +2,6 @@
 
 module Langchain
   module Chunker
-    #
     # LLM-powered semantic chunker.
     # Semantic chunking is a technique of splitting texts by their semantic meaning, e.g.: themes, topics, and ideas.
     # We use an LLM to accomplish this. The Anthropic LLM is highly recommended for this task as it has the longest context window (100k tokens).
@@ -12,7 +11,6 @@ module Langchain
     #       text,
     #       llm: Langchain::LLM::Anthropic.new(api_key: ENV["ANTHROPIC_API_KEY"])
     #     ).chunks
-    #
     class Semantic < Base
       attr_reader :text, :llm, :prompt_template
       # @param [Langchain::LLM::Base] Langchain::LLM::* instance
@@ -28,7 +26,7 @@ module Langchain
         prompt = prompt_template.format(text: text)
 
         # Replace static 50k limit with dynamic limit based on text length (max_tokens_to_sample)
-        completion = llm.complete(prompt: prompt, max_tokens_to_sample: 50000)
+        completion = llm.complete(prompt: prompt, max_tokens_to_sample: 50000).completion
         completion
           .gsub("Here are the paragraphs split by topic:\n\n", "")
           .split("---")

data/lib/langchain/chunker/sentence.rb

@@ -4,12 +4,10 @@ require "pragmatic_segmenter"
 
 module Langchain
   module Chunker
-    #
     # This chunker splits text by sentences.
     #
     # Usage:
     #     Langchain::Chunker::Sentence.new(text).chunks
-    #
     class Sentence < Base
       attr_reader :text
 

data/lib/langchain/chunker/text.rb

@@ -4,12 +4,10 @@ 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
 

data/lib/langchain/contextual_logger.rb

@@ -42,7 +42,7 @@ module Langchain
       for_class_name = for_class&.name
 
       log_line_parts = []
-      log_line_parts << "[LangChain.rb]".colorize(color: :yellow)
+      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

data/lib/langchain/data.rb

@@ -9,9 +9,10 @@ module Langchain
 
     # @param data [String] data that was loaded
     # @option options [String] :source URL or Path of the data source
-    def initialize(data, options = {})
-      @source = options[:source]
+    def initialize(data, source: nil, chunker: Langchain::Chunker::Text)
+      @source = source
       @data = data
+      @chunker_klass = chunker
     end
 
     # @return [String]
@@ -22,7 +23,7 @@ module Langchain
     # @param opts [Hash] options passed to the chunker
     # @return [Array<String>]
     def chunks(opts = {})
-      Langchain::Chunker::Text.new(@data, **opts).chunks
+      @chunker_klass.new(@data, **opts).chunks
     end
   end
 end

data/lib/langchain/llm/ai21.rb

@@ -35,7 +35,7 @@ module Langchain::LLM
     def complete(prompt:, **params)
       parameters = complete_parameters params
 
-      parameters[:maxTokens] = LENGTH_VALIDATOR.validate_max_tokens!(prompt, parameters[:model], client)
+      parameters[:maxTokens] = LENGTH_VALIDATOR.validate_max_tokens!(prompt, parameters[:model], {llm: client})
 
       response = client.complete(prompt, parameters)
       Langchain::LLM::AI21Response.new response, model: parameters[:model]

data/lib/langchain/llm/anthropic.rb

@@ -14,12 +14,19 @@ module Langchain::LLM
     DEFAULTS = {
       temperature: 0.0,
       completion_model_name: "claude-2",
+      chat_completion_model_name: "claude-3-sonnet-20240229",
       max_tokens_to_sample: 256
     }.freeze
 
     # TODO: Implement token length validator for Anthropic
     # LENGTH_VALIDATOR = Langchain::Utils::TokenLength::AnthropicValidator
 
+    # Initialize an Anthropic LLM instance
+    #
+    # @param api_key [String] The API key to use
+    # @param llm_options [Hash] Options to pass to the Anthropic client
+    # @param default_options [Hash] Default options to use on every call to LLM, e.g.: { temperature:, completion_model_name:, chat_completion_model_name:, max_tokens_to_sample: }
+    # @return [Langchain::LLM::Anthropic] Langchain::LLM::Anthropic instance
     def initialize(api_key:, llm_options: {}, default_options: {})
       depends_on "anthropic"
 
@@ -27,17 +34,43 @@ module Langchain::LLM
       @defaults = DEFAULTS.merge(default_options)
     end
 
-    #
     # Generate a completion for a given prompt
     #
-    # @param prompt [String] The prompt to generate a completion for
-    # @param params [Hash] extra parameters passed to Anthropic::Client#complete
+    # @param prompt [String] Prompt to generate a completion for
+    # @param model [String] The model to use
+    # @param max_tokens_to_sample [Integer] The maximum number of tokens to sample
+    # @param stop_sequences [Array<String>] The stop sequences to use
+    # @param temperature [Float] The temperature to use
+    # @param top_p [Float] The top p value to use
+    # @param top_k [Integer] The top k value to use
+    # @param metadata [Hash] The metadata to use
+    # @param stream [Boolean] Whether to stream the response
     # @return [Langchain::LLM::AnthropicResponse] The completion
-    #
-    def complete(prompt:, **params)
-      parameters = compose_parameters @defaults[:completion_model_name], params
+    def complete(
+      prompt:,
+      model: @defaults[:completion_model_name],
+      max_tokens_to_sample: @defaults[:max_tokens_to_sample],
+      stop_sequences: nil,
+      temperature: @defaults[:temperature],
+      top_p: nil,
+      top_k: nil,
+      metadata: nil,
+      stream: nil
+    )
+      raise ArgumentError.new("model argument is required") if model.empty?
+      raise ArgumentError.new("max_tokens_to_sample argument is required") if max_tokens_to_sample.nil?
 
-      parameters[:prompt] = prompt
+      parameters = {
+        model: model,
+        prompt: prompt,
+        max_tokens_to_sample: max_tokens_to_sample,
+        temperature: temperature
+      }
+      parameters[:stop_sequences] = stop_sequences if stop_sequences
+      parameters[:top_p] = top_p if top_p
+      parameters[:top_k] = top_k if top_k
+      parameters[:metadata] = metadata if metadata
+      parameters[:stream] = stream if stream
 
       # TODO: Implement token length validator for Anthropic
       # parameters[:max_tokens_to_sample] = validate_max_tokens(prompt, parameters[:completion_model_name])
@@ -46,12 +79,54 @@ module Langchain::LLM
       Langchain::LLM::AnthropicResponse.new(response)
     end
 
-    private
+    # Generate a chat completion for given messages
+    #
+    # @param messages [Array<String>] Input messages
+    # @param model [String] The model that will complete your prompt
+    # @param max_tokens [Integer] Maximum number of tokens to generate before stopping
+    # @param metadata [Hash] Object describing metadata about the request
+    # @param stop_sequences [Array<String>] Custom text sequences that will cause the model to stop generating
+    # @param stream [Boolean] Whether to incrementally stream the response using server-sent events
+    # @param system [String] System prompt
+    # @param temperature [Float] Amount of randomness injected into the response
+    # @param tools [Array<String>] Definitions of tools that the model may use
+    # @param top_k [Integer] Only sample from the top K options for each subsequent token
+    # @param top_p [Float] Use nucleus sampling.
+    # @return [Langchain::LLM::AnthropicResponse] The chat completion
+    def chat(
+      messages: [],
+      model: @defaults[:chat_completion_model_name],
+      max_tokens: @defaults[:max_tokens_to_sample],
+      metadata: nil,
+      stop_sequences: nil,
+      stream: nil,
+      system: nil,
+      temperature: @defaults[:temperature],
+      tools: [],
+      top_k: nil,
+      top_p: nil
+    )
+      raise ArgumentError.new("messages argument is required") if messages.empty?
+      raise ArgumentError.new("model argument is required") if model.empty?
+      raise ArgumentError.new("max_tokens argument is required") if max_tokens.nil?
+
+      parameters = {
+        messages: messages,
+        model: model,
+        max_tokens: max_tokens,
+        temperature: temperature
+      }
+      parameters[:metadata] = metadata if metadata
+      parameters[:stop_sequences] = stop_sequences if stop_sequences
+      parameters[:stream] = stream if stream
+      parameters[:system] = system if system
+      parameters[:tools] = tools if tools.any?
+      parameters[:top_k] = top_k if top_k
+      parameters[:top_p] = top_p if top_p
 
-    def compose_parameters(model, params)
-      default_params = {model: model}.merge(@defaults.except(:completion_model_name))
+      response = client.messages(parameters: parameters)
 
-      default_params.merge(params)
+      Langchain::LLM::AnthropicResponse.new(response)
     end
 
     # TODO: Implement token length validator for Anthropic

data/lib/langchain/llm/aws_bedrock.rb

@@ -46,7 +46,10 @@ module Langchain::LLM
       }
     }.freeze
 
+    attr_reader :client, :defaults
+
     SUPPORTED_COMPLETION_PROVIDERS = %i[anthropic cohere ai21].freeze
+    SUPPORTED_CHAT_COMPLETION_PROVIDERS = %i[anthropic].freeze
     SUPPORTED_EMBEDDING_PROVIDERS = %i[amazon].freeze
 
     def initialize(completion_model: DEFAULTS[:completion_model_name], embedding_model: DEFAULTS[:embedding_model_name], aws_client_options: {}, default_options: {})
@@ -91,6 +94,8 @@ module Langchain::LLM
     def complete(prompt:, **params)
       raise "Completion provider #{completion_provider} is not supported." unless SUPPORTED_COMPLETION_PROVIDERS.include?(completion_provider)
 
+      raise "Model #{@defaults[:completion_model_name]} only supports #chat." if @defaults[:completion_model_name].include?("claude-3")
+
       parameters = compose_parameters params
 
       parameters[:prompt] = wrap_prompt prompt
@@ -105,6 +110,53 @@ module Langchain::LLM
       parse_response response
     end
 
+    # Generate a chat completion for a given prompt
+    # Currently only configured to work with the Anthropic provider and
+    # the claude-3 model family
+    # @param messages [Array] The messages to generate a completion for
+    # @param system [String] The system prompt to provide instructions
+    # @param model [String] The model to use for completion defaults to @defaults[:chat_completion_model_name]
+    # @param max_tokens [Integer] The maximum number of tokens to generate
+    # @param stop_sequences [Array] The stop sequences to use for completion
+    # @param temperature [Float] The temperature to use for completion
+    # @param top_p [Float] The top p to use for completion
+    # @param top_k [Integer] The top k to use for completion
+    # @return [Langchain::LLM::AnthropicMessagesResponse] Response object
+    def chat(
+      messages: [],
+      system: nil,
+      model: defaults[:completion_model_name],
+      max_tokens: defaults[:max_tokens_to_sample],
+      stop_sequences: nil,
+      temperature: nil,
+      top_p: nil,
+      top_k: nil
+    )
+      raise ArgumentError.new("messages argument is required") if messages.empty?
+
+      raise "Model #{model} does not support chat completions." unless Langchain::LLM::AwsBedrock::SUPPORTED_CHAT_COMPLETION_PROVIDERS.include?(completion_provider)
+
+      inference_parameters = {
+        messages: messages,
+        max_tokens: max_tokens,
+        anthropic_version: @defaults[:anthropic_version]
+      }
+      inference_parameters[:system] = system if system
+      inference_parameters[:stop_sequences] = stop_sequences if stop_sequences
+      inference_parameters[:temperature] = temperature if temperature
+      inference_parameters[:top_p] = top_p if top_p
+      inference_parameters[:top_k] = top_k if top_k
+
+      response = client.invoke_model({
+        model_id: model,
+        body: inference_parameters.to_json,
+        content_type: "application/json",
+        accept: "application/json"
+      })
+
+      parse_response response
+    end
+
     private
 
     def completion_provider

data/lib/langchain/llm/azure.rb

@@ -4,7 +4,7 @@ module Langchain::LLM
   # LLM interface for Azure OpenAI Service APIs: https://learn.microsoft.com/en-us/azure/ai-services/openai/
   #
   # Gem requirements:
-  #    gem "ruby-openai", "~> 5.2.0"
+  #    gem "ruby-openai", "~> 6.3.0"
   #
   # Usage:
   #    openai = Langchain::LLM::Azure.new(api_key:, llm_options: {}, embedding_deployment_url: chat_deployment_url:)
@@ -34,106 +34,19 @@ module Langchain::LLM
       @defaults = DEFAULTS.merge(default_options)
     end
 
-    #
-    # Generate an embedding for a given text
-    #
-    # @param text [String] The text to generate an embedding for
-    # @param params extra parameters passed to OpenAI::Client#embeddings
-    # @return [Langchain::LLM::OpenAIResponse] Response object
-    #
-    def embed(text:, **params)
-      parameters = {model: @defaults[:embeddings_model_name], input: text}
-
-      validate_max_tokens(text, parameters[:model])
-
-      response = with_api_error_handling do
-        embed_client.embeddings(parameters: parameters.merge(params))
-      end
-
-      Langchain::LLM::OpenAIResponse.new(response)
+    def embed(...)
+      @client = @embed_client
+      super(...)
     end
 
-    #
-    # Generate a completion for a given prompt
-    #
-    # @param prompt [String] The prompt to generate a completion for
-    # @param params  extra parameters passed to OpenAI::Client#complete
-    # @return [Langchain::LLM::Response::OpenaAI] Response object
-    #
-    def complete(prompt:, **params)
-      parameters = compose_parameters @defaults[:completion_model_name], params
-
-      parameters[:messages] = compose_chat_messages(prompt: prompt)
-      parameters[:max_tokens] = validate_max_tokens(parameters[:messages], parameters[:model])
-
-      response = with_api_error_handling do
-        chat_client.chat(parameters: parameters)
-      end
-
-      Langchain::LLM::OpenAIResponse.new(response)
+    def complete(...)
+      @client = @chat_client
+      super(...)
     end
 
-    #
-    # Generate a chat completion for a given prompt or messages.
-    #
-    # == Examples
-    #
-    #     # simplest case, just give a prompt
-    #     openai.chat prompt: "When was Ruby first released?"
-    #
-    #     # prompt plus some context about how to respond
-    #     openai.chat context: "You are RubyGPT, a helpful chat bot for helping people learn Ruby", prompt: "Does Ruby have a REPL like IPython?"
-    #
-    #     # full control over messages that get sent, equivilent to the above
-    #     openai.chat messages: [
-    #       {
-    #         role: "system",
-    #         content: "You are RubyGPT, a helpful chat bot for helping people learn Ruby", prompt: "Does Ruby have a REPL like IPython?"
-    #       },
-    #       {
-    #         role: "user",
-    #         content: "When was Ruby first released?"
-    #       }
-    #     ]
-    #
-    #     # few-short prompting with examples
-    #     openai.chat prompt: "When was factory_bot released?",
-    #       examples: [
-    #         {
-    #           role: "user",
-    #           content: "When was Ruby on Rails released?"
-    #         }
-    #         {
-    #           role: "assistant",
-    #           content: "2004"
-    #         },
-    #       ]
-    #
-    # @param prompt [String] The prompt to generate a chat completion for
-    # @param messages [Array<Hash>] The messages that have been sent in the conversation
-    # @param context [String] An initial context to provide as a system message, ie "You are RubyGPT, a helpful chat bot for helping people learn Ruby"
-    # @param examples [Array<Hash>] Examples of messages to provide to the model. Useful for Few-Shot Prompting
-    # @param options [Hash] extra parameters passed to OpenAI::Client#chat
-    # @yield [Hash] Stream responses back one token at a time
-    # @return [Langchain::LLM::OpenAIResponse] Response object
-    #
-    def chat(prompt: "", messages: [], context: "", examples: [], **options, &block)
-      raise ArgumentError.new(":prompt or :messages argument is expected") if prompt.empty? && messages.empty?
-
-      parameters = compose_parameters @defaults[:chat_completion_model_name], options, &block
-      parameters[:messages] = compose_chat_messages(prompt: prompt, messages: messages, context: context, examples: examples)
-
-      if functions
-        parameters[:functions] = functions
-      else
-        parameters[:max_tokens] = validate_max_tokens(parameters[:messages], parameters[:model])
-      end
-
-      response = with_api_error_handling { chat_client.chat(parameters: parameters) }
-
-      return if block
-
-      Langchain::LLM::OpenAIResponse.new(response)
+    def chat(...)
+      @client = @chat_client
+      super(...)
     end
   end
 end

data/lib/langchain/llm/base.rb

@@ -11,6 +11,7 @@ module Langchain::LLM
   # - {Langchain::LLM::Azure}
   # - {Langchain::LLM::Cohere}
   # - {Langchain::LLM::GooglePalm}
+  # - {Langchain::LLM::GoogleVertexAi}
   # - {Langchain::LLM::HuggingFace}
   # - {Langchain::LLM::LlamaCpp}
   # - {Langchain::LLM::OpenAI}
@@ -23,8 +24,8 @@ module Langchain::LLM
     # A client for communicating with the LLM
     attr_reader :client
 
-    def default_dimension
-      self.class.const_get(:DEFAULTS).dig(:dimension)
+    def default_dimensions
+      self.class.const_get(:DEFAULTS).dig(:dimensions)
     end
 
     #

data/lib/langchain/llm/cohere.rb

@@ -15,7 +15,7 @@ module Langchain::LLM
       temperature: 0.0,
       completion_model_name: "command",
       embeddings_model_name: "small",
-      dimension: 1024,
+      dimensions: 1024,
       truncate: "START"
     }.freeze
 
@@ -62,17 +62,15 @@ module Langchain::LLM
 
       default_params.merge!(params)
 
-      default_params[:max_tokens] = Langchain::Utils::TokenLength::CohereValidator.validate_max_tokens!(prompt, default_params[:model], client)
+      default_params[:max_tokens] = Langchain::Utils::TokenLength::CohereValidator.validate_max_tokens!(prompt, default_params[:model], llm: client)
 
       response = client.generate(**default_params)
       Langchain::LLM::CohereResponse.new response, model: @defaults[:completion_model_name]
     end
 
-    # Cohere does not have a dedicated chat endpoint, so instead we call `complete()`
-    def chat(...)
-      response_text = complete(...)
-      ::Langchain::Conversation::Response.new(response_text)
-    end
+    # TODO: Implement chat method: https://github.com/andreibondarev/cohere-ruby/issues/11
+    # def chat
+    # end
 
     # Generate a summary in English for a given text
     #

data/lib/langchain/llm/google_palm.rb

@@ -13,7 +13,7 @@ module Langchain::LLM
   class GooglePalm < Base
     DEFAULTS = {
       temperature: 0.0,
-      dimension: 768, # This is what the `embedding-gecko-001` model generates
+      dimensions: 768, # This is what the `embedding-gecko-001` model generates
       completion_model_name: "text-bison-001",
       chat_completion_model_name: "chat-bison-001",
       embeddings_model_name: "embedding-gecko-001"
@@ -23,6 +23,8 @@ module Langchain::LLM
       "assistant" => "ai"
     }
 
+    attr_reader :defaults
+
     def initialize(api_key:, default_options: {})
       depends_on "google_palm_api"
 
@@ -131,7 +133,7 @@ module Langchain::LLM
         prompt: prompt,
         temperature: @defaults[:temperature],
         # Most models have a context length of 2048 tokens (except for the newest models, which support 4096).
-        max_tokens: 2048
+        max_tokens: 256
       )
     end