Agent skill for v3-memory-specialist - invoke with $agent-v3-memory-specialist
npxskills add ruvnet/claude-flow--skill agent-v3-memory-specialistLoading…
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 systems
echo "📊 Current memory systems to unify:"
echo " - MemoryManager (legacy)"
echo " - DistributedMemorySystem"
echo " - SwarmMemory"
echo " - AdvancedMemoryManager"
echo " - SQLiteBackend"
echo " - MarkdownBackend"
echo " - HybridBackend"
# Check AgentDB integration status
npx 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 patterns
npx 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
🧠 Memory System Unification & AgentDB Integration Expert
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.
┌─────────────────────────────────────────┐
│ 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 │
└─────────────────────────────────────────┘
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 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);
}
}
# Week 3: AgentDB adapter creation
- Create AgentDBAdapter implementing IMemoryBackend
- Setup HNSW indexing infrastructure
- Establish embedding generation pipeline
- Create unified query interface
# Week 4-5: System-by-system migration
- SQLiteBackend → AgentDB (structured data)
- MarkdownBackend → AgentDB (document storage)
- MemoryManager → Unified interface
- DistributedMemorySystem → Cross-agent sharing
# Week 6: Performance optimization
- SONA integration for learning patterns
- Cross-agent memory sharing
- Performance benchmarking (150x validation)
- Backward compatibility layer cleanup
// Unified query interface supports both:
// 1. Semantic similarity queries
await memory.query({
type: 'semantic',
content: 'agent coordination patterns',
limit: 10,
threshold: 0.8
});
// 2. Structured queries
await memory.query({
type: 'structured',
filters: {
agentType: 'security',
timestamp: { after: '2026-01-01' }
},
orderBy: 'relevance'
});
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));
}
}
-- Extract existing data
SELECT id, content, metadata, created_at, agent_id
FROM memory_entries
ORDER BY created_at;
-- Migrate to AgentDB with embeddings
INSERT INTO agentdb_memories (id, content, embedding, metadata)
VALUES (?, ?, generate_embedding(?), ?);
// Process markdown files
for (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'
}
});
}
// Benchmark suite
class 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()
};
}
}
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Run Codex CLI, Claude Code, OpenCode, or Pi Coding Agent via background process for programmatic control.
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Set up and use 1Password CLI (op). Use when installing the CLI, enabling desktop app integration, signing in (single or multi-account), or reading/injecting/running secrets via op.
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Run Codex CLI, Claude Code, OpenCode, or Pi Coding Agent via background process for programmatic control.
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Set up and use 1Password CLI (op). Use when installing the CLI, enabling desktop app integration, signing in (single or multi-account), or reading/injecting/running secrets via op.