langchainrb 0.15.3 → 0.15.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c8d4d8e7dd770a724268c97b24f40ba812c1ec2b60e37242ee97da9c83a6c7d
-  data.tar.gz: 8b98e726a7079ef750324052ad6681e81f92327ba74d82ea2445ee1212e048f6
+  metadata.gz: 68d2d64fb264bf47488e83581540b88f7746f0e1b1b318d7dfc9c15356f40c8c
+  data.tar.gz: efbd840632f0f22b202d9257a2020c4bc49cea7528d79efa7e05f963e9e4745f
 SHA512:
-  metadata.gz: d5189bbf3830a802aecf9ac67e4723b49bcbd68af5fbba6c107b656eb3658318f9a664a70344d77ae67972c1277bf19f606bf46c338d1d3f6ac4461c2f135d6b
-  data.tar.gz: b6afcec28e4228a402dfee5d8f0aefd17a2d6bcbbacece31a6781d4e4c39433d16699c92aad7147a38553a61f63154335f39cbe8240fd5b4b618f25e97d0fb5f
+  metadata.gz: f57817cc62de3af8f9aa80c62e421255e4172f55d54d91c1adc7d7a03ac9272e866670532c996a19d502c6d3110627d778efdad8c4faad0b07868c8b0aebc81c
+  data.tar.gz: b35d82314edc0d747c87a37bd0e2036755f884e85977639e8b53063ca8ebd7002b9dd4ae9a5dd443f088552e575471e080dc9aa4519e25efaa908e16130b613a

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [0.15.4] - 2024-08-30
+- Improve the Langchain::Tool::Database tool
+- Allow explictly setting tool_choice on the Assistant instance
+- Add support for bulk embedding in Ollama
+- `Langchain::Assistant` works with `Langchain::LLM::MistralAI` llm
+- Fix Langchain::LLM::Azure not applying full default_options
+
 ## [0.15.3] - 2024-08-27
 - Fix OpenAI#embed when text-embedding-ada-002 is used
 

data/README.md

@@ -402,75 +402,107 @@ client.ask(question: "...")
 ```
 
 ## Assistants
-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 (currently only OpenAI), any vector search database and easily extended with additional tools.
-
-### Available Tools 🛠️
-
-| Name         | Description                                        | ENV Requirements                                              | Gem Requirements                          |
-| ------------ | :------------------------------------------------: | :-----------------------------------------------------------: | :---------------------------------------: |
-| "calculator" | Useful for getting the result of a math expression |                                                               | `gem "eqn", "~> 1.6.5"`                   |
-| "database"   | Useful for querying a SQL database |                                                               | `gem "sequel", "~> 5.68.0"`                   |
-| "file_system"   | Interacts with the file system |                                                               |       |
-| "ruby_code_interpreter" | Interprets Ruby expressions             |                                                               | `gem "safe_ruby", "~> 1.0.4"`             |
-| "google_search"     | A wrapper around Google Search                     | `ENV["SERPAPI_API_KEY"]` (https://serpapi.com/manage-api-key) | `gem "google_search_results", "~> 2.0.0"` |
-| "news_retriever"     | A wrapper around NewsApi.org                     | `ENV["NEWS_API_KEY"]` (https://newsapi.org/) |  |
-| "tavily"     | A wrapper around Tavily AI                     | `ENV["TAVILY_API_KEY"]` (https://tavily.com/) |  |
-| "weather"  | Calls Open Weather API to retrieve the current weather        |      `ENV["OPEN_WEATHER_API_KEY"]` (https://home.openweathermap.org/api_keys)               |    |
-| "wikipedia"  | Calls Wikipedia API to retrieve the summary        |                                                               | `gem "wikipedia-client", "~> 1.17.0"`     |
+`Langchain::Assistant` is a powerful and flexible class that combines Large Language Models (LLMs), tools, and conversation management to create intelligent, interactive assistants. It's designed to handle complex conversations, execute tools, and provide coherent responses based on the context of the interaction.
 
-### Demos
-1. [Building an AI Assistant that operates a simulated E-commerce Store](https://www.loom.com/share/83aa4fd8dccb492aad4ca95da40ed0b2)
-2. [New Langchain.rb Assistants interface](https://www.loom.com/share/e883a4a49b8746c1b0acf9d58cf6da36)
-3. [Langchain.rb Assistant demo with NewsRetriever and function calling on Gemini](https://youtu.be/-ieyahrpDpM&t=1477s) - [code](https://github.com/palladius/gemini-news-crawler)
+### Features
+* Supports multiple LLM providers (OpenAI, Google Gemini, Anthropic, Mistral AI and open-source models via Ollama)
+* Integrates with various tools to extend functionality
+* Manages conversation threads
+* Handles automatic and manual tool execution
+* Supports different message formats for various LLM providers
 
-### Creating an Assistant
-1. Instantiate an LLM of your choice
+### Usage
 ```ruby
 llm = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"])
