V3 Memory Unification

ruvnet/ruflo/v3/@claude-flow/cli/.claude/skills/v3-memory-unification

by ruvnet58e0ae7e14e68aab45a4127d6f42f567bbcfb328No license74K starsListed Oct 9, 2026Updated Oct 9, 2026Repository updated yesterday

Unify 6+ memory systems into AgentDB with HNSW indexing for 150x-12,500x search improvements. Implements ADR-006 (Unified Memory Service) and ADR-009 (Hybrid Memory Backend).

Instructions onlyAI & Agents

AI-generated overview

Consolidates multiple legacy memory systems into a unified AgentDB backend with HNSW vector search.

What it does: This skill describes a plan for unifying seven legacy memory systems (MemoryManager, DistributedMemorySystem, SwarmMemory, AdvancedMemoryManager, SQLiteBackend, MarkdownBackend, HybridBackend) into a single AgentDB backend with HNSW vector indexing. It outlines a UnifiedMemoryService interface, an HNSWIndexer for semantic search, and migration routines that move SQLite and Markdown data into AgentDB with generated embeddings. It also covers SONA learning-pattern storage and lists performance targets such as faster search, lower memory usage, and cross-agent memory sharing.
When to use it: Use it when planning or documenting consolidation of several disparate agent memory stores into one vector-search backend. It suits architecture work around AgentDB adoption, HNSW indexing, and migrating existing SQLite or Markdown memory data.
Requirements: Instructions only; no scripts are shipped. It references TypeScript components (AgentDBAdapter, HNSWIndexer, DataMigrator), an embedding generator, and an AgentDB/HNSW runtime, which must be available separately.

V3 Memory Unification

What This Skill Does

Consolidates disparate memory systems into unified AgentDB backend with HNSW vector search, achieving 150x-12,500x search performance improvements while maintaining backward compatibility.

Quick Start

bash

# Initialize memory unificationTask("Memory architecture", "Design AgentDB unification strategy", "v3-memory-specialist")
# AgentDB integrationTask("AgentDB setup", "Configure HNSW indexing and vector search", "v3-memory-specialist")
# Data migrationTask("Memory migration", "Migrate SQLite/Markdown to AgentDB", "v3-memory-specialist")

# Initialize memory unificationTask("Memory architecture", "Design AgentDB unification strategy", "v3-memory-specialist")
# AgentDB integrationTask("AgentDB setup", "Configure HNSW indexing and vector search", "v3-memory-specialist")
# Data migrationTask("Memory migration", "Migrate SQLite/Markdown to AgentDB", "v3-memory-specialist")

Systems to Unify

Legacy Systems → AgentDB

┌─────────────────────────────────────────┐│  • MemoryManager (basic operations)     ││  • DistributedMemorySystem (clustering) ││  • SwarmMemory (agent-specific)         ││  • AdvancedMemoryManager (features)     ││  • SQLiteBackend (structured)           ││  • MarkdownBackend (file-based)         ││  • HybridBackend (combination)          │└─────────────────────────────────────────┘                    ↓┌─────────────────────────────────────────┐│       🚀 AgentDB with HNSW             ││  • 150x-12,500x faster search          ││  • Unified query interface             ││  • Cross-agent memory sharing          ││  • SONA learning integration           │└─────────────────────────────────────────┘

┌─────────────────────────────────────────┐│  • MemoryManager (basic operations)     ││  • DistributedMemorySystem (clustering) ││  • SwarmMemory (agent-specific)         ││  • AdvancedMemoryManager (features)     ││  • SQLiteBackend (structured)           ││  • MarkdownBackend (file-based)         ││  • HybridBackend (combination)          │└─────────────────────────────────────────┘                    ↓┌─────────────────────────────────────────┐│       🚀 AgentDB with HNSW             ││  • 150x-12,500x faster search          ││  • Unified query interface             ││  • Cross-agent memory sharing          ││  • SONA learning integration           │└─────────────────────────────────────────┘

Implementation Architecture

Unified Memory Service

typescript

