rcrewai 0.4.0 → 0.6.0

data/lib/rcrewai/crew.rb

@@ -23,16 +23,33 @@ module RCrewAI
       @planning_llm = options[:planning_llm]
       @planned = false
       @knowledge = build_knowledge(options[:knowledge], options[:knowledge_sources])
+      @before_kickoff_hooks = []
+      @after_kickoff_hooks = []
+      @last_inputs = {}
       @process_instance = nil
       validate_process_type!
     end
 
-    attr_reader :knowledge, :stream_sink
+    attr_reader :knowledge, :stream_sink, :last_inputs
 
     def planning?
       @planning
     end
 
+    # Register a callback run before execution. Receives the inputs hash and may
+    # return a transformed hash. Multiple hooks run in registration order.
+    def before_kickoff(&block)
+      @before_kickoff_hooks << block
+      self
+    end
+
+    # Register a callback run after execution. Receives the result and may
+    # return a transformed result. Multiple hooks run in registration order.
+    def after_kickoff(&block)
+      @after_kickoff_hooks << block
+      self
+    end
+
     def add_agent(agent)
       @agents << agent
     end
@@ -41,20 +58,25 @@ module RCrewAI
       @tasks << task
     end
 
-    def execute(async: false, stream: nil, **async_options, &block)
+    def execute(async: false, stream: nil, inputs: {}, **async_options, &block)
       sinks = []
       sinks << block if block_given?
       Array(stream).each { |s| sinks << s } if stream
       @stream_sink = sinks.empty? ? nil : RCrewAI::Events.fan_out(sinks)
 
+      run_before_hooks(inputs)
+
       distribute_knowledge if @knowledge
       run_planning_pass if planning?
 
-      if async
-        execute_async(**async_options)
-      else
-        execute_sync
-      end
+      result = async ? execute_async(**async_options) : execute_sync
+      run_after_hooks(result)
+    end
+
+    # Runs the crew once per input set, returning one result per input in order.
+    # Runs are isolated: each execution starts from only its own inputs.
+    def kickoff_for_each(inputs:)
+      Array(inputs).map { |input| execute(inputs: input) }
     end
 
     # Runs the crew repeatedly, collecting feedback after each iteration and
@@ -144,6 +166,22 @@ module RCrewAI
 
     private
 
+    def run_before_hooks(inputs)
+      # Assign before running hooks so a hook that reads #last_inputs sees this
+      # run's own inputs; update it as each hook transforms them.
+      @last_inputs = inputs || {}
+      @before_kickoff_hooks.each do |hook|
+        @last_inputs = hook.call(@last_inputs) || @last_inputs
+      end
+      @last_inputs
+    end
+
+    def run_after_hooks(result)
+      @after_kickoff_hooks.reduce(result) do |acc, hook|
+        hook.call(acc) || acc
+      end
+    end
+
     def build_knowledge(knowledge, sources)
       return knowledge if knowledge
       return nil if sources.nil? || sources.empty?

data/lib/rcrewai/knowledge/store.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../similarity'
+
 module RCrewAI
   module Knowledge
     # In-memory vector store with cosine-similarity search. The default backing
@@ -38,20 +40,8 @@ module RCrewAI
 
       private
 
-      def cosine_similarity(a, b)
-        dot = 0.0
-        norm_a = 0.0
-        norm_b = 0.0
-        a.each_index do |i|
-          ai = a[i].to_f
-          bi = (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))
+      def cosine_similarity(vec_a, vec_b)
+        Similarity.cosine(vec_a, vec_b)
       end
     end
   end

data/lib/rcrewai/legacy_react_runner.rb

@@ -30,7 +30,7 @@ module RCrewAI
         iter += 1
         emit(Events::IterationStart, iteration: iter, iteration_index: iter)
 
-        response = @llm.chat(messages: msgs)
+        response = @llm.chat(messages: fit_context(msgs))
         accumulate_usage(total_usage, response[:usage])
         reasoning = response[:content] || ''
         last_reasoning = reasoning