-```
-2. Instantiate an Assistant
-```ruby
 assistant = Langchain::Assistant.new(
   llm: llm,
-  instructions: "You are a Meteorologist Assistant that is able to pull the weather for any location",
-  tools: [
-    Langchain::Tool::Weather.new(api_key: ENV["OPEN_WEATHER_API_KEY"])
-  ]
+  instructions: "You're a helpful AI assistant",
+  tools: [Langchain::Tool::NewsRetriever.new(api_key: ENV["NEWS_API_KEY"])]
 )
-```
-### Using an Assistant
-You can now add your message to an Assistant.
-```ruby
-assistant.add_message content: "What's the weather in New York, New York?"
-```
 
-Run the Assistant to generate a response. 
-```ruby
-assistant.run
-```
+# Add a user message and run the assistant
+assistant.add_message_and_run(content: "What's the latest news about AI?")
 
-If a Tool is invoked you can manually submit an output.
-```ruby
-assistant.submit_tool_output tool_call_id: "...", output: "It's 70 degrees and sunny in New York City"
-```
+# Access the conversation thread
+messages = assistant.messages
 
-Or run the assistant with `auto_tool_execution: tool` to call Tools automatically.
-```ruby
-assistant.add_message content: "How about San Diego, CA?"
+# Run the assistant with automatic tool execution
 assistant.run(auto_tool_execution: true)
 ```
-You can also combine the two by calling:
-```ruby
-assistant.add_message_and_run content: "What about Sacramento, CA?", auto_tool_execution: true
+
+### Configuration
+* `llm`: The LLM instance to use (required)
+* `tools`: An array of tool instances (optional)
+* `instructions`: System instructions for the assistant (optional)
+* `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.
+
+### Key Methods
+* `add_message`: Adds a user message to the messages array
+* `run`: Processes the conversation and generates responses
+* `add_message_and_run`: Combines adding a message and running the assistant
+* `submit_tool_output`: Manually submit output to a tool call
+* `messages`: Returns a list of ongoing messages
+
+### Built-in Tools 🛠️
+* `Langchain::Tool::Calculator`: Useful for evaluating math expressions. Requires `gem "eqn"`.
+* `Langchain::Tool::Database`: Connect your SQL database. Requires `gem "sequel"`.
+* `Langchain::Tool::FileSystem`: Interact with the file system (read & write).
+* `Langchain::Tool::RubyCodeInterpreter`: Useful for evaluating generated Ruby code. Requires `gem "safe_ruby"` (In need of a better solution).
+* `Langchain::Tool::NewsRetriever`: A wrapper around [NewsApi.org](https://newsapi.org) to fetch news articles.
+* `Langchain::Tool::Tavily`: A wrapper around [Tavily AI](https://tavily.com).
+* `Langchain::Tool::Weather`: Calls [Open Weather API](https://home.openweathermap.org) to retrieve the current weather.
+* `Langchain::Tool::Wikipedia`: Calls Wikipedia API.
+
+### Creating custom Tools
+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
+
+  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
+  end
+
+  define_function :get_movie_details, description: "MovieInfoTool: Get detailed information about a specific movie" do
+    property :movie_id, type: "integer", description: "The TMDb ID of the movie", required: true
+  end
+
+  def initialize(api_key:)
+    @api_key = api_key
+  end
+
+  def search_movie(query:)
+    ...
+  end
+
+  def get_movie_details(movie_id:)
+    ...
+  end
+end
 ```
 
