┌─────────────────────────┐
│   短期记忆层             │
│   (Context Window)      │
│   - 最近N轮对话          │
│   - 当前任务状态         │
└────────────┬────────────┘
             │ 摘要/提炼
┌────────────▼────────────┐
│   中期记忆层             │
│   (Vector Database)     │
│   - 会话摘要             │
│   - 关键信息提取         │
│   - 语义向量索引         │
└────────────┬────────────┘
             │ 重要信息固化
┌────────────▼────────────┐
│   长期记忆层             │
│   (Knowledge Graph +    │
│    Structured Storage)  │
│   - 用户画像             │
│   - 知识图谱             │
│   - 经验库               │
└─────────────────────────┘

from langchain.memory import (
    ConversationBufferMemory,      # 简单缓冲
    ConversationSummaryMemory,     # 摘要记忆
    VectorStoreRetrieverMemory,    # 向量检索
    ConversationKGMemory           # 知识图谱
)

# 示例：使用Chroma存储对话记忆
import chromadb
from sentence_transformers import SentenceTransformer

class VectorMemory:
    def __init__(self, collection_name="agent_memory"):
        self.client = chromadb.PersistentClient()
        self.collection = self.client.get_or_create_collection(collection_name)
        self.embedder = SentenceTransformer('all-MiniLM-L6-v2')
    
    def add_memory(self, text: str, metadata: dict):
        embedding = self.embedder.encode(text).tolist()
        self.collection.add(
            embeddings=[embedding],
            documents=[text],
            metadatas=[metadata],
            ids=[metadata['id']]
        )
    
    def search_memories(self, query: str, top_k=5):
        query_embedding = self.embedder.encode(query).tolist()
        results = self.collection.query(
            query_embeddings=[query_embedding],
            n_results=top_k
        )
        return results

(用户)-[喜欢]->(技术)
(技术)-[属于]->(领域)
(问题)-[解决方案]->(方法)

-- 用户记忆表
CREATE TABLE user_memories (
    id UUID PRIMARY KEY,
    user_id VARCHAR(100),
    memory_type VARCHAR(50),  -- factual, procedural, episodic
    content TEXT,
    importance FLOAT,         -- 重要性评分
    confidence FLOAT,         -- 可信度
    created_at TIMESTAMP,
    last_accessed TIMESTAMP,
    access_count INTEGER,
    metadata JSONB
);

-- 记忆关系表
CREATE TABLE memory_relations (
    source_id UUID REFERENCES user_memories(id),
    target_id UUID REFERENCES user_memories(id),
    relation_type VARCHAR(50),
    strength FLOAT
);

def hybrid_search(query, vector_results, keyword_results, alpha=0.7):
    """
    混合向量检索和关键词检索
    alpha: 向量检索权重
    """
    combined_scores = {}
    
    for doc_id, score in vector_results:
        combined_scores[doc_id] = alpha * score
    
    for doc_id, score in keyword_results:
        if doc_id in combined_scores:
            combined_scores[doc_id] += (1 - alpha) * score
        else:
            combined_scores[doc_id] = (1 - alpha) * score
    
    return sorted(combined_scores.items(), key=lambda x: x[1], reverse=True)

def select_relevant_memories(retrieved_memories, context_limit=4000):
    """
    根据相关性选择最相关的记忆注入上下文
    """
    selected = []
    current_length = 0
    
    # 按相关性排序
    sorted_memories = sorted(retrieved_memories, 
                            key=lambda x: x['relevance_score'], 
                            reverse=True)
    
    for memory in sorted_memories:
        memory_length = len(memory['content'])
        if current_length + memory_length <= context_limit:
            selected.append(memory)
            current_length += memory_length
        else:
            break
    
    return selected

def extract_memory_from_conversation(conversation_history):
    """
    从对话历史中提取重要记忆
    """
    prompt = f"""
    从以下对话中提取重要的事实性信息：
    
    {conversation_history}
    
    请提取：
    1. 用户个人信息
    2. 用户偏好
    3. 重要事件
    4. 关键知识点
    
    以JSON格式返回。
    """
    
    response = llm.invoke(prompt)
    return parse_json(response)

def update_memory_importance(memory, decay_factor=0.95):
    """
    基于时间和访问频率更新记忆重要性
    """
    days_since_creation = (now() - memory.created_at).days
    time_decay = decay_factor ** days_since_creation
    
    access_boost = log1p(memory.access_count) * 0.1
    
    new_importance = memory.base_importance * time_decay + access_boost
    
    memory.importance = min(1.0, max(0.0, new_importance))
    return memory

class MemoryManager:
    def soft_delete(self, memory_id):
        """标记为删除，但保留可恢复"""
        memory = self.get_memory(memory_id)
        memory.status = 'deleted'
        memory.deleted_at = now()
        self.save(memory)
    
    def hard_delete(self, memory_id):
        """永久删除"""
        self.db.delete(memory_id)
    
    def cleanup(self, retention_days=90):
        """清理超过保留期的软删除记忆"""
        cutoff = now() - timedelta(days=retention_days)
        old_deleted = self.db.query(
            "status='deleted' AND deleted_at < %s", cutoff
        )
        for memory in old_deleted:
            self.hard_delete(memory.id)

