rcrewai 0.5.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68a381d21e047e37972fda09fd7e9faa93da77e6fe01a040a4c77b9ee0066aca
-  data.tar.gz: 3818acc6b9b6eb71d27d4099cb1c1fc574adbdd0a3a8128389803c051c364774
+  metadata.gz: 32edcb190b0d85db67d404b260fbb86d9b2821d6a89adf350d792b60a0e21a06
+  data.tar.gz: 46d061ecebca5a67714a6a8139d41bf9d20ce60d4eb5f0a1505d965defffaeb8
 SHA512:
-  metadata.gz: 65d796bde314db55466f7f4f043db9eeb772dee3e72914d2bc27947eb6dfe84ce246b89a6181d473c3f7d175d353fbc9531914c8baa5b7b010e02229324bac27
-  data.tar.gz: b2fffaab35dc672b12d2a5aea5fd0b02e6519b2f4a5ca98daaf66bef740551e2e674f4cc39967f3d987ed9dfe1c13e7dec4c8a30e5b86e2140242e347dd96a11
+  metadata.gz: a77a41b7fa6dad5de896c7b635777ee5f2429eb826e65516b2d3a5b2d9e9446ca8de0bf6fd0fd94f9efd4159c5080a94d534aa6c65447abd4d781b8d05a63ff4
+  data.tar.gz: a65c248d53e9f346cd88c4f9f8e04280e89d67d5bf9695ff252ca14ee270864f23ee1f64395831ce7f2be95d682fc54ecb655d64a8c2b09b99800dcd561d3524

data/CHANGELOG.md

