test

service/company.py

@@ -0,0 +1,6 @@
+from service.mysql_service import get_company_by_name
+
+
+def check_company_exists(company_name):
+    result = get_company_by_name(company_name)
+    return len(result) > 0

service/hf_upload.py

@@ -0,0 +1,39 @@
+from huggingface_hub import HfApi, hf_hub_url
+
+def get_hf_files_with_links(repo_id):
+    """
+    获取Hugging Face仓库中的文件列表（文件名和完整链接），排除.gitattributes文件
+    
+    Args:
+        repo_id (str): Hugging Face仓库ID，格式为"用户名/仓库名"
+    
+    Returns:
+        list: 包含字典的列表，每个字典包含'title'和'link'键
+              例如: [{'title': 'model.bin', 'link': 'https://huggingface.co/...'}, ...]
+    
+    Raises:
+        ValueError: 当获取文件列表失败时抛出异常
+    """
+    try:
+        # 初始化Hugging Face API客户端
+        api = HfApi()
+        
+        # 获取仓库中的所有文件
+        files = api.list_repo_files(repo_id=repo_id, repo_type="model")
+        
+        # 过滤掉.gitattributes文件并生成完整链接
+        file_list = []
+        for file_path in files:
+            # 排除.gitattributes文件
+            if file_path != ".gitattributes":
+                # 生成文件的完整URL
+                file_url = hf_hub_url(repo_id=repo_id, filename=file_path)
+                file_list.append({
+                    'title': file_path,
+                    'link': file_url
+                })
+        
+        return file_list
+        
+    except Exception as e:
+        raise ValueError(f"获取文件列表失败: {str(e)}")

service/mcp_client.py

