langchainrb 0.16.0 → 0.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f685910b0f3f1816c3822debc2ec470d72d85203b2695ab8ab780b5d0f1cb09
-  data.tar.gz: 7ec406ad7980e12739aa70e9710b21e1f7df0a1e46f66820d7003026e3bbc877
+  metadata.gz: b078089a99e9e8d6654a244165ecc9d0f3dfdd8fbc0367623d41fe771a98ac41
+  data.tar.gz: 890c371564ce9188087bed9eb053a59e11f7b734a44b9f753696f8458f8a7b7e
 SHA512:
-  metadata.gz: 1145ffbab814f09acb539df3662f0c4c5536ded25252a4db3e640d29cc550930b11ac9310b11436d591e1ec13449af59f125bdab3fe463f9a59683ea9d8f38ed
-  data.tar.gz: d9e76d70f24f964b3f17addda08ace46695149af48c7bd4aff1936a10888640f9cb222bef15bdb205ad7997028f88c81142dcb3ef49d96fcd37682c56409f4c6
+  metadata.gz: 8f458bfae5af31190f41661a13c24e5cd63d5f88e594e854ee79ea3b8af1f51b20552f178c89c71e454a86e4d827b3facecd97f0fa3ef107b7b6097754fab5e3
+  data.tar.gz: cfe0c684f89c5eef73ceb26b70292fe8fc4f941e13795ac98bd1d3197321a1303250d2584f9e45aa530e311304004911ffe3a6af7f606f6a733baad21ff2b814

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.16.1] - 2024-09-30
+- Deprecate Langchain::LLM::GooglePalm
+- Allow setting response_object: {} parameter when initializing supported Langchain::LLM::* classes
+- Simplify and consolidate logging for some of the LLM providers (namely OpenAI and Google). Now most of the HTTP requests are being logged when on DEBUG level
+- Improve doc on how to set up a custom logger with a custom destination
+
 ## [0.16.0] - 2024-09-19
 - Remove `Langchain::Thread` class as it was not needed.
 - Support `cohere` provider for `Langchain::LLM::AwsBedrock#embed`

data/README.md