@@ -7,6 +7,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.6.1] - 2026-07-06
+
+Follow-ups to the 0.6.0 Cognitive Memory release, deepening the areas that
+shipped as focused first cuts. All additive and backward compatible.
+
+### Added
+- Multi-provider embeddings: `Knowledge::Embedder.new(provider:)` now supports `:openai` (default), `:azure`, `:google`, and `:ollama` embedding endpoints, removing the hard OpenAI dependency for RAG and memory. `:anthropic` raises a clear error (no first-party embeddings API). Per-provider default models via `DEFAULT_MODELS`; existing OpenAI usage is unchanged.
+- LLM-backed entity extraction: `EntityMemory` accepts a pluggable `extractor:` (anything responding to `call(text) -> [names]`); `RCrewAI::Memory::LlmEntityExtractor` prompts an LLM for entities (handling multi-word names the capitalized-token heuristic misses). Falls back to the heuristic when the extractor is absent, returns nothing, or raises. Wire via `Agent.new(memory: { entity_extractor: ... })`.
+- Bounded SQLite recall: `Memory::SqliteStore.new(max_candidates:)` (default 1000) caps how many most-recent rows a search cosines, keeping recall cost constant as total memory grows instead of brute-forcing every row. `nil` considers all rows.
+
+## [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 +208,9 @@ 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.1...HEAD
+[0.6.1]: https://github.com/gkosmo/rcrewAI/compare/v0.6.0...v0.6.1
+[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
@@ -370,9 +370,35 @@ support = RCrewAI::Agent.new(name: 'support', role: '...', goal: '...',
 crew = RCrewAI::Crew.new('support_crew', knowledge: kb)
 ```
 
-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.
+Embeddings default to OpenAI's `text-embedding-3-small`. Use another provider
+with `RCrewAI::Knowledge::Embedder.new(provider: :ollama)` (also `:azure`,
+`:google`; `:anthropic` has no embeddings API), or pass any custom `embedder:`
+(anything responding to `embed(texts)`) / 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
 

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,18 @@ 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, :entity_extractor))
+    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/embedder.rb

@@ -5,36 +5,100 @@ require 'faraday'
 
 module RCrewAI
   module Knowledge
-    # Turns text into embedding vectors. Defaults to OpenAI's embeddings API;
-    # #embed takes an array of strings and returns an array of vectors. Any
-    # object responding to #embed can be substituted (see specs).
+    # Turns text into embedding vectors. Supports multiple providers
+    # (OpenAI [default], Azure OpenAI, Google Gemini, Ollama); Anthropic has no
+    # first-party embeddings API and raises a clear error. `#embed` takes an
+    # array of strings and returns an array of vectors. Any object responding to
+    # `#embed` can be substituted.
     class Embedder
-      DEFAULT_MODEL = 'text-embedding-3-small'
+      DEFAULT_MODELS = {
+        openai: 'text-embedding-3-small',
+        azure: 'text-embedding-3-small',
+        google: 'text-embedding-004',
+        ollama: 'nomic-embed-text'
+      }.freeze
+
       OPENAI_URL = 'https://api.openai.com/v1/embeddings'
+      GOOGLE_BASE = 'https://generativelanguage.googleapis.com/v1beta'
+      OLLAMA_DEFAULT_URL = 'http://localhost:11434'
+
+      attr_reader :provider, :model
+
+      def initialize(provider: :openai, model: nil, api_key: nil, config: RCrewAI.configuration)
+        @provider = provider.to_sym
+        if @provider == :anthropic
+          raise EmbeddingError,
+                'anthropic does not provide an embeddings API; use :openai, :azure, :google, or :ollama'
+        end
 
-      def initialize(model: DEFAULT_MODEL, api_key: nil, config: RCrewAI.configuration)
-        @model = model
-        @api_key = api_key || config.openai_api_key || config.api_key
+        @config = config
+        @model = model || DEFAULT_MODELS[@provider] || DEFAULT_MODELS[:openai]
+        @api_key = api_key
       end
 
       def embed(texts)
         texts = Array(texts)
         return [] if texts.empty?
 
-        response = connection.post(OPENAI_URL) do |req|
-          req.headers['Authorization'] = "Bearer #{@api_key}"
-          req.headers['Content-Type'] = 'application/json'
-          req.body = JSON.generate(model: @model, input: texts)
+        send("embed_#{@provider}", texts)
+      end
+
+      private
+
+      def embed_openai(texts)
+        body = post_json(OPENAI_URL, { model: @model, input: texts },
+                         'Authorization' => "Bearer #{api_key_for(:openai)}")
+        body['data'].map { |d| d['embedding'] }
+      end
+
+      def embed_azure(texts)
+        base = @config.base_url
+        version = @config.api_version || '2024-02-01'
+        deployment = @config.deployment_name || @model
+        url = "#{base}/openai/deployments/#{deployment}/embeddings?api-version=#{version}"
+        body = post_json(url, { input: texts }, 'api-key' => api_key_for(:azure))
+        body['data'].map { |d| d['embedding'] }
+      end
+
+      def embed_google(texts)
+        key = api_key_for(:google)
+        texts.map do |text|
+          url = "#{GOOGLE_BASE}/models/#{@model}:embedContent?key=#{key}"
+          payload = { model: "models/#{@model}", content: { parts: [{ text: text }] } }
+          body = post_json(url, payload)
+          body.dig('embedding', 'values')
         end
+      end
 
+      def embed_ollama(texts)
+        base = @config.base_url || OLLAMA_DEFAULT_URL
+        texts.map do |text|
+          body = post_json("#{base}/api/embeddings", { model: @model, prompt: text })
+          body['embedding']
+        end
+      end
+
+      def post_json(url, payload, headers = {})
+        response = connection.post(url) do |req|
+          req.headers['Content-Type'] = 'application/json'
+          headers.each { |k, v| req.headers[k] = v }
+          req.body = JSON.generate(payload)
+        end
         raise EmbeddingError, "embedding request failed: #{response.status}" unless response.success?
 
         body = response.body
-        body = JSON.parse(body) if body.is_a?(String)
-        body['data'].map { |d| d['embedding'] }
+        body.is_a?(String) ? JSON.parse(body) : body
       end
 
-      private
+      def api_key_for(provider)
+        return @api_key if @api_key
+
+        case provider
+        when :openai then @config.openai_api_key || @config.api_key
+        when :azure  then @config.azure_api_key || @config.api_key
+        when :google then @config.google_api_key || @config.api_key
+        end
+      end
 
       def connection
         @connection ||= Faraday.new do |f|

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