langchainrb 0.7.5 → 0.12.0

data/lib/langchain/llm/google_vertex_ai.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Langchain::LLM
+  #
+  # Wrapper around the Google Vertex AI APIs: https://cloud.google.com/vertex-ai?hl=en
+  #
+  # Gem requirements:
+  #     gem "google-apis-aiplatform_v1", "~> 0.7"
+  #
+  # Usage:
+  #     google_palm = Langchain::LLM::GoogleVertexAi.new(project_id: ENV["GOOGLE_VERTEX_AI_PROJECT_ID"])
+  #
+  class GoogleVertexAi < Base
+    DEFAULTS = {
+      temperature: 0.1, # 0.1 is the default in the API, quite low ("grounded")
+      max_output_tokens: 1000,
+      top_p: 0.8,
+      top_k: 40,
+      dimensions: 768,
+      completion_model_name: "text-bison", # Optional: tect-bison@001
+      embeddings_model_name: "textembedding-gecko"
+    }.freeze
+
+    # TODO: Implement token length validation
+    # LENGTH_VALIDATOR = Langchain::Utils::TokenLength::...
+
+    # Google Cloud has a project id and a specific region of deployment.
+    # For GenAI-related things, a safe choice is us-central1.
+    attr_reader :project_id, :client, :region
+
+    def initialize(project_id:, default_options: {})
+      depends_on "google-apis-aiplatform_v1"
+
+      @project_id = project_id
+      @region = default_options.fetch :region, "us-central1"
+
+      @client = Google::Apis::AiplatformV1::AiplatformService.new
+
+      # TODO: Adapt for other regions; Pass it in via the constructor
+      # For the moment only us-central1 available so no big deal.
+      @client.root_url = "https://#{@region}-aiplatform.googleapis.com/"
+      @client.authorization = Google::Auth.get_application_default
+
+      @defaults = DEFAULTS.merge(default_options)
+    end
+
+    #
+    # Generate an embedding for a given text
+    #
+    # @param text [String] The text to generate an embedding for
+    # @return [Langchain::LLM::GoogleVertexAiResponse] Response object
+    #
+    def embed(text:)
+      content = [{content: text}]
+      request = Google::Apis::AiplatformV1::GoogleCloudAiplatformV1PredictRequest.new(instances: content)
+
+      api_path = "projects/#{@project_id}/locations/us-central1/publishers/google/models/#{@defaults[:embeddings_model_name]}"
+
+      # puts("api_path: #{api_path}")
+
+      response = client.predict_project_location_publisher_model(api_path, request)
+
+      Langchain::LLM::GoogleVertexAiResponse.new(response.to_h, model: @defaults[:embeddings_model_name])
+    end
+
+    #
+    # Generate a completion for a given prompt
+    #
+    # @param prompt [String] The prompt to generate a completion for
+    # @param params extra parameters passed to GooglePalmAPI::Client#generate_text
+    # @return [Langchain::LLM::GooglePalmResponse] Response object
+    #
+    def complete(prompt:, **params)
+      default_params = {
+        prompt: prompt,
+        temperature: @defaults[:temperature],
+        top_k: @defaults[:top_k],
+        top_p: @defaults[:top_p],
+        max_output_tokens: @defaults[:max_output_tokens],
+        model: @defaults[:completion_model_name]
+      }
+
+      if params[:stop_sequences]
+        default_params[:stop_sequences] = params.delete(:stop_sequences)
+      end
+
+      if params[:max_output_tokens]
+        default_params[:max_output_tokens] = params.delete(:max_output_tokens)
+      end
+
+      # to be tested
+      temperature = params.delete(:temperature) || @defaults[:temperature]
+      max_output_tokens = default_params.fetch(:max_output_tokens, @defaults[:max_output_tokens])
+
+      default_params.merge!(params)
+
+      # response = client.generate_text(**default_params)
+      request = Google::Apis::AiplatformV1::GoogleCloudAiplatformV1PredictRequest.new \
+        instances: [{
+          prompt: prompt # key used to be :content, changed to :prompt
+        }],
+        parameters: {
+          temperature: temperature,
+          maxOutputTokens: max_output_tokens,
+          topP: 0.8,
+          topK: 40
+        }
+
+      response = client.predict_project_location_publisher_model \
+        "projects/#{project_id}/locations/us-central1/publishers/google/models/#{@defaults[:completion_model_name]}",
+        request
+
+      Langchain::LLM::GoogleVertexAiResponse.new(response, model: default_params[:model])
+    end
+
+    #
+    # Generate a summarization for a given text
+    #
+    # @param text [String] The text to generate a summarization for
+    # @return [String] The summarization
+    #
+    # TODO(ricc): add params for Temp, topP, topK, MaxTokens and have it default to these 4 values.
+    def summarize(text:)
+      prompt_template = Langchain::Prompt.load_from_path(
+        file_path: Langchain.root.join("langchain/llm/prompts/summarize_template.yaml")
+      )
+      prompt = prompt_template.format(text: text)
+
+      complete(
+        prompt: prompt,
+        # For best temperature, topP, topK, MaxTokens for summarization: see
+        # https://cloud.google.com/vertex-ai/docs/samples/aiplatform-sdk-summarization
+        temperature: 0.2,
+        top_p: 0.95,
+        top_k: 40,
+        # Most models have a context length of 2048 tokens (except for the newest models, which support 4096).
+        max_output_tokens: 256
+      )
+    end
+
+    # def chat(...)
+    # https://cloud.google.com/vertex-ai/docs/samples/aiplatform-sdk-chathat
+    # Chat params: https://cloud.google.com/vertex-ai/docs/samples/aiplatform-sdk-chat
+    # \"temperature\": 0.3,\n"
+    #       + "  \"maxDecodeSteps\": 200,\n"
+    #       + "  \"topP\": 0.8,\n"
+    #       + "  \"topK\": 40\n"
+    #       + "}";
+    # end
+  end
+end