-### Accessing Thread messages
-You can access the messages in a Thread by calling `assistant.thread.messages`.
+#### Example usage:
 ```ruby
-assistant.messages
+movie_tool = MovieInfoTool.new(api_key: "...")
+
+assistant = Langchain::Assistant.new(
+  llm: llm,
+  instructions: "You're a helpful AI assistant that can provide movie information",
+  tools: [movie_tool]
+)
+
+assistant.add_message_and_run(content: "Can you tell me about the movie 'Inception'?")
+# Check the response in the last message in the conversation
+assistant.messages.last
 ```
 
-The Assistant checks the context window limits before every request to the LLM and remove oldest thread messages one by one if the context window is exceeded.
+### Error Handling
+The assistant includes error handling for invalid inputs, unsupported LLM types, and tool execution failures. It uses a state machine to manage the conversation flow and handle different scenarios gracefully.
+
+### Demos
+1. [Building an AI Assistant that operates a simulated E-commerce Store](https://www.loom.com/share/83aa4fd8dccb492aad4ca95da40ed0b2)
+2. [New Langchain.rb Assistants interface](https://www.loom.com/share/e883a4a49b8746c1b0acf9d58cf6da36)
+3. [Langchain.rb Assistant demo with NewsRetriever and function calling on Gemini](https://youtu.be/-ieyahrpDpM&t=1477s) - [code](https://github.com/palladius/gemini-news-crawler)
 
 ## Evaluations (Evals)
 The Evaluations module is a collection of tools that can be used to evaluate and track the performance of the output products by LLM and your RAG (Retrieval Augmented Generation) pipelines.

data/lib/langchain/assistants/assistant.rb

@@ -15,7 +15,7 @@ module Langchain
     extend Forwardable
     def_delegators :thread, :messages
 
-    attr_reader :llm, :thread, :instructions, :state
+    attr_reader :llm, :thread, :instructions, :state, :llm_adapter, :tool_choice
     attr_reader :total_prompt_tokens, :total_completion_tokens, :total_tokens
     attr_accessor :tools
 
@@ -29,7 +29,8 @@ module Langchain
       llm:,
       thread: nil,
       tools: [],
-      instructions: nil
+      instructions: nil,
+      tool_choice: "auto"
     )
       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"
@@ -39,6 +40,7 @@ module Langchain
       @llm_adapter = LLM::Adapter.build(llm)
       @thread = thread || Langchain::Thread.new
       @tools = tools
+      self.tool_choice = tool_choice
       @instructions = instructions
       @state = :ready
 
@@ -150,8 +152,21 @@ module Langchain
       thread.messages.unshift(message)
     end
 
+    def tool_choice=(new_tool_choice)
+      validate_tool_choice!(new_tool_choice)
+      @tool_choice = new_tool_choice
+    end
+
     private
 
+    # TODO: If tool_choice = "tool_function_name" and then tool is removed from the assistant, should we set tool_choice back to "auto"?
+    def validate_tool_choice!(tool_choice)
+      allowed_tool_choices = llm_adapter.allowed_tool_choices.concat(available_tool_names)
+      unless allowed_tool_choices.include?(tool_choice)
+        raise ArgumentError, "Tool choice must be one of: #{allowed_tool_choices.join(", ")}"
+      end
+    end
+
     # Check if the run is finished
     #
     # @param auto_tool_execution [Boolean] Whether or not to automatically run tools
@@ -257,19 +272,21 @@ module Langchain
     # @return [String] The tool role
     def determine_tool_role
       case llm
+      when Langchain::LLM::Anthropic
+        Langchain::Messages::AnthropicMessage::TOOL_ROLE
+      when Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI
+        Langchain::Messages::GoogleGeminiMessage::TOOL_ROLE
+      when Langchain::LLM::MistralAI
+        Langchain::Messages::MistralAIMessage::TOOL_ROLE
       when Langchain::LLM::Ollama
         Langchain::Messages::OllamaMessage::TOOL_ROLE
       when Langchain::LLM::OpenAI
         Langchain::Messages::OpenAIMessage::TOOL_ROLE
-      when Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI
-        Langchain::Messages::GoogleGeminiMessage::TOOL_ROLE
-      when Langchain::LLM::Anthropic
-        Langchain::Messages::AnthropicMessage::TOOL_ROLE
       end
     end
 
     def initialize_instructions
-      if llm.is_a?(Langchain::LLM::OpenAI)
+      if llm.is_a?(Langchain::LLM::OpenAI) || llm.is_a?(Langchain::LLM::MistralAI)
         add_message(role: "system", content: instructions) if instructions
       end
     end
@@ -281,9 +298,10 @@ module Langchain
       Langchain.logger.info("Sending a call to #{llm.class}", for: self.class)
 
       params = @llm_adapter.build_chat_params(
-        tools: @tools,
         instructions: @instructions,
-        messages: thread.array_of_message_hashes
+        messages: thread.array_of_message_hashes,
+        tools: @tools,
+        tool_choice: tool_choice
       )
       @llm.chat(**params)
     end
@@ -298,7 +316,7 @@ module Langchain
 
         tool_instance = tools.find do |t|
           t.class.tool_name == tool_name
-        end or raise ArgumentError, "Tool not found in assistant.tools"
+        end or raise ArgumentError, "Tool: #{tool_name} not found in assistant.tools"
 
         output = tool_instance.send(method_name, **tool_arguments)
 
@@ -329,20 +347,26 @@ module Langchain
       @total_tokens += total_tokens_from_operation if total_tokens_from_operation
     end
 
+    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
-          when Langchain::LLM::GoogleGemini, Langchain::LLM::GoogleVertexAI
-            Adapters::GoogleGemini.new
-          when Langchain::LLM::Anthropic
-            Adapters::Anthropic.new
           else
             raise ArgumentError, "Unsupported LLM type: #{llm.class}"
           end
@@ -351,7 +375,7 @@ module Langchain
 
       module Adapters
         class Base
-          def build_chat_params(tools:, instructions:, messages:)
+          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
             raise NotImplementedError, "Subclasses must implement build_chat_params"
           end
 
@@ -365,10 +389,10 @@ module Langchain
         end
 
         class Ollama < Base
-          def build_chat_params(tools:, instructions:, messages:)
+          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
             params = {messages: messages}
             if tools.any?
-              params[:tools] = tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten
+              params[:tools] = build_tools(tools)
             end
             params
           end
@@ -396,14 +420,28 @@ module Langchain
 
             [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:)
+          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
             params = {messages: messages}
             if tools.any?
-              params[:tools] = tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten
-              params[:tool_choice] = "auto"
+              params[:tools] = build_tools(tools)
+              params[:tool_choice] = build_tool_choice(tool_choice)
             end
             params
           end
@@ -431,15 +469,96 @@ module Langchain
 
             [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, tool_calls: [], tool_call_id: nil)
+            Langchain::Messages::MistralAIMessage.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 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:)
+          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
             params = {messages: messages}
             if tools.any?
-              params[:tools] = tools.map { |tool| tool.class.function_schemas.to_google_gemini_format }.flatten
+              params[:tools] = build_tools(tools)
               params[:system] = instructions if instructions
-              params[:tool_choice] = "auto"
+              params[:tool_choice] = build_tool_config(tool_choice)
             end
             params
           end
@@ -459,14 +578,39 @@ module Langchain
             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:)
