langchainrb 0.19.0 → 0.19.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89fdd6c82d689f6e7057133eab08ef8367e72e211d3a59df423ce26cd3b2c04d
-  data.tar.gz: e77493aec62198a014b0296490779b18016407c1808de45020e25b63a8d42d17
+  metadata.gz: 86b8bd9a7b846fb7be528116984e3e6353ea36ee75f06ddae8872c9b70c8deee
+  data.tar.gz: 3cc860f9d448d5e7df4eef2ea7e136e2381f3aecee4ffd245ebd41df7b9bd650
 SHA512:
-  metadata.gz: 9040755869f6cbf666f8ec1225b976d095a809915c533e8102b281bc8c66d4751e93abbef19a4c27d806e5abd9555690a4d89401e7d06c29d8e4e9b6252bff4f
-  data.tar.gz: 23287eb713d76ed824e13e4b2e07e66f342a08177b39b7fa2d6fb85af25f3f0ed2bc898d6b1316c2859963526f7cf1e635c413a8786ae671399ff50b87697f82
+  metadata.gz: 55128bb86766b2fb3e852764603df1786df971f736328f115581666eb7779249b0236058edf31a53a8197929496b2d1d5f667c26e04ff759a6763028d892735a
+  data.tar.gz: '028c8049dd2d2642d4652dfe1df94d7f94a4acfadb5cf61e46b2ac82a392022eafde5e5be8820f3919c1ffe1c73693d56b09bf60fbcdb1e207ae3abcec5abaaa'

data/CHANGELOG.md

@@ -4,13 +4,25 @@
 - [BREAKING]: A breaking change. After an upgrade, your app may need modifications to keep working correctly.
 - [FEATURE]: A non-breaking improvement to the app. Either introduces new functionality, or improves on an existing feature.
 - [BUGFIX]: Fixes a bug with a non-breaking change.
-- [COMPAT]: Compatibility improvements - changes to make Administrate more compatible with different dependency versions.
+- [COMPAT]: Compatibility improvements - changes to make Langchain.rb more compatible with different dependency versions.
 - [OPTIM]: Optimization or performance increase.
 - [DOCS]: Documentation changes. No changes to the library's behavior.
 - [SECURITY]: A change which fixes a security vulnerability.
 
 ## [Unreleased]
 
