rcrewai 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68a381d21e047e37972fda09fd7e9faa93da77e6fe01a040a4c77b9ee0066aca
-  data.tar.gz: 3818acc6b9b6eb71d27d4099cb1c1fc574adbdd0a3a8128389803c051c364774
+  metadata.gz: fb90e26000ddf4a2907b06150fdc87b1707fc701c6c61ba35db33339ed6f38d4
+  data.tar.gz: ba3435eb1918be328ce65faf2c3000553833b09778eb3b06f2a6191cae31aab4
 SHA512:
-  metadata.gz: 65d796bde314db55466f7f4f043db9eeb772dee3e72914d2bc27947eb6dfe84ce246b89a6181d473c3f7d175d353fbc9531914c8baa5b7b010e02229324bac27
-  data.tar.gz: b2fffaab35dc672b12d2a5aea5fd0b02e6519b2f4a5ca98daaf66bef740551e2e674f4cc39967f3d987ed9dfe1c13e7dec4c8a30e5b86e2140242e347dd96a11
+  metadata.gz: 992ac3d7368cb7690f11294b78fe876fcea29d48cffd001a355471a351c22c321563fbd390a0688951be6bcbd0f177322509e59cdd19cf8073e228784d96b503
+  data.tar.gz: 92e7db7609d4503693396f85735fd48633cb5204a34d2431e57ffcb7c758e693bff5b1282ed716899f4242bd9a26b0483f278c991dedb13b21d05894a59b7105

data/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-07-06
+
+Replaces the placeholder agent memory with a **cognitive memory** system —
+semantic recall (embeddings + cosine), optional SQLite persistence, and four
+memory types. This is the one area where CrewAI advanced past what the gem
+originally ported. Backward compatible: the `Memory` public API is unchanged and
+the zero-config default behaves as before.
+
+### Added
+- Cognitive memory: `RCrewAI::Memory` is now a semantic, optionally-persistent, multi-type memory system, replacing the previous word-overlap placeholder. It composes four memory types — `ShortTermMemory` (recent executions, capped), `LongTermMemory` (durable, deduped insights), `EntityMemory` (facts about entities seen in work), and `ToolMemory` (tool-call history) — behind the original `Memory` public API.
+- Semantic recall: pass `Agent.new(memory: { embedder: RCrewAI::Knowledge::Embedder.new })` to recall conceptually related past work via embeddings + cosine similarity. Without an embedder, recall falls back to lexical (word-overlap) similarity — and embedding failures fall back gracefully, so memory never breaks execution.
+- Persistent memory: `RCrewAI::Memory::SqliteStore` persists memories to SQLite (vectors packed as floats, metadata as JSON) so recall survives restarts. Default store is `InMemoryStore` (volatile). The store interface is pluggable.
+- Memory scoping: each agent's memory is scoped to its name by default, so agents sharing a persistent store don't cross-read; override via `memory: { scope: ... }`.
+- `RCrewAI::Similarity` — shared cosine + lexical similarity helpers (extracted from `Knowledge::Store`, now used by both Knowledge and Memory).
+- `sqlite3` added as a runtime dependency (required lazily; only needed for `SqliteStore`).
+
+### Changed
+- `Agent.new(memory:)` accepts a pre-built `Memory`, an options hash (`{ embedder:, store:, scope:, short_term_limit: }`), or nothing (zero-config default, unchanged behavior).
+
 ## [0.5.0] - 2026-07-03
 
 Polish release completing the roadmap backlog: crew lifecycle hooks, batch
@@ -179,7 +198,8 @@ output, guardrails, planning, and training/testing. See `ROADMAP.md`.
 - CLI usage documentation
 - Real-world use cases and examples
 
-[Unreleased]: https://github.com/gkosmo/rcrewAI/compare/v0.5.0...HEAD
+[Unreleased]: https://github.com/gkosmo/rcrewAI/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/gkosmo/rcrewAI/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/gkosmo/rcrewAI/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/gkosmo/rcrewAI/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/gkosmo/rcrewAI/compare/v0.1.0...v0.3.0

data/README.md

