rcrewai 0.5.0 → 0.6.1

data/lib/rcrewai/memory.rb

@@ -1,202 +1,99 @@
 # frozen_string_literal: true
 
 require 'json'
-require 'digest'
 
 module RCrewAI
+  # Cognitive memory facade. Preserves the original public API
+  # (add_execution / add_tool_usage / relevant_executions / tool_usage_for /
+  # clear_*! / stats) while delegating to semantic, optionally-persistent
+  # memory types (short-term, long-term, entity, tool).
+  #
+  # Zero-config: `Memory.new` uses an in-memory store and, when no embedder is
+  # available, falls back to lexical similarity — so existing code behaves as
+  # before, just with better recall once an embedder is configured.
   class Memory
-    attr_reader :short_term, :long_term, :tool_usage
-
-    def initialize
-      @short_term = []  # Recent executions, limited size
-      @long_term = {}   # Persistent memory, keyed by task type/similarity
-      @tool_usage = []  # Tool usage history
-      @max_short_term = 100
-      @similarity_threshold = 0.7
+    def initialize(scope: 'default', embedder: nil, store: nil, short_term_limit: 100, entity_extractor: nil)
+      @short_term = ShortTermMemory.new(scope: scope, embedder: embedder, store: store, limit: short_term_limit)
+      @long_term  = LongTermMemory.new(scope: scope, embedder: embedder, store: store)
+      @entity     = EntityMemory.new(scope: scope, embedder: embedder, store: store, extractor: entity_extractor)
+      @tool       = ToolMemory.new(scope: scope, embedder: embedder, store: store)
     end
 
+    # --- original API --------------------------------------------------------
+
     def add_execution(task, result, execution_time)
