langchainrb 0.15.3 → 0.15.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c8d4d8e7dd770a724268c97b24f40ba812c1ec2b60e37242ee97da9c83a6c7d
-  data.tar.gz: 8b98e726a7079ef750324052ad6681e81f92327ba74d82ea2445ee1212e048f6
+  metadata.gz: cb478a5261da82b78d6a90b6179e4050ae0fcba274c370b507f546b59cfd1a78
+  data.tar.gz: 7fb27d8b3c68060e923e69b1c67680be20846e5a384def4c6ce0efd1c9fa56ab
 SHA512:
-  metadata.gz: d5189bbf3830a802aecf9ac67e4723b49bcbd68af5fbba6c107b656eb3658318f9a664a70344d77ae67972c1277bf19f606bf46c338d1d3f6ac4461c2f135d6b
-  data.tar.gz: b6afcec28e4228a402dfee5d8f0aefd17a2d6bcbbacece31a6781d4e4c39433d16699c92aad7147a38553a61f63154335f39cbe8240fd5b4b618f25e97d0fb5f
+  metadata.gz: b6533a4064e822c78cc7659c55c948b13b4904d75ab99fb50269f82d7f815e02ff3c0659f0b6c1905b16c0834f2577ccd136cb3d1a34db6e26b7352c77350a10
+  data.tar.gz: 170e767e0fdef21fc6051a161904ee867205bb18a98641b545adf7fe3933b499d157be52009fd20e168efa5d94e5a03c39a1a21c94c2747b8e6a0393f2099e4e

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [0.15.4] - 2024-09-10 🇧🇦
+- Fix for Langchain::Prompt::PromptTemplate supporting nested JSON data
+- Require common libs at top-level
+- Add `add_message_callback` to `Langchain::Assistant` constructor to invoke an optional function when any message is added to the conversation
+- Adding Assistant syntactic sugar with #run! and #add_message_and_run!
+
+## [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,108 @@ 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?")
+
+# Access the conversation thread
+messages = assistant.messages
+
+# Run the assistant with automatic tool execution
+assistant.run!
+```
+
+### 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.
+* `add_message_callback`: A callback function (proc, lambda) that is called when any message is added to the conversation (optional)
+
+### 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
 ```
 
-If a Tool is invoked you can manually submit an output.
+#### Example usage:
 ```ruby
-assistant.submit_tool_output tool_call_id: "...", output: "It's 70 degrees and sunny in New York City"
-```
+movie_tool = MovieInfoTool.new(api_key: "...")
 
-Or run the assistant with `auto_tool_execution: tool` to call Tools automatically.
-```ruby
-assistant.add_message content: "How about San Diego, CA?"
-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
-```
+assistant = Langchain::Assistant.new(
+  llm: llm,
+  instructions: "You're a helpful AI assistant that can provide movie information",
+  tools: [movie_tool]
+)
 
