minds_sdk 0.1.1 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d88ff0f758abeb81dc3f474ec4cbdbd09ea71ab231a0b1fa6c4f69f3b55b955f
-  data.tar.gz: dc0e152e583e199c4a7767009003742ca8ad32acae8c8ff6090a19f83ff17609
+  metadata.gz: c87aafd23aa3c79beffb7e71f2e8c5559cdeacd4d9ea313a918959d3c467f7c6
+  data.tar.gz: 50968756d64771da955cbbcdfe0a4f56222c01b6a1a5d4228b0916d0e2e34cf3
 SHA512:
-  metadata.gz: c39da018fb204e1967817196bfd71f1e643dd7c3f29e7fff81b01aa95c7b255f95d2b49d71882ca5bc972802b574d336e6eb122742feedc20ed13674e23401f9
-  data.tar.gz: b1c59d6961862d5636cef58058617dc06e5cf47be66c5b6f0a3f1f8b393ed0a0c9f433fd99466864687c8333b47afe4f7585f1fad16aff7f1cd1a0a6e560a587
+  metadata.gz: 0cb27972f74e235847215349ae2ff1d43c3dd157918954d7987e3ee1d1327d4239e13180213fd7c8fcf95abedb47b3c1a059dde0e22c614b24dabd86868e8385
+  data.tar.gz: 5a9e256939116119fe9b2e5252dadcdc15cc5fc8083f9434bd296005e47ccff265ade9922db54a6c9554dcf895501acd15b173a9fafb84419fb41e2cd5e8d6e6

data/README.md

@@ -1,5 +1,9 @@
 # Minds Ruby SDK