data/lib/langchain/llm/hugging_face.rb

@@ -16,7 +16,7 @@ module Langchain::LLM
     DEFAULTS = {
       temperature: 0.0,
       embeddings_model_name: "sentence-transformers/all-MiniLM-L6-v2",
-      dimension: 384 # Vector size generated by the above model
+      dimensions: 384 # Vector size generated by the above model
     }.freeze
 
     #

data/lib/langchain/llm/llama_cpp.rb

@@ -22,7 +22,7 @@ module Langchain::LLM
     # @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)
+    def initialize(model_path:, n_gpu_layers: 1, n_ctx: 2048, n_threads: 1, seed: 0)
       depends_on "llama_cpp"
 
       @model_path = model_path
@@ -33,30 +33,25 @@ module Langchain::LLM
     end
 
     # @param text [String] The text to embed
-    # @param n_threads [Integer] The number of CPU threads to use
     # @return [Array<Float>] The embedding
-    def embed(text:, n_threads: nil)
+    def embed(text:)
       # 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)
+      embedding_input = @model.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
+      context.eval(tokens: embedding_input, n_past: 0)
+      Langchain::LLM::LlamaCppResponse.new(context, model: context.model.desc)
     end
 
     # @param prompt [String] The prompt to complete
     # @param n_predict [Integer] The number of tokens to predict
-    # @param 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
+    def complete(prompt:, n_predict: 128)
       # 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)
+      ::LLaMACpp.generate(context, prompt, n_predict: n_predict)
     end
 
     private
@@ -71,23 +66,30 @@ module Langchain::LLM
 
       context_params.seed = seed
       context_params.n_ctx = n_ctx
-      context_params.n_gpu_layers = n_gpu_layers
+      context_params.n_threads = n_threads
       context_params.embedding = embeddings
 
       context_params
     end
 