@@ -60,6 +60,12 @@ module RCrewAI
 
     private
 
+    # Trims the message list to the model's context window when the agent
+    # supports it; a no-op otherwise.
+    def fit_context(messages)
+      @agent.respond_to?(:fit_context) ? @agent.fit_context(messages) : messages
+    end
+
     def parse_and_execute_actions(reasoning, iter)
       results = []
       iteration_history = []

data/lib/rcrewai/memory/base_memory.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'digest'
+require_relative '../similarity'
+require_relative 'in_memory_store'
+
+module RCrewAI
+  class Memory
+    # Shared behavior for the memory types: embed-on-write (when an embedder is
+    # present) and semantic recall with a lexical fallback when it isn't.
+    # Records are namespaced per (agent) scope + a type suffix so different
+    # memory types don't collide in a shared store.
+    class BaseMemory
+      def initialize(scope:, embedder: nil, store: nil, limit: nil)
+        @scope = "#{scope}:#{type_suffix}"
+        @embedder = embedder
+        @store = store || InMemoryStore.new
+        @limit = limit
+        @seq = 0
+      end
+
+      def record(text, metadata = {})
+        add(text, metadata)
+      end
+
+      def recall(query, limit: 3)
+        records = search_records(query, limit)
+        records.map { |r| format(r) }
+      end
+
+      def count
+        @store.all(scope: @scope).length
+      end
+
+      def clear!
+        @store.delete(scope: @scope)
+      end
+
+      protected
+
+      # Subclasses override to namespace their records.
+      def type_suffix
+        'base'
+      end
+
+      def format(record)
+        { text: record[:text], metadata: record[:metadata] }
+      end
+
+      def add(text, metadata)
+        vector = embed(text)
+        id = next_id(text)
+        @store.add(id: id, text: text, vector: vector, scope: @scope, metadata: stringify(metadata))
+        evict_if_needed
+        id
+      end
+
+      def search_records(query, limit)
+        all = @store.all(scope: @scope)
+        return [] if all.empty?
+
+        query_vector = embed(query)
+        if query_vector && all.any? { |r| r[:vector] }
+          @store.search(query_vector, k: limit, scope: @scope)
+        else
+          lexical_search(query, all, limit)
+        end
+      end
+
+      def lexical_search(query, records, limit)
+        records
+          .map { |r| [r, Similarity.lexical(query, r[:text])] }
+          .sort_by { |(_r, score)| -score }
+          .first(limit)
+          .map(&:first)
+      end
+
+      def embed(text)
+        return nil unless @embedder
+
+        @embedder.embed([text]).first
+      rescue StandardError
+        nil # embedding is best-effort; fall back to lexical
+      end
+
+      def evict_if_needed
+        return unless @limit
+
+        records = @store.all(scope: @scope)
+        return if records.length <= @limit
+
+        # records carry a monotonic :seq in metadata; drop the oldest.
+        oldest = records.min_by { |r| r[:metadata]['seq'].to_i }
+        @store.delete_record(id: oldest[:id], scope: @scope) if @store.respond_to?(:delete_record)
+      end
+
+      def next_id(text)
+        @seq += 1
+        Digest::SHA256.hexdigest("#{@scope}:#{@seq}:#{text}")[0, 24]
+      end
+
+      def stringify(metadata)
+        (metadata || {}).transform_keys(&:to_s).merge('seq' => @seq)
+      end
+    end
+  end
+end