+## [0.19.2] - 2024-11-26
+- [FEATURE] [https://github.com/patterns-ai-core/langchainrb/pull/884] Add `tool_execution_callback` to `Langchain::Assistant`, a callback function (proc, lambda) that is called right before a tool is executed
+
+## [0.19.1] - 2024-11-21
+- [FEATURE] [https://github.com/patterns-ai-core/langchainrb/pull/858] Assistant, when using Anthropic, now also accepts image_url in the message.
+- [FEATURE] [https://github.com/patterns-ai-core/langchainrb/pull/861] Clean up passing `max_tokens` to Anthropic constructor and chat method
+- [FEATURE] [https://github.com/patterns-ai-core/langchainrb/pull/849] Langchain::Assistant now works with AWS Bedrock-hosted Anthropic models
+- [OPTIM] [https://github.com/patterns-ai-core/langchainrb/pull/867] Refactor `GoogleGeminiMessage#to_hash` and `OpenAIMessage#to_hash` methods.
+- [OPTIM] [https://github.com/patterns-ai-core/langchainrb/pull/849] Simplify Langchain::LLM::AwsBedrock class
+- [BUGFIX] [https://github.com/patterns-ai-core/langchainrb/pull/869] AnthropicMessage now correctly handles tool calls with content.
+- [OPTIM] [https://github.com/patterns-ai-core/langchainrb/pull/870] Assistant, when using Ollama (e.g.: llava model), now also accepts image_url in the message.
+
 ## [0.19.0] - 2024-10-23
 - [BREAKING] [https://github.com/patterns-ai-core/langchainrb/pull/840] Rename `chat_completion_model_name` parameter to `chat_model` in Langchain::LLM parameters.
 - [BREAKING] [https://github.com/patterns-ai-core/langchainrb/pull/840] Rename `completion_model_name` parameter to `completion_model` in Langchain::LLM parameters.
@@ -19,6 +31,7 @@
 - [BUGFIX] [https://github.com/patterns-ai-core/langchainrb/pull/837] Fix bug when tool functions with no input variables are used with Langchain::LLM::Anthropic
 - [BUGFIX] [https://github.com/patterns-ai-core/langchainrb/pull/836] Fix bug when assistant.instructions = nil did not remove the system message
 - [FEATURE] [https://github.com/patterns-ai-core/langchainrb/pull/838] Allow setting safety_settings: [] in default_options for Langchain::LLM::GoogleGemini and Langchain::LLM::GoogleVertexAI constructors
+- [BUGFIX] [https://github.com/patterns-ai-core/langchainrb/pull/871] Allow passing in options hash to Ollama
 
 ## [0.18.0] - 2024-10-12
 - [BREAKING] Remove `Langchain::Assistant#clear_thread!` method

data/README.md

@@ -133,7 +133,7 @@ messages = [
   { role: "system", content: "You are a helpful assistant." },
   { role: "user", content: "What's the weather like today?" }
   # Google Gemini and Google VertexAI expect messages in a different format:
-  # { role: "user", parts: [{ text: "why is the sky blue?" }]
+  # { role: "user", parts: [{ text: "why is the sky blue?" }]}
 ]
 response = llm.chat(messages: messages)
 chat_completion = response.chat_completion
@@ -536,6 +536,13 @@ Note that streaming is not currently supported for all LLMs.
 * `tool_choice`: Specifies how tools should be selected. Default: "auto". A specific tool function name can be passed. This will force the Assistant to **always** use this function.
 * `parallel_tool_calls`: Whether to make multiple parallel tool calls. Default: true
 * `add_message_callback`: A callback function (proc, lambda) that is called when any message is added to the conversation (optional)
+```ruby
+assistant.add_message_callback = -> (message) { puts "New message: #{message}" }
+```
+* `tool_execution_callback`: A callback function (proc, lambda) that is called right before a tool is executed (optional)
+```ruby
+assistant.tool_execution_callback = -> (tool_call_id, tool_name, method_name, tool_arguments) { puts "Executing tool_call_id: #{tool_call_id}, tool_name: #{tool_name}, method_name: #{method_name}, tool_arguments: #{tool_arguments}" }
+```
 
 ### Key Methods
 * `add_message`: Adds a user message to the messages array
@@ -558,7 +565,7 @@ Note that streaming is not currently supported for all LLMs.
 The Langchain::Assistant can be easily extended with custom tools by creating classes that `extend Langchain::ToolDefinition` module and implement required methods.
 ```ruby
 class MovieInfoTool
-  include Langchain::ToolDefinition
+  extend Langchain::ToolDefinition
 
   define_function :search_movie, description: "MovieInfoTool: Search for a movie by title" do
     property :query, type: "string", description: "The movie title to search for", required: true

data/lib/langchain/assistant/llm/adapter.rb

@@ -6,16 +6,17 @@ module Langchain
       # TODO: Fix the message truncation when context window is exceeded
       class Adapter
         def self.build(llm)
-          case llm
-          when Langchain::LLM::Anthropic
+          if llm.is_a?(Langchain::LLM::Anthropic)
             LLM::Adapters::Anthropic.new
-          when Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI
+          elsif llm.is_a?(Langchain::LLM::AwsBedrock) && llm.defaults[:chat_model].include?("anthropic")
+            LLM::Adapters::AwsBedrockAnthropic.new
+          elsif llm.is_a?(Langchain::LLM::GoogleGemini) || llm.is_a?(Langchain::LLM::GoogleVertexAI)
             LLM::Adapters::GoogleGemini.new
-          when Langchain::LLM::MistralAI
+          elsif llm.is_a?(Langchain::LLM::MistralAI)
             LLM::Adapters::MistralAI.new
-          when Langchain::LLM::Ollama
+          elsif llm.is_a?(Langchain::LLM::Ollama)
             LLM::Adapters::Ollama.new
-          when Langchain::LLM::OpenAI
+          elsif llm.is_a?(Langchain::LLM::OpenAI)
             LLM::Adapters::OpenAI.new
           else
             raise ArgumentError, "Unsupported LLM type: #{llm.class}"

data/lib/langchain/assistant/llm/adapters/anthropic.rb

@@ -38,9 +38,7 @@ module Langchain
           # @param tool_call_id [String] The tool call ID
           # @return [Messages::AnthropicMessage] The Anthropic message
           def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
-            Langchain.logger.warn "WARNING: Image URL is not supported by Anthropic currently" if image_url
-
-            Messages::AnthropicMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+            Messages::AnthropicMessage.new(role: role, content: content, image_url: image_url, tool_calls: tool_calls, tool_call_id: tool_call_id)
           end
 
           # Extract the tool call information from the Anthropic tool call hash

data/lib/langchain/assistant/llm/adapters/aws_bedrock_anthropic.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Langchain
+  class Assistant
+    module LLM
+      module Adapters
+        class AwsBedrockAnthropic < Anthropic
+          private
+
+          # @param [String] choice
+          # @param [Boolean] _parallel_tool_calls
+          # @return [Hash]
+          def build_tool_choice(choice, _parallel_tool_calls)
+            # Aws Bedrock hosted Anthropic does not support parallel tool calls
+            Langchain.logger.warn "WARNING: parallel_tool_calls is not supported by AWS Bedrock Anthropic currently"
+
+            tool_choice_object = {}
+
+            case choice
+            when "auto"
+              tool_choice_object[:type] = "auto"
+            when "any"
+              tool_choice_object[:type] = "any"
+            else
+              tool_choice_object[:type] = "tool"
+              tool_choice_object[:name] = choice
+            end
+
+            tool_choice_object
+          end
+        end
+      end
+    end
+  end
+end

data/lib/langchain/assistant/llm/adapters/ollama.rb

@@ -39,9 +39,7 @@ module Langchain
           # @param tool_call_id [String] The tool call ID
           # @return [Messages::OllamaMessage] The Ollama message
           def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
-            Langchain.logger.warn "WARNING: Image URL is not supported by Ollama currently" if image_url
-
-            Messages::OllamaMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+            Messages::OllamaMessage.new(role: role, content: content, image_url: image_url, tool_calls: tool_calls, tool_call_id: tool_call_id)
           end
 
           # Extract the tool call information from the OpenAI tool call hash

data/lib/langchain/assistant/messages/anthropic_message.rb

@@ -18,13 +18,20 @@ module Langchain
         # @param content [String] The content of the message
         # @param tool_calls [Array<Hash>] The tool calls made in the message
         # @param tool_call_id [String] The ID of the tool call
-        def initialize(role:, content: nil, tool_calls: [], tool_call_id: nil)
+        def initialize(
+          role:,
+          content: nil,
+          image_url: nil,
+          tool_calls: [],
+          tool_call_id: nil
+        )
           raise ArgumentError, "Role must be one of #{ROLES.join(", ")}" unless ROLES.include?(role)
           raise ArgumentError, "Tool calls must be an array of hashes" unless tool_calls.is_a?(Array) && tool_calls.all? { |tool_call| tool_call.is_a?(Hash) }
 
           @role = role
           # Some Tools return content as a JSON hence `.to_s`
           @content = content.to_s
+          @image_url = image_url
           @tool_calls = tool_calls
           @tool_call_id = tool_call_id
         end
@@ -33,25 +40,84 @@ module Langchain
         #
         # @return [Hash] The message as an Anthropic API-compatible hash
         def to_hash
-          {}.tap do |h|
-            h[:role] = tool? ? "user" : role
-
-            h[:content] = if tool?
-              [
-                {
-                  type: "tool_result",
-                  tool_use_id: tool_call_id,
-                  content: content
-                }
-              ]
-            elsif tool_calls.any?
-              tool_calls
-            else
-              content
-            end
+          if assistant?
+            assistant_hash
+          elsif tool?
+            tool_hash
+          elsif user?
+            user_hash
           end
         end
 
+        # Convert the message to an Anthropic API-compatible hash
+        #
+        # @return [Hash] The message as an Anthropic API-compatible hash, with the role as "assistant"
+        def assistant_hash
+          {
+            role: "assistant",
+            content: [
+              {
+                type: "text",
+                text: content
+              }
+            ].concat(tool_calls)
+          }
+        end
+
+        # Convert the message to an Anthropic API-compatible hash
+        #
+        # @return [Hash] The message as an Anthropic API-compatible hash, with the role as "user"
+        def tool_hash
+          {
+            role: "user",
+            # TODO: Tool can also return images
+            # https://docs.anthropic.com/en/docs/build-with-claude/tool-use#handling-tool-use-and-tool-result-content-blocks
+            content: [
+              {
+                type: "tool_result",
+                tool_use_id: tool_call_id,
+                content: content
+              }
+            ]
+          }
+        end
+
+        # Convert the message to an Anthropic API-compatible hash
+        #
+        # @return [Hash] The message as an Anthropic API-compatible hash, with the role as "user"
+        def user_hash
+          {
+            role: "user",
+            content: build_content_array
+          }
+        end
+
+        # Builds the content value for the message hash
+        # @return [Array<Hash>] An array of content hashes
+        def build_content_array
+          content_details = []
+
+          if content && !content.empty?
+            content_details << {
+              type: "text",
+              text: content
+            }
+          end
+
+          if image
+            content_details << {
+              type: "image",
+              source: {
+                type: "base64",
+                data: image.base64,
+                media_type: image.mime_type
+              }
+            }
+          end
+
+          content_details
+        end
+
         # Check if the message is a tool call
         #
         # @return [Boolean] true/false whether this message is a tool call

data/lib/langchain/assistant/messages/base.rb

@@ -50,6 +50,10 @@ module Langchain
           # TODO: Should we return :unknown or raise an error?
           :unknown
         end
+
+        def image
+          image_url ? Utils::ImageWrapper.new(image_url) : nil
+        end
       end
     end
   end

data/lib/langchain/assistant/messages/google_gemini_message.rb

@@ -41,23 +41,12 @@ module Langchain
         #
         # @return [Hash] The message as a Google Gemini API-compatible hash
         def to_hash
-          {}.tap do |h|
-            h[:role] = role
-            h[:parts] = if function?
-              [{
-                functionResponse: {
-                  name: tool_call_id,
-                  response: {
-                    name: tool_call_id,
-                    content: content
-                  }
-                }
-              }]
-            elsif tool_calls.any?
-              tool_calls
-            else
-              [{text: content}]
-            end
+          if tool?
+            tool_hash
+          elsif model?
+            model_hash
+          elsif user?
+            user_hash
           end
         end
 
@@ -73,6 +62,13 @@ module Langchain
           function?
         end
 
+        # Check if the message is a user call
+        #
+        # @return [Boolean] true/false whether this message is a user call
+        def user?
+          role == "user"
+        end
+
         # Check if the message is a tool call
         #
         # @return [Boolean] true/false whether this message is a tool call
@@ -80,6 +76,51 @@ module Langchain
           role == "function"
         end
 
+        # Convert the message to an GoogleGemini API-compatible hash
+        # @return [Hash] The message as an GoogleGemini API-compatible hash, with the role as "model"
+        def model_hash
+          {
+            role: role,
+            parts: build_parts
+          }
+        end
+
+        # Convert the message to an GoogleGemini API-compatible hash
+        # @return [Hash] The message as an GoogleGemini API-compatible hash, with the role as "function"
+        def tool_hash
+          {
+            role: role,
+            parts: [{
+              functionResponse: {
+                name: tool_call_id,
+                response: {
+                  name: tool_call_id,
+                  content: content
+                }
+              }
+            }]
+          }
+        end
+
+        # Convert the message to an GoogleGemini API-compatible hash
+        # @return [Hash] The message as an GoogleGemini API-compatible hash, with the role as "user"
+        def user_hash
+          {
+            role: role,
+            parts: build_parts
+          }
+        end
+
+        # Builds the part value for the message hash
+        # @return [Array<Hash>] An array of content hashes of the text or of the tool calls if present
+        def build_parts
+          if tool_calls.any?
+            tool_calls
+          else
+            [{text: content}]
+          end
+        end
+
         # Check if the message came from an LLM
         #
         # @return [Boolean] true/false whether this message was produced by an LLM

data/lib/langchain/assistant/messages/ollama_message.rb

@@ -18,15 +18,18 @@ module Langchain
         #
         # @param role [String] The role of the message
         # @param content [String] The content of the message
+        # @param image_url [String] The URL of the image to include in the message
         # @param tool_calls [Array<Hash>] The tool calls made in the message
         # @param tool_call_id [String] The ID of the tool call
-        def initialize(role:, content: nil, tool_calls: [], tool_call_id: nil)
+        def initialize(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
           raise ArgumentError, "Role must be one of #{ROLES.join(", ")}" unless ROLES.include?(role)
           raise ArgumentError, "Tool calls must be an array of hashes" unless tool_calls.is_a?(Array) && tool_calls.all? { |tool_call| tool_call.is_a?(Hash) }
+          raise ArgumentError, "image_url must be a valid url" if image_url && !URI::DEFAULT_PARSER.make_regexp.match?(image_url)
 
           @role = role
           # Some Tools return content as a JSON hence `.to_s`
           @content = content.to_s
+          @image_url = image_url
           @tool_calls = tool_calls
           @tool_call_id = tool_call_id
         end
@@ -38,6 +41,7 @@ module Langchain
           {}.tap do |h|
             h[:role] = role
             h[:content] = content if content # Content is nil for tool calls
+            h[:images] = [image.base64] if image
             h[:tool_calls] = tool_calls if tool_calls.any?
             h[:tool_call_id] = tool_call_id if tool_call_id
           end

data/lib/langchain/assistant/messages/openai_message.rb

@@ -50,32 +50,14 @@ module Langchain
         #
         # @return [Hash] The message as an OpenAI API-compatible hash
         def to_hash
-          {}.tap do |h|
-            h[:role] = role
-
-            if tool_calls.any?
-              h[:tool_calls] = tool_calls
-            else
-              h[:tool_call_id] = tool_call_id if tool_call_id
-
-              h[:content] = []
-
-              if content && !content.empty?
-                h[:content] << {
-                  type: "text",
-                  text: content
-                }
-              end
-
-              if image_url
-                h[:content] << {
-                  type: "image_url",
-                  image_url: {
-                    url: image_url
-                  }
-                }
-              end
-            end
+          if assistant?
+            assistant_hash
+          elsif system?
+            system_hash
+          elsif tool?
+            tool_hash
+          elsif user?
+            user_hash
           end
         end
 
@@ -99,6 +81,76 @@ module Langchain
         def tool?
           role == "tool"
         end
+
+        def user?
+          role == "user"
+        end
+
+        # Convert the message to an OpenAI API-compatible hash
+        # @return [Hash] The message as an OpenAI API-compatible hash, with the role as "assistant"
+        def assistant_hash
+          if tool_calls.any?
+            {
+              role: "assistant",
+              tool_calls: tool_calls
+            }
+          else
+            {
+              role: "assistant",
+              content: build_content_array
+            }
+          end
+        end
+
+        # Convert the message to an OpenAI API-compatible hash
+        # @return [Hash] The message as an OpenAI API-compatible hash, with the role as "system"
+        def system_hash
+          {
+            role: "system",
+            content: build_content_array
+          }
+        end
+
+        # Convert the message to an OpenAI API-compatible hash
+        # @return [Hash] The message as an OpenAI API-compatible hash, with the role as "tool"
+        def tool_hash
+          {
+            role: "tool",
+            tool_call_id: tool_call_id,
+            content: build_content_array
+          }
+        end
+
+        # Convert the message to an OpenAI API-compatible hash
+        # @return [Hash] The message as an OpenAI API-compatible hash, with the role as "user"
+        def user_hash
+          {
+            role: "user",
+            content: build_content_array
+          }
+        end
+
+        # Builds the content value for the message hash
+        # @return [Array<Hash>] An array of content hashes, with keys :type and :text or :image_url.
+        def build_content_array
+          content_details = []
+          if content && !content.empty?
+            content_details << {
+              type: "text",
+              text: content
+            }
+          end
+
+          if image_url
+            content_details << {
+              type: "image_url",
+              image_url: {
+                url: image_url
+              }
+            }
+          end
+          content_details
+        end
       end
     end
   end

data/lib/langchain/assistant.rb

@@ -24,6 +24,7 @@ module Langchain
 
     attr_accessor :tools,
       :add_message_callback,
+      :tool_execution_callback,
       :parallel_tool_calls
 
     # Create a new assistant
@@ -35,6 +36,7 @@ module Langchain
     # @param parallel_tool_calls [Boolean] Whether or not to run tools in parallel
     # @param messages [Array<Langchain::Assistant::Messages::Base>] The messages
     # @param add_message_callback [Proc] A callback function (Proc or lambda) that is called when any message is added to the conversation
+    # @param tool_execution_callback [Proc] A callback function (Proc or lambda) that is called right before a tool function is executed
     def initialize(
       llm:,
       tools: [],
@@ -42,7 +44,9 @@ module Langchain
       tool_choice: "auto",
       parallel_tool_calls: true,
       messages: [],
+      # Callbacks
       add_message_callback: nil,
+      tool_execution_callback: nil,
       &block
     )
       unless tools.is_a?(Array) && tools.all? { |tool| tool.class.singleton_class.included_modules.include?(Langchain::ToolDefinition) }
@@ -52,11 +56,8 @@ module Langchain
       @llm = llm
       @llm_adapter = LLM::Adapter.build(llm)
 
-      # TODO: Validate that it is, indeed, a Proc or lambda
-      if !add_message_callback.nil? && !add_message_callback.respond_to?(:call)
-        raise ArgumentError, "add_message_callback must be a callable object, like Proc or lambda"
-      end
-      @add_message_callback = add_message_callback
+      @add_message_callback = add_message_callback if validate_callback!("add_message_callback", add_message_callback)
+      @tool_execution_callback = tool_execution_callback if validate_callback!("tool_execution_callback", tool_execution_callback)
 
       self.messages = messages
       @tools = tools
@@ -353,16 +354,26 @@ module Langchain
     def run_tools(tool_calls)
       # Iterate over each function invocation and submit tool output
       tool_calls.each do |tool_call|
-        tool_call_id, tool_name, method_name, tool_arguments = @llm_adapter.extract_tool_call_args(tool_call: tool_call)
+        run_tool(tool_call)
+      end
+    end
 
-        tool_instance = tools.find do |t|
-          t.class.tool_name == tool_name
-        end or raise ArgumentError, "Tool: #{tool_name} not found in assistant.tools"
+    # Run the tool call
+    #
+    # @param tool_call [Hash] The tool call to run
+    # @return [Object] The result of the tool call
+    def run_tool(tool_call)
+      tool_call_id, tool_name, method_name, tool_arguments = @llm_adapter.extract_tool_call_args(tool_call: tool_call)
 
-        output = tool_instance.send(method_name, **tool_arguments)
+      tool_instance = tools.find do |t|
+        t.class.tool_name == tool_name
+      end or raise ArgumentError, "Tool: #{tool_name} not found in assistant.tools"
 
-        submit_tool_output(tool_call_id: tool_call_id, output: output)
-      end
+      # Call the callback if set
+      tool_execution_callback.call(tool_call_id, tool_name, method_name, tool_arguments) if tool_execution_callback # rubocop:disable Style/SafeNavigation
+      output = tool_instance.send(method_name, **tool_arguments)
+
+      submit_tool_output(tool_call_id: tool_call_id, output: output)
     end
 
     # Build a message
@@ -392,5 +403,13 @@ module Langchain
     def available_tool_names
       llm_adapter.available_tool_names(tools)
     end
+
+    def validate_callback!(attr_name, callback)
+      if !callback.nil? && !callback.respond_to?(:call)
+        raise ArgumentError, "#{attr_name} must be a callable object, like Proc or lambda"
+      end
+
+      true
+    end
   end
 end

data/lib/langchain/llm/anthropic.rb

@@ -15,14 +15,14 @@ module Langchain::LLM
       temperature: 0.0,
       completion_model: "claude-2.1",
       chat_model: "claude-3-5-sonnet-20240620",
-      max_tokens_to_sample: 256
+      max_tokens: 256
     }.freeze
 
     # 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:, chat_model:, max_tokens_to_sample: }
+    # @param default_options [Hash] Default options to use on every call to LLM, e.g.: { temperature:, completion_model:, chat_model:, max_tokens: }
     # @return [Langchain::LLM::Anthropic] Langchain::LLM::Anthropic instance
     def initialize(api_key:, llm_options: {}, default_options: {})
       depends_on "anthropic"
@@ -32,7 +32,7 @@ module Langchain::LLM
       chat_parameters.update(
         model: {default: @defaults[:chat_model]},
         temperature: {default: @defaults[:temperature]},
-        max_tokens: {default: @defaults[:max_tokens_to_sample]},
+        max_tokens: {default: @defaults[:max_tokens]},
         metadata: {},
         system: {}
       )
@@ -55,7 +55,7 @@ module Langchain::LLM
     def complete(
       prompt:,
       model: @defaults[:completion_model],
-      max_tokens_to_sample: @defaults[:max_tokens_to_sample],
+      max_tokens: @defaults[:max_tokens],
       stop_sequences: nil,
       temperature: @defaults[:temperature],
       top_p: nil,
@@ -64,12 +64,12 @@ module Langchain::LLM
       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?
+      raise ArgumentError.new("max_tokens argument is required") if max_tokens.nil?
 
       parameters = {
         model: model,
         prompt: prompt,
-        max_tokens_to_sample: max_tokens_to_sample,
+        max_tokens_to_sample: max_tokens,
         temperature: temperature
       }
       parameters[:stop_sequences] = stop_sequences if stop_sequences

data/lib/langchain/llm/aws_bedrock.rb

@@ -7,51 +7,40 @@ module Langchain::LLM
   #    gem 'aws-sdk-bedrockruntime', '~> 1.1'
   #
   # Usage:
-  #    llm = Langchain::LLM::AwsBedrock.new(llm_options: {})
+  #    llm = Langchain::LLM::AwsBedrock.new(default_options: {})
   #
   class AwsBedrock < Base
     DEFAULTS = {
-      chat_model: "anthropic.claude-v2",
-      completion_model: "anthropic.claude-v2",
+      chat_model: "anthropic.claude-3-5-sonnet-20240620-v1:0",
+      completion_model: "anthropic.claude-v2:1",
       embedding_model: "amazon.titan-embed-text-v1",
       max_tokens_to_sample: 300,
       temperature: 1,
       top_k: 250,
       top_p: 0.999,
       stop_sequences: ["\n\nHuman:"],
-      anthropic_version: "bedrock-2023-05-31",
-      return_likelihoods: "NONE",
-      count_penalty: {
-        scale: 0,
-        apply_to_whitespaces: false,
-        apply_to_punctuations: false,
-        apply_to_numbers: false,
-        apply_to_stopwords: false,
-        apply_to_emojis: false
-      },
-      presence_penalty: {
-        scale: 0,
-        apply_to_whitespaces: false,
-        apply_to_punctuations: false,
-        apply_to_numbers: false,
-        apply_to_stopwords: false,
-        apply_to_emojis: false
-      },
-      frequency_penalty: {
-        scale: 0,
-        apply_to_whitespaces: false,
-        apply_to_punctuations: false,
-        apply_to_numbers: false,
-        apply_to_stopwords: false,
-        apply_to_emojis: false
-      }
+      return_likelihoods: "NONE"
     }.freeze
 
     attr_reader :client, :defaults
 
-    SUPPORTED_COMPLETION_PROVIDERS = %i[anthropic ai21 cohere meta].freeze
-    SUPPORTED_CHAT_COMPLETION_PROVIDERS = %i[anthropic].freeze
-    SUPPORTED_EMBEDDING_PROVIDERS = %i[amazon cohere].freeze
+    SUPPORTED_COMPLETION_PROVIDERS = %i[
+      anthropic
+      ai21
+      cohere
+      meta
+    ].freeze
+
+    SUPPORTED_CHAT_COMPLETION_PROVIDERS = %i[
+      anthropic
+      ai21
+      mistral
+    ].freeze
+
+    SUPPORTED_EMBEDDING_PROVIDERS = %i[
+      amazon
+      cohere
+    ].freeze
 
     def initialize(aws_client_options: {}, default_options: {})
       depends_on "aws-sdk-bedrockruntime", req: "aws-sdk-bedrockruntime"
@@ -64,8 +53,7 @@ module Langchain::LLM
         temperature: {},
         max_tokens: {default: @defaults[:max_tokens_to_sample]},
         metadata: {},
-        system: {},
-        anthropic_version: {default: "bedrock-2023-05-31"}
+        system: {}
       )
       chat_parameters.ignore(:n, :user)
       chat_parameters.remap(stop: :stop_sequences)
@@ -100,23 +88,25 @@ module Langchain::LLM
     # @param params  extra parameters passed to Aws::BedrockRuntime::Client#invoke_model
     # @return [Langchain::LLM::AnthropicResponse], [Langchain::LLM::CohereResponse] or [Langchain::LLM::AI21Response] Response object
     #
-    def complete(prompt:, **params)
-      raise "Completion provider #{completion_provider} is not supported." unless SUPPORTED_COMPLETION_PROVIDERS.include?(completion_provider)
+    def complete(
+      prompt:,
+      model: @defaults[:completion_model],
+      **params
+    )
+      raise "Completion provider #{model} is not supported." unless SUPPORTED_COMPLETION_PROVIDERS.include?(provider_name(model))
 
-      raise "Model #{@defaults[:completion_model]} only supports #chat." if @defaults[:completion_model].include?("claude-3")
-
-      parameters = compose_parameters params
+      parameters = compose_parameters(params, model)
 
       parameters[:prompt] = wrap_prompt prompt
 
       response = client.invoke_model({
-        model_id: @defaults[:completion_model],
+        model_id: model,
         body: parameters.to_json,
         content_type: "application/json",
         accept: "application/json"
       })
 
-      parse_response response
+      parse_response(response, model)
     end
 
     # Generate a chat completion for a given prompt
@@ -137,10 +127,11 @@ module Langchain::LLM
     # @return [Langchain::LLM::AnthropicResponse] Response object
     def chat(params = {}, &block)
       parameters = chat_parameters.to_params(params)
+      parameters = compose_parameters(parameters, parameters[:model])
 
-      raise ArgumentError.new("messages argument is required") if Array(parameters[:messages]).empty?
-
-      raise "Model #{parameters[:model]} does not support chat completions." unless Langchain::LLM::AwsBedrock::SUPPORTED_CHAT_COMPLETION_PROVIDERS.include?(completion_provider)
+      unless SUPPORTED_CHAT_COMPLETION_PROVIDERS.include?(provider_name(parameters[:model]))
+        raise "Chat provider #{parameters[:model]} is not supported."
+      end
 
       if block
         response_chunks = []
@@ -168,12 +159,26 @@ module Langchain::LLM
           accept: "application/json"
         })
 
-        parse_response response
+        parse_response(response, parameters[:model])
       end
     end
 
     private
 
+    def parse_model_id(model_id)
+      model_id
+        .gsub("us.", "") # Meta append "us." to their model ids
+        .split(".")
+    end
+
+    def provider_name(model_id)
+      parse_model_id(model_id).first.to_sym
+    end
+
+    def model_name(model_id)
+      parse_model_id(model_id).last
+    end
+
     def completion_provider
       @defaults[:completion_model].split(".").first.to_sym
     end
@@ -200,15 +205,17 @@ module Langchain::LLM
       end
     end
 
-    def compose_parameters(params)
-      if completion_provider == :anthropic
-        compose_parameters_anthropic params
-      elsif completion_provider == :cohere
-        compose_parameters_cohere params
-      elsif completion_provider == :ai21
-        compose_parameters_ai21 params
-      elsif completion_provider == :meta
-        compose_parameters_meta params
+    def compose_parameters(params, model_id)
+      if provider_name(model_id) == :anthropic
+        compose_parameters_anthropic(params)
+      elsif provider_name(model_id) == :cohere
+        compose_parameters_cohere(params)
+      elsif provider_name(model_id) == :ai21
+        params
+      elsif provider_name(model_id) == :meta
+        params
+      elsif provider_name(model_id) == :mistral
+        params
       end
     end
 
@@ -220,15 +227,17 @@ module Langchain::LLM
       end
     end
 
-    def parse_response(response)
-      if completion_provider == :anthropic
+    def parse_response(response, model_id)
+      if provider_name(model_id) == :anthropic
         Langchain::LLM::AnthropicResponse.new(JSON.parse(response.body.string))
-      elsif completion_provider == :cohere
+      elsif provider_name(model_id) == :cohere
         Langchain::LLM::CohereResponse.new(JSON.parse(response.body.string))
-      elsif completion_provider == :ai21
+      elsif provider_name(model_id) == :ai21
         Langchain::LLM::AI21Response.new(JSON.parse(response.body.string, symbolize_names: true))
-      elsif completion_provider == :meta
+      elsif provider_name(model_id) == :meta
         Langchain::LLM::AwsBedrockMetaResponse.new(JSON.parse(response.body.string))
+      elsif provider_name(model_id) == :mistral
+        Langchain::LLM::MistralAIResponse.new(JSON.parse(response.body.string))
       end
     end
 
@@ -276,61 +285,7 @@ module Langchain::LLM
     end
 
     def compose_parameters_anthropic(params)
-      default_params = @defaults.merge(params)
-
-      {
-        max_tokens_to_sample: default_params[:max_tokens_to_sample],
-        temperature: default_params[:temperature],
-        top_k: default_params[:top_k],
-        top_p: default_params[:top_p],
-        stop_sequences: default_params[:stop_sequences],
-        anthropic_version: default_params[:anthropic_version]
-      }
-    end
-
-    def compose_parameters_ai21(params)
-      default_params = @defaults.merge(params)
-
-      {
-        maxTokens: default_params[:max_tokens_to_sample],
-        temperature: default_params[:temperature],
-        topP: default_params[:top_p],
-        stopSequences: default_params[:stop_sequences],
-        countPenalty: {
-          scale: default_params[:count_penalty][:scale],
-          applyToWhitespaces: default_params[:count_penalty][:apply_to_whitespaces],
-          applyToPunctuations: default_params[:count_penalty][:apply_to_punctuations],
-          applyToNumbers: default_params[:count_penalty][:apply_to_numbers],
-          applyToStopwords: default_params[:count_penalty][:apply_to_stopwords],
-          applyToEmojis: default_params[:count_penalty][:apply_to_emojis]
-        },
-        presencePenalty: {
-          scale: default_params[:presence_penalty][:scale],
-          applyToWhitespaces: default_params[:presence_penalty][:apply_to_whitespaces],
-          applyToPunctuations: default_params[:presence_penalty][:apply_to_punctuations],
-          applyToNumbers: default_params[:presence_penalty][:apply_to_numbers],
-          applyToStopwords: default_params[:presence_penalty][:apply_to_stopwords],
-          applyToEmojis: default_params[:presence_penalty][:apply_to_emojis]
-        },
-        frequencyPenalty: {
-          scale: default_params[:frequency_penalty][:scale],
-          applyToWhitespaces: default_params[:frequency_penalty][:apply_to_whitespaces],
-          applyToPunctuations: default_params[:frequency_penalty][:apply_to_punctuations],
-          applyToNumbers: default_params[:frequency_penalty][:apply_to_numbers],
-          applyToStopwords: default_params[:frequency_penalty][:apply_to_stopwords],
-          applyToEmojis: default_params[:frequency_penalty][:apply_to_emojis]
-        }
-      }
-    end
-
-    def compose_parameters_meta(params)
-      default_params = @defaults.merge(params)
-
-      {
-        temperature: default_params[:temperature],
-        top_p: default_params[:top_p],
-        max_gen_len: default_params[:max_tokens_to_sample]
-      }
+      params.merge(anthropic_version: "bedrock-2023-05-31")
     end
 
     def response_from_chunks(chunks)

data/lib/langchain/llm/ollama.rb

@@ -14,7 +14,8 @@ module Langchain::LLM
       temperature: 0.0,
       completion_model: "llama3.1",
       embedding_model: "llama3.1",
-      chat_model: "llama3.1"
+      chat_model: "llama3.1",
+      options: {}
     }.freeze
 
     EMBEDDING_SIZES = {
@@ -45,7 +46,8 @@ module Langchain::LLM
         temperature: {default: @defaults[:temperature]},
         template: {},
         stream: {default: false},
-        response_format: {default: @defaults[:response_format]}
+        response_format: {default: @defaults[:response_format]},
+        options: {default: @defaults[:options]}
       )
       chat_parameters.remap(response_format: :format)
     end

data/lib/langchain/llm/parameters/chat.rb

@@ -37,7 +37,10 @@ module Langchain::LLM::Parameters
       parallel_tool_calls: {},
 
       # Additional optional parameters
-      logit_bias: {}
+      logit_bias: {},
+
+      # Additional llm options. Ollama only.
+      options: {}
     }
 
     def initialize(parameters: {})

data/lib/langchain/llm/response/ai21_response.rb

@@ -9,5 +9,25 @@ module Langchain::LLM
     def completion
       completions.dig(0, :data, :text)
     end
+
+    def chat_completion
+      raw_response.dig(:choices, 0, :message, :content)
+    end
+
+    def prompt_tokens
+      raw_response.dig(:usage, :prompt_tokens).to_i
+    end
+
+    def completion_tokens
+      raw_response.dig(:usage, :completion_tokens).to_i
+    end
+
+    def total_tokens
+      raw_response.dig(:usage, :total_tokens).to_i
+    end
+
+    def role
+      raw_response.dig(:choices, 0, :message, :role)
+    end
   end
 end

data/lib/langchain/utils/image_wrapper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "open-uri"
+require "base64"
+
+module Langchain
+  module Utils
+    class ImageWrapper
+      attr_reader :image_url
+
+      def initialize(image_url)
+        @image_url = image_url
+      end
+
+      def base64
+        @base64 ||= begin
+          image_data = open_image.read
+          Base64.strict_encode64(image_data)
+        end
+      end
+
+      def mime_type
+        # TODO: Make it work with local files
+        open_image.meta["content-type"]
+      end
+
+      private
+
+      def open_image
+        # TODO: Make it work with local files
+        uri = URI.parse(image_url)
+        raise URI::InvalidURIError, "Invalid URL scheme" unless %w[http https].include?(uri.scheme)
+        @open_image ||= URI.open(image_url) # rubocop:disable Security/Open
+      end
+    end
+  end
+end

data/lib/langchain/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: langchainrb
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.19.2
 platform: ruby
 authors:
 - Andrei Bondarev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-23 00:00:00.000000000 Z
+date: 2024-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: baran
@@ -640,6 +640,7 @@ files:
 - lib/langchain/assistant.rb
 - lib/langchain/assistant/llm/adapter.rb
 - lib/langchain/assistant/llm/adapters/anthropic.rb
+- lib/langchain/assistant/llm/adapters/aws_bedrock_anthropic.rb
 - lib/langchain/assistant/llm/adapters/base.rb
 - lib/langchain/assistant/llm/adapters/google_gemini.rb
 - lib/langchain/assistant/llm/adapters/mistral_ai.rb
@@ -736,6 +737,7 @@ files:
 - lib/langchain/tool_definition.rb
 - lib/langchain/utils/cosine_similarity.rb
 - lib/langchain/utils/hash_transformer.rb
+- lib/langchain/utils/image_wrapper.rb
 - lib/langchain/utils/to_boolean.rb
 - lib/langchain/vectorsearch/base.rb
 - lib/langchain/vectorsearch/chroma.rb