+    def build_model_params
+      model_params = ::LLaMACpp::ModelParams.new
+      model_params.n_gpu_layers = n_gpu_layers
+
+      model_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))
+      @model = ::LLaMACpp::Model.new(model_path: model_path, params: build_model_params)
     end
 
     def build_completion_context
-      ::LLaMACpp::Context.new(model: build_model)
+      ::LLaMACpp::Context.new(model: build_model, params: build_context_params(embeddings: false))
     end
 
     def build_embedding_context
-      ::LLaMACpp::Context.new(model: build_model(embeddings: true))
+      ::LLaMACpp::Context.new(model: build_model, params: build_context_params(embeddings: true))
     end
 
     def completion_context

data/lib/langchain/llm/mistral_ai.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Langchain::LLM
+  # Gem requirements:
+  #    gem "mistral-ai"
+  #
+  # Usage:
+  #    llm = Langchain::LLM::MistralAI.new(api_key: ENV["MISTRAL_AI_API_KEY"])
+  class MistralAI < Base
+    DEFAULTS = {
+      chat_completion_model_name: "mistral-medium",
+      embeddings_model_name: "mistral-embed"
+    }.freeze
+
+    attr_reader :defaults
+
+    def initialize(api_key:, default_options: {})
+      depends_on "mistral-ai"
+
+      @client = Mistral.new(
+        credentials: {api_key: api_key},
+        options: {server_sent_events: true}
+      )
+
+      @defaults = DEFAULTS.merge(default_options)
+    end
+
+    def chat(
+      messages:,
+      model: defaults[:chat_completion_model_name],
+      temperature: nil,
+      top_p: nil,
+      max_tokens: nil,
+      safe_prompt: nil,
+      random_seed: nil
+    )
+      params = {
+        messages: messages,
+        model: model
+      }
+      params[:temperature] = temperature if temperature
+      params[:top_p] = top_p if top_p
+      params[:max_tokens] = max_tokens if max_tokens
+      params[:safe_prompt] = safe_prompt if safe_prompt
+      params[:random_seed] = random_seed if random_seed
+
+      response = client.chat_completions(params)
+
+      Langchain::LLM::MistralAIResponse.new(response.to_h)
+    end
+
+    def embed(
+      text:,
+      model: defaults[:embeddings_model_name],
+      encoding_format: nil
+    )
+      params = {
+        input: text,
+        model: model
+      }
+      params[:encoding_format] = encoding_format if encoding_format
+
+      response = client.embeddings(params)
+
+      Langchain::LLM::MistralAIResponse.new(response.to_h)
+    end
+  end
+end

data/lib/langchain/llm/ollama.rb

@@ -1,25 +1,52 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/hash"
+
 module Langchain::LLM
   # Interface to Ollama API.
   # Available models: https://ollama.ai/library
   #
   # Usage:
-  #    ollama = Langchain::LLM::Ollama.new(url: ENV["OLLAMA_URL"])
+  #    ollama = Langchain::LLM::Ollama.new(url: ENV["OLLAMA_URL"], default_options: {})
   #
   class Ollama < Base
-    attr_reader :url
+    attr_reader :url, :defaults
 
     DEFAULTS = {
-      temperature: 0.0,
+      temperature: 0.8,
       completion_model_name: "llama2",
-      embeddings_model_name: "llama2"
+      embeddings_model_name: "llama2",
+      chat_completion_model_name: "llama2"
+    }.freeze
+
+    EMBEDDING_SIZES = {
+      codellama: 4_096,
+      "dolphin-mixtral": 4_096,
+      llama2: 4_096,
+      llava: 4_096,
+      mistral: 4_096,
+      "mistral-openorca": 4_096,
+      mixtral: 4_096
     }.freeze
 
     # Initialize the Ollama client
     # @param url [String] The URL of the Ollama instance
-    def initialize(url:)
+    # @param default_options [Hash] The default options to use
+    #
+    def initialize(url:, default_options: {})
+      depends_on "faraday"
       @url = url
