Class: RailsAi::Agents::Memory

Inherits:
Object
  • Object
show all
Defined in:
lib/rails_ai/agents/memory.rb

Constant Summary collapse

IMPORTANCE_LEVELS = 
{
  critical: 4,
  high: 3,
  normal: 2,
  low: 1
}.freeze

Instance Method Summary collapse

Constructor Details

#initialize(max_size: 1000) ⇒ Memory

Returns a new instance of Memory.



13
14
15
16
17
 
# File 'lib/rails_ai/agents/memory.rb', line 13

def initialize(max_size: 1000)
  @max_size = max_size
  @memories = []
  @index = {}
end

Instance Method Details

#add(key, value, importance: :normal) ⇒ Object 



19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/rails_ai/agents/memory.rb', line 19

def add(key, value, importance: :normal)
  memory_item = {
    key: key,
    value: value,
    importance: importance,
    importance_score: IMPORTANCE_LEVELS[importance] || 2,
    created_at: Time.now,
    accessed_at: Time.now,
    access_count: 0
  }

  # Remove oldest low-importance memory if at capacity
  if @memories.length >= @max_size
    remove_oldest_low_importance
  end

  @memories << memory_item
  @index[key] = memory_item
  memory_item
end

#clear! ⇒ Object 



89
90
91
92
 
# File 'lib/rails_ai/agents/memory.rb', line 89

def clear!
  @memories.clear
  @index.clear
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


98
99
100
 
# File 'lib/rails_ai/agents/memory.rb', line 98

def empty?
  @memories.empty?
end

#get(key) ⇒ Object 



40
41
42
43
44
45
46
47
 
# File 'lib/rails_ai/agents/memory.rb', line 40

def get(key)
  memory_item = @index[key]
  return nil unless memory_item

  memory_item[:accessed_at] = Time.now
  memory_item[:access_count] += 1
  memory_item[:value]
end

#important(count = 5) ⇒ Object 



77
78
79
80
81
82
83
 
# File 'lib/rails_ai/agents/memory.rb', line 77

def important(count = 5)
  @memories
    .select { |memory| memory[:importance_score] >= 3 }
    .sort_by { |memory| -memory[:importance_score] }
    .first(count)
    .map { |memory| { key: memory[:key], value: memory[:value], importance: memory[:importance] } }
end

#recent(count = 10) ⇒ Object 



70
71
72
73
74
75
 
# File 'lib/rails_ai/agents/memory.rb', line 70

def recent(count = 10)
  @memories
    .sort_by { |memory| -memory[:created_at].to_f }
    .first(count)
    .map { |memory| { key: memory[:key], value: memory[:value], created_at: memory[:created_at] } }
end

#remove(key) ⇒ Object 



49
50
51
52
53
54
55
 
# File 'lib/rails_ai/agents/memory.rb', line 49

def remove(key)
  memory_item = @index.delete(key)
  return nil unless memory_item

  @memories.delete(memory_item)
  memory_item[:value]
end

#search(query, limit: 10) ⇒ Object 



57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/rails_ai/agents/memory.rb', line 57

def search(query, limit: 10)
  query_lower = query.downcase
  
  @memories
    .select do |memory|
      memory[:value].to_s.downcase.include?(query_lower) ||
      memory[:key].to_s.downcase.include?(query_lower)
    end
    .sort_by { |memory| -memory[:importance_score] }
    .first(limit)
    .map { |memory| memory[:value] }
end

#size ⇒ Object 



94
95
96
 
# File 'lib/rails_ai/agents/memory.rb', line 94

def size
  @memories.length
end

#usage_percentage ⇒ Object 



85
86
87
 
# File 'lib/rails_ai/agents/memory.rb', line 85

def usage_percentage
  (@memories.length.to_f / @max_size * 100).round(2)
end