langchainrb 0.17.0 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c125e87218ae9ce233711968edf212e128b50910f118951296593d141c9b7a68
-  data.tar.gz: a8e0890d5eef171709068ee19e4e0955929035d732225916e28debd03cfebcbf
+  metadata.gz: f7061ef2090d35626239ca575b60edb291dbbadab7de85a5a2796792e1691437
+  data.tar.gz: 30cb1f14b602a22e7df8f2dba42660383d44482cbe83fb35dc9539afa836739c
 SHA512:
-  metadata.gz: ae228197ef8be183cf9f36dc46bb523033fcfd1c563246e3f49bec081822b819d3ca1b93a0b5a780af276cb80ef3ce6ef6734e87f7cf3fad335d0e57e186e965
-  data.tar.gz: fd17a2caabbce6d6b006831e3eb51c6c3c174f178536991f6c0477aadc4d5ea64c2dae317cf59be9691908c0d0908cca6fac681eedc413b69588883cb6494a50
+  metadata.gz: dd08fb29bd0ff9237cc27980c3bac607baeb9d54a93f297b1e81fb863b7cbb9720db4adacb3dae92bcbe71d2eb59b38d4de0ee321face467a0b82bde627d2929
+  data.tar.gz: 4a3661afd2d9d75a64e02f6f173cd0bf0e016207c444ca4506bab907f00dc906f5bbf82c96aad9521280265f214b0f3e82dd5e4ee54dc40f3afb415a6f50b365

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## [Unreleased]
 
+## [0.17.1] - 2024-10-07
+- Move Langchain::Assistant::LLM::Adapter-related classes to separate files
+- Fix Langchain::Tool::Database#describe_table method
+
 ## [0.17.0] - 2024-10-02
 - [BREAKING] Langchain::Vectorsearch::Milvus was rewritten to work with newer milvus 0.10.0 gem
 - [BREAKING] Removing Langchain::LLM::GooglePalm

data/lib/langchain/assistants/assistant.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "llm/adapter"
+
 module Langchain
   # Assistants are Agent-like objects that leverage helpful instructions, LLMs, tools and knowledge to respond to user queries.
   # Assistants can be configured with an LLM of your choice, any vector search database and easily extended with additional tools.
@@ -412,320 +414,5 @@ module Langchain
     def available_tool_names
       llm_adapter.available_tool_names(tools)
     end