+      @defaults = DEFAULTS.deep_merge(default_options)
+    end
+
+    # Returns the # of vector dimensions for the embeddings
+    # @return [Integer] The # of vector dimensions
+    def default_dimensions
+      # since Ollama can run multiple models, look it up or generate an embedding and return the size
+      @default_dimensions ||=
+        EMBEDDING_SIZES.fetch(defaults[:embeddings_model_name].to_sym) do
+          embed(text: "test").embedding.size
+        end
     end
 
     #
@@ -27,32 +54,135 @@ module Langchain::LLM
     #
     # @param prompt [String] The prompt to complete
     # @param model [String] The model to use
-    # @param options [Hash] The options to use (https://github.com/jmorganca/ollama/blob/main/docs/modelfile.md#valid-parameters-and-values)
+    #   For a list of valid parameters and values, see:
+    #   https://github.com/jmorganca/ollama/blob/main/docs/modelfile.md#valid-parameters-and-values
     # @return [Langchain::LLM::OllamaResponse] Response object
     #
-    def complete(prompt:, model: nil, **options)
-      response = +""
+    def complete(
+      prompt:,
+      model: defaults[:completion_model_name],
+      images: nil,
+      format: nil,
+      system: nil,
+      template: nil,
+      context: nil,
+      stream: nil,
+      raw: nil,
+      mirostat: nil,
+      mirostat_eta: nil,
+      mirostat_tau: nil,
+      num_ctx: nil,
+      num_gqa: nil,
+      num_gpu: nil,
+      num_thread: nil,
+      repeat_last_n: nil,
+      repeat_penalty: nil,
+      temperature: defaults[:temperature],
+      seed: nil,
+      stop: nil,
+      tfs_z: nil,
+      num_predict: nil,
+      top_k: nil,
+      top_p: nil,
+      stop_sequences: nil,
+      &block
+    )
+      if stop_sequences
+        stop = stop_sequences
+      end
 
-      model_name = model || DEFAULTS[:completion_model_name]
+      parameters = {
+        prompt: prompt,
+        model: model,
+        images: images,
+        format: format,
+        system: system,
+        template: template,
+        context: context,
+        stream: stream,
+        raw: raw
+      }.compact
 
-      client.post("api/generate") do |req|
-        req.body = {}
-        req.body["prompt"] = prompt
-        req.body["model"] = model_name
+      llm_parameters = {
+        mirostat: mirostat,
+        mirostat_eta: mirostat_eta,
+        mirostat_tau: mirostat_tau,
+        num_ctx: num_ctx,
+        num_gqa: num_gqa,
+        num_gpu: num_gpu,
+        num_thread: num_thread,
+        repeat_last_n: repeat_last_n,
+        repeat_penalty: repeat_penalty,
+        temperature: temperature,
+        seed: seed,
+        stop: stop,
+        tfs_z: tfs_z,
+        num_predict: num_predict,
+        top_k: top_k,
+        top_p: top_p
+      }
 
-        req.body["options"] = options if options.any?
+      parameters[:options] = llm_parameters.compact
+
+      response = ""
+
+      client.post("api/generate") do |req|
+        req.body = parameters
 
-        # TODO: Implement streaming support when a &block is passed in
         req.options.on_data = proc do |chunk, size|
-          json_chunk = JSON.parse(chunk)
+          chunk.split("\n").each do |line_chunk|
+            json_chunk = begin
+              JSON.parse(line_chunk)
+            # In some instance the chunk exceeds the buffer size and the JSON parser fails
+            rescue JSON::ParserError
+              nil
+            end
 
-          unless json_chunk.dig("done")
-            response.to_s << JSON.parse(chunk).dig("response")
+            response += json_chunk.dig("response") unless json_chunk.blank?
           end
+
+          yield json_chunk, size if block
         end
       end
 