@@ -13,7 +13,7 @@ RCrewAI is a Ruby implementation of the CrewAI framework, allowing you to create
 - **🤖 Intelligent Agents**: AI agents with reasoning loops, memory, and tool usage capabilities
 - **🔗 Multi-LLM Support**: OpenAI, Anthropic (Claude), Google (Gemini), Azure OpenAI, and Ollama
 - **🛠️ Rich Tool Ecosystem**: Web search, file operations, SQL, email, code execution, PDF processing, and custom tools
-- **🧠 Agent Memory**: Short-term and long-term memory for learning from past executions
+- **🧠 Cognitive Memory**: Semantic recall (embeddings + cosine) with optional SQLite persistence and short-term/long-term/entity/tool memory types
 - **🤝 Human-in-the-Loop**: Interactive approval workflows, human guidance, and collaborative decision making
 - **⚡ Advanced Task System**: Dependencies, retries, async/concurrent execution, and context sharing
 - **🏗️ Hierarchical Teams**: Manager agents that coordinate and delegate tasks to specialist agents
@@ -374,6 +374,31 @@ Embeddings default to OpenAI's `text-embedding-3-small`; pass a custom
 `embedder:` (anything responding to `embed(texts)`) or vector store to swap the
 backend.
 
+## 🧠 Cognitive Memory
+
+Agents remember what they've done and recall it semantically on future tasks.
+Memory is zero-config by default (in-memory, lexical recall); add an embedder
+for semantic recall and a SQLite store for persistence:
+
+```ruby
+embedder = RCrewAI::Knowledge::Embedder.new
+store    = RCrewAI::Memory::SqliteStore.new(path: '~/.rcrewai/memory.db')
+
+agent = RCrewAI::Agent.new(
+  name: 'engineer', role: '...', goal: '...',
+  memory: { embedder: embedder, store: store }   # both optional
+)
+```
+
+- **Semantic recall** — with an embedder, an agent recalls conceptually related
+  past work even when the wording differs (falls back to word-overlap without one).
+- **Persistence** — a `SqliteStore` makes memory survive restarts.
+- **Memory types** — `agent.memory.short_term` / `long_term` / `entity` / `tool`.
+- **Scoping** — memory is scoped per agent so a shared store doesn't cross-read.
+
+Memory is best-effort: embedding failures fall back to lexical similarity, so it
+never breaks agent execution.
+
 ## 🌊 Flows
 
 Beyond crews, RCrewAI has **Flows** — an event-driven workflow engine for

data/ROADMAP.md