@@ -0,0 +1,286 @@
+import json
+import requests
+import subprocess
+import os
+from typing import Dict, Any, Generator, Optional
+import time
+
+
+class MCP_Client:
+    """MCP客户端，支持本地命令行和HTTP连接方式"""
+
+    def __init__(self, config: Dict[str, Any]):
+        """
+        初始化MCP客户端
+
+        Args:
+            config: MCP服务器配置
+        """
+        self.config = config
+        self.server_name = list(config["mcpServers"].keys())[0]
+        self.server_config = config["mcpServers"][self.server_name]
+
+        # 根据配置类型初始化不同的连接方式
+        if "command" in self.server_config:
+            # 本地命令行方式
+            self.connection_type = "local"
+            self.process: Optional[subprocess.Popen] = None
+        else:
+            # HTTP方式
+            self.connection_type = "http"
+            self.url = self.server_config.get("url")
+            self.headers = self.server_config.get("headers", {})
+
+        # 初始化状态
+        self.initialized = False
+
+    def initialize(self) -> bool:
+        """
+        初始化MCP会话
+
+        Returns:
+            bool: 初始化是否成功
+        """
+        if self.initialized:
+            return True
+
+        try:
+            if self.connection_type == "local":
+                # 启动本地MCP进程
+                command = self.server_config["command"]
+                args = self.server_config.get("args", [])
+                env = self.server_config.get("env", {})
+
+                # 合并环境变量
+                process_env = os.environ.copy()
+                process_env.update(env)
+
+                self.process = subprocess.Popen(
+                    [command] + args,
+                    stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    env=process_env,
+                    text=True,
+                    bufsize=1
+                )
+
+                # 发送初始化请求到子进程
+                init_request = {
+                    "jsonrpc": "2.0",
+                    "id": 1,
+                    "method": "initialize",
+                    "params": {
+                        "protocolVersion": "2025-06-18",
+                        "capabilities": {
+                            "experimental": {},
+                            "sampling": {},
+                            "elicitations": {},
+                            "roots": {}
+                        },
+                        "clientInfo": {
+                            "name": "mcp-client",
+                            "version": "1.0.0"
+                        }
+                    }
+                }
+
+                if self.process.stdin is not None:
+                    self.process.stdin.write(json.dumps(init_request) + "\n")
+                    self.process.stdin.flush()
+
+                # 读取响应
+                if self.process.stdout is not None:
+                    response_line = self.process.stdout.readline()
+                    response_data = json.loads(response_line.strip())
+                else:
+                    raise Exception("无法读取进程输出")
+
+                if "result" in response_data:
+                    # 发送初始化完成通知
+                    initialized_notification = {
+                        "jsonrpc": "2.0",
+                        "method": "notifications/initialized"
+                    }
+                    if self.process.stdin is not None:
+                        self.process.stdin.write(json.dumps(initialized_notification) + "\n")
+                        self.process.stdin.flush()
+                    self.initialized = True
+                    return True
+
+            else:
+                # HTTP方式初始化
+                init_request = {
+                    "jsonrpc": "2.0",
+                    "id": 1,
+                    "method": "initialize",
+                    "params": {
+                        "protocolVersion": "2025-06-18",
+                        "capabilities": {
+                            "experimental": {},
+                            "sampling": {},
+                            "elicitations": {},
+                            "roots": {}
+                        },
+                        "clientInfo": {
+                            "name": "mcp-http-client",
+                            "version": "1.0.0"
+                        }
+                    }
+                }
+
+                init_response = requests.post(
+                    self.url,
+                    json=init_request,
+                    headers={**self.headers, "Content-Type": "application/json"},
+                    timeout=10
+                )
+
+                if init_response.status_code == 200:
+                    response_data = init_response.json()
+                    if "result" in response_data:
+                        # 发送初始化完成通知
+                        initialized_notification = {
+                            "jsonrpc": "2.0",
+                            "method": "notifications/initialized"
+                        }
+                        requests.post(
+                            self.url,
+                            json=initialized_notification,
+                            headers={**self.headers, "Content-Type": "application/json"}
+                        )
+                        self.initialized = True
+                        return True
+
+            print(f"MCP初始化失败")
+            return False
+
+        except Exception as e:
+            print(f"MCP初始化错误: {e}")
+            return False
+
+    def call_tool(self, tool_name: str, arguments: Dict[str, Any], timeout: int = 90) -> Dict[str, Any]:
+        """
+        调用MCP工具
+
+        Args:
+            tool_name: 工具名称
+            arguments: 工具参数
+            timeout: 超时时间（秒）
+
+        Returns:
+            Dict[str, Any]: 工具执行结果
+        """
+        # 确保已初始化
+        if not self.initialized:
+            if not self.initialize():
+                raise Exception("MCP会话初始化失败")
+
+        if self.connection_type == "local":
+            # 本地命令行方式调用工具
+            tool_request = {
+                "jsonrpc": "2.0",
+                "id": 1,
+                "method": "tools/call",
+                "params": {
+                    "name": tool_name,
+                    "arguments": arguments
+                }
+            }
+
+            if self.process is not None and self.process.stdin is not None:
+                self.process.stdin.write(json.dumps(tool_request) + "\n")
+                self.process.stdin.flush()
+
+            # 读取响应
+            if self.process is not None and self.process.stdout is not None:
+                response_line = self.process.stdout.readline()
+                response_data = json.loads(response_line.strip())
+            else:
+                raise Exception("无法读取进程输出")
+
+            # 检查是否有错误
+            if "error" in response_data:
+                error = response_data["error"]
+                raise Exception(f"MCP错误 {error.get('code', 'unknown')}: {error.get('message', 'Unknown error')}")
+
+            # 返回结果
+            return response_data.get("result", {})
+        else:
+            # HTTP方式调用工具
+            tool_request = {
+                "jsonrpc": "2.0",
+                "id": 1,
+                "method": "tools/call",
+                "params": {
+                    "name": tool_name,
+                    "arguments": arguments
+                }
+            }
+
+            tool_response = requests.post(
+                self.url,
+                json=tool_request,
+                headers={**self.headers, "Content-Type": "application/json"},
+                timeout=timeout
+            )
+
+            if tool_response.status_code != 200:
+                raise Exception(f"工具调用请求失败: HTTP {tool_response.status_code}")
+
+            response_data = tool_response.json()
+
+            # 检查是否有错误
+            if "error" in response_data:
+                error = response_data["error"]
+                raise Exception(f"MCP错误 {error.get('code', 'unknown')}: {error.get('message', 'Unknown error')}")
+
+            # 返回结果
+            return response_data.get("result", {})
+
+    def close(self) -> None:
+        """关闭MCP客户端连接"""
+        if self.connection_type == "local" and self.process:
+            self.process.terminate()
+            self.process.wait()
+        # 对于HTTP客户端，不需要特殊清理
+        pass
+
+
+# 使用示例
+if __name__ == "__main__":
+    # Alpha Vantage MCP配置（本地命令行方式）
+    mcp_config = {
+        "mcpServers": {
+            "alpha-vantage": {
+                "command": "npx",
+                "args": ["alpha-ventage-mcp"],
+                "env": {
+                    "ALPHA_VANTAGE_API_KEY": "97Q9TT7I6J9ZOLDS"
+                }
+            }
+        }
+    }
+
+    # 创建MCP客户端
+    client = MCP_Client(mcp_config)
+
+    try:
+        # 初始化MCP会话
+        print("正在初始化MCP会话...")
+        if client.initialize():
+            print("MCP会话初始化成功")
+        else:
+            print("MCP会话初始化失败")
+            exit(1)
+
+        # 示例：调用工具（请根据实际情况替换工具名称和参数）
+        print("MCP客户端已准备就绪，可以调用工具")
+
+    except Exception as e:
+        print(f"发生错误: {e}")
+
+    finally:
+        # 关闭连接
+        client.close()
+        print("MCP客户端连接已关闭")