-
-    # TODO: Fix the message truncation when context window is exceeded
-
-    module LLM
-      class Adapter
-        def self.build(llm)
-          case llm
-          when Langchain::LLM::Anthropic
-            Adapters::Anthropic.new
-          when Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI
-            Adapters::GoogleGemini.new
-          when Langchain::LLM::MistralAI
-            Adapters::MistralAI.new
-          when Langchain::LLM::Ollama
-            Adapters::Ollama.new
-          when Langchain::LLM::OpenAI
-            Adapters::OpenAI.new
-          else
-            raise ArgumentError, "Unsupported LLM type: #{llm.class}"
-          end
-        end
-      end
-
-      module Adapters
-        class Base
-          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
-            raise NotImplementedError, "Subclasses must implement build_chat_params"
-          end
-
-          def extract_tool_call_args(tool_call:)
-            raise NotImplementedError, "Subclasses must implement extract_tool_call_args"
-          end
-
-          def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
-            raise NotImplementedError, "Subclasses must implement build_message"
-          end
-        end
-
-        class Ollama < Base
-          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
-            params = {messages: messages}
-            if tools.any?
-              params[:tools] = build_tools(tools)
-            end
-            params
-          end
-
-          def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
-            warn "Image URL is not supported by Ollama currently" if image_url
-
-            Langchain::Messages::OllamaMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
-          end
-
-          # Extract the tool call information from the OpenAI tool call hash
-          #
-          # @param tool_call [Hash] The tool call hash
-          # @return [Array] The tool call information
-          def extract_tool_call_args(tool_call:)
-            tool_call_id = tool_call.dig("id")
-
-            function_name = tool_call.dig("function", "name")
-            tool_name, method_name = function_name.split("__")
-
-            tool_arguments = tool_call.dig("function", "arguments")
-            tool_arguments = if tool_arguments.is_a?(Hash)
-              Langchain::Utils::HashTransformer.symbolize_keys(tool_arguments)
-            else
-              JSON.parse(tool_arguments, symbolize_names: true)
-            end
-
-            [tool_call_id, tool_name, method_name, tool_arguments]
-          end
-
-          def available_tool_names(tools)
-            build_tools(tools).map { |tool| tool.dig(:function, :name) }
-          end
-
-          def allowed_tool_choices
-            ["auto", "none"]
-          end
-
-          private
-
-          def build_tools(tools)
-            tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten
-          end
-        end
-
-        class OpenAI < Base
-          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
-            params = {messages: messages}
-            if tools.any?
-              params[:tools] = build_tools(tools)
-              params[:tool_choice] = build_tool_choice(tool_choice)
-            end
-            params
-          end
-
-          def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
-            Langchain::Messages::OpenAIMessage.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
-          #
-          # @param tool_call [Hash] The tool call hash
-          # @return [Array] The tool call information
-          def extract_tool_call_args(tool_call:)
-            tool_call_id = tool_call.dig("id")
-
-            function_name = tool_call.dig("function", "name")
-            tool_name, method_name = function_name.split("__")
-
-            tool_arguments = tool_call.dig("function", "arguments")
-            tool_arguments = if tool_arguments.is_a?(Hash)
-              Langchain::Utils::HashTransformer.symbolize_keys(tool_arguments)
-            else
-              JSON.parse(tool_arguments, symbolize_names: true)
-            end
-
-            [tool_call_id, tool_name, method_name, tool_arguments]
-          end
-
-          def build_tools(tools)
-            tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten
-          end
-
-          def allowed_tool_choices
-            ["auto", "none"]
-          end
-
-          def available_tool_names(tools)
-            build_tools(tools).map { |tool| tool.dig(:function, :name) }
-          end
-
-          private
-
-          def build_tool_choice(choice)
-            case choice
-            when "auto"
-              choice
-            else
-              {"type" => "function", "function" => {"name" => choice}}
-            end
-          end
-        end
-
-        class MistralAI < Base
-          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
-            params = {messages: messages}
-            if tools.any?
-              params[:tools] = build_tools(tools)
-              params[:tool_choice] = build_tool_choice(tool_choice)
-            end
-            params
-          end
-
-          def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
-            Langchain::Messages::MistralAIMessage.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
-          #
-          # @param tool_call [Hash] The tool call hash
-          # @return [Array] The tool call information
-          def extract_tool_call_args(tool_call:)
-            tool_call_id = tool_call.dig("id")
-
-            function_name = tool_call.dig("function", "name")
-            tool_name, method_name = function_name.split("__")
-
-            tool_arguments = tool_call.dig("function", "arguments")
-            tool_arguments = if tool_arguments.is_a?(Hash)
-              Langchain::Utils::HashTransformer.symbolize_keys(tool_arguments)
-            else
-              JSON.parse(tool_arguments, symbolize_names: true)
-            end
-
-            [tool_call_id, tool_name, method_name, tool_arguments]
-          end
-
-          def build_tools(tools)
-            tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten
-          end
-
-          def allowed_tool_choices
-            ["auto", "none"]
-          end
-
-          def available_tool_names(tools)
-            build_tools(tools).map { |tool| tool.dig(:function, :name) }
-          end
-
-          private
-
-          def build_tool_choice(choice)
-            case choice
-            when "auto"
-              choice
-            else
-              {"type" => "function", "function" => {"name" => choice}}
-            end
-          end
-        end
-
-        class GoogleGemini < Base
-          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
-            params = {messages: messages}
-            if tools.any?
-              params[:tools] = build_tools(tools)
-              params[:system] = instructions if instructions
-              params[:tool_choice] = build_tool_config(tool_choice)
-            end
-            params
-          end
-
-          def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
-            warn "Image URL is not supported by Google Gemini" if image_url
-
-            Langchain::Messages::GoogleGeminiMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
-          end
-
-          # Extract the tool call information from the Google Gemini tool call hash
-          #
-          # @param tool_call [Hash] The tool call hash, format: {"functionCall"=>{"name"=>"weather__execute", "args"=>{"input"=>"NYC"}}}
-          # @return [Array] The tool call information
-          def extract_tool_call_args(tool_call:)
-            tool_call_id = tool_call.dig("functionCall", "name")
-            function_name = tool_call.dig("functionCall", "name")
-            tool_name, method_name = function_name.split("__")
-            tool_arguments = tool_call.dig("functionCall", "args").transform_keys(&:to_sym)
-            [tool_call_id, tool_name, method_name, tool_arguments]
-          end
-
-          def build_tools(tools)
-            tools.map { |tool| tool.class.function_schemas.to_google_gemini_format }.flatten
-          end
-
-          def allowed_tool_choices
-            ["auto", "none"]
-          end
-
-          def available_tool_names(tools)
-            build_tools(tools).map { |tool| tool.dig(:name) }
-          end
-
-          private
-
-          def build_tool_config(choice)
-            case choice
-            when "auto"
-              {function_calling_config: {mode: "auto"}}
-            when "none"
-              {function_calling_config: {mode: "none"}}
-            else
-              {function_calling_config: {mode: "any", allowed_function_names: [choice]}}
-            end
-          end
-        end
-
-        class Anthropic < Base
-          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
-            params = {messages: messages}
-            if tools.any?
-              params[:tools] = build_tools(tools)
-              params[:tool_choice] = build_tool_choice(tool_choice)
-            end
-            params[:system] = instructions if instructions
-            params
-          end
-
-          def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
-            warn "Image URL is not supported by Anthropic currently" if image_url
-
-            Langchain::Messages::AnthropicMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
-          end
-
-          # Extract the tool call information from the Anthropic tool call hash
-          #
-          # @param tool_call [Hash] The tool call hash, format: {"type"=>"tool_use", "id"=>"toolu_01TjusbFApEbwKPRWTRwzadR", "name"=>"news_retriever__get_top_headlines", "input"=>{"country"=>"us", "page_size"=>10}}], "stop_reason"=>"tool_use"}
-          # @return [Array] The tool call information
-          def extract_tool_call_args(tool_call:)
-            tool_call_id = tool_call.dig("id")
-            function_name = tool_call.dig("name")
-            tool_name, method_name = function_name.split("__")
-            tool_arguments = tool_call.dig("input").transform_keys(&:to_sym)
-            [tool_call_id, tool_name, method_name, tool_arguments]
-          end
-
-          def build_tools(tools)
-            tools.map { |tool| tool.class.function_schemas.to_anthropic_format }.flatten
-          end
-
-          def allowed_tool_choices
-            ["auto", "any"]
-          end
-
-          def available_tool_names(tools)
-            build_tools(tools).map { |tool| tool.dig(:name) }
-          end
-
-          private
-
-          def build_tool_choice(choice)
-            case choice
-            when "auto"
-              {type: "auto"}
-            when "any"
-              {type: "any"}
-            else
-              {type: "tool", name: choice}
-            end
-          end
-        end
-      end
-    end
   end
 end

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