data/lib/rcrewai/memory/entity_memory.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'base_memory'
+
+module RCrewAI
+  class Memory
+    # Facts about entities (people, systems, concepts) accumulated from work.
+    # Entities are extracted heuristically (capitalized tokens / acronyms); an
+    # LLM-backed extractor can be swapped in later.
+    class EntityMemory < BaseMemory
+      # Skip sentence-initial common words that happen to be capitalized.
+      COMMON = %w[The A An I In On At To For Of With By And Or But It This That Who Where When].freeze
+
+      def initialize(scope:, embedder: nil, store: nil, limit: nil)
+        super
+        @entities = []
+      end
+
+      # Records a full observation and indexes the entities it mentions.
+      def observe(text)
+        found = extract_entities(text)
+        @entities.concat(found)
+        add(text, { 'entities' => found })
+      end
+
+      def entities
+        @entities.uniq
+      end
+
+      protected
+
+      def type_suffix
+        'entity'
+      end
+
+      def format(record)
+        record[:text]
+      end
+
+      private
+
+      def extract_entities(text)
+        text.to_s.scan(/\b([A-Z][a-zA-Z0-9]{1,})\b/).flatten.reject { |w| COMMON.include?(w) }.uniq
+      end
+    end
+  end
+end

data/lib/rcrewai/memory/in_memory_store.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../similarity'
+
+module RCrewAI
+  class Memory
+    # Default, volatile vector store: records live in a Hash keyed by scope.
+    # Records: { id:, text:, vector:, metadata: }. Cosine search in Ruby.
+    class InMemoryStore
+      def initialize
+        @scopes = Hash.new { |h, k| h[k] = {} }
+      end
+
+      def add(id:, text:, vector:, scope:, metadata: {})
+        @scopes[scope][id] = { id: id, text: text, vector: vector, metadata: metadata || {} }
+      end
+
+      def all(scope:)
+        @scopes[scope].values
+      end
+
+      def search(vector, k:, scope:)
+        @scopes[scope].values
+                      .reject { |r| r[:vector].nil? }
+                      .map { |r| [r, Similarity.cosine(vector, r[:vector])] }
+                      .sort_by { |(_r, score)| -score }
+                      .first(k)
+                      .map(&:first)
+      end
+
+      def delete(scope:)
+        @scopes.delete(scope)
+      end
+
+      def delete_record(id:, scope:)
+        @scopes[scope].delete(id)
+      end
+    end
+  end
+end

data/lib/rcrewai/memory/long_term_memory.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'base_memory'
+
+module RCrewAI
+  class Memory
+    # Durable insights promoted from successful executions. Dedupes
+    # near-identical insights so the store doesn't fill with paraphrases.
+    class LongTermMemory < BaseMemory
+      DEDUPE_THRESHOLD = 0.92
+
+      def record(text, metadata = {})
+        return nil if duplicate?(text)
+
+        add(text, metadata)
+      end
+
+      protected
+
+      def type_suffix
+        'long_term'
+      end
+
+      private
+
+      def duplicate?(text)
+        existing = @store.all(scope: @scope)
+        return false if existing.empty?
+
+        query_vector = embed(text)
+        if query_vector && existing.any? { |r| r[:vector] }
+          existing.any? { |r| r[:vector] && Similarity.cosine(query_vector, r[:vector]) >= DEDUPE_THRESHOLD }
+        else
+          existing.any? { |r| Similarity.lexical(text, r[:text]) >= DEDUPE_THRESHOLD }
+        end
+      end
+    end
+  end
+end

data/lib/rcrewai/memory/short_term_memory.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'base_memory'
+
+module RCrewAI
+  class Memory
+    # Recent executions with semantic recall. Capped and volatile-by-default.
+    class ShortTermMemory < BaseMemory
+      def initialize(scope:, embedder: nil, store: nil, limit: 100)
+        super
+      end
+
+      protected
+
+      def type_suffix
+        'short_term'
+      end
+    end
+  end
+end

