minds_sdk 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c7f832efbb02c672f51644db5065474eb0795f5a34da8f97b1dcd345d43cd02
-  data.tar.gz: 6f0518f9fb72275fe165e1ef5ce47433f38eadfcf755c7dc0716d85cb488505f
+  metadata.gz: e7d338a8c7a60751a9ff07a8e0a80b88d5a41c8d725913d20b9a48e8101ac862
+  data.tar.gz: 5f6df32b49f25319e67d1ac7b2992bd6dd89922176f46ad5819b08aad119e698
 SHA512:
-  metadata.gz: 1c0b304a9f92c73c61e9d96d9e9ef33e726dffd39740e92185ae6543eec606e2a3ea8b4dcdfcb3eb1e775f20ffbff445a1fb26e44e175c347d78d4432da41c93
-  data.tar.gz: 822c1f3baa51a8f9385787c0f984f9241b68e5b13df67c1d281cdf626c6937c68c0c49bbae493948f8a6e811c140378e23e092a923a69a0bae7e322c89e963d2
+  metadata.gz: f481f5d03353c3199685763970b6c0b78c2787819d8222bb9ad8b18e71812c9de90736400ae8ace9c21ca94b529c5267845250b595e4199735e7493af358c935
+  data.tar.gz: 93b0f55f6be94511d2172324804f6ecc7a8c2f457beb0fc17804970596305f16e1be3afdb1622996f4149938a9db5b7d38caeb401ff284a9b310c590d6cb627d

data/README.md

@@ -1,7 +1,10 @@
 # Minds Ruby SDK
+[![Gem Version](https://badge.fury.io/rb/minds_sdk.svg)](https://badge.fury.io/rb/minds_sdk)
 
 Minds Ruby SDK provides an interface to interact with the Minds AI system API. It allows you to create and manage "minds" (artificial intelligences), create chat completions, and manage data sources.
 
+The best starting point is the [Mind Website](https://docs.mdb.ai/docs/data-mind), with its introduction and explanation.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -21,6 +24,11 @@ Or install it yourself as:
 ```bash
 $ gem install minds_sdk
 ```
+and require with:
+
+```ruby
+require 'minds'
+```
 
 ## Getting Started
 
@@ -44,7 +52,7 @@ end
 Alternatively, you can configure each client instance individually:
 
 ```ruby
-client = Minds::Client.new("YOUR_API_KEY", "https://mdb.ai")
+client = Minds::Client.new(api_key: "YOUR_API_KEY", base_url: "https://mdb.ai")
 ```
 
 ### Initialize the Client
@@ -56,19 +64,35 @@ After configuration, you can initialize the client:
 client = Minds::Client.new
 
 # Or with instance-specific configuration
-client = Minds::Client.new("YOUR_API_KEY", "https://mdb.ai")
+client = Minds::Client.new(api_key: "YOUR_API_KEY", base_url: "https://mdb.ai")
 
 # For a self-hosted Minds Cloud instance
-client = Minds::Client.new("YOUR_API_KEY", "https://<custom_cloud>.mdb.ai")
+client = Minds::Client.new(api_key: "YOUR_API_KEY", base_url: "https://<custom_cloud>.mdb.ai")
+```
+> 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
 
 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',
@@ -83,9 +107,10 @@ postgres_config = Minds::Resources::DatabaseConfig.new(
   tables: ['<TABLE-1>', '<TABLE-2>']
 )
 
-See supported [Data Sources](https://docs.mdb.ai/docs/data_sources)
 ```
 
+> See supported [Data Sources](https://docs.mdb.ai/docs/data_sources)
+
 ### Creating a Mind
 
 You can create a mind and associate it with a data source.
@@ -132,7 +157,7 @@ mind.update(
 You can list all the minds you've created:
 
 ```ruby
-puts client.minds.all
+client.minds.all
 ```
 
 ### Get a Mind by Name
@@ -156,7 +181,7 @@ client.minds.destroy('mind_name')
 To view all data sources:
 
 ```ruby
-puts client.datasources.all
+client.datasources.all
 ```
 
 ### Get a Data Source by Name
@@ -186,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
@@ -195,11 +225,13 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at [here](https://github.com/your_github_username/minds_ruby_sdk).
+Bug reports and pull requests are welcome on GitHub at [here](https://github.com/tungnt1203/minds_ruby_sdk).
 
 ## Acknowledgments
 
-This SDK is built for integration with Minds, AI layer for existing databases. We would like to express our gratitude to the MindsDB team for their innovative work in making AI more accessible.
+This SDK is built for integration with Minds, AI layer for existing databases. See more docs [here](https://docs.mdb.ai/docs/data-mind)
+
+We would like to express our gratitude to the MindsDB team for their innovative work in making AI more accessible.
 For more information about MindsDB, please visit their official website: [https://mindsdb.com/](https://mindsdb.com/)
 ## License
 

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,26 +23,22 @@ module Minds
       end
     end
 
-    attr_accessor :base_url, :api_key
-    DEFAULT_HOST = "https://mdb.ai"
-
-    def initialize(api_key = nil, base_url = nil)
-      # if api_key & base_url not present. Fall back to global config
-      @base_url =
-        if base_url.nil?
-          Minds::Client.config.send(:base_url).nil? ? DEFAULT_HOST : Minds::Client.config.send(:base_url)
-        else
-          base_url
-        end
-      @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,11 +1,16 @@
 module Minds
   module Config
     class Base
-      attr_accessor :base_url, :api_key
+      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 = nil
         @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.0"
+  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.0
+  version: 1.0.0
 platform: ruby
 authors:
 - tungnt
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-13 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,95 +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,247 +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)
-        parsed = URI.parse(self.api.base_url)
-        host = parsed.host
-        if host == "mdb.ai"
-          llm_host = "llm.mdb.ai"
-        else
-          llm_host = "ai.#{host}"
-        end
-        parsed.host = llm_host
-        parsed.path = ""
-        parsed.query = nil
-        uri_base = parsed
-        openai_client = OpenAI::Client.new(access_token: self.api_key, uri_base: uri_base)
-        if stream
-          openai_client.chat(
-            parameters: {
-              model: @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: @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
-        resp = self.api.get("/api/projects/#{@project}/minds")
-        resp.body
-        resp.body.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
-
-          find(name)
-        end
-      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