@@ -0,0 +1,27 @@
+Dir[Pathname.new(__FILE__).dirname.join("adapters", "*.rb")].sort.each { |file| require file }
+
+module Langchain
+  class Assistant
+    module LLM
+      # TODO: Fix the message truncation when context window is exceeded
+      class Adapter
+        def self.build(llm)
+          case llm
+          when Langchain::LLM::Anthropic
+            LLM::Adapters::Anthropic.new
+          when Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI
+            LLM::Adapters::GoogleGemini.new
+          when Langchain::LLM::MistralAI
+            LLM::Adapters::MistralAI.new
+          when Langchain::LLM::Ollama
+            LLM::Adapters::Ollama.new
+          when Langchain::LLM::OpenAI
+            LLM::Adapters::OpenAI.new
+          else
+            raise ArgumentError, "Unsupported LLM type: #{llm.class}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/langchain/assistants/llm/adapters/_base.rb

@@ -0,0 +1,21 @@
+module Langchain
+  class Assistant
+    module LLM
+      module Adapters
+        class Base
+          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
+            raise NotImplementedError, "Subclasses must implement build_chat_params"
+          end
+
+          def extract_tool_call_args(tool_call:)
+            raise NotImplementedError, "Subclasses must implement extract_tool_call_args"
+          end
+
+          def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
+            raise NotImplementedError, "Subclasses must implement build_message"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Langchain
+  class Assistant
+    module LLM
+      module Adapters
+        class Anthropic < Base
+          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
+            params = {messages: messages}
+            if tools.any?
+              params[:tools] = build_tools(tools)
+              params[:tool_choice] = build_tool_choice(tool_choice)
+            end
+            params[:system] = instructions if instructions
+            params
+          end
+
+          def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
+            warn "Image URL is not supported by Anthropic currently" if image_url
+
+            Langchain::Messages::AnthropicMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+          end
+
+          # Extract the tool call information from the Anthropic tool call hash
+          #
+          # @param tool_call [Hash] The tool call hash, format: {"type"=>"tool_use", "id"=>"toolu_01TjusbFApEbwKPRWTRwzadR", "name"=>"news_retriever__get_top_headlines", "input"=>{"country"=>"us", "page_size"=>10}}], "stop_reason"=>"tool_use"}
+          # @return [Array] The tool call information
+          def extract_tool_call_args(tool_call:)
+            tool_call_id = tool_call.dig("id")
+            function_name = tool_call.dig("name")
+            tool_name, method_name = function_name.split("__")
+            tool_arguments = tool_call.dig("input").transform_keys(&:to_sym)
+            [tool_call_id, tool_name, method_name, tool_arguments]
+          end
+
+          def build_tools(tools)
+            tools.map { |tool| tool.class.function_schemas.to_anthropic_format }.flatten
+          end
+
+          def allowed_tool_choices
+            ["auto", "any"]
+          end
+
+          def available_tool_names(tools)
+            build_tools(tools).map { |tool| tool.dig(:name) }
+          end
+
+          private
+
+          def build_tool_choice(choice)
+            case choice
+            when "auto"
+              {type: "auto"}
+            when "any"
+              {type: "any"}
+            else
+              {type: "tool", name: choice}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/langchain/assistants/llm/adapters/google_gemini.rb

