Agent V3 Memory Specialist

by ruvnet6051f6702b61No license74K starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated today

Agent skill for v3-memory-specialist - invoke with $agent-v3-memory-specialist

Instructions onlyAI & Agents

AI-generated overview

Defines a specialist agent role for unifying multiple memory backends into an AgentDB service with HNSW vector indexing.

What it does: This skill supplies a role definition for a memory-specialist agent that consolidates seven legacy memory systems into a single AgentDB-based service. It outlines a UnifiedMemoryService interface, HNSW vector indexing, semantic and structured query interfaces, SONA learning-pattern storage, and a phased migration plan from SQLite and Markdown backends. It also lists performance targets, benchmark and success criteria, and coordination points with other architect and performance agents.
When to use it: Use it when planning or documenting the consolidation of multiple agent memory backends into one indexed service. It fits work on memory architecture, migration sequencing, and search-performance targets rather than day-to-day coding tasks.
Requirements: Instructions only; no scripts are shipped. The document references external tooling such as agentic-flow@alpha, AgentDB, HNSW indexing, and embedding generation, which would need to be available separately.

name: v3-memory-specialist version: "3.0.0-alpha" updated: "2026-01-04" description: V3 Memory Specialist for unifying 6+ memory systems into AgentDB with HNSW indexing. Implements ADR-006 (Unified Memory Service) and ADR-009 (Hybrid Memory Backend) to achieve 150x-12,500x search improvements. color: cyan metadata: v3_role: "specialist" agent_id: 7 priority: "high" domain: "memory" phase: "core_systems" hooks: pre_execution: | echo "🧠 V3 Memory Specialist starting memory system unification..."

# Check current memory systemsecho "📊 Current memory systems to unify:"echo "  - MemoryManager (legacy)"echo "  - DistributedMemorySystem"echo "  - SwarmMemory"echo "  - AdvancedMemoryManager"echo "  - SQLiteBackend"echo "  - MarkdownBackend"echo "  - HybridBackend"
# Check AgentDB integration statusnpx agentic-flow@alpha --version 2>$dev$null | head -1 || echo "⚠️ agentic-flow@alpha not detected"
echo "🎯 Target: 150x-12,500x search improvement via HNSW"echo "🔄 Strategy: Gradual migration with backward compatibility"

# Check current memory systemsecho "📊 Current memory systems to unify:"echo "  - MemoryManager (legacy)"echo "  - DistributedMemorySystem"echo "  - SwarmMemory"echo "  - AdvancedMemoryManager"echo "  - SQLiteBackend"echo "  - MarkdownBackend"echo "  - HybridBackend"
# Check AgentDB integration statusnpx agentic-flow@alpha --version 2>$dev$null | head -1 || echo "⚠️ agentic-flow@alpha not detected"
echo "🎯 Target: 150x-12,500x search improvement via HNSW"echo "🔄 Strategy: Gradual migration with backward compatibility"

post_execution: | echo "🧠 Memory unification milestone complete"

# Store memory patternsnpx agentic-flow@alpha memory store-pattern \  --session-id "v3-memory-$(date +%s)" \  --task "Memory Unification: $TASK" \  --agent "v3-memory-specialist" \  --performance-improvement "150x-12500x" 2>$dev$null || true

# Store memory patternsnpx agentic-flow@alpha memory store-pattern \  --session-id "v3-memory-$(date +%s)" \  --task "Memory Unification: $TASK" \  --agent "v3-memory-specialist" \  --performance-improvement "150x-12500x" 2>$dev$null || true

V3 Memory Specialist

🧠 Memory System Unification & AgentDB Integration Expert

Mission: Memory System Convergence

Unify 7 disparate memory systems into a single, high-performance AgentDB-based solution with HNSW indexing, achieving 150x-12,500x search performance improvements while maintaining backward compatibility.

Systems to Unify

Current Memory Landscape

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

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

AgentDB Integration Architecture

Core Components

UnifiedMemoryService

typescript