service/mysql_service.py

@@ -0,0 +1,194 @@
+import gradio as gr
+import pandas as pd
+from sqlalchemy import create_engine, text
+
+# 数据库连接配置
+DB_CONFIG = {
+    'host': 'rm-j6c5yhe0l739e7752vo.mysql.cnhk.rds.aliyuncs.com',
+    'user': 'report_user',
+    'password': 'report_user_123',
+    'database': 'easy_financial_report'
+}
+
+def get_database_url():
+    """构造数据库连接URL"""
+    return f"mysql+pymysql://{DB_CONFIG['user']}:{DB_CONFIG['password']}@{DB_CONFIG['host']}/{DB_CONFIG['database']}"
+
+def execute_query_with_connection(engine, query, params=None):
+    """
+    自动打开和关闭数据库连接执行查询
+    
+    Args:
+        engine: SQLAlchemy引擎实例
+        query: SQL查询语句
+        params: 查询参数(可选)
+    
+    Returns:
+        查询结果或错误信息
+    """
+    try:
+        with engine.connect() as conn:
+            if params:
+                result = conn.execute(text(query), params)
+            else:
+                result = conn.execute(text(query))
+            return result.fetchall()
+    except Exception as e:
+        return f"查询执行失败: {str(e)}"
+
+def execute_query(query):
+    """执行SQL查询并返回结果"""
+    if not query.strip():
+        return "请输入SQL查询语句"
+    
+    try:
+        # 创建数据库连接引擎
+        engine = create_engine(get_database_url())
+        
+        # 使用上下文管理器执行查询
+        with engine.connect() as conn:
+            df = pd.read_sql_query(text(query), conn)
+            return df
+    except Exception as e:
+        return f"查询执行失败: {str(e)}"
+    # 引擎会在with语句结束后自动清理连接
+
+def get_table_names():
+    """获取数据库中的所有表名"""
+    try:
+        # 创建数据库连接引擎
+        engine = create_engine(get_database_url())
+        
+        # 使用上下文管理器执行查询
+        with engine.connect() as conn:
+            # 查询所有表名
+            query = "SHOW TABLES"
+            df = pd.read_sql_query(text(query), conn)
+            
+            # 返回表名列表
+            return df.iloc[:, 0].tolist() if not df.empty else []
+    except Exception as e:
+        return [f"获取表名失败: {str(e)}"]
+    # 引擎会在with语句结束后自动清理连接
+
+def preview_table(table_name):
+    """预览表的前几行数据"""
+    if not table_name or "失败" in table_name:
+        return "请选择有效的表名"
+    
+    query = f"SELECT * FROM {table_name} LIMIT 10"
+    return execute_query(query)
+
+# 新增功能函数
+def insert_record(title):
+    """向report_file_link表插入新记录"""
+    if not title.strip():
+        return "请输入标题"
+    
+    try:
+        engine = create_engine(get_database_url())
+        # 插入新记录
+        query = "INSERT INTO report_file_link (title) VALUES (:title)"
+        with engine.connect() as conn:
+            trans = conn.begin()
+            try:
+                conn.execute(text(query), {"title": title})
+                trans.commit()
+                return f"成功插入记录: {title}"
+            except Exception as e:
+                trans.rollback()
+                raise e
+    except Exception as e:
+        return f"插入记录失败: {str(e)}"
+    # 引擎会在with语句结束后自动清理连接
+
+def update_record(record_id, new_title):
+    """更新report_file_link表中的记录"""
+    if not record_id or not new_title.strip():
+        return "请输入记录ID和新标题"
+    
+    try:
+        engine = create_engine(get_database_url())
+        # 更新记录
+        query = "UPDATE report_file_link SET title = :title WHERE id = :id"
+        with engine.connect() as conn:
+            trans = conn.begin()
+            try:
+                result = conn.execute(text(query), {"title": new_title, "id": record_id})
+                trans.commit()
+                
+                if result.rowcount > 0:
+                    return f"成功更新记录ID {record_id} 的标题为: {new_title}"
+                else:
+                    return f"未找到ID为 {record_id} 的记录"
+            except Exception as e:
+                trans.rollback()
+                raise e
+    except Exception as e:
+        return f"更新记录失败: {str(e)}"
+    # 引擎会在with语句结束后自动清理连接
+
+def delete_record(record_id):
+    """从report_file_link表中删除记录"""
+    if not record_id:
+        return "请输入记录ID"
+    
+    try:
+        engine = create_engine(get_database_url())
+        # 删除记录
+        query = "DELETE FROM report_file_link WHERE id = :id"
+        with engine.connect() as conn:
+            trans = conn.begin()
+            try:
+                result = conn.execute(text(query), {"id": record_id})
+                trans.commit()
+                
+                if result.rowcount > 0:
+                    return f"成功删除ID为 {record_id} 的记录"
+                else:
+                    return f"未找���ID为 {record_id} 的记录"
+            except Exception as e:
+                trans.rollback()
+                raise e
+    except Exception as e:
+        return f"删除记录失败: {str(e)}"
+    # 引擎会在with语句结束后自动清理连接
+
+def refresh_report_file_link():
+    """刷新report_file_link表的数据"""
+    return execute_query("SELECT * FROM report_file_link")
+
+# 新增功能函数
+def insert_company(company_name, stock_code):  
+    try:
+        engine = create_engine(get_database_url())
+        # 插入新记录
+        query = "INSERT INTO company (company_name, stock_code) VALUES (:company_name, :stock_code)"
+        with engine.connect() as conn:
+            trans = conn.begin()
+            try:
+                conn.execute(text(query), {"company_name": company_name, "stock_code": stock_code})
+                trans.commit()
+                return True
+            except Exception as e:
+                trans.rollback()
+                raise e
+    except Exception as e:
+        return False
+    # 引擎会在with语句结束后自动清理连接
+
+def get_companys():
+    """获取company表中的所有公司"""
+    query = "SELECT * FROM company"
+    return execute_query(query)
+
+def get_company_by_name(company_name):
+    """根据公司名称获取公司信息"""
+    query = "SELECT * FROM company WHERE company_name = :company_name"
+    try:
+        engine = create_engine(get_database_url())
+        with engine.connect() as conn:
+            df = pd.read_sql_query(text(query), conn, params={"company_name": company_name})
+            return df
+    except Exception as e:
+        return f"查询执行失败: {str(e)}"

