Class: KairosMcp::Storage::Backend

Inherits:
Object
  • Object
show all
Defined in:
lib/kairos_mcp/storage/backend.rb

Overview

Abstract base class for storage backends

KairosChain supports two storage backends:

  • FileBackend (default): File-based storage for individual use

  • SqliteBackend (optional): SQLite-based storage for team use

The backend is selected via config.yml:

storage:
  backend: file  # or 'sqlite'

Direct Known Subclasses

FileBackend, SqliteBackend

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.create(config = {}) ⇒ Backend

Create a storage backend based on configuration

Parameters:

  • config (Hash) (defaults to: {}) —

    Configuration hash with :backend key

Returns:

  • (Backend) —

    A FileBackend or SqliteBackend instance



152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
 
# File 'lib/kairos_mcp/storage/backend.rb', line 152

def self.create(config = {})
  backend = config[:backend]&.to_s || 'file'

  # Check SkillSet-registered backends first (e.g. 'postgresql')
  if @registry.key?(backend)
    return @registry[backend].new(config[backend.to_sym] || {})
  end

  case backend
  when 'sqlite'
    begin
      require_relative 'sqlite_backend'
      SqliteBackend.new(config[:sqlite] || {})
    rescue LoadError => e
      warn "[KairosChain] SQLite backend requested but sqlite3 gem not available: #{e.message}"
      warn "[KairosChain] Falling back to file backend"
      require_relative 'file_backend'
      FileBackend.new(config[:file] || {})
    end
  else
    require_relative 'file_backend'
    FileBackend.new(config[:file] || {})
  end
end

.default ⇒ Backend

Create a backend using the default configuration

Returns:

  • (Backend) —

    A FileBackend or SqliteBackend instance



194
195
196
197
 
# File 'lib/kairos_mcp/storage/backend.rb', line 194

def self.default
  config = load_config
  create(config.transform_keys(&:to_sym))
end

.load_config ⇒ Hash

Get the default storage configuration from config.yml

Returns:

  • (Hash) —

    Storage configuration



179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/kairos_mcp/storage/backend.rb', line 179

def self.load_config
  require_relative '../../kairos_mcp'
  config_path = KairosMcp.skills_config_path
  return {} unless File.exist?(config_path)

  require 'yaml'
  config = YAML.safe_load(File.read(config_path), permitted_classes: [Symbol]) || {}
  config['storage'] || {}
rescue StandardError => e
  warn "[KairosChain] Failed to load storage config: #{e.message}"
  {}
end

.register(name, klass) ⇒ Object

Register a named backend class for SkillSet use (e.g. ‘postgresql’)



23
24
25
 
# File 'lib/kairos_mcp/storage/backend.rb', line 23

def self.register(name, klass)
  @registry[name.to_s] = klass
end

.unregister(name) ⇒ Object

Unregister a named backend



28
29
30
 
# File 'lib/kairos_mcp/storage/backend.rb', line 28

def self.unregister(name)
  @registry.delete(name.to_s)
end

Instance Method Details

#action_history(limit: 50) ⇒ Array<Hash>

Get action history

Parameters:

  • limit (Integer) (defaults to: 50) —

    Maximum number of entries to return

Returns:

  • (Array<Hash>) —

    Recent action log entries

Raises:

  • (NotImplementedError) 


76
77
78
 
# File 'lib/kairos_mcp/storage/backend.rb', line 76

def action_history(limit: 50)
  raise NotImplementedError, "#{self.class}#action_history must be implemented"
end

#all_blocks ⇒ Array<Hash>

Get all blocks

Returns:

  • (Array<Hash>) —

    All blocks

Raises:

  • (NotImplementedError) 


58
59
60
 
# File 'lib/kairos_mcp/storage/backend.rb', line 58

def all_blocks
  raise NotImplementedError, "#{self.class}#all_blocks must be implemented"
end

#backend_type ⇒ Symbol

Get backend type

Returns:

  • (Symbol) —

    :file or :sqlite

Raises:

  • (NotImplementedError) 


141
142
143
 
# File 'lib/kairos_mcp/storage/backend.rb', line 141

def backend_type
  raise NotImplementedError, "#{self.class}#backend_type must be implemented"
end

#clear_action_log! ⇒ Boolean

Clear all action logs

Returns:

  • (Boolean) —

    Success status

Raises:

  • (NotImplementedError) 


82
83
84
 
# File 'lib/kairos_mcp/storage/backend.rb', line 82

def clear_action_log!
  raise NotImplementedError, "#{self.class}#clear_action_log! must be implemented"
end

#delete_knowledge_meta(name) ⇒ Boolean