@@ -0,0 +1,62 @@
+module Langchain
+  class Assistant
+    module LLM
+      module Adapters
+        class GoogleGemini < Base
+          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
+            params = {messages: messages}
+            if tools.any?
+              params[:tools] = build_tools(tools)
+              params[:system] = instructions if instructions
+              params[:tool_choice] = build_tool_config(tool_choice)
+            end
+            params
+          end
+
+          def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
+            warn "Image URL is not supported by Google Gemini" if image_url
+
+            Langchain::Messages::GoogleGeminiMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+          end
+
+          # Extract the tool call information from the Google Gemini tool call hash
+          #
+          # @param tool_call [Hash] The tool call hash, format: {"functionCall"=>{"name"=>"weather__execute", "args"=>{"input"=>"NYC"}}}
+          # @return [Array] The tool call information
+          def extract_tool_call_args(tool_call:)
+            tool_call_id = tool_call.dig("functionCall", "name")
+            function_name = tool_call.dig("functionCall", "name")
+            tool_name, method_name = function_name.split("__")
+            tool_arguments = tool_call.dig("functionCall", "args").transform_keys(&:to_sym)
+            [tool_call_id, tool_name, method_name, tool_arguments]
+          end
+
+          def build_tools(tools)
+            tools.map { |tool| tool.class.function_schemas.to_google_gemini_format }.flatten
+          end
+
+          def allowed_tool_choices
+            ["auto", "none"]
+          end
+
+          def available_tool_names(tools)
+            build_tools(tools).map { |tool| tool.dig(:name) }
+          end
+
+          private
+
+          def build_tool_config(choice)
+            case choice
+            when "auto"
+              {function_calling_config: {mode: "auto"}}
+            when "none"
+              {function_calling_config: {mode: "none"}}
+            else
+              {function_calling_config: {mode: "any", allowed_function_names: [choice]}}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/langchain/assistants/llm/adapters/mistral_ai.rb

