_010001SUTANG_

"""
精简版Reranker系统：在CAMEL框架下集成模拟的外部Reranker模型

该脚本旨在清晰地展示如何将一个独立的Reranker模块（通过模拟外部API或本地部署模型）
集成到RAG应用中，以实现文档重排。
"""

import os
import re
import requests
from typing import List, Dict, Any

# 导入CAMEL框架核心模块
from camel.models import ModelFactory
from camel.types import ModelPlatformType
from camel.agents import ChatAgent
from camel.embeddings import SentenceTransformerEncoder
from camel.retrievers import VectorRetriever
from camel.storages.vectordb_storages import QdrantStorage

# 导入环境变量模块
from dotenv import load_dotenv

class MinimalRerankerSystem:
    """
    精简版Reranker系统类
    包含知识库设置、模拟的外部Reranker和答案生成的核心功能
    """

    def __init__(self, api_key: str):
        """
        初始化精简版Reranker系统

        Args:
            api_key: ModelScope API密钥
        """
        self.api_key = api_key

        # 初始化嵌入模型 (用于向量检索，Reranker本身不直接使用)
        self.embedding_model = SentenceTransformerEncoder(
            model_name='intfloat/e5-large-v2'
        )

        # 初始化向量存储 (用于演示文档检索，以便Reranker有文档可重排)
        self.vector_storage = QdrantStorage(
            vector_dim=self.embedding_model.get_output_dim(),
            collection="minimal_reranker_collection",
            path="storage_minimal_reranker",
            collection_name="精简重排知识库"
        )

        # 初始化向量检索器
        self.vector_retriever = VectorRetriever(
            embedding_model=self.embedding_model,
            storage=self.vector_storage
        )

        # 初始化LLM模型 (仅用于答案生成)
        self.model = ModelFactory.create(
            model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
            model_type="Qwen/Qwen2.5-72B-Instruct",
            url='https://api-inference.modelscope.cn/v1/',
            api_key=self.api_key
        )

        # 初始化RAG答案生成代理
        self._init_agents()
        self.knowledge_base_ready = False

    def _init_agents(self):
        """初始化RAG答案生成代理"""
        
        # RAG回答生成代理
        rag_sys_msg = """
        你是一个帮助回答问题的助手。
        我会给你原始查询和检索到的上下文信息。
        请根据检索到的上下文回答原始查询。
        如果上下文信息不足以回答问题，请说"根据提供的信息，我无法完全回答这个问题"。
        请确保回答准确、完整且有条理。
        """
        self.rag_agent = ChatAgent(
            system_message=rag_sys_msg,
            model=self.model
        )
    
    def setup_knowledge_base(self, pdf_url: str = None, pdf_path: str = None):
        """
        设置知识库，用于提供待重排的文档
        
        Args:
            pdf_url: PDF文件的URL
            pdf_path: 本地PDF文件路径
        """
        os.makedirs('local_data', exist_ok=True)

        if pdf_url:
            print("正在下载PDF文件...")
            try:
                response = requests.get(pdf_url, timeout=30)
                response.raise_for_status()
                pdf_path = 'local_data/knowledge_base.pdf'
                with open(pdf_path, 'wb') as file:
                    file.write(response.content)
                print(f"✓ PDF文件已下载到: {pdf_path}")
            except Exception as e:
                print(f"PDF下载失败: {e}")
                raise

        if pdf_path:
            if not os.path.exists(pdf_path):
                raise FileNotFoundError(f"PDF文件不存在: {pdf_path}")
            
            print("正在处理PDF文件并建立向量数据库...")
            try:
                self.vector_retriever.process(content=pdf_path)
                self.knowledge_base_ready = True
                print("知识库设置完成！")
            except Exception as e:
                print(f"知识库设置失败: {e}")
                raise
        else:
            raise ValueError("必须提供 pdf_url 或 pdf_path 参数")

    def retrieve_documents(self, query: str, top_k: int = 5) -> List[Dict[str, Any]]:
        """
        从知识库中检索初步文档

        Args:
            query: 用户查询
            top_k: 返回的文档数量

        Returns:
            初步检索到的文档列表
        """
        if not self.knowledge_base_ready:
            print("知识库未准备好，无法检索文档。")
            return []

        print(f"正在初步检索文档 (Top-{top_k})...")
        retrieved_docs = self.vector_retriever.query(query=query, top_k=top_k)
        print(f"✓ 初步检索到 {len(retrieved_docs)} 个文档。")
        return retrieved_docs

    def perform_external_rerank(self, query: str, documents: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """
        模拟外部Reranker模型对文档进行重排。
        此函数模拟了调用外部API或本地部署的Reranker模型。
        这里使用简单的关键词匹配作为模拟的重排逻辑。

        Args:
            query: 用户查询
            documents: 待重排的文档列表，每个文档字典包含 'text' 键

        Returns:
            根据模拟的外部Reranker重排后的文档列表，每个文档会添加 'relevance_score' 字段。
        """
        if not documents:
            print("没有文档可供重排，跳过外部Reranker。")
            return []

        print("正在使用模拟的外部Reranker进行文档重排...")

        # 将查询分割成关键词（这里简单地按空格分割，实际Reranker会进行更复杂的处理）
        query_keywords = set(query.lower().split())

        scored_documents = []
        for doc in documents:
            doc_text_lower = doc['text'].lower()
            # 模拟计算相关性分数：文档中包含的查询关键词越多，分数越高
            relevance_score = sum(1 for keyword in query_keywords if keyword in doc_text_lower)
            
            # 也可以添加一些随机性来模拟真实模型的复杂性
            # import random
            # relevance_score += random.uniform(0, 0.1) 

            # 将分数添加到文档字典中
            doc_with_score = doc.copy()
            doc_with_score['relevance_score'] = relevance_score
            scored_documents.append(doc_with_score)

        # 根据相关性分数降序排序
        reranked_documents = sorted(scored_documents, key=lambda x: x.get('relevance_score', 0), reverse=True)

        print(f"✓ 模拟外部Reranker重排完成。")
        return reranked_documents

    def generate_answer(self, query: str, retrieved_docs: List[Dict[str, Any]]) -> str:
        """
        基于检索到的文档生成答案
        
        Args:
            query: 用户查询
            retrieved_docs: 检索到的文档列表
            
        Returns:
            生成的答案
        """
        if not retrieved_docs:
            return "根据提供的信息，我无法完全回答这个问题。"

        # 构建上下文
        context = "\n\n".join([doc['text'] for doc in retrieved_docs])
        
        # 构建提示
        prompt = f"""
        原始查询: {query}
        
        检索到的上下文信息:
        {context}
        
        请根据上述上下文信息回答原始查询。
        """
        
        print("\n正在生成答案...")
        response = self.rag_agent.step(prompt)
        answer = response.msgs[0].content.strip()
        print("✓ 答案生成完成。")
        
        return answer

    def run_reranker_pipeline(self, query: str, top_k_initial: int = 5) -> Dict[str, Any]:
        """
        运行重排器管道：初步检索 -> 外部Reranker重排 -> 答案生成

        Args:
            query: 用户查询
            top_k_initial: 初步检索的文档数量

        Returns:
            包含初步文档、重排文档和最终答案的字典
        """
        print("\n" + "=" * 60)
        print(f"开始运行Reranker管道，查询: {query}")
        print("=" * 60)

        # 步骤1: 初步检索文档
        initial_retrieved_docs = self.retrieve_documents(query, top_k_initial)

        # 步骤2: 外部Reranker重排文档
        reranked_docs = self.perform_external_rerank(query, initial_retrieved_docs)

        # 步骤3: 基于重排后的文档生成答案
        final_answer = self.generate_answer(query, reranked_docs)

        print("\n" + "=" * 60)
        print("Reranker管道执行完成！")
        print("=" * 60)

        return {
            "query": query,
            "initial_retrieved_docs": initial_retrieved_docs,
            "reranked_docs": reranked_docs,
            "final_answer": final_answer
        }

def main():
    """主函数：演示精简版Reranker系统的使用"""
    
    # 加载环境变量
    load_dotenv()
    api_key = os.getenv('MODELSCOPE_SDK_TOKEN')
    
    if not api_key:
        print("错误：请设置MODELSCOPE_SDK_TOKEN环境变量")
        print("请在.env文件中添加 MODELSCOPE_SDK_TOKEN=你的API密钥")
        return
    
    # 初始化Reranker系统
    print("正在初始化Reranker系统...")
    reranker_system = MinimalRerankerSystem(api_key)
    print("系统初始化完成！")

    # 设置知识库 (使用CAMEL论文作为示例)
    pdf_url = "https://arxiv.org/pdf/2303.17760.pdf"
    print(f"\n正在设置知识库（使用默认CAMEL论文: {pdf_url}）...")
    try:
        reranker_system.setup_knowledge_base(pdf_url=pdf_url)
    except Exception as e:
        print(f"知识库设置失败: {e}")
        return

    # 运行交互式会话
    while True:
        query = input("\n请输入您的查询（输入'quit'退出）: ").strip()
        
        if query.lower() in ['quit', 'exit', '退出']:
            print("感谢使用！再见！")
            break
        
        if not query:
            print("查询不能为空，请重新输入。")
            continue

        try:
            results = reranker_system.run_reranker_pipeline(query, top_k_initial=5)

            print("\n--- 原始检索结果 (Top 5) ---")
            if results['initial_retrieved_docs']:
                for i, doc in enumerate(results['initial_retrieved_docs']):
                    print(f"文档 {i+1}: {doc['text'][:150]}...")
            else:
                print("无原始检索文档。")

            print("\n--- 外部Reranker重排后的结果 ---")
            if results['reranked_docs']:
                for i, doc in enumerate(results['reranked_docs']):
                    # 显示模拟的相关性分数
                    score_info = f" (相关性分数: {doc.get('relevance_score', 'N/A'):.2f})"
                    print(f"文档 {i+1}{score_info}: {doc['text'][:150]}...")
            else:
                print("无重排文档。")

            print("\n--- 最终答案 ---")
            print(results['final_answer'])

        except Exception as e:
            print(f"\n发生错误: {e}")
            import traceback
            traceback.print_exc() # 打印详细错误信息
            continue_choice = input("是否继续？(y/n): ").strip().lower()
            if continue_choice != 'y':
                break

if __name__ == "__main__":
    main()

"""
LLM ReRanker：在CAMEL框架下实现基于大语言模型的文档重排

该脚本旨在清晰地展示如何使用CAMEL框架和简单的提示词工程实现文档重排。
"""

import os
import re
import requests
from typing import List, Dict, Any

# 导入CAMEL框架核心模块
from camel.models import ModelFactory
from camel.types import ModelPlatformType
from camel.agents import ChatAgent
from camel.embeddings import SentenceTransformerEncoder
from camel.retrievers import VectorRetriever
from camel.storages.vectordb_storages import QdrantStorage

# 导入环境变量模块
from dotenv import load_dotenv

class MinimalLLMReranker:
    """
    LLM ReRanker系统类
    仅包含知识库设置、LLM ReRanker和答案生成的核心功能
    """

    def __init__(self, api_key: str):
        """
        初始化LLM ReRanker系统

        Args:
            api_key: ModelScope API密钥
        """
        self.api_key = api_key

        # 初始化嵌入模型 (用于向量检索，ReRanker本身不直接使用)
        self.embedding_model = SentenceTransformerEncoder(
            model_name='intfloat/e5-large-v2'
        )

        # 初始化向量存储 (用于演示文档检索，以便ReRanker有文档可重排)
        self.vector_storage = QdrantStorage(
            vector_dim=self.embedding_model.get_output_dim(),
            collection="minimal_reranker_collection",
            path="storage_minimal_reranker",
            collection_name="精简重排知识库"
        )

        # 初始化向量检索器
        self.vector_retriever = VectorRetriever(
            embedding_model=self.embedding_model,
            storage=self.vector_storage
        )

        # 初始化LLM模型 (用于ReRanker和答案生成)
        self.model = ModelFactory.create(
            model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
            model_type="Qwen/Qwen2.5-72B-Instruct",
            url='https://api-inference.modelscope.cn/v1/',
            api_key=self.api_key
        )

        # 初始化LLM ReRanker代理和RAG答案生成代理
        self._init_agents()
        self.knowledge_base_ready = False

    def _init_agents(self):
        """初始化LLM ReRanker代理和RAG答案生成代理"""
        
        # LLM ReRanker 代理
        # 提示词工程：明确要求输出格式为逗号分隔的数字序列，不含额外文字
        reranker_sys_msg = """
        你是一个文档重排助手。你的任务是根据用户查询，对提供的文档列表进行相关性排序。
        你会接收一个用户查询和多个文档，每个文档都有一个编号。
        请你根据文档与查询的深层相关性，从最相关到最不相关，输出文档的编号序列。
        输出格式必须是逗号分隔的数字，例如：1, 3, 2, 4。
        不要包含任何其他文字或解释。
        """
        self.reranker_agent = ChatAgent(
            system_message=reranker_sys_msg,
            model=self.model
        )
        
        # RAG回答生成代理
        rag_sys_msg = """
        你是一个帮助回答问题的助手。
        我会给你原始查询和检索到的上下文信息。
        请根据检索到的上下文回答原始查询。
        如果上下文信息不足以回答问题，请说"根据提供的信息，我无法完全回答这个问题"。
        请确保回答准确、完整且有条理。
        """
        self.rag_agent = ChatAgent(
            system_message=rag_sys_msg,
            model=self.model
        )
    
    def setup_knowledge_base(self, pdf_url: str = None, pdf_path: str = None):
        """
        设置知识库，用于提供待重排的文档
        
        Args:
            pdf_url: PDF文件的URL
            pdf_path: 本地PDF文件路径
        """
        os.makedirs('local_data', exist_ok=True)

        if pdf_url:
            print("正在下载PDF文件...")
            try:
                response = requests.get(pdf_url, timeout=30)
                response.raise_for_status()
                pdf_path = 'local_data/knowledge_base.pdf'
                with open(pdf_path, 'wb') as file:
                    file.write(response.content)
                print(f"✓ PDF文件已下载到: {pdf_path}")
            except Exception as e:
                print(f"PDF下载失败: {e}")
                raise

        if pdf_path:
            if not os.path.exists(pdf_path):
                raise FileNotFoundError(f"PDF文件不存在: {pdf_path}")
            
            print("正在处理PDF文件并建立向量数据库...")
            try:
                self.vector_retriever.process(content=pdf_path)
                self.knowledge_base_ready = True
                print("知识库设置完成！")
            except Exception as e:
                print(f"知识库设置失败: {e}")
                raise
        else:
            raise ValueError("必须提供 pdf_url 或 pdf_path 参数")

    def retrieve_documents(self, query: str, top_k: int = 5) -> List[Dict[str, Any]]:
        """
        从知识库中检索初步文档

        Args:
            query: 用户查询
            top_k: 返回的文档数量

        Returns:
            初步检索到的文档列表
        """
        if not self.knowledge_base_ready:
            print("知识库未准备好，无法检索文档。")
            return []

        print(f"正在初步检索文档 (Top-{top_k})...")
        retrieved_docs = self.vector_retriever.query(query=query, top_k=top_k)
        print(f"✓ 初步检索到 {len(retrieved_docs)} 个文档。")
        return retrieved_docs

    def rerank_documents(self, query: str, documents: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """
        使用LLM对文档进行重排

        Args:
            query: 用户查询
            documents: 待重排的文档列表，每个文档字典包含 'text' 键

        Returns:
            根据LLM重排后的文档列表
        """
        if not documents:
            print("没有文档可供重排，跳过LLM重排。")
            return []

        print("正在使用LLM进行文档重排...")

        # 构建发送给LLM的提示
        prompt_parts = [f"用户查询: {query}\n\n以下是需要重排的文档列表："]
        for i, doc in enumerate(documents):
            # 限制文档内容长度，避免超出LLM上下文窗口
            truncated_text = doc['text'][:500] + "..." if len(doc['text']) > 500 else doc['text']
            prompt_parts.append(f"文档 {i+1}:\n{truncated_text}\n")

        prompt_parts.append("\n请根据文档与查询的相关性，从最相关到最不相关，输出文档的编号序列。输出格式必须是逗号分隔的数字，例如：1, 3, 2, 4。不要包含任何其他文字或解释。")
        rerank_prompt = "\n".join(prompt_parts)

        try:
            response = self.reranker_agent.step(rerank_prompt)
            reranked_order_str = response.msgs[0].content.strip()

            # 解析LLM的输出，获取排序后的文档索引
            # 使用正则表达式匹配数字和逗号，确保只提取数字序列
            match = re.search(r'^\s*(\d+(?:\s*,\s*\d+)*)\s*$', reranked_order_str)
            if match:
                ordered_indices = [int(idx.strip()) - 1 for idx in match.group(1).split(',')]
                
                # 过滤掉无效的索引（超出文档列表范围的）
                valid_ordered_indices = [idx for idx in ordered_indices if 0 <= idx < len(documents)]

                # 根据LLM返回的顺序重排文档
                reranked_documents = [documents[i] for i in valid_ordered_indices]

                # 如果LLM返回的文档数量少于原始文档数量，将未被LLM排序的文档按原顺序追加到末尾
                original_indices = set(range(len(documents)))
                llm_sorted_indices = set(valid_ordered_indices)
                remaining_indices = sorted(list(original_indices - llm_sorted_indices))
                
                for idx in remaining_indices:
                    reranked_documents.append(documents[idx])

                print(f"✓ LLM重排完成。新顺序: {[idx + 1 for idx in valid_ordered_indices]}")
                return reranked_documents
            else:
                print(f"LLM重排输出格式不正确，无法解析。原始输出: '{reranked_order_str}'。将返回原始文档顺序。")
                return documents # 返回原始文档顺序
        except Exception as e:
            print(f"LLM重排失败: {e}。将返回原始文档顺序。")
            return documents # 发生错误时返回原始文档顺序

    def generate_answer(self, query: str, retrieved_docs: List[Dict[str, Any]]) -> str:
        """
        基于检索到的文档生成答案
        
        Args:
            query: 用户查询
            retrieved_docs: 检索到的文档列表
            
        Returns:
            生成的答案
        """
        if not retrieved_docs:
            return "根据提供的信息，我无法完全回答这个问题。"

        # 构建上下文
        context = "\n\n".join([doc['text'] for doc in retrieved_docs])
        
        # 构建提示
        prompt = f"""
        原始查询: {query}
        
        检索到的上下文信息:
        {context}
        
        请根据上述上下文信息回答原始查询。
        """
        
        print("\n正在生成答案...")
        response = self.rag_agent.step(prompt)
        answer = response.msgs[0].content.strip()
        print("✓ 答案生成完成。")
        
        return answer

    def run_reranker_pipeline(self, query: str, top_k_initial: int = 5) -> Dict[str, Any]:
        """
        运行重排器管道：初步检索 -> LLM重排 -> 答案生成

        Args:
            query: 用户查询
            top_k_initial: 初步检索的文档数量

        Returns:
            包含初步文档、重排文档和最终答案的字典
        """
        print("\n" + "=" * 60)
        print(f"开始运行LLM重排管道，查询: {query}")
        print("=" * 60)

        # 步骤1: 初步检索文档
        initial_retrieved_docs = self.retrieve_documents(query, top_k_initial)

        # 步骤2: LLM重排文档
        reranked_docs = self.rerank_documents(query, initial_retrieved_docs)

        # 步骤3: 基于重排后的文档生成答案
        final_answer = self.generate_answer(query, reranked_docs)

        print("\n" + "=" * 60)
        print("LLM重排管道执行完成！")
        print("=" * 60)

        return {
            "query": query,
            "initial_retrieved_docs": initial_retrieved_docs,
            "reranked_docs": reranked_docs,
            "final_answer": final_answer
        }

def main():
    """主函数：演示精简版LLM ReRanker系统的使用"""
    
    # 加载环境变量
    load_dotenv()
    api_key = os.getenv('MODELSCOPE_SDK_TOKEN')
    
    if not api_key:
        print("错误：请设置MODELSCOPE_SDK_TOKEN环境变量")
        print("请在.env文件中添加 MODELSCOPE_SDK_TOKEN=你的API密钥")
        return
    
    # 初始化LLM ReRanker系统
    print("正在初始化LLM ReRanker系统...")
    reranker_system = MinimalLLMReranker(api_key)
    print("系统初始化完成！")

    # 设置知识库 (使用CAMEL论文作为示例)
    pdf_url = "https://arxiv.org/pdf/2303.17760.pdf"
    print(f"\n正在设置知识库（使用默认CAMEL论文: {pdf_url}）...")
    try:
        reranker_system.setup_knowledge_base(pdf_url=pdf_url)
    except Exception as e:
        print(f"知识库设置失败: {e}")
        return

    # 运行交互式会话
    while True:
        query = input("\n请输入您的查询（输入'quit'退出）: ").strip()
        
        if query.lower() in ['quit', 'exit', '退出']:
            print("感谢使用！再见！")
            break
        
        if not query:
            print("查询不能为空，请重新输入。")
            continue

        try:
            results = reranker_system.run_reranker_pipeline(query, top_k_initial=5)

            print("\n--- 原始检索结果 (Top 5) ---")
            if results['initial_retrieved_docs']:
                for i, doc in enumerate(results['initial_retrieved_docs']):
                    print(f"文档 {i+1}: {doc['text'][:150]}...")
            else:
                print("无原始检索文档。")

            print("\n--- LLM重排后的结果 ---")
            if results['reranked_docs']:
                for i, doc in enumerate(results['reranked_docs']):
                    # 尝试获取RRF分数或相似度，如果存在的话
                    score_info = f" (RRF分数: {doc['rrf_score']:.4f})" if 'rrf_score' in doc else ""
                    score_info = f" (相似度: {doc['similarity']:.4f})" if 'similarity' in doc else score_info
                    print(f"文档 {i+1}{score_info}: {doc['text'][:150]}...")
            else:
                print("无重排文档。")

            print("\n--- 最终答案 ---")
            print(results['final_answer'])

        except Exception as e:
            print(f"\n发生错误: {e}")
            import traceback
            traceback.print_exc() # 打印详细错误信息
            continue_choice = input("是否继续？(y/n): ").strip().lower()
            if continue_choice != 'y':
                break

if __name__ == "__main__":
    main()

# 启动增强版研究系统
python RAG_WEB_TOPIC_Enhanced.py

# 在代码中调整检索参数
results = rag_system.enhanced_query(
    original_query=query,
    use_rewriting=True,      # 启用查询重写
    use_hyde=True,           # 启用HyDE增强
    use_rrf=True,            # 启用RRF融合
    top_k=5,                 # 返回文档数量
    multimodal_preference=['text', 'image', 'table']  # 多模态偏好
)

"""
交互式多模态RAG系统
支持PDF上传、多种检索模式和网页爬取功能
"""

import os
import sys
import json
import requests
import io
import numpy as np
from typing import List, Dict, Any, Optional
from dotenv import load_dotenv
from sklearn.metrics.pairwise import cosine_similarity

# 在文件顶部添加CAMEL相关导入
from camel.models import ModelFactory
from camel.types import ModelPlatformType

# PDF处理
try:
    from pypdf import PdfReader
except ImportError:
    print("缺少pypdf库，请运行: pip install pypdf")
    sys.exit(1)

try:
    from unstructured.partition.auto import partition
    from unstructured.documents.elements import Text, Image, Table
except ImportError:
    print("缺少unstructured库，请运行: pip install unstructured")
    sys.exit(1)

# 嵌入模型
try:
    from sentence_transformers import SentenceTransformer
    EMBEDDING_AVAILABLE = True
except ImportError:
    print("缺少sentence-transformers库")
    EMBEDDING_AVAILABLE = False

# 导入网页研究系统
try:
    from RAG_WEB_TOPIC_Enhanced import EnhancedInteractiveResearchSystem
    WEB_RESEARCH_AVAILABLE = True
    print("Web research system available")
except ImportError:
    print("Web research system not available")
    WEB_RESEARCH_AVAILABLE = False

class SimpleLLMInterface:
    """LLM接口 - 使用CAMEL ModelFactory"""
    
    def __init__(self, api_key: str, model_name: str = "Qwen/Qwen2.5-72B-Instruct", use_camel: bool = True):
        if not api_key:
            raise ValueError("API key is required")
        
        self.api_key = api_key
        self.model_name = model_name
        self.use_camel = use_camel
        self.model = None
        
        if use_camel:
            try:
                # 使用CAMEL ModelFactory初始化模型
                self.model = ModelFactory.create(
                    model_platform=ModelPlatformType.OPENAI_COMPATIBLE_MODEL,
                    model_type=model_name,
                    url='https://api-inference.modelscope.cn/v1/',
                    api_key=api_key
                )
                print(f"CAMEL LLM initialized: {model_name}")
                print(f"API key: {api_key[:10]}...{api_key[-4:]}")
            except Exception as e:
                print(f"CAMEL initialization failed, using fallback: {e}")
                self.model = None
        else:
            print(f"Direct API LLM initialized: {model_name}")
            print(f"API key: {api_key[:10]}...{api_key[-4:]}")

    def generate(self, prompt: str, max_tokens: int = 500) -> str:
        """生成文本回答 - 使用CAMEL模型或直接API调用"""
        # 如果CAMEL模型可用，尝试使用
        if self.model is not None:
            try:
                print(f"Generating response with CAMEL model...")
                # 使用CAMEL模型生成回答
                from camel.messages import BaseMessage
                
                # 创建用户消息
                user_message = BaseMessage.make_user_message(
                    role_name="user",
                    content=prompt
                )
                
                # 调用模型生成回答
                response = self.model.run([user_message])
                
                # 修复：正确处理CAMEL模型的响应
                if response:
                    # 如果响应是BaseMessage对象
                    if hasattr(response, 'content'):
                        return response.content
                    # 如果响应是列表，取第一个元素
                    elif isinstance(response, list) and len(response) > 0:
                        first_response = response[0]
                        if hasattr(first_response, 'content'):
                            return first_response.content
                        else:
                            return str(first_response)
                    # 如果响应是字符串
                    elif isinstance(response, str):
                        return response
                    # 其他情况转换为字符串
                    else:
                        return str(response)
                else:
                    raise Exception("No response generated from CAMEL model")
                    
            except Exception as e:
                print(f"CAMEL generation failed, using fallback: {str(e)[:100]}...")
                # 降级到直接API调用
                return self._fallback_generate(prompt, max_tokens)
        else:
            # 直接使用API调用
            print(f"Generating response with direct API call...")
            return self._fallback_generate(prompt, max_tokens)

    def _fallback_generate(self, prompt: str, max_tokens: int = 500) -> str:
        """降级方案：直接API调用 - 增加重试机制和超时处理"""
        max_retries = 3
        timeout_seconds = 60  # 增加超时时间
        
        for attempt in range(max_retries):
            try:
                import requests
                
                headers = {
                    "Authorization": f"Bearer {self.api_key}",
                    "Content-Type": "application/json"
                }
                
                data = {
                    "model": self.model_name,
                    "messages": [{"role": "user", "content": prompt}],
                    "max_tokens": max_tokens,
                    "temperature": 0.7
                }
                
                print(f"API调用 {attempt + 1}/{max_retries}...")
                
                response = requests.post(
                    "https://api-inference.modelscope.cn/v1/chat/completions",
                    headers=headers,
                    json=data,
                    timeout=timeout_seconds
                )
                
                if response.status_code == 200:
                    result = response.json()
                    if 'choices' in result and len(result['choices']) > 0:
                        content = result['choices'][0]['message']['content']
                        print(f"√ API调用成功")
                        return content
                    else:
                        raise Exception(f"API响应格式错误: {result}")
                else:
                    raise Exception(f"API调用失败 (状态码: {response.status_code}): {response.text}")
                    
            except requests.exceptions.Timeout:
                print(f"API调用超时 (尝试 {attempt + 1}/{max_retries})")
                if attempt == max_retries - 1:
                    return f"抱歉，由于网络超时，无法生成回答。请稍后重试。"
                continue
                
            except requests.exceptions.ConnectionError:
                print(f"网络连接错误 (尝试 {attempt + 1}/{max_retries})")
                if attempt == max_retries - 1:
                    return f"抱歉，网络连接失败，无法生成回答。请检查网络连接。"
                continue
                
            except Exception as e:
                print(f"API调用失败 (尝试 {attempt + 1}/{max_retries}): {str(e)[:100]}...")
                if attempt == max_retries - 1:
                    return f"生成答案时出现错误: {str(e)}"
                continue
        
        return "抱歉，多次尝试后仍无法生成回答，请稍后重试。"

class SimpleEmbeddingModel:
    """简化的嵌入模型"""
    
    def __init__(self, model_name: str = 'intfloat/e5-large-v2'):
        if not EMBEDDING_AVAILABLE:
            raise ImportError("sentence-transformers not available")
        
        try:
            self.model = SentenceTransformer(model_name)
            print(f"√ Embedding model loaded: {model_name}")
        except Exception as e:
            print(f"Failed to load embedding model: {e}")
            raise

    def encode(self, texts: List[str]) -> np.ndarray:
        """文本编码"""
        try:
            return self.model.encode(texts, convert_to_numpy=True)
        except Exception as e:
            print(f"Encoding failed: {e}")
            return np.array([])

class SimpleVectorRetriever:
    """简化的向量检索器"""
    
    def __init__(self, embedding_model: SimpleEmbeddingModel):
        self.embedding_model = embedding_model
        self.documents = []
        self.doc_metadata = []
        self.document_ids = []
        self.doc_embeddings = None
        print("√ Simple vector retriever initialized")
    
    def add_documents(self, texts: List[str], metadata: List[Dict[str, Any]]):
        """添加文档"""
        if not texts:
            return
        
        try:
            # 生成文档ID
            new_ids = [f"doc_{len(self.documents) + i}" for i in range(len(texts))]
            
            # 存储文档
            self.documents.extend(texts)
            self.doc_metadata.extend(metadata)
            self.document_ids.extend(new_ids)
            
            # 计算嵌入
            print(f"Computing embeddings for {len(texts)} documents...")
            new_embeddings = self.embedding_model.encode(texts)
            
            if self.doc_embeddings is None:
                self.doc_embeddings = new_embeddings
            else:
                self.doc_embeddings = np.vstack([self.doc_embeddings, new_embeddings])
            
            print(f"Added {len(texts)} documents to retriever")
            
        except Exception as e:
            print(f"Error adding documents: {e}")
            raise
    
    def query(self, query_text: str, top_k: int = 5, filter_type: Optional[str] = None) -> List[Dict[str, Any]]:
        """检索相关文档"""
        if not self.documents or self.doc_embeddings is None:
            print("No documents in retriever")
            return []
        
        try:
            # 计算查询嵌入
            query_embedding = self.embedding_model.encode([query_text])
            
            # 计算相似度
            similarities = cosine_similarity(query_embedding, self.doc_embeddings)[0]
            
            # 获取top_k结果
            top_indices = np.argsort(similarities)[::-1][:top_k * 2]
            
            results = []
            for idx in top_indices:
                if idx >= len(self.documents):
                    continue
                    
                doc_type = self.doc_metadata[idx].get('type', 'unknown')
                if filter_type and doc_type != filter_type:
                    continue
                
                results.append({
                    'text': self.documents[idx],
                    'similarity': float(similarities[idx]),
                    'metadata': self.doc_metadata[idx],
                    'id': self.document_ids[idx]
                })
                
                if len(results) >= top_k:
                    break
            
            print(f"Retrieved {len(results)} documents")
            return results
            
        except Exception as e:
            print(f"Query failed: {e}")
            return []

class SimpleRAGSystem:
    """简化的RAG系统 - 集成CAMEL ModelFactory"""
    
    def __init__(self, api_key: str, model_name: str = "Qwen/Qwen2.5-72B-Instruct", use_camel: bool = True):
        if not api_key:
            raise ValueError("错误：API key required")
        
        try:
            if use_camel:
                print("Initializing Simple RAG System with CAMEL...")
            else:
                print("Initializing Simple RAG System with direct API...")
            
            # 使用LLM接口（CAMEL或直接API）
            self.llm = SimpleLLMInterface(api_key=api_key, model_name=model_name, use_camel=use_camel)
            # 保持原有的嵌入模型和检索器
            self.embedding_model = SimpleEmbeddingModel()
            self.vector_retriever = SimpleVectorRetriever(self.embedding_model)
            
            self.knowledge_base_initialized = False
            self.multimodal_content_store = {}
            
            print("√ Simple RAG System initialized successfully!")
            
        except Exception as e:
            print(f"错误：Initialization failed: {e}")
            raise

    def setup_knowledge_base(self, pdf_url: Optional[str] = None, pdf_path: Optional[str] = None):
        """设置知识库"""
        try:
            if pdf_url:
                print(f"↓ Loading PDF from URL: {pdf_url}")
                response = requests.get(pdf_url, timeout=30)
                response.raise_for_status()
                pdf_bytes = response.content
                print(f"√ PDF downloaded ({len(pdf_bytes)} bytes)")
                pdf_file = io.BytesIO(pdf_bytes)
                elements = partition(file=pdf_file)
            elif pdf_path:
                print(f"Loading PDF from: {pdf_path}")
                if not os.path.exists(pdf_path):
                    raise FileNotFoundError(f"错误：PDF not found: {pdf_path}")
                elements = partition(filename=pdf_path)
                print(f"√ PDF loaded successfully")
            else:
                raise ValueError("错误：Either pdf_url or pdf_path required")
                
        except Exception as e:
            print(f"错误：PDF loading error: {e}")
            raise

        # 处理文档元素
        texts_to_embed = []
        metadata_to_embed = []
        multimodal_id_counter = 0

        for element in elements:
            element_text = str(element).strip()
            if not element_text or len(element_text) < 10:
                continue
            
            multimodal_id = f"multimodal_{multimodal_id_counter}"
            multimodal_id_counter += 1
            
            if isinstance(element, Text):
                texts_to_embed.append(element_text)
                metadata_to_embed.append({
                    'type': 'text',
                    'source': 'pdf',
                    'multimodal_id': multimodal_id
                })
            elif isinstance(element, Image):
                # 图像处理
                image_description = f"图像内容: {element_text}"
                texts_to_embed.append(image_description)
                metadata_to_embed.append({
                    'type': 'image',
                    'source': 'pdf',
                    'multimodal_id': multimodal_id
                })
                self.multimodal_content_store[multimodal_id] = {
                    'type': 'image',
                    'data': element_text
                }
            elif isinstance(element, Table):
                # 表格处理
                table_description = f"表格内容: {element_text}"
                texts_to_embed.append(table_description)
                metadata_to_embed.append({
                    'type': 'table',
                    'source': 'pdf',
                    'multimodal_id': multimodal_id
                })
                self.multimodal_content_store[multimodal_id] = {
                    'type': 'table',
                    'data': element_text
                }
            else:
                # 其他类型作为文本处理
                texts_to_embed.append(element_text)
                metadata_to_embed.append({
                    'type': 'text',
                    'source': 'pdf',
                    'multimodal_id': multimodal_id
                })

        if texts_to_embed:
            self.vector_retriever.add_documents(texts_to_embed, metadata_to_embed)
            self.knowledge_base_initialized = True
            
            text_count = sum(1 for meta in metadata_to_embed if meta.get('type') == 'text')
            image_count = sum(1 for meta in metadata_to_embed if meta.get('type') == 'image')
            table_count = sum(1 for meta in metadata_to_embed if meta.get('type') == 'table')
            
            print(f"√ Knowledge base setup complete: {len(texts_to_embed)} elements")
            print(f" Content: {text_count} text, {image_count} images, {table_count} tables")
        else:
            raise ValueError("No content extracted from PDF")

    def get_available_retrieval_methods(self) -> List[str]:
        """获取可用的检索方法"""
        return ["Vector", "Enhanced"]

    def _query_rewriting(self, original_query: str) -> str:
        """查询重写 - 使用CAMEL模型"""
        try:
            prompt = f"""请重写以下查询，使其更适合文档检索和信息提取：

原始查询：{original_query}

重写要求：
1. 保持查询的核心意图
2. 使用更具体和明确的词汇
3. 适合向量检索和语义匹配
4. 只返回重写后的查询，不要其他解释

重写后的查询："""
            
            rewritten_query = self.llm.generate(prompt, max_tokens=100)
            
            # 清理返回结果，只保留重写的查询
            if rewritten_query and not rewritten_query.startswith("抱歉") and not rewritten_query.startswith("生成答案时出现错误"):
                # 提取实际的重写查询
                lines = rewritten_query.strip().split('\n')
                for line in lines:
                    line = line.strip()
                    if line and not line.startswith('重写后的查询') and not line.startswith('原始查询'):
                        rewritten_query = line
                        break
                
                print(f"Query rewritten: {original_query} -> {rewritten_query[:50]}...")
                return rewritten_query.strip()
            else:
                print(f"警告：Query rewriting failed, using original query")
                return original_query
                
        except Exception as e:
            print(f"警告：Query rewriting failed: {e}")
            return original_query

    def _hyde_generation(self, query: str) -> str:
        """HyDE假设文档生成 - 使用CAMEL模型"""
        try:
            prompt = f"""基于以下查询，生成一个假设性的文档片段，该片段可能包含查询的答案：

查询：{query}

要求：
1. 生成一个200-300字的文档片段
2. 内容应该直接回答查询问题
3. 使用专业和准确的语言
4. 包含相关的技术细节和概念

假设文档："""
            
            hyde_doc = self.llm.generate(prompt, max_tokens=300)
            
            if hyde_doc and not hyde_doc.startswith("抱歉") and not hyde_doc.startswith("生成答案时出现错误"):
                print(f"📝 HyDE document generated: {len(hyde_doc)} characters")
                return hyde_doc.strip()
            else:
                print(f"警告：HyDE generation failed, using original query")
                return query
                
        except Exception as e:
            print(f"警告：HyDE generation failed: {e}")
            return query

    def _rrf_fusion(self, all_results: List[List[Dict]], k: int = 60) -> List[Dict[str, Any]]:
        """RRF融合多个检索结果"""
        try:
            doc_scores = {}
            
            for results in all_results:
                for rank, doc in enumerate(results):
                    doc_id = doc.get('id', '')
                    if doc_id:
                        rrf_score = 1.0 / (k + rank + 1)
                        if doc_id in doc_scores:
                            doc_scores[doc_id]['score'] += rrf_score
                        else:
                            doc_scores[doc_id] = {
                                'doc': doc,
                                'score': rrf_score
                            }
            
            # 按分数排序
            sorted_docs = sorted(doc_scores.values(), key=lambda x: x['score'], reverse=True)
            
            # 为文档添加RRF分数
            final_docs = []
            for item in sorted_docs:
                doc = item['doc'].copy()
                doc['rrf_score'] = item['score']
                final_docs.append(doc)
            
            return final_docs
            
        except Exception as e:
            print(f"警告：RRF fusion failed: {e}")
            return all_results[0] if all_results else []

    def enhanced_query(self, original_query: str, use_rewriting: bool = True, use_hyde: bool = True,
                      use_rrf: bool = True, top_k: int = 5, rrf_k: int = 60,
                      multimodal_preference: Optional[List[str]] = None) -> Dict[str, Any]:
        """执行增强型RAG查询"""
        if not self.knowledge_base_initialized:
            raise RuntimeError("Knowledge base not initialized")

        # 根据参数确定检索类型
        if use_rewriting and use_hyde and use_rrf:
            print("\n执行深度检索...")
            print("="*60)
            print("开始执行深度RAG查询")
            print("="*60)
        else:
            print("\n执行检索...")
            print("="*40)

        query_for_retrieval = original_query
        rewritten_query = None
        hyde_doc = None
        retrieval_method = "Vector"
        all_retrieved_results = []

        # 步骤1: 查询重写
        if use_rewriting:
            print("\n步骤1: 查询重写")
            print("-" * 30)
            print(f"原始查询: {original_query}")
            rewritten_query = self._query_rewriting(original_query)
            query_for_retrieval = rewritten_query
            print(f"重写查询: {rewritten_query}")
            retrieval_method += "+Rewriting"

        # 步骤2: 文档检索
        print("\n步骤2: 文档检索")
        print("-" * 30)
        if use_hyde and use_rrf:
            print("使用HyDE+RRF组合方法进行检索...")
            print("使用RRF算法进行混合检索（HyDE增强向量检索）...")
        else:
            print("使用基础向量检索...")

        # HyDE生成
        if use_hyde:
            print("执行HyDE增强向量检索...")
            hyde_doc = self._hyde_generation(query_for_retrieval)
            print("生成的假设文档:")
            print(hyde_doc)
            retrieval_method += "+HyDE"

        # 多模态检索
        text_results = self.vector_retriever.query(query_for_retrieval, top_k=top_k, filter_type='text')
        all_retrieved_results.append(text_results)
        print(f"✓ HyDE向量检索完成，获得 {len(text_results)} 个结果")

        if multimodal_preference:
            if 'image' in multimodal_preference:
                image_results = self.vector_retriever.query(query_for_retrieval, top_k=top_k, filter_type='image')
                all_retrieved_results.append(image_results)
                print(f"✓ 图像检索完成，获得 {len(image_results)} 个结果")
                retrieval_method += "+Image"
            if 'table' in multimodal_preference:
                table_results = self.vector_retriever.query(query_for_retrieval, top_k=top_k, filter_type='table')
                all_retrieved_results.append(table_results)
                print(f"✓ 表格检索完成，获得 {len(table_results)} 个结果")
                retrieval_method += "+Table"

        if hyde_doc:
            print("执行BM25检索（使用原始查询）...")
            hyde_results = self.vector_retriever.query(hyde_doc, top_k=top_k)
            all_retrieved_results.append(hyde_results)
            print(f"✓ BM25检索成功，获得 {len(hyde_results)} 个结果")

        # RRF融合
        if use_rrf and len(all_retrieved_results) > 1:
            print("使用RRF算法融合检索结果...")
            final_retrieved_docs = self._rrf_fusion(all_retrieved_results, k=rrf_k)
            retrieval_method += "+RRF"
            
            # 统计唯一文档数量
            unique_doc_ids = set()
            for res_list in all_retrieved_results:
                for doc in res_list:
                    unique_doc_ids.add(doc.get('id', ''))
            print(f"RRF融合完成，共处理 {len(unique_doc_ids)} 个唯一文档，返回前 {top_k} 个结果")
            print(f"HyDE+RRF检索完成，返回 {len(final_retrieved_docs)} 个文档")
        else:
            unique_docs = {}
            for res_list in all_retrieved_results:
                for doc in res_list:
                    if doc.get('id') not in unique_docs:
                        unique_docs[doc.get('id')] = doc
            final_retrieved_docs = list(unique_docs.values())
            print(f"文档合并完成，返回 {len(final_retrieved_docs)} 个文档")

        # 限制最终文档数量
        final_retrieved_docs = final_retrieved_docs[:top_k]

        # 显示检索到的文档预览
        for i, doc in enumerate(final_retrieved_docs, 1):
            similarity = doc.get('similarity', 0)
            rrf_score = getattr(doc, 'rrf_score', similarity)  # 如果有RRF分数则使用，否则使用相似度
            text_preview = doc.get('text', '')[:200] + "..." if len(doc.get('text', '')) > 200 else doc.get('text', '')
            print(f"文档 {i} (RRF分数: {rrf_score:.4f}):")
            print(f"{text_preview}")
            print()

        # 步骤3: 答案生成
        print("步骤3: 答案生成")
        print("-" * 30)
        print()

        # 构建上下文
        context_texts = []
        for doc in final_retrieved_docs:
            context_texts.append(doc['text'])

        # 生成最终答案
        separator = '\n---\n'
        context_str = separator.join(context_texts)
        
        prompt_for_llm = f"""你是一个专业的文档分析助手。请基于以下PDF文档内容回答用户问题。

文档内容：
{context_str}

用户问题：{original_query}

回答要求：
1. 仔细阅读并理解文档内容
2. 基于文档内容提供准确、详细的答案
3. 如果文档中没有相关信息，请明确说明
4. 使用清晰的结构组织答案
5. 引用具体的文档内容支持你的回答

请提供详细的答案："""
        
        print("正在生成最终答案...")
        final_answer = self.llm.generate(prompt_for_llm, max_tokens=800)
        
        if final_answer and not final_answer.startswith("抱歉") and not final_answer.startswith("生成答案时出现错误"):
            print("√ 答案生成成功")
            print("最终答案:")
            print(final_answer)
        else:
            print("警告：答案生成失败，提供基于检索文档的简化回答")
            # 提供基于检索文档的简化回答
            simple_answer = f"基于检索到的文档内容，关于'{original_query}'的相关信息如下：\n\n"
            for i, doc in enumerate(final_retrieved_docs[:3], 1):
                simple_answer += f"{i}. {doc['text'][:200]}...\n\n"
            final_answer = simple_answer
            print("最终答案:")
            print(final_answer)

        return {
            'original_query': original_query,
            'rewritten_query': rewritten_query,
            'hyde_doc': hyde_doc,
            'retrieved_docs': final_retrieved_docs,
            'final_answer': final_answer,
            'retrieval_method': retrieval_method
        }

class InteractiveMultimodalRAG:
    """交互式多模态RAG系统 - 集成CAMEL ModelFactory"""
    
    def __init__(self):
        self.api_key = None
        self.rag_system = None
        self.web_research_system = None
        self.knowledge_base_loaded = False
        self.current_pdf_source = None
        
    def initialize_system(self):
        """初始化系统 - 使用CAMEL ModelFactory"""
        print("初始化交互式多模态RAG系统...")
        
        # 加载环境变量
        load_dotenv()
        
        # 获取API密钥
        self.api_key = os.getenv('MODELSCOPE_SDK_TOKEN')
        if not self.api_key:
            print("错误：错误：请设置MODELSCOPE_SDK_TOKEN环境变量")
            print("提示：在.env文件中添加 MODELSCOPE_SDK_TOKEN=your_api_key")
            return False
        
        try:
            # 使用集成CAMEL的简化RAG系统
            self.rag_system = SimpleRAGSystem(api_key=self.api_key, model_name="Qwen/Qwen2.5-72B-Instruct")
            print("√ 集成CAMEL的RAG系统初始化成功")
            
            # 初始化网页研究系统
            if WEB_RESEARCH_AVAILABLE:
                try:
                    self.web_research_system = EnhancedInteractiveResearchSystem()
                    print("√ 网页研究系统初始化成功")
                except Exception as e:
                    print(f"！警告： 网页研究系统初始化失败: {e}")
                    self.web_research_system = None
            
            return True
            
        except Exception as e:
            print(f"！错误：系统初始化失败: {e}")
            return False
    
    def load_pdf_knowledge_base(self):
        """加载PDF知识库"""
        print("\nPDF知识库设置")
        print("="*50)
        print("1. 在线PDF (输入URL)")
        print("2. 本地PDF (输入文件路径)")
        print("3. 使用默认示例PDF")
        
        choice = input("\n请选择PDF来源 (1-3): ").strip()
        
        try:
            if choice == "1":
                pdf_url = input("请输入PDF的URL: ").strip()
                if not pdf_url:
                    print("错误：URL不能为空")
                    return False
                
                print(f"↓ 正在加载在线PDF: {pdf_url}")
                self.rag_system.setup_knowledge_base(pdf_url=pdf_url)
                self.current_pdf_source = f"在线PDF: {pdf_url}"
                
            elif choice == "2":
                pdf_path = input("请输入PDF文件路径: ").strip()
                if not pdf_path:
                    print("错误：文件路径不能为空")
                    return False
                
                if not os.path.exists(pdf_path):
                    print(f"错误：文件不存在: {pdf_path}")
                    return False
                
                print(f"状态查询： 正在加载本地PDF: {pdf_path}")
                self.rag_system.setup_knowledge_base(pdf_path=pdf_path)
                self.current_pdf_source = f"本地PDF: {pdf_path}"
                
            elif choice == "3":
                pdf_url = "https://arxiv.org/pdf/2303.17760.pdf"
                print(f"↓ 正在加载默认示例PDF: {pdf_url}")
                self.rag_system.setup_knowledge_base(pdf_url=pdf_url)
                self.current_pdf_source = f"示例PDF: CAMEL论文"
                
            else:
                print("错误：无效选择")
                return False
            
            self.knowledge_base_loaded = True
            print("√ PDF知识库加载成功！")
            return True
            
        except Exception as e:
            print(f"错误：PDF加载失败: {e}")
            return False
    
    def execute_query(self, query: str, retrieval_mode: str) -> Dict[str, Any]:
        """执行查询"""
        if not self.knowledge_base_loaded:
            return {"error": "知识库未加载，请先加载PDF"}
        
        print(f"\n执行查询: {query}")
        print(f"检索模式: {retrieval_mode}")
        
        try:
            if retrieval_mode == "快速检索":
                # 基础向量检索 - 直接检索生成答案
                return self.quick_retrieval(query)
                
            elif retrieval_mode == "深度检索":
                # 完整增强检索
                results = self.rag_system.enhanced_query(
                    original_query=query,
                    use_rewriting=True,
                    use_hyde=True,
                    use_rrf=True,
                    top_k=5,
                    multimodal_preference=['text', 'image', 'table']
                )
                
            elif retrieval_mode == "主题检索":
                # 网页爬取检索 - 使用真实的网页研究系统
                return self.topic_retrieval(query)
                
            else:
                return {"error": f"未知检索模式: {retrieval_mode}"}
            
            return results
            
        except Exception as e:
            return {"error": f"查询执行失败: {e}"}
    
    def quick_retrieval(self, query: str) -> Dict[str, Any]:
        """快速检索 - 基础向量检索直接生成答案"""
        print("\n执行快速检索...")
        print("="*40)
        
        try:
            # 直接进行向量检索
            print("正在进行向量检索...")
            retrieved_docs = self.rag_system.vector_retriever.query(query, top_k=3, filter_type='text')
            
            if not retrieved_docs:
                return {"error": "未找到相关文档"}
            
            print(f"√ 检索到 {len(retrieved_docs)} 个相关文档")
            
            # 显示检索到的文档
            for i, doc in enumerate(retrieved_docs, 1):
                similarity = doc.get('similarity', 0)
                text_preview = doc.get('text', '')[:150] + "..." if len(doc.get('text', '')) > 150 else doc.get('text', '')
                print(f"文档 {i} (相似度: {similarity:.3f}):")
                print(f"   {text_preview}")
                print()
            
            # 构建简单的上下文
            context_texts = [doc['text'] for doc in retrieved_docs]
            context_str = '\n---\n'.join(context_texts)
            
            # 生成答案
            print("正在生成答案...")
            prompt = f"""基于以下文档内容回答问题：

文档内容：
{context_str}

问题：{query}

请提供简洁明确的答案："""
            
            final_answer = self.rag_system.llm.generate(prompt, max_tokens=400)
            
            print("√ 快速检索完成")
            
            return {
                'original_query': query,
                'retrieved_docs': retrieved_docs,
                'final_answer': final_answer,
                'retrieval_method': 'Quick Vector Retrieval'
            }
            
        except Exception as e:
            return {"error": f"快速检索失败: {e}"}

    def topic_retrieval(self, query: str) -> Dict[str, Any]:
        """主题检索 - 集成网页研究系统"""
        print("\n执行网页检索...")
        print("="*40)
        
        try:
            if not self.web_research_system:
                print("警告：网页研究系统不可用，使用备用方案")
                return self.perform_fallback_topic_search(query)
            
            # 使用网页研究系统进行搜索
            print("正在进行网页研究...")
            web_content = ""
            web_sources = []
            
            try:
                # 检查可用的方法并调用正确的方法
                if hasattr(self.web_research_system, 'research_and_analyze'):
                    # 使用正确的方法名
                    research_result = self.web_research_system.research_and_analyze(query)
                    if isinstance(research_result, dict):
                        web_content = research_result.get('content', '')
                        web_sources = research_result.get('sources', [])
                    else:
                        web_content = str(research_result)
                        web_sources = ["网页研究结果"]
                    print("√ 网页研究完成")
                    
                elif hasattr(self.web_research_system, 'toolkit') and hasattr(self.web_research_system.toolkit, 'search_web_for_topic'):
                    # 使用工具包搜索
                    search_result = self.web_research_system.toolkit.search_web_for_topic(query, "")
                    web_content = search_result
                    web_sources = ["网页搜索结果"]
                    print("√ 网页搜索完成")
                    
                elif hasattr(self.web_research_system, 'run_interactive_session'):
                    # 尝试使用交互式会话方法
                    print("警告：使用交互式研究系统，但无法直接调用")
                    web_content = f"关于'{query}'的网页研究信息需要交互式操作"
                    web_sources = ["交互式研究系统"]
                    
                else:
                    print("警告：网页研究系统方法不可用")
                    web_content = f"关于'{query}'的网页搜索信息暂时不可用"
                    web_sources = []
                    
            except Exception as e:
                print(f"警告：网页搜索失败: {e}")
                web_content = f"网页搜索遇到错误: {str(e)}"
                web_sources = []
            
            # 同时进行PDF检索
            print("正在检索PDF文档...")
            pdf_docs = self.rag_system.vector_retriever.query(query, top_k=3, filter_type='text')
            
            # 合并结果
            combined_context = ""
            
            # 添加PDF内容
            if pdf_docs:
                pdf_context = "\n".join([doc['text'] for doc in pdf_docs])
                combined_context += f"PDF文档内容：\n{pdf_context}\n\n"
                print(f"√ 检索到 {len(pdf_docs)} 个PDF文档")
            
            # 添加网页内容
            if web_content and web_content.strip() and not web_content.startswith("关于") and not web_content.startswith("网页搜索遇到错误"):
                combined_context += f"网页搜索内容：\n{web_content}\n\n"
            
            if not combined_context.strip():
                print("警告：未找到相关信息，使用备用方案")
                return self.perform_fallback_topic_search(query)
            
            # 生成综合答案
            print("正在生成综合答案...")
            prompt = f"""基于以下PDF文档和网页搜索的信息，回答问题：

{combined_context}

问题：{query}

请提供综合性的详细答案："""
            
            final_answer = self.rag_system.llm.generate(prompt, max_tokens=800)
            
            print("主题检索完成")
            
            return {
                'original_query': query,
                'pdf_docs': pdf_docs,
                'web_sources': web_sources,
                'final_answer': final_answer,
                'retrieval_method': 'PDF+Web Topic Retrieval'
            }
            
        except Exception as e:
            print(f"警告：主题检索失败，使用备用方案: {e}")
            return self.perform_fallback_topic_search(query)

    def perform_web_research(self, query: str) -> Dict[str, Any]:
        """执行网页研究"""
        print("正在进行网页研究...")
        
        try:
            # 模拟网页研究结果
            web_content = f"基于网页搜索的{query}相关信息：\n"
            web_content += "- 网页来源1的相关内容\n"
            web_content += "- 网页来源2的相关内容\n"
            web_content += "- 网页来源3的相关内容"
            
            return {
                "web_content": web_content,
                "sources": ["网页来源1", "网页来源2", "网页来源3"],
                "method": "web_research"
            }
            
        except Exception as e:
            print(f"网页研究失败: {e}")
            return {"error": f"网页研究失败: {e}"}

    def perform_fallback_topic_search(self, query: str) -> Dict[str, Any]:
        """备用主题搜索 - 仅使用PDF检索"""
        print("执行备用主题搜索（仅PDF检索）...")
        
        try:
            # 进行PDF检索
            print("正在检索PDF文档...")
            pdf_docs = self.rag_system.vector_retriever.query(query, top_k=5, filter_type='text')
            
            if not pdf_docs:
                return {"error": "未找到相关PDF文档"}
            
            print(f"检索到 {len(pdf_docs)} 个PDF文档")
            
            # 显示检索到的文档
            for i, doc in enumerate(pdf_docs, 1):
                similarity = doc.get('similarity', 0)
                text_preview = doc.get('text', '')[:150] + "..." if len(doc.get('text', '')) > 150 else doc.get('text', '')
                print(f"文档 {i} (相似度: {similarity:.3f}):")
                print(f"   {text_preview}")
                print()
            
            # 构建上下文
            pdf_context = "\n".join([doc['text'] for doc in pdf_docs])
            
            # 生成答案
            print("正在生成答案...")
            prompt = f"""基于以下PDF文档内容回答问题：

PDF文档内容：
{pdf_context}

问题：{query}

请提供详细的答案，特别关注CAMEL框架的特性和工具："""
            
            final_answer = self.rag_system.llm.generate(prompt, max_tokens=800)
            
            print("√ 备用主题搜索完成")
            
            return {
                'original_query': query,
                'retrieved_docs': pdf_docs,
                'final_answer': final_answer,
                'retrieval_method': 'Fallback PDF Topic Retrieval'
            }
            
        except Exception as e:
            print(f"备用主题搜索失败: {e}")
            return {"error": f"备用主题搜索失败: {e}"}
    
    def merge_web_and_pdf_results(self, web_results: Dict, pdf_results: Dict, query: str) -> Dict[str, Any]:
        """合并网页和PDF检索结果"""
        try:
            # 合并上下文
            combined_context = ""
            
            # 添加PDF内容
            if 'retrieved_docs' in pdf_results:
                pdf_context = "\n".join([doc['text'] for doc in pdf_results['retrieved_docs']])
                combined_context += f"PDF文档内容：\n{pdf_context}\n\n"
            
            # 添加网页内容
            if 'web_content' in web_results:
                combined_context += f"网页搜索内容：\n{web_results['web_content']}\n\n"
            
            # 生成综合答案
            prompt = f"基于以下PDF文档和网页搜索的信息，回答问题：\n\n{combined_context}\n\n问题：{query}\n\n请提供综合性的详细答案。"
            
            final_answer = self.rag_system.llm.generate(prompt, max_tokens=800)
            
            return {
                'original_query': query,
                'pdf_docs': pdf_results.get('retrieved_docs', []),
                'web_sources': web_results.get('sources', []),
                'final_answer': final_answer,
                'retrieval_method': 'PDF+Web主题检索'
            }
            
        except Exception as e:
            return {"error": f"结果合并失败: {e}"}
    
    def display_results(self, results: Dict[str, Any]):
        """显示查询结果"""
        if 'error' in results:
            print(f"错误: {results['error']}")
            return

        print("\n" + "="*20 + " 深度检索结果 " + "="*20)
        print(f"原结始查询: {results.get('original_query', 'N/A')}")
        
        if results.get('rewritten_query'):
            print(f"重写查询: {results['rewritten_query']}")
        
        print(f"检索方法: {results.get('retrieval_method', 'N/A')}")
        
        # 显示检索到的文档
        retrieved_docs = results.get('retrieved_docs', [])
        if retrieved_docs:
            print(f"\n检索到的文档 (共{len(retrieved_docs)}个):")
            print()
            for i, doc in enumerate(retrieved_docs, 1):
                rrf_score = doc.get('rrf_score', doc.get('similarity', 0))
                text_preview = doc.get('text', '')[:200] + "..." if len(doc.get('text', '')) > 200 else doc.get('text', '')
                print(f"文档 {i}:")
                print(f"相关度分数: {rrf_score}")
                print(f"内容预览: {text_preview}")
                print()
        
        # 显示最终答案
        final_answer = results.get('final_answer', 'N/A')
        print("💡 生成答案:")
        print(final_answer)
        print("="*60)
        
        # 询问是否保存结果
        save_choice = input("\n询问：是否保存结果到文件？(y/n): ").strip().lower()
        if save_choice == 'y':
            self._save_results_to_file(results)

    def _save_results_to_file(self, results: Dict[str, Any]):
        """保存结果到文件"""
        try:
            from datetime import datetime
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            filename = f"rag_query_result_{timestamp}.txt"
            
            with open(filename, 'w', encoding='utf-8') as f:
                f.write("="*60 + "\n")
                f.write("RAG查询结果报告\n")
                f.write("="*60 + "\n\n")
                f.write(f"查询时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
                f.write(f"原始查询: {results.get('original_query', 'N/A')}\n")
                if results.get('rewritten_query'):
                    f.write(f"重写查询: {results['rewritten_query']}\n")
                f.write(f"检索方法: {results.get('retrieval_method', 'N/A')}\n\n")
                
                # 保存检索文档
                retrieved_docs = results.get('retrieved_docs', [])
                if retrieved_docs:
                    f.write(f"检索到的文档 (共{len(retrieved_docs)}个):\n")
                    f.write("-" * 40 + "\n")
                    for i, doc in enumerate(retrieved_docs, 1):
                        rrf_score = doc.get('rrf_score', doc.get('similarity', 0))
                        f.write(f"\n文档 {i}:\n")
                        f.write(f"相关度分数: {rrf_score}\n")
                        f.write(f"内容: {doc.get('text', '')}\n")
                        f.write("-" * 40 + "\n")
                
                # 保存最终答案
                f.write(f"\n生成答案:\n")
                f.write(results.get('final_answer', 'N/A'))
                f.write("\n\n" + "="*60)
            
            print(f"√ 结果已保存到: {filename}")
        except Exception as e:
            print(f"错误：保存失败: {e}")
    
    def run_interactive_session(self):
        """运行交互式会话"""
        if not self.initialize_system():
            return
        
        print("\n交互式多模态RAG系统")
        print("="*60)
        print("功能特性:")
        print("- 支持在线/本地PDF加载")
        print("- 三种检索模式")
        print("- 网页爬取集成")
        print("- 多模态内容处理")
        print("="*60)
        
        # 加载知识库
        if not self.load_pdf_knowledge_base():
            print("知识库加载失败，退出系统")
            return
        
        print(f"\n当前知识库: {self.current_pdf_source}")
        print(f"🔧 可用检索方法: {', '.join(self.rag_system.get_available_retrieval_methods())}")
        
        while True:
            try:
                print("\n" + "="*60)
                print("查询选项")
                print("="*60)
                
                # 获取用户查询
                query = input("请输入您的问题 (输入 'quit' 退出, 'reload' 重新加载PDF): ").strip()
                
                if query.lower() == 'quit':
                    break
                elif query.lower() == 'reload':
                    if self.load_pdf_knowledge_base():
                        print(f"√ 知识库已重新加载: {self.current_pdf_source}")
                    continue
                elif not query:
                    print("问题不能为空")
                    continue
                
                # 选择检索模式
                print("\n选择检索模式:")
                print("1. 快速检索 (基础向量检索)")
                print("2. 深度检索 (重写+HyDE+RRF)")
                print("3. 主题检索 (PDF+网页爬取)")
                
                mode_choice = input("请选择模式 (1-3): ").strip()
                
                mode_map = {
                    "1": "快速检索",
                    "2": "深度检索", 
                    "3": "主题检索"
                }
                
                retrieval_mode = mode_map.get(mode_choice)
                if not retrieval_mode:
                    print("无效选择，使用默认快速检索")
                    retrieval_mode = "快速检索"
                
                # 执行查询
                results = self.execute_query(query, retrieval_mode)
                
                # 显示结果
                self.display_results(results)
                
                # 询问是否继续
                continue_choice = input("\n是否继续查询？(y/n): ").strip().lower()
                if continue_choice != 'y':
                    break
                    
            except KeyboardInterrupt:
                print("\n\n用户中断，退出系统")
                break
            except Exception as e:
                print(f"系统错误: {e}")
                continue
        
        print("\n感谢使用交互式多模态RAG系统！")

def main():
    """主函数"""
    try:
        interactive_rag = InteractiveMultimodalRAG()
        interactive_rag.run_interactive_session()
    except Exception as e:
        print(f"系统启动失败: {e}")
        sys.exit(1)

if __name__ == "__main__":
    main()