data/lib/rcrewai/memory/sqlite_store.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative '../similarity'
+
+module RCrewAI
+  class Memory
+    # Persistent vector store backed by SQLite. Vectors are packed as
+    # little-endian floats; metadata is JSON. Cosine is computed in Ruby over
+    # rows filtered by scope — adequate for the thousands-of-memories scale an
+    # agent produces; an ANN index is a later optimization.
+    #
+    # The sqlite3 gem is required lazily so the rest of the library (and the
+    # in-memory store) works even if it isn't installed.
+    class SqliteStore
+      DEFAULT_PATH = File.join(Dir.home, '.rcrewai', 'memory.db')
+
+      def initialize(path: DEFAULT_PATH)
+        require 'sqlite3'
+        ensure_parent_dir(path) unless path == ':memory:'
+        @db = SQLite3::Database.new(path)
+        @db.results_as_hash = true
+        create_schema
+      end
+
+      def add(id:, text:, vector:, scope:, metadata: {})
+        @db.execute(
+          'INSERT INTO memories (id, scope, text, vector, metadata) VALUES (?, ?, ?, ?, ?) ' \
+          'ON CONFLICT(id) DO UPDATE SET scope=excluded.scope, text=excluded.text, ' \
+          'vector=excluded.vector, metadata=excluded.metadata',
+          [id, scope, text, pack_vector(vector), JSON.generate(metadata || {})]
+        )
+      end
+
+      def all(scope:)
+        @db.execute('SELECT * FROM memories WHERE scope = ?', [scope]).map { |row| to_record(row) }
+      end
+
+      def search(vector, k:, scope:)
+        all(scope: scope)
+          .reject { |r| r[:vector].nil? }
+          .map { |r| [r, Similarity.cosine(vector, r[:vector])] }
+          .sort_by { |(_r, score)| -score }
+          .first(k)
+          .map(&:first)
+      end
+
+      def delete(scope:)
+        @db.execute('DELETE FROM memories WHERE scope = ?', [scope])
+      end
+
+      def delete_record(id:, scope:)
+        @db.execute('DELETE FROM memories WHERE id = ? AND scope = ?', [id, scope])
+      end
+
+      private
+
+      def create_schema
+        @db.execute(<<~SQL)
+          CREATE TABLE IF NOT EXISTS memories (
+            id TEXT PRIMARY KEY,
+            scope TEXT NOT NULL,
+            text TEXT,
+            vector BLOB,
+            metadata TEXT,
+            created_at TEXT DEFAULT CURRENT_TIMESTAMP
+          )
+        SQL
+        @db.execute('CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories (scope)')
+      end
+
+      def ensure_parent_dir(path)
+        require 'fileutils'
+        FileUtils.mkdir_p(File.dirname(path))
+      end
+
+      def pack_vector(vector)
+        return nil if vector.nil?
+
+        vector.map(&:to_f).pack('e*')
+      end
+
+      def unpack_vector(blob)
+        return nil if blob.nil?
+
+        blob.unpack('e*')
+      end
+
+      def to_record(row)
+        {
+          id: row['id'],
+          text: row['text'],
+          vector: unpack_vector(row['vector']),
+          metadata: JSON.parse(row['metadata'] || '{}')
+        }
+      end
+    end
+  end
+end

data/lib/rcrewai/memory/tool_memory.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'base_memory'
+
+module RCrewAI
+  class Memory
+    # Tool-call history and outcomes. Replaces the old @tool_usage array;
+    # persistable and searchable like the other memory types.
+    class ToolMemory < BaseMemory
+      def record_call(tool_name, params, result)
+        success = !result.to_s.downcase.include?('error')
+        text = "#{tool_name}(#{format_params(params)}) -> #{result}"
+        add(text, { 'tool' => tool_name, 'success' => success, 'result' => result.to_s })
+      end
+
+      # Most-recent-first usage records for a given tool.
+      def usage_for(tool_name, limit: 5)
+        @store.all(scope: @scope)
+              .select { |r| r[:metadata]['tool'] == tool_name }
+              .sort_by { |r| -r[:metadata]['seq'].to_i }
+              .first(limit)
+              .map { |r| r[:text] }
+      end
+
+      protected
+
+      def type_suffix
+        'tool'
+      end
+
+      private
+
+      def format_params(params)
+        (params || {}).map { |k, v| "#{k}=#{v}" }.join(', ')
+      end
+    end
+  end
+end