+          def build_chat_params(tools:, instructions:, messages:, tool_choice:)
             params = {messages: messages}
             if tools.any?
-              params[:tools] = tools.map { |tool| tool.class.function_schemas.to_anthropic_format }.flatten
-              params[:tool_choice] = {type: "auto"}
+              params[:tools] = build_tools(tools)
+              params[:tool_choice] = build_tool_choice(tool_choice)
             end
             params[:system] = instructions if instructions
             params
@@ -487,6 +631,31 @@ module Langchain
             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

data/lib/langchain/assistants/messages/mistral_ai_message.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Langchain
+  module Messages
+    class MistralAIMessage < Base
+      # MistralAI uses the following roles:
+      ROLES = [
+        "system",
+        "assistant",
+        "user",
+        "tool"
+      ].freeze
+
+      TOOL_ROLE = "tool"
+
+      # Initialize a new MistralAI message
+      #
+      # @param [String] The role of the message
+      # @param [String] The content of the message
+      # @param [Array<Hash>] The tool calls made in the message
+      # @param [String] The ID of the tool call
+      def initialize(role:, content: nil, tool_calls: [], tool_call_id: nil) # TODO: Implement image_file: reference (https://platform.openai.com/docs/api-reference/messages/object#messages/object-content)
+        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
+        @tool_calls = tool_calls
+        @tool_call_id = tool_call_id
+      end
+
+      # Check if the message came from an LLM
+      #
+      # @return [Boolean] true/false whether this message was produced by an LLM
+      def llm?
+        assistant?
+      end
+
+      # Convert the message to an MistralAI API-compatible hash
+      #
+      # @return [Hash] The message as an MistralAI API-compatible hash
+      def to_hash
+        {}.tap do |h|
+          h[:role] = role
+          h[:content] = content if content # Content is nil for tool calls
+          h[:tool_calls] = tool_calls if tool_calls.any?
+          h[:tool_call_id] = tool_call_id if tool_call_id
+        end
+      end
+
+      # Check if the message came from an LLM
+      #
+      # @return [Boolean] true/false whether this message was produced by an LLM
+      def assistant?
+        role == "assistant"
+      end
+
+      # Check if the message are system instructions
+      #
+      # @return [Boolean] true/false whether this message are system instructions
+      def system?
+        role == "system"
+      end
+
+      # Check if the message is a tool call
+      #
+      # @return [Boolean] true/false whether this message is a tool call
+      def tool?
+        role == "tool"
+      end
+    end
+  end
+end