@@ -19,8 +19,7 @@ Since CrewAI's `1.0`, the framework grew a second pillar (**Flows**) plus
 **Training/Testing**. RCrewAI now implements all of these — see the matrix below.
 
 **Status: complete.** All milestone issues (#5–#12) shipped in v0.4.0, and all
-backlog items (#15–#20) are done and merged to `main` (awaiting the next
-release). There is no outstanding roadmap work.
+backlog items (#15–#20) shipped in v0.5.0. There is no outstanding roadmap work.
 
 ## Parity matrix
 

data/docs/superpowers/specs/2026-07-06-cognitive-memory-design.md

@@ -0,0 +1,118 @@
+# Cognitive Memory: Semantic, Persistent, Multi-Type Agent Memory
+
+**Date:** 2026-07-06
+**Status:** Approved design (pending implementation)
+**Target version:** `rcrewai` 0.6.0 (current is 0.5.0)
+**Scope:** Replace the placeholder `RCrewAI::Memory` with a cognitive memory system modeled on CrewAI's memory taxonomy — short-term (semantic recent recall), long-term (persistent insights), entity memory, and tool-usage memory — backed by embeddings and a persistent SQLite vector store. No new external dependencies; reuses the in-repo `Knowledge::Embedder` and cosine-search infrastructure.
+
+---
+
+## Motivation
+
+The current `RCrewAI::Memory` is a placeholder. It matches "relevant" past executions with word-overlap similarity (`common_words / total_words`) plus a hardcoded keyword/stopword list and a `classify_task_type` that greps the description for words like "research" or "write". Nothing is embedded; nothing is persisted; everything is lost when the process exits. It is the weakest module in the codebase and it undercuts the framework's core promise — agents that learn from what they've done.
+
+Meanwhile CrewAI has advanced *past* the version this project ported: its 2026 "cognitive memory" work adds semantic recall, distinct memory types (short-term, long-term, entity), and persistence. This is genuine parity work, not gold-plating — and the infrastructure to do it well already exists in-repo (`Knowledge::Embedder`, cosine `Knowledge::Store`), so we compose rather than build from scratch.
+
+## Goals
+
+1. **Semantic recall.** Replace word-overlap with embedding-based similarity so an agent recalls conceptually related past work, not just keyword-overlapping work.
+2. **Persistence.** Memory survives process restarts via a SQLite-backed vector store (no external service).
+3. **Memory types.** Model CrewAI's taxonomy: short-term, long-term, entity, and tool-usage memory, each with clear write/read semantics.
+4. **Backward compatibility.** The existing `Memory` public API (`add_execution`, `add_tool_usage`, `relevant_executions`, `tool_usage_for`, `clear_*!`, `stats`) keeps working, so `Agent` and the runners need no changes to function.
+5. **No new hard dependencies.** SQLite via Ruby's stdlib-adjacent `sqlite3` gem (already common in Ruby projects) — but the store is pluggable, and the default remains in-memory so the gem works with zero setup.
+
+## Non-goals
+
+- External vector databases (Chroma/Qdrant/pgvector). The pluggable store interface leaves room for them later; we ship SQLite + in-memory.
+- Reranking, query rewriting, or summarization of memories (CrewAI has some of this; it's a follow-up).
+- Multi-tenant / shared cross-agent memory servers.
+
+## Decisions captured during brainstorming
+
+| # | Decision | Choice |
+|---|----------|--------|
+| 1 | Similarity mechanism | Embeddings + cosine, reusing `Knowledge::Embedder` and the cosine math already in `Knowledge::Store`. |
+| 2 | Persistence | Pluggable vector store; ship `InMemoryStore` (default) and `SqliteStore`. |
+| 3 | Memory taxonomy | Four types: `ShortTermMemory`, `LongTermMemory`, `EntityMemory`, `ToolMemory`. |
+| 4 | Backward compat | Keep the `Memory` facade and its current method signatures; delegate internally to the new types. |
+| 5 | Default behavior | Zero-config: in-memory store, embeddings only if an embedder is available/keyed; graceful fallback to the current lexical similarity when no embedder. |
+| 6 | Embedding failures | Never fatal. If embedding fails (no key, network), fall back to lexical similarity so agents still run. |
+| 7 | Namespacing | Memories are scoped by agent (role/name) so one agent's memory doesn't leak into another, matching CrewAI's per-role collections. |
+
+## Architecture
+
+```
+RCrewAI::Memory  (facade — preserves today's public API)
+  ├── ShortTermMemory   recent executions, semantic recall, capped, volatile-by-default
+  ├── LongTermMemory    durable insights from successful executions, persistent
+  ├── EntityMemory      facts about entities (people, systems, concepts) extracted from work
+  └── ToolMemory        tool-call history + outcomes (replaces @tool_usage)
+
+Each memory type holds:
+  - a VectorStore  (InMemoryStore | SqliteStore)   ← persistence + search
+  - an Embedder    (Knowledge::Embedder | nil)     ← semantic vectors
+  - a lexical fallback (current word-overlap)       ← when no embedder
+```
+
+### Storage: `Memory::VectorStore`
+
+A small interface (mirrors `Knowledge::Store` so they can converge later):
+
+```ruby
+store.add(id:, text:, vector:, metadata:)   # upsert a record
+store.search(vector, k:, scope:)            # cosine top-k, filtered by scope
+store.all(scope:)                           # enumerate (for stats / lexical fallback)
+store.delete(scope:)                        # clear a scope
+```
+
+- **`InMemoryStore`** — array of records; cosine in Ruby (lift the existing private cosine out of `Knowledge::Store` into a shared `Similarity` helper). Default.
+- **`SqliteStore`** — one row per memory: `id, scope, type, text, vector (blob), metadata (json), created_at`. Vectors stored as packed floats (`Array#pack('e*')`). Cosine computed in Ruby over candidate rows filtered by `scope`/`type` (fine for the thousands-of-memories scale agents produce; a real ANN index is a later optimization). Opened at a configurable path (default `~/.rcrewai/memory.db` or `:memory:`).
+
+### Embeddings
+
+Reuse `Knowledge::Embedder`. The memory system takes an optional `embedder:`; when present, `add_*` embeds the text and stores the vector, and recall embeds the query. When absent (no key, or explicitly disabled), the store keeps `vector: nil` and recall falls back to the current lexical similarity over `store.all`. This keeps the zero-config path working.
+
+### The four memory types
+
+- **ShortTermMemory** — every execution is written here; recall returns the top-k semantically similar recent items. Capped (default 100) and, by default, uses the in-memory store (volatile). This is the direct upgrade of today's `@short_term` + `relevant_executions`.
+- **LongTermMemory** — successful executions promote a distilled "insight" record (task type, what worked, result summary) into a persistent store, deduped by similarity so we don't store near-identical insights repeatedly. Upgrade of today's `@long_term`.
+- **EntityMemory** — optional lightweight entity extraction (heuristic first: capitalized noun phrases / quoted terms; pluggable LLM extractor later) so agents accumulate facts about recurring entities. New capability.
+- **ToolMemory** — replaces `@tool_usage`; same API (`add_tool_usage`, `tool_usage_for`) but persistable and searchable.
+
+### Facade: `RCrewAI::Memory`
+
+Keeps today's signatures, delegating to the types:
+
+```ruby
+Memory.new(embedder: nil, store: nil, scope: nil, short_term_limit: 100)
+
+add_execution(task, result, execution_time)   # -> ShortTerm + (if success) LongTerm + Entity
+add_tool_usage(tool_name, params, result)      # -> ToolMemory
+relevant_executions(task, limit = 3)           # -> semantic recall across Short+Long, formatted string|nil
+tool_usage_for(tool_name, limit = 5)           # -> ToolMemory
+clear_short_term! / clear_all! / stats         # -> delegate
+```
+
+`Agent#initialize` gains optional `memory:` config (embedder/store/persistence) but defaults to the zero-config in-memory, lexical-fallback behavior — so existing code is unchanged.
+
+## Backward compatibility & migration
+
+- The `Memory` public API is preserved exactly; `agent.rb` and the runners are untouched functionally.
+- Default construction (`Memory.new` with no args) behaves like today from the caller's perspective — just with better recall when an embedder is configured, and identical lexical recall when not.
+- `relevant_executions` still returns the same formatted-string-or-nil shape consumed at `agent.rb:241`.
+
+## Testing strategy
+
+- **Unit**: each memory type with a fake deterministic embedder (as `knowledge_spec.rb` already does) — assert semantic recall ranks the conceptually-closest item first, not the keyword-overlapping one.
+- **Persistence**: `SqliteStore` round-trip — write memories, reopen the DB, recall survives.
+- **Fallback**: with no embedder, recall still returns results via lexical similarity (proves the graceful path).
+- **Facade compat**: the existing `memory_spec.rb` expectations continue to pass (or are updated only where the placeholder behavior was clearly a bug).
+- **Agent integration**: an agent with `reasoning`/knowledge off recalls a semantically-related prior execution injected into its context.
+
+## Dependencies
+
+- `sqlite3` gem — added as a runtime dependency, but only required lazily inside `SqliteStore` so the gem loads and the in-memory path works even if it's absent. (If we'd rather avoid the dependency entirely, the fallback is a JSON-file-backed store; SQLite is preferred for query/scale.)
+
+## Rollout
+
+Ship in `0.6.0`. `docs/upgrading-to-0.6.md` documents opt-in persistence and embeddings; the default path is unchanged, so it's a no-action upgrade for existing users.

data/docs/upgrading-to-0.6.md

@@ -0,0 +1,101 @@
+# Upgrading to RCrewAI 0.6
+
+RCrewAI 0.6 replaces the placeholder memory with a **cognitive memory** system:
+semantic recall (embeddings + cosine), optional SQLite persistence, and four
+memory types (short-term, long-term, entity, tool).
+
+**0.6 is backward compatible.** The `RCrewAI::Memory` public API is unchanged,
+and the default (`Memory.new` with no config) behaves like before from the
+caller's perspective — just with better recall once an embedder is configured.
+Everything below is opt-in.
+
+---
+
+## 1. What you must do
+
+Nothing. Upgrade the gem; existing code keeps working:
+
+```ruby
+gem 'rcrewai', '~> 0.6'
+```
+
+Note: `0.6` adds `sqlite3` as a runtime dependency (used only if you opt into
+persistence). It is required lazily, so the in-memory default works even if the
+native extension isn't present.
+
+---
+
+## 2. What you can do (new capabilities)
+
+### 2a. Semantic recall via embeddings
+
+By default, memory recall uses lexical (word-overlap) similarity — same as
+before. Pass an embedder to get semantic recall, so an agent remembers
+conceptually related work even when the wording differs:
+
+```ruby
+embedder = RCrewAI::Knowledge::Embedder.new   # OpenAI text-embedding-3-small
+agent = RCrewAI::Agent.new(
+  name: 'engineer', role: '...', goal: '...',
+  memory: { embedder: embedder }
+)
+```
+
+If embedding fails (no API key, network error), recall automatically falls back
+to lexical similarity — memory never breaks agent execution.
+
+### 2b. Persistent memory (SQLite)
+
+Give memory a SQLite store and it survives restarts:
+
+```ruby
+store = RCrewAI::Memory::SqliteStore.new(path: '~/.rcrewai/memory.db')
+agent = RCrewAI::Agent.new(
+  name: 'engineer', role: '...', goal: '...',
+  memory: { embedder: embedder, store: store }
+)
+```
+
+The default store is in-memory (volatile). Any object implementing the store
+interface (`add` / `search` / `all` / `delete` / `delete_record`) can be used —
+e.g. a future Chroma/pgvector adapter.
+
+### 2c. Memory scoping
+
+Each agent's memory is scoped to its name by default, so agents sharing a
+persistent store don't read each other's memories. Override with
+`memory: { scope: 'custom' }` if you want deliberate sharing.
+
+### 2d. Memory types (direct access)
+
+The `Memory` facade exposes the underlying types for advanced use:
+
+```ruby
+agent.memory.short_term   # recent executions, semantic recall, capped
+agent.memory.long_term    # durable insights from successful executions, deduped
+agent.memory.entity       # facts about entities (people, systems) seen in work
+agent.memory.tool         # tool-call history + outcomes
+
+agent.memory.entity.entities            # => ["Alice", "AWS", ...]
+agent.memory.long_term.recall('...', limit: 3)
+```
+
+### 2e. Pre-built Memory
+
+You can also construct and pass a `Memory` directly:
+
+```ruby
+memory = RCrewAI::Memory.new(scope: 'shared', embedder: embedder, store: store)
+agent  = RCrewAI::Agent.new(name: 'a', role: '...', goal: '...', memory: memory)
+```
+
+---
+
+## Behavior notes
+
+- `add_execution` writes to short-term always, and (on success) promotes a
+  deduped insight to long-term and extracts entities.
+- `relevant_executions(task, limit)` recalls across short- and long-term and
+  returns the same formatted-string-or-nil shape as before.
+- `clear_short_term!` leaves long-term insights intact; `clear_all!` wipes
+  everything.

data/examples/cognitive_memory_example.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Cognitive Memory — semantic recall + persistence.
+#
+# Agents remember past executions and recall them by *meaning*, not just shared
+# words. With a SQLite store, memory survives restarts.
+#
+# This example uses a fake, deterministic embedder so it runs WITHOUT an API
+# key. In real use you'd pass `RCrewAI::Knowledge::Embedder.new` (OpenAI).
+#
+# Run:
+#   ruby examples/cognitive_memory_example.rb
+
+require_relative '../lib/rcrewai'
+require 'tmpdir'
+
+RCrewAI.configure(validate: false) do |c|
+  c.llm_provider = :openai
+  c.api_key = 'demo-key'
+end
+
+# Fake embedder: maps text to a concept vector by keyword. Any object
+# responding to embed(texts) -> [[float, ...], ...] works.
+class ConceptEmbedder
+  def embed(texts)
+    texts.map do |t|
+      l = t.downcase
+      [
+        l.match?(/payment|billing|invoice|charge/) ? 1.0 : 0.0,
+        l.match?(/auth|login|session|token/) ? 1.0 : 0.0,
+        l.match?(/deploy|release|ci|pipeline/) ? 1.0 : 0.0
+      ]
+    end
+  end
+end
+
+Task = Struct.new(:name, :description)
+
+Dir.mktmpdir do |dir|
+  store = RCrewAI::Memory::SqliteStore.new(path: File.join(dir, 'memory.db'))
+  agent = RCrewAI::Agent.new(
+    name: 'engineer', role: 'Senior engineer', goal: 'Ship reliable software',
+    memory: { embedder: ConceptEmbedder.new, store: store }
+  )
+
+  # Record a few past executions.
+  agent.memory.add_execution(Task.new('t1', 'fixed the billing invoice bug'),
+                             'adjusted the payment retry logic', 1.2)
+  agent.memory.add_execution(Task.new('t2', 'patched the login session flow'),
+                             'rotated the auth tokens', 0.8)
+  agent.memory.add_execution(Task.new('t3', 'sped up the release pipeline'),
+                             'parallelized the CI stages', 2.0)
+
+  puts '== Semantic recall =='
+  # Query shares NO words with the billing execution, but is conceptually close.
+  query = Task.new('q', 'a customer got double-charged on checkout')
+  puts agent.memory.relevant_executions(query, 1)
+
+  puts "\n== Persistence (reopen the DB in a fresh agent) =="
+  store2 = RCrewAI::Memory::SqliteStore.new(path: File.join(dir, 'memory.db'))
+  agent2 = RCrewAI::Agent.new(name: 'engineer', role: 'r', goal: 'g',
+                              memory: { embedder: ConceptEmbedder.new, store: store2 })
+  puts agent2.memory.relevant_executions(query, 1)
+  puts "stats: #{agent2.memory.stats.inspect}"
+end

data/lib/rcrewai/agent.rb

@@ -39,7 +39,7 @@ module RCrewAI
       @reasoning = options.fetch(:reasoning, false)
       @max_reasoning_attempts = options.fetch(:max_reasoning_attempts, 3)
       @respect_context_window = options.fetch(:respect_context_window, false)
-      @memory = Memory.new
+      @memory = build_memory(options[:memory])
       @rate_limiter = options[:max_rpm] ? RateLimiter.new(max_rpm: options[:max_rpm]) : nil
       @llm_client = wrap_with_rate_limiter(build_llm_client(options[:llm]))
       @knowledge = build_knowledge(options[:knowledge], options[:knowledge_sources])
@@ -220,6 +220,17 @@ module RCrewAI
       RateLimiter::ThrottledClient.new(client, @rate_limiter)
     end
 
+    # Builds the agent's memory. Accepts a pre-built Memory, an options hash
+    # (`{ embedder:, store:, scope:, short_term_limit: }`), or nil for the
+    # zero-config default. Memory is scoped to the agent's name so agents don't
+    # share recall (matters when a persistent store is shared).
+    def build_memory(memory)
+      return memory if memory.is_a?(Memory)
+
+      opts = memory.is_a?(Hash) ? memory : {}
+      Memory.new(scope: opts.fetch(:scope, name), **opts.slice(:embedder, :store, :short_term_limit))
+    end
+
     # Accepts a pre-built Knowledge::Base via +knowledge:+ or an array of
     # sources via +knowledge_sources:+ (wrapped in a Base). Returns nil if
     # neither is given.

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/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

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)
+      @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)
+      @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.0'
 end

data/lib/rcrewai.rb

@@ -22,7 +22,15 @@ 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/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.0
 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,13 @@ 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/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 +424,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