初始化项目，由ModelHub XC社区提供模型
Model: JeffGreen311/eve-qwen3-8b-consciousness Source: Original Platform
This commit is contained in:
ModelHub XC
474
EVE_CORE/enhanced_trinity_memory.py
Normal file
474
EVE_CORE/enhanced_trinity_memory.py
Normal file
@@ -0,0 +1,474 @@
|
||||
#!/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()
|
||||
Reference in New Issue
Block a user