data/lib/langchain/llm/azure.rb

@@ -33,8 +33,11 @@ module Langchain::LLM
       )
       @defaults = DEFAULTS.merge(default_options)
       chat_parameters.update(
+        model: {default: @defaults[:chat_completion_model_name]},
         logprobs: {},
         top_logprobs: {},
+        n: {default: @defaults[:n]},
+        temperature: {default: @defaults[:temperature]},
         user: {}
       )
       chat_parameters.ignore(:top_k)

data/lib/langchain/llm/google_gemini.rb

@@ -39,7 +39,6 @@ module Langchain::LLM
     def chat(params = {})
       params[:system] = {parts: [{text: params[:system]}]} if params[:system]
       params[:tools] = {function_declarations: params[:tools]} if params[:tools]
-      params[:tool_choice] = {function_calling_config: {mode: params[:tool_choice].upcase}} if params[:tool_choice]
 
       raise ArgumentError.new("messages argument is required") if Array(params[:messages]).empty?
 

data/lib/langchain/llm/mistral_ai.rb

@@ -8,7 +8,7 @@ module Langchain::LLM
   #    llm = Langchain::LLM::MistralAI.new(api_key: ENV["MISTRAL_AI_API_KEY"])
   class MistralAI < Base
     DEFAULTS = {
-      chat_completion_model_name: "mistral-medium",
+      chat_completion_model_name: "mistral-large-latest",
       embeddings_model_name: "mistral-embed"
     }.freeze
 

data/lib/langchain/llm/ollama.rb