-      execution_data = {
-        task_name: task.name,
-        task_description: task.description,
-        task_type: classify_task_type(task),
-        result: result,
-        execution_time: execution_time,
-        timestamp: Time.now,
-        success: !result.to_s.downcase.include?('failed'),
-        hash: generate_task_hash(task)
+      success = !result.to_s.downcase.include?('failed')
+      text = "Task: #{task.name}\nDescription: #{task.description}\nResult: #{truncate(result, 300)}"
+      metadata = {
+        'task' => task.name,
+        'success' => success,
+        'execution_time' => execution_time,
+        'result' => result.to_s
       }
 
-      # Add to short-term memory
-      @short_term.unshift(execution_data)
-      @short_term = @short_term.first(@max_short_term)
-
-      # Add to long-term memory if successful
-      return unless execution_data[:success]
-
-      task_type = execution_data[:task_type]
-      @long_term[task_type] ||= []
-      @long_term[task_type] << execution_data
-
-      # Keep only best executions for each type
-      @long_term[task_type] = @long_term[task_type]
-                              .sort_by { |e| [e[:success] ? 0 : 1, -e[:execution_time]] }
-                              .first(10)
+      @short_term.record(text, metadata)
+      if success
+        @long_term.record(text, metadata)
+        @entity.observe("#{task.description} #{result}")
+      end
+      nil
     end
 
     def add_tool_usage(tool_name, params, result)
-      usage_data = {
-        tool_name: tool_name,
-        params: params,
-        result: result,
-        timestamp: Time.now,
-        success: !result.to_s.downcase.include?('error')
-      }
-
-      @tool_usage.unshift(usage_data)
-      @tool_usage = @tool_usage.first(50) # Keep last 50 tool usages
+      @tool.record_call(tool_name, params, result)
+      nil
     end
 
+    # Returns a formatted string of the most relevant past executions, or nil.
     def relevant_executions(task, limit = 3)
-      task_type = classify_task_type(task)
-      task_hash = generate_task_hash(task)
-
-      # Get similar executions from both short and long term memory
-      candidates = []
-
-      # Check short-term for exact or similar matches
-      @short_term.each do |execution|
-        if execution[:hash] == task_hash
-          candidates << { execution: execution, similarity: 1.0 }
-        elsif execution[:task_type] == task_type
-          similarity = calculate_similarity(task, execution)
-          candidates << { execution: execution, similarity: similarity } if similarity > @similarity_threshold
-        end
-      end
+      query = "#{task.name} #{task.description}"
+      recalled = (@short_term.recall(query, limit: limit) + @long_term.recall(query, limit: limit))
+      seen = {}
+      unique = recalled.reject { |r| seen[r[:text]].tap { seen[r[:text]] = true } }
+      return nil if unique.empty?
 
-      # Check long-term memory
-      @long_term[task_type]&.each do |execution|
-        similarity = calculate_similarity(task, execution)
-        candidates << { execution: execution, similarity: similarity } if similarity > @similarity_threshold
-      end
-
-      # Sort by similarity and success, return top results
-      relevant = candidates
-                 .sort_by { |c| [-c[:similarity], c[:execution][:success] ? 0 : 1] }
-                 .first(limit)
-                 .map { |c| format_execution_for_context(c[:execution]) }
-
-      relevant.empty? ? nil : relevant.join("\n---\n")
+      unique.first(limit).map { |r| format_execution(r) }.join("\n---\n")
     end
 
     def tool_usage_for(tool_name, limit = 5)
-      @tool_usage
-        .select { |usage| usage[:tool_name] == tool_name }
-        .first(limit)
-        .map { |usage| format_tool_usage_for_context(usage) }
-        .join("\n")
+      @tool.usage_for(tool_name, limit: limit).join("\n")
     end
 
     def clear_short_term!
-      @short_term.clear
+      @short_term.clear!
     end
 
     def clear_all!
-      @short_term.clear
-      @long_term.clear
-      @tool_usage.clear
+      @short_term.clear!
+      @long_term.clear!
+      @entity.clear!
+      @tool.clear!
     end
 
     def stats
       {
-        short_term_count: @short_term.length,
-        long_term_types: @long_term.keys.length,
-        long_term_total: @long_term.values.flatten.length,
-        tool_usage_count: @tool_usage.length,
-        success_rate: calculate_success_rate
+        short_term_count: @short_term.count,
+        long_term_total: @long_term.count,
+        entity_count: @entity.entities.length,
+        tool_usage_count: @tool.count
       }
     end
 
-    private
-
-    def classify_task_type(task)
-      description = task.description.downcase
-
-      if description.include?('research') || description.include?('find') || description.include?('search')
-        return :research
-      end
-      if description.include?('analyze') || description.include?('examine') || description.include?('study')
-        return :analysis
-      end
-      if description.include?('write') || description.include?('create') || description.include?('compose')
-        return :writing
-      end
-      if description.include?('code') || description.include?('program') || description.include?('develop')
-        return :coding
-      end
-      if description.include?('plan') || description.include?('strategy') || description.include?('organize')
-        return :planning
-      end
-
-      :general
-    end
-
-    def generate_task_hash(task)
-      content = "#{task.name}:#{task.description}"
-      Digest::SHA256.hexdigest(content)[0..16]
-    end
-
-    def calculate_similarity(task, execution)
-      # Simple similarity based on common words and task type
-      task_words = extract_keywords(task.description)
-      execution_words = extract_keywords(execution[:task_description])
-
-      common_words = (task_words & execution_words).length
-      total_words = (task_words | execution_words).length
-
-      return 0.0 if total_words.zero?
+    # --- new surface (optional direct access) --------------------------------
 
-      word_similarity = common_words.to_f / total_words
+    attr_reader :short_term, :long_term, :entity, :tool
 
-      # Boost similarity if task types match
-      type_bonus = classify_task_type(task) == execution[:task_type] ? 0.2 : 0.0
-
-      [word_similarity + type_bonus, 1.0].min
-    end
-
-    def extract_keywords(text)
-      # Simple keyword extraction - remove common words
-      stopwords = %w[the a an and or but in on at to for of with by]
-      text.downcase.split(/\W+/).reject { |w| w.length < 3 || stopwords.include?(w) }
-    end
-
-    def format_execution_for_context(execution)
-      success_indicator = execution[:success] ? '✓' : '✗'
-      <<~CONTEXT
-        #{success_indicator} Task: #{execution[:task_name]}
-        Description: #{execution[:task_description]}
-        Result: #{execution[:result][0..200]}#{'...' if execution[:result].length > 200}
-        Time: #{execution[:execution_time].round(2)}s
-        Date: #{execution[:timestamp].strftime('%Y-%m-%d %H:%M')}
-      CONTEXT
-    end
+    private
 
-    def format_tool_usage_for_context(usage)
-      success_indicator = usage[:success] ? '✓' : '✗'
-      params_str = usage[:params].map { |k, v| "#{k}=#{v}" }.join(', ')
-      <<~CONTEXT
-        #{success_indicator} Tool: #{usage[:tool_name]}
-        Params: #{params_str}
-        Result: #{usage[:result][0..100]}#{'...' if usage[:result].to_s.length > 100}
-        Date: #{usage[:timestamp].strftime('%Y-%m-%d %H:%M')}
-      CONTEXT
+    def format_execution(record)
+      meta = record[:metadata] || {}
+      indicator = meta['success'] == false ? '✗' : '✓'
+      "#{indicator} #{record[:text]}"
     end
 
-    def calculate_success_rate
-      return 0.0 if @short_term.empty?
-
-      successful = @short_term.count { |e| e[:success] }
-      (successful.to_f / @short_term.length * 100).round(1)
+    def truncate(text, limit)
+      str = text.to_s
+      str.length > limit ? "#{str[0, limit]}..." : str
     end
   end
 end

data/lib/rcrewai/similarity.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RCrewAI
+  # Similarity measures shared across Knowledge and Memory. `cosine` compares
+  # embedding vectors; `lexical` is the word-overlap fallback used when no
+  # embedder is available.
+  module Similarity
+    STOPWORDS = %w[the a an and or but in on at to for of with by is are was were be].freeze
+
+    module_function
+
+    def cosine(vec_a, vec_b)
+      dot = 0.0
+      norm_a = 0.0
+      norm_b = 0.0
+      length = [vec_a.length, vec_b.length].max
+      length.times do |i|
+        ai = (vec_a[i] || 0).to_f
+        bi = (vec_b[i] || 0).to_f
+        dot += ai * bi
+        norm_a += ai * ai
+        norm_b += bi * bi
+      end
+      return 0.0 if norm_a.zero? || norm_b.zero?
+
+      dot / (Math.sqrt(norm_a) * Math.sqrt(norm_b))
+    end
+
+    # Jaccard-style overlap of content words. Cheap, no embeddings.
+    def lexical(text_a, text_b)
+      words_a = keywords(text_a)
+      words_b = keywords(text_b)
+      union = (words_a | words_b).length
+      return 0.0 if union.zero?
+
+      (words_a & words_b).length.to_f / union
+    end
+
+    def keywords(text)
+      text.to_s.downcase.split(/\W+/).reject { |w| w.length < 3 || STOPWORDS.include?(w) }
+    end
+  end
+end

data/lib/rcrewai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RCrewAI
-  VERSION = '0.5.0'
+  VERSION = '0.6.1'
 end

data/lib/rcrewai.rb

@@ -22,7 +22,16 @@ require_relative 'rcrewai/events'
 require_relative 'rcrewai/sse_parser'
 require_relative 'rcrewai/pricing'
 require_relative 'rcrewai/llm_client'
+require_relative 'rcrewai/similarity'
 require_relative 'rcrewai/memory'
+require_relative 'rcrewai/memory/in_memory_store'
+require_relative 'rcrewai/memory/sqlite_store'
+require_relative 'rcrewai/memory/base_memory'
+require_relative 'rcrewai/memory/short_term_memory'
+require_relative 'rcrewai/memory/long_term_memory'
+require_relative 'rcrewai/memory/entity_memory'
+require_relative 'rcrewai/memory/llm_entity_extractor'
+require_relative 'rcrewai/memory/tool_memory'
 require_relative 'rcrewai/rate_limiter'
 require_relative 'rcrewai/context_window'
 require_relative 'rcrewai/multimodal'

data/rcrewai.gemspec

@@ -59,6 +59,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'nokogiri', '~> 1.15'
   spec.add_dependency 'pdf-reader', '~> 2.11'
   spec.add_dependency 'ruby-openai', '~> 6.3'
+  spec.add_dependency 'sqlite3', '~> 2.0'
   spec.add_dependency 'thor', '~> 1.3'
 
   # Development dependencies

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rcrewai
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.1
 platform: ruby
 authors:
 - gkosmo
@@ -149,6 +149,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '6.3'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -342,6 +356,7 @@ files:
 - docs/mcp.md
 - docs/superpowers/plans/2026-05-11-llm-modernization.md
 - docs/superpowers/specs/2026-05-11-llm-modernization-design.md
+- docs/superpowers/specs/2026-07-06-cognitive-memory-design.md
 - docs/tutorials/advanced-agents.md
 - docs/tutorials/custom-tools.md
 - docs/tutorials/deployment.md
@@ -350,7 +365,9 @@ files:
 - docs/tutorials/multiple-crews.md
 - docs/upgrading-to-0.3.md
 - docs/upgrading-to-0.4.md
+- docs/upgrading-to-0.6.md
 - examples/async_execution_example.rb
+- examples/cognitive_memory_example.rb
 - examples/flow_example.rb
 - examples/hierarchical_crew_example.rb
 - examples/human_in_the_loop_example.rb
@@ -393,6 +410,14 @@ files:
 - lib/rcrewai/mcp/transport/http.rb
 - lib/rcrewai/mcp/transport/stdio.rb
 - lib/rcrewai/memory.rb
+- lib/rcrewai/memory/base_memory.rb
+- lib/rcrewai/memory/entity_memory.rb
+- lib/rcrewai/memory/in_memory_store.rb
+- lib/rcrewai/memory/llm_entity_extractor.rb
+- lib/rcrewai/memory/long_term_memory.rb
+- lib/rcrewai/memory/short_term_memory.rb
+- lib/rcrewai/memory/sqlite_store.rb
+- lib/rcrewai/memory/tool_memory.rb
 - lib/rcrewai/multimodal.rb
 - lib/rcrewai/output_schema.rb
 - lib/rcrewai/planning.rb
@@ -400,6 +425,7 @@ files:
 - lib/rcrewai/process.rb
 - lib/rcrewai/provider_schema.rb
 - lib/rcrewai/rate_limiter.rb
+- lib/rcrewai/similarity.rb
 - lib/rcrewai/sse_parser.rb
 - lib/rcrewai/task.rb
 - lib/rcrewai/tool_runner.rb