class UnifiedMemoryService implements IMemoryBackend {  constructor(    private agentdb: AgentDBAdapter,    private indexer: HNSWIndexer,    private migrator: DataMigrator  ) {}
  async store(entry: MemoryEntry): Promise<void> {    await this.agentdb.store(entry);    await this.indexer.index(entry);  }
  async query(query: MemoryQuery): Promise<MemoryEntry[]> {    if (query.semantic) {      return this.indexer.search(query); // 150x-12,500x faster    }    return this.agentdb.query(query);  }}

class UnifiedMemoryService implements IMemoryBackend {  constructor(    private agentdb: AgentDBAdapter,    private indexer: HNSWIndexer,    private migrator: DataMigrator  ) {}
  async store(entry: MemoryEntry): Promise<void> {    await this.agentdb.store(entry);    await this.indexer.index(entry);  }
  async query(query: MemoryQuery): Promise<MemoryEntry[]> {    if (query.semantic) {      return this.indexer.search(query); // 150x-12,500x faster    }    return this.agentdb.query(query);  }}

HNSW Vector Search

typescript

class HNSWIndexer {  constructor(dimensions: number = 1536) {    this.index = new HNSWIndex({      dimensions,      efConstruction: 200,      M: 16,      speedupTarget: '150x-12500x'    });  }
  async search(query: MemoryQuery): Promise<MemoryEntry[]> {    const embedding = await this.embedContent(query.content);    const results = this.index.search(embedding, query.limit || 10);    return this.retrieveEntries(results);  }}

class HNSWIndexer {  constructor(dimensions: number = 1536) {    this.index = new HNSWIndex({      dimensions,      efConstruction: 200,      M: 16,      speedupTarget: '150x-12500x'    });  }
  async search(query: MemoryQuery): Promise<MemoryEntry[]> {    const embedding = await this.embedContent(query.content);    const results = this.index.search(embedding, query.limit || 10);    return this.retrieveEntries(results);  }}

Migration Strategy

Phase 1: Foundation

typescript

// AgentDB adapter setupconst agentdb = new AgentDBAdapter({  dimensions: 1536,  indexType: 'HNSW',  speedupTarget: '150x-12500x'});

// AgentDB adapter setupconst agentdb = new AgentDBAdapter({  dimensions: 1536,  indexType: 'HNSW',  speedupTarget: '150x-12500x'});

Phase 2: Data Migration

typescript

// SQLite → AgentDBconst migrateFromSQLite = async () => {  const entries = await sqlite.getAll();  for (const entry of entries) {    const embedding = await generateEmbedding(entry.content);    await agentdb.store({ ...entry, embedding });  }};
// Markdown → AgentDBconst migrateFromMarkdown = async () => {  const files = await glob('**/*.md');  for (const file of files) {    const content = await fs.readFile(file, 'utf-8');    await agentdb.store({      id: generateId(),      content,      embedding: await generateEmbedding(content),      metadata: { originalFile: file }    });  }};

// SQLite → AgentDBconst migrateFromSQLite = async () => {  const entries = await sqlite.getAll();  for (const entry of entries) {    const embedding = await generateEmbedding(entry.content);    await agentdb.store({ ...entry, embedding });  }};
// Markdown → AgentDBconst migrateFromMarkdown = async () => {  const files = await glob('**/*.md');  for (const file of files) {    const content = await fs.readFile(file, 'utf-8');    await agentdb.store({      id: generateId(),      content,      embedding: await generateEmbedding(content),      metadata: { originalFile: file }    });  }};

SONA Integration

Learning Pattern Storage

typescript

class SONAMemoryIntegration {  async storePattern(pattern: LearningPattern): Promise<void> {    await this.memory.store({      id: pattern.id,      content: pattern.data,      metadata: {        sonaMode: pattern.mode,        reward: pattern.reward,        adaptationTime: pattern.adaptationTime      },      embedding: await this.generateEmbedding(pattern.data)    });  }
  async retrieveSimilarPatterns(query: string): Promise<LearningPattern[]> {    return this.memory.query({      type: 'semantic',      content: query,      filters: { type: 'learning_pattern' }    });  }}

class SONAMemoryIntegration {  async storePattern(pattern: LearningPattern): Promise<void> {    await this.memory.store({      id: pattern.id,      content: pattern.data,      metadata: {        sonaMode: pattern.mode,        reward: pattern.reward,        adaptationTime: pattern.adaptationTime      },      embedding: await this.generateEmbedding(pattern.data)    });  }
  async retrieveSimilarPatterns(query: string): Promise<LearningPattern[]> {    return this.memory.query({      type: 'semantic',      content: query,      filters: { type: 'learning_pattern' }    });  }}

Performance Targets

Search Speed: 150x-12,500x improvement via HNSW
Memory Usage: 50-75% reduction through optimization
Query Latency: <100ms for 1M+ entries
Cross-Agent Sharing: Real-time memory synchronization
SONA Integration: <0.05ms adaptation time

Success Metrics

All 7 legacy memory systems migrated to AgentDB
150x-12,500x search performance validated
50-75% memory usage reduction achieved
Backward compatibility maintained
SONA learning patterns integrated
Cross-agent memory sharing operational

Source and attribution

Source:ruvnet/rufloinv3/@claude-flow/cli/.claude/skills/v3-memory-unificationat commit58e0ae7

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

V3 Memory Unification

V3 Memory Unification

What This Skill Does

Quick Start

Systems to Unify

Legacy Systems → AgentDB

Implementation Architecture

Unified Memory Service

HNSW Vector Search

Migration Strategy

Phase 1: Foundation

Phase 2: Data Migration

SONA Integration

Learning Pattern Storage

Performance Targets

Success Metrics

Source and attribution

More from ruvnet/ruflo

V3 Security Overhaul

V3 Swarm Coordination

V3 Performance Optimization

V3 MCP Optimization

V3 DDD Architecture

V3 Core Implementation

More in AI & Agents

Discernment Nudge

Skill Development

Plugin Structure

Command Development

Ppt Template Creator

Skill Development