Delete knowledge metadata

Parameters:

  • name (String) —

    Knowledge name

Returns:

  • (Boolean) —

    Success status

Raises:

  • (NotImplementedError) 


116
117
118
 
# File 'lib/kairos_mcp/storage/backend.rb', line 116

def delete_knowledge_meta(name)
  raise NotImplementedError, "#{self.class}#delete_knowledge_meta must be implemented"
end

#get_knowledge_meta(name) ⇒ Hash?

Get knowledge metadata

Parameters:

  • name (String) —

    Knowledge name

Returns:

  • (Hash, nil) —

    Metadata or nil if not found

Raises:

  • (NotImplementedError) 


103
104
105
 
# File 'lib/kairos_mcp/storage/backend.rb', line 103

def get_knowledge_meta(name)
  raise NotImplementedError, "#{self.class}#get_knowledge_meta must be implemented"
end

#list_knowledge_meta ⇒ Array<Hash>

List all knowledge metadata

Returns:

  • (Array<Hash>) —

    Array of metadata for all knowledge entries

Raises:

  • (NotImplementedError) 


109
110
111
 
# File 'lib/kairos_mcp/storage/backend.rb', line 109

def list_knowledge_meta
  raise NotImplementedError, "#{self.class}#list_knowledge_meta must be implemented"
end

#load_blocks ⇒ Array<Hash>?

Load all blocks from storage

Returns:

  • (Array<Hash>, nil) —

    Array of block data or nil if not found

Raises:

  • (NotImplementedError) 


38
39
40
 
# File 'lib/kairos_mcp/storage/backend.rb', line 38

def load_blocks
  raise NotImplementedError, "#{self.class}#load_blocks must be implemented"
end

#ready? ⇒ Boolean

Check if the backend is ready

Returns:

  • (Boolean) —

    True if backend is initialized and ready

Raises:

  • (NotImplementedError) 


135
136
137
 
# File 'lib/kairos_mcp/storage/backend.rb', line 135

def ready?
  raise NotImplementedError, "#{self.class}#ready? must be implemented"
end

#record_action(entry) ⇒ Boolean

Record an action to the log

Parameters:

  • entry (Hash) —

    Log entry with :timestamp, :action, :skill_id, :details

Returns:

  • (Boolean) —

    Success status

Raises:

  • (NotImplementedError) 


69
70
71
 
# File 'lib/kairos_mcp/storage/backend.rb', line 69

def record_action(entry)
  raise NotImplementedError, "#{self.class}#record_action must be implemented"
end

#save_all_blocks(blocks) ⇒ Boolean

Save all blocks to storage (for file backend bulk write)

Parameters:

  • blocks (Array<Hash>) —

    Array of block data

Returns:

  • (Boolean) —

    Success status

Raises:

  • (NotImplementedError) 


52
53
54
 
# File 'lib/kairos_mcp/storage/backend.rb', line 52

def save_all_blocks(blocks)
  raise NotImplementedError, "#{self.class}#save_all_blocks must be implemented"
end

#save_block(block) ⇒ Boolean

Save a single block to storage

Parameters:

  • block (Hash) —

    Block data to save

Returns:

  • (Boolean) —

    Success status

Raises:

  • (NotImplementedError) 


45
46
47
 
# File 'lib/kairos_mcp/storage/backend.rb', line 45

def save_block(block)
  raise NotImplementedError, "#{self.class}#save_block must be implemented"
end

#save_knowledge_meta(name, meta) ⇒ Boolean

Save knowledge metadata

Parameters:

  • name (String) —

    Knowledge name

  • meta (Hash) —

    Metadata (content_hash, version, description, tags, etc.)

Returns:

  • (Boolean) —

    Success status

Raises:

  • (NotImplementedError) 


96
97
98
 
# File 'lib/kairos_mcp/storage/backend.rb', line 96

def save_knowledge_meta(name, meta)
  raise NotImplementedError, "#{self.class}#save_knowledge_meta must be implemented"
end

#update_knowledge_archived(name, archived, reason: nil) ⇒ Boolean

Update knowledge archived status

Parameters:

  • name (String) —

    Knowledge name

  • archived (Boolean) —

    Archived status

  • reason (String, nil) (defaults to: nil) —

    Archive reason

Returns:

  • (Boolean) —

    Success status

Raises:

  • (NotImplementedError) 


125
126
127
 
# File 'lib/kairos_mcp/storage/backend.rb', line 125

def update_knowledge_archived(name, archived, reason: nil)
  raise NotImplementedError, "#{self.class}#update_knowledge_archived must be implemented"
end