@@ -21,7 +21,7 @@ Available for paid consulting engagements! [Email me](mailto:andrei@sourcelabs.i
 
 - [Installation](#installation)
 - [Usage](#usage)
-- [Large Language Models (LLMs)](#large-language-models-llms)
+- [Unified Interface for LLMs](#unified-interface-for-llms)
 - [Prompt Management](#prompt-management)
 - [Output Parsers](#output-parsers)
 - [Building RAG](#building-retrieval-augment-generation-rag-system)
@@ -51,61 +51,139 @@ Additional gems may be required. They're not included by default so you can incl
 require "langchain"
 ```
 
-## Large Language Models (LLMs)
-Langchain.rb wraps supported LLMs in a unified interface allowing you to easily swap out and test out different models.
+# Unified Interface for LLMs
 
-#### Supported LLMs and features:
-| LLM providers                                                                                   | `embed()`          | `complete()`       | `chat()`            | `summarize()`      | Notes              |
-| --------                                                                                        |:------------------:| :-------:          | :-----------------: | :-------:          | :----------------- |
-| [OpenAI](https://openai.com/?utm_source=langchainrb&utm_medium=github)                          | ✅                 | ✅                 | ✅                  | ✅                 | Including Azure OpenAI |
-| [AI21](https://ai21.com/?utm_source=langchainrb&utm_medium=github)                              | ❌                 | ✅                 | ❌                  | ✅                 |                    |
-| [Anthropic](https://anthropic.com/?utm_source=langchainrb&utm_medium=github)                    | ❌                 | ✅                 | ✅                  | ❌                 |                    |
-| [AwsBedrock](https://aws.amazon.com/bedrock?utm_source=langchainrb&utm_medium=github)          | ✅                 | ✅                 | ✅                  | ❌                 | Provides AWS, Cohere, AI21, Antropic and Stability AI models |
-| [Cohere](https://cohere.com/?utm_source=langchainrb&utm_medium=github)                          | ✅                 | ✅                 | ✅                  | ✅                 |                    |
-| [GooglePalm](https://ai.google/discover/palm2?utm_source=langchainrb&utm_medium=github)         | ✅                 | ✅                 | ✅                  | ✅                 |                    |
-| [GoogleVertexAI](https://cloud.google.com/vertex-ai?utm_source=langchainrb&utm_medium=github) | ✅                 | ❌                 | ✅                  | ❌                 | Requires Google Cloud service auth                   |
-| [GoogleGemini](https://cloud.google.com/vertex-ai?utm_source=langchainrb&utm_medium=github) | ✅                 | ❌                 | ✅                  | ❌                 | Requires Gemini API Key ([get key](https://ai.google.dev/gemini-api/docs/api-key)) |
-| [HuggingFace](https://huggingface.co/?utm_source=langchainrb&utm_medium=github)                 | ✅                 | ❌                 | ❌                  | ❌                 |                    |
-| [MistralAI](https://mistral.ai/?utm_source=langchainrb&utm_medium=github)                      | ✅                 | ❌                 | ✅                  | ❌                 |                    |
-| [Ollama](https://ollama.ai/?utm_source=langchainrb&utm_medium=github)                           | ✅                 | ✅                 | ✅                  | ✅                 |                    |
-| [Replicate](https://replicate.com/?utm_source=langchainrb&utm_medium=github)                    | ✅                 | ✅                 | ✅                  | ✅                 |                    |
+The `Langchain::LLM` module provides a unified interface for interacting with various Large Language Model (LLM) providers. This abstraction allows you to easily switch between different LLM backends without changing your application code.
 
+## Supported LLM Providers
 
+- AI21
+- Anthropic
+- AWS Bedrock
+- Azure OpenAI
+- Cohere
+- Google Gemini
+- Google PaLM (deprecated)
+- Google Vertex AI
+- HuggingFace
+- LlamaCpp
+- Mistral AI
+- Ollama
+- OpenAI
+- Replicate
 
-#### Using standalone LLMs:
+## Usage
 
-#### OpenAI
+All LLM classes inherit from `Langchain::LLM::Base` and provide a consistent interface for common operations:
 
-Add `gem "ruby-openai", "~> 6.3.0"` to your Gemfile.
+1. Generating embeddings
+2. Generating prompt completions
+3. Generating chat completions
+
+### Initialization
+
+Most LLM classes can be initialized with an API key and optional default options:
 
 ```ruby
-llm = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"])
-```
-You can pass additional parameters to the constructor, it will be passed to the OpenAI client:
-```ruby
-llm = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"], llm_options: { ... })
+llm = Langchain::LLM::OpenAI.new(
+  api_key: ENV["OPENAI_API_KEY"],
+  default_options: { temperature: 0.7, chat_completion_model_name: "gpt-4o" }
+)
 ```
 
-Generate vector embeddings:
+### Generating Embeddings
+
+Use the `embed` method to generate embeddings for given text:
+
 ```ruby
-llm.embed(text: "foo bar").embedding
+response = llm.embed(text: "Hello, world!")
+embedding = response.embedding
 ```
 
-Generate a chat completion:
+#### Accepted parameters for `embed()`
+
+- `text`: (Required) The input text to embed.
+- `model`: (Optional) The model name to use or default embedding model will be used.
+
+### Prompt completions
+
+Use the `complete` method to generate completions for a given prompt:
+
 ```ruby
-llm.chat(messages: [{role: "user", content: "What is the meaning of life?"}]).completion
+response = llm.complete(prompt: "Once upon a time")
+completion = response.completion
 ```
 
-Summarize the text:
+#### Accepted parameters for `complete()`
+
+- `prompt`: (Required) The input prompt for completion.
+- `max_tokens`: (Optional) The maximum number of tokens to generate.
+- `temperature`: (Optional) Controls randomness in generation. Higher values (e.g., 0.8) make output more random, while lower values (e.g., 0.2) make it more deterministic.
+- `top_p`: (Optional) An alternative to temperature, controls diversity of generated tokens.
+- `n`: (Optional) Number of completions to generate for each prompt.
+- `stop`: (Optional) Sequences where the API will stop generating further tokens.
+- `presence_penalty`: (Optional) Penalizes new tokens based on their presence in the text so far.
+- `frequency_penalty`: (Optional) Penalizes new tokens based on their frequency in the text so far.
+
+### Generating Chat Completions
+
+Use the `chat` method to generate chat completions:
+
 ```ruby
-llm.summarize(text: "...").completion
+messages = [
+  { role: "system", content: "You are a helpful assistant." },
+  { role: "user", content: "What's the weather like today?" }
+]
+response = llm.chat(messages: messages)
+chat_completion = response.chat_completion
 ```
 
-You can use any other LLM by invoking the same interface:
+#### Accepted parameters for `chat()`
+
+- `messages`: (Required) An array of message objects representing the conversation history.
+- `model`: (Optional) The specific chat model to use.
+- `temperature`: (Optional) Controls randomness in generation.
+- `top_p`: (Optional) An alternative to temperature, controls diversity of generated tokens.
+- `n`: (Optional) Number of chat completion choices to generate.
+- `max_tokens`: (Optional) The maximum number of tokens to generate in the chat completion.
+- `stop`: (Optional) Sequences where the API will stop generating further tokens.
+- `presence_penalty`: (Optional) Penalizes new tokens based on their presence in the text so far.
+- `frequency_penalty`: (Optional) Penalizes new tokens based on their frequency in the text so far.
+- `logit_bias`: (Optional) Modifies the likelihood of specified tokens appearing in the completion.
+- `user`: (Optional) A unique identifier representing your end-user.
+- `tools`: (Optional) A list of tools the model may call.
+- `tool_choice`: (Optional) Controls how the model calls functions.
+
+## Switching LLM Providers
+
+Thanks to the unified interface, you can easily switch between different LLM providers by changing the class you instantiate:
+
 ```ruby
-llm = Langchain::LLM::GooglePalm.new(api_key: ENV["GOOGLE_PALM_API_KEY"], default_options: { ... })
+# Using Anthropic
+anthropic_llm = Langchain::LLM::Anthropic.new(api_key: ENV["ANTHROPIC_API_KEY"])
+
+# Using Google Gemini
+gemini_llm = Langchain::LLM::GoogleGemini.new(api_key: ENV["GOOGLE_GEMINI_API_KEY"])
+
+# Using OpenAI
+openai_llm = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"])
 ```
 
+## Response Objects
+
+Each LLM method returns a response object that provides a consistent interface for accessing the results:
+
+- `embedding`: Returns the embedding vector
+- `completion`: Returns the generated text completion
+- `chat_completion`: Returns the generated chat completion
+- `tool_calls`: Returns tool calls made by the LLM
+- `prompt_tokens`: Returns the number of tokens in the prompt
+- `completion_tokens`: Returns the number of tokens in the completion
+- `total_tokens`: Returns the total number of tokens used
+
+> [!NOTE]
+> While the core interface is consistent across providers, some LLMs may offer additional features or parameters. Consult the documentation for each LLM class to learn about provider-specific capabilities and options.
+
 ### Prompt Management
 
 #### Prompt Templates
@@ -427,7 +505,19 @@ assistant.add_message_and_run!(content: "What's the latest news about AI?")
 messages = assistant.messages
 
 # Run the assistant with automatic tool execution
-assistant.run!
+assistant.run(auto_tool_execution: true)
+
+# If you want to stream the response, you can add a response handler
+assistant = Langchain::Assistant.new(
+  llm: llm,
+  instructions: "You're a helpful AI assistant",
+  tools: [Langchain::Tool::NewsRetriever.new(api_key: ENV["NEWS_API_KEY"])]
+) do |response_chunk|
+  # ...handle the response stream
+  # print(response_chunk.inspect)
+end
+assistant.add_message(content: "Hello")
+assistant.run(auto_tool_execution: true)
 ```
 
 ### Configuration
@@ -536,11 +626,18 @@ Additional examples available: [/examples](https://github.com/andreibondarev/lan
 
 ## Logging
 
-Langchain.rb uses standard logging mechanisms and defaults to `:warn` level. Most messages are at info level, but we will add debug or warn statements as needed.
+Langchain.rb uses the standard Ruby [Logger](https://ruby-doc.org/stdlib-2.4.0/libdoc/logger/rdoc/Logger.html) mechanism and defaults to same `level` value (currently `Logger::DEBUG`).
+
 To show all log messages:
 
 ```ruby
-Langchain.logger.level = :debug
+Langchain.logger.level = Logger::DEBUG
+```
+
+The logger logs to `STDOUT` by default. In order to configure the log destination (ie. log to a file) do:
+
+```ruby
+Langchain.logger = Logger.new("path/to/file", **Langchain::LOGGER_OPTIONS)
 ```
 
 ## Problems

data/lib/langchain/assistants/assistant.rb

@@ -29,7 +29,8 @@ module Langchain
       instructions: nil,
       tool_choice: "auto",
       messages: [],
-      add_message_callback: nil
+      add_message_callback: nil,
+      &block
     )
       unless tools.is_a?(Array) && tools.all? { |tool| tool.class.singleton_class.included_modules.include?(Langchain::ToolDefinition) }
         raise ArgumentError, "Tools must be an array of objects extending Langchain::ToolDefinition"
@@ -48,6 +49,7 @@ module Langchain
       @tools = tools
       self.tool_choice = tool_choice
       @instructions = instructions
+      @block = block
       @state = :ready
 
       @total_prompt_tokens = 0
@@ -120,7 +122,7 @@ module Langchain
     # @return [Array<Langchain::Message>] The messages
     def run(auto_tool_execution: false)
       if messages.empty?
-        Langchain.logger.warn("No messages to process")
+        Langchain.logger.warn("#{self.class} - No messages to process")
         @state = :completed
         return
       end
@@ -270,7 +272,7 @@ module Langchain
     #
     # @return [Symbol] The completed state
     def handle_system_message
-      Langchain.logger.warn("At least one user message is required after a system message")
+      Langchain.logger.warn("#{self.class} - At least one user message is required after a system message")
       :completed
     end
 
@@ -285,7 +287,7 @@ module Langchain
     #
     # @return [Symbol] The failed state
     def handle_unexpected_message
-      Langchain.logger.error("Unexpected message role encountered: #{messages.last.standard_role}")
+      Langchain.logger.error("#{self.class} - Unexpected message role encountered: #{messages.last.standard_role}")
       :failed
     end
 
@@ -309,7 +311,7 @@ module Langchain
       elsif response.completion # Currently only used by Ollama
         :completed
       else
-        Langchain.logger.error("LLM response does not contain tool calls, chat or completion response")
+        Langchain.logger.error("#{self.class} - LLM response does not contain tool calls, chat or completion response")
         :failed
       end
     end
@@ -321,7 +323,7 @@ module Langchain
       run_tools(messages.last.tool_calls)
       :in_progress
     rescue => e
-      Langchain.logger.error("Error running tools: #{e.message}; #{e.backtrace.join('\n')}")
+      Langchain.logger.error("#{self.class} - Error running tools: #{e.message}; #{e.backtrace.join('\n')}")
       :failed
     end
 
@@ -353,7 +355,7 @@ module Langchain
     #
     # @return [Langchain::LLM::BaseResponse] The LLM response object
     def chat_with_llm
-      Langchain.logger.info("Sending a call to #{llm.class}", for: self.class)
+      Langchain.logger.debug("#{self.class} - Sending a call to #{llm.class}")
 
       params = @llm_adapter.build_chat_params(
         instructions: @instructions,
@@ -361,7 +363,7 @@ module Langchain
         tools: @tools,
         tool_choice: tool_choice
       )
-      @llm.chat(**params)
+      @llm.chat(**params, &@block)
     end
 
     # Run the tools automatically

data/lib/langchain/llm/azure.rb

@@ -38,7 +38,8 @@ module Langchain::LLM
         top_logprobs: {},
         n: {default: @defaults[:n]},
         temperature: {default: @defaults[:temperature]},
-        user: {}
+        user: {},
+        response_format: {default: @defaults[:response_format]}
       )
       chat_parameters.ignore(:top_k)
     end

data/lib/langchain/llm/base.rb

@@ -24,7 +24,10 @@ module Langchain::LLM
     include Langchain::DependencyHelper
 
     # A client for communicating with the LLM
-    attr_reader :client
+    attr_accessor :client
+
+    # Default LLM options. Can be overridden by passing `default_options: {}` to the Langchain::LLM::* constructors.
+    attr_reader :defaults
 
     # Ensuring backward compatibility after https://github.com/patterns-ai-core/langchainrb/pull/586
     # TODO: Delete this method later

data/lib/langchain/llm/cohere.rb

@@ -27,7 +27,8 @@ module Langchain::LLM
       @defaults = DEFAULTS.merge(default_options)
       chat_parameters.update(
         model: {default: @defaults[:chat_completion_model_name]},
-        temperature: {default: @defaults[:temperature]}
+        temperature: {default: @defaults[:temperature]},
+        response_format: {default: @defaults[:response_format]}
       )
       chat_parameters.remap(
         system: :preamble,
@@ -97,6 +98,10 @@ module Langchain::LLM
 
       parameters = chat_parameters.to_params(params)
 
+      # Cohere API requires `message:` parameter to be sent separately from `chat_history:`.
+      # We extract the last message from the messages param.
+      parameters[:message] = parameters[:chat_history].pop&.dig(:message)
+
       response = client.chat(**parameters)
 
       Langchain::LLM::CohereResponse.new(response)

data/lib/langchain/llm/google_gemini.rb

@@ -59,15 +59,7 @@ module Langchain::LLM
 
       uri = URI("https://generativelanguage.googleapis.com/v1beta/models/#{parameters[:model]}:generateContent?key=#{api_key}")
 
-      request = Net::HTTP::Post.new(uri)
-      request.content_type = "application/json"
-      request.body = parameters.to_json
-
-      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
-        http.request(request)
-      end
-
-      parsed_response = JSON.parse(response.body)
+      parsed_response = http_post(uri, parameters)
 
       wrapped_response = Langchain::LLM::GoogleGeminiResponse.new(parsed_response, model: parameters[:model])
 
@@ -95,17 +87,25 @@ module Langchain::LLM
 
       uri = URI("https://generativelanguage.googleapis.com/v1beta/models/#{model}:embedContent?key=#{api_key}")
 
-      request = Net::HTTP::Post.new(uri)
+      parsed_response = http_post(uri, params)
+
+      Langchain::LLM::GoogleGeminiResponse.new(parsed_response, model: model)
+    end
+
+    private
+
+    def http_post(url, params)
+      http = Net::HTTP.new(url.hostname, url.port)
+      http.use_ssl = url.scheme == "https"
+      http.set_debug_output(Langchain.logger) if Langchain.logger.debug?
+
+      request = Net::HTTP::Post.new(url)
       request.content_type = "application/json"
       request.body = params.to_json
 
-      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
-        http.request(request)
-      end
-
-      parsed_response = JSON.parse(response.body)
+      response = http.request(request)
 
-      Langchain::LLM::GoogleGeminiResponse.new(parsed_response, model: model)
+      JSON.parse(response.body)
     end
   end
 end

data/lib/langchain/llm/google_palm.rb

@@ -11,6 +11,8 @@ module Langchain::LLM
   #     google_palm = Langchain::LLM::GooglePalm.new(api_key: ENV["GOOGLE_PALM_API_KEY"])
   #
   class GooglePalm < Base
+    extend Gem::Deprecate
+
     DEFAULTS = {
       temperature: 0.0,
       dimensions: 768, # This is what the `embedding-gecko-001` model generates
@@ -25,12 +27,16 @@ module Langchain::LLM
 
     attr_reader :defaults
 
+    # @deprecated Please use Langchain::LLM::GoogleGemini instead
+    #
+    # @param api_key [String] The API key for the Google PaLM API
     def initialize(api_key:, default_options: {})
       depends_on "google_palm_api"
 
       @client = ::GooglePalmApi::Client.new(api_key: api_key)
       @defaults = DEFAULTS.merge(default_options)
     end
+    deprecate :initialize, "Langchain::LLM::GoogleGemini.new(api_key:)", 2024, 10
 
     #
     # Generate an embedding for a given text

data/lib/langchain/llm/google_vertex_ai.rb

@@ -63,16 +63,7 @@ module Langchain::LLM
 
       uri = URI("#{url}#{model}:predict")
 
-      request = Net::HTTP::Post.new(uri)
-      request.content_type = "application/json"
-      request["Authorization"] = "Bearer #{@authorizer.fetch_access_token!["access_token"]}"
-      request.body = params.to_json
-
-      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
-        http.request(request)
-      end
-
-      parsed_response = JSON.parse(response.body)
+      parsed_response = http_post(uri, params)
 
       Langchain::LLM::GoogleGeminiResponse.new(parsed_response, model: model)
     end
@@ -96,16 +87,7 @@ module Langchain::LLM
 
       uri = URI("#{url}#{parameters[:model]}:generateContent")
 
-      request = Net::HTTP::Post.new(uri)
-      request.content_type = "application/json"
-      request["Authorization"] = "Bearer #{@authorizer.fetch_access_token!["access_token"]}"
-      request.body = parameters.to_json
-
-      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
-        http.request(request)
-      end
-
-      parsed_response = JSON.parse(response.body)
+      parsed_response = http_post(uri, parameters)
 
       wrapped_response = Langchain::LLM::GoogleGeminiResponse.new(parsed_response, model: parameters[:model])
 
@@ -115,5 +97,22 @@ module Langchain::LLM
         raise StandardError.new(parsed_response)
       end
     end
+
+    private
+
+    def http_post(url, params)
+      http = Net::HTTP.new(url.hostname, url.port)
+      http.use_ssl = url.scheme == "https"
+      http.set_debug_output(Langchain.logger) if Langchain.logger.debug?
+
+      request = Net::HTTP::Post.new(url)
+      request.content_type = "application/json"
+      request["Authorization"] = "Bearer #{@authorizer.fetch_access_token!["access_token"]}"
+      request.body = params.to_json
+
+      response = http.request(request)
+
+      JSON.parse(response.body)
+    end
   end
 end

data/lib/langchain/llm/mistral_ai.rb

@@ -26,7 +26,9 @@ module Langchain::LLM
       chat_parameters.update(
         model: {default: @defaults[:chat_completion_model_name]},
         n: {default: @defaults[:n]},
-        safe_prompt: {}
+        safe_prompt: {},
+        temperature: {default: @defaults[:temperature]},
+        response_format: {default: @defaults[:response_format]}
       )
       chat_parameters.remap(seed: :random_seed)
       chat_parameters.ignore(:n, :top_k)

data/lib/langchain/llm/ollama.rb

@@ -45,7 +45,8 @@ module Langchain::LLM
         model: {default: @defaults[:chat_completion_model_name]},
         temperature: {default: @defaults[:temperature]},
         template: {},
-        stream: {default: false}
+        stream: {default: false},
+        response_format: {default: @defaults[:response_format]}
       )
       chat_parameters.remap(response_format: :format)
     end
@@ -149,7 +150,7 @@ module Langchain::LLM
         end
       end
 
-      generate_final_completion_response(responses_stream, parameters)
+      generate_final_completion_response(responses_stream, parameters[:model])
     end
 
     # Generate a chat completion
@@ -186,7 +187,7 @@ module Langchain::LLM
         end
       end
 
-      generate_final_chat_completion_response(responses_stream, parameters)
+      generate_final_chat_completion_response(responses_stream, parameters[:model])
     end
 
     #
@@ -289,20 +290,20 @@ module Langchain::LLM
       end
     end
 
-    def generate_final_completion_response(responses_stream, parameters)
+    def generate_final_completion_response(responses_stream, model)
       final_response = responses_stream.last.merge(
         "response" => responses_stream.map { |resp| resp["response"] }.join
       )
 
-      OllamaResponse.new(final_response, model: parameters[:model])
+      OllamaResponse.new(final_response, model: model)
     end
 
     # BUG: If streamed, this method does not currently return the tool_calls response.
-    def generate_final_chat_completion_response(responses_stream, parameters)
+    def generate_final_chat_completion_response(responses_stream, model)
       final_response = responses_stream.last
       final_response["message"]["content"] = responses_stream.map { |resp| resp.dig("message", "content") }.join
 
-      OllamaResponse.new(final_response, model: parameters[:model])
+      OllamaResponse.new(final_response, model: model)
     end
   end
 end

data/lib/langchain/llm/openai.rb

@@ -26,8 +26,6 @@ module Langchain::LLM
       "text-embedding-3-small" => 1536
     }.freeze
 
-    attr_reader :defaults
-
     # Initialize an OpenAI LLM instance
     #
     # @param api_key [String] The API key to use
@@ -35,7 +33,11 @@ module Langchain::LLM
     def initialize(api_key:, llm_options: {}, default_options: {})
       depends_on "ruby-openai", req: "openai"
 
-      @client = ::OpenAI::Client.new(access_token: api_key, **llm_options)
+      llm_options[:log_errors] = Langchain.logger.debug? unless llm_options.key?(:log_errors)
+
+      @client = ::OpenAI::Client.new(access_token: api_key, **llm_options) do |f|
+        f.response :logger, Langchain.logger, {headers: true, bodies: true, errors: true}
+      end
 
       @defaults = DEFAULTS.merge(default_options)
       chat_parameters.update(
@@ -44,7 +46,8 @@ module Langchain::LLM
         top_logprobs: {},
         n: {default: @defaults[:n]},
         temperature: {default: @defaults[:temperature]},
-        user: {}
+        user: {},
+        response_format: {default: @defaults[:response_format]}
       )
       chat_parameters.ignore(:top_k)
     end
@@ -122,11 +125,11 @@ module Langchain::LLM
         raise ArgumentError.new("'tool_choice' is only allowed when 'tools' are specified.")
       end
 
-      # TODO: Clean this part up
       if block
         @response_chunks = []
+        parameters[:stream_options] = {include_usage: true}
         parameters[:stream] = proc do |chunk, _bytesize|
-          chunk_content = chunk.dig("choices", 0)
+          chunk_content = chunk.dig("choices", 0) || {}
           @response_chunks << chunk
           yield chunk_content
         end
@@ -177,7 +180,9 @@ module Langchain::LLM
     end
 
     def response_from_chunks
-      grouped_chunks = @response_chunks.group_by { |chunk| chunk.dig("choices", 0, "index") }
+      grouped_chunks = @response_chunks
+        .group_by { |chunk| chunk.dig("choices", 0, "index") }
+        .except(nil) # the last chunk (that contains the token usage) has no index
       final_choices = grouped_chunks.map do |index, chunks|
         {
           "index" => index,
@@ -189,7 +194,7 @@ module Langchain::LLM
           "finish_reason" => chunks.last.dig("choices", 0, "finish_reason")
         }
       end
-      @response_chunks.first&.slice("id", "object", "created", "model")&.merge({"choices" => final_choices})
+      @response_chunks.first&.slice("id", "object", "created", "model")&.merge({"choices" => final_choices, "usage" => @response_chunks.last["usage"]})
     end
 
     def tool_calls_from_choice_chunks(choice_chunks)

data/lib/langchain/prompt/loading.rb

@@ -79,7 +79,7 @@ module Langchain::Prompt
       def load_from_config(config)
         # If `_type` key is not present in the configuration hash, add it with a default value of `prompt`
         unless config.key?("_type")
-          Langchain.logger.warn "No `_type` key found, defaulting to `prompt`"
+          Langchain.logger.warn("#{self.class} - No `_type` key found, defaulting to `prompt`")
           config["_type"] = "prompt"
         end
 

data/lib/langchain/tool/calculator.rb

@@ -28,7 +28,7 @@ module Langchain::Tool
     # @param input [String] math expression
     # @return [String] Answer
     def execute(input:)
-      Langchain.logger.info("Executing \"#{input}\"", for: self.class)
+      Langchain.logger.debug("#{self.class} - Executing \"#{input}\"")
 
       Eqn::Calculator.calc(input)
     rescue Eqn::ParseError, Eqn::NoVariableValueError

data/lib/langchain/tool/database.rb

@@ -61,7 +61,7 @@ module Langchain::Tool
     def describe_tables(tables: [])
       return "No tables specified" if tables.empty?
 
-      Langchain.logger.info("Describing tables: #{tables}", for: self.class)
+      Langchain.logger.debug("#{self.class} - Describing tables: #{tables}")
 
       tables
         .map do |table|
@@ -74,7 +74,7 @@ module Langchain::Tool
     #
     # @return [String] Database schema
     def dump_schema
-      Langchain.logger.info("Dumping schema tables and keys", for: self.class)
+      Langchain.logger.debug("#{self.class} - Dumping schema tables and keys")
 
       schemas = db.tables.map do |table|
         describe_table(table)
@@ -87,11 +87,11 @@ module Langchain::Tool
     # @param input [String] SQL query to be executed
     # @return [Array] Results from the SQL query
     def execute(input:)
-      Langchain.logger.info("Executing \"#{input}\"", for: self.class)
+      Langchain.logger.debug("#{self.class} - Executing \"#{input}\"")
 
       db[input].to_a
     rescue Sequel::DatabaseError => e
-      Langchain.logger.error(e.message, for: self.class)
+      Langchain.logger.error("#{self.class} - #{e.message}")
       e.message # Return error to LLM
     end
 

data/lib/langchain/tool/google_search.rb

@@ -38,7 +38,7 @@ module Langchain::Tool
     # @param input [String] search query
     # @return [String] Answer
     def execute(input:)
-      Langchain.logger.info("Executing \"#{input}\"", for: self.class)
+      Langchain.logger.debug("#{self.class} - Executing \"#{input}\"")
 
       results = execute_search(input: input)
 

data/lib/langchain/tool/news_retriever.rb

@@ -71,7 +71,7 @@ module Langchain::Tool
       page_size: 5, # The API default is 20 but that's too many.
       page: nil
     )
-      Langchain.logger.info("Retrieving all news", for: self.class)
+      Langchain.logger.debug("#{self.class} - Retrieving all news")
 
       params = {apiKey: @api_key}
       params[:q] = q if q
@@ -107,7 +107,7 @@ module Langchain::Tool
       page_size: 5,
       page: nil
     )
-      Langchain.logger.info("Retrieving top news headlines", for: self.class)
+      Langchain.logger.debug("#{self.class} - Retrieving top news headlines")
 
       params = {apiKey: @api_key}
       params[:country] = country if country
@@ -132,7 +132,7 @@ module Langchain::Tool
       language: nil,
       country: nil
     )
-      Langchain.logger.info("Retrieving news sources", for: self.class)
+      Langchain.logger.debug("#{self.class} - Retrieving news sources")
 
       params = {apiKey: @api_key}
       params[:country] = country if country

data/lib/langchain/tool/ruby_code_interpreter.rb

@@ -29,7 +29,7 @@ module Langchain::Tool
     # @param input [String] ruby code expression
     # @return [String] Answer
     def execute(input:)
-      Langchain.logger.info("Executing \"#{input}\"", for: self.class)
+      Langchain.logger.debug("#{self.class} - Executing \"#{input}\"")
 
       safe_eval(input)
     end

data/lib/langchain/tool/weather.rb

@@ -44,7 +44,7 @@ module Langchain::Tool
     def get_current_weather(city:, state_code:, country_code: nil, units: "imperial")
       validate_input(city: city, state_code: state_code, country_code: country_code, units: units)
 
-      Langchain.logger.info("get_current_weather", for: self.class, city:, state_code:, country_code:, units:)
+      Langchain.logger.debug("#{self.class} - get_current_weather #{{city:, state_code:, country_code:, units:}}")
 
       fetch_current_weather(city: city, state_code: state_code, country_code: country_code, units: units)
     end
@@ -74,9 +74,9 @@ module Langchain::Tool
       request = Net::HTTP::Get.new(uri.request_uri)
       request["Content-Type"] = "application/json"
 
-      Langchain.logger.info("Sending request to OpenWeatherMap API", path: path, params: params.except(:appid))
+      Langchain.logger.debug("#{self.class} - Sending request to OpenWeatherMap API #{{path: path, params: params.except(:appid)}}")
       response = http.request(request)
-      Langchain.logger.info("Received response from OpenWeatherMap API", status: response.code)
+      Langchain.logger.debug("#{self.class} - Received response from OpenWeatherMap API #{{status: response.code}}")
 
       if response.code == "200"
         JSON.parse(response.body)

data/lib/langchain/tool/wikipedia.rb

@@ -29,7 +29,7 @@ module Langchain::Tool
     # @param input [String] search query
     # @return [String] Answer
     def execute(input:)
-      Langchain.logger.info("Executing \"#{input}\"", for: self.class)
+      Langchain.logger.debug("#{self.class} - Executing \"#{input}\"")
 
       page = ::Wikipedia.find(input)
       # It would be nice to figure out a way to provide page.content but the LLM token limit is an issue

data/lib/langchain/vectorsearch/base.rb

@@ -194,11 +194,5 @@ module Langchain::Vectorsearch
 
       add_texts(texts: texts)
     end
-
-    def self.logger_options
-      {
-        color: :blue
-      }
-    end
   end
 end

data/lib/langchain/vectorsearch/epsilla.rb

@@ -39,7 +39,7 @@ module Langchain::Vectorsearch
             # This behavior is changed in https://github.com/epsilla-cloud/vectordb/pull/95
             # Old behavior (HTTP 500) is preserved for backwards compatibility.
             # It does not prevent us from using the db.
-            Langchain.logger.info("Database already loaded")
+            Langchain.logger.debug("#{self.class} - Database already loaded")
           else
             raise "Failed to load database: #{response}"
           end

data/lib/langchain/vectorsearch/hnswlib.rb

@@ -114,12 +114,12 @@ module Langchain::Vectorsearch
       if File.exist?(path_to_index)
         client.load_index(path_to_index)
 
-        Langchain.logger.info("Successfully loaded the index at \"#{path_to_index}\"", for: self.class)
+        Langchain.logger.debug("#{self.class} - Successfully loaded the index at \"#{path_to_index}\"")
       else
         # Default max_elements: 100, but we constantly resize the index as new data is written to it
         client.init_index(max_elements: 100)
 
-        Langchain.logger.info("Creating a new index at \"#{path_to_index}\"", for: self.class)
+        Langchain.logger.debug("#{self.class} - Creating a new index at \"#{path_to_index}\"")
       end
     end
   end

data/lib/langchain/version.rb

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

data/lib/langchain.rb

@@ -2,7 +2,6 @@
 
 require "logger"
 require "pathname"
-require "rainbow"
 require "zeitwerk"
 require "uri"
 require "json"
@@ -92,24 +91,58 @@ loader.setup
 # Langchain.logger.level = :info
 module Langchain
   class << self
-    # @return [ContextualLogger]
-    attr_reader :logger
-
-    # @param logger [Logger]
-    # @return [ContextualLogger]
-    def logger=(logger)
-      @logger = ContextualLogger.new(logger)
-    end
-
+    # @return [Logger]
+    attr_accessor :logger
     # @return [Pathname]
     attr_reader :root
   end
 
-  self.logger ||= ::Logger.new($stdout, level: :debug)
-
-  @root = Pathname.new(__dir__)
-
   module Errors
     class BaseError < StandardError; end
   end
+
+  module Colorizer
+    class << self
+      def red(str)
+        "\e[31m#{str}\e[0m"
+      end
+
+      def green(str)
+        "\e[32m#{str}\e[0m"
+      end
+
+      def yellow(str)
+        "\e[33m#{str}\e[0m"
+      end
+
+      def blue(str)
+        "\e[34m#{str}\e[0m"
+      end
+
+      def colorize_logger_msg(msg, severity)
+        return msg unless msg.is_a?(String)
+
+        return red(msg) if severity.to_sym == :ERROR
+        return yellow(msg) if severity.to_sym == :WARN
+        msg
+      end
+    end
+  end
+
+  LOGGER_OPTIONS = {
+    progname: "Langchain.rb",
+
+    formatter: ->(severity, time, progname, msg) do
+      Logger::Formatter.new.call(
+        severity,
+        time,
+        "[#{progname}]",
+        Colorizer.colorize_logger_msg(msg, severity)
+      )
+    end
+  }.freeze
+
+  self.logger ||= ::Logger.new($stdout, **LOGGER_OPTIONS)
+
+  @root = Pathname.new(__dir__)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: langchainrb
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.16.1
 platform: ruby
 authors:
 - Andrei Bondarev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-19 00:00:00.000000000 Z
+date: 2024-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: baran
@@ -24,20 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.9
-- !ruby/object:Gem::Dependency
-  name: rainbow
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.1.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: json-schema
   requirement: !ruby/object:Gem::Requirement
@@ -680,7 +666,6 @@ files:
 - lib/langchain/chunker/semantic.rb
 - lib/langchain/chunker/sentence.rb
 - lib/langchain/chunker/text.rb
-- lib/langchain/contextual_logger.rb
 - lib/langchain/data.rb
 - lib/langchain/dependency_helper.rb
 - lib/langchain/evals/ragas/answer_relevance.rb
@@ -758,7 +743,6 @@ files:
 - lib/langchain/tool/weather.rb
 - lib/langchain/tool/wikipedia.rb
 - lib/langchain/tool_definition.rb
-- lib/langchain/utils/colorizer.rb
 - lib/langchain/utils/cosine_similarity.rb
 - lib/langchain/utils/hash_transformer.rb
 - lib/langchain/utils/to_boolean.rb
@@ -799,7 +783,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.20
 signing_key:
 specification_version: 4
 summary: Build LLM-backed Ruby applications with Ruby's Langchain.rb

data/lib/langchain/contextual_logger.rb

@@ -1,68 +0,0 @@
-# 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 << colorize("[Langchain.rb]", color: :yellow)
-      log_line_parts << if for_class.respond_to?(:logger_options)
-        colorize("[#{for_class_name}]", for_class.logger_options) + ":"
-      elsif for_class_name
-        "[#{for_class_name}]:"
-      end
-      log_line_parts << colorize(args.first, MESSAGE_COLOR_OPTIONS[method])
-      log_line_parts << kwargs if !!kwargs && kwargs.any?
-      log_line_parts << block.call if block
-      log_line = log_line_parts.compact.join(" ")
-
-      @logger.send(
-        method,
-        log_line
-      )
-    end
-
-    private
-
-    def colorize(line, options)
-      Langchain::Utils::Colorizer.colorize(line, options)
-    end
-  end
-end

data/lib/langchain/utils/colorizer.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Langchain
-  module Utils
-    class Colorizer
-      def self.colorize(line, options)
-        decorated_line = Rainbow(line)
-        options.each_pair.each do |modifier, value|
-          decorated_line = if modifier == :mode
-            decorated_line.public_send(value)
-          else
-            decorated_line.public_send(modifier, value)
-          end
-        end
-        decorated_line
-      end
-    end
-  end
-end