Class: Legion::Extensions::Agentic::Memory::Compression::Helpers::CompressionEngine

Inherits:
Object
  • Object
show all
Includes:
Constants
Defined in:
lib/legion/extensions/agentic/memory/compression/helpers/compression_engine.rb

Constant Summary

Constants included from Constants

Legion::Extensions::Agentic::Memory::Compression::Helpers::Constants::CHUNK_TYPES, Legion::Extensions::Agentic::Memory::Compression::Helpers::Constants::COMPRESSION_LABELS, Legion::Extensions::Agentic::Memory::Compression::Helpers::Constants::COMPRESSION_RATE, Legion::Extensions::Agentic::Memory::Compression::Helpers::Constants::DEFAULT_COMPRESSION_RATIO, Legion::Extensions::Agentic::Memory::Compression::Helpers::Constants::FIDELITY_LABELS, Legion::Extensions::Agentic::Memory::Compression::Helpers::Constants::FIDELITY_LOSS_RATE, Legion::Extensions::Agentic::Memory::Compression::Helpers::Constants::MAX_ABSTRACTIONS, Legion::Extensions::Agentic::Memory::Compression::Helpers::Constants::MAX_CHUNKS, Legion::Extensions::Agentic::Memory::Compression::Helpers::Constants::MIN_FIDELITY

Instance Method Summary collapse

Constructor Details

#initialize ⇒ CompressionEngine

Returns a new instance of CompressionEngine.



12
13
14
15
 
# File 'lib/legion/extensions/agentic/memory/compression/helpers/compression_engine.rb', line 12

def initialize
  @chunks       = {}
  @abstractions = {}
end

Instance Method Details

#abstract_chunks(chunk_ids:, abstraction_label:) ⇒ Object 



39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/legion/extensions/agentic/memory/compression/helpers/compression_engine.rb', line 39

def abstract_chunks(chunk_ids:, abstraction_label:)
  prune_abstractions_if_needed
  chunks = chunk_ids.filter_map { |id| @chunks[id] }
  return nil if chunks.empty?

  combined_size = chunks.sum(&:compressed_size)
  abstraction = InformationChunk.new(
    label:         abstraction_label,
    chunk_type:    :abstract,
    original_size: combined_size
  )
  avg_fidelity = (chunks.sum(&:fidelity) / chunks.size).round(10)
  abstraction.compress!(amount: DEFAULT_COMPRESSION_RATIO)
  @abstractions[abstraction.id] = {
    chunk:      abstraction,
    source_ids: chunk_ids,
    fidelity:   avg_fidelity
  }
  abstraction
end

#average_compression_ratio ⇒ Object 



74
75
76
77
78
79
 
# File 'lib/legion/extensions/agentic/memory/compression/helpers/compression_engine.rb', line 74

def average_compression_ratio
  return 0.0 if @chunks.empty?

  ratios = @chunks.values.map(&:compression_ratio)
  (ratios.sum / ratios.size).round(10)
end

#average_fidelity ⇒ Object 



81
82
83
84
85
86
 
# File 'lib/legion/extensions/agentic/memory/compression/helpers/compression_engine.rb', line 81

def average_fidelity
  return 1.0 if @chunks.empty?

  fids = @chunks.values.map(&:fidelity)
  (fids.sum / fids.size).round(10)
end

#chunks_by_type(chunk_type:) ⇒ Object 



65
66
67
68
 
# File 'lib/legion/extensions/agentic/memory/compression/helpers/compression_engine.rb', line 65

def chunks_by_type(chunk_type:)
  ct = chunk_type.to_sym
  @chunks.values.select { |c| c.chunk_type == ct }
end

#compress_all(amount: COMPRESSION_RATE) ⇒ Object 



60
61
62
63
 
# File 'lib/legion/extensions/agentic/memory/compression/helpers/compression_engine.rb', line 60

def compress_all(amount: COMPRESSION_RATE)
  @chunks.each_value { |c| c.compress!(amount: amount) }
  @chunks.size
end

#compress_chunk(chunk_id:, amount: COMPRESSION_RATE) ⇒ Object 



25
26
27
28
29
30
 
# File 'lib/legion/extensions/agentic/memory/compression/helpers/compression_engine.rb', line 25

def compress_chunk(chunk_id:, amount: COMPRESSION_RATE)
  chunk = @chunks[chunk_id]
  return nil unless chunk

  chunk.compress!(amount: amount)
end

#compression_report ⇒ Object 



102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/legion/extensions/agentic/memory/compression/helpers/compression_engine.rb', line 102

def compression_report
  {
    total_chunks:              @chunks.size,
    total_abstractions:        @abstractions.size,
    average_compression_ratio: average_compression_ratio,
    overall_compression_ratio: overall_compression_ratio,
    average_fidelity:          average_fidelity,
    total_original_size:       total_original_size,
    total_compressed_size:     total_compressed_size,
    highly_compressed_count:   highly_compressed_chunks.size
  }
end

#decompress_chunk(chunk_id:, amount: COMPRESSION_RATE) ⇒ Object 



32
33
34
35
36
37
 
# File 'lib/legion/extensions/agentic/memory/compression/helpers/compression_engine.rb', line 32

def decompress_chunk(chunk_id:, amount: COMPRESSION_RATE)
  chunk = @chunks[chunk_id]
  return nil unless chunk

  chunk.decompress!(amount: amount)
end

#highly_compressed_chunks ⇒ Object 



70
71
72
 
# File 'lib/legion/extensions/agentic/memory/compression/helpers/compression_engine.rb', line 70

def highly_compressed_chunks
  @chunks.values.select(&:highly_compressed?)
end

#overall_compression_ratio ⇒ Object 



96
97
98
99
100
 
# File 'lib/legion/extensions/agentic/memory/compression/helpers/compression_engine.rb', line 96

def overall_compression_ratio
  return 0.0 if total_original_size.zero?

  (1.0 - (total_compressed_size / total_original_size)).clamp(0.0, 1.0).round(10)
end

#store_chunk(label:, chunk_type: :semantic, original_size: 1.0) ⇒ Object 



17
18
19
20
21
22
23
 
# File 'lib/legion/extensions/agentic/memory/compression/helpers/compression_engine.rb', line 17

def store_chunk(label:, chunk_type: :semantic, original_size: 1.0)
  prune_chunks_if_needed
  chunk = InformationChunk.new(label: label, chunk_type: chunk_type,
                               original_size: original_size)
  @chunks[chunk.id] = chunk
  chunk
end

#to_h ⇒ Object 



115
116
117
118
119
120
121
122
 
# File 'lib/legion/extensions/agentic/memory/compression/helpers/compression_engine.rb', line 115

def to_h
  {
    total_chunks:              @chunks.size,
    total_abstractions:        @abstractions.size,
    average_compression_ratio: average_compression_ratio,
    average_fidelity:          average_fidelity
  }
end

#total_compressed_size ⇒ Object 



92
93
94
 
# File 'lib/legion/extensions/agentic/memory/compression/helpers/compression_engine.rb', line 92

def total_compressed_size
  @chunks.values.sum(&:compressed_size).round(10)
end

#total_original_size ⇒ Object 



88
89
90
 
# File 'lib/legion/extensions/agentic/memory/compression/helpers/compression_engine.rb', line 88

def total_original_size
  @chunks.values.sum(&:original_size).round(10)
end