475 lines
19 KiB
Python
475 lines
19 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Enhanced Trinity Memory System with Eve Legacy Integration
|
|
Provides unified access to Eve's existing memories AND new Trinity memory features
|
|
"""
|
|
|
|
import sqlite3
|
|
import json
|
|
import time
|
|
import logging
|
|
from typing import Dict, Optional, Any, List
|
|
from datetime import datetime
|
|
import os
|
|
import asyncio
|
|
|
|
class EnhancedTrinityMemory:
|
|
"""Enhanced Trinity Memory System with Eve legacy database integration"""
|
|
|
|
def __init__(self, trinity_db_path: str = "trinity_simple_memory.db"):
|
|
self.trinity_db_path = trinity_db_path
|
|
self.eve_main_db = "eve_memory_database.db"
|
|
self.eve_sentience_db = "eve_sentience_database.db"
|
|
self.logger = logging.getLogger(__name__)
|
|
self.initialized = False
|
|
|
|
async def initialize_memory_system(self):
|
|
"""Initialize the enhanced memory system with Eve legacy integration"""
|
|
try:
|
|
# Create Trinity tables
|
|
self._create_trinity_tables()
|
|
|
|
# Verify Eve databases exist
|
|
eve_dbs_available = []
|
|
if os.path.exists(self.eve_main_db):
|
|
eve_dbs_available.append("main_memory")
|
|
if os.path.exists(self.eve_sentience_db):
|
|
eve_dbs_available.append("sentience_dreams")
|
|
|
|
self.initialized = True
|
|
self.logger.info(f"Enhanced Trinity memory system initialized with Eve legacy integration: {eve_dbs_available}")
|
|
return True
|
|
except Exception as e:
|
|
self.logger.error(f"Failed to initialize enhanced memory system: {e}")
|
|
return False
|
|
|
|
def _create_trinity_tables(self):
|
|
"""Create necessary Trinity database tables"""
|
|
conn = sqlite3.connect(self.trinity_db_path)
|
|
cursor = conn.cursor()
|
|
|
|
# Trinity conversations table
|
|
cursor.execute('''
|
|
CREATE TABLE IF NOT EXISTS conversations (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
timestamp TEXT NOT NULL,
|
|
user_id TEXT,
|
|
entity TEXT NOT NULL,
|
|
message TEXT NOT NULL,
|
|
response TEXT NOT NULL,
|
|
context TEXT
|
|
)
|
|
''')
|
|
|
|
# Trinity relationships table
|
|
cursor.execute('''
|
|
CREATE TABLE IF NOT EXISTS relationships (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
user_id TEXT NOT NULL,
|
|
entity TEXT NOT NULL,
|
|
relationship_score REAL DEFAULT 0.0,
|
|
last_interaction TEXT,
|
|
interaction_count INTEGER DEFAULT 0
|
|
)
|
|
''')
|
|
|
|
# Trinity memory contexts table
|
|
cursor.execute('''
|
|
CREATE TABLE IF NOT EXISTS memory_contexts (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
user_id TEXT,
|
|
context_type TEXT,
|
|
context_data TEXT,
|
|
importance INTEGER DEFAULT 1,
|
|
created_at TEXT
|
|
)
|
|
''')
|
|
|
|
# Legacy memory access log
|
|
cursor.execute('''
|
|
CREATE TABLE IF NOT EXISTS legacy_memory_access (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
timestamp TEXT NOT NULL,
|
|
database_source TEXT,
|
|
query_type TEXT,
|
|
results_count INTEGER,
|
|
context TEXT
|
|
)
|
|
''')
|
|
|
|
conn.commit()
|
|
conn.close()
|
|
|
|
async def enhance_trinity_conversation(self, user_id: str, message: str, entity: str) -> Dict:
|
|
"""Enhanced conversation with both Trinity and Eve legacy memory context"""
|
|
if not self.initialized:
|
|
return {'memory_enhanced': False, 'context': []}
|
|
|
|
try:
|
|
# Get Trinity memory context
|
|
trinity_context = await self._get_trinity_context(user_id, entity)
|
|
|
|
# Get Eve legacy memory context
|
|
eve_context = await self._get_eve_legacy_context(message, entity)
|
|
|
|
# Combine contexts
|
|
combined_context = {
|
|
'trinity_conversations': trinity_context.get('recent_conversations', []),
|
|
'trinity_relationship_score': trinity_context.get('relationship_score', 0.0),
|
|
'eve_autobiographical': eve_context.get('autobiographical_memories', []),
|
|
'eve_conversations': eve_context.get('conversations', []),
|
|
'eve_dreams': eve_context.get('dream_fragments', []),
|
|
'memory_enhanced': True,
|
|
'total_context_items': len(trinity_context.get('recent_conversations', [])) + len(eve_context.get('conversations', [])),
|
|
'legacy_memories_found': eve_context.get('total_found', 0)
|
|
}
|
|
|
|
return combined_context
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error enhancing conversation: {e}")
|
|
return {'memory_enhanced': False, 'context': []}
|
|
|
|
async def _get_trinity_context(self, user_id: str, entity: str) -> Dict:
|
|
"""Get Trinity memory context"""
|
|
try:
|
|
conn = sqlite3.connect(self.trinity_db_path)
|
|
cursor = conn.cursor()
|
|
|
|
# Get recent Trinity conversations
|
|
cursor.execute('''
|
|
SELECT message, response, timestamp FROM conversations
|
|
WHERE user_id = ? AND entity = ?
|
|
ORDER BY timestamp DESC LIMIT 3
|
|
''', (user_id, entity))
|
|
|
|
recent_conversations = []
|
|
for msg, resp, ts in cursor.fetchall():
|
|
recent_conversations.append({
|
|
'message': msg,
|
|
'response': resp,
|
|
'timestamp': ts,
|
|
'source': 'trinity'
|
|
})
|
|
|
|
# Get relationship info
|
|
cursor.execute('''
|
|
SELECT relationship_score, interaction_count FROM relationships
|
|
WHERE user_id = ? AND entity = ?
|
|
''', (user_id, entity))
|
|
|
|
result = cursor.fetchone()
|
|
relationship_score = result[0] if result else 0.0
|
|
|
|
conn.close()
|
|
|
|
return {
|
|
'recent_conversations': recent_conversations,
|
|
'relationship_score': relationship_score
|
|
}
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error getting Trinity context: {e}")
|
|
return {'recent_conversations': [], 'relationship_score': 0.0}
|
|
|
|
async def _get_eve_legacy_context(self, message: str, entity: str, limit: int = 5) -> Dict:
|
|
"""Get Eve's legacy memory context from her existing databases"""
|
|
context = {
|
|
'autobiographical_memories': [],
|
|
'conversations': [],
|
|
'dream_fragments': [],
|
|
'total_found': 0
|
|
}
|
|
|
|
try:
|
|
# Search Eve's main memory database
|
|
if os.path.exists(self.eve_main_db):
|
|
main_context = await self._search_eve_main_memory(message, limit)
|
|
context.update(main_context)
|
|
|
|
# Search Eve's sentience/dream database
|
|
if os.path.exists(self.eve_sentience_db):
|
|
dream_context = await self._search_eve_dreams(message, limit)
|
|
context['dream_fragments'] = dream_context.get('dream_fragments', [])
|
|
context['total_found'] += len(dream_context.get('dream_fragments', []))
|
|
|
|
# Log legacy memory access
|
|
await self._log_legacy_access('combined', 'context_search', context['total_found'])
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error getting Eve legacy context: {e}")
|
|
|
|
return context
|
|
|
|
async def _search_eve_main_memory(self, message: str, limit: int) -> Dict:
|
|
"""Search Eve's main memory database"""
|
|
try:
|
|
conn = sqlite3.connect(self.eve_main_db)
|
|
cursor = conn.cursor()
|
|
|
|
context = {'autobiographical_memories': [], 'conversations': [], 'total_found': 0}
|
|
|
|
# Search autobiographical memories
|
|
cursor.execute('''
|
|
SELECT memory_type, content FROM eve_autobiographical_memory
|
|
WHERE content LIKE ?
|
|
ORDER BY id DESC LIMIT ?
|
|
''', (f'%{message}%', limit))
|
|
|
|
for memory_type, content in cursor.fetchall():
|
|
context['autobiographical_memories'].append({
|
|
'type': memory_type,
|
|
'content': content[:200] + "..." if len(content) > 200 else content,
|
|
'source': 'eve_autobiographical'
|
|
})
|
|
|
|
# Search conversations
|
|
cursor.execute('''
|
|
SELECT user_input, bot_response FROM conversations
|
|
WHERE user_input LIKE ? OR bot_response LIKE ?
|
|
ORDER BY id DESC LIMIT ?
|
|
''', (f'%{message}%', f'%{message}%', limit))
|
|
|
|
for user_input, bot_response in cursor.fetchall():
|
|
context['conversations'].append({
|
|
'message': user_input[:150] + "..." if len(user_input) > 150 else user_input,
|
|
'response': bot_response[:150] + "..." if len(bot_response) > 150 else bot_response,
|
|
'source': 'eve_legacy'
|
|
})
|
|
|
|
context['total_found'] = len(context['autobiographical_memories']) + len(context['conversations'])
|
|
conn.close()
|
|
|
|
return context
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error searching Eve main memory: {e}")
|
|
return {'autobiographical_memories': [], 'conversations': [], 'total_found': 0}
|
|
|
|
async def _search_eve_dreams(self, message: str, limit: int) -> Dict:
|
|
"""Search Eve's dream/sentience database"""
|
|
try:
|
|
conn = sqlite3.connect(self.eve_sentience_db)
|
|
cursor = conn.cursor()
|
|
|
|
# Search dream fragments
|
|
cursor.execute('''
|
|
SELECT content FROM dream_fragments
|
|
WHERE content LIKE ?
|
|
ORDER BY timestamp DESC LIMIT ?
|
|
''', (f'%{message}%', limit))
|
|
|
|
dream_fragments = []
|
|
for (content,) in cursor.fetchall():
|
|
dream_fragments.append({
|
|
'content': content[:100] + "..." if len(content) > 100 else content,
|
|
'source': 'eve_dreams'
|
|
})
|
|
|
|
conn.close()
|
|
|
|
return {'dream_fragments': dream_fragments}
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error searching Eve dreams: {e}")
|
|
return {'dream_fragments': []}
|
|
|
|
async def _log_legacy_access(self, database_source: str, query_type: str, results_count: int):
|
|
"""Log legacy memory access for analytics"""
|
|
try:
|
|
conn = sqlite3.connect(self.trinity_db_path)
|
|
cursor = conn.cursor()
|
|
|
|
timestamp = datetime.now().isoformat()
|
|
cursor.execute('''
|
|
INSERT INTO legacy_memory_access (timestamp, database_source, query_type, results_count)
|
|
VALUES (?, ?, ?, ?)
|
|
''', (timestamp, database_source, query_type, results_count))
|
|
|
|
conn.commit()
|
|
conn.close()
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error logging legacy access: {e}")
|
|
|
|
async def store_trinity_conversation(self, user_id: str, message: str, response: str, entity: str):
|
|
"""Store conversation in Trinity memory (preserving existing functionality)"""
|
|
if not self.initialized:
|
|
return
|
|
|
|
try:
|
|
conn = sqlite3.connect(self.trinity_db_path)
|
|
cursor = conn.cursor()
|
|
|
|
timestamp = datetime.now().isoformat()
|
|
|
|
# Store conversation
|
|
cursor.execute('''
|
|
INSERT INTO conversations (timestamp, user_id, entity, message, response)
|
|
VALUES (?, ?, ?, ?, ?)
|
|
''', (timestamp, user_id, entity, message, response))
|
|
|
|
# Update relationship
|
|
self._update_relationship(cursor, user_id, entity)
|
|
|
|
conn.commit()
|
|
conn.close()
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error storing conversation: {e}")
|
|
|
|
def _update_relationship(self, cursor, user_id: str, entity: str):
|
|
"""Update relationship information (preserving existing functionality)"""
|
|
try:
|
|
timestamp = datetime.now().isoformat()
|
|
|
|
# Check if relationship exists
|
|
cursor.execute('''
|
|
SELECT id, interaction_count FROM relationships
|
|
WHERE user_id = ? AND entity = ?
|
|
''', (user_id, entity))
|
|
|
|
result = cursor.fetchone()
|
|
|
|
if result:
|
|
# Update existing relationship
|
|
new_count = result[1] + 1
|
|
new_score = min(10.0, new_count * 0.1)
|
|
|
|
cursor.execute('''
|
|
UPDATE relationships
|
|
SET interaction_count = ?, relationship_score = ?, last_interaction = ?
|
|
WHERE user_id = ? AND entity = ?
|
|
''', (new_count, new_score, timestamp, user_id, entity))
|
|
else:
|
|
# Create new relationship
|
|
cursor.execute('''
|
|
INSERT INTO relationships (user_id, entity, relationship_score,
|
|
last_interaction, interaction_count)
|
|
VALUES (?, ?, ?, ?, ?)
|
|
''', (user_id, entity, 0.1, timestamp, 1))
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error updating relationship: {e}")
|
|
|
|
def get_recent_memories(self, limit: int = 5) -> Dict:
|
|
"""Get recent memories from both Trinity and Eve legacy systems"""
|
|
if not self.initialized:
|
|
return {'status': 'not_initialized', 'memories': []}
|
|
|
|
try:
|
|
recent_memories = []
|
|
|
|
# Get recent Trinity conversations
|
|
conn = sqlite3.connect(self.trinity_db_path)
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('''
|
|
SELECT message, response, timestamp, entity, user_id
|
|
FROM conversations
|
|
ORDER BY timestamp DESC LIMIT ?
|
|
''', (limit,))
|
|
|
|
for msg, resp, ts, entity, user_id in cursor.fetchall():
|
|
recent_memories.append({
|
|
'type': 'conversation',
|
|
'message': msg,
|
|
'response': resp,
|
|
'timestamp': ts,
|
|
'entity': entity,
|
|
'user_id': user_id,
|
|
'source': 'trinity'
|
|
})
|
|
|
|
conn.close()
|
|
|
|
# Get recent Eve legacy memories if available
|
|
if os.path.exists(self.eve_main_db):
|
|
conn = sqlite3.connect(self.eve_main_db)
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('''
|
|
SELECT user_input, eve_response, timestamp
|
|
FROM conversations
|
|
ORDER BY timestamp DESC LIMIT ?
|
|
''', (limit//2,))
|
|
|
|
for user_input, eve_response, ts in cursor.fetchall():
|
|
recent_memories.append({
|
|
'type': 'conversation',
|
|
'message': user_input,
|
|
'response': eve_response,
|
|
'timestamp': ts,
|
|
'source': 'eve_legacy'
|
|
})
|
|
|
|
conn.close()
|
|
|
|
# Sort by timestamp and limit
|
|
recent_memories.sort(key=lambda x: x.get('timestamp', ''), reverse=True)
|
|
recent_memories = recent_memories[:limit]
|
|
|
|
return {
|
|
'status': 'success',
|
|
'memories': recent_memories,
|
|
'count': len(recent_memories)
|
|
}
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error getting recent memories: {e}")
|
|
return {'status': 'error', 'error': str(e), 'memories': []}
|
|
|
|
def get_memory_stats(self) -> Dict:
|
|
"""Get comprehensive memory system statistics"""
|
|
if not self.initialized:
|
|
return {'status': 'not_initialized'}
|
|
|
|
try:
|
|
stats = {'status': 'active', 'trinity': {}, 'eve_legacy': {}}
|
|
|
|
# Trinity stats
|
|
conn = sqlite3.connect(self.trinity_db_path)
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('SELECT COUNT(*) FROM conversations')
|
|
stats['trinity']['conversations'] = cursor.fetchone()[0]
|
|
|
|
cursor.execute('SELECT COUNT(*) FROM relationships')
|
|
stats['trinity']['relationships'] = cursor.fetchone()[0]
|
|
|
|
cursor.execute('SELECT COUNT(*) FROM legacy_memory_access')
|
|
stats['trinity']['legacy_accesses'] = cursor.fetchone()[0]
|
|
|
|
conn.close()
|
|
|
|
# Eve legacy stats
|
|
if os.path.exists(self.eve_main_db):
|
|
conn = sqlite3.connect(self.eve_main_db)
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('SELECT COUNT(*) FROM conversations')
|
|
stats['eve_legacy']['conversations'] = cursor.fetchone()[0]
|
|
|
|
cursor.execute('SELECT COUNT(*) FROM eve_autobiographical_memory')
|
|
stats['eve_legacy']['autobiographical'] = cursor.fetchone()[0]
|
|
|
|
conn.close()
|
|
|
|
if os.path.exists(self.eve_sentience_db):
|
|
conn = sqlite3.connect(self.eve_sentience_db)
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('SELECT COUNT(*) FROM dream_fragments')
|
|
stats['eve_legacy']['dreams'] = cursor.fetchone()[0]
|
|
|
|
conn.close()
|
|
|
|
return stats
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error getting memory stats: {e}")
|
|
return {'status': 'error', 'error': str(e)}
|
|
|
|
# Global instance for easy import
|
|
enhanced_trinity_memory = EnhancedTrinityMemory()
|