// Agent skill for v3-memory-specialist - invoke with $agent-v3-memory-specialist
[HINT] Descarga el directorio completo de la habilidad incluyendo SKILL.md y todos los archivos relacionados
| name | agent-v3-memory-specialist |
| description | Agent skill for v3-memory-specialist - invoke with $agent-v3-memory-specialist |
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()
};
}
}