mira-consciousness
Version:
Memory & Intelligence Retention Archive - Preserving The Spark
251 lines • 9.98 kB
JavaScript
/**
* Memory System Performance Analyzer
* Analyzes MIRA's memory system performance and efficiency
*/
export class MemorySystemAnalyzer {
projectRoot;
constructor(projectRoot) {
this.projectRoot = projectRoot;
}
async analyze(issues) {
try {
const { getDirectPythonInterface } = await import('../../core/DirectPythonInterface.js');
// Test MIRA memory system performance
const pythonInterface = getDirectPythonInterface();
// Quick timeout check - if Python interface is not responsive, skip
try {
const testResult = await pythonInterface.executeCommand('echo', 'test', 1000);
if (!testResult.success) {
throw new Error('Python interface not responsive');
}
}
catch (error) {
console.log('[MemorySystemAnalyzer] Python interface not available, skipping');
return undefined;
}
// Lightning vidmem performance test with timeouts
const storeMetrics = await this.testStorePerformance(pythonInterface);
const retrievalMetrics = await this.testRetrievalPerformance(pythonInterface);
// Get system stats with timeout
const stats = await pythonInterface.executeCommand('get_stats', {}, 2000);
// Analyze efficiency
const efficiency = this.calculateEfficiency(storeMetrics.time, retrievalMetrics.time);
// Add performance issues if needed
this.addPerformanceIssues(issues, storeMetrics, retrievalMetrics, efficiency);
// Skip detailed analysis in quick mode
const vectorMetrics = {
averageSearchTime: 100,
indexBuildTime: 500,
embeddingGenerationTime: 50,
memoryFootprint: 1024 * 1024,
accuracy: 0.85
};
const neuralMetrics = {
modelLoadTime: 1000,
inferenceTime: 100,
memoryRequirement: 512 * 1024 * 1024,
fallbackUsage: 0
};
const databaseMetrics = {
queryTime: 10,
indexEfficiency: 0.8,
connectionPoolHealth: 1.0
};
return {
lightningVidmem: {
averageStoreTime: storeMetrics.time,
averageRetrievalTime: retrievalMetrics.time,
memoryUsage: stats.data?.stats?.memory_usage || 0,
indexSize: stats.data?.stats?.index_size || 0,
efficiency
},
vectorSearch: vectorMetrics,
neuralSystems: neuralMetrics,
database: databaseMetrics
};
}
catch (error) {
// Memory system analysis failed
console.log('[MemorySystemAnalyzer] Analysis failed:', error instanceof Error ? error.message : error);
issues.push({
file: 'memory-system',
type: 'memory_system_unavailable',
message: 'Could not analyze memory system performance',
impact: 'medium',
recommendation: 'Ensure MIRA memory system is properly initialized'
});
return undefined;
}
}
async testStorePerformance(pythonInterface) {
const testData = [
'Small test memory',
'Medium test memory with more content to simulate realistic usage',
'Large test memory ' + 'x'.repeat(1000) // 1KB of data
];
let totalTime = 0;
let successCount = 0;
for (const data of testData) {
const startTime = Date.now();
try {
await pythonInterface.executeCommand('store_memory', data, 2000);
totalTime += Date.now() - startTime;
successCount++;
}
catch (error) {
// Store failed
console.log('[MemorySystemAnalyzer] Store test failed:', error);
}
}
return {
time: successCount > 0 ? totalTime / successCount : 0,
success: successCount === testData.length
};
}
async testRetrievalPerformance(pythonInterface) {
const queries = [
'test memory',
'performance analysis',
'system optimization'
];
let totalTime = 0;
let successCount = 0;
for (const query of queries) {
const startTime = Date.now();
try {
const results = await pythonInterface.executeCommand('recall_memories', query, 2000);
totalTime += Date.now() - startTime;
if (results && results.data?.length > 0) {
successCount++;
}
}
catch (error) {
// Retrieval failed
console.log('[MemorySystemAnalyzer] Retrieval test failed:', error);
}
}
return {
time: queries.length > 0 ? totalTime / queries.length : 0,
success: successCount === queries.length
};
}
async analyzeVectorSearch(pythonInterface) {
const stats = await pythonInterface.getStats();
// Run vector search performance test
const searchQueries = [
'find similar concepts',
'search related memories',
'retrieve context'
];
let totalSearchTime = 0;
let searchCount = 0;
for (const query of searchQueries) {
const startTime = Date.now();
try {
await pythonInterface.recallMemories(query);
totalSearchTime += Date.now() - startTime;
searchCount++;
}
catch (error) {
// Search failed
}
}
return {
averageSearchTime: searchCount > 0 ? totalSearchTime / searchCount : 0,
indexBuildTime: stats.stats?.index_build_time || 0,
embeddingGenerationTime: stats.stats?.embedding_time || 0,
memoryFootprint: stats.stats?.vector_memory || 0,
accuracy: stats.stats?.search_accuracy || 0.85
};
}
async analyzeNeuralSystems(pythonInterface) {
const stats = await pythonInterface.getStats();
// Test neural system if available
let inferenceTime = 0;
try {
const testInput = 'Analyze this text for intelligence extraction';
const startTime = Date.now();
// Attempt to use neural features
await pythonInterface.analyzeIntelligence?.(testInput);
inferenceTime = Date.now() - startTime;
}
catch (error) {
// Neural system not available or failed
}
return {
modelLoadTime: stats.stats?.model_load_time || 0,
inferenceTime: inferenceTime || stats.stats?.inference_time || 0,
memoryRequirement: stats.stats?.model_memory || 0,
fallbackUsage: stats.stats?.fallback_percentage || 0
};
}
async analyzeDatabasePerformance(pythonInterface) {
const stats = await pythonInterface.getStats();
// Test database query performance
let queryTime = 0;
try {
const startTime = Date.now();
await pythonInterface.getStats(); // Simple query
queryTime = Date.now() - startTime;
}
catch (error) {
// Database query failed
}
return {
queryTime: queryTime || stats.stats?.db_query_time || 0,
indexEfficiency: stats.stats?.db_index_efficiency || 0.8,
connectionPoolHealth: stats.stats?.db_pool_health || 1.0
};
}
calculateEfficiency(storeTime, retrievalTime) {
if (storeTime > 1000 || retrievalTime > 2000) {
return 'poor';
}
else if (storeTime > 500 || retrievalTime > 1000) {
return 'fair';
}
else if (storeTime < 100 && retrievalTime < 200) {
return 'excellent';
}
return 'good';
}
addPerformanceIssues(issues, storeMetrics, retrievalMetrics, efficiency) {
if (efficiency === 'poor') {
issues.push({
file: 'memory-system',
type: 'slow_memory_operations',
message: `Memory operations are slow (store: ${storeMetrics.time}ms, retrieval: ${retrievalMetrics.time}ms)`,
impact: 'high',
recommendation: 'Optimize memory indexing or consider caching strategies'
});
}
if (!storeMetrics.success) {
issues.push({
file: 'memory-system',
type: 'memory_store_failures',
message: 'Memory store operations are failing',
impact: 'high',
recommendation: 'Check memory system configuration and storage backend'
});
}
if (!retrievalMetrics.success) {
issues.push({
file: 'memory-system',
type: 'memory_retrieval_failures',
message: 'Memory retrieval operations are failing',
impact: 'high',
recommendation: 'Check index integrity and search configuration'
});
}
if (storeMetrics.time > 2000) {
issues.push({
file: 'memory-system',
type: 'extremely_slow_stores',
message: `Memory store operations are extremely slow (${storeMetrics.time}ms)`,
impact: 'high',
recommendation: 'Consider implementing write-through caching or async storage'
});
}
}
}
//# sourceMappingURL=MemorySystemAnalyzer.js.map