-      Langchain::LLM::OllamaResponse.new(response, model: model_name)
+      Langchain::LLM::OllamaResponse.new(response, model: parameters[:model])
+    end
+
+    # Generate a chat completion
+    #
+    # @param model [String] Model name
+    # @param messages [Array<Hash>] Array of messages
+    # @param format [String] Format to return a response in. Currently the only accepted value is `json`
+    # @param temperature [Float] The temperature to use
+    # @param template [String] The prompt template to use (overrides what is defined in the `Modelfile`)
+    # @param stream [Boolean] Streaming the response. If false the response will be returned as a single response object, rather than a stream of objects
+    #
+    # The message object has the following fields:
+    #   role: the role of the message, either system, user or assistant
+    #   content: the content of the message
+    #   images (optional): a list of images to include in the message (for multimodal models such as llava)
+    def chat(
+      model: defaults[:chat_completion_model_name],
+      messages: [],
+      format: nil,
+      temperature: defaults[:temperature],
+      template: nil,
+      stream: false # TODO: Fix streaming.
+    )
+      parameters = {
+        model: model,
+        messages: messages,
+        format: format,
+        temperature: temperature,
+        template: template,
+        stream: stream
+      }.compact
+
+      response = client.post("api/chat") do |req|
+        req.body = parameters
+      end
+
+      Langchain::LLM::OllamaResponse.new(response.body, model: parameters[:model])
     end
 
     #
@@ -63,18 +193,70 @@ module Langchain::LLM
     # @param options [Hash] The options to use
     # @return [Langchain::LLM::OllamaResponse] Response object
     #
-    def embed(text:, model: nil, **options)
-      model_name = model || DEFAULTS[:embeddings_model_name]
+    def embed(
+      text:,
+      model: defaults[:embeddings_model_name],
+      mirostat: nil,
+      mirostat_eta: nil,
+      mirostat_tau: nil,
+      num_ctx: nil,
+      num_gqa: nil,
+      num_gpu: nil,
+      num_thread: nil,
+      repeat_last_n: nil,
+      repeat_penalty: nil,
+      temperature: defaults[:temperature],
+      seed: nil,
+      stop: nil,
+      tfs_z: nil,
+      num_predict: nil,
+      top_k: nil,
+      top_p: nil
+    )
+      parameters = {
+        prompt: text,
+        model: model
+      }.compact
 
-      response = client.post("api/embeddings") do |req|
-        req.body = {}
-        req.body["prompt"] = text
-        req.body["model"] = model_name
+      llm_parameters = {
+        mirostat: mirostat,
+        mirostat_eta: mirostat_eta,
+        mirostat_tau: mirostat_tau,
+        num_ctx: num_ctx,
+        num_gqa: num_gqa,
+        num_gpu: num_gpu,
+        num_thread: num_thread,
+        repeat_last_n: repeat_last_n,
+        repeat_penalty: repeat_penalty,
+        temperature: temperature,
+        seed: seed,
+        stop: stop,
+        tfs_z: tfs_z,
+        num_predict: num_predict,
+        top_k: top_k,
+        top_p: top_p
+      }
 
-        req.body["options"] = options if options.any?
+      parameters[:options] = llm_parameters.compact
+
+      response = client.post("api/embeddings") do |req|
+        req.body = parameters
       end
 
-      Langchain::LLM::OllamaResponse.new(response.body, model: model_name)
+      Langchain::LLM::OllamaResponse.new(response.body, model: parameters[:model])
+    end
+
+    # Generate a summary for a given text
+    #
+    # @param text [String] The text to generate a summary for
+    # @return [String] The summary
+    def summarize(text:)
+      prompt_template = Langchain::Prompt.load_from_path(
+        file_path: Langchain.root.join("langchain/llm/prompts/ollama/summarize_template.yaml")
+      )
+      prompt = prompt_template.format(text: text)
+
+      complete(prompt: prompt)
     end
 
     private