def resolve_conflict(old_memory, new_memory):
    """
    解决记忆冲突
    """
    # 策略1: 最新优先
    if new_memory.timestamp > old_memory.timestamp:
        return new_memory
    
    # 策略2: 高可信度优先
    if old_memory.confidence > new_memory.confidence:
        return old_memory
    
    # 策略3: 高频访问优先
    if old_memory.access_count > new_memory.access_count * 1.5:
        return old_memory
    
    # 策略4: 人工审核（当无法自动决定时）
    return flag_for_review(old_memory, new_memory)

def summarize_conversation(messages, max_tokens=500):
    """
    将长对话压缩为摘要
    """
    prompt = f"""
    请将以下对话压缩为简洁的摘要，保留关键信息：
    
    {messages}
    
    摘要要求：
    - 不超过{max_tokens} tokens
    - 保留重要事实和决策
    - 去除冗余和寒暄
    """
    
    return llm.invoke(prompt)

def reflect_on_interaction(interaction_log):
    """
    Agent对自身交互进行反思
    """
    prompt = f"""
    回顾以下交互过程：
    
    {interaction_log}
    
    请反思：
    1. 哪些回答是成功的？为什么？
    2. 哪些地方可以改进？
    3. 学到了什么新知识或经验？
    4. 下次遇到类似情况应该如何处理？
    """
    
    reflection = llm.invoke(prompt)
    store_as_procedural_memory(reflection)

def memory_augmented_reasoning(question):
    """
    使用记忆增强的推理
    """
    # 1. 检索相关记忆
    relevant_memories = retrieve_memories(question)
    
    # 2. 构建增强prompt
    augmented_prompt = f"""
    相关背景信息：
    {format_memories(relevant_memories)}
    
    问题：{question}
    
    请基于以上信息进行推理并回答。
    """
    
    # 3. 执行推理
    return llm.invoke(augmented_prompt)

def detect_sensitive_info(text):
    """
    检测文本中的敏感信息
    """
    patterns = {
        'email': r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
        'phone': r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b',
        'ssn': r'\b\d{3}-\d{2}-\d{4}\b',
        'credit_card': r'\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b'
    }
    
    sensitive_items = {}
    for info_type, pattern in patterns.items():
        matches = re.findall(pattern, text)
        if matches:
            sensitive_items[info_type] = matches
    
    return sensitive_items

class MemoryControlPanel:
    def view_memories(self, user_id):
        """查看存储的所有记忆"""
        return self.db.query("SELECT * FROM memories WHERE user_id=%s", user_id)
    
    def delete_memory(self, user_id, memory_id):
        """用户删除指定记忆"""
        self.verify_ownership(user_id, memory_id)
        self.db.delete(memory_id)
    
    def export_memories(self, user_id):
        """导出用户所有记忆数据"""
        memories = self.view_memories(user_id)
        return json.dumps(memories, indent=2)
    
    def set_retention_policy(self, user_id, policy):
        """设置记忆保留策略"""
        self.user_prefs.update(user_id, {'memory_retention': policy})

from functools import lru_cache

class CachedMemoryRetriever:
    def __init__(self, cache_size=1000):
        self.cache = {}
        self.cache_size = cache_size
    
    @lru_cache(maxsize=1000)
    def retrieve(self, query_hash):
        """带缓存的记忆检索"""
        return self.vector_db.search(query_hash)
    
    def invalidate_cache(self, pattern=None):
        """使缓存失效"""
        if pattern:
            keys_to_delete = [k for k in self.cache if pattern in k]
            for key in keys_to_delete:
                del self.cache[key]
        else:
            self.cache.clear()

async def batch_add_memories(memories):
    """批量添加记忆"""
    embeddings = await embed_batch([m.text for m in memories])
    
    async with db_pool.acquire() as conn:
        async with conn.transaction():
            for memory, embedding in zip(memories, embeddings):
                await conn.execute(
                    "INSERT INTO memories VALUES ($1, $2, $3)",
                    memory.id, memory.text, embedding
                )

class MemoryMetrics:
    def __init__(self):
        self.metrics = {
            'storage_size': 0,
            'retrieval_latency': [],
            'hit_rate': 0,
            'memory_age_distribution': {},
            'access_patterns': {}
        }
    
    def track_retrieval(self, latency_ms, is_hit):
        self.metrics['retrieval_latency'].append(latency_ms)
        if is_hit:
            self.metrics['hit_rate'] = calculate_hit_rate()
    
    def get_report(self):
        return {
            'avg_latency': np.mean(self.metrics['retrieval_latency']),
            'p95_latency': np.percentile(self.metrics['retrieval_latency'], 95),
            'hit_rate': self.metrics['hit_rate'],
            'total_memories': self.metrics['storage_size']
        }

class PersonalAssistantAgent:
    def __init__(self):
        self.short_term = ConversationBufferMemory()
        self.long_term = VectorStoreRetrieverMemory()
        self.user_profile = UserProfileStore()
    
    def handle_request(self, user_input):
        # 1. 检索相关长期记忆
        context_memories = self.long_term.search(user_input)
        
        # 2. 获取用户画像
        profile = self.user_profile.get_preferences()
        
        # 3. 构建增强上下文
        enriched_context = self.build_context(
            user_input, 
            context_memories, 
            profile
        )
        
        # 4. 生成响应
        response = self.llm.generate(enriched_context)
        
        # 5. 更新记忆
        self.update_memories(user_input, response)
        
        return response