@@ -218,8 +218,8 @@ module Langchain::LLM
       top_p: nil
     )
       parameters = {
-        prompt: text,
-        model: model
+        model: model,
+        input: Array(text)
       }.compact
 
       llm_parameters = {
@@ -243,7 +243,7 @@ module Langchain::LLM
 
       parameters[:options] = llm_parameters.compact
 
-      response = client.post("api/embeddings") do |req|
+      response = client.post("api/embed") do |req|
         req.body = parameters
       end
 

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

@@ -7,7 +7,15 @@ module Langchain::LLM
     end
 
     def chat_completion
-      raw_response.dig("choices", 0, "message", "content")
+      chat_completions.dig(0, "message", "content")
+    end
+
+    def chat_completions
+      raw_response.dig("choices")
+    end
+
+    def tool_calls
+      chat_completions.dig(0, "message", "tool_calls") || []
     end
 
     def role

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

@@ -28,7 +28,7 @@ module Langchain::LLM
     end
 
     def embeddings
-      [raw_response&.dig("embedding")]
+      raw_response&.dig("embeddings") || []
     end
 
     def role

data/lib/langchain/tool/database.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Langchain::Tool
   #
-  # Connects to a database, executes SQL queries, and outputs DB schema for Agents to use
+  # Connects to a SQL database, executes SQL queries, and outputs DB schema for Agents to use
   #
   # Gem requirements:
   #     gem "sequel", "~> 5.68.0"
@@ -15,7 +17,9 @@ module Langchain::Tool
     define_function :list_tables, description: "Database Tool: Returns a list of tables in the database"
 
     define_function :describe_tables, description: "Database Tool: Returns the schema for a list of tables" do
-      property :tables, type: "string", description: "The tables to describe", required: true
+      property :tables, type: "array", description: "The tables to describe", required: true do
+        item type: "string"
+      end
     end
 
     define_function :dump_schema, description: "Database Tool: Returns the database schema"
@@ -38,25 +42,32 @@ module Langchain::Tool
       raise StandardError, "connection_string parameter cannot be blank" if connection_string.empty?
 
       @db = Sequel.connect(connection_string)
+      # TODO: This is a bug, these 2 parameters are completely ignored.
       @requested_tables = tables
       @excluded_tables = exclude_tables
     end
 
     # Database Tool: Returns a list of tables in the database
+    #
+    # @return [Array<Symbol>] List of tables in the database
     def list_tables
       db.tables
     end
 
     # Database Tool: Returns the schema for a list of tables
     #
-    # @param tables [String] The tables to describe.
-    # @return [String] Database schema for the tables
-    def describe_tables(tables:)
-      schema = ""
-      tables.split(",").each do |table|
-        describe_table(table, schema)
-      end
-      schema
+    # @param tables [Array<String>] The tables to describe.
+    # @return [String] The schema for the tables
+    def describe_tables(tables: [])
+      return "No tables specified" if tables.empty?
+
+      Langchain.logger.info("Describing tables: #{tables}", for: self.class)
+
+      tables
+        .map do |table|
+          describe_table(table)
+        end
+        .join("\n")
     end
 
     # Database Tool: Returns the database schema
@@ -64,18 +75,39 @@ module Langchain::Tool
     # @return [String] Database schema
     def dump_schema
       Langchain.logger.info("Dumping schema tables and keys", for: self.class)
-      schema = ""
-      db.tables.each do |table|
-        describe_table(table, schema)
+
+      schemas = db.tables.map do |table|
+        describe_table(table)
       end
-      schema
+      schemas.join("\n")
     end
 
-    def describe_table(table, schema)
+    # Database Tool: Executes a SQL query and returns the results
+    #
+    # @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)
+
+      db[input].to_a
+    rescue Sequel::DatabaseError => e
+      Langchain.logger.error(e.message, for: self.class)
+      e.message # Return error to LLM
+    end
+
+    private
+
+    # Describes a table and its schema
+    #
+    # @param table [String] The table to describe
+    # @return [String] The schema for the table
+    def describe_table(table)
+      # TODO: There's probably a clear way to do all of this below
+
       primary_key_columns = []
       primary_key_column_count = db.schema(table).count { |column| column[1][:primary_key] == true }
 
-      schema << "CREATE TABLE #{table}(\n"
+      schema = "CREATE TABLE #{table}(\n"
       db.schema(table).each do |column|
         schema << "#{column[0]} #{column[1][:type]}"
         if column[1][:primary_key] == true
@@ -95,17 +127,5 @@ module Langchain::Tool
       end
       schema << ");\n"
     end
-
-    # Database Tool: Executes a SQL query and returns the results
-    #
-    # @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)
-
-      db[input].to_a
-    rescue Sequel::DatabaseError => e
-      Langchain.logger.error(e.message, for: self.class)
-    end
   end
 end

data/lib/langchain/version.rb

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

data/lib/langchain.rb

@@ -18,6 +18,7 @@ loader.inflector.inflect(
   "llm" => "LLM",
   "mistral_ai" => "MistralAI",
   "mistral_ai_response" => "MistralAIResponse",
+  "mistral_ai_message" => "MistralAIMessage",
   "openai" => "OpenAI",
   "openai_validator" => "OpenAIValidator",
   "openai_response" => "OpenAIResponse",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: langchainrb
 version: !ruby/object:Gem::Version
-  version: 0.15.3
+  version: 0.15.4
 platform: ruby
 authors:
 - Andrei Bondarev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-27 00:00:00.000000000 Z
+date: 2024-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: baran
@@ -669,6 +669,7 @@ files:
 - lib/langchain/assistants/messages/anthropic_message.rb
 - lib/langchain/assistants/messages/base.rb
 - lib/langchain/assistants/messages/google_gemini_message.rb
+- lib/langchain/assistants/messages/mistral_ai_message.rb
 - lib/langchain/assistants/messages/ollama_message.rb
 - lib/langchain/assistants/messages/openai_message.rb
 - lib/langchain/assistants/thread.rb