@@ -0,0 +1,65 @@
+module Langchain
+  class Assistant
+    module LLM
+      module Adapters
+        class MistralAI < Base
+          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
+            params = {messages: messages}
+            if tools.any?
+              params[:tools] = build_tools(tools)
+              params[:tool_choice] = build_tool_choice(tool_choice)
+            end
+            params
+          end
+
+          def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
+            Langchain::Messages::MistralAIMessage.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
+          #
+          # @param tool_call [Hash] The tool call hash
+          # @return [Array] The tool call information
+          def extract_tool_call_args(tool_call:)
+            tool_call_id = tool_call.dig("id")
+
+            function_name = tool_call.dig("function", "name")
+            tool_name, method_name = function_name.split("__")
+
+            tool_arguments = tool_call.dig("function", "arguments")
+            tool_arguments = if tool_arguments.is_a?(Hash)
+              Langchain::Utils::HashTransformer.symbolize_keys(tool_arguments)
+            else
+              JSON.parse(tool_arguments, symbolize_names: true)
+            end
+
+            [tool_call_id, tool_name, method_name, tool_arguments]
+          end
+
+          def build_tools(tools)
+            tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten
+          end
+
+          def allowed_tool_choices
+            ["auto", "none"]
+          end
+
+          def available_tool_names(tools)
+            build_tools(tools).map { |tool| tool.dig(:function, :name) }
+          end
+
+          private
+
+          def build_tool_choice(choice)
+            case choice
+            when "auto"
+              choice
+            else
+              {"type" => "function", "function" => {"name" => choice}}
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Langchain
+  class Assistant
+    module LLM
+      module Adapters
+        class Ollama < Base
+          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
+            params = {messages: messages}
+            if tools.any?
+              params[:tools] = build_tools(tools)
+            end
+            params
+          end
+
+          def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
+            warn "Image URL is not supported by Ollama currently" if image_url
+
+            Langchain::Messages::OllamaMessage.new(role: role, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+          end
+
+          # Extract the tool call information from the OpenAI tool call hash
+          #
+          # @param tool_call [Hash] The tool call hash
+          # @return [Array] The tool call information
+          def extract_tool_call_args(tool_call:)
+            tool_call_id = tool_call.dig("id")
+
+            function_name = tool_call.dig("function", "name")
+            tool_name, method_name = function_name.split("__")
+
+            tool_arguments = tool_call.dig("function", "arguments")
+            tool_arguments = if tool_arguments.is_a?(Hash)
+              Langchain::Utils::HashTransformer.symbolize_keys(tool_arguments)
+            else
+              JSON.parse(tool_arguments, symbolize_names: true)
+            end
+
+            [tool_call_id, tool_name, method_name, tool_arguments]
+          end
+
+          def available_tool_names(tools)
+            build_tools(tools).map { |tool| tool.dig(:function, :name) }
+          end
+
+          def allowed_tool_choices
+            ["auto", "none"]
+          end
+
+          private
+
+          def build_tools(tools)
+            tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten
+          end
+        end
+      end
+    end
+  end
+end

data/lib/langchain/assistants/llm/adapters/openai.rb

@@ -0,0 +1,65 @@
+module Langchain
+  class Assistant
+    module LLM
+      module Adapters
+        class OpenAI < Base
+          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
+            params = {messages: messages}
+            if tools.any?
+              params[:tools] = build_tools(tools)
+              params[:tool_choice] = build_tool_choice(tool_choice)
+            end
+            params
+          end
+
+          def build_message(role:, content: nil, image_url: nil, tool_calls: [], tool_call_id: nil)
+            Langchain::Messages::OpenAIMessage.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
+          #
+          # @param tool_call [Hash] The tool call hash
+          # @return [Array] The tool call information
+          def extract_tool_call_args(tool_call:)
+            tool_call_id = tool_call.dig("id")
+
+            function_name = tool_call.dig("function", "name")
+            tool_name, method_name = function_name.split("__")
+
+            tool_arguments = tool_call.dig("function", "arguments")
+            tool_arguments = if tool_arguments.is_a?(Hash)
+              Langchain::Utils::HashTransformer.symbolize_keys(tool_arguments)
+            else
+              JSON.parse(tool_arguments, symbolize_names: true)
+            end
+
+            [tool_call_id, tool_name, method_name, tool_arguments]
+          end
+
+          def build_tools(tools)
+            tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten
+          end
+
+          def allowed_tool_choices
+            ["auto", "none"]
+          end
+
+          def available_tool_names(tools)
+            build_tools(tools).map { |tool| tool.dig(:function, :name) }
+          end
+
+          private
+
+          def build_tool_choice(choice)
+            case choice
+            when "auto"
+              choice
+            else
+              {"type" => "function", "function" => {"name" => choice}}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/langchain/llm/anthropic.rb

@@ -14,7 +14,7 @@ module Langchain::LLM
     DEFAULTS = {
       temperature: 0.0,
       completion_model_name: "claude-2.1",
-      chat_completion_model_name: "claude-3-sonnet-20240229",
+      chat_completion_model_name: "claude-3-5-sonnet-20240620",
       max_tokens_to_sample: 256
     }.freeze
 
@@ -109,6 +109,7 @@ module Langchain::LLM
       raise ArgumentError.new("model argument is required") if parameters[:model].empty?
       raise ArgumentError.new("max_tokens argument is required") if parameters[:max_tokens].nil?
 
+      binding.pry
       response = client.messages(parameters: parameters)
 
       Langchain::LLM::AnthropicResponse.new(response)

data/lib/langchain/tool/database.rb

@@ -122,7 +122,7 @@ module Langchain::Tool
       end
       db.foreign_key_list(table).each do |fk|
         schema << ",\n" if fk == db.foreign_key_list(table).first
-        schema << "FOREIGN KEY (#{fk[:columns][0]}) REFERENCES #{fk[:table]}(#{fk[:key][0]})"
+        schema << "FOREIGN KEY (#{fk[:columns]&.first}) REFERENCES #{fk[:table]}(#{fk[:key]&.first})"
         schema << ",\n" unless fk == db.foreign_key_list(table).last
       end
       schema << ");\n"

data/lib/langchain/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: langchainrb
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.17.1
 platform: ruby
 authors:
 - Andrei Bondarev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-02 00:00:00.000000000 Z
+date: 2024-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: baran
@@ -638,6 +638,13 @@ files:
 - README.md
 - lib/langchain.rb
 - lib/langchain/assistants/assistant.rb
+- lib/langchain/assistants/llm/adapter.rb
+- lib/langchain/assistants/llm/adapters/_base.rb
+- lib/langchain/assistants/llm/adapters/anthropic.rb
+- lib/langchain/assistants/llm/adapters/google_gemini.rb
+- lib/langchain/assistants/llm/adapters/mistral_ai.rb
+- lib/langchain/assistants/llm/adapters/ollama.rb
+- lib/langchain/assistants/llm/adapters/openai.rb
 - lib/langchain/assistants/messages/anthropic_message.rb
 - lib/langchain/assistants/messages/base.rb
 - lib/langchain/assistants/messages/google_gemini_message.rb