-### Accessing Thread messages
-You can access the messages in a Thread by calling `assistant.thread.messages`.
-```ruby
-assistant.messages
+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,9 @@ module Langchain
       llm:,
       thread: nil,
       tools: [],
-      instructions: nil
+      instructions: nil,
+      tool_choice: "auto",
+      add_message_callback: nil
     )
       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"
@@ -37,8 +39,12 @@ module Langchain
 
       @llm = llm
       @llm_adapter = LLM::Adapter.build(llm)
+
       @thread = thread || Langchain::Thread.new
+      @thread.add_message_callback = add_message_callback
+
       @tools = tools
+      self.tool_choice = tool_choice
       @instructions = instructions
       @state = :ready
 
@@ -49,9 +55,8 @@ module Langchain
       raise ArgumentError, "Thread must be an instance of Langchain::Thread" unless @thread.is_a?(Langchain::Thread)
 
       # The first message in the thread should be the system instructions
-      # TODO: What if the user added old messages and the system instructions are already in there? Should this overwrite the existing instructions?
-      initialize_instructions
       # For Google Gemini, and Anthropic system instructions are added to the `system:` param in the `chat` method
+      initialize_instructions
     end
 
     # Add a user message to the thread
@@ -105,6 +110,13 @@ module Langchain
       thread.messages
     end
 
+    # Run the assistant with automatic tool execution
+    #
+    # @return [Array<Langchain::Message>] The messages in the thread
+    def run!
+      run(auto_tool_execution: true)
+    end
+
     # Add a user message to the thread and run the assistant
     #
     # @param content [String] The content of the message
@@ -115,6 +127,14 @@ module Langchain
       run(auto_tool_execution: auto_tool_execution)
     end
 
+    # Add a user message to the thread and run the assistant with automatic tool execution
+    #
+    # @param content [String] The content of the message
+    # @return [Array<Langchain::Message>] The messages in the thread
+    def add_message_and_run!(content:)
+      add_message_and_run(content: content, auto_tool_execution: true)
+    end
+
     # Submit tool output to the thread
     #
     # @param tool_call_id [String] The ID of the tool call to submit output for
@@ -150,8 +170,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,20 +290,22 @@ 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)
-        add_message(role: "system", content: instructions) if instructions
+      if llm.is_a?(Langchain::LLM::OpenAI) || llm.is_a?(Langchain::LLM::MistralAI)
+        self.instructions = @instructions if @instructions
       end
     end
 
@@ -281,9 +316,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 +334,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 +365,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 +393,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 +407,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 +438,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 +487,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 +596,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 +649,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/assistants/thread.rb

@@ -4,12 +4,14 @@ module Langchain
   # Langchain::Thread keeps track of messages in a conversation.
   # TODO: Add functionality to persist to the thread to disk, DB, storage, etc.
   class Thread
-    attr_accessor :messages
+    attr_accessor :messages, :add_message_callback
 
     # @param messages [Array<Langchain::Message>]
-    def initialize(messages: [])
+    # @param add_message_callback [Proc] A callback to call when a message is added to the thread
+    def initialize(messages: [], add_message_callback: nil)
       raise ArgumentError, "messages array must only contain Langchain::Message instance(s)" unless messages.is_a?(Array) && messages.all? { |m| m.is_a?(Langchain::Messages::Base) }
 
+      @add_message_callback = add_message_callback
       @messages = messages
     end
 
@@ -34,6 +36,9 @@ module Langchain
     def add_message(message)
       raise ArgumentError, "message must be a Langchain::Message instance" unless message.is_a?(Langchain::Messages::Base)
 
+      # Call the callback with the message
+      add_message_callback.call(message) if add_message_callback # rubocop:disable Style/SafeNavigation
+
       # Prepend the message to the thread
       messages << message
     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/output_parsers/structured_output_parser.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
 require "json-schema"
 
 module Langchain::OutputParsers

data/lib/langchain/processors/eml.rb

@@ -1,4 +1,4 @@
-require "uri"
+# frozen_string_literal: true
 
 module Langchain
   module Processors

data/lib/langchain/prompt/base.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "strscan"
-require "json"
 require "yaml"
 
 module Langchain::Prompt

data/lib/langchain/prompt/loading.rb

@@ -2,7 +2,6 @@
 
 require "strscan"
 require "pathname"
-require "json"
 require "yaml"
 
 module Langchain::Prompt

data/lib/langchain/prompt/prompt_template.rb

@@ -58,8 +58,9 @@ module Langchain::Prompt
     #
     def format(**kwargs)
       result = @template
+      result = result.gsub(/{{/, "{").gsub(/}}/, "}")
       kwargs.each { |key, value| result = result.gsub(/\{#{key}\}/, value.to_s) }
-      result.gsub(/{{/, "{").gsub(/}}/, "}")
+      result
     end
 
     #

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/tool_definition.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
-
 #
 # Extends a class to be used as a tool in the assistant.
 # A tool is a collection of functions (methods) used to perform specific tasks.
@@ -42,8 +40,8 @@ module Langchain::ToolDefinition
   # @param method_name [Symbol] Name of the method to define
   # @param description [String] Description of the function
   # @yield Block that defines the parameters for the function
-  def define_function(method_name, description:, &)
-    function_schemas.add_function(method_name:, description:, &)
+  def define_function(method_name, description:, &block)
+    function_schemas.add_function(method_name:, description:, &block)
   end
 
   # Returns the FunctionSchemas instance for this tool
@@ -76,11 +74,11 @@ module Langchain::ToolDefinition
     # @param description [String] Description of the function
     # @yield Block that defines the parameters for the function
     # @raise [ArgumentError] If a block is defined and no parameters are specified for the function
-    def add_function(method_name:, description:, &)
+    def add_function(method_name:, description:, &block)
       name = "#{@tool_name}__#{method_name}"
 
-      if block_given?
-        parameters = ParameterBuilder.new(parent_type: "object").build(&)
+      if block_given? # rubocop:disable Performance/BlockGivenWithExplicitBlock
+        parameters = ParameterBuilder.new(parent_type: "object").build(&block)
 
         if parameters[:properties].empty?
           raise ArgumentError, "Function parameters must have at least one property defined within it, if a block is provided"
@@ -130,8 +128,8 @@ module Langchain::ToolDefinition
     #
     # @yield Block that defines the properties of the schema
     # @return [Hash] The built schema
-    def build(&)
-      instance_eval(&)
+    def build(&block)
+      instance_eval(&block)
       @schema
     end
 
@@ -144,13 +142,13 @@ module Langchain::ToolDefinition
     # @param required [Boolean] Whether the property is required
     # @yield [Block] Block for nested properties (only for object and array types)
     # @raise [ArgumentError] If any parameter is invalid
-    def property(name = nil, type:, description: nil, enum: nil, required: false, &)
+    def property(name = nil, type:, description: nil, enum: nil, required: false, &block)
       validate_parameters(name:, type:, enum:, required:)
 
       prop = {type:, description:, enum:}.compact
 
-      if block_given?
-        nested_schema = ParameterBuilder.new(parent_type: type).build(&)
+      if block_given? # rubocop:disable Performance/BlockGivenWithExplicitBlock
+        nested_schema = ParameterBuilder.new(parent_type: type).build(&block)
 
         case type
         when "object"

data/lib/langchain/vectorsearch/epsilla.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
 require "securerandom"
-require "json"
 require "timeout"
-require "uri"
 
 module Langchain::Vectorsearch
   class Epsilla < Base

data/lib/langchain/version.rb

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

data/lib/langchain.rb

@@ -4,6 +4,9 @@ require "logger"
 require "pathname"
 require "rainbow"
 require "zeitwerk"
+require "uri"
+require "json"
+
 loader = Zeitwerk::Loader.for_gem
 loader.ignore("#{__dir__}/langchainrb.rb")
 loader.inflector.inflect(
@@ -18,6 +21,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",
@@ -29,6 +33,7 @@ loader.collapse("#{__dir__}/langchain/assistants")
 
 loader.collapse("#{__dir__}/langchain/tool/calculator")
 loader.collapse("#{__dir__}/langchain/tool/database")
+loader.collapse("#{__dir__}/langchain/tool/docs_tool")
 loader.collapse("#{__dir__}/langchain/tool/file_system")
 loader.collapse("#{__dir__}/langchain/tool/google_search")
 loader.collapse("#{__dir__}/langchain/tool/ruby_code_interpreter")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: langchainrb
 version: !ruby/object:Gem::Version
-  version: 0.15.3
+  version: 0.15.5
 platform: ruby
 authors:
 - Andrei Bondarev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-27 00:00:00.000000000 Z
+date: 2024-09-10 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