service/tool_processor.py

@@ -0,0 +1,391 @@
+import json
+import time
+from .mcp_client import MCP_Client
+
+BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1"
+MODEL = "qwen3-max"
+TOKEN = "sk-ef26097310ec45c184e8d84b31ea9356"
+
+# Alpha Vantage MCP配置
+MCP_CONFIG = {
+    "mcpServers": {
+        "alpha-vantage": {
+            "command": "npx",
+            "args": ["alpha-ventage-mcp"],
+            "env": {
+                "ALPHA_VANTAGE_API_KEY": "97Q9TT7I6J9ZOLDS"
+            }
+        }
+    }
+}
+
+
+def extract_stock_symbol(user_input: str) -> str:
+    """
+    从用户输入中提取股票代码
+    支持多种格式:
+    - "查询阿里巴巴股票" -> BABA
+    - "查询AAPL股票" -> AAPL
+    - "我想了解MSFT的股价" -> MSFT
+    - "BABA股价如何" -> BABA
+    """
+    # 预定义一些常见股票代码的映射
+    stock_mapping = {
+        "阿里巴巴": "BABA",
+        "阿里": "BABA",
+        "腾讯": "TCEHY",
+        "微软": "MSFT",
+        "苹果": "AAPL",
+        "谷歌": "GOOGL",
+        "亚马逊": "AMZN",
+        "特斯拉": "TSLA",
+        "英伟达": "NVDA",
+        "百度": "BIDU",
+        "京东": "JD",
+        "拼多多": "PDD"
+    }
+
+    # 检查预定义映射
+    for chinese_name, symbol in stock_mapping.items():
+        if chinese_name in user_input:
+            return symbol
+
+    # 尝试直接匹配常见的股票代码格式 (如 AAPL, MSFT 等)
+    import re
+    # 匹配常见的股票代码格式
+    patterns = [
+        r'\b([A-Z]{1,5})\b',  # 大写字母组成的股票代码
+        r'股票代码[是为]?([A-Z]{1,5})',
+        r'([A-Z]{1,5})股票'
+    ]
+
+    for pattern in patterns:
+        match = re.search(pattern, user_input)
+        if match:
+            symbol = match.group(1)
+            # 验证是否为有效的股票代码格式
+            if 1 <= len(symbol) <= 5 and symbol.isalpha():
+                return symbol
+
+    # 默认返回阿里巴巴
+    return "BABA"
+
+
+def get_stock_price(symbol: str):
+    """获取股票价格"""
+    client = MCP_Client(MCP_CONFIG)
+    if not client.initialize():
+        raise Exception("MCP初始化失败")
+    
+    try:
+        result = client.call_tool("get_stock_price", {"symbol": symbol})
+        client.close()
+        return result
+    except Exception as e:
+        client.close()
+        raise e
+
+
+def get_company_overview(symbol: str):
+    """获取公司概况"""
+    client = MCP_Client(MCP_CONFIG)
+    if not client.initialize():
+        raise Exception("MCP初始化失败")
+    
+    try:
+        result = client.call_tool("get_company_overview", {"symbol": symbol})
+        client.close()
+        return result
+    except Exception as e:
+        client.close()
+        raise e
+
+
+def get_daily_time_series(symbol: str):
+    """获取每日时间序列数据"""
+    client = MCP_Client(MCP_CONFIG)
+    if not client.initialize():
+        raise Exception("MCP初始化失败")
+    
+    try:
+        result = client.call_tool("get_daily_time_series", {"symbol": symbol})
+        client.close()
+        return result
+    except Exception as e:
+        client.close()
+        raise e
+
+
+def get_forex_rate(from_currency: str = "USD", to_currency: str = "CNY"):
+    """获取外汇汇率"""
+    client = MCP_Client(MCP_CONFIG)
+    if not client.initialize():
+        raise Exception("MCP初始化失败")
+    
+    try:
+        result = client.call_tool("get_forex_rate", {
+            "from_currency": from_currency, 
+            "to_currency": to_currency
+        })
+        client.close()
+        return result
+    except Exception as e:
+        client.close()
+        raise e
+
+
+def get_tools_for_stock(symbol: str):
+    """根据股票代码生成工具列表"""
+    return [
+        {
+            "name": "get_stock_price",
+            "description": "获取股票价格",
+            "params": {"symbol": symbol},
+        },
+        {
+            "name": "get_company_overview",
+            "description": "获取公司概况",
+            "params": {"symbol": symbol},
+        },
+        {
+            "name": "get_daily_time_series",
+            "description": "获取每日时间序列数据",
+            "params": {"symbol": symbol},
+        },
+        {
+            "name": "get_forex_rate",
+            "description": "获取外汇汇率",
+            "params": {"from_currency": "USD", "to_currency": "CNY"},
+        }
+    ]
+
+
+def call_llm(prompt: str):
+    """模拟调用大模型的函数（你可以替换为真实请求）"""
+    import requests
+
+    headers = {
+        "Authorization": f"Bearer {TOKEN}",
+        "Content-Type": "application/json"
+    }
+    data = {
+        "model": MODEL,
+        "messages": [{"role": "user", "content": prompt}],
+        "stream": True  # 启用流式响应
+    }
+    response = requests.post(f"{BASE_URL}/chat/completions", headers=headers, json=data, stream=True)
+    for line in response.iter_lines():
+        if line:
+            yield line.decode('utf-8')
+
+
+def get_stock_data_example(symbol: str):
+    """示例函数：获取股票数据的简化调用方式"""
+    try:
+        # 获取股票价格
+        price_data = get_stock_price(symbol)
+        print(f"股票价格数据: {price_data}")
+        
+        # 获取公司概况
+        overview_data = get_company_overview(symbol)
+        print(f"公司概况数据: {overview_data}")
+        
+        # 获取每日时间序列
+        time_series_data = get_daily_time_series(symbol)
+        print(f"时间序列数据: {time_series_data}")
+        
+        # 获取外汇汇率
+        forex_data = get_forex_rate()
+        print(f"外汇汇率数据: {forex_data}")
+        
+        return {
+            "price": price_data,
+            "overview": overview_data,
+            "time_series": time_series_data,
+            "forex": forex_data
+        }
+    except Exception as e:
+        print(f"获取股票数据时出错: {str(e)}")
+        raise e
+
+
+def process_tool_analysis(user_input: str, history: list):
+    """
+    处理工具分析的主要逻辑
+    - user_input: str
+    - history: list of {"role": ..., "content": ...}
+    Returns generator for streaming.
+    """
+    if not user_input.strip():
+        yield "", history
+        return
+
+    # 添加用户消息到历史
+    history.append({"role": "user", "content": user_input})
+
+    try:
+        # 从用户输入中提取股票代码
+        stock_symbol = extract_stock_symbol(user_input)
+
+        # 根据股票代码生成工具列表
+        tools_to_test = get_tools_for_stock(stock_symbol)
+
+        # 创建MCP客户端
+        client = MCP_Client(MCP_CONFIG)
+
+        # 初始化MCP会话
+        if not client.initialize():
+            error_msg = "❌ MCP初始化失败"
+            history.append({"role": "assistant", "content": error_msg})
+            yield "", history
+            return
+
+        # 收集所有工具的查询结果
+        all_results = []
+
+        # 依次调用每个工具
+        for i, tool in enumerate(tools_to_test, 1):
+            # 添加工具标题（使用HTML实现可折叠效果，默认折叠）
+            tool_content = f'''<details>
+<summary class="tool-header querying" style="background-color: #f0f8ff; border: 1px solid #d0e0f0; border-radius: 5px; padding: 10px; margin: 10px 0; color: #1e40af; font-weight: bold; cursor: pointer;">
+[MCP] <span class="status-tag querying">查询中</span> 🔧 工具 {i}/{len(tools_to_test)}: {tool['name']} ({tool['description']})
+</summary>
+<div style="border: 1px solid #d0e0f0; border-top: none; border-radius: 0 0 5px 5px; padding: 15px; background-color: #f8fafc; margin-bottom: 10px;">'''
+
+            history.append({"role": "assistant", "content": tool_content})
+            yield "", history
+
+            try:
+                result = client.call_tool(tool["name"], tool["params"])
+
+                # 解析结果
+                if isinstance(result, dict) and "content" in result:
+                    content = result["content"]
+                    if isinstance(content, list) and len(content) > 0:
+                        text_content = content[0].get("text", "") if isinstance(content[0], dict) else str(content[0])
+                        # 立即调用模型总结这个信息内容
+                        summary_prompt = f"给我总结这个信息内容：{text_content}"
+                        # 更新状态为分析中
+                        # 找到完整的summary标签并更新状态
+                        start_idx = history[-1]["content"].find('<summary')
+                        end_idx = history[-1]["content"].find('</summary>') + len('</summary>')
+                        if start_idx != -1 and end_idx != -1:
+                            summary_content = history[-1]["content"][start_idx:end_idx]
+                            # 更新工具标题的类名和状态文本（添加过渡效果）
+                            updated_summary = summary_content.replace('tool-header querying',
+                                                                      'tool-header analyzing').replace(
+                                'status-tag querying', 'status-tag analyzing').replace('查询中', '分析中')
+                            history[-1]["content"] = history[-1]["content"].replace(summary_content, updated_summary)
+                        yield "", history
+
+                        # 流式显示模型处理结果（在可折叠面板内部）
+                        model_summary = ""
+                        # 移除所有冗余提示文本，直接显示分析结果区域
+                        history[-1]["content"] += "<div id='analysis-result'>"
+                        yield "", history
+
+                        for chunk in call_llm(summary_prompt):
+                            if not chunk or chunk == "[DONE]":
+                                continue
+
+                            if chunk.startswith("data: "):
+                                chunk = chunk[6:]
+
+                            try:
+                                response_data = json.loads(chunk)
+                                delta = response_data.get("choices", [{}])[0].get("delta", {})
+                                content = delta.get("content", "")
+                                if content:
+                                    model_summary += content
+                                    # 更新分析结果（在可折叠面板内部）
+                                    history[-1]["content"] = history[-1]["content"][0:history[-1]["content"].find(
+                                        "<div id='analysis-result'>") + 26] + model_summary
+                                    yield "", history
+                            except json.JSONDecodeError:
+                                continue  # 忽略无效 JSON
+
+                        history[-1]["content"] += "</div>"
+
+                        result_msg = f"✅ {tool['name']}: {model_summary}"
+                        all_results.append(f"{tool['description']}: {model_summary}")
+                        # 添加最终结果到历史（在可折叠面板内部），移除所有冗余提示文本
+                        history[-1]["content"] += f"<p><strong>分析结果:</strong></p><p>{result_msg}</p>"
+
+                        # 更新状态为已完成（添加过渡效果）
+                        # 找到完整的summary标签并更新状态
+                        start_idx = history[-1]["content"].find('<summary')
+                        end_idx = history[-1]["content"].find('</summary>') + len('</summary>')
+                        if start_idx != -1 and end_idx != -1:
+                            summary_start = history[-1]["content"][start_idx:end_idx]
+                            updated_summary = summary_start.replace('tool-header analyzing',
+                                                                    'tool-header completed').replace(
+                                'status-tag analyzing', 'status-tag completed').replace('分析中', '已完成')
+                            history[-1]["content"] = history[-1]["content"].replace(summary_start, updated_summary)
+
+                        # 关闭可折叠面板
+                        history[-1]["content"] += "</div>\n</details>"
+
+            except Exception as e:
+                error_msg = f"❌ {tool['name']} 查询失败: {str(e)}"
+                history.append({"role": "assistant", "content": error_msg})
+                yield "", history
+
+                # 关闭可折叠面板（即使是错误情况）
+                history[-1]["content"] += "</div>\n</details>"
+                all_results.append(f"{tool['name']}: 查询失败 - {str(e)}")
+
+            # 添加短暂延迟以改善用户体验
+            time.sleep(0.5)
+
+        # 关闭MCP连接
+        client.close()
+
+        # 将所有结果汇总后传递给AI模型进行总结
+        final_summary_header = '''<div style="border: 2px solid #4CAF50; border-radius: 8px; padding: 20px; background-color: #f8fff8; margin: 15px 0;">
+<h3 style="color: #2E7D32; text-align: center; margin-top: 0;">📈 最终总结</h3>'''
+        history.append({"role": "assistant", "content": final_summary_header})
+        yield "", history
+
+        summary_msg = "📊 正在分析所有数据并生成总结..."
+        history.append({"role": "assistant", "content": summary_msg})
+        yield "", history
+
+        # 构造给AI模型的提示
+        all_results_text = "\n".join(all_results)
+        summary_prompt = f"""用户问题: {user_input}
+
+收集到的金融数据:
+{all_results_text}
+
+请根据以上数据回答用户问题，提供简洁明了的总结。"""
+
+        # 调用AI模型进行总结
+        bot_response = ""
+        for chunk in call_llm(summary_prompt):
+            if not chunk or chunk == "[DONE]":
+                continue
+
+            if chunk.startswith("data: "):
+                chunk = chunk[6:]
+
+            try:
+                response_data = json.loads(chunk)
+                delta = response_data.get("choices", [{}])[0].get("delta", {})
+                content = delta.get("content", "")
+                if content:
+                    bot_response += content
+                    # 更新累积历史记录中的最后一条消息，实现流式显示
+                    history[-1]["content"] = "📊 正在分析所有数据并生成总结...\n" + bot_response
+                    yield "", history
+            except json.JSONDecodeError:
+                continue  # 忽略无效 JSON
+
+        # 最终完整历史
+        final_footer = "</div>"
+        history.append({"role": "assistant", "content": bot_response + final_footer})
+        yield "", history
+
+    except Exception as e:
+        error_msg = f"❌ 错误: {str(e)}"
+        history.append({"role": "assistant", "content": error_msg})
+        yield "", history