85_多轮对话：上下文管理与压缩

class DialogueBuffer:
    def __init__(self, core_size=3, max_history=100):
        self.core_buffer = []  # 核心缓冲区
        self.important_buffer = []  # 重要信息缓冲区
        self.summary_buffer = []  # 历史摘要缓冲区
        self.core_size = core_size  # 核心缓冲区大小
        self.max_history = max_history  # 最大历史记录数
        self.full_history = []  # 完整历史（用于生成摘要）
    
    def add_turn(self, user_input, assistant_response, important_entities=None):
        """添加一轮对话到缓冲区"""
        # 更新完整历史
        self.full_history.append({
            "user": user_input,
            "assistant": assistant_response,
            "timestamp": datetime.now().isoformat()
        })
        
        # 限制完整历史大小
        if len(self.full_history) > self.max_history:
            self.full_history.pop(0)
        
        # 更新核心缓冲区
        self.core_buffer.append({
            "user": user_input,
            "assistant": assistant_response
        })
        
        # 当核心缓冲区超过大小限制时，将最旧的对话移动到摘要缓冲区
        if len(self.core_buffer) > self.core_size:
            oldest_turn = self.core_buffer.pop(0)
            # 生成并添加摘要
            summary = self._generate_turn_summary(oldest_turn)
            self.summary_buffer.append(summary)
        
        # 更新重要信息缓冲区
        if important_entities:
            self.important_buffer.extend(important_entities)
            # 去重
            self.important_buffer = list(set(self.important_buffer))
            # 限制重要信息数量
            if len(self.important_buffer) > 20:  # 保留最近20个重要实体
                self.important_buffer = self.important_buffer[-20:]
    
    def _generate_turn_summary(self, turn):
        """生成单轮对话的摘要"""
        # 简单摘要实现，实际应用中可使用LLM生成更精确的摘要
        user_text = turn["user"][:30] + "..." if len(turn["user"]) > 30 else turn["user"]
        assistant_text = turn["assistant"][:30] + "..." if len(turn["assistant"]) > 30 else turn["assistant"]
        return f"用户: {user_text} | 助手: {assistant_text}"
    
    def get_context(self, max_tokens=2000, model="gpt-4"):
        """获取当前对话上下文，考虑token限制"""
        # 初始化上下文
        context = []
        
        # 添加重要信息
        if self.important_buffer:
            important_info = "关键信息: " + ", ".join(self.important_buffer)
            context.append(important_info)
        
        # 添加历史摘要
        if self.summary_buffer:
            summary_text = "历史对话摘要: " + " | ".join(self.summary_buffer)
            context.append(summary_text)
        
        # 添加核心对话
        for turn in self.core_buffer:
            context.append(f"用户: {turn['user']}")
            context.append(f"助手: {turn['assistant']}")
        
        # 合并上下文
        full_context = "\n".join(context)
        
        # 检查token长度（实际应用中应使用对应模型的tokenizer）
        estimated_tokens = len(full_context) / 4  # 粗略估算，1个token约等于4个字符
        if estimated_tokens > max_tokens:
            # 如果超过token限制，进一步压缩摘要
            if self.summary_buffer:
                # 仅保留最近的摘要
                self.summary_buffer = self.summary_buffer[-max(1, len(self.summary_buffer) // 2):]
                return self.get_context(max_tokens, model)  # 递归调用，直到满足token限制
            
        return full_context

import torch
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

class SemanticCompressor:
    def __init__(self, model_name="facebook/bart-large-cnn"):
        # 加载预训练的摘要模型
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
        # 如果有GPU，将模型移至GPU
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.model = self.model.to(self.device)
    
    def compress_dialogue(self, dialogue_history, max_length=150, min_length=30):
        """压缩对话历史，保留核心语义"""
        # 将对话历史格式化为连续文本
        formatted_history = "\n".join([f"用户: {turn['user']}\n助手: {turn['assistant']}" 
                                    for turn in dialogue_history])
        
        # 使用模型生成摘要
        inputs = self.tokenizer([formatted_history], max_length=1024, truncation=True, return_tensors="pt")
        inputs = {k: v.to(self.device) for k, v in inputs.items()}
        
        # 生成压缩摘要
        summary_ids = self.model.generate(
            inputs["input_ids"],
            max_length=max_length,
            min_length=min_length,
            num_beams=4,
            temperature=0.7,
            do_sample=True,
            early_stopping=True
        )
        
        summary = self.tokenizer.decode(summary_ids[0], skip_special_tokens=True)
        return summary

def structure_dialogue(history):
    """将对话历史转换为结构化表示"""
    structured_data = {
        "entities": set(),  # 实体集合
        "intents": set(),  # 意图集合
        "key_questions": [],  # 关键问题
        "key_answers": [],  # 关键回答
        "timeline": []  # 时间线事件
    }
    
    # 提取信息（简化版，实际应使用NLP工具）
    for i, turn in enumerate(history):
        # 简单实体提取（示例）
        if "日期" in turn["user"] or "时间" in turn["user"]:
            structured_data["entities"].add("时间信息")
        
        # 简单意图识别（示例）
        if "如何" in turn["user"] or "方法" in turn["user"]:
            structured_data["intents"].add("请求指导")
            structured_data["key_questions"].append((i, turn["user"]))
        
        # 记录关键回答
        if len(turn["assistant"]) > 100:  # 假设长回答包含重要信息
            structured_data["key_answers"].append((i, turn["assistant"]))
    
    # 将结构化数据转换为压缩文本
    compressed_parts = []
    
    if structured_data["entities"]:
        compressed_parts.append(f"关键实体: {', '.join(structured_data['entities'])}")
    
    if structured_data["intents"]:
        compressed_parts.append(f"用户意图: {', '.join(structured_data['intents'])}")
    
    if structured_data["key_questions"]:
        # 只保留最新的2个关键问题
        recent_questions = [q[1][:50] + "..." if len(q[1]) > 50 else q[1] 
                          for q in sorted(structured_data["key_questions"], key=lambda x: x[0], reverse=True)[:2]]
        compressed_parts.append(f"关键问题: {'; '.join(recent_questions)}")
    
    # 组合压缩结果
    return " | ".join(compressed_parts)

class IncrementalSummarizer:
    def __init__(self, model_name="google/pegasus-xsum"):
        # 加载预训练模型
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.model = self.model.to(self.device)
        self.current_summary = ""
    
    def update_summary(self, new_dialogue_turn, max_summary_length=200):
        """增量更新对话摘要"""
        # 格式化新的对话轮次
        formatted_turn = f"用户: {new_dialogue_turn['user']}\n助手: {new_dialogue_turn['assistant']}"
        
        # 如果没有当前摘要，创建新摘要
        if not self.current_summary:
            # 直接对新对话生成摘要
            inputs = self.tokenizer([formatted_turn], max_length=512, truncation=True, return_tensors="pt")
            inputs = {k: v.to(self.device) for k, v in inputs.items()}
            
            summary_ids = self.model.generate(
                inputs["input_ids"],
                max_length=max_summary_length,
                min_length=30,
                num_beams=4,
                early_stopping=True
            )
            
            self.current_summary = self.tokenizer.decode(summary_ids[0], skip_special_tokens=True)
        else:
            # 结合当前摘要和新对话，生成更新后的摘要
            combined_text = f"当前摘要: {self.current_summary}\n新对话: {formatted_turn}\n请生成更新后的摘要，保留所有重要信息，同时保持简洁。"
            
            inputs = self.tokenizer([combined_text], max_length=1024, truncation=True, return_tensors="pt")
            inputs = {k: v.to(self.device) for k, v in inputs.items()}
            
            summary_ids = self.model.generate(
                inputs["input_ids"],
                max_length=max_summary_length,
                min_length=30,
                num_beams=4,
                early_stopping=True
            )
            
            self.current_summary = self.tokenizer.decode(summary_ids[0], skip_special_tokens=True)
        
        return self.current_summary

def hybrid_summarization_strategy(dialogue_history, user_profile=None):
    """根据对话特点选择最佳总结策略"""
    # 分析对话特点
    dialogue_length = len(dialogue_history)
    avg_turn_length = sum(len(turn["user"]) + len(turn["assistant"]) 
                        for turn in dialogue_history) / dialogue_length if dialogue_length > 0 else 0
    
    # 检测对话类型（简化示例）
    if any("请填写" in turn["user"] or "表格" in turn["user"] for turn in dialogue_history):
        # 结构化/表单对话，使用规则式总结
        return "规则式总结"
    elif avg_turn_length < 50 and dialogue_length > 20:
        # 简短频繁交互，使用检索式总结
        return "检索式总结"
    elif any("解释" in turn["user"] or "详细" in turn["user"] for turn in dialogue_history):
        # 需要详细解释的复杂对话，使用生成式总结
        return "生成式总结"
    elif user_profile and user_profile.get("preference") == "concise":
        # 用户偏好简洁，使用高度压缩的混合策略
        return "简洁混合总结"
    else:
        # 默认使用平衡的混合策略
        return "平衡混合总结"

import numpy as np
from sentence_transformers import SentenceTransformer
import faiss

class VectorContextRetriever:
    def __init__(self, embedding_model="all-MiniLM-L6-v2", dimension=384):
        # 初始化嵌入模型
        self.embedding_model = SentenceTransformer(embedding_model)
        # 初始化向量数据库 (使用FAISS)
        self.index = faiss.IndexFlatL2(dimension)  # 欧式距离索引
        self.dialogue_memory = []  # 存储原始对话历史
    
    def add_dialogue_turn(self, user_input, assistant_response):
        """将对话轮次添加到向量数据库"""
        # 创建对话表示
        dialogue_text = f"用户: {user_input}\n助手: {assistant_response}"
        # 生成嵌入向量
        embedding = self.embedding_model.encode([dialogue_text])[0]
        # 添加到向量数据库
        self.index.add(np.array([embedding], dtype=np.float32))
        # 保存原始对话
        self.dialogue_memory.append({
            "user": user_input,
            "assistant": assistant_response,
            "text": dialogue_text
        })
    
    def retrieve_relevant_context(self, current_query, top_k=3):
        """检索与当前查询最相关的历史对话"""
        # 生成查询嵌入
        query_embedding = self.embedding_model.encode([current_query])[0]
        # 在向量数据库中检索
        distances, indices = self.index.search(np.array([query_embedding], dtype=np.float32), top_k)
        
        # 获取相关对话
        relevant_dialogues = []
        for i in range(top_k):
            if indices[0][i] < len(self.dialogue_memory):  # 确保索引有效
                relevant_dialogues.append({
                    "dialogue": self.dialogue_memory[indices[0][i]],
                    "relevance": 1 - distances[0][i] / np.max(distances[0])  # 归一化相关性分数
                })
        
        # 按相关性排序
        relevant_dialogues.sort(key=lambda x: x["relevance"], reverse=True)
        
        return relevant_dialogues

def analyze_dialogue_complexity(dialogue_history, current_query):
    """分析对话复杂度并返回管理策略建议"""
    # 计算基本复杂度指标
    dialogue_length = len(dialogue_history)
    unique_entities = set()
    technical_terms = 0
    question_density = 0
    
    # 简单分析（实际应用应使用更复杂的NLP技术）
    for turn in dialogue_history + ["user" if isinstance(current_query, str) else current_query["user"]]:
        text = turn if isinstance(turn, str) else (turn["user"] + " " + turn.get("assistant", ""))
        
        # 简单实体计数（示例）
        if ".com" in text or ".org" in text:
            unique_entities.add("网址")
        
        # 简单技术术语检测
        technical_keywords = ["算法", "API", "模型", "参数", "配置", "部署"]
        for keyword in technical_keywords:
            if keyword in text:
                technical_terms += 1
        
        # 问题密度
        question_markers = ["?", "？", "如何", "什么", "为什么", "是否"]
        for marker in question_markers:
            if marker in text:
                question_density += 1
    
    # 计算复杂度分数
    complexity_score = 0
    complexity_score += min(dialogue_length / 20, 1) * 30  # 对话长度因子
    complexity_score += min(len(unique_entities) / 10, 1) * 25  # 实体多样性因子
    complexity_score += min(technical_terms / 20, 1) * 25  # 技术复杂度因子
    complexity_score += min(question_density / 10, 1) * 20  # 信息需求因子
    
    # 根据复杂度分数建议管理策略
    if complexity_score < 30:
        return {"strategy": "轻量管理", "context_ratio": 0.3, "compression_level": "低"}
    elif complexity_score < 60:
        return {"strategy": "标准管理", "context_ratio": 0.5, "compression_level": "中"}
    elif complexity_score < 80:
        return {"strategy": "增强管理", "context_ratio": 0.7, "compression_level": "高"}
    else:
        return {"strategy": "全面管理", "context_ratio": 0.9, "compression_level": "极高"}

class PersonalizedContextManager:
    def __init__(self, base_manager, user_profile_service):
        self.base_manager = base_manager  # 基础上下文管理器
        self.user_profile_service = user_profile_service  # 用户画像服务
        self.user_preferences = {}  # 缓存用户偏好
    
    def get_personalized_context(self, user_id, current_query, dialogue_history):
        """获取个性化的对话上下文"""
        # 获取用户画像
        if user_id not in self.user_preferences:
            self.user_preferences[user_id] = self.user_profile_service.get_user_profile(user_id)
        
        user_profile = self.user_preferences[user_id]
        
        # 根据用户画像调整上下文管理策略
        context_params = {
            "max_context_length": 1000,  # 默认值
            "compression_level": "medium",  # 默认值
            "retrieval_strategy": "balanced"  # 默认值
        }
        
        # 根据用户偏好调整参数
        if user_profile.get("preference") == "concise":
            context_params["compression_level"] = "high"
            context_params["max_context_length"] = 600
        elif user_profile.get("preference") == "detailed":
            context_params["compression_level"] = "low"
            context_params["max_context_length"] = 1500
        
        # 根据用户专业水平调整
        if user_profile.get("expertise_level") == "expert":
            context_params["retrieval_strategy"] = "technical_focus"
        elif user_profile.get("expertise_level") == "beginner":
            context_params["retrieval_strategy"] = "simplified_explanations"
        
        # 根据调整后的参数获取上下文
        context = self.base_manager.get_context(
            dialogue_history=dialogue_history,
            current_query=current_query,
            **context_params
        )
        
        # 添加个性化提示
        if user_profile.get("language_preference"):
            context = f"[使用{user_profile['language_preference']}回复]\n" + context
        
        return context

class MultimodalContextManager:
    def __init__(self):
        # 初始化不同模态的处理器
        self.text_processor = TextProcessor()
        self.image_processor = ImageProcessor()
        self.audio_processor = AudioProcessor()
    
    def add_multimodal_turn(self, user_input, assistant_response):
        """添加多模态对话轮次"""
        processed_turn = {
            "text_content": [],
            "image_content": [],
            "audio_content": []
        }
        
        # 处理用户输入
        if isinstance(user_input, str):
            # 纯文本输入
            processed_turn["text_content"].append(("user", self.text_processor.process(user_input)))
        elif isinstance(user_input, dict):
            # 多模态输入
            if "text" in user_input:
                processed_turn["text_content"].append(("user", self.text_processor.process(user_input["text"])))
            if "image" in user_input:
                processed_turn["image_content"].append(("user", self.image_processor.process(user_input["image"])))
            if "audio" in user_input:
                processed_turn["audio_content"].append(("user", self.audio_processor.process(user_input["audio"])))
        
        # 处理助手回复
        if isinstance(assistant_response, str):
            processed_turn["text_content"].append(("assistant", self.text_processor.process(assistant_response)))
        elif isinstance(assistant_response, dict):
            if "text" in assistant_response:
                processed_turn["text_content"].append(("assistant", self.text_processor.process(assistant_response["text"])))
            if "image" in assistant_response:
                processed_turn["image_content"].append(("assistant", self.image_processor.process(assistant_response["image"])))
            if "audio" in assistant_response:
                processed_turn["audio_content"].append(("assistant", self.audio_processor.process(assistant_response["audio"])))
        
        return processed_turn
    
    def generate_multimodal_context(self, history, max_context_size=3000):
        """生成多模态上下文表示"""
        context = {
            "text_context": [],
            "image_references": [],
            "audio_references": []
        }
        
        # 优先添加最近的多模态内容
        recent_history = reversed(history[-5:])  # 优先考虑最近5轮
        
        estimated_size = 0
        for turn in recent_history:
            # 添加文本内容
            for role, content in turn["text_content"]:
                text_entry = f"{role}: {content}"
                context["text_context"].append(text_entry)
                estimated_size += len(text_entry) * 1.5  # 估算token数
            
            # 添加图像引用（使用描述代替图像本身）
            for role, image_desc in turn["image_content"]:
                image_ref = f"{role}发送了图像: {image_desc}"
                context["image_references"].append(image_ref)
                estimated_size += len(image_ref) * 1.2
            
            # 添加音频引用（使用文本转录）
            for role, audio_transcript in turn["audio_content"]:
                audio_ref = f"{role}发送了语音: {audio_transcript[:100]}..." if len(audio_transcript) > 100 else audio_transcript
                context["audio_references"].append(audio_ref)
                estimated_size += len(audio_ref)
            
            # 如果超过大小限制，停止添加
            if estimated_size > max_context_size:
                break
        
        # 合并上下文
        full_context = []
        if context["text_context"]:
            full_context.append("\n".join(context["text_context"]))
        
        if context["image_references"]:
            full_context.append("\n图像历史: " + " | ".join(context["image_references"][-3:]))  # 只保留最近3个图像引用
        
        if context["audio_references"]:
            full_context.append("\n语音历史: " + " | ".join(context["audio_references"][-2:]))  # 只保留最近2个语音引用
        
        return "\n".join(full_context)

class ContextManagementEvaluator:
    def __init__(self):
        self.metrics = {}
    
    def evaluate_information_relevance(self, original_context, compressed_context, query):
        """评估压缩上下文的信息相关性"""
        # 这里应使用复杂的相关性评估模型
        # 简化示例仅作说明
        relevant_keywords = self._extract_keywords(query)
        original_coverage = sum(1 for keyword in relevant_keywords if keyword in original_context)
        compressed_coverage = sum(1 for keyword in relevant_keywords if keyword in compressed_context)
        
        relevance_score = compressed_coverage / original_coverage if original_coverage > 0 else 0
        self.metrics['information_relevance'] = relevance_score
        return relevance_score
    
    def evaluate_compression_ratio(self, original_context, compressed_context):
        """评估上下文压缩率"""
        original_size = len(original_context)  # 实际应用中应使用token数
        compressed_size = len(compressed_context)
        
        compression_ratio = 1 - (compressed_size / original_size) if original_size > 0 else 0
        self.metrics['compression_ratio'] = compression_ratio
        return compression_ratio
    
    def evaluate_response_quality(self, responses_with_full_context, responses_with_compressed_context):
        """评估使用压缩上下文的回复质量"""
        # 这里应使用人工评估或高级NLP模型
        # 简化示例计算语义相似度
        similarity_scores = []
        for full_resp, compressed_resp in zip(responses_with_full_context, responses_with_compressed_context):
            similarity = self._calculate_semantic_similarity(full_resp, compressed_resp)
            similarity_scores.append(similarity)
        
        avg_quality_score = sum(similarity_scores) / len(similarity_scores) if similarity_scores else 0
        self.metrics['response_quality'] = avg_quality_score
        return avg_quality_score
    
    def evaluate_latency(self, context_management_functions, test_data):
        """评估上下文管理的延迟性能"""
        import time
        latencies = []
        
        for data in test_data:
            start_time = time.time()
            for func in context_management_functions:
                func(data)
            end_time = time.time()
            latencies.append(end_time - start_time)
        
        avg_latency = sum(latencies) / len(latencies) if latencies else 0
        self.metrics['avg_latency'] = avg_latency
        return avg_latency
    
    def _extract_keywords(self, text):
        # 简化的关键词提取
        return [word for word in text.split() if len(word) > 3]
    
    def _calculate_semantic_similarity(self, text1, text2):
        # 简化的语义相似度计算
        words1 = set(text1.split())
        words2 = set(text2.split())
        if not words1 and not words2:
            return 1.0
        return len(words1.intersection(words2)) / len(words1.union(words2))

from sklearn.model_selection import GridSearchCV
from sklearn.metrics import make_scorer

class ContextManagerOptimizer:
    def __init__(self, base_context_manager):
        self.base_manager = base_context_manager
    
    def optimize_parameters(self, training_data, validation_data, parameter_grid):
        """通过网格搜索优化上下文管理器参数"""
        # 定义自定义评分函数
        def custom_score(y_true, y_pred):
            # 评估压缩上下文的综合性能
            relevance_score = self.evaluate_relevance(y_true, y_pred)
            compression_score = self.evaluate_compression(y_true, y_pred)
            # 加权综合评分
            return 0.6 * relevance_score + 0.4 * compression_score
        
        custom_scorer = make_scorer(custom_score, greater_is_better=True)
        
        # 包装上下文管理器为可搜索的估计器
        estimator = ContextManagerEstimator(self.base_manager)
        
        # 执行网格搜索
        grid_search = GridSearchCV(
            estimator=estimator,
            param_grid=parameter_grid,
            scoring=custom_scorer,
            cv=3,
            verbose=2
        )
        
        # 准备训练数据
        X_train = [item['dialogue_history'] for item in training_data]
        y_train = [item['full_context'] for item in training_data]
        
        # 执行优化
        grid_search.fit(X_train, y_train)
        
        # 验证最佳参数
        best_params = grid_search.best_params_
        best_score = grid_search.best_score_
        
        # 在验证集上测试
        X_val = [item['dialogue_history'] for item in validation_data]
        y_val = [item['full_context'] for item in validation_data]
        val_score = grid_search.score(X_val, y_val)
        
        return {
            'best_params': best_params,
            'best_score': best_score,
            'validation_score': val_score
        }
    
    def evaluate_relevance(self, true_context, predicted_context):
        # 简化的相关性评估
        return sum(1 for word in true_context.split() if word in predicted_context.split()) / len(true_context.split())
    
    def evaluate_compression(self, true_context, predicted_context):
        # 计算压缩率
        return 1 - (len(predicted_context) / len(true_context))

class ContextManagerEstimator:
    def __init__(self, base_manager):
        self.base_manager = base_manager
        self.params = {}
    
    def fit(self, X, y):
        # 这里实际上不训练，只是存储参数
        return self
    
    def predict(self, X):
        # 使用当前参数处理对话历史
        results = []
        for dialogue_history in X:
            # 应用参数并生成上下文
            context = self.base_manager.get_context(
                dialogue_history=dialogue_history,
                **self.params
            )
            results.append(context)
        return results
    
    def set_params(self, **params):
        self.params = params
        return self
    
    def get_params(self, deep=True):
        return self.params

class ContextManagerMonitor:
    def __init__(self):
        self.metrics_history = []
        self.alerts = []
        self.thresholds = {
            'response_time': 1.0,  # 秒
            'compression_ratio': 0.3,  # 压缩率至少30%
            'information_relevance': 0.8,  # 信息保留率至少80%
            'error_rate': 0.05  # 错误率不超过5%
        }
    
    def record_metrics(self, metrics, timestamp=None):
        """记录当前性能指标"""
        if timestamp is None:
            timestamp = datetime.now().isoformat()
        
        record = {
            'timestamp': timestamp,
            'metrics': metrics
        }
        self.metrics_history.append(record)
        
        # 检查是否触发警报
        self._check_thresholds(metrics)
        
        # 保留最近的记录
        if len(self.metrics_history) > 1000:
            self.metrics_history.pop(0)
    
    def _check_thresholds(self, metrics):
        """检查指标是否超过阈值"""
        for metric_name, threshold in self.thresholds.items():
            if metric_name in metrics:
                if metric_name == 'error_rate':
                    if metrics[metric_name] > threshold:
                        self.alerts.append({
                            'timestamp': datetime.now().isoformat(),
                            'level': 'critical',
                            'message': f'错误率 ({metrics[metric_name]:.2%}) 超过阈值 ({threshold:.2%})'
                        })
                else:
                    if metrics[metric_name] < threshold:
                        severity = 'warning' if metric_name != 'response_time' else 'critical'
                        self.alerts.append({
                            'timestamp': datetime.now().isoformat(),
                            'level': severity,
                            'message': f'{metric_name} ({metrics[metric_name]:.2f}) 低于阈值 ({threshold:.2f})'
                        })
    
    def get_performance_report(self, time_window='hour'):
        """生成性能报告"""
        now = datetime.now()
        if time_window == 'hour':
            cutoff_time = now - timedelta(hours=1)
        elif time_window == 'day':
            cutoff_time = now - timedelta(days=1)
        elif time_window == 'week':
            cutoff_time = now - timedelta(weeks=1)
        else:
            cutoff_time = now - timedelta(hours=1)
        
        # 筛选时间范围内的记录
        recent_records = [r for r in self.metrics_history 
                         if datetime.fromisoformat(r['timestamp']) >= cutoff_time]
        
        if not recent_records:
            return {'error': '没有足够的历史数据'}
        
        # 计算平均指标
        avg_metrics = {}
        metric_names = set()
        for record in recent_records:
            metric_names.update(record['metrics'].keys())
        
        for metric_name in metric_names:
            values = [r['metrics'].get(metric_name, 0) for r in recent_records if metric_name in r['metrics']]
            avg_metrics[metric_name] = sum(values) / len(values)
        
        # 获取最近的警报
        recent_alerts = [a for a in self.alerts 
                        if datetime.fromisoformat(a['timestamp']) >= cutoff_time]
        
        return {
            'time_window': time_window,
            'record_count': len(recent_records),
            'average_metrics': avg_metrics,
            'recent_alerts': recent_alerts,
            'recommendations': self._generate_recommendations(avg_metrics)
        }
    
    def _generate_recommendations(self, avg_metrics):
        """基于平均指标生成优化建议"""
        recommendations = []
        
        if 'response_time' in avg_metrics and avg_metrics['response_time'] > self.thresholds['response_time']:
            recommendations.append("响应时间过长，建议增加缓存大小或优化压缩算法")
        
        if 'compression_ratio' in avg_metrics and avg_metrics['compression_ratio'] < self.thresholds['compression_ratio']:
            recommendations.append("压缩率过低，建议增加压缩强度或使用更先进的压缩算法")
        
        if 'information_relevance' in avg_metrics and avg_metrics['information_relevance'] < self.thresholds['information_relevance']:
            recommendations.append("信息保留率过低，建议调整过滤阈值或改进检索算法")
        
        return recommendations

class EnterpriseCustomerServiceSystem:
    def __init__(self):
        # 初始化核心组件
        self.context_manager = AdvancedContextManager()
        self.llm_client = LLMClient(model="gpt-4-turbo")
        self.knowledge_base = KnowledgeBase()
        self.user_profile_manager = UserProfileManager()
        
        # 初始化监控系统
        self.monitor = ContextManagerMonitor()
    
    async def handle_conversation(self, user_id, session_id, user_input):
        """处理用户对话请求"""
        start_time = time.time()
        
        # 获取用户画像
        user_profile = self.user_profile_manager.get_profile(user_id)
        
        # 获取会话历史
        dialogue_history = self.get_session_history(session_id)
        
        # 智能分类用户问题
        question_category = self.classify_question(user_input)
        
        # 根据用户画像和问题类型调整上下文管理策略
        strategy = self.select_context_strategy(user_profile, question_category)
        
        # 生成优化后的上下文
        optimized_context = self.context_manager.generate_context(
            dialogue_history=dialogue_history,
            user_input=user_input,
            strategy=strategy
        )
        
        # 检索相关知识库信息
        relevant_knowledge = self.knowledge_base.retrieve(
            query=user_input,
            context=optimized_context,
            top_k=3
        )
        
        # 构建完整提示
        prompt = self.build_prompt(optimized_context, user_input, relevant_knowledge)
        
        # 获取LLM响应
        response = await self.llm_client.generate(
            prompt=prompt,
            temperature=0.3,  # 客服场景下使用较低的随机性
            max_tokens=500
        )
        
        # 更新会话历史
        self.update_session_history(session_id, {
            "user": user_input,
            "assistant": response,
            "timestamp": datetime.now().isoformat(),
            "question_category": question_category
        })
        
        # 计算性能指标
        metrics = {
            "response_time": time.time() - start_time,
            "context_size": len(prompt),
            "knowledge_retrieval_count": len(relevant_knowledge),
            "session_length": len(dialogue_history) + 1
        }
        
        # 记录指标
        self.monitor.record_metrics(metrics)
        
        return response
    
    def select_context_strategy(self, user_profile, question_category):
        """根据用户和问题类型选择上下文策略"""
        # 技术问题需要更详细的历史上下文
        if question_category in ["technical_support", "product_specs"]:
            return {
                "compression_level": "low",
                "retrieval_strategy": "technical_focus",
                "max_history_turns": 10
            }
        # 账单和账户问题需要更简洁但准确的上下文
        elif question_category in ["billing", "account_management"]:
            return {
                "compression_level": "high",
                "retrieval_strategy": "factual_accuracy",
                "max_history_turns": 5
            }
        # 新用户给予更友好的上下文处理
        elif user_profile.get("account_age_days", 0) < 30:
            return {
                "compression_level": "medium",
                "retrieval_strategy": "beginner_friendly",
                "max_history_turns": 8,
                "include_welcome_prompts": True
            }
        # 高级用户使用更高效的上下文策略
        else:
            return {
                "compression_level": "medium",
                "retrieval_strategy": "balanced",
                "max_history_turns": 8
            }

class EducationalTutoringSystem:
    def __init__(self):
        self.student_profile_db = StudentProfileDatabase()
        self.learning_path_manager = LearningPathManager()
        self.context_manager = EducationContextManager()
        self.llm_engine = LLMWithEducationFocus()
        self.progress_tracker = ProgressTracker()
    
    def generate_personalized_response(self, student_id, current_query, session_history):
        """生成个性化教育回复"""
        # 获取学生档案
        student_profile = self.student_profile_db.get_profile(student_id)
        
        # 分析学生当前学习水平和进度
        learning_level = student_profile.get("current_level", "beginner")
        learning_progress = self.progress_tracker.get_progress(student_id)
        
        # 获取相关学习内容
        relevant_content = self.learning_path_manager.get_relevant_content(
            query=current_query,
            level=learning_level,
            progress=learning_progress
        )
        
        # 生成教育特定的上下文
        educational_context = self.context_manager.generate_educational_context(
            session_history=session_history,
            student_profile=student_profile,
            current_query=current_query,
            relevant_content=relevant_content
        )
        
        # 根据学生水平调整回复复杂度
        complexity_level = self._determine_complexity_level(learning_level, learning_progress)
        
        # 生成个性化辅导回复
        response = self.llm_engine.generate_tutoring_response(
            context=educational_context,
            query=current_query,
            complexity_level=complexity_level,
            learning_style=student_profile.get("learning_style", "visual"),
            knowledge_gaps=student_profile.get("knowledge_gaps", [])
        )
        
        # 更新学生档案和进度
        self._update_student_profile(student_id, current_query, response)
        
        return response
    
    def _determine_complexity_level(self, learning_level, progress):
        """确定合适的内容复杂度"""
        # 简化示例
        if learning_level == "beginner":
            return "basic"
        elif learning_level == "intermediate":
            if progress.get("overall_mastery", 0) > 0.7:
                return "advanced_intermediate"
            else:
                return "standard_intermediate"
        else:  # advanced
            return "advanced"
    
    def _update_student_profile(self, student_id, query, response):
        """根据交互更新学生档案"""
        # 分析查询和回复中的新概念和技能
        new_concepts = self._extract_concepts(query, response)
        
        # 更新学生的概念掌握情况
        self.student_profile_db.update_concept_mastery(student_id, new_concepts)
        
        # 识别可能的知识缺口
        knowledge_gaps = self._identify_knowledge_gaps(query, response)
        if knowledge_gaps:
            self.student_profile_db.update_knowledge_gaps(student_id, knowledge_gaps)

class MedicalConsultationSystem:
    def __init__(self):
        self.patient_record_manager = SecurePatientRecordManager()
        self.medical_knowledge_base = EvidenceBasedMedicineKB()
        self.context_manager = HIPAACompliantContextManager()
        self.llm_medical = MedicalSpecializedLLM()
        self.consent_manager = PatientConsentManager()
    
    async def handle_medical_consultation(self, patient_id, doctor_id, query, session_history):
        """处理医疗咨询请求"""
        # 验证医生权限和患者同意
        if not await self._validate_access(patient_id, doctor_id):
            return {"error": "权限验证失败"}
        
        # 获取患者记录（经过脱敏处理）
        patient_record = await self.patient_record_manager.get_secure_record(
            patient_id=patient_id,
            authorized_party=doctor_id,
            purpose="consultation"
        )
        
        # 生成符合医疗标准的上下文
        medical_context = self.context_manager.generate_medical_context(
            session_history=session_history,
            patient_record=patient_record,
            current_query=query,
            privacy_level="high"
        )
        
        # 检索相关医学知识
        relevant_medical_info = await self.medical_knowledge_base.retrieve_evidence(
            query=query,
            patient_context=medical_context,
            include_guidelines=True,
            include_recent_research=True
        )
        
        # 生成符合医疗伦理的回复
        response = await self.llm_medical.generate_medical_response(
            context=medical_context,
            query=query,
            relevant_evidence=relevant_medical_info,
            risk_level=self._assess_query_risk(query),
            require_citation=True
        )
        
        # 记录咨询会话（符合医疗记录要求）
        await self._log_consultation(
            patient_id=patient_id,
            doctor_id=doctor_id,
            query=query,
            response=response,
            session_id=self._generate_session_id()
        )
        
        return response
    
    async def _validate_access(self, patient_id, doctor_id):
        """验证访问权限"""
        # 检查患者是否同意该医生访问其记录
        consent_status = await self.consent_manager.check_consent(patient_id, doctor_id)
        
        # 检查医生资质
        doctor_credentials = await self._verify_doctor_credentials(doctor_id)
        
        return consent_status and doctor_credentials
    
    def _assess_query_risk(self, query):
        """评估查询的风险级别"""
        # 简化的风险评估
        high_risk_keywords = ["紧急", "严重", "胸痛", "呼吸困难", "高烧", "意识不清"]
        
        for keyword in high_risk_keywords:
            if keyword in query:
                return "high"
        
        return "standard"