langchainrb 0.8.2 → 0.9.1

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", "~> 6.1.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}

data/lib/langchain/llm/cohere.rb

@@ -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

@@ -23,6 +23,8 @@ module Langchain::LLM
       "assistant" => "ai"
     }
 
+    attr_reader :defaults
+
     def initialize(api_key:, default_options: {})
       depends_on "google_palm_api"
 

data/lib/langchain/llm/google_vertex_ai.rb

@@ -21,6 +21,9 @@ module Langchain::LLM
       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
@@ -135,15 +138,14 @@ module Langchain::LLM
       )
     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"
-      #       + "}";
-      raise NotImplementedError, "coming soon for Vertex AI.."
-    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/ollama.rb

@@ -5,21 +5,26 @@ module Langchain::LLM
   # 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
 
     # 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.merge(default_options)
     end
 
     #
@@ -27,32 +32,128 @@ 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
+
+      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
+      }
+
+      parameters[:options] = llm_parameters.compact
+
+      response = ""
 
       client.post("api/generate") do |req|
-        req.body = {}
-        req.body["prompt"] = prompt
-        req.body["model"] = model_name
-
-        req.body["options"] = options if options.any?
+        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)
 
-          unless json_chunk.dig("done")
-            response.to_s << JSON.parse(chunk).dig("response")
-          end
+          response += json_chunk.dig("response")
+
+          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 +164,57 @@ 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
+
+      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
+      }
+
+      parameters[:options] = llm_parameters.compact
 
       response = client.post("api/embeddings") do |req|
-        req.body = {}
-        req.body["prompt"] = text
-        req.body["model"] = model_name
-
-        req.body["options"] = options if options.any?
+        req.body = parameters
       end
 
-      Langchain::LLM::OllamaResponse.new(response.body, model: model_name)
+      Langchain::LLM::OllamaResponse.new(response.body, model: parameters[:model])
     end
 
     private