# 上下文构建示例代码
def build_context(retrieved_docs, query, max_tokens=4000):
    """
    构建优化的上下文
    """
    # 1. 重排序
    reranked_docs = rerank_model.sort(query, retrieved_docs)
    
    # 2. 去重
    unique_docs = remove_duplicates(reranked_docs)
    
    # 3. 构建结构化上下文
    context = {
        "核心信息": extract_key_points(unique_docs[:3]),
        "支撑细节": extract_details(unique_docs[3:6]),
        "相关背景": extract_background(unique_docs[6:])
    }
    
    # 4. 压缩到窗口限制内
    compressed = compress_to_limit(context, max_tokens)
    
    # 5. 格式化为prompt
    prompt = f"""
    基于以下信息回答用户问题：
    
    【核心信息】
    {compressed['核心信息']}
    
    【支撑细节】
    {compressed['支撑细节']}
    
    【相关背景】
    {compressed['相关背景']}
    
    用户问题：{query}
    
    请基于上述信息，准确、完整地回答用户问题。
    """
    
    return prompt

第一步：识别问题的关键点是什么
第二步：从提供的信息中找出相关内容
第三步：分析这些信息之间的关系
第四步：综合得出结论
第五步：检查答案的逻辑性和完整性

def semantic_chunking(text, max_tokens=512, overlap=50):
    """
    基于语义的智能分块
    """
    # 1. 句子分割
    sentences = sent_tokenize(text)
    
    # 2. 计算句子embedding
    embeddings = model.encode(sentences)
    
    # 3. 基于相似度聚类
    chunks = []
    current_chunk = []
    current_tokens = 0
    
    for i, sent in enumerate(sentences):
        sent_tokens = len(tokenizer.encode(sent))
        
        # 检查语义相似度
        if i > 0:
            similarity = cosine_similarity(
                embeddings[i-1], embeddings[i]
            )
            
            # 低相似度表示主题转换
            if similarity < 0.7 or current_tokens + sent_tokens > max_tokens:
                chunks.append(' '.join(current_chunk))
                current_chunk = [sentences[max(0, i-2):i]]  # 重叠
                current_tokens = sum(len(tokenizer.encode(s)) for s in current_chunk)
        
        current_chunk.append(sent)
        current_tokens += sent_tokens
    
    if current_chunk:
        chunks.append(' '.join(current_chunk))
    
    return chunks

class RAGExperiment:
    """
    RAG系统A/B测试框架
    """
    def __init__(self):
        self.control_config = {
            "embedding_model": "ada-002",
            "chunk_size": 512,
            "top_k": 5
        }
        self.treatment_config = {
            "embedding_model": "bge-large",
            "chunk_size": 768,
            "top_k": 8
        }
    
    def run_experiment(self, queries, duration_days=7):
        results = {
            "control": [],
            "treatment": []
        }
        
        for query in queries:
            # 随机分配到实验组
            group = random.choice(["control", "treatment"])
            config = self.control_config if group == "control" else self.treatment_config
            
            # 执行查询
            response = self.execute_rag(query, config)
            
            # 收集指标
            metrics = {
                "latency": response.latency,
                "relevance": self.evaluate_relevance(response),
                "user_rating": self.collect_user_feedback(response)
            }
            
            results[group].append(metrics)
        
        # 统计分析
        return self.analyze_results(results)

# 不同融合策略的效果对比
fusion_strategies = {
    "简单加权": {
        "方法": "score = 0.5 * bm25_score + 0.5 * vector_score",
        "MRR": 0.72,
        "Recall@10": 0.68,
        "优点": "简单直观",
        "缺点": "权重固定"
    },
    "RRF (Reciprocal Rank Fusion)": {
        "方法": "score = Σ(1/(k+rank_i))",
        "MRR": 0.78,
        "Recall@10": 0.74,
        "优点": "无需调参",
        "缺点": "忽略原始分数"
    },
    "学习排序 (LambdaMART)": {
        "方法": "机器学习模型预测相关性",
        "MRR": 0.85,
        "Recall@10": 0.82,
        "优点": "效果最好",
        "缺点": "需要训练数据"
    },
    "自适应融合": {
        "方法": "根据查询类型动态调整权重",
        "MRR": 0.83,
        "Recall@10": 0.80,
        "优点": "灵活适应",
        "缺点": "实现复杂"
    }
}

class QueryRewriter:
    """
    多策略查询改写器
    """
    
    def rewrite(self, query, context=None):
        rewrites = []
        
        # 1. 同义词扩展
        synonyms = self.expand_synonyms(query)
        rewrites.extend(synonyms)
        
        # 2. 缩写展开
        expanded = self.expand_abbreviations(query)
        rewrites.append(expanded)
        
        # 3. 错别字纠正
        corrected = self.spell_correct(query)
        if corrected != query:
            rewrites.append(corrected)
        
        # 4. 意图明确化
        clarified = self.clarify_intent(query, context)
        rewrites.append(clarified)
        
        # 5. 实体识别与标准化
        standardized = self.standardize_entities(query)
        rewrites.append(standardized)
        
        # 6. 基于LLM的改写
        llm_rewrites = self.llm_rewrite(query, num_rewrites=3)
        rewrites.extend(llm_rewrites)
        
        # 去重和评分
        unique_rewrites = list(set(rewrites))
        scored_rewrites = self.score_rewrites(query, unique_rewrites)
        
        return scored_rewrites[:5]  # 返回Top-5改写
    
    def llm_rewrite(self, query, num_rewrites=3):
        """
        使用LLM生成查询改写
        """
        prompt = f"""
        请将以下查询改写成{num_rewrites}个不同的版本，保持语义不变：
        
        原始查询：{query}
        
        要求：
        1. 使用不同的表达方式
        2. 补充可能的隐含信息
        3. 使用更专业的术语
        
        改写版本：
        """
        
        response = llm.generate(prompt)
        return parse_rewrites(response)

class VersionedDocument:
    def __init__(self, doc_id):
        self.doc_id = doc_id
        self.versions = []
        self.current_version = None
    
    def update(self, content, metadata):
        new_version = {
            "version": len(self.versions) + 1,
            "content": content,
            "metadata": metadata,
            "timestamp": datetime.now(),
            "hash": calculate_hash(content)
        }
        
        # 检测是否真的有变化
        if self.current_version and \
           new_version["hash"] == self.current_version["hash"]:
            return False  # 内容未变化
        
        self.versions.append(new_version)
        self.current_version = new_version
        return True
    
    def rollback(self, version_num):
        if version_num <= len(self.versions):
            self.current_version = self.versions[version_num - 1]
            return True
        return False