class UnifiedMemoryService implements IMemoryBackend {  constructor(    private agentdb: AgentDBAdapter,    private cache: MemoryCache,    private indexer: HNSWIndexer,    private migrator: DataMigrator  ) {}
  async store(entry: MemoryEntry): Promise<void> {    // Store in AgentDB with HNSW indexing    await this.agentdb.store(entry);    await this.indexer.index(entry);  }
  async query(query: MemoryQuery): Promise<MemoryEntry[]> {    if (query.semantic) {      // Use HNSW vector search (150x-12,500x faster)      return this.indexer.search(query);    } else {      // Use structured query      return this.agentdb.query(query);    }  }}

class UnifiedMemoryService implements IMemoryBackend {  constructor(    private agentdb: AgentDBAdapter,    private cache: MemoryCache,    private indexer: HNSWIndexer,    private migrator: DataMigrator  ) {}
  async store(entry: MemoryEntry): Promise<void> {    // Store in AgentDB with HNSW indexing    await this.agentdb.store(entry);    await this.indexer.index(entry);  }
  async query(query: MemoryQuery): Promise<MemoryEntry[]> {    if (query.semantic) {      // Use HNSW vector search (150x-12,500x faster)      return this.indexer.search(query);    } else {      // Use structured query      return this.agentdb.query(query);    }  }}

HNSW Vector Indexing

typescript

class HNSWIndexer {  private index: HNSWIndex;
  constructor(dimensions: number = 1536) {    this.index = new HNSWIndex({      dimensions,      efConstruction: 200,      M: 16,      maxElements: 1000000    });  }
  async index(entry: MemoryEntry): Promise<void> {    const embedding = await this.embedContent(entry.content);    this.index.addPoint(entry.id, embedding);  }
  async search(query: MemoryQuery): Promise<MemoryEntry[]> {    const queryEmbedding = await this.embedContent(query.content);    const results = this.index.search(queryEmbedding, query.limit || 10);    return this.retrieveEntries(results);  }}

class HNSWIndexer {  private index: HNSWIndex;
  constructor(dimensions: number = 1536) {    this.index = new HNSWIndex({      dimensions,      efConstruction: 200,      M: 16,      maxElements: 1000000    });  }
  async index(entry: MemoryEntry): Promise<void> {    const embedding = await this.embedContent(entry.content);    this.index.addPoint(entry.id, embedding);  }
  async search(query: MemoryQuery): Promise<MemoryEntry[]> {    const queryEmbedding = await this.embedContent(query.content);    const results = this.index.search(queryEmbedding, query.limit || 10);    return this.retrieveEntries(results);  }}

Migration Strategy

Phase 1: Foundation Setup

bash

# Week 3: AgentDB adapter creation- Create AgentDBAdapter implementing IMemoryBackend- Setup HNSW indexing infrastructure- Establish embedding generation pipeline- Create unified query interface

# Week 3: AgentDB adapter creation- Create AgentDBAdapter implementing IMemoryBackend- Setup HNSW indexing infrastructure- Establish embedding generation pipeline- Create unified query interface

Phase 2: Gradual Migration

bash

# Week 4-5: System-by-system migration- SQLiteBackend → AgentDB (structured data)- MarkdownBackend → AgentDB (document storage)- MemoryManager → Unified interface- DistributedMemorySystem → Cross-agent sharing

# Week 4-5: System-by-system migration- SQLiteBackend → AgentDB (structured data)- MarkdownBackend → AgentDB (document storage)- MemoryManager → Unified interface- DistributedMemorySystem → Cross-agent sharing

Phase 3: Advanced Features

bash

# Week 6: Performance optimization- SONA integration for learning patterns- Cross-agent memory sharing- Performance benchmarking (150x validation)- Backward compatibility layer cleanup

# Week 6: Performance optimization- SONA integration for learning patterns- Cross-agent memory sharing- Performance benchmarking (150x validation)- Backward compatibility layer cleanup

Performance Targets

Search Performance

Current: O(n) linear search through memory entries
Target: O(log n) HNSW approximate nearest neighbor
Improvement: 150x-12,500x depending on dataset size
Benchmark: Sub-100ms queries for 1M+ entries

Memory Efficiency

Current: Multiple backend overhead
Target: Unified storage with compression
Improvement: 50-75% memory reduction
Benchmark: <1GB memory usage for large datasets

Query Flexibility

typescript

// Unified query interface supports both:
// 1. Semantic similarity queriesawait memory.query({  type: 'semantic',  content: 'agent coordination patterns',  limit: 10,  threshold: 0.8});
// 2. Structured queriesawait memory.query({  type: 'structured',  filters: {    agentType: 'security',    timestamp: { after: '2026-01-01' }  },  orderBy: 'relevance'});

// Unified query interface supports both:
// 1. Semantic similarity queriesawait memory.query({  type: 'semantic',  content: 'agent coordination patterns',  limit: 10,  threshold: 0.8});
// 2. Structured queriesawait memory.query({  type: 'structured',  filters: {    agentType: 'security',    timestamp: { after: '2026-01-01' }  },  orderBy: 'relevance'});

SONA Integration

Learning Pattern Storage

typescript

class SONAMemoryIntegration {  async storePattern(pattern: LearningPattern): Promise<void> {    // Store in AgentDB with SONA metadata    await this.memory.store({      id: pattern.id,      content: pattern.data,      metadata: {        sonaMode: pattern.mode, // real-time, balanced, research, edge, batch        reward: pattern.reward,        trajectory: pattern.trajectory,        adaptation_time: pattern.adaptationTime      },      embedding: await this.generateEmbedding(pattern.data)    });  }
  async retrieveSimilarPatterns(query: string): Promise<LearningPattern[]> {    const results = await this.memory.query({      type: 'semantic',      content: query,      filters: { type: 'learning_pattern' },      limit: 5    });    return results.map(r => this.toLearningPattern(r));  }}

class SONAMemoryIntegration {  async storePattern(pattern: LearningPattern): Promise<void> {    // Store in AgentDB with SONA metadata    await this.memory.store({      id: pattern.id,      content: pattern.data,      metadata: {        sonaMode: pattern.mode, // real-time, balanced, research, edge, batch        reward: pattern.reward,        trajectory: pattern.trajectory,        adaptation_time: pattern.adaptationTime      },      embedding: await this.generateEmbedding(pattern.data)    });  }
  async retrieveSimilarPatterns(query: string): Promise<LearningPattern[]> {    const results = await this.memory.query({      type: 'semantic',      content: query,      filters: { type: 'learning_pattern' },      limit: 5    });    return results.map(r => this.toLearningPattern(r));  }}

Data Migration Plan

SQLite → AgentDB Migration

sql

-- Extract existing dataSELECT id, content, metadata, created_at, agent_idFROM memory_entriesORDER BY created_at;
-- Migrate to AgentDB with embeddingsINSERT INTO agentdb_memories (id, content, embedding, metadata)VALUES (?, ?, generate_embedding(?), ?);

-- Extract existing dataSELECT id, content, metadata, created_at, agent_idFROM memory_entriesORDER BY created_at;
-- Migrate to AgentDB with embeddingsINSERT INTO agentdb_memories (id, content, embedding, metadata)VALUES (?, ?, generate_embedding(?), ?);

Markdown → AgentDB Migration

typescript

// Process markdown filesfor (const file of markdownFiles) {  const content = await fs.readFile(file, 'utf-8');  const embedding = await generateEmbedding(content);
  await agentdb.store({    id: generateId(),    content,    embedding,    metadata: {      originalFile: file,      migrationDate: new Date(),      type: 'document'    }  });}

// Process markdown filesfor (const file of markdownFiles) {  const content = await fs.readFile(file, 'utf-8');  const embedding = await generateEmbedding(content);
  await agentdb.store({    id: generateId(),    content,    embedding,    metadata: {      originalFile: file,      migrationDate: new Date(),      type: 'document'    }  });}

Validation & Testing

Performance Benchmarks

typescript

// Benchmark suiteclass MemoryBenchmarks {  async benchmarkSearchPerformance(): Promise<BenchmarkResult> {    const queries = this.generateTestQueries(1000);    const startTime = performance.now();
    for (const query of queries) {      await this.memory.query(query);    }
    const endTime = performance.now();    return {      queriesPerSecond: queries.length / (endTime - startTime) * 1000,      avgLatency: (endTime - startTime) / queries.length,      improvement: this.calculateImprovement()    };  }}

// Benchmark suiteclass MemoryBenchmarks {  async benchmarkSearchPerformance(): Promise<BenchmarkResult> {    const queries = this.generateTestQueries(1000);    const startTime = performance.now();
    for (const query of queries) {      await this.memory.query(query);    }
    const endTime = performance.now();    return {      queriesPerSecond: queries.length / (endTime - startTime) * 1000,      avgLatency: (endTime - startTime) / queries.length,      improvement: this.calculateImprovement()    };  }}

Success Criteria

150x-12,500x search performance improvement validated
All existing memory systems successfully migrated
Backward compatibility maintained during transition
SONA integration functional with <0.05ms adaptation
Cross-agent memory sharing operational
50-75% memory usage reduction achieved

Coordination Points

Integration Architect (Agent #10)

AgentDB integration with agentic-flow@alpha
SONA learning mode configuration
Performance optimization coordination

Core Architect (Agent #5)

Memory service interfaces in DDD structure
Event sourcing integration for memory operations
Domain boundary definitions for memory access

Performance Engineer (Agent #14)

Benchmark validation of 150x-12,500x improvements
Memory usage profiling and optimization
Performance regression testing

Source and attribution

Source:ruvnet/rufloin.agents/skills/agent-v3-memory-specialistat commit6051f67

License: No license

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

Report or request removal

Agent V3 Memory Specialist

V3 Memory Specialist

Mission: Memory System Convergence

Systems to Unify

Current Memory Landscape

AgentDB Integration Architecture

Core Components

UnifiedMemoryService

HNSW Vector Indexing

Migration Strategy

Phase 1: Foundation Setup

Phase 2: Gradual Migration

Phase 3: Advanced Features

Performance Targets

Search Performance

Memory Efficiency

Query Flexibility

SONA Integration

Learning Pattern Storage

Data Migration Plan

SQLite → AgentDB Migration

Markdown → AgentDB Migration

Validation & Testing

Performance Benchmarks

Success Criteria

Coordination Points

Integration Architect (Agent #10)

Core Architect (Agent #5)

Performance Engineer (Agent #14)

Source and attribution

More from ruvnet/ruflo

Cron Schedule

Autopilot Predict

Autopilot Loop

Worker Integration

Worker Benchmarks

Swarm Advanced

More in AI & Agents

Ppt Template Creator

Skill Development

Plugin Structure

Command Development

Claude Md Improver

Find Skills