-[![Gem Version](https://badge.fury.io/rb/minds_sdk.svg)](https://badge.fury.io/rb/minds_sdk)
+[![Gem Version](https://img.shields.io/gem/v/minds_sdk)](https://rubygems.org/gems/minds_sdk)
+[![Ruby](https://img.shields.io/badge/ruby->=3.0.0-ruby.svg)](https://www.ruby-lang.org/en/)
+[![Documentation](https://img.shields.io/badge/docs-rubydoc.info-blue.svg)](https://www.rubydoc.info/gems/minds_sdk)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 
 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.
 
@@ -24,6 +28,11 @@ Or install it yourself as:
 ```bash
 $ gem install minds_sdk
 ```
+and require with:
+
+```ruby
+require 'minds'
+```
 
 ## Getting Started
 
@@ -66,6 +75,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 +96,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 +215,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,20 @@
-require "faraday"
-require "json"
-require_relative "config/base"
-require_relative "resources/base"
-require_relative "resources/minds"
-require_relative "resources/datasources"
+# frozen_string_literal: true
 
 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 +25,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,18 @@
+# frozen_string_literal: true
+
 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,121 @@
+module Minds
+  class DatabaseConfig
+    attr_accessor :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 update [Boolean] If true, to update datasourse if exists, default is false
+    # @return [Datasource] The created datasource object
+    # @raise [ObjectNotSupported] If datasource type is not supported
+    #
+    # @example
+    #   config = DatabaseConfig.new(
+    #     name: 'sales_db',
+    #     engine: 'postgres',
+    #     connection_data: {
+    #       host: 'localhost',
+    #       port: 5432,
+    #       user_name: "test"
+    #       password: "test"
+    #     }
+    #   )
+    #   datasource = datasources.create(config)
+    #
+    def create(ds_config, update = false)
+      name = ds_config.name
+
+      path = "datasources"
+      path += "/#{name}" if update
+
+      @client.send(update ? :put : :post, path: path, parameters: ds_config.to_h)
+      find(name)
+    end
+
+    # Return a list of datasources
+    #
+    # @return [Array<Datasource>] An array of Datasource objects
+    #
+    # @example
+    #   datasources = datasources.all
+    #   datasources.each { |ds| puts ds.name }
+    #
+    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
+
+    # Find 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
+    #
+    # @example
+    #   datasource = datasources.find('sales_db')
+    #   puts datasource.engine
+    #
+    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
+
+    # Delete a datasource
+    #
+    # @param name [String]  Datasource name to delete
+    # @param force [Boolean] Whether to force delete from all minds
+    #
+    # @example
+    #   # Simple delete
+    #   datasources.destroy('old_db')
+    #
+    #   # Force delete
+    #   datasources.destroy('old_db', force: true)
+    #
+    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,267 @@
+# frozen_string_literal: true
+
+require "openai"
+require "uri"
+
+module Minds
+  DEFAULT_PROMPT_TEMPLATE = "Use your database tools to answer the user's question: {{question}}"
+
+  class Mind
+    attr_reader :name, :model_name, :provider, :parameters, :created_at, :updated_at, :datasources, :prompt_template
+
+    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 mind
+    #
+    # @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::Datasource)
+    #   - DatabaseConfig object (Minds::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
+      end if datasources
+
+      data["datasources"] = ds_names if !ds_names.empty?
+      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
+
+      updated_mind = @client.minds.find(@name)
+
+      @model_name = updated_mind.model_name
+      @datasources = updated_mind.datasources
+      @parameters = updated_mind.parameters
+      @prompt_template = updated_mind.prompt_template
+      @provider = updated_mind.provider
+      @created_at = updated_mind.created_at
+      @updated_at = updated_mind.updated_at
+      true
+    end
+
+    # Add datasource to mind
+    #
+    # @param datasource [String, Datasource, DatabaseConfig] Datasource to add
+    #   Can be passed as:
+    #   - String: name of the datasource
+    #   - Datasource object (Minds::Datasource)
+    #   - DatabaseConfig object (Minds::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
+
+      true
+    end
+
+    # Remove datasource from mind
+    #
+    # @param datasource [String, Datasource] Datasource to remove
+    #   Can be passed as:
+    #   - String: name of the datasource
+    #   - Datasource object (Minds::Datasource)
+    # @return [void]
+    # @raise [ArgumentError] If datasource type is invalid
+    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
+      true
+    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
+
+    # Lists minds
+    #
+    # @return [Array<Mind>] List of minds
+    #
+    # @example
+    #   minds = minds.all
+    #   minds.each { |mind| puts mind.name }
+    #
+    def all
+      data = @client.get(path: "projects/#{@project}/minds")
+      return [] if data.empty?
+
+      data.map { |item| Mind.new(@client, item) }
+    end
+
+    # Find a mind by name
+    #
+    # @param name [String] The name of the mind to find
+    # @return [Mind] The found mind object
+    #
+    # @example
+    #   mind = minds.find('sales_assistant')
+    #   puts mind.model_name
+    #
+    def find(name)
+      data = @client.get(path: "projects/#{@project}/minds/#{name}")
+      Mind.new(@client, data)
+    end
+
+    # Delete a mind
+    #
+    # @param name [String] The name of the mind to delete
+    # @return [void]
+    #
+    # @example
+    #   minds.destroy('old_assistant')
+    #
+    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)
+    # @param update [Boolean] If true, to update mind if exists(default: false)
+    # @return [Mind] The created mind object
+    #
+    # @example Simple creation
+    #   mind = minds.create(name: 'sales_assistant', model_name: 'gpt-4')
+    #
+    # @example Creation with datasources
+    #   mind = minds.create(
+    #     name: 'sales_assistant',
+    #     model_name: 'gpt-4',
+    #     datasources: ['sales_db'],
+    #     prompt_template: 'Analyze sales data: {{question}}'
+    #   )
+    #
+    def create(name:, model_name: nil, provider: nil, prompt_template: nil, datasources: nil, parameters: nil, replace: false, update: false)
+      if replace
+        find(name)
+        destroy(name)
+      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
+      }
+
+      path = "projects/#{@project}/minds"
+      path += "/#{name}" if update
+      @client.send(update ? :put : :post, path: path, 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)
+    rescue Faraday::ResourceNotFound
+      @client.datasources.create(ds)
+    end
+  end
+end

data/lib/minds/rest_client.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+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 put(path:, parameters:)
+      conn.put(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.1"
 end

data/lib/minds.rb

@@ -1,9 +1,43 @@
 # 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
+    ##
+    # Handles API error responses and provides detailed logging
+    #
+    # @param env [Hash] The Faraday environment hash
+    # @raise [Faraday::Error] Re-raises the original error after logging
+    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,43 +1,49 @@
 --- !ruby/object:Gem::Specification
 name: minds_sdk
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.1
 platform: ruby
 authors:
 - tungnt
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-15 00:00:00.000000000 Z
+date: 2024-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.12'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.12'
 - !ruby/object:Gem::Dependency
   name: ruby-openai
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 7.3.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 7.3.1
 description: Official Ruby SDK for Minds
 email:
 - tungnguyen120301@gmail.com
@@ -55,10 +61,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