Agent V3 Memory Specialist

ruvnet/ruflo/.agents/skills/agent-v3-memory-specialist

作者 ruvnet6051f6702b61無授權條款74K 個星標收錄於 2026年10月8日更新於 2026年10月8日儲存庫今天更新

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

僅含說明AI & Agents

AI 產生的概覽

定義專家代理角色，用於將多個記憶後端統一為搭載 HNSW 向量索引的 AgentDB 服務。

功能: 此技能提供記憶專家代理的角色定義，用於把七套舊有記憶系統整合為單一的 AgentDB 服務。內容說明 UnifiedMemoryService 介面、HNSW 向量索引、語意與結構化查詢介面、SONA 學習模式儲存，以及從 SQLite 與 Markdown 後端遷移的分階段方案。同時列出效能目標、基準與成功標準，以及與其他架構與效能代理的協作點。
適用情境: 適用於規劃或記錄將多個代理記憶後端整併為統一索引服務的工作。它著重於記憶架構、遷移順序與搜尋效能目標，而非日常編碼任務。
執行需求: 僅為說明內容，未附帶指令碼。文件引用 agentic-flow@alpha、AgentDB、HNSW 索引與嵌入產生等外部工具，需另行提供。

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

來源與署名

來源：ruvnet/ruflo位於.agents/skills/agent-v3-memory-specialist提交6051f67

授權條款：無授權條款

內容歸原作者所有。SourceWeft 從公開儲存庫中收錄這些內容。

檢舉或申請下架

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)

來源與署名

更多來自 ruvnet/ruflo 的技能

Cron Schedule

Autopilot Predict

Autopilot Loop

Worker Integration

Worker Integration

Worker Benchmarks

更多AI & Agents技能

Ppt Template Creator

Skill Development

Plugin Structure

Command Development

Claude Md Improver

Find Skills