minds_sdk 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d88ff0f758abeb81dc3f474ec4cbdbd09ea71ab231a0b1fa6c4f69f3b55b955f
-  data.tar.gz: dc0e152e583e199c4a7767009003742ca8ad32acae8c8ff6090a19f83ff17609
+  metadata.gz: e7d338a8c7a60751a9ff07a8e0a80b88d5a41c8d725913d20b9a48e8101ac862
+  data.tar.gz: 5f6df32b49f25319e67d1ac7b2992bd6dd89922176f46ad5819b08aad119e698
 SHA512:
-  metadata.gz: c39da018fb204e1967817196bfd71f1e643dd7c3f29e7fff81b01aa95c7b255f95d2b49d71882ca5bc972802b574d336e6eb122742feedc20ed13674e23401f9
-  data.tar.gz: b1c59d6961862d5636cef58058617dc06e5cf47be66c5b6f0a3f1f8b393ed0a0c9f433fd99466864687c8333b47afe4f7585f1fad16aff7f1cd1a0a6e560a587
+  metadata.gz: f481f5d03353c3199685763970b6c0b78c2787819d8222bb9ad8b18e71812c9de90736400ae8ace9c21ca94b529c5267845250b595e4199735e7493af358c935
+  data.tar.gz: 93b0f55f6be94511d2172324804f6ecc7a8c2f457beb0fc17804970596305f16e1be3afdb1622996f4149938a9db5b7d38caeb401ff284a9b310c590d6cb627d

data/README.md

@@ -24,6 +24,11 @@ Or install it yourself as:
 ```bash
 $ gem install minds_sdk
 ```
+and require with:
+
+```ruby
+require 'minds'
+```
 
 ## Getting Started
 
@@ -66,6 +71,20 @@ client = Minds::Client.new(api_key: "YOUR_API_KEY", base_url: "https://<custom_c
 ```
 > Get your minds api key [here](https://mdb.ai/apiKeys)
 
+### Logging
+
+By default, the Minds SDK does not log any Faraday::Errors encountered during network requests to prevent potential data leaks. To enable error logging, you can set `log_errors` to true when configuring the client:
+
+```ruby
+# Global configuration
+Minds::Client.configure do |config|
+  config.log_errors = true
+end
+
+# Or instance configuration
+client = Minds::Client.new(log_errors: true)
+```
+
 ## Resources
 
 ### Creating a Data Source
@@ -73,7 +92,7 @@ client = Minds::Client.new(api_key: "YOUR_API_KEY", base_url: "https://<custom_c
 You can connect to various databases, such as PostgreSQL, by configuring your data source. Use the DatabaseConfig to define the connection details for your data source.
 
 ```ruby
-postgres_config = Minds::Resources::DatabaseConfig.new(
+postgres_config = Minds::DatabaseConfig.new(
   name: 'my_datasource',
   description: '<DESCRIPTION-OF-YOUR-DATA>',
   engine: 'postgres',
@@ -192,7 +211,12 @@ response = mind.completion(message: "Hello, how are you?")
 puts response
 
 # For streaming responses
-mind.completion(message: "Tell me a story", stream: true)
+mind.completion(message: "Tell me a story", stream: true) do |chunk|
+  puts chunk
+end
+
+# => {"id"=>"ad2592865b844aadbb070b3fb5090869", "choices"=>[{"delta"=>{"content"=>"I understand your request. I'm working on a detailed response for you.", "function_call"=>nil, "role"=>"assistant", "tool_calls"=>nil}, "finish_reason"=>nil, "index"=>0, "logprobs"=>nil}], "created"=>1729085931, "model"=>"mind_house_sale", "object"=>"chat.completion.chunk", "system_fingerprint"=>nil, "usage"=>nil}
+# => ...
 ```
 
 ## Development

data/lib/minds/client.rb

@@ -1,12 +1,18 @@
-require "faraday"
-require "json"
-require_relative "config/base"
-require_relative "resources/base"
-require_relative "resources/minds"
-require_relative "resources/datasources"
-
 module Minds
   class Client
+    include Minds::RestClient
+
+    SENSITIVE_ATTRIBUTES = %i[@base_url @api_key].freeze
+    CONFIG_KEYS = %i[base_url api_key log_errors api_version].freeze
+    attr_reader(*CONFIG_KEYS)
+
+    def initialize(options = {})
+      # if key not present. Fall back to global config
+      CONFIG_KEYS.each do |key|
+        instance_variable_set "@#{key}", options[key] || Client.config.send(key)
+      end
+    end
+
     class << self
       def config
         @config ||= Config::Base.new
@@ -17,20 +23,22 @@ module Minds
       end
     end
 
-    attr_accessor :base_url, :api_key
-
-    def initialize(api_key: nil, base_url: nil)
-      # if api_key & base_url not present. Fall back to global config
-      @base_url = base_url.nil? ? Minds::Client.config.send(:base_url) : base_url
-      @api_key = api_key.nil? ? Minds::Client.config.send(:api_key) : api_key
-    end
-
     def datasources
-      @datasources ||= Minds::Resources::Datasources.new(self)
+      @datasources ||= Datasources.new(client: self)
     end
 
     def minds
-      @minds ||= Minds::Resources::Minds.new(self)
+      @minds ||= Minds.new(client: self)
+    end
+
+    def inspect
+      vars = instance_variables.map do |var|
+        value = instance_variable_get(var)
+
+        SENSITIVE_ATTRIBUTES.include?(var) ? "#{var}=[FILTERED]" : "#{var}=#{value.inspect}"
+      end
+
+      "#<#{self.class}:0x#{object_id.to_s(16)} #{vars.join(', ')}>"
     end
   end
 end

data/lib/minds/config/base.rb

@@ -1,12 +1,16 @@
 module Minds
   module Config
     class Base
-      attr_accessor :base_url, :api_key
-      DEFAULT_BASE_URL = "https://mdb.ai"
+      attr_accessor :base_url, :api_key, :log_errors, :api_version
+      DEFAULT_BASE_URL = "https://mdb.ai".freeze
+      DEFAULT_LOG_ERRORS = false
+      DEFAULT_API_VERSION = "api".freeze
 
       def initialize
-        @base_url = DEFAULT_BASE_URL
         @api_key  = nil
+        @base_url = DEFAULT_BASE_URL
+        @log_errors = DEFAULT_LOG_ERRORS
+        @api_version = DEFAULT_API_VERSION
       end
     end
   end

data/lib/minds/datasources.rb

@@ -0,0 +1,89 @@
+module Minds
+  class DatabaseConfig
+    attr_reader :name, :engine, :description, :connection_data, :tables, :created_at
+
+    def initialize(name:, engine:, description:, connection_data: {}, tables: [], created_at: nil)
+      @name = name
+      @engine = engine
+      @description = description
+      @connection_data = connection_data
+      @tables = tables
+      @created_at = created_at
+    end
+
+    def to_h
+      {
+        name: @name,
+        engine: @engine,
+        description: @description,
+        connection_data: @connection_data,
+        tables: @tables
+      }
+    end
+  end
+
+  class Datasource < DatabaseConfig; end
+
+  class Datasources
+    def initialize(client:)
+      @client = client
+    end
+    # Create a new datasource and return it
+    #
+    # @param ds_config [DatabaseConfig] datasource configuration
+    # @option ds_config [String] :name Name of the datasource
+    # @option ds_config [String] :engine Type of database handler (e.g., 'postgres', 'mysql')
+    # @option ds_config [String] :description Description of the database. Used by mind to understand what data can be retrieved from it.
+    # @option ds_config [Hash] :connection_data (optional) Credentials to connect to the database
+    # @option ds_config [Array<String>] :tables (optional) List of allowed tables
+    # @param replace [Boolean] If true, replaces an existing datasource with the same name
+    # @return [Datasource] The created datasource object
+    def create(ds_config, replace = false)
+      name = ds_config.name
+      if replace
+        begin
+          find(name)
+          destroy(name, force: true)
+        end
+      end
+      @client.post(path: "datasources", parameters: ds_config.to_h)
+      find(name)
+    end
+
+    # Returns a list of all datasources
+    #
+    # @return [Array<Datasource>] An array of Datasource objects
+    def all
+      data = @client.get(path: "datasources")
+      return [] if data.empty?
+
+      data.each_with_object([]) do |item, ds_list|
+        next if item["engine"].nil?
+
+        ds_list << Datasource.new(**item.transform_keys(&:to_sym))
+      end
+    end
+
+    # Get a datasource by name
+    #
+    # @param name [String] The name of the datasource to find
+    # @return [Datasource] The found datasource object
+    # @raise [ObjectNotSupported] If the datasource type is not supported
+    def find(name)
+      data = @client.get(path: "datasources/#{name}")
+      if data["engine"].nil?
+        raise ObjectNotSupported, "Wrong type of datasource: #{name}"
+      end
+      Datasource.new(**data.transform_keys(&:to_sym))
+    end
+
+    # Destroy (delete) a datasource by name
+    #
+    # @param name [String] The name of the datasource to delete
+    # @param force: if true -remove from all minds, default: false
+    def destroy(name, force: false)
+      data = force ? { cascade: true } : nil
+      @client.delete(path: "datasources/#{name}", parameters: data)
+    end
+  end
+end

data/lib/minds/errors.rb

@@ -1,5 +1,6 @@
-class Error < StandardError; end
-
-class ValidationError < Error; end
-class ObjectNotFound < Error; end
-class ObjectNotSupported < Error; end
+module Minds
+  class Error < StandardError; end
+  class ValidationError < Error; end
+  class ObjectNotFound < Error; end
+  class ObjectNotSupported < Error; end
+end

data/lib/minds/minds.rb

@@ -0,0 +1,222 @@
+require "openai"
+require "uri"
+
+module Minds
+  DEFAULT_PROMPT_TEMPLATE = "Use your database tools to answer the user's question: {{question}}"
+
+  class Mind
+    attr_accessor :name, :model_name, :provider, :parameters, :created_at, :updated_at, :datasources
+
+    def initialize(client, attributes = {})
+      @client = client
+      @project = "mindsdb"
+      @name = attributes["name"]
+      @model_name = attributes["model_name"]
+      @provider = attributes["provider"]
+      @parameters = attributes["parameters"] || {}
+      @prompt_template = @parameters.delete("prompt_template")
+      @created_at = attributes["created_at"]
+      @updated_at = attributes["updated_at"]
+      @datasources = attributes["datasources"]
+    end
+
+    # Update the mind with new parameters
+    #
+    # @param name [String, nil] New name of the mind (optional)
+    # @param model_name [String, nil] New LLM model name (optional)
+    # @param provider [String, nil] New LLM provider (optional)
+    # @param prompt_template [String, nil] New prompt template (optional)
+    # @param datasources [Array<String, Datasource, DatabaseConfig>, nil] Alter list of datasources used by mind (optional)
+    #   Datasource can be passed as:
+    #   - String: name of the datasource
+    #   - Datasource object (Minds::Resources::Datasource)
+    #   - DatabaseConfig object (Minds::Resources::DatabaseConfig), in this case datasource will be created
+    # @param parameters [Hash, nil] Alter other parameters of the mind (optional)
+    # @return [void]
+    def update(name: nil, model_name: nil, provider: nil, prompt_template: nil, datasources: nil, parameters: nil)
+      data = {}
+
+      ds_names = []
+      datasources.each do |ds|
+        ds_name = @client.minds.check_datasource(ds)
+        ds_names << ds_name
+        data["datasources"] = ds_names
+      end if datasources
+
+      data["name"] = name if name
+      data["model_name"] = model_name if model_name
+      data["provider"] = provider if provider
+      data["parameters"] = parameters.nil? ? {} : parameters
+      data["parameters"]["prompt_template"] = prompt_template if prompt_template
+
+      @client.patch(path: "projects/#{@project}/minds/#{@name}", parameters: data)
+
+      @name = name if name && name != @name
+    end
+
+    # Add a datasource to the mind
+    #
+    # @param datasource [String, Datasource, DatabaseConfig] The datasource to add
+    #   Can be passed as:
+    #   - String: name of the datasource
+    #   - Datasource object (Minds::Resources::Datasource)
+    #   - DatabaseConfig object (Minds::Resources::DatabaseConfig), in this case datasource will be created
+    # @return [void]
+    def add_datasources(datasource)
+      ds_name = @client.minds.check_datasource(datasource)
+      data = { name: ds_name }
+      @client.post(path: "projects/#{@project}/minds/#{@name}/datasources", parameters: data)
+
+      mind = @client.minds.find(@name)
+      @datasources = mind.datasources
+    end
+
+    # Delete a datasource from the mind
+    #
+    # @param datasource [String, Datasource] The datasource to delete
+    #   Can be passed as:
+    #   - String: name of the datasource
+    #   - Datasource object (Minds::Resources::Datasource)
+    # @return [void]
+    def destroy_datasources(datasource)
+      if datasource.is_a?(Datasource)
+        datasource = datasource.name
+      elsif !datasource.is_a?(String)
+        raise ArgumentError, "Unknown type of datasource: #{datasource}"
+      end
+      @client.delete(path: "projects/#{@project}/minds/#{@name}/datasources/#{datasource}")
+
+      mind = @client.minds.find(@name)
+      @datasources = mind.datasources
+    end
+
+    # Call mind completion
+    #
+    # @param message [String] The input question or prompt
+    # @param stream [Boolean] Whether to enable stream mode (default: false)
+    # @return [String, Enumerator] If stream mode is off, returns a String.
+    #   If stream mode is on, returns an Enumerator of ChoiceDelta objects (as defined by OpenAI)
+    def completion(message:, stream: false)
+      openai_client = OpenAI::Client.new(access_token: @client.api_key, uri_base: @client.base_url)
+      params = {
+        model: @name,
+        messages: [ { role: "user", content: message } ],
+        temperature: 0
+      }
+
+      if stream
+        openai_client.chat(
+          parameters: params.merge(
+            stream: proc do |chunk, _bytesize|
+              yield chunk if block_given?
+            end
+          )
+        )
+      else
+        response = openai_client.chat(parameters: params)
+        response.dig("choices", 0, "message", "content")
+      end
+    end
+  end
+
+  class Minds
+    def initialize(client:)
+      @client = client
+      @project = "mindsdb"
+    end
+
+    # Returns a list of all minds
+    #
+    # @return [Array<Mind>] An array of Mind objects
+    def all
+      data = @client.get(path: "projects/#{@project}/minds")
+      return [] if data.empty?
+
+      data.map { |item| Mind.new(@client, item) }
+    end
+
+    # Get a mind by name
+    #
+    # @param name [String] The name of the mind to find
+    # @return [Mind] The found mind object
+    def find(name)
+      data = @client.get(path: "projects/#{@project}/minds/#{name}")
+      Mind.new(@client, data)
+    end
+
+    # Drop (delete) a mind by name
+    #
+    # @param name [String] The name of the mind to delete
+    # @return [void]
+    def destroy(name)
+      @client.delete(path: "projects/#{@project}/minds/#{name}")
+    end
+
+    # Create a new mind and return it
+    #
+    # @param name [String] The name of the mind
+    # @param model_name [String, nil] The LLM model name (optional)
+    # @param provider [String, nil] The LLM provider (optional)
+    # @param prompt_template [String, nil] Instructions to LLM (optional)
+    # @param datasources [Array<String, Datasource, DatabaseConfig>, nil] List of datasources used by mind (optional)
+    #   Datasource can be passed as:
+    #   - String: name of the datasource
+    #   - Datasource object (Minds::Datasource)
+    #   - DatabaseConfig object (Minds::DatabaseConfig), in this case datasource will be created
+    # @param parameters [Hash, nil] Other parameters of the mind (optional)
+    # @param replace [Boolean] If true, remove existing mind with the same name (default: false)
+    # @return [Mind] The created mind object
+    def create(name:, model_name: nil, provider: nil, prompt_template: nil, datasources: nil, parameters: nil, replace: false)
+      if replace
+        begin
+          find(name)
+          destroy(name)
+        end
+      end
+
+      ds_names = []
+      datasources.each do |ds|
+        ds_name = check_datasource(ds)
+        ds_names << ds_name
+      end if datasources
+
+      parameters = {} if parameters.nil?
+
+      parameters["prompt_template"] = prompt_template if prompt_template
+      parameters["prompt_template"] ||= DEFAULT_PROMPT_TEMPLATE
+      data = {
+        name: name,
+        model_name: model_name,
+        provider: provider,
+        parameters: parameters,
+        datasources: ds_names
+      }
+
+      @client.post(path: "projects/#{@project}/minds", parameters: data)
+      find(name)
+    end
+
+    def check_datasource(ds)
+      ds_name = extract_datasource_name(ds)
+      create_datasource_if_needed(ds)
+      ds_name
+    end
+
+    private
+
+    def extract_datasource_name(ds)
+      case ds
+      when Datasource, DatabaseConfig, String
+        ds.respond_to?(:name) ? ds.name : ds
+      else
+        raise ArgumentError, "Unknown type of datasource: #{ds.class}"
+      end
+    end
+
+    def create_datasource_if_needed(ds)
+      return unless ds.is_a?(DatabaseConfig)
+
+      @client.datasources.find(ds.name)
+    end
+  end
+end

data/lib/minds/rest_client.rb

@@ -0,0 +1,44 @@
+module Minds
+  module RestClient
+    def get(path:)
+      conn.get(uri(path: path))&.body
+    end
+
+    def post(path:, parameters:)
+      conn.post(uri(path: path)) do |req|
+        req.body = parameters.to_json
+      end&.body
+    end
+
+    def patch(path:, parameters:)
+      conn.patch(uri(path: path)) do |req|
+        req.body = parameters.to_json
+      end&.body
+    end
+
+    def delete(path:, parameters: nil)
+      conn.delete(uri(path: path)) do |req|
+        req.body = parameters.to_json
+      end&.body
+    end
+
+    private
+
+    def uri(path:)
+      return path if @base_url.include?(@api_version)
+
+      "/#{@api_version}/#{path}"
+    end
+
+    def conn
+      Faraday.new(url: @base_url) do |builder|
+        builder.use MiddlewareErrors if @log_errors
+        builder.headers["Authorization"] = "Bearer #{@api_key}"
+        builder.headers["Content-Type"] = "application/json"
+        builder.request :json
+        builder.response :json
+        builder.response :raise_error
+      end
+    end
+  end
+end

data/lib/minds/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Minds
-  VERSION = "0.1.1"
+  VERSION = "1.0.0"
 end

data/lib/minds.rb

@@ -1,9 +1,38 @@
 # frozen_string_literal: true
 
+require "faraday"
+require "json"
 require_relative "minds/version"
+require_relative "minds/rest_client"
 require_relative "minds/client"
 require_relative "minds/errors"
 require_relative "minds/config/base"
-require_relative "minds/resources/datasources"
+require_relative "minds/datasources"
+require_relative "minds/minds"
 
-module Minds; end
+module Minds
+  class MiddlewareErrors < Faraday::Middleware
+    def call(env)
+      @app.call(env)
+    rescue Faraday::Error => e
+      raise e unless e.response.is_a?(Hash)
+
+      logger = Logger.new($stdout)
+      logger.formatter = proc do |_severity, datetime, _progname, msg|
+        timestamp = datetime.strftime("%Y-%m-%d %H:%M:%S.%L")
+
+        error_prefix = "\033[31m[Minds #{VERSION}] #{timestamp} ERROR"
+        error_suffix = "\033[0m"
+
+        formatted_message = msg.split("\n").map do |line|
+          "#{' ' * 15}#{line}"
+        end.join("\n")
+
+        "#{error_prefix} Rest Client Error\n#{formatted_message}#{error_suffix}\n"
+      end
+
+      logger.error(e.response[:body])
+      raise e
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minds_sdk
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - tungnt
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-15 00:00:00.000000000 Z
+date: 2024-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -55,10 +55,10 @@ files:
 - lib/minds.rb
 - lib/minds/client.rb
 - lib/minds/config/base.rb
+- lib/minds/datasources.rb
 - lib/minds/errors.rb
-- lib/minds/resources/base.rb
-- lib/minds/resources/datasources.rb
-- lib/minds/resources/minds.rb
+- lib/minds/minds.rb
+- lib/minds/rest_client.rb
 - lib/minds/version.rb
 - sig/minds.rbs
 homepage: https://github.com/tungnt1203/minds_ruby_sdk

data/lib/minds/resources/base.rb

@@ -1,26 +0,0 @@
-module Minds
-  module Resources
-    class Base
-      attr_accessor :api_key, :base_url, :api
-
-      def initialize(client)
-        @base_url = client.base_url
-        @api_key = client.api_key
-        @api = conn
-      end
-
-      private
-
-      def conn
-        Faraday.new(url: @base_url) do |builder|
-          builder.request :json
-          builder.response :json
-          builder.response :raise_error
-          builder.adapter Faraday.default_adapter
-          builder.headers["Authorization"] = "Bearer #{@api_key}"
-          builder.headers["Content-Type"] = "application/json"
-        end
-      end
-    end
-  end
-end

data/lib/minds/resources/datasources.rb

@@ -1,96 +0,0 @@
-module Minds
-  module Resources
-    class DatabaseConfig
-      attr_reader :name, :engine, :description, :connection_data, :tables, :created_at
-
-      def initialize(name:, engine:, description:, connection_data: {}, tables: [], created_at: nil)
-        @name = name
-        @engine = engine
-        @description = description
-        @connection_data = connection_data
-        @tables = tables
-        @created_at = created_at
-      end
-
-      def to_h
-        {
-          name: @name,
-          engine: @engine,
-          description: @description,
-          connection_data: @connection_data,
-          tables: @tables
-        }
-      end
-    end
-
-    class Datasource < DatabaseConfig; end
-
-    class Datasources < Base
-      # Create a new datasource and return it
-      #
-      # @param ds_config [DatabaseConfig] datasource configuration
-      # @option ds_config [String] :name Name of the datasource
-      # @option ds_config [String] :engine Type of database handler (e.g., 'postgres', 'mysql')
-      # @option ds_config [String] :description Description of the database. Used by mind to understand what data can be retrieved from it.
-      # @option ds_config [Hash] :connection_data (optional) Credentials to connect to the database
-      # @option ds_config [Array<String>] :tables (optional) List of allowed tables
-      # @param replace [Boolean] If true, replaces an existing datasource with the same name
-      # @return [Datasource] The created datasource object
-      # @raise [ObjectNotFound] If the datasource to be replaced doesn't exist
-      def create(ds_config, replace = false)
-        name = ds_config.name
-
-        if replace
-          begin
-            find(name)
-            destroy(name)
-          rescue ObjectNotFound
-            # Do nothing
-          end
-        end
-        self.api.post("/api/datasources") do |req|
-          req.body = ds_config.to_h.to_json
-        end
-        find(name)
-      end
-
-      # Returns a list of all datasources
-      #
-      # @return [Array<Datasource>] An array of Datasource objects
-      def all
-        data = self.api.get("/api/datasources").body
-        data.each_with_object([]) do |item, ds_list|
-          next if item["engine"].nil?
-
-          ds_list << Datasource.new(**item.transform_keys(&:to_sym))
-        end
-      end
-
-      # Get a datasource by name
-      #
-      # @param name [String] The name of the datasource to find
-      # @return [Datasource] The found datasource object
-      # @raise [ObjectNotSupported] If the datasource type is not supported
-      def find(name)
-        data = self.api.get("api/datasources/#{name}").body
-
-        if data["engine"].nil?
-          raise ObjectNotSupported, "Wrong type of datasource: #{name}"
-        end
-
-        Datasource.new(**data.transform_keys(&:to_sym))
-      end
-
-      # Drop (delete) a datasource by name
-      #
-      # @param name [String] The name of the datasource to delete
-      # @return [void]
-      # @raise [Faraday::ResourceNotFound] If the datasource doesn't exist
-      # @raise [Faraday::ClientError] If there's a client-side error
-      # @raise [Faraday::ServerError] If there's a server-side error
-      def destroy(name)
-       self.api.delete("api/datasources/#{name}")
-      end
-    end
-  end
-end

data/lib/minds/resources/minds.rb

@@ -1,237 +0,0 @@
-require "openai"
-require "uri"
-module Minds
-  module Resources
-    DEFAULT_PROMPT_TEMPLATE = "Use your database tools to answer the user's question: {{question}}"
-
-    class Mind < Base
-      attr_accessor :name, :model_name, :provider, :parameters, :created_at, :updated_at, :datasources
-
-      def initialize(client, attributes = {})
-        super(client)
-        @project = "mindsdb"
-        @name = attributes["name"]
-        @model_name = attributes["model_name"]
-        @provider = attributes["provider"]
-        @parameters = attributes["parameters"] || {}
-        @prompt_template = @parameters.delete("prompt_template")
-        @created_at = attributes["created_at"]
-        @updated_at = attributes["updated_at"]
-        @datasources = attributes["datasources"]
-      end
-
-      # Update the mind with new parameters
-      #
-      # @param name [String, nil] New name of the mind (optional)
-      # @param model_name [String, nil] New LLM model name (optional)
-      # @param provider [String, nil] New LLM provider (optional)
-      # @param prompt_template [String, nil] New prompt template (optional)
-      # @param datasources [Array<String, Datasource, DatabaseConfig>, nil] Alter list of datasources used by mind (optional)
-      #   Datasource can be passed as:
-      #   - String: name of the datasource
-      #   - Datasource object (Minds::Resources::Datasource)
-      #   - DatabaseConfig object (Minds::Resources::DatabaseConfig), in this case datasource will be created
-      # @param parameters [Hash, nil] Alter other parameters of the mind (optional)
-      # @return [void]
-      def update(name: nil, model_name: nil, provider: nil, prompt_template: nil, datasources: nil, parameters: nil)
-        data = {}
-
-        ds_names = []
-        datasources.each do |ds|
-          minds = Minds.new(self)
-          ds_name = minds.check_datasource(ds)
-          ds_names << ds_name
-          data["datasources"] = ds_names
-        end if datasources
-
-        data["name"] = name if name
-        data["model_name"] = model_name if model_name
-        data["provider"] = provider if provider
-        data["parameters"] = parameters.nil? ? {} :  parameters
-        data["parameters"]["prompt_template"] = prompt_template if prompt_template
-
-        self.api.patch("/api/projects/#{@project}/minds/#{@name}") do |req|
-          req.body = data.to_json
-        end
-
-        @name = name if name && name != @name
-      end
-
-      # Add a datasource to the mind
-      #
-      # @param datasource [String, Datasource, DatabaseConfig] The datasource to add
-      #   Can be passed as:
-      #   - String: name of the datasource
-      #   - Datasource object (Minds::Resources::Datasource)
-      #   - DatabaseConfig object (Minds::Resources::DatabaseConfig), in this case datasource will be created
-      # @return [void]
-      def add_datasources(datasource)
-        minds = Minds.new(self)
-        ds_name = minds.check_datasource(datasource)
-        self.api.post("/api/projects/#{project}/minds/#{@name}/datasources") do |req|
-          req.body = { name: ds_name }.to_json
-        end
-
-        mind = minds.find(@name)
-
-        @datasources = mind.datasources
-      end
-
-      # Delete a datasource from the mind
-      #
-      # @param datasource [String, Datasource] The datasource to delete
-      #   Can be passed as:
-      #   - String: name of the datasource
-      #   - Datasource object (Minds::Resources::Datasource)
-      # @return [void]
-      def destroy_datasources(datasource)
-        if datasource.is_a?(Datasource)
-          datasource = datasource.name
-        elsif !datasource.is_a?(String)
-          raise ArgumentError, "Unknown type of datasource: #{datasource}"
-        end
-        self.api.delete("/api/projects/#{@project}/minds/#{@name}/datasources/#{datasource}")
-
-        minds = Minds.new(self)
-        mind = minds.find(@name)
-        @datasources = mind.datasources
-      end
-
-      # Call mind completion
-      #
-      # @param message [String] The input question or prompt
-      # @param stream [Boolean] Whether to enable stream mode (default: false)
-      # @return [String, Enumerator] If stream mode is off, returns a String.
-      #   If stream mode is on, returns an Enumerator of ChoiceDelta objects (as defined by OpenAI)
-      def completion(message:, stream: false)
-        openai_client = OpenAI::Client.new(access_token: self.api_key, uri_base: self.base_url)
-        if stream
-          openai_client.chat(
-            parameters: {
-              model: @name,
-              messages: [ { role: "user", content: message } ], # Required.
-              temperature: 0,
-              stream: proc do |chunk, _bytesize|
-                print chunk.dig("choices", 0, "delta")
-              end
-            }
-          )
-        else
-          response = openai_client.chat(
-            parameters: {
-              model: @name,
-              messages: [ { role: "user", content: message } ],
-              temperature: 0
-            }
-          )
-          response.dig("choices", 0, "message", "content")
-        end
-      end
-    end
-
-    class Minds < Base
-      def initialize(client)
-        super
-        @project = "mindsdb"
-      end
-
-      # Returns a list of all minds
-      #
-      # @return [Array<Mind>] An array of Mind objects
-      def all
-        data = self.api.get("/api/projects/#{@project}/minds").body
-        return [] if data.empty?
-
-        data.map { |item| Mind.new(self, item) }
-      end
-
-      # Get a mind by name
-      #
-      # @param name [String] The name of the mind to find
-      # @return [Mind] The found mind object
-      def find(name)
-        resp = self.api.get("/api/projects/#{@project}/minds/#{name}")
-        Mind.new(self, resp.body)
-      end
-
-      # Drop (delete) a mind by name
-      #
-      # @param name [String] The name of the mind to delete
-      # @return [void]
-      def destroy(name)
-        self.api.delete("/api/projects/#{@project}/minds/#{name}")
-      end
-
-      # Create a new mind and return it
-      #
-      # @param name [String] The name of the mind
-      # @param model_name [String, nil] The LLM model name (optional)
-      # @param provider [String, nil] The LLM provider (optional)
-      # @param prompt_template [String, nil] Instructions to LLM (optional)
-      # @param datasources [Array<String, Datasource, DatabaseConfig>, nil] List of datasources used by mind (optional)
-      #   Datasource can be passed as:
-      #   - String: name of the datasource
-      #   - Datasource object (Minds::Resources::Datasource)
-      #   - DatabaseConfig object (Minds::Resources::DatabaseConfig), in this case datasource will be created
-      # @param parameters [Hash, nil] Other parameters of the mind (optional)
-      # @param replace [Boolean] If true, remove existing mind with the same name (default: false)
-      # @return [Mind] The created mind object
-      def create(name:, model_name: nil, provider: nil, prompt_template: nil, datasources:  nil, parameters: nil, replace: false)
-        if replace
-          begin
-            find(name)
-            destroy(name)
-          rescue Faraday::ResourceNotFound
-          end
-        end
-
-        ds_names = []
-        datasources.each do |ds|
-          ds_name = check_datasource(ds)
-          ds_names << ds_name
-        end if datasources
-
-        parameters = {} if parameters.nil?
-
-        parameters["prompt_template"] = prompt_template if prompt_template
-        parameters["prompt_template"] ||= DEFAULT_PROMPT_TEMPLATE
-        self.api.post("api/projects/#{@project}/minds") do |req|
-          req.body = {
-            name: name,
-            model_name: model_name,
-            provider: provider,
-            parameters: parameters,
-            datasources: ds_names
-          }.to_json
-        end
-        find(name)
-      end
-
-      def check_datasource(ds)
-        ds_name = extract_datasource_name(ds)
-        create_datasource_if_needed(ds)
-        ds_name
-      end
-
-      private
-
-      def extract_datasource_name(ds)
-        case ds
-        when Datasource, DatabaseConfig, String
-          ds.respond_to?(:name) ? ds.name : ds
-        else
-          raise ArgumentError, "Unknown type of datasource: #{ds.class}"
-        end
-      end
-
-      def create_datasource_if_needed(ds)
-        return unless ds.is_a?(DatabaseConfig)
-
-        datasources = Datasources.new(self)
-        datasources.find(ds.name)
-      rescue Faraday::ResourceNotFound
-        datasources.create(ds)
-      end
-    end
-  end
-end