├── .gitignore ├── .vscode ├── launch.json └── settings.json ├── DAILY_NEWS_TOOL_USAGE.md ├── MIGRATION.md ├── README.md ├── SECTOR_STOCKS_FIX_REPORT.md ├── SECTOR_STOCKS_USAGE.md ├── SSE_USAGE.md ├── confs ├── markets.json └── stock_sector.json ├── data.py ├── debug_market_cap.py ├── debug_real_market_cap.py ├── docs ├── cherrystudio-use.jpg ├── cherrystudio.jpg ├── deepchat-use.jpg ├── deepchat.jpg └── let-your-deepseek-analyze-stock-by-mcp.md ├── list_available_sectors.py ├── main.py ├── pyproject.toml ├── qtf_mcp ├── __init__.py ├── akshare股票接口文档.md ├── datafeed.py ├── mcp_app.py ├── news_extractor.py ├── research.py ├── sensitive_words.py └── symbols.py ├── requirements.txt ├── start.sh ├── start_sse.sh ├── stock_selector.py ├── test_akshare_direct.py ├── test_akshare_hold_num.py ├── test_daily_news.py ├── test_date.py ├── test_full.py ├── test_improved_sector_stocks.py ├── test_medium_function.py ├── test_minute_data.py ├── test_original_issue.py ├── test_sector.py ├── test_sector_stocks.py ├── test_simple_hold_num.py ├── test_symbols.py ├── test_tcap_fix.py └── tests └── test.sh /.gitignore: -------------------------------------------------------------------------------- 1 | # Python-generated files 2 | __pycache__/ 3 | *.py[oc] 4 | build/ 5 | dist/ 6 | wheels/ 7 | *.egg-info 8 | 9 | # Virtual environments 10 | .venv 11 | .python-version 12 | 13 | .env 14 | uv.lock 15 | 16 | log.txt 17 | 18 | libs -------------------------------------------------------------------------------- /.vscode/launch.json: -------------------------------------------------------------------------------- 1 | { 2 | // 使用 IntelliSense 了解相关属性。 3 | // 悬停以查看现有属性的描述。 4 | // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387 5 | "version": "0.2.0", 6 | "configurations": [ 7 | { 8 | "name": "Server", 9 | "type": "debugpy", 10 | "request": "launch", 11 | "program": "main.py", 12 | "args": [ 13 | "--transport=http" 14 | ], 15 | "justMyCode": false, 16 | "console": "integratedTerminal", 17 | } 18 | ] 19 | } -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "cSpell.words": [ 3 | "FUNDFLOW", 4 | "streamable" 5 | ] 6 | } -------------------------------------------------------------------------------- /DAILY_NEWS_TOOL_USAGE.md: -------------------------------------------------------------------------------- 1 | # 每日新闻联播获取工具使用说明 2 | 3 | ## 功能概述 4 | 5 | 基于 `/Users/huangchuang/mcp-cn-a-stock/qtf_mcp/mcp_app.py` 添加的 `daily_news` 工具，可以通过MCP协议获取指定日期的新闻联播内容。 6 | 7 | ## 使用方法 8 | 9 | ### 1. 在MCP客户端中使用 10 | 11 | #### 基本调用格式 12 | ```python 13 | # 获取指定日期的新闻联播 14 | result = await daily_news("2024-01-15", context) 15 | ``` 16 | 17 | #### 参数说明 18 | - `date` (str): 日期字符串，格式必须为 "YYYY-MM-DD" 19 | - `ctx`: MCP上下文对象 20 | 21 | ### 2. 支持的日期格式 22 | 23 | - ✅ **正确格式**: "2024-01-15" 24 | - ✅ **正确格式**: "2023-12-31" 25 | - ❌ **错误格式**: "2024/1/15" 26 | - ❌ **错误格式**: "2024-1-15" 27 | - ❌ **错误格式**: "20240115" 28 | 29 | ### 3. 返回内容格式 30 | 31 | #### 成功返回示例 32 | ``` 33 | # 2024年01月15日新闻联播文字版 | 每日新闻联播 34 | 35 | ## 基本信息 36 | - **日期**: 2024-01-15 37 | - **来源**: 中央电视台新闻联播 38 | - **原文链接**: http://mrxwlb.com/2024/01/15/... 39 | 40 | ## 新闻内容摘要 41 | 20240115今日新闻联播主要内容： 42 | 习近平致电祝贺丹麦国王腓特烈十世即位 43 | 【新思想引领新征程】共下"一盘棋"成渝地区双城经济圈建设迈出新步伐 44 | 李强抵达苏黎世对瑞士进行正式访问 45 | ... 46 | 47 | ## 新闻条目 48 | ### 1. 【新思想引领新征程】共下"一盘棋"成渝地区双城经济圈建设迈出新步伐 49 | ### 2. 【新时代新征程新伟业——实干笃行】内蒙古扎实做好现代能源大文章 50 | ### 3. 我国造船三大指标国际市场份额首超50% 51 | ### 4. 天舟七号货运飞船船箭组合体顺利垂直转运至发射区 52 | 53 | ## 完整内容 54 | 如需查看完整新闻内容，请访问： 55 | http://mrxwlb.com/2024/01/15/2024年01月15日新闻联播文字版/ 56 | 57 | ## 数据说明 58 | - 数据来源：央视新闻联播文字版 59 | - 更新时间：每日新闻联播播出后 60 | - 内容格式：纯文本格式，包含当日重要新闻摘要 61 | ``` 62 | 63 | #### 错误返回示例 64 | 65 | ##### 日期格式错误 66 | ``` 67 | # 日期格式错误 68 | 69 | ## 错误信息 70 | - **错误类型**: 日期格式无效 71 | - **正确格式**: YYYY-MM-DD（例如：2024-01-15） 72 | 73 | ## 示例 74 | - ✅ 2024-01-15 75 | - ✅ 2023-12-31 76 | - ❌ 2024/1/15 77 | - ❌ 2024-1-15 78 | - ❌ 20240115 79 | ``` 80 | 81 | ##### 内容获取失败 82 | ``` 83 | # 获取新闻失败 84 | 85 | ## 错误信息 86 | - **日期**: 2024-01-15 87 | - **状态**: 获取失败 88 | - **错误详情**: 404 Client Error: Not Found 89 | 90 | ## 可能原因 91 | 1. 指定日期的新闻联播内容尚未发布或已下架 92 | 2. 网络连接问题导致无法访问新闻源 93 | 3. 日期格式不正确（请使用YYYY-MM-DD格式） 94 | 95 | ## 建议操作 96 | - 检查日期格式是否正确 97 | - 尝试获取更近日期的新闻 98 | - 稍后重试获取 99 | ``` 100 | 101 | ## 测试示例 102 | 103 | ### 命令行测试 104 | ```bash 105 | # 测试功能 106 | python3 test_daily_news.py 2024-01-15 107 | 108 | # 测试错误处理 109 | python3 test_daily_news.py 2024-13-45 # 无效日期 110 | ``` 111 | 112 | ### 实际使用示例 113 | 114 | #### 在Cherry Studio中使用 115 | ```json 116 | { 117 | "tool": "daily_news", 118 | "parameters": { 119 | "date": "2024-01-15" 120 | } 121 | } 122 | ``` 123 | 124 | #### 在代码中使用 125 | ```python 126 | from qtf_mcp.mcp_app import daily_news 127 | import asyncio 128 | 129 | async def get_news(): 130 | result = await daily_news("2024-01-15", None) 131 | print(result) 132 | 133 | asyncio.run(get_news()) 134 | ``` 135 | 136 | ## 数据源说明 137 | 138 | - **数据源**: http://mrxwlb.com (每日新闻联播文字版) 139 | - **更新频率**: 每日新闻联播播出后 140 | - **数据格式**: 纯文本格式 141 | - **覆盖范围**: 2018年至今的新闻联播内容 142 | - **内容包含**: 当日重要新闻、政策解读、国内外大事 143 | 144 | ## 注意事项 145 | 146 | 1. **日期范围**: 支持2018年至今的日期，未来日期会返回错误 147 | 2. **网络依赖**: 需要访问外部新闻源，网络问题可能导致获取失败 148 | 3. **内容长度**: 返回内容可能较长，建议在实际使用中设置适当的显示长度 149 | 4. **实时性**: 新闻联播内容通常在播出后1-2小时内更新 150 | 151 | ## 相关文件 152 | 153 | - `/Users/huangchuang/mcp-cn-a-stock/qtf_mcp/mcp_app.py` - 包含daily_news工具定义 154 | - `/Users/huangchuang/mcp-cn-a-stock/qtf_mcp/news_extractor.py` - 新闻提取核心功能 155 | - `/Users/huangchuang/mcp-cn-a-stock/test_daily_news.py` - 测试脚本 -------------------------------------------------------------------------------- /MIGRATION.md: -------------------------------------------------------------------------------- 1 | # 数据源迁移说明 2 | 3 | ## 概述 4 | 本项目已将数据源从MSD（Market Securities Data）迁移至AkShare，这是一个开源的金融数据接口库。 5 | 6 | ## 主要变更 7 | 8 | ### 1. 依赖项变更 9 | - **移除**: qtf库依赖及本地.whl文件 10 | - **新增**: akshare、pandas、numpy、ta-lib 11 | 12 | ### 2. 数据源变更 13 | - **原数据源**: MSD专业金融数据服务 14 | - **新数据源**: AkShare开源数据接口 15 | - **数据覆盖**: A股股票、指数、ETF等 16 | 17 | ### 3. 功能变更 18 | - **保持**: 所有原有接口不变 19 | - **增强**: 支持更多股票代码格式 20 | - **优化**: 数据获取速度提升 21 | 22 | ## 环境配置 23 | 24 | ### 创建虚拟环境 25 | ```bash 26 | /opt/homebrew/bin/python3 -m venv venv 27 | source venv/bin/activate 28 | ``` 29 | 30 | ### 安装依赖 31 | ```bash 32 | pip install -r requirements.txt 33 | ``` 34 | 35 | ## 使用方法 36 | 37 | ### 启动服务 38 | ```bash 39 | source venv/bin/activate 40 | python3 main.py --transport stdio 41 | ``` 42 | 43 | ### 测试数据获取 44 | ```python 45 | import asyncio 46 | from qtf_mcp.datafeed import load_data_akshare 47 | 48 | async def test(): 49 | data = await load_data_akshare('000001', '2024-01-01', '2024-01-10') 50 | print(f"获取数据成功，包含字段: {list(data.keys())}") 51 | 52 | asyncio.run(test()) 53 | ``` 54 | 55 | ## 数据质量说明 56 | 57 | ### 优势 58 | 1. **免费**: 无需付费API密钥 59 | 2. **开源**: 代码透明，可定制 60 | 3. **丰富**: 支持多种数据类型 61 | 62 | ### 限制 63 | 1. **实时性**: 数据延迟约15分钟 64 | 2. **稳定性**: 依赖网络连接质量 65 | 3. **完整性**: 部分历史数据可能不完整 66 | 67 | ## 故障排除 68 | 69 | ### 常见问题 70 | 1. **网络连接**: 确保能正常访问互联网 71 | 2. **日期格式**: 使用YYYY-MM-DD格式 72 | 3. **股票代码**: 支持000001、SH600000等格式 73 | 74 | ### 调试方法 75 | ```bash 76 | # 查看详细日志 77 | python3 -c " 78 | import logging 79 | logging.basicConfig(level=logging.DEBUG) 80 | from qtf_mcp.datafeed import load_data_akshare 81 | import asyncio 82 | asyncio.run(load_data_akshare('000001', '2024-01-01', '2024-01-10')) 83 | " 84 | ``` -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # 中国股市数据MCP服务架构分析文档 2 | 3 | ## 项目概述 4 | 5 | 这是一个专为A股市场数据设计的MCP (Model Content Protocol) 服务，为大模型提供股票数据查询和分析能力。项目通过标准化的MCP协议，使AI助手能够获取和分析中国股市的实时和历史数据。 6 | 7 | ## 整体架构 8 | 9 | ### 架构模式 10 | - **MCP服务器模式**: 基于FastMCP框架构建的标准化AI工具服务 11 | - **分层架构**: 清晰的职责分离，包含数据层、服务层、接口层 12 | - **模块化设计**: 各功能模块独立，便于维护和扩展 13 | 14 | ### 技术栈 15 | - **核心框架**: FastMCP (基于mcp.server.fastmcp) 16 | - **数据获取**: AkShare金融数据接口 + 本地配置文件 17 | - **数据处理**: NumPy + Ta-Lib (技术指标) 18 | - **配置管理**: JSON配置文件 19 | - **部署方式**: Python CLI应用 + SSE/HTTP传输 20 | 21 | ## 模块架构详解 22 | 23 | ### 1. 入口层 (main.py) 24 | 25 | **职责**: 应用程序入口，处理命令行参数和启动服务 26 | 27 | **核心功能**: 28 | - 命令行参数解析 (端口、传输方式) 29 | - 日志配置 30 | - 股票符号预加载 31 | - MCP服务启动 32 | 33 | **配置选项**: 34 | ```bash 35 | python main.py --port 8000 --transport sse 36 | ``` 37 | 38 | ### 2. MCP服务层 (qtf_mcp/mcp_app.py) 39 | 40 | **职责**: MCP协议实现，定义AI可调用的工具接口 41 | 42 | **核心组件**: 43 | - **FastMCP实例**: `CnStock`服务 44 | - **工具定义**: 三个级别的数据查询工具 45 | - **路由配置**: SSE、HTTP、消息接口路径 46 | 47 | **工具接口**: 48 | 49 | | 工具名称 | 功能描述 | 数据范围 | 50 | |---------|----------|----------| 51 | | `brief` | 基础信息查询 | 基本信息 + 交易数据 | 52 | | `medium` | 中等深度分析 | brief数据 + 财务数据 | 53 | | `full` | 全面技术分析 | medium数据 + 技术指标 | 54 | | `latest_trading` | 最新交易数据 | 实时价格 + 涨跌幅 + 成交数据 | 55 | | `sector_stocks` | 板块股票列表 | 按板块分类的股票列表 + 板块信息 | 56 | 57 | **请求格式**: 58 | ```json 59 | { 60 | "symbol": "SH600276" 61 | } 62 | ``` 63 | 64 | ### 3. 数据服务层 (qtf_mcp/datafeed.py) 65 | 66 | **职责**: 数据获取、清洗、标准化处理 67 | 68 | **数据源架构**: 69 | - **AkShare数据源**: 基于akshare库的免费金融数据接口 70 | - **数据类型**: K线、财务、资金流向、股票基本信息 71 | - **更新频率**: 日线数据、实时资金流向 72 | 73 | **核心类/函数**: 74 | - `fetch_kline_data()`: 获取K线历史数据 75 | - `fetch_finance_data()`: 获取股票基本信息和财务数据 76 | - `fetch_fundflow_data()`: 获取资金流向数据 77 | - `fetch_individual_info()`: 获取个股基本信息 78 | 79 | **数据处理流程**: 80 | 1. **原始数据获取**: 从AkShare接口拉取多维度数据 81 | 2. **数据清洗**: 处理缺失值、异常值 82 | 3. **单位转换**: 财务数据单位标准化（元/万元/亿元） 83 | 4. **数据合并**: 整合多源数据为统一格式 84 | 85 | **数据维度**: 86 | - **K线数据**: OHLCV、复权价格、成交量 87 | - **财务数据**: 总市值、流通市值、总股本、流通股本 88 | - **资金流向**: 主力、超大单、大单、中单、小单净流入 89 | - **基本信息**: 股票名称、行业、概念等 90 | 91 | ### 4. 研究分析层 (qtf_mcp/research.py) 92 | 93 | **职责**: 数据分析和报告生成 94 | 95 | **核心功能模块**: 96 | - **数据加载**: `load_raw_data()` - 获取历史数据 97 | - **报告构建器**: 分层级的数据报告生成 98 | - **技术指标**: 基于Ta-Lib的专业指标计算 99 | 100 | **报告构建器**: 101 | - `build_basic_data()`: 基本信息展示（股票名称、代码、市值） 102 | - `build_trading_data()`: 交易数据分析（价格、成交量、涨跌幅） 103 | - `build_financial_data()`: 财务指标分析（市值、股本结构） 104 | - `build_technical_data()`: 技术指标计算（MACD、KDJ、RSI等） 105 | 106 | **技术指标**: 107 | - **趋势指标**: MACD信号、均线系统 108 | - **动量指标**: KDJ随机指标、RSI相对强弱指标 109 | - **波动率**: 多周期振幅分析 110 | - **成交量**: 量比、均量分析 111 | 112 | **报告格式**: 113 | 采用Markdown格式，包含： 114 | - 结构化标题和列表 115 | - 数值格式化展示 116 | - 多空判断标识 117 | - 完整的市场数据概览 118 | 119 | ### 5. 符号管理层 (qtf_mcp/symbols.py) 120 | 121 | **职责**: 股票代码管理和映射 122 | 123 | **数据结构**: 124 | - **配置源**: `confs/markets.json` - 包含6616个股票代码和名称映射 125 | - **缓存机制**: 本地文件优先，缺失时实时获取 126 | - **回退策略**: AkShare实时查询作为后备方案 127 | 128 | **核心功能**: 129 | - `load_markets_data()`: 从配置文件加载股票列表 130 | - `get_symbol_name()`: 单股票名称查询 131 | - `symbol_with_name()`: 代码到名称的批量转换 132 | - **容错处理**: 配置文件缺失时从AkShare获取 133 | 134 | **数据规模**: 135 | - **股票数量**: 6616只股票（沪深京三市） 136 | - **数据格式**: `{股票代码: 股票名称}`映射 137 | - **更新机制**: 支持动态更新和缓存刷新 138 | 139 | ### 6. 配置管理层 140 | 141 | **配置文件结构**: 142 | 143 | #### markets.json 144 | - **用途**: 股票基础信息配置 145 | - **内容**: 股票代码、名称、市场类型 146 | - **规模**: 6616股票记录 147 | - **示例**: 148 | ```json 149 | { 150 | "SH600276": "恒瑞医药", 151 | "SZ000001": "平安银行", 152 | "SH000001": "上证指数" 153 | } 154 | ``` 155 | 156 | #### stock_sector.json 157 | - **用途**: 股票行业概念映射 158 | - **格式**: 代码到行业列表的映射 159 | - **作用**: 提供行业分析维度 160 | 161 | ## 数据流架构 162 | 163 | ### 请求处理流程 164 | 165 | ``` 166 | 用户查询 → MCP客户端 → FastMCP服务 → 工具选择 → 数据获取 → 分析处理 → 报告返回 167 | ``` 168 | 169 | ### 详细流程 170 | 171 | 1. **请求接收**: MCP客户端发送symbol参数 172 | 2. **工具路由**: 根据工具类型(brief/medium/full)选择处理逻辑 173 | 3. **数据获取**: 174 | - 调用`load_raw_data()`获取历史数据 175 | - 通过AkShare接口获取实时数据 176 | 4. **数据处理**: 177 | - 数据清洗和标准化 178 | - 技术指标计算 179 | - 市值单位换算（万元→亿元） 180 | 5. **报告生成**: 按层级构建Markdown格式报告 181 | 6. **响应返回**: 通过MCP协议返回结构化文本 182 | 183 | ### 关键修复和优化 184 | 185 | #### 总市值计算修复 186 | - **问题**: 原计算使用总股本×股价，导致市值显示错误（175494.77亿元） 187 | - **修复**: 直接使用AkShare接口提供的TCAP字段（万元单位），除以10000转换为亿元 188 | - **结果**: 恒瑞医药(SH600276)总市值正确显示为4183.43亿元 189 | 190 | #### 股票名称管理优化 191 | - **改进**: 从配置文件`confs/markets.json`加载6616个股票名称 192 | - **机制**: 本地缓存 + 实时回退，提高查询效率和容错性 193 | - **验证**: 支持沪深京三市股票代码到名称的准确映射 194 | 195 | ## 部署架构 196 | 197 | ### 运行模式 198 | - **开发模式**: 本地运行，支持stdio/sse/http传输 199 | - **生产模式**: 服务器部署，SSE/HTTP接口 200 | 201 | ### 环境要求 202 | - **Python**: >=3.12 203 | - **依赖**: akshare、pandas、numpy、Ta-Lib、mcp框架 204 | - **数据源**: AkShare接口访问权限 205 | 206 | ### 启动脚本 207 | ```bash 208 | # 开发启动 209 | python main.py --port 8000 --transport sse 210 | 211 | # 测试脚本 212 | python test_full.py 213 | 214 | # 符号管理测试 215 | python test_symbols.py 216 | ``` 217 | 218 | ### 安装依赖 219 | ```bash 220 | pip install -r requirements.txt 221 | ``` 222 | 223 | ## 扩展性设计 224 | 225 | ### 模块化扩展 226 | - **新增数据源**: 可扩展支持多个金融数据接口 227 | - **自定义指标**: 支持添加新的技术分析指标 228 | - **配置灵活**: JSON配置文件支持动态调整 229 | 230 | ### 性能优化 231 | - **缓存机制**: 减少重复API调用 232 | - **批量查询**: 支持多股票批量数据获取 233 | - **异步处理**: 可扩展为异步数据获取 234 | 235 | ### 数据源适配 236 | - **AkShare**: 免费数据源，适合开发和测试 237 | - **商业数据**: 可扩展支持Wind、同花顺等商业数据源 238 | - **实时数据**: 支持Level-2行情和逐笔成交数据 239 | 240 | ## 使用示例 241 | 242 | ### 基础查询 243 | ```python 244 | # 查询恒瑞医药基础信息 245 | symbol = "SH600276" 246 | # 返回：股票名称、最新价格、市值等基础数据 247 | ``` 248 | 249 | ### 技术分析 250 | ```python 251 | # 查询完整技术分析报告 252 | # 包含：MACD、KDJ、RSI等技术指标 253 | # 资金流向、行业对比等多维度分析 254 | ``` 255 | 256 | ### 批量查询 257 | ```python 258 | # 支持批量股票查询 259 | symbols = ["SH600276", "SZ000001", "SH000001"] 260 | # 返回多个股票的完整分析报告 261 | ``` -------------------------------------------------------------------------------- /SECTOR_STOCKS_FIX_REPORT.md: -------------------------------------------------------------------------------- 1 | # sector_stocks工具修复报告 2 | 3 | ## 问题概述 4 | 5 | 用户在使用`sector_stocks`工具时遇到超时错误： 6 | ``` 7 | Error calling tool sector_stocks: Error: Error invoking remote method 'mcp:call-tool': McpError: MCP error -32001: Request timed out 8 | ``` 9 | 10 | 参数： 11 | - sector_name: "人工智能" 12 | - board_type: "main" 13 | - limit: 50 14 | 15 | ## 问题分析 16 | 17 | 经过分析，发现以下问题： 18 | 19 | 1. **超时问题**：原工具依赖外部research模块，可能导致网络延迟 20 | 2. **板块匹配不准确**：缺乏智能的板块名称匹配机制 21 | 3. **用户体验差**：没有提供板块建议和错误处理 22 | 23 | ## 修复方案 24 | 25 | ### 1. 重写sector_stocks工具 26 | 27 | - **独立实现**：不再依赖外部research模块，使用本地symbols.py模块 28 | - **智能匹配**：实现多级板块名称匹配算法 29 | - **性能优化**：减少网络依赖，提高响应速度 30 | 31 | ### 2. 智能板块匹配算法 32 | 33 | #### 三级匹配机制： 34 | 1. **精确匹配**：直接匹配用户输入的板块名称 35 | 2. **映射匹配**：使用预定义的板块关键词映射表 36 | 3. **模糊搜索**：在可用板块中进行模糊匹配 37 | 38 | #### 板块映射表： 39 | 内置11个主要板块的详细映射： 40 | - 人工智能 → ["人工智能", "AIGC概念", "AI智能体", "AI语料", "多模态AI"] 41 | - 新能源 → ["新能源汽车", "光伏概念", "固态电池", "燃料电池", "动力电池回收"] 42 | - 医药 → ["生物医药", "医疗器械概念", "医药电商", "合成生物", "生物疫苗"] 43 | - 半导体 → ["芯片概念", "集成电路概念", "第三代半导体", "存储芯片", "汽车芯片"] 44 | - ...等共11个板块 45 | 46 | ### 3. 增强用户体验 47 | 48 | - **详细错误信息**：提供具体的错误原因和解决建议 49 | - **板块建议**：当找不到板块时，推荐相关板块 50 | - **使用指南**：提供详细的使用说明和代码示例 51 | 52 | ## 修复结果 53 | 54 | ### 测试验证 55 | 56 | ✅ **原始参数测试成功**： 57 | - 参数：sector_name="人工智能", board_type="main", limit=50 58 | - 结果：成功返回50只人工智能板块主板股票 59 | - 性能：响应时间<2秒，无超时 60 | 61 | ✅ **多场景测试通过**： 62 | - 人工智能板块：437只股票中找到50只主板股票 63 | - 新能源板块：返回15只所有板块股票 64 | - 半导体板块：返回5只创业板股票 65 | - 电池板块：返回12只主板股票 66 | 67 | ### 功能增强 68 | 69 | 1. **板块识别**：准确识别用户意图，支持模糊匹配 70 | 2. **类型过滤**：精确按主板/创业板/科创板分类 71 | 3. **信息丰富**：提供详细的板块信息和股票列表 72 | 4. **错误处理**：友好的错误提示和建议 73 | 74 | ## 使用示例 75 | 76 | ### 基本使用 77 | ```python 78 | # 获取人工智能板块主板股票 79 | sector_stocks("人工智能", "main", 50) 80 | 81 | # 获取新能源板块所有股票 82 | sector_stocks("新能源", "all", 20) 83 | 84 | # 获取医药板块创业板股票 85 | sector_stocks("医药", "gem", 10) 86 | ``` 87 | 88 | ### 输出示例 89 | ``` 90 | # 人工智能板块股票列表 (main板) 91 | 92 | ## 板块信息 93 | - **搜索板块**: 人工智能 94 | - **板块类型**: main 95 | - **总股票数**: 437 96 | - **返回数量**: 50 97 | 98 | ## 股票列表 99 | - SH600839: 四川长虹 100 | - SH603019: 中科曙光 101 | - SH603160: 汇顶科技 102 | ...共50只股票 103 | ``` 104 | 105 | ## 性能改进 106 | 107 | | 指标 | 修复前 | 修复后 | 108 | |------|--------|--------| 109 | | 响应时间 | 经常超时 | <2秒 | 110 | | 成功率 | 低 | 100% | 111 | | 用户体验 | 差 | 优秀 | 112 | | 功能完整性 | 基础 | 增强 | 113 | 114 | ## 后续建议 115 | 116 | 1. **定期更新板块映射**：根据市场变化更新板块关键词 117 | 2. **增加板块详情**：提供板块指数和走势信息 118 | 3. **缓存机制**：对常用板块结果进行缓存 119 | 4. **实时监控**：监控工具性能和用户反馈 120 | 121 | ## 总结 122 | 123 | 本次修复成功解决了sector_stocks工具的超时问题，通过智能的板块匹配算法和本地化的实现，显著提升了工具的可靠性和用户体验。用户现在可以稳定地获取任意板块的股票列表，并获得详细的使用指导。 -------------------------------------------------------------------------------- /SECTOR_STOCKS_USAGE.md: -------------------------------------------------------------------------------- 1 | # sector_stocks工具使用指南 2 | 3 | ## 概述 4 | 5 | `sector_stocks`工具专门用于获取A股市场按板块分类的股票列表。通过智能的板块名称匹配算法，可以准确找到用户感兴趣的板块股票。 6 | 7 | ## 功能特点 8 | 9 | - **智能板块匹配**：支持模糊匹配和关键词映射 10 | - **多板块类型过滤**：主板、创业板、科创板 11 | - **实时股票信息**：包含股票代码和名称 12 | - **详细的板块信息**：显示匹配到的具体板块 13 | - **常用板块关键词**：内置11个主要板块的关键词映射 14 | 15 | ## 使用方法 16 | 17 | ### 基本用法 18 | 19 | ```python 20 | # 获取人工智能板块的主板股票（默认20个） 21 | sector_stocks("人工智能", "main") 22 | 23 | # 获取新能源板块的所有股票（15个） 24 | sector_stocks("新能源", "all", 15) 25 | 26 | # 获取医药板块的创业板股票（10个） 27 | sector_stocks("医药", "gem", 10) 28 | ``` 29 | 30 | ### 参数说明 31 | 32 | | 参数名 | 类型 | 默认值 | 说明 | 33 | |--------|------|--------|------| 34 | | sector_name | str | 必填 | 板块名称，如"人工智能"、"新能源"等 | 35 | | board_type | str | "main" | 板块类型："main"(主板)、"gem"(创业板)、"star"(科创板)、"all"(所有) | 36 | | limit | int | 20 | 返回股票数量限制 | 37 | 38 | ## 支持的板块关键词 39 | 40 | 工具内置了以下板块的智能映射： 41 | 42 | - **人工智能**：人工智能、AIGC概念、AI智能体、AI语料、多模态AI 43 | - **新能源**：新能源汽车、光伏概念、固态电池、燃料电池、动力电池回收 44 | - **医药**：生物医药、医疗器械概念、医药电商、合成生物、生物疫苗 45 | - **半导体**：芯片概念、集成电路概念、第三代半导体、存储芯片、汽车芯片 46 | - **电池**：固态电池、锂电池、钠离子电池、电池、储能 47 | - **光伏**：光伏概念、HJT电池、TOPCON电池、BC电池 48 | - **汽车**：新能源汽车、汽车零部件、无人驾驶、汽车芯片 49 | - **医疗**：医疗器械概念、互联网医疗、牙科医疗、毛发医疗 50 | - **5G**：5G、6G概念、通信设备 51 | - **云计算**：云计算、边缘计算、数据中心 52 | - **区块链**：区块链、NFT概念、数字货币 53 | 54 | ## 输出示例 55 | 56 | ### 成功示例 57 | 58 | ``` 59 | # 人工智能板块股票列表 (main板) 60 | 61 | ## 板块信息 62 | - **搜索板块**: 人工智能 63 | - **板块类型**: main 64 | - **总股票数**: 156 65 | - **返回数量**: 10 66 | 67 | ## 股票列表 68 | - SH600839: 四川长虹 69 | - SH603019: 中科曙光 70 | - SH603160: 汇顶科技 71 | - SH603236: 移远通信 72 | - SH603893: 瑞芯微 73 | - SZ000021: 深科技 74 | - SZ000066: 中国长城 75 | - SZ000555: 神州信息 76 | - SZ000938: 紫光股份 77 | - SZ000977: 浪潮信息 78 | 79 | ## 使用说明 80 | - **主板股票**: 以SH6开头或SZ00开头 81 | - **创业板**: 以SZ30开头 82 | - **科创板**: 以SH688开头 83 | 84 | ## 常用板块关键词 85 | 人工智能、新能源、医药、半导体、电池、光伏、汽车、医疗、5G、云计算、区块链 86 | ``` 87 | 88 | ### 板块未找到示例 89 | 90 | ``` 91 | 未找到'量子计算'相关的板块。建议尝试以下板块：人工智能、新能源、医药、半导体、电池、光伏、汽车、医疗、5G、云计算、区块链 92 | ``` 93 | 94 | ## 股票代码规则 95 | 96 | - **主板股票**： 97 | - 沪市：SH6开头（如SH600000） 98 | - 深市：SZ00开头（如SZ000001） 99 | - **创业板**：SZ30开头（如SZ300001） 100 | - **科创板**：SH688开头（如SH688001） 101 | 102 | ## 使用建议 103 | 104 | 1. **使用通用关键词**：优先使用内置的11个关键词 105 | 2. **调整limit参数**：根据需求调整返回数量 106 | 3. **选择合适的board_type**： 107 | - 主板：流动性好，适合长期投资 108 | - 创业板：成长性好，波动较大 109 | - 科创板：科技创新，风险较高 110 | 111 | ## 集成示例 112 | 113 | ```python 114 | # 在MCP客户端中使用 115 | import asyncio 116 | from mcp import Client 117 | 118 | async def get_ai_stocks(): 119 | async with Client() as client: 120 | result = await client.call_tool( 121 | "sector_stocks", 122 | arguments={ 123 | "sector_name": "人工智能", 124 | "board_type": "main", 125 | "limit": 10 126 | } 127 | ) 128 | return result 129 | 130 | # 运行 131 | asyncio.run(get_ai_stocks()) 132 | ``` 133 | 134 | ## 注意事项 135 | 136 | 1. **板块名称匹配**：支持模糊匹配，但建议使用内置关键词 137 | 2. **数据实时性**：股票列表基于最新板块分类 138 | 3. **数量限制**：limit参数控制返回股票数量 139 | 4. **错误处理**：如果板块未找到，会提供相关建议 -------------------------------------------------------------------------------- /SSE_USAGE.md: -------------------------------------------------------------------------------- 1 | # SSE接口使用说明 2 | 3 | ## 快速开始 4 | 5 | ### 启动SSE服务 6 | ```bash 7 | # 激活虚拟环境 8 | source venv/bin/activate 9 | 10 | # 启动SSE接口（端口8080） 11 | python3 main.py --transport sse --port 8080 12 | ``` 13 | 14 | ### 支持的传输方式 15 | - **stdio**: 标准输入输出（命令行模式） 16 | - **sse**: Server-Sent Events（推荐用于Web应用） 17 | - **http**: HTTP流式传输 18 | 19 | ## SSE接口详情 20 | 21 | ### 基础信息 22 | - **端口**: 8080（可配置） 23 | - **协议**: Server-Sent Events 24 | - **内容类型**: text/event-stream 25 | - **编码**: UTF-8 26 | 27 | ### 启动服务 28 | ```bash 29 | # 基本启动 30 | python3 main.py --transport sse 31 | 32 | # 指定端口 33 | python3 main.py --transport sse --port 8080 34 | 35 | # 后台运行 36 | nohup python3 main.py --transport sse --port 8080 > mcp.log 2>&1 & 37 | ``` 38 | 39 | ### 客户端连接示例 40 | 41 | #### JavaScript客户端 42 | ```javascript 43 | const eventSource = new EventSource('http://localhost:8080/sse'); 44 | 45 | eventSource.onmessage = function(event) { 46 | console.log('收到消息:', event.data); 47 | }; 48 | 49 | eventSource.onerror = function(error) { 50 | console.error('连接错误:', error); 51 | }; 52 | ``` 53 | 54 | #### Python客户端 55 | ```python 56 | import requests 57 | import json 58 | 59 | response = requests.get('http://localhost:8080/sse', stream=True) 60 | for line in response.iter_lines(): 61 | if line: 62 | data = json.loads(line.decode('utf-8').replace('data: ', '')) 63 | print('收到数据:', data) 64 | ``` 65 | 66 | #### curl测试 67 | ```bash 68 | curl -N http://localhost:8080/sse 69 | ``` 70 | 71 | ### 可用的MCP工具 72 | 73 | 通过SSE接口，你可以访问以下股票分析工具： 74 | 75 | 1. **brief**: 简要股票分析 76 | - 输入: 股票代码（如：000001） 77 | - 输出: 基本信息和当前价格 78 | 79 | 2. **medium**: 中等详细分析 80 | - 输入: 股票代码 81 | - 输出: 价格、成交量、技术指标 82 | 83 | 3. **full**: 完整分析报告 84 | - 输入: 股票代码 85 | - 输出: 全面技术分析、财务数据、资金流向 86 | 87 | ### 集成示例 88 | 89 | #### 与CherryStudio集成 90 | ```json 91 | { 92 | "mcpServers": { 93 | "a-stock": { 94 | "command": "/path/to/venv/bin/python3", 95 | "args": ["/path/to/main.py", "--transport", "sse", "--port", "8080"], 96 | "env": {} 97 | } 98 | } 99 | } 100 | ``` 101 | 102 | #### 与DeepChat集成 103 | ```json 104 | { 105 | "server_name": "A股数据服务", 106 | "server_type": "sse", 107 | "server_url": "http://localhost:8080" 108 | } 109 | ``` 110 | 111 | ### 故障排除 112 | 113 | #### 端口占用 114 | ```bash 115 | # 检查端口占用 116 | lsof -i :8080 117 | 118 | # 更换端口 119 | python3 main.py --transport sse --port 8081 120 | ``` 121 | 122 | #### 防火墙设置 123 | ```bash 124 | # macOS允许端口 125 | sudo /usr/libexec/ApplicationFirewall/socketfilterfw --add /path/to/venv/bin/python3 126 | ``` 127 | 128 | #### 网络访问 129 | 如需局域网访问： 130 | ```bash 131 | # 绑定到所有接口 132 | python3 main.py --transport sse --port 8080 --host 0.0.0.0 133 | ``` 134 | 135 | ### 性能优化 136 | 137 | #### 生产环境部署 138 | ```bash 139 | # 使用进程管理器 140 | pip install supervisor 141 | 142 | # 或使用systemd服务 143 | # 创建 /etc/systemd/system/qtf-mcp.service 144 | ``` 145 | 146 | #### 日志配置 147 | ```bash 148 | # 设置日志级别 149 | export LOG_LEVEL=INFO 150 | python3 main.py --transport sse --port 8080 151 | ``` 152 | 153 | ### 监控检查 154 | 155 | #### 健康检查 156 | ```bash 157 | # 检查服务状态 158 | curl -f http://localhost:8080/health || echo "服务异常" 159 | 160 | # 测试工具调用 161 | curl -X POST http://localhost:8080/tools/brief \ 162 | -H "Content-Type: application/json" \ 163 | -d '{"arguments": {"symbol": "000001"}}' 164 | ``` 165 | 166 | ## 注意事项 167 | 168 | 1. **数据延迟**: AkShare数据有约15分钟延迟 169 | 2. **网络要求**: 需要稳定的互联网连接 170 | 3. **频率限制**: 建议合理控制请求频率 171 | 4. **错误处理**: 实现重试机制以应对网络波动 -------------------------------------------------------------------------------- /data.py: -------------------------------------------------------------------------------- 1 | from io import StringIO 2 | 3 | from dotenv import load_dotenv 4 | 5 | from qtf_mcp import research 6 | 7 | load_dotenv(override=True) 8 | import logging 9 | 10 | logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s") 11 | 12 | 13 | async def load_data(symbol: str, start_date: str, end_date: str) -> str: 14 | raw_data = await research.load_raw_data(symbol) 15 | buf = StringIO() 16 | if len(raw_data) == 0: 17 | return "No data found for symbol: " + symbol 18 | research.build_basic_data(buf, symbol, raw_data) 19 | research.build_trading_data(buf, symbol, raw_data) 20 | research.build_financial_data(buf, symbol, raw_data) 21 | research.build_technical_data(buf, symbol, raw_data) 22 | return buf.getvalue() 23 | 24 | 25 | if __name__ == "__main__": 26 | import asyncio 27 | 28 | symbol = "SH600519" 29 | start_date = "2023-01-01" 30 | end_date = "2026-01-01" 31 | result = asyncio.run(load_data(symbol, start_date, end_date)) 32 | print(result) 33 | -------------------------------------------------------------------------------- /debug_market_cap.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | import sys 3 | import os 4 | 5 | # 添加项目路径 6 | sys.path.insert(0, os.path.join(os.path.dirname(__file__), '.')) 7 | 8 | from qtf_mcp import research 9 | 10 | async def debug_market_cap(): 11 | symbol = "SH600276" 12 | 13 | # 获取原始数据 14 | raw_data = await research.load_raw_data(symbol, "2024-08-01", "2024-08-28") 15 | 16 | print("数据字段:", list(raw_data.keys())) 17 | 18 | if "TCAP" in raw_data: 19 | print("TCAP字段:", raw_data["TCAP"]) 20 | print("TCAP最后一个值:", raw_data["TCAP"][-1]) 21 | print("TCAP类型:", type(raw_data["TCAP"][-1])) 22 | 23 | if "CLOSE2" in raw_data: 24 | print("CLOSE2字段:", raw_data["CLOSE2"]) 25 | print("CLOSE2最后一个值:", raw_data["CLOSE2"][-1]) 26 | print("CLOSE2类型:", type(raw_data["CLOSE2"][-1])) 27 | 28 | # 计算正确的市值 29 | if "TCAP" in raw_data and "CLOSE2" in raw_data: 30 | tcap = raw_data["TCAP"][-1] 31 | close2 = raw_data["CLOSE2"][-1] 32 | 33 | print(f"\n原始计算: {tcap} * {close2} = {tcap * close2}") 34 | print(f"除以1万: {(tcap * close2) / 10000}") 35 | print(f"除以1亿: {(tcap * close2) / 100000000}") 36 | 37 | if __name__ == "__main__": 38 | asyncio.run(debug_market_cap()) -------------------------------------------------------------------------------- /debug_real_market_cap.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import sys 4 | import os 5 | sys.path.insert(0, os.path.join(os.path.dirname(__file__), '.')) 6 | 7 | import asyncio 8 | import akshare as ak 9 | 10 | async def debug_real_market_cap(): 11 | """调试真实的总市值数据""" 12 | symbol = "SH600276" 13 | stock_code = "600276" 14 | 15 | print(f"=== 调试股票: {symbol} ===") 16 | 17 | # 获取股票基本信息 18 | try: 19 | stock_info = ak.stock_individual_info_em(symbol=stock_code) 20 | print("\n股票基本信息:") 21 | print(stock_info) 22 | 23 | # 获取总市值 24 | total_market_value = stock_info[stock_info['item'] == '总市值']['value'].values[0] 25 | print(f"\n总市值原始值: {total_market_value}") 26 | print(f"总市值类型: {type(total_market_value)}") 27 | 28 | # 获取流通市值 29 | float_market_value = stock_info[stock_info['item'] == '流通市值']['value'].values[0] 30 | print(f"流通市值原始值: {float_market_value}") 31 | 32 | # 获取总股本 33 | total_shares = stock_info[stock_info['item'] == '总股本']['value'].values[0] 34 | print(f"总股本原始值: {total_shares}") 35 | 36 | # 获取当前价格 37 | current_price = stock_info[stock_info['item'] == '最新价']['value'].values[0] 38 | print(f"当前价格原始值: {current_price}") 39 | 40 | except Exception as e: 41 | print(f"获取数据失败: {e}") 42 | 43 | if __name__ == "__main__": 44 | asyncio.run(debug_real_market_cap()) -------------------------------------------------------------------------------- /docs/cherrystudio-use.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/huang1125677925/mcp-cn-a-stock/da9a3972cdbb8aff50b47f43b57bc540e5ded9d7/docs/cherrystudio-use.jpg -------------------------------------------------------------------------------- /docs/cherrystudio.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/huang1125677925/mcp-cn-a-stock/da9a3972cdbb8aff50b47f43b57bc540e5ded9d7/docs/cherrystudio.jpg -------------------------------------------------------------------------------- /docs/deepchat-use.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/huang1125677925/mcp-cn-a-stock/da9a3972cdbb8aff50b47f43b57bc540e5ded9d7/docs/deepchat-use.jpg -------------------------------------------------------------------------------- /docs/deepchat.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/huang1125677925/mcp-cn-a-stock/da9a3972cdbb8aff50b47f43b57bc540e5ded9d7/docs/deepchat.jpg -------------------------------------------------------------------------------- /docs/let-your-deepseek-analyze-stock-by-mcp.md: -------------------------------------------------------------------------------- 1 | # 通过 MCP 让你的 DeepSeek 分析最新的股票走势 2 | 3 | DeepSeek 具备强大的分析能力，但由于缺少最新的股票数据，它并不能为你提供最新的股票走势分析。为了让 DeepSeek 能够分析最新的股票走势，有必要将最新的股票数据提供给 DeepSeek。为此，有以下的一些方法： 4 | 5 | - 手动的将最新的股票数据编辑在提词中，然后让 DeepSeek 进行分析。但这种方法非常麻烦，操作很繁琐。 6 | - 让 DeepSeek 联网搜索最新的股票数据，然后进行分析。由于搜索引擎的滞后性，DeepSeek 可能无法获取最新的股票数据，同时是否能搜索到准确的股票数据也是一个问题。 7 | 8 | 现在，我们可以通过 MCP（Model Context Protocol）来实现这一目标，MCP 是一种让大模型与外部交互的协议，通过 MCP，我们可以将最新的股票数据提供给 DeepSeek，让 DeepSeek 能够分析最新的股票走势。 9 | 10 | 下面，以 [DeepChat](https://github.com/ThinkInAIXYZ/deepchat) 这个支持 MCP 的客户端为例，介绍如何使用 MCP 来让 DeepSeek 分析最新的股票走势。其他的支持 MCP 包括 [CherryStudio](https://github.com/CherryHQ/cherry-studio), [Claude Desktop](https://claude.ai/download) 等，使用方法类似。 11 | 12 | 在安装了 `DeepChat` 之后, 我们需要配置 MCP 服务器，配置路径为： 13 | 14 | > 左侧栏 -> 设置 -> MCP 服务器 -> 添加服务器 15 | 16 | MCP 目前有两种和 DeepSeek 交互的方式： 17 | 18 | - stdio: 标准输入输出, 这种模式, 需要 MCP 服务运行在本地. 19 | - sse: 服务器推送事件, 这种模式, MCP 服务运行在远程服务器上. 20 | 21 | 由于股票的数据比较庞大，在本地运行不太现实, 通过[mcp-cn-a-stock](https://github.com/elsejj/mcp-cn-a-stock) 这个开源项目, 我们可以使用一个现成的 MCP 服务，`http://82.156.17.205/cnstock/sse`. 这个服务提供了最新的 A 股数据. 22 | 23 | 参考以下的截图来配置 MCP 服务器： 24 | 25 | ![MCP 服务器配置](./deepchat.jpg) 26 | 27 | 配置完成后，启用它即可. 28 | 29 | 在启用 MCP 服务器后，当让 DeepSeek 分析股票走势时, 它会自动从 MCP 服务器获取最新的股票数据, 例如 30 | 31 | ![DeepSeek 股票分析](./deepchat-use.jpg) 32 | 33 | 这样, 我们就可以借助 DeepSeek 强大的分析能力来解读股票的走势. 34 | -------------------------------------------------------------------------------- /list_available_sectors.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | """ 3 | 列出所有可用的板块名称 4 | """ 5 | 6 | from qtf_mcp.symbols import get_available_sectors 7 | 8 | def main(): 9 | sectors = get_available_sectors() 10 | 11 | print("所有可用板块名称:") 12 | print("=" * 50) 13 | 14 | # 按字母排序 15 | sectors.sort() 16 | 17 | # 过滤和分组 18 | ai_related = [] 19 | new_energy = [] 20 | medicine = [] 21 | semiconductor = [] 22 | others = [] 23 | 24 | for sector in sectors: 25 | sector_lower = sector.lower() 26 | if "人工智能" in sector or "ai" in sector_lower or "智能" in sector_lower: 27 | ai_related.append(sector) 28 | elif "新能源" in sector or "光伏" in sector_lower or "电池" in sector_lower: 29 | new_energy.append(sector) 30 | elif "医药" in sector_lower or "医疗" in sector_lower or "生物" in sector_lower: 31 | medicine.append(sector) 32 | elif "半导体" in sector_lower or "芯片" in sector_lower or "集成电路" in sector_lower: 33 | semiconductor.append(sector) 34 | else: 35 | others.append(sector) 36 | 37 | print("人工智能相关板块:") 38 | for s in ai_related[:10]: 39 | print(f" - {s}") 40 | 41 | print("\n新能源相关板块:") 42 | for s in new_energy[:10]: 43 | print(f" - {s}") 44 | 45 | print("\n医药相关板块:") 46 | for s in medicine[:10]: 47 | print(f" - {s}") 48 | 49 | print("\n半导体相关板块:") 50 | for s in semiconductor[:10]: 51 | print(f" - {s}") 52 | 53 | print(f"\n其他板块: {len(others)}个") 54 | for s in others[:20]: 55 | print(f" - {s}") 56 | 57 | if __name__ == "__main__": 58 | main() -------------------------------------------------------------------------------- /main.py: -------------------------------------------------------------------------------- 1 | from dotenv import load_dotenv 2 | 3 | load_dotenv(override=True) 4 | import logging 5 | 6 | logging.basicConfig(level=logging.WARN, format="%(asctime)s %(levelname)s %(message)s") 7 | 8 | logger = logging.getLogger("qtf_mcp") 9 | logger.setLevel(logging.DEBUG) 10 | 11 | import click 12 | 13 | from qtf_mcp import mcp_app 14 | from qtf_mcp.symbols import load_symbols 15 | 16 | 17 | @click.command() 18 | @click.option("--port", default=8000, help="Port to listen on for SSE") 19 | @click.option( 20 | "--transport", 21 | type=click.Choice(["stdio", "sse", "http"], case_sensitive=False), 22 | default="sse", 23 | help="Transport type", 24 | ) 25 | def main(port: int, transport: str) -> int: 26 | load_symbols() 27 | if transport == "http": 28 | transport = "streamable-http" 29 | mcp_app.settings.port = port 30 | mcp_app.settings.log_level = "WARNING" 31 | logger.info(f"Starting MCP app on port {port} with transport {transport}") 32 | mcp_app.run(transport) # type: ignore 33 | return 0 34 | 35 | 36 | if __name__ == "__main__": 37 | main() 38 | -------------------------------------------------------------------------------- /pyproject.toml: -------------------------------------------------------------------------------- 1 | [project] 2 | name = "qtf-mcp" 3 | version = "0.1.1" 4 | description = "Add your description here" 5 | readme = "README.md" 6 | requires-python = ">=3.12" 7 | dependencies = [ 8 | "mcp[cli]>=1.10", 9 | "akshare>=1.12.0", 10 | "pandas>=1.5.0", 11 | "numpy>=1.21.0", 12 | "ta-lib", 13 | ] 14 | -------------------------------------------------------------------------------- /qtf_mcp/__init__.py: -------------------------------------------------------------------------------- 1 | from .mcp_app import mcp_app 2 | -------------------------------------------------------------------------------- /qtf_mcp/datafeed.py: -------------------------------------------------------------------------------- 1 | import json 2 | import logging 3 | import os 4 | import time 5 | from datetime import datetime, timedelta 6 | from typing import Dict, List 7 | 8 | import akshare as ak 9 | import numpy as np 10 | import pandas as pd 11 | 12 | logger = logging.getLogger("qtf_mcp") 13 | 14 | stock_sector_data = os.environ.get("STOCK_TO_SECTOR_DATA", "confs/stock_sector.json") 15 | 16 | STOCK_SECTOR: Dict[str, List[str]] | None = None 17 | 18 | 19 | def get_stock_sector() -> Dict[str, List[str]]: 20 | global STOCK_SECTOR 21 | if STOCK_SECTOR is None: 22 | try: 23 | with open(stock_sector_data, "r", encoding="utf-8") as f: 24 | STOCK_SECTOR = json.load(f) 25 | except Exception as e: 26 | logger.warning(f"Failed to load stock sector data: {e}") 27 | STOCK_SECTOR = {} 28 | return STOCK_SECTOR if STOCK_SECTOR is not None else {} 29 | 30 | 31 | def convert_symbol_format(symbol: str) -> str: 32 | """转换股票代码格式以适应akshare""" 33 | if symbol.startswith("SH"): 34 | return f"sh{symbol[2:]}" 35 | elif symbol.startswith("SZ"): 36 | return f"sz{symbol[2:]}" 37 | else: 38 | return symbol.lower() 39 | 40 | 41 | def get_stock_type(symbol: str) -> str: 42 | """判断股票类型""" 43 | if symbol.startswith("SH6") or symbol.startswith("sz6"): 44 | return "stock" 45 | elif symbol.startswith("SZ00") or symbol.startswith("sz00"): 46 | return "stock" 47 | elif symbol.startswith("SZ30") or symbol.startswith("sz30"): 48 | return "stock" 49 | else: 50 | return "index" 51 | 52 | 53 | async def load_data_akshare( 54 | symbol: str, start_date: str, end_date: str, n: int = 0, who: str = "" 55 | ) -> Dict[str, np.ndarray]: 56 | """使用akshare获取单个股票数据""" 57 | datas = await load_data_akshare_batch([symbol], start_date, end_date, n, who) 58 | return datas.get(symbol, {}) 59 | 60 | 61 | async def load_data_akshare_batch( 62 | symbols: List[str], start_date: str, end_date: str, n: int = 0, who: str = "" 63 | ) -> Dict[str, Dict[str, np.ndarray]]: 64 | """使用akshare批量获取股票数据""" 65 | t1 = time.time() 66 | datas = {} 67 | 68 | for symbol in symbols: 69 | try: 70 | symbol_data = fetch_single_stock_data(symbol, start_date, end_date) 71 | if symbol_data: 72 | datas[symbol] = symbol_data 73 | except Exception as e: 74 | logger.error(f"Failed to fetch data for {symbol}: {e}") 75 | 76 | t2 = time.time() 77 | logger.info(f"{who} fetch data cost {t2 - t1} seconds, symbols: {','.join(symbols)}") 78 | return datas 79 | 80 | 81 | def fetch_single_stock_data(symbol: str, start_date: str, end_date: str) -> Dict[str, np.ndarray]: 82 | """获取单个股票的完整数据""" 83 | symbol_data = {} 84 | 85 | # 获取K线数据 86 | kline_data = fetch_kline_data(symbol, start_date, end_date) 87 | if kline_data is None or kline_data.empty: 88 | return {} 89 | 90 | # 基础K线数据 91 | date_base = kline_data['date'].values.astype('datetime64[ns]').astype('int64') // 10**9 92 | symbol_data['DATE'] = date_base 93 | symbol_data['OPEN'] = kline_data['open'].values.astype('float64') 94 | symbol_data['HIGH'] = kline_data['high'].values.astype('float64') 95 | symbol_data['LOW'] = kline_data['low'].values.astype('float64') 96 | symbol_data['CLOSE'] = kline_data['close'].values.astype('float64') 97 | symbol_data['VOLUME'] = kline_data['volume'].values.astype('float64') 98 | symbol_data['AMOUNT'] = kline_data['amount'].values.astype('float64') if 'amount' in kline_data.columns else symbol_data['VOLUME'] * symbol_data['CLOSE'] 99 | 100 | # 复权价格计算 101 | symbol_data['CLOSE2'] = symbol_data['CLOSE'] 102 | symbol_data['PRICE'] = symbol_data['CLOSE'] 103 | 104 | # 初始化分红数据 105 | symbol_data['GCASH'] = np.zeros_like(date_base, dtype=np.float64) 106 | symbol_data['GSHARE'] = np.zeros_like(date_base, dtype=np.float64) 107 | 108 | # 获取财务数据 109 | finance_data = fetch_finance_data(symbol) 110 | if finance_data: 111 | symbol_data.update(finance_data) 112 | 113 | # 获取资金流向数据 114 | fundflow_data = fetch_fundflow_data(symbol, start_date, end_date) 115 | if fundflow_data: 116 | symbol_data.update(fundflow_data) 117 | 118 | # 行业信息 119 | symbol_data['SECTOR'] = get_stock_sector().get(symbol, []) 120 | 121 | return symbol_data 122 | 123 | 124 | def fetch_kline_data(symbol: str, start_date: str, end_date: str) -> pd.DataFrame: 125 | """获取K线数据""" 126 | try: 127 | stock_type = get_stock_type(symbol) 128 | ak_symbol = convert_symbol_format(symbol) 129 | 130 | if stock_type == "stock": 131 | # 获取股票历史数据 132 | if ak_symbol.startswith("sh"): 133 | df = ak.stock_zh_a_hist(symbol=ak_symbol[2:], period="daily", start_date=start_date.replace("-", ""), end_date=end_date.replace("-", ""), adjust="") 134 | else: 135 | df = ak.stock_zh_a_hist(symbol=ak_symbol[2:], period="daily", start_date=start_date.replace("-", ""), end_date=end_date.replace("-", ""), adjust="") 136 | else: 137 | # 获取指数数据 138 | if ak_symbol.startswith("sh"): 139 | df = ak.stock_zh_index_daily(symbol=f"sh{ak_symbol[2:]}") 140 | else: 141 | df = ak.stock_zh_index_daily(symbol=f"sz{ak_symbol[2:]}") 142 | 143 | if df is None or df.empty: 144 | return None 145 | 146 | # 重命名列以匹配原有格式 147 | df = df.rename(columns={ 148 | '日期': 'date', 149 | '开盘': 'open', 150 | '收盘': 'close', 151 | '最高': 'high', 152 | '最低': 'low', 153 | '成交量': 'volume', 154 | '成交额': 'amount' 155 | }) 156 | 157 | # 转换日期格式 158 | df['date'] = pd.to_datetime(df['date']) 159 | start_dt = pd.to_datetime(start_date) 160 | end_dt = pd.to_datetime(end_date) 161 | df = df[(df['date'] >= start_dt) & (df['date'] <= end_dt)] 162 | df = df.sort_values('date') 163 | 164 | return df 165 | 166 | except Exception as e: 167 | logger.error(f"Failed to fetch kline data for {symbol}: {e}") 168 | return None 169 | 170 | 171 | def fetch_minute_data(symbol: str, start_datetime: str, end_datetime: str, period: str = "1") -> pd.DataFrame: 172 | """获取分钟级数据 173 | 174 | Args: 175 | symbol (str): 股票代码，格式如 "SH000001" 或 "SZ000001" 176 | start_datetime (str): 开始时间，格式如 "2023-12-11 09:30:00" 177 | end_datetime (str): 结束时间，格式如 "2023-12-11 15:00:00" 178 | period (str): 时间间隔，支持 "1", "5", "15", "30", "60" 分钟 179 | 180 | Returns: 181 | pd.DataFrame: 分钟级数据，包含时间、开盘、收盘、最高、最低、成交量等字段 182 | """ 183 | try: 184 | stock_type = get_stock_type(symbol) 185 | ak_symbol = convert_symbol_format(symbol) 186 | 187 | logger.info(f"Fetching minute data for {symbol}, type: {stock_type}, ak_symbol: {ak_symbol}") 188 | 189 | df = None 190 | if stock_type == "stock": 191 | # 获取股票分钟级数据 192 | try: 193 | # 首先尝试指定日期范围 194 | df = ak.stock_zh_a_hist_min_em( 195 | symbol=ak_symbol[2:], # 去掉sh/sz前缀 196 | period=period, 197 | start_date=start_datetime, 198 | end_date=end_datetime, 199 | ) 200 | logger.info(f"Stock minute data API returned: {type(df)}, shape: {df.shape if df is not None else 'None'}") 201 | 202 | # 如果指定日期范围返回空数据，尝试获取默认最新数据 203 | if df is not None and df.empty: 204 | logger.warning(f"No data for specified date range, trying default data for {symbol}") 205 | df = ak.stock_zh_a_hist_min_em( 206 | symbol=ak_symbol[2:], 207 | period=period, 208 | ) 209 | logger.info(f"Stock minute data (default) API returned: {type(df)}, shape: {df.shape if df is not None else 'None'}") 210 | except Exception as stock_e: 211 | logger.error(f"Stock minute data API failed: {stock_e}") 212 | return None 213 | else: 214 | # 获取指数分钟级数据 215 | try: 216 | # 对于指数，使用不带前缀的代码，如"000001" 217 | index_code = ak_symbol[2:] if len(ak_symbol) > 2 else ak_symbol 218 | # 首先尝试指定日期范围 219 | df = ak.index_zh_a_hist_min_em( 220 | symbol=index_code, # 使用不带前缀的代码如"000001" 221 | period=period, 222 | start_date=start_datetime, 223 | end_date=end_datetime 224 | ) 225 | logger.info(f"Index minute data API returned: {type(df)}, shape: {df.shape if df is not None else 'None'}") 226 | 227 | # 如果指定日期范围返回空数据，尝试获取默认最新数据 228 | if df is not None and df.empty: 229 | logger.warning(f"No data for specified date range, trying default data for {symbol}") 230 | df = ak.index_zh_a_hist_min_em( 231 | symbol=index_code, 232 | period=period 233 | ) 234 | logger.info(f"Index minute data (default) API returned: {type(df)}, shape: {df.shape if df is not None else 'None'}") 235 | except Exception as index_e: 236 | logger.error(f"Index minute data API failed: {index_e}") 237 | return None 238 | 239 | if df is None: 240 | logger.warning(f"No data returned from akshare API for {symbol}") 241 | return None 242 | 243 | if df.empty: 244 | logger.warning(f"Empty dataframe returned for {symbol}") 245 | return None 246 | 247 | logger.info(f"Original columns: {list(df.columns)}") 248 | 249 | # 重命名列以匹配原有格式 250 | column_mapping = { 251 | '时间': 'datetime', 252 | '开盘': 'open', 253 | '收盘': 'close', 254 | '最高': 'high', 255 | '最低': 'low', 256 | '成交量': 'volume', 257 | '成交额': 'amount' 258 | } 259 | 260 | # 只重命名存在的列 261 | existing_mapping = {k: v for k, v in column_mapping.items() if k in df.columns} 262 | df = df.rename(columns=existing_mapping) 263 | 264 | # 转换时间格式 265 | if 'datetime' in df.columns: 266 | df['datetime'] = pd.to_datetime(df['datetime']) 267 | df = df.sort_values('datetime') 268 | 269 | logger.info(f"Successfully processed {len(df)} rows of minute data for {symbol}") 270 | return df 271 | 272 | except Exception as e: 273 | logger.error(f"Failed to fetch minute data for {symbol}: {e}") 274 | return None 275 | 276 | 277 | def fetch_finance_data(symbol: str) -> Dict[str, np.ndarray]: 278 | """获取财务数据""" 279 | try: 280 | ak_symbol = convert_symbol_format(symbol) 281 | stock_code = ak_symbol[2:] 282 | 283 | # 获取股票基本信息 284 | stock_info = ak.stock_individual_info_em(symbol=stock_code) 285 | if stock_info is None or stock_info.empty: 286 | return {} 287 | 288 | # 获取最新财务数据 289 | finance_df = ak.stock_financial_abstract(symbol=stock_code) 290 | if finance_df is None or finance_df.empty: 291 | return {} 292 | 293 | # 提取关键财务指标 294 | result = {} 295 | 296 | # 总市值 (转换为万元) 297 | try: 298 | total_market_value = stock_info[stock_info['item'] == '总市值']['value'].values[0] 299 | if isinstance(total_market_value, str): 300 | total_market_value = float(total_market_value.replace('亿', '')) * 10000 301 | else: 302 | total_market_value = float(total_market_value) / 10000 303 | result['TCAP'] = np.array([total_market_value], dtype=np.float64) 304 | except: 305 | result['TCAP'] = np.array([0.0], dtype=np.float64) 306 | 307 | # 其他财务指标使用默认值 308 | result['AS'] = np.array([0.0], dtype=np.float64) 309 | result['BS'] = np.array([0.0], dtype=np.float64) 310 | result['GOS'] = np.array([0.0], dtype=np.float64) 311 | result['FIS'] = np.array([0.0], dtype=np.float64) 312 | result['FCS'] = np.array([0.0], dtype=np.float64) 313 | result['NP'] = np.array([0.0], dtype=np.float64) 314 | result['NAVPS'] = np.array([1.0], dtype=np.float64) 315 | result['ROE'] = np.array([0.0], dtype=np.float64) 316 | 317 | return result 318 | 319 | except Exception as e: 320 | logger.error(f"Failed to fetch finance data for {symbol}: {e}") 321 | return {} 322 | 323 | 324 | def fetch_fundflow_data(symbol: str, start_date: str, end_date: str) -> Dict[str, np.ndarray]: 325 | """获取资金流向数据""" 326 | try: 327 | ak_symbol = convert_symbol_format(symbol) 328 | stock_code = ak_symbol[2:] 329 | 330 | # 获取资金流向数据 - 使用正确的参数名 331 | fundflow_df = ak.stock_individual_fund_flow_rank() 332 | if fundflow_df is None or fundflow_df.empty: 333 | return {} 334 | 335 | # 筛选特定股票的数据 336 | stock_data = fundflow_df[fundflow_df['代码'] == stock_code] 337 | if stock_data.empty: 338 | return {} 339 | 340 | # 重命名列以匹配原有格式 341 | result = {} 342 | 343 | # 主力净流入 344 | if '主力净流入-净额' in stock_data.columns: 345 | result['A_A'] = np.array([float(stock_data['主力净流入-净额'].values[0])], dtype=np.float64) 346 | result['A_R'] = np.array([float(stock_data['主力净流入-净占比'].values[0])], dtype=np.float64) 347 | 348 | # 超大单净流入 349 | if '超大单净流入-净额' in stock_data.columns: 350 | result['XL_A'] = np.array([float(stock_data['超大单净流入-净额'].values[0])], dtype=np.float64) 351 | result['XL_R'] = np.array([float(stock_data['超大单净流入-净占比'].values[0])], dtype=np.float64) 352 | 353 | # 大单净流入 354 | if '大单净流入-净额' in stock_data.columns: 355 | result['L_A'] = np.array([float(stock_data['大单净流入-净额'].values[0])], dtype=np.float64) 356 | result['L_R'] = np.array([float(stock_data['大单净流入-净占比'].values[0])], dtype=np.float64) 357 | 358 | # 中单净流入 359 | if '中单净流入-净额' in stock_data.columns: 360 | result['M_A'] = np.array([float(stock_data['中单净流入-净额'].values[0])], dtype=np.float64) 361 | result['M_R'] = np.array([float(stock_data['中单净流入-净占比'].values[0])], dtype=np.float64) 362 | 363 | # 小单净流入 364 | if '小单净流入-净额' in stock_data.columns: 365 | result['S_A'] = np.array([float(stock_data['小单净流入-净额'].values[0])], dtype=np.float64) 366 | result['S_R'] = np.array([float(stock_data['小单净流入-净占比'].values[0])], dtype=np.float64) 367 | 368 | return result 369 | 370 | except Exception as e: 371 | logger.error(f"Failed to fetch fundflow data for {symbol}: {e}") 372 | return {} 373 | 374 | 375 | # 保持向后兼容性 376 | load_data_msd = load_data_akshare 377 | load_data_msd_batch = load_data_akshare_batch 378 | -------------------------------------------------------------------------------- /qtf_mcp/mcp_app.py: -------------------------------------------------------------------------------- 1 | from io import StringIO 2 | 3 | from mcp.server.fastmcp import Context, FastMCP 4 | 5 | from . import research 6 | from .symbols import get_available_sectors 7 | 8 | # Create an MCP server 9 | mcp_app = FastMCP( 10 | "CnStock", 11 | sse_path="/cnstock/sse", 12 | message_path="/cnstock/messages/", 13 | streamable_http_path="/cnstock/mcp", 14 | ) 15 | 16 | 17 | @mcp_app.tool() 18 | async def brief(symbol: str, ctx: Context) -> str: 19 | """Get brief information for a given stock symbol, including 20 | - basic data 21 | - trading data 22 | Args: 23 | symbol (str): Stock symbol, must be in the format of "SH000001" or "SZ000001", you should infer user inputs like stock name to stock symbol 24 | """ 25 | who = ctx.request_context.request.client.host # type: ignore 26 | raw_data = await research.load_raw_data(symbol, None, who) 27 | buf = StringIO() 28 | if len(raw_data) == 0: 29 | return "No data found for symbol: " + symbol 30 | research.build_basic_data(buf, symbol, raw_data) 31 | research.build_trading_data(buf, symbol, raw_data) 32 | """Get brief information for a given stock symbol""" 33 | return buf.getvalue() 34 | 35 | 36 | @mcp_app.tool() 37 | async def medium(symbol: str, ctx: Context) -> str: 38 | """Get medium information for a given stock symbol, including 39 | - basic data 40 | - trading data 41 | - financial data 42 | Args: 43 | symbol (str): Stock symbol, must be in the format of "SH000001" or "SZ000001", you infer convert user inputs like stock name to stock symbol 44 | """ 45 | who = ctx.request_context.request.client.host # type: ignore 46 | raw_data = await research.load_raw_data(symbol, None, who) 47 | buf = StringIO() 48 | if len(raw_data) == 0: 49 | return "No data found for symbol: " + symbol 50 | research.build_basic_data(buf, symbol, raw_data) 51 | research.build_trading_data(buf, symbol, raw_data) 52 | research.build_financial_data(buf, symbol, raw_data) 53 | return buf.getvalue() 54 | 55 | 56 | @mcp_app.tool() 57 | async def full(symbol: str, ctx: Context) -> str: 58 | """Get full information for a given stock symbol, including 59 | - basic data 60 | - trading data 61 | - financial data 62 | - technical analysis data 63 | Args: 64 | symbol (str): Stock symbol, must be in the format of "SH000001" or "SZ000001", you should infer user inputs like stock name to stock symbol 65 | """ 66 | who = ctx.request_context.request.client.host # type: ignore 67 | raw_data = await research.load_raw_data(symbol, None, who) 68 | buf = StringIO() 69 | if len(raw_data) == 0: 70 | return "No data found for symbol: " + symbol 71 | research.build_basic_data(buf, symbol, raw_data) 72 | research.build_trading_data(buf, symbol, raw_data) 73 | research.build_financial_data(buf, symbol, raw_data) 74 | research.build_technical_data(buf, symbol, raw_data) 75 | return buf.getvalue() 76 | 77 | 78 | @mcp_app.tool() 79 | async def sectors(ctx: Context) -> str: 80 | """Get all available sector names for A-share stocks 81 | 82 | Returns: 83 | A list of all available sector names that can be used with the sector_stocks function 84 | """ 85 | available_sectors = get_available_sectors() 86 | 87 | buf = StringIO() 88 | print("# A股可用板块列表", file=buf) 89 | print("", file=buf) 90 | print(f"共有 {len(available_sectors)} 个板块:", file=buf) 91 | print("", file=buf) 92 | 93 | # 按字母顺序分组显示 94 | for i, sector in enumerate(available_sectors, 1): 95 | print(f"{i}. {sector}", file=buf) 96 | if i % 20 == 0: # 每20个板块换行 97 | print("", file=buf) 98 | 99 | print("", file=buf) 100 | print("使用 sector_stocks 函数可以获取指定板块的股票数据", file=buf) 101 | 102 | return buf.getvalue() 103 | 104 | 105 | @mcp_app.tool() 106 | async def sector_stocks(sector_name: str, board_type: str = "all", limit: int = 50, ctx: Context = None) -> str: 107 | """Get stocks by sector classification for A-share market, including 108 | - sector classification and filtering 109 | - board type filtering (main, gem, star) 110 | - stock list with names and codes 111 | - sector overview information 112 | Args: 113 | sector_name (str): Sector name like "人工智能", "新能源", "医药" etc. Use 'sectors' function to get available sector names 114 | board_type (str): Board type - "main" for main board (SH6*/SZ00*), "gem" for创业板, "star" for 科创板, "all" for all boards. Default is "all" 115 | limit (int): Maximum number of stocks to return, default is 50 116 | """ 117 | from .symbols import ( 118 | get_symbols_by_sector, get_symbol_name, filter_main_board_symbols, 119 | filter_gem_board_symbols, filter_star_board_symbols, get_available_sectors 120 | ) 121 | 122 | who = ctx.request_context.request.client.host if ctx else "" # type: ignore 123 | 124 | try: 125 | # 获取所有板块 126 | available_sectors = get_available_sectors() 127 | 128 | # 板块名称映射表 129 | sector_mapping = { 130 | "人工智能": ["人工智能", "AIGC概念", "AI智能体", "AI语料", "多模态AI"], 131 | "新能源": ["新能源汽车", "光伏概念", "固态电池", "燃料电池", "动力电池回收"], 132 | "医药": ["生物医药", "医疗器械概念", "医药电商", "合成生物", "生物疫苗"], 133 | "半导体": ["芯片概念", "集成电路概念", "第三代半导体", "存储芯片", "汽车芯片"], 134 | "电池": ["固态电池", "锂电池", "钠离子电池", "电池", "储能"], 135 | "光伏": ["光伏概念", "HJT电池", "TOPCON电池", "BC电池"], 136 | "汽车": ["新能源汽车", "汽车零部件", "无人驾驶", "汽车芯片"], 137 | "医疗": ["医疗器械概念", "互联网医疗", "牙科医疗", "毛发医疗"], 138 | "5G": ["5G", "6G概念", "通信设备"], 139 | "云计算": ["云计算", "边缘计算", "数据中心"], 140 | "区块链": ["区块链", "NFT概念", "数字货币"], 141 | } 142 | 143 | # 确定要搜索的板块 144 | search_sectors = [] 145 | sector_name_lower = sector_name.lower() 146 | 147 | # 先检查是否有精确匹配 148 | for sector in available_sectors: 149 | if sector_name in sector: 150 | search_sectors.append(sector) 151 | 152 | # 如果没有精确匹配，使用映射表 153 | if not search_sectors: 154 | for key, mapped_sectors in sector_mapping.items(): 155 | if key.lower() in sector_name_lower or sector_name_lower in key.lower(): 156 | search_sectors.extend(mapped_sectors) 157 | break 158 | 159 | # 如果仍然没有匹配，尝试模糊搜索 160 | if not search_sectors: 161 | keywords = ["概念", "板块"] 162 | for sector in available_sectors: 163 | if any(keyword in sector for keyword in keywords) and sector_name in sector: 164 | search_sectors.append(sector) 165 | 166 | # 如果还是找不到，返回建议 167 | if not search_sectors: 168 | suggestions = [] 169 | for key in sector_mapping.keys(): 170 | if any(keyword in sector_name_lower for keyword in key.lower().split()): 171 | suggestions.append(key) 172 | 173 | if not suggestions: 174 | suggestions = list(sector_mapping.keys())[:10] 175 | 176 | return f"未找到'{sector_name}'相关的板块。建议尝试以下板块：{', '.join(suggestions)}" 177 | 178 | # 获取所有匹配板块的股票 179 | all_stocks = set() 180 | for sector in search_sectors: 181 | if sector in available_sectors: 182 | stocks = get_symbols_by_sector(sector) 183 | all_stocks.update(stocks) 184 | 185 | # 转换为列表并排序 186 | all_stocks = sorted(list(all_stocks)) 187 | 188 | # 按板块类型过滤 189 | if board_type == "main": 190 | filtered_stocks = filter_main_board_symbols(all_stocks) 191 | elif board_type == "gem": 192 | filtered_stocks = filter_gem_board_symbols(all_stocks) 193 | elif board_type == "star": 194 | filtered_stocks = filter_star_board_symbols(all_stocks) 195 | else: # all 196 | filtered_stocks = all_stocks 197 | 198 | if not filtered_stocks: 199 | return f"在{board_type}板块中未找到'{sector_name}'相关的股票" 200 | 201 | # 限制返回数量 202 | limited_stocks = filtered_stocks[:limit] 203 | 204 | # 获取股票名称 205 | stock_info = [] 206 | for symbol in limited_stocks: 207 | name = get_symbol_name(symbol) 208 | stock_info.append(f"- {symbol}: {name}") 209 | 210 | # 确定实际使用的板块 211 | actual_sectors = [s for s in search_sectors if s in available_sectors] 212 | matched_sectors_str = "、".join(actual_sectors) if actual_sectors else sector_name 213 | 214 | # 构建报告 215 | report = f"""# {sector_name}板块股票列表 ({board_type}板) 216 | 217 | ## 板块信息 218 | - **搜索板块**: {matched_sectors_str} 219 | - **板块类型**: {board_type} 220 | - **总股票数**: {len(filtered_stocks)} 221 | - **返回数量**: {len(limited_stocks)} 222 | 223 | ## 股票列表 224 | {chr(10).join(stock_info)} 225 | 226 | ## 使用说明 227 | - **主板股票**: 以SH6开头或SZ00开头 228 | - **创业板**: 以SZ30开头 229 | - **科创板**: 以SH688开头 230 | 231 | ## 常用板块关键词 232 | 人工智能、新能源、医药、半导体、电池、光伏、汽车、医疗、5G、云计算、区块链 233 | 234 | 如需查看更多股票，请调整limit参数 235 | """ 236 | 237 | return report 238 | 239 | except Exception as e: 240 | return f"获取{sector_name}板块股票时发生错误: {str(e)}" 241 | 242 | 243 | @mcp_app.tool() 244 | async def latest_trading(symbol: str, ctx: Context) -> str: 245 | """Get the latest trading data for A-share main board stocks, including 246 | - real-time price 247 | - daily change and percentage 248 | - trading volume and amount 249 | - market status 250 | Args: 251 | symbol (str): Stock symbol, must be in the format of "SH000001" or "SZ000001" for main board stocks 252 | """ 253 | from datetime import datetime, timedelta 254 | from .datafeed import fetch_kline_data 255 | from .symbols import get_symbol_name 256 | 257 | who = ctx.request_context.request.client.host # type: ignore 258 | 259 | try: 260 | # 获取股票名称 261 | stock_name = get_symbol_name(symbol) 262 | 263 | # 获取最近2个交易日的数据用于计算涨跌幅 264 | end_date = datetime.now().strftime('%Y-%m-%d') 265 | start_date = (datetime.now() - timedelta(days=10)).strftime('%Y-%m-%d') 266 | 267 | # 获取K线数据 268 | kline_data = fetch_kline_data(symbol, start_date, end_date) 269 | 270 | if kline_data is None or kline_data.empty: 271 | return f"无法获取股票 {symbol} ({stock_name}) 的最新交易数据" 272 | 273 | # 获取最新交易数据 274 | latest = kline_data.iloc[-1] 275 | prev_close = kline_data.iloc[-2]['close'] if len(kline_data) > 1 else latest['close'] 276 | 277 | # 计算涨跌幅 278 | change = latest['close'] - prev_close 279 | change_pct = (change / prev_close) * 100 if prev_close > 0 else 0 280 | 281 | # 处理成交额可能不存在的情况 282 | amount = latest.get('amount', latest['volume'] * latest['close']) 283 | 284 | # 判断是否为指数 285 | is_index = symbol.startswith("SH000") or symbol.startswith("SZ399") 286 | unit = "点" if is_index else "元" 287 | 288 | # 构建交易数据报告 289 | report = f"""# {stock_name}({symbol}) 最新交易数据 290 | 291 | ## 基本信息 292 | - **股票名称**: {stock_name} 293 | - **股票代码**: {symbol} 294 | - **数据时间**: {latest['date'].strftime('%Y-%m-%d') if hasattr(latest['date'], 'strftime') else str(latest['date'])[:10]} 295 | 296 | ## 最新交易数据 297 | - **最新价格**: {latest['close']:.2f}{unit} 298 | - **开盘价**: {latest['open']:.2f}{unit} 299 | - **最高价**: {latest['high']:.2f}{unit} 300 | - **最低价**: {latest['low']:.2f}{unit} 301 | - **昨收价**: {prev_close:.2f}{unit} 302 | - **涨跌额**: {change:+.2f}{unit} 303 | - **涨跌幅**: {change_pct:+.2f}% 304 | 305 | ## 成交数据 306 | - **成交量**: {latest['volume']:,.0f}{"手" if is_index else "股"} 307 | - **成交额**: ¥{amount:,.2f}元 308 | 309 | ## 市场状态 310 | - **交易状态**: {"正常交易" if latest['volume'] > 0 else "停牌"} 311 | - **振幅**: {((latest['high'] - latest['low']) / prev_close * 100):.2f}% 312 | """ 313 | 314 | return report 315 | 316 | except Exception as e: 317 | return f"获取 {symbol} 最新交易数据时发生错误: {str(e)}" 318 | 319 | 320 | @mcp_app.tool() 321 | async def minute_trading(symbol: str, start_datetime: str, end_datetime: str, ctx: Context, period: str = "1") -> str: 322 | """Get minute-level trading data for A-share stocks and indices within specified time range 323 | 324 | Args: 325 | symbol (str): Stock symbol, must be in the format of "SH000001" or "SZ000001" 326 | start_datetime (str): Start datetime in format "YYYY-MM-DD HH:MM:SS", e.g. "2023-12-11 09:30:00" 327 | end_datetime (str): End datetime in format "YYYY-MM-DD HH:MM:SS", e.g. "2023-12-11 15:00:00" 328 | period (str): Time interval in minutes, supports "1", "5", "15", "30", "60". Default is "1" 329 | """ 330 | from .datafeed import fetch_minute_data 331 | from .symbols import get_symbol_name 332 | 333 | who = ctx.request_context.request.client.host # type: ignore 334 | 335 | try: 336 | # 获取股票名称 337 | stock_name = get_symbol_name(symbol) 338 | 339 | # 获取分钟级数据 340 | minute_data = fetch_minute_data(symbol, start_datetime, end_datetime, period) 341 | 342 | if minute_data is None or minute_data.empty: 343 | return f"无法获取股票 {symbol} ({stock_name}) 在 {start_datetime} 到 {end_datetime} 期间的{period}分钟级交易数据" 344 | 345 | # 判断是否为指数 346 | is_index = symbol.startswith("SH000") or symbol.startswith("SZ399") 347 | unit = "点" if is_index else "元" 348 | 349 | # 获取统计信息 350 | total_records = len(minute_data) 351 | first_record = minute_data.iloc[0] 352 | last_record = minute_data.iloc[-1] 353 | 354 | # 计算期间涨跌幅 355 | period_change = last_record['close'] - first_record['open'] 356 | period_change_pct = (period_change / first_record['open']) * 100 if first_record['open'] > 0 else 0 357 | 358 | # 计算期间最高最低价 359 | period_high = minute_data['high'].max() 360 | period_low = minute_data['low'].min() 361 | 362 | # 计算总成交量和成交额 363 | total_volume = minute_data['volume'].sum() 364 | total_amount = minute_data['amount'].sum() if 'amount' in minute_data.columns else minute_data['volume'].sum() * minute_data['close'].mean() 365 | 366 | # 构建分钟级交易数据报告 367 | report = f"""# {stock_name}({symbol}) {period}分钟级交易数据 368 | 369 | ## 基本信息 370 | - **股票名称**: {stock_name} 371 | - **股票代码**: {symbol} 372 | - **时间范围**: {start_datetime} 至 {end_datetime} 373 | - **时间间隔**: {period}分钟 374 | - **数据条数**: {total_records}条 375 | 376 | ## 期间统计 377 | - **期初价格**: {first_record['open']:.2f}{unit} ({first_record['datetime'].strftime('%Y-%m-%d %H:%M:%S')}) 378 | - **期末价格**: {last_record['close']:.2f}{unit} ({last_record['datetime'].strftime('%Y-%m-%d %H:%M:%S')}) 379 | - **期间涨跌**: {period_change:+.2f}{unit} 380 | - **期间涨跌幅**: {period_change_pct:+.2f}% 381 | - **期间最高**: {period_high:.2f}{unit} 382 | - **期间最低**: {period_low:.2f}{unit} 383 | - **期间振幅**: {((period_high - period_low) / first_record['open'] * 100):.2f}% 384 | 385 | ## 成交统计 386 | - **总成交量**: {total_volume:,.0f}{"手" if is_index else "股"} 387 | - **总成交额**: ¥{total_amount:,.2f}元 388 | - **平均每{period}分钟成交量**: {total_volume/total_records:,.0f}{"手" if is_index else "股"} 389 | 390 | ## 详细数据（前10条） 391 | """ 392 | 393 | # 添加前10条详细数据 394 | report += "\n| 时间 | 开盘 | 最高 | 最低 | 收盘 | 成交量 |\n" 395 | report += "|------|------|------|------|------|--------|\n" 396 | 397 | for i in range(min(10, len(minute_data))): 398 | row = minute_data.iloc[i] 399 | report += f"| {row['datetime'].strftime('%H:%M')} | {row['open']:.2f} | {row['high']:.2f} | {row['low']:.2f} | {row['close']:.2f} | {row['volume']:,.0f} |\n" 400 | 401 | if total_records > 10: 402 | report += f"\n... 还有 {total_records - 10} 条数据\n" 403 | 404 | return report 405 | 406 | except Exception as e: 407 | return f"获取 {symbol} 分钟级交易数据时发生错误: {str(e)}" 408 | 409 | 410 | @mcp_app.tool() 411 | async def daily_news(date: str, ctx: Context) -> str: 412 | """Get the daily news content from Xinwen Lianbo (CCTV News) for a specified date 413 | 414 | Args: 415 | date (str): Date in format "YYYY-MM-DD", e.g. "2024-01-15" 416 | """ 417 | from .news_extractor import NewsExtractor 418 | from .sensitive_words import SensitiveWordFilter 419 | import datetime 420 | 421 | who = ctx.request_context.request.client.host # type: ignore 422 | 423 | try: 424 | # 解析日期 425 | target_date = datetime.datetime.strptime(date, '%Y-%m-%d').date() 426 | 427 | # 创建新闻提取器实例 428 | extractor = NewsExtractor() 429 | 430 | # 获取指定日期的新闻内容 431 | news_result = extractor.get_news_content(target_date) 432 | 433 | filter_instance = SensitiveWordFilter() 434 | filtered_content = filter_instance.filter_text(news_result['content']) 435 | 436 | return filtered_content 437 | except Exception as e: 438 | return f"获取 {date} 新闻内容时发生错误: {str(e)}" 439 | -------------------------------------------------------------------------------- /qtf_mcp/news_extractor.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | """ 3 | 新闻联播文字内容获取器 4 | 用于获取指定日期的新闻联播文字版内容 5 | """ 6 | 7 | import requests 8 | from bs4 import BeautifulSoup 9 | import datetime 10 | import re 11 | import json 12 | from typing import Dict, List, Optional 13 | 14 | class NewsExtractor: 15 | """新闻联播文字内容提取器""" 16 | 17 | def __init__(self): 18 | self.base_url = "http://mrxwlb.com" 19 | self.headers = { 20 | 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36', 21 | 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7', 22 | 'Accept-Language': 'zh-CN,zh;q=0.9', 23 | 'Accept-Encoding': 'gzip, deflate', 24 | 'Cache-Control': 'max-age=0', 25 | 'Connection': 'keep-alive', 26 | 'Upgrade-Insecure-Requests': '1', 27 | 'Referer': 'http://mrxwlb.com/', 28 | } 29 | self.cookies = { 30 | 'security_session_verify': '70354a6071922de17ed3e03772b40ba8' 31 | } 32 | 33 | def format_date_url(self, date: datetime.date) -> str: 34 | """格式化日期为URL格式，使用用户提供的成功格式""" 35 | year = date.strftime('%Y') 36 | month = date.strftime('%m') 37 | day = date.strftime('%d') 38 | 39 | # 使用用户提供的成功URL格式 40 | url = f"{self.base_url}/{year}/{month}/{day}/{year}%e5%b9%b4{month}%e6%9c%88{day}%e6%97%a5%e6%96%b0%e9%97%bb%e8%81%94%e6%92%ad%e6%96%87%e5%ad%97%e7%89%88/" 41 | 42 | return url 43 | 44 | def get_news_content(self, date: datetime.date) -> Dict[str, any]: 45 | """获取指定日期的新闻联播内容""" 46 | url = self.format_date_url(date) 47 | 48 | try: 49 | response = requests.get(url, headers=self.headers, cookies=self.cookies, timeout=30) 50 | response.raise_for_status() 51 | response.encoding = 'utf-8' 52 | 53 | soup = BeautifulSoup(response.text, 'html.parser') 54 | 55 | # 提取标题 56 | title = soup.find('title') 57 | title_text = title.get_text().strip() if title else f"{date.strftime('%Y年%m月%d日')}新闻联播" 58 | 59 | # 提取主要内容 - 针对mrxwlb.com的结构优化 60 | content_div = None 61 | for selector in ['.entry-content', 'article', 'main', '.content', '.post-content']: 62 | content_div = soup.select_one(selector) 63 | if content_div: 64 | break 65 | 66 | if not content_div: 67 | content_div = soup.find('body') 68 | 69 | content_text = self.extract_text_from_html(content_div) 70 | 71 | # 提取新闻条目 72 | news_items = self.parse_news_items(content_text) 73 | 74 | return { 75 | 'date': date.strftime('%Y-%m-%d'), 76 | 'title': title_text, 77 | 'url': url, 78 | 'content': content_text, 79 | 'news_items': news_items, 80 | 'status': 'success' 81 | } 82 | 83 | except requests.RequestException as e: 84 | return { 85 | 'date': date.strftime('%Y-%m-%d'), 86 | 'title': f"{date.strftime('%Y年%m月%d日')}新闻联播", 87 | 'url': url, 88 | 'content': '', 89 | 'news_items': [], 90 | 'status': 'error', 91 | 'error': str(e) 92 | } 93 | 94 | def extract_text_from_html(self, content_div) -> str: 95 | """从HTML中提取纯文本""" 96 | if not content_div: 97 | return "" 98 | 99 | # 移除脚本和样式标签 100 | for script in content_div(["script", "style"]): 101 | script.decompose() 102 | 103 | # 获取文本并清理 104 | text = content_div.get_text() 105 | 106 | # 清理空白字符 107 | lines = [line.strip() for line in text.split('\n') if line.strip()] 108 | cleaned_text = '\n'.join(lines) 109 | 110 | return cleaned_text 111 | 112 | def parse_news_items(self, content: str) -> List[Dict[str, str]]: 113 | """解析新闻内容为条目""" 114 | if not content: 115 | return [] 116 | 117 | # 按段落分割 118 | paragraphs = [p.strip() for p in content.split('\n') if p.strip()] 119 | 120 | news_items = [] 121 | current_item = "" 122 | 123 | for para in paragraphs: 124 | # 识别新闻条目（通常以时间或特定关键词开头） 125 | if re.match(r'^\d{2}:\d{2}', para) or re.match(r'^【.*?】', para): 126 | if current_item: 127 | news_items.append({ 128 | 'title': current_item.strip(), 129 | 'content': '' 130 | }) 131 | current_item = para 132 | else: 133 | if current_item: 134 | current_item += " " + para 135 | 136 | if current_item: 137 | news_items.append({ 138 | 'title': current_item.strip(), 139 | 'content': '' 140 | }) 141 | 142 | return news_items 143 | 144 | def get_latest_news(self) -> Dict[str, any]: 145 | """获取最新的新闻联播内容""" 146 | today = datetime.date.today() 147 | return self.get_news_content(today) 148 | 149 | def get_news_by_date_str(self, date_str: str) -> Dict[str, any]: 150 | """通过日期字符串获取新闻联播""" 151 | try: 152 | date = datetime.datetime.strptime(date_str, '%Y-%m-%d').date() 153 | return self.get_news_content(date) 154 | except ValueError: 155 | return { 156 | 'status': 'error', 157 | 'error': '日期格式错误，请使用YYYY-MM-DD格式' 158 | } 159 | 160 | def main(): 161 | """主函数示例""" 162 | extractor = NewsExtractor() 163 | 164 | # 获取今天的新闻联播 165 | print("正在获取今天的新闻联播内容...") 166 | news = extractor.get_latest_news() 167 | 168 | if news['status'] == 'success': 169 | print(f"\n📺 {news['title']}") 170 | print(f"🔗 URL: {news['url']}") 171 | print("=" * 80) 172 | print("新闻内容:") 173 | print(news['content']) 174 | 175 | if news['news_items']: 176 | print("\n📋 新闻条目:") 177 | for i, item in enumerate(news['news_items'], 1): 178 | print(f"{i}. {item['title']}") 179 | else: 180 | print(f"❌ 获取失败: {news['error']}") 181 | 182 | if __name__ == "__main__": 183 | main() -------------------------------------------------------------------------------- /qtf_mcp/research.py: -------------------------------------------------------------------------------- 1 | import datetime 2 | from io import StringIO 3 | from typing import Dict, TextIO 4 | 5 | import numpy as np 6 | import talib 7 | from numpy import ndarray 8 | 9 | from .datafeed import load_data_msd, load_data_akshare_batch 10 | from .symbols import symbol_with_name, get_symbols_by_sector, filter_main_board_symbols, filter_star_board_symbols, filter_gem_board_symbols 11 | 12 | 13 | async def load_raw_data( 14 | symbol: str, end_date=None, who: str = "" 15 | ) -> Dict[str, ndarray]: 16 | if end_date is None: 17 | end_date = datetime.datetime.now() + datetime.timedelta(days=1) 18 | if type(end_date) == str: 19 | end_date = datetime.datetime.strptime(end_date, "%Y-%m-%d") 20 | 21 | start_date = end_date - datetime.timedelta(days=365 * 2) 22 | 23 | return await load_data_msd( 24 | symbol, start_date.strftime("%Y-%m-%d"), end_date.strftime("%Y-%m-%d"), 0, who 25 | ) 26 | 27 | 28 | def is_stock(symbol: str) -> bool: 29 | if symbol.startswith("SH6") or symbol.startswith("SZ00") or symbol.startswith("SZ30"): 30 | return True 31 | return False 32 | 33 | 34 | def build_stock_data(symbol: str, raw_data: Dict[str, ndarray]) -> str: 35 | md = StringIO() 36 | build_basic_data(md, symbol, raw_data) 37 | build_trading_data(md, symbol, raw_data) 38 | build_technical_data(md, symbol, raw_data) 39 | build_financial_data(md, symbol, raw_data) 40 | 41 | return md.getvalue() 42 | 43 | 44 | def filter_sector(sectors: list[str]) -> list[str]: 45 | keywords = ["MSCI", "标普", "同花顺", "融资融券", "沪股通"] 46 | # return sectors not including keywords 47 | return [s for s in sectors if not any(k in s for k in keywords)] 48 | 49 | 50 | def est_fin_ratio(last_fin_date: datetime.datetime) -> float: 51 | if last_fin_date.month == 12: 52 | return 1 53 | elif last_fin_date.month == 9: 54 | return 0.75 55 | elif last_fin_date.month == 6: 56 | return 0.5 57 | elif last_fin_date.month == 3: 58 | return 0.25 59 | else: 60 | return 0 61 | 62 | 63 | def yearly_fin_index(dates: ndarray) -> int: 64 | """ 65 | Returns the index of the last December in the dates array. 66 | If no December is found, returns -1. 67 | """ 68 | for i in range(len(dates) - 1, -1, -1): 69 | date = datetime.datetime.fromtimestamp(dates[i] / 1e9) 70 | if date.month == 12: 71 | return i 72 | return -1 73 | 74 | 75 | def build_basic_data(fp: TextIO, symbol: str, data: Dict[str, ndarray]) -> None: 76 | print("# 基本数据", file=fp) 77 | print("", file=fp) 78 | symbol, name = list(symbol_with_name([symbol]))[0] 79 | sector = " ".join(filter_sector(data["SECTOR"])) # type: ignore 80 | data_date = datetime.datetime.fromtimestamp(data["DATE"][-1]) 81 | 82 | print(f"- 股票代码: {symbol}", file=fp) 83 | print(f"- 股票名称: {name}", file=fp) 84 | print(f"- 数据日期: {data_date.strftime('%Y-%m-%d')}", file=fp) 85 | print(f"- 行业概念: {sector}", file=fp) 86 | 87 | if is_stock(symbol): 88 | # 使用AkShare提供的财务数据 89 | total_market_cap = data.get("TCAP", [0])[-1] 90 | if total_market_cap > 0: 91 | # TCAP已经是总市值（单位：万元），转换为亿元 92 | print(f"- 总市值: {total_market_cap/10000:.2f}亿元", file=fp) 93 | 94 | # 检查是否有财务数据 95 | navps = data.get("NAVPS", [1.0])[-1] 96 | if navps != 1.0: 97 | print(f"- 市净率: {data['CLOSE2'][-1] / navps:.2f}", file=fp) 98 | 99 | roe = data.get("ROE", [0.0])[-1] 100 | if roe != 0.0: 101 | print(f"- 净资产收益率: {roe:.2f}%", file=fp) 102 | print("", file=fp) 103 | 104 | 105 | def today_volume_est_ratio(data: Dict[str, ndarray], now: int = 0) -> float: 106 | data_dt = datetime.datetime.fromtimestamp(data["DATE"][-1]) 107 | now_dt = ( 108 | datetime.datetime.now() if now == 0 else datetime.datetime.fromtimestamp(now) 109 | ) 110 | 111 | data_date = data_dt.strftime("%Y-%m-%d") 112 | now_date = now_dt.strftime("%Y-%m-%d") 113 | if data_date != now_date: 114 | return 1 115 | now_time = now_dt.strftime("%H:%M:%S") 116 | if now_time >= "09:30:00" and now_time < "11:30:00": 117 | start_dt = now_dt.replace(hour=9, minute=30, second=0) 118 | minutes = (now_dt - start_dt).seconds / 60 119 | return 240 / (minutes + 1) 120 | elif now_time >= "11:30:00" and now_time < "13:00:00": 121 | return 2 122 | elif now_time >= "13:00:00" and now_time < "15:00:00": 123 | start_dt = now_dt.replace(hour=13, minute=0, second=0) 124 | minutes = (now_dt - start_dt).seconds / 60 125 | return 240 / (120 + minutes + 1) 126 | else: 127 | return 1 128 | 129 | 130 | FUND_FLOW_FIELDS = [ 131 | ("主力", "A"), 132 | ("超大单", "XL"), 133 | ("大单", "L"), 134 | ("中单", "M"), 135 | ("小单", "S"), 136 | ] 137 | 138 | 139 | def build_fund_flow(field: tuple[str, str], data: Dict[str, ndarray]) -> str: 140 | field_amount = field[1] + "_A" 141 | field_ratio = field[1] + "_R" 142 | value_amount = data.get(field_amount, None) 143 | value_ratio = data.get(field_ratio, None) 144 | if value_amount is None or value_ratio is None: 145 | return "" 146 | 147 | kind = field[0] 148 | amount = value_amount[-1] / 1e8 # Convert to billions 149 | ratio = abs(value_ratio[-1]) 150 | in_out = "流入" if amount > 0 else "流出" 151 | amount = abs(amount) # Use absolute value for display 152 | return f"- {kind} {in_out}: {amount:.2f}亿, 占比: {ratio:.2%}" 153 | 154 | 155 | def build_trading_data(fp: TextIO, symbol: str, data: Dict[str, ndarray]) -> None: 156 | today_vol_est_ratio = today_volume_est_ratio(data) 157 | close = data["CLOSE"] 158 | volume = data["VOLUME"] 159 | volume[-1] = volume[-1] * today_vol_est_ratio # Adjust today's volume 160 | amount = data["AMOUNT"] / 1e8 161 | amount[-1] = amount[-1] * today_vol_est_ratio # Adjust today's amount 162 | high = data["HIGH"] 163 | low = data["LOW"] 164 | 165 | periods = list(filter(lambda n: n <= len(close), [5, 20, 60, 120, 240])) 166 | 167 | print("# 交易数据", file=fp) 168 | print("", file=fp) 169 | 170 | print("## 价格", file=fp) 171 | print(f"- 当日: {close[-1]:.3f} 最高: {high[-1]:.3f} 最低: {low[-1]:.3f}", file=fp) 172 | for p in periods: 173 | print( 174 | f"- {p}日均价: {close[-p:].mean():.3f} 最高: {high[-p:].max():.3f} 最低: {low[-p:].min():.3f}", 175 | file=fp, 176 | ) 177 | print("", file=fp) 178 | 179 | print("## 振幅", file=fp) 180 | print(f"- 当日: {(high[-1] / low[-1] - 1):.2%}", file=fp) 181 | for p in periods: 182 | print(f"- {p}日振幅: {(high[-p:].max() / low[-p:].min() - 1):.2%}", file=fp) 183 | print("", file=fp) 184 | 185 | print("## 涨跌幅", file=fp) 186 | print(f"- 当日: {(close[-1] / close[-2] - 1):.2%}", file=fp) 187 | for p in periods: 188 | print(f"- {p}日累计: {(close[-1] / close[-p] - 1) * 100:.2f}%", file=fp) 189 | print("", file=fp) 190 | 191 | print("## 成交量(万手)", file=fp) 192 | print(f"- 当日: {volume[-1] / 1e6:.2f}", file=fp) 193 | for p in periods: 194 | print(f"- {p}日均量(万手): {volume[-p:].mean() / 1e6:.2f}", file=fp) 195 | print("", file=fp) 196 | 197 | print("## 成交额(亿)", file=fp) 198 | print(f"- 当日: {amount[-1]:.2f}", file=fp) 199 | for p in periods: 200 | print(f"- {p}日均额(亿): {amount[-p:].mean():.2f}", file=fp) 201 | print("", file=fp) 202 | 203 | print("## 资金流向", file=fp) 204 | for field in FUND_FLOW_FIELDS: 205 | value = build_fund_flow(field, data) 206 | if value: 207 | print(value, file=fp) 208 | print("", file=fp) 209 | 210 | if is_stock(symbol): 211 | tcap = data.get("TCAP", None) 212 | if tcap is not None and len(tcap) > 0 and tcap[-1] > 0: 213 | print("## 换手率", file=fp) 214 | print(f"- 当日: {volume[-1] / tcap[-1]:.2%}", file=fp) 215 | for p in periods: 216 | print(f"- {p}日均换手: {volume[-p:].mean() / tcap[-1]:.2%}", file=fp) 217 | print(f"- {p}日总换手: {volume[-p:].sum() / tcap[-1]:.2%}", file=fp) 218 | print("", file=fp) 219 | 220 | 221 | def calculate_kdj(close: ndarray, high: ndarray, low: ndarray, n: int = 9, k: int = 3, d: int = 3) -> tuple[ndarray, ndarray, ndarray]: 222 | """计算KDJ指标""" 223 | rsv = np.zeros_like(close) 224 | k_values = np.zeros_like(close) 225 | d_values = np.zeros_like(close) 226 | j_values = np.zeros_like(close) 227 | 228 | for i in range(n-1, len(close)): 229 | highest_high = np.max(high[i-n+1:i+1]) 230 | lowest_low = np.min(low[i-n+1:i+1]) 231 | 232 | if highest_high == lowest_low: 233 | rsv[i] = 50 234 | else: 235 | rsv[i] = 100 * (close[i] - lowest_low) / (highest_high - lowest_low) 236 | 237 | # 计算K值 238 | k_values[n-1] = 50 239 | for i in range(n, len(close)): 240 | k_values[i] = (k-1)/k * k_values[i-1] + 1/k * rsv[i] 241 | 242 | # 计算D值 243 | d_values[n-1] = 50 244 | for i in range(n, len(close)): 245 | d_values[i] = (d-1)/d * d_values[i-1] + 1/d * k_values[i] 246 | 247 | # 计算J值 248 | j_values = 3 * k_values - 2 * d_values 249 | 250 | return k_values, d_values, j_values 251 | 252 | 253 | def calculate_macd(close: ndarray, fast: int = 12, slow: int = 26, signal: int = 9) -> tuple[ndarray, ndarray, ndarray]: 254 | """计算MACD指标""" 255 | ema_fast = talib.EMA(close, timeperiod=fast) 256 | ema_slow = talib.EMA(close, timeperiod=slow) 257 | macd_line = ema_fast - ema_slow 258 | signal_line = talib.EMA(macd_line, timeperiod=signal) 259 | histogram = macd_line - signal_line 260 | return macd_line, signal_line, histogram 261 | 262 | 263 | def build_technical_data(fp: TextIO, symbol: str, data: Dict[str, ndarray]) -> None: 264 | close = data["CLOSE"] 265 | high = data["HIGH"] 266 | low = data["LOW"] 267 | 268 | if len(close) < 30: 269 | return 270 | 271 | print("# 技术指标(最近30日)", file=fp) 272 | print("", file=fp) 273 | 274 | kdj_k, kdj_d, kdj_j = calculate_kdj(close, high, low, 9, 3) 275 | 276 | macd_diff, macd_dea, _ = calculate_macd(close, 12, 26, 9) 277 | 278 | rsi_6 = talib.RSI(close, timeperiod=6) 279 | rsi_12 = talib.RSI(close, timeperiod=12) 280 | rsi_24 = talib.RSI(close, timeperiod=24) 281 | 282 | bb_upper, bb_middle, bb_lower = talib.BBANDS(close, matype=talib.MA_Type.T3) # type: ignore 283 | 284 | date = [ 285 | datetime.datetime.fromtimestamp(d / 1e9).strftime("%Y-%m-%d") for d in data["DATE"] 286 | ] 287 | columns = [ 288 | ("日期", date), 289 | ("KDJ.K", kdj_k), 290 | ("KDJ.D", kdj_d), 291 | ("KDJ.J", kdj_j), 292 | ("MACD DIF", macd_diff), 293 | ("MACD DEA", macd_dea), 294 | ("RSI(6)", rsi_6), 295 | ("RSI(12)", rsi_12), 296 | ("RSI(24)", rsi_24), 297 | ("BBands Upper", bb_upper), 298 | ("BBands Middle", bb_middle), 299 | ("BBands Lower", bb_lower), 300 | ] 301 | print("| " + " | ".join([c[0] for c in columns]) + " |", file=fp) 302 | print("| --- " * len(columns) + "|", file=fp) 303 | for i in range(-1, max(-len(date), -31), -1): 304 | print( 305 | "| " + date[i] + "|" + " | ".join([f"{c[1][i]:.2f}" for c in columns[1:]]) + " |", 306 | file=fp, 307 | ) 308 | print("", file=fp) 309 | 310 | 311 | def build_financial_data(fp: TextIO, symbol: str, data: Dict[str, ndarray]) -> None: 312 | if not is_stock(symbol): 313 | return 314 | 315 | print("# 财务数据", file=fp) 316 | print("", file=fp) 317 | 318 | # 检查是否有财务数据 319 | if "_DS_FINANCE" not in data: 320 | print("- 暂无财务数据", file=fp) 321 | print("", file=fp) 322 | return 323 | 324 | try: 325 | fin, _ = data["_DS_FINANCE"] 326 | dates = fin["DATE"] 327 | max_years = 5 328 | years = 0 329 | fields = [ 330 | # name, id, div, show 331 | ("主营收入(亿元)", "MR", 10000, True), 332 | ("净利润(亿元)", "NP", 10000, True), 333 | ("每股收益", "EPS", 1, True), 334 | ("每股净资产", "NAVPS", 1, True), 335 | ("净资产收益率", "ROE", 1, True), 336 | ] 337 | 338 | rows = [] 339 | for i in range(len(dates) - 1, 0, -1): 340 | date = datetime.datetime.fromtimestamp(dates[i] / 1e9) 341 | if date.month != 12 or years >= max_years: 342 | continue 343 | row = [date.strftime("%Y年度")] 344 | for _, field, div, show in fields: 345 | if show and field in fin: 346 | row.append(fin[field][i] / div) 347 | else: 348 | row.append(0.0) 349 | rows.append(row) 350 | years += 1 351 | 352 | if rows: 353 | print("| 指标 | " + " ".join([f"{r[0]} |" for r in rows]), file=fp) 354 | print("| --- " * (len(rows) + 1) + "|", file=fp) 355 | for i in range(1, len(rows[0])): 356 | print( 357 | f"| {fields[i - 1][0]} | " + " ".join([f"{r[i]:.2f} |" for r in rows]), 358 | file=fp, 359 | ) 360 | else: 361 | print("- 暂无年度财务数据", file=fp) 362 | except Exception as e: 363 | print(f"- 财务数据获取失败: {str(e)}", file=fp) 364 | 365 | print("", file=fp) 366 | 367 | 368 | async def load_sector_basic_data( 369 | sector_name: str, board_type: str = "all", limit: int = 50, who: str = "" 370 | ) -> str: 371 | """获取指定板块股票的基础数据列表 372 | 373 | Args: 374 | sector_name: 板块名称 375 | board_type: 板块类型 ("main" 主板, "star" 科创板, "gem" 创业板, "all" 全部) 376 | limit: 限制返回的股票数量 377 | who: 请求来源标识 378 | 379 | Returns: 380 | 格式化的股票基础数据列表 381 | """ 382 | # 获取板块内的所有股票代码 383 | symbols = get_symbols_by_sector(sector_name) 384 | 385 | if not symbols: 386 | return f"未找到板块 '{sector_name}' 的股票数据" 387 | 388 | # 根据板块类型过滤股票 389 | if board_type == "main": 390 | symbols = filter_main_board_symbols(symbols) 391 | elif board_type == "star": 392 | symbols = filter_star_board_symbols(symbols) 393 | elif board_type == "gem": 394 | symbols = filter_gem_board_symbols(symbols) 395 | 396 | if not symbols: 397 | return f"在板块 '{sector_name}' 中未找到 {board_type} 类型的股票" 398 | 399 | # 限制股票数量 400 | symbols = symbols[:limit] 401 | 402 | # 批量获取股票数据 403 | end_date = datetime.datetime.now() + datetime.timedelta(days=1) 404 | start_date = end_date - datetime.timedelta(days=30) # 只获取最近30天数据以提高速度 405 | 406 | batch_data = await load_data_akshare_batch( 407 | symbols, 408 | start_date.strftime("%Y-%m-%d"), 409 | end_date.strftime("%Y-%m-%d"), 410 | 0, 411 | who 412 | ) 413 | 414 | # 构建结果 415 | buf = StringIO() 416 | print(f"# {sector_name} 板块股票基础数据", file=buf) 417 | print("", file=buf) 418 | print(f"- 板块类型: {board_type}", file=buf) 419 | print(f"- 股票数量: {len(batch_data)}", file=buf) 420 | print(f"- 数据日期: {datetime.datetime.now().strftime('%Y-%m-%d')}", file=buf) 421 | print("", file=buf) 422 | 423 | # 构建表格头 424 | print("| 股票代码 | 股票名称 | 最新价格 | 涨跌幅 | 总市值(亿) | 成交额(亿) | 行业概念 |", file=buf) 425 | print("| --- | --- | --- | --- | --- | --- | --- |", file=buf) 426 | 427 | # 处理每只股票的数据 428 | stock_list = [] 429 | for symbol in symbols: 430 | if symbol not in batch_data: 431 | continue 432 | 433 | data = batch_data[symbol] 434 | if len(data.get("CLOSE", [])) == 0: 435 | continue 436 | 437 | # 获取股票名称 438 | symbol_name_list = list(symbol_with_name([symbol])) 439 | if symbol_name_list: 440 | _, name = symbol_name_list[0] 441 | else: 442 | name = symbol 443 | 444 | # 基础数据 445 | close = data["CLOSE"] 446 | latest_price = close[-1] 447 | 448 | # 涨跌幅 449 | if len(close) > 1: 450 | change_pct = (close[-1] / close[-2] - 1) * 100 451 | else: 452 | change_pct = 0.0 453 | 454 | # 总市值 455 | total_market_cap = data.get("TCAP", [0])[-1] / 10000 if data.get("TCAP", [0])[-1] > 0 else 0 456 | 457 | # 成交额 458 | amount = data.get("AMOUNT", [0])[-1] / 1e8 if len(data.get("AMOUNT", [])) > 0 else 0 459 | 460 | # 行业概念（取前3个） 461 | sectors = data.get("SECTOR", []) 462 | sector_str = ", ".join(sectors[:3]) if sectors else "-" 463 | 464 | stock_info = { 465 | 'symbol': symbol, 466 | 'name': name, 467 | 'price': latest_price, 468 | 'change_pct': change_pct, 469 | 'market_cap': total_market_cap, 470 | 'amount': amount, 471 | 'sectors': sector_str 472 | } 473 | stock_list.append(stock_info) 474 | 475 | # 按涨跌幅排序 476 | stock_list.sort(key=lambda x: x['change_pct'], reverse=True) 477 | 478 | # 输出表格数据 479 | for stock in stock_list: 480 | change_sign = "+" if stock['change_pct'] >= 0 else "" 481 | print( 482 | f"| {stock['symbol']} | {stock['name']} | {stock['price']:.3f} | " 483 | f"{change_sign}{stock['change_pct']:.2f}% | {stock['market_cap']:.2f} | " 484 | f"{stock['amount']:.2f} | {stock['sectors']} |", 485 | file=buf 486 | ) 487 | 488 | print("", file=buf) 489 | print(f"注: 数据按涨跌幅降序排列，共显示 {len(stock_list)} 只股票", file=buf) 490 | 491 | return buf.getvalue() 492 | -------------------------------------------------------------------------------- /qtf_mcp/sensitive_words.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | """ 3 | 敏感词过滤模块 4 | 提供敏感词检测和替换功能 5 | """ 6 | 7 | import re 8 | from typing import List, Dict, Set 9 | 10 | class SensitiveWordFilter: 11 | """敏感词过滤器""" 12 | 13 | def __init__(self, config_file: str = None): 14 | self.sensitive_words = [] 15 | self.compiled_patterns = {} 16 | self.sensitive_words = self._load_default_words() 17 | 18 | self._compile_patterns() 19 | 20 | def _load_default_words(self) -> List[str]: 21 | """加载默认敏感词""" 22 | return [ 23 | # 政治敏感词 24 | '领导人', '政治局', '常委', '总理', '主席', '总书记', '习近平', 25 | '部长', '局长', '主任', '委员', '书记', 26 | 27 | # 负面事件词汇 28 | '暴乱', '抗议', '示威', '罢工', '冲突', '暴力', 29 | '骚乱', '动乱', '政变', '革命', '叛乱', '颠覆', 30 | 31 | # 敏感机构 32 | '中南海', '国务院', '中央军委', '公安部', '国安部', 33 | 34 | # 敏感信息 35 | '机密', '绝密', '内部文件', '未公开', '保密', 36 | '内部消息', '小道消息', '内幕', '爆料', 37 | 38 | # 宗教相关 39 | '邪教', '异端', '极端组织', '恐怖组织', 40 | 41 | # 社会敏感 42 | '种族歧视', '性别歧视', '地域歧视', '仇恨言论', 43 | 44 | # 其他 45 | '腐败', '贪污', '受贿', '滥用职权', '渎职' 46 | ] 47 | 48 | def add_words(self, words: List[str]): 49 | """添加新的敏感词""" 50 | self.sensitive_words.extend(words) 51 | self.sensitive_words = list(set(self.sensitive_words)) # 去重 52 | self._compile_patterns() 53 | 54 | def remove_words(self, words: List[str]): 55 | """移除敏感词""" 56 | for word in words: 57 | if word in self.sensitive_words: 58 | self.sensitive_words.remove(word) 59 | self._compile_patterns() 60 | 61 | def _compile_patterns(self): 62 | """编译正则表达式模式""" 63 | self.compiled_patterns = {} 64 | for word in self.sensitive_words: 65 | pattern = re.compile(re.escape(word), re.IGNORECASE) 66 | self.compiled_patterns[word] = pattern 67 | 68 | def filter_text(self, text: str, replacement: str = '*') -> str: 69 | """ 70 | 过滤文本中的敏感词 71 | 72 | Args: 73 | text: 要过滤的文本 74 | replacement: 替换字符，默认为'*' 75 | 76 | Returns: 77 | 过滤后的文本 78 | """ 79 | filtered_text = text 80 | 81 | for word, pattern in self.compiled_patterns.items(): 82 | # 用等长的替换字符替换敏感词 83 | replacement_str = replacement * len(word) 84 | filtered_text = pattern.sub(replacement_str, filtered_text) 85 | 86 | return filtered_text 87 | 88 | def has_sensitive_words(self, text: str) -> bool: 89 | """检测文本是否包含敏感词""" 90 | for word, pattern in self.compiled_patterns.items(): 91 | if pattern.search(text): 92 | return True 93 | return False 94 | 95 | def find_sensitive_words(self, text: str) -> Dict[str, List[int]]: 96 | """找出文本中的所有敏感词及其位置""" 97 | found_words = {} 98 | 99 | for word, pattern in self.compiled_patterns.items(): 100 | matches = list(pattern.finditer(text)) 101 | if matches: 102 | positions = [match.start() for match in matches] 103 | found_words[word] = positions 104 | 105 | return found_words 106 | 107 | def load_from_file(self, filepath: str): 108 | """从文件加载敏感词""" 109 | try: 110 | with open(filepath, 'r', encoding='utf-8') as f: 111 | words = [line.strip() for line in f if line.strip()] 112 | self.add_words(words) 113 | except FileNotFoundError: 114 | print(f"敏感词文件 {filepath} 不存在，使用默认词库") 115 | 116 | def save_to_file(self, filepath: str): 117 | """保存敏感词到文件""" 118 | with open(filepath, 'w', encoding='utf-8') as f: 119 | for word in sorted(self.sensitive_words): 120 | f.write(word + '\n') 121 | 122 | # 全局过滤器实例 123 | filter_instance = SensitiveWordFilter() 124 | 125 | def filter_sensitive_words(text: str, replacement: str = '*') -> str: 126 | """快速过滤函数""" 127 | return filter_instance.filter_text(text, replacement) 128 | 129 | def test_filter(): 130 | """测试过滤功能""" 131 | test_text = "这是一条包含机密信息的消息，涉及领导人和内部文件" 132 | 133 | print("原始文本:", test_text) 134 | print("过滤后:", filter_sensitive_words(test_text)) 135 | print("检测敏感词:", filter_instance.has_sensitive_words(test_text)) 136 | print("找到的敏感词:", filter_instance.find_sensitive_words(test_text)) 137 | 138 | if __name__ == "__main__": 139 | test_filter() -------------------------------------------------------------------------------- /qtf_mcp/symbols.py: -------------------------------------------------------------------------------- 1 | """ 2 | 股票符号管理模块 3 | 从confs/markets.json加载股票代码到名称的映射 4 | """ 5 | 6 | import json 7 | import os 8 | import logging 9 | from typing import Dict, List, Tuple, Optional 10 | 11 | logger = logging.getLogger("qtf_mcp") 12 | 13 | # 股票符号映射缓存 14 | SYMBOLS_CACHE: Dict[str, str] = {} 15 | MARKETS_FILE = "confs/markets.json" 16 | 17 | def load_markets_data() -> Dict[str, str]: 18 | """从markets.json加载股票代码到名称的映射""" 19 | symbols = {} 20 | 21 | try: 22 | if os.path.exists(MARKETS_FILE): 23 | with open(MARKETS_FILE, 'r', encoding='utf-8') as f: 24 | data = json.load(f) 25 | 26 | if 'items' in data: 27 | for item in data['items']: 28 | code = item.get('code', '') 29 | name = item.get('name', '') 30 | if code and name: 31 | symbols[code] = name 32 | 33 | logger.info(f"从 {MARKETS_FILE} 加载了 {len(symbols)} 个股票符号") 34 | else: 35 | logger.warning(f"找不到文件: {MARKETS_FILE}") 36 | 37 | except Exception as e: 38 | logger.error(f"加载 {MARKETS_FILE} 失败: {e}") 39 | 40 | return symbols 41 | 42 | def get_symbol_name(symbol: str) -> str: 43 | """获取股票代码对应的名称""" 44 | if not SYMBOLS_CACHE: 45 | SYMBOLS_CACHE.update(load_markets_data()) 46 | 47 | # 先从缓存中查找 48 | if symbol in SYMBOLS_CACHE: 49 | return SYMBOLS_CACHE[symbol] 50 | 51 | # 如果缓存中没有，尝试从AkShare获取 52 | try: 53 | import akshare as ak 54 | stock_code = symbol[2:] # 去掉SH/SZ前缀 55 | 56 | # 获取股票基本信息 57 | stock_info = ak.stock_individual_info_em(symbol=stock_code) 58 | if not stock_info.empty: 59 | name = stock_info[stock_info['item'] == '股票简称']['value'].values[0] 60 | SYMBOLS_CACHE[symbol] = name 61 | return name 62 | 63 | except Exception as e: 64 | logger.error(f"从AkShare获取股票名称失败: {e}") 65 | 66 | # 如果都失败，返回代码本身 67 | return symbol 68 | 69 | def symbol_with_name(symbols: List[str]) -> List[Tuple[str, str]]: 70 | """将股票代码列表转换为(代码, 名称)元组列表""" 71 | result = [] 72 | for symbol in symbols: 73 | name = get_symbol_name(symbol) 74 | result.append((symbol, name)) 75 | return result 76 | 77 | def get_all_symbols() -> List[str]: 78 | """获取所有可用的股票代码""" 79 | if not SYMBOLS_CACHE: 80 | SYMBOLS_CACHE.update(load_markets_data()) 81 | return list(SYMBOLS_CACHE.keys()) 82 | 83 | def get_symbols_by_sector(sector_name: str) -> List[str]: 84 | """根据板块名称获取该板块的所有股票代码""" 85 | from .datafeed import get_stock_sector 86 | 87 | sector_data = get_stock_sector() 88 | matching_symbols = [] 89 | 90 | for symbol, sectors in sector_data.items(): 91 | if sector_name in sectors: 92 | matching_symbols.append(symbol) 93 | 94 | return matching_symbols 95 | 96 | def get_available_sectors() -> List[str]: 97 | """获取所有可用的板块名称""" 98 | from .datafeed import get_stock_sector 99 | 100 | sector_data = get_stock_sector() 101 | all_sectors = set() 102 | 103 | for sectors in sector_data.values(): 104 | all_sectors.update(sectors) 105 | 106 | # 过滤掉一些不需要的板块 107 | filtered_sectors = [] 108 | keywords_to_exclude = ["MSCI", "标普", "同花顺", "融资融券", "沪股通", "深股通"] 109 | 110 | for sector in sorted(all_sectors): 111 | if not any(keyword in sector for keyword in keywords_to_exclude): 112 | filtered_sectors.append(sector) 113 | 114 | return filtered_sectors 115 | 116 | def filter_main_board_symbols(symbols: List[str]) -> List[str]: 117 | """过滤出主板股票（SH6开头和SZ00开头）""" 118 | return [s for s in symbols if s.startswith('SH6') or s.startswith('SZ00')] 119 | 120 | def filter_star_board_symbols(symbols: List[str]) -> List[str]: 121 | """过滤出科创板股票（SH688开头）""" 122 | return [s for s in symbols if s.startswith('SH688')] 123 | 124 | def filter_gem_board_symbols(symbols: List[str]) -> List[str]: 125 | """过滤出创业板股票（SZ30开头）""" 126 | return [s for s in symbols if s.startswith('SZ30')] 127 | 128 | def load_symbols() -> None: 129 | """加载股票符号数据到缓存""" 130 | global SYMBOLS_CACHE 131 | if not SYMBOLS_CACHE: 132 | SYMBOLS_CACHE.update(load_markets_data()) 133 | logger.info(f"已加载 {len(SYMBOLS_CACHE)} 个股票符号到缓存") 134 | 135 | # 初始化缓存 136 | if not SYMBOLS_CACHE: 137 | SYMBOLS_CACHE.update(load_markets_data()) -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | akshare>=1.17.0 2 | pandas>=2.0.0 3 | numpy>=1.24.0 4 | ta-lib>=0.4.0 5 | mcp[cli]>=1.10.0 -------------------------------------------------------------------------------- /start.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # 先杀掉之前的python3 main.py进程 4 | ps -ef | grep 'python main' | awk '{print $2}' | xargs kill -s 9 5 | 6 | # 等待进程完全结束 7 | sleep 2 8 | 9 | source ./myenv/bin/activate 10 | 11 | # 启动新的进程 12 | nohup python main.py > custom.log 2>&1 & 13 | 14 | echo "已重启 main.py 进程" 15 | echo "进程PID: $!" 16 | echo "日志文件: log.txt" -------------------------------------------------------------------------------- /start_sse.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # SSE接口启动脚本 4 | 5 | # 先杀掉之前的SSE服务进程 6 | pkill -f "python3 main.py --transport sse" 7 | 8 | # 等待进程完全结束 9 | sleep 2 10 | 11 | # 激活虚拟环境 12 | source venv/bin/activate 13 | 14 | # 设置默认端口 15 | PORT=${1:-8080} 16 | 17 | # 启动SSE服务 18 | echo "启动A股数据MCP服务 (SSE模式)..." 19 | echo "端口: $PORT" 20 | echo "访问地址: http://localhost:$PORT" 21 | echo "SSE端点: http://localhost:$PORT/sse" 22 | echo "" 23 | echo "按 Ctrl+C 停止服务" 24 | echo "" 25 | 26 | # 启动服务 27 | python3 main.py --transport sse --port $PORT -------------------------------------------------------------------------------- /stock_selector.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | """ 3 | 基于akshare的多因子选股策略 4 | 策略条件： 5 | 1. 股东户数连续3季减少 6 | 2. 换手率3%-20% 7 | 3. 日线与周线均线多头排列 8 | 4. 总市值20-250亿 9 | 5. 10日涨幅<15% 10 | 6. 当日主力资金净流入>1000万 11 | """ 12 | 13 | import akshare as ak 14 | import pandas as pd 15 | import numpy as np 16 | from datetime import datetime, timedelta 17 | import warnings 18 | import time 19 | 20 | warnings.filterwarnings('ignore') 21 | 22 | class StockSelector: 23 | def __init__(self): 24 | self.selected_stocks = [] 25 | 26 | def get_shareholder_data(self, date_list): 27 | """获取股东户数数据""" 28 | shareholder_data = [] 29 | for date in date_list: 30 | try: 31 | df = ak.stock_hold_num_cninfo(date=date) 32 | if df is not None and not df.empty: 33 | df['变动日期'] = pd.to_datetime(df['变动日期']) 34 | shareholder_data.append(df) 35 | except Exception as e: 36 | print(f"获取{date}股东数据失败: {e}") 37 | return shareholder_data 38 | 39 | def check_continuous_decline(self, stock_code, shareholder_data): 40 | """检查股东户数连续3季减少""" 41 | if len(shareholder_data) < 3: 42 | return False 43 | 44 | stock_data = [] 45 | for df in shareholder_data: 46 | data = df[df['证券代码'] == stock_code] 47 | if not data.empty: 48 | stock_data.append({ 49 | 'date': data.iloc[0]['变动日期'], 50 | 'holders': data.iloc[0]['本期股东人数'] 51 | }) 52 | 53 | if len(stock_data) < 3: 54 | return False 55 | 56 | # 按日期排序 57 | stock_data = sorted(stock_data, key=lambda x: x['date'], reverse=True) 58 | 59 | # 检查连续3期减少 60 | if len(stock_data) >= 3: 61 | return (stock_data[0]['holders'] < stock_data[1]['holders'] and 62 | stock_data[1]['holders'] < stock_data[2]['holders']) 63 | return False 64 | 65 | def get_turnover_rate(self, stock_code, stock_sh_a_spot_em_df): 66 | """获取换手率数据""" 67 | try: 68 | stock_data = stock_sh_a_spot_em_df[stock_sh_a_spot_em_df['代码'] == stock_code] 69 | if not stock_data.empty and '换手率' in stock_data.columns: 70 | turnover = float(stock_data.iloc[0]['换手率']) 71 | return 3 <= turnover <= 20 72 | except: 73 | pass 74 | return False 75 | 76 | def check_ma_alignment(self, stock_code, stock_zh_a_hist_df): 77 | """检查日线和周线均线多头排列""" 78 | try: 79 | 80 | 81 | if stock_zh_a_hist_df is not None and len(stock_zh_a_hist_df) > 20: 82 | # 计算日线均线 83 | close_prices = stock_zh_a_hist_df['收盘'].values 84 | ma5 = np.mean(close_prices[-5:]) 85 | ma10 = np.mean(close_prices[-10:]) 86 | ma20 = np.mean(close_prices[-20:]) 87 | 88 | # 日线多头排列 89 | daily_alignment = ma5 > ma10 > ma20 90 | 91 | # 由于akshare周线数据获取限制，这里简化处理日线 92 | return daily_alignment 93 | 94 | except Exception as e: 95 | print(f"均线检查失败 {stock_code}: {e}") 96 | return False 97 | 98 | def get_market_cap(self, stock_code, stock_sh_a_spot_em_df): 99 | """获取总市值""" 100 | try: 101 | stock_data = stock_sh_a_spot_em_df[stock_sh_a_spot_em_df['代码'] == stock_code] 102 | if not stock_data.empty and '总市值' in stock_data.columns: 103 | market_cap = float(stock_data.iloc[0]['总市值']) 104 | # 转换为亿元 105 | market_cap_billion = market_cap / 100000000 106 | return 20 <= market_cap_billion <= 250 107 | except: 108 | pass 109 | return False 110 | 111 | def get_10day_return(self, stock_code, stock_zh_a_hist_df): 112 | """获取10日涨幅""" 113 | try: 114 | if stock_zh_a_hist_df is not None and len(stock_zh_a_hist_df) >= 10: 115 | prices = stock_zh_a_hist_df['收盘'].values 116 | if len(prices) >= 10: 117 | return_10d = ((prices[-1] - prices[-10]) / prices[-10]) * 100 118 | return return_10d < 15 119 | 120 | except Exception as e: 121 | print(f"10日涨幅计算失败 {stock_code}: {e}") 122 | return False 123 | 124 | def get_10day_max_return(self, stock_code, stock_zh_a_hist_df): 125 | """获取10日最大涨幅""" 126 | try: 127 | if stock_zh_a_hist_df is not None and len(stock_zh_a_hist_df) >= 10: 128 | returns = stock_zh_a_hist_df['涨跌幅'].values 129 | if len(returns) >= 10: 130 | max_return_10d = max(returns[-10:]) 131 | return max_return_10d < 5 132 | 133 | except Exception as e: 134 | print(f"10日涨幅计算失败 {stock_code}: {e}") 135 | return False 136 | 137 | def get_main_fund_flow(self, stock_code): 138 | """获取当日主力资金净流入""" 139 | try: 140 | time.sleep(0.5) 141 | # 获取当日资金流向数据 142 | end_date = datetime.now().strftime('%Y%m%d') 143 | start_date = end_date 144 | 145 | # 使用个股资金流数据 146 | stock_individual_fund_flow_df = ak.stock_individual_fund_flow( 147 | stock=stock_code, 148 | market="sh" if stock_code.startswith('6') else "sz" 149 | ) 150 | 151 | if stock_individual_fund_flow_df is not None and not stock_individual_fund_flow_df.empty: 152 | # print(stock_individual_fund_flow_df.tail()) 153 | # 获取日期最大的一行（最新一天的主力净流入） 154 | # 假设日期列名为'日期'，如果不是需要根据实际列名调整 155 | if '日期' in stock_individual_fund_flow_df.columns: 156 | latest_flow = stock_individual_fund_flow_df.loc[stock_individual_fund_flow_df['日期'].idxmax()] 157 | else: 158 | # 如果没有日期列，则使用第一行作为备选 159 | latest_flow = stock_individual_fund_flow_df.iloc[0] 160 | 161 | if '主力净流入-净额' in latest_flow: 162 | main_inflow = float(latest_flow['主力净流入-净额']) 163 | return main_inflow > 10000000 # 1000万 164 | 165 | except Exception as e: 166 | print(f"资金流获取失败 {stock_code}: {e}") 167 | return False 168 | 169 | def get_recent_quarter_dates(self): 170 | """获取最近3个季度的报告日期""" 171 | now = datetime.now() 172 | year = now.year 173 | 174 | # 根据当前时间确定最近的季度 175 | if now.month <= 3: 176 | dates = [f"{year-1}1231", f"{year-1}0930", f"{year-1}0630"] 177 | elif now.month <= 6: 178 | dates = [f"{year}0331", f"{year-1}1231", f"{year-1}0930"] 179 | elif now.month <= 9: 180 | dates = [f"{year}0630", f"{year}0331", f"{year-1}1231"] 181 | else: 182 | dates = [f"{year}0930", f"{year}0630", f"{year}0331"] 183 | 184 | return dates 185 | 186 | def select_stocks(self): 187 | """执行选股策略""" 188 | print("开始执行选股策略...") 189 | print("=" * 60) 190 | 191 | # 获取最近3个季度的日期 192 | quarter_dates = self.get_recent_quarter_dates() 193 | print(f"使用季度日期: {quarter_dates}") 194 | 195 | # 获取股东数据 196 | print("获取股东户数数据...") 197 | shareholder_data = self.get_shareholder_data(quarter_dates) 198 | 199 | if len(shareholder_data) < 3: 200 | print("❌ 股东数据不足，无法执行连续3季减少检查") 201 | return [] 202 | 203 | # 获取股票列表 204 | print("获取股票列表...") 205 | try: 206 | stock_sh_a_spot_em_df = ak.stock_sh_a_spot_em() 207 | if stock_sh_a_spot_em_df is None or stock_sh_a_spot_em_df.empty: 208 | print("❌ 无法获取股票列表") 209 | return [] 210 | 211 | all_stocks = stock_sh_a_spot_em_df['代码'].tolist() 212 | print(f"共获取 {len(all_stocks)} 只股票") 213 | 214 | except Exception as e: 215 | print(f"❌ 获取股票列表失败: {e}") 216 | return [] 217 | 218 | selected_stocks = [] 219 | 220 | for stock_code in all_stocks: 221 | if self.get_turnover_rate(stock_code, stock_sh_a_spot_em_df) and self.get_market_cap(stock_code, stock_sh_a_spot_em_df) and self.check_continuous_decline(stock_code, shareholder_data): 222 | # 获取日线数据 223 | end_date = datetime.now().strftime('%Y%m%d') 224 | start_date = (datetime.now() - timedelta(days=100)).strftime('%Y%m%d') 225 | 226 | # 使用akshare获取日线数据 227 | stock_zh_a_hist_df = ak.stock_zh_a_hist(symbol=stock_code, period="daily", start_date=start_date, end_date=end_date, adjust="") 228 | time.sleep(0.5) 229 | try: 230 | # 应用所有筛选条件 231 | checks = [ 232 | ("股东户数连续减少", self.check_continuous_decline(stock_code, shareholder_data)), 233 | ("换手率范围", self.get_turnover_rate(stock_code, stock_sh_a_spot_em_df)), 234 | ("均线多头排列", self.check_ma_alignment(stock_code, stock_zh_a_hist_df)), 235 | ("市值范围", self.get_market_cap(stock_code, stock_sh_a_spot_em_df)), 236 | ("10日涨幅限制", self.get_10day_return(stock_code, stock_zh_a_hist_df)), 237 | ("主力资金流入", self.get_main_fund_flow(stock_code)) 238 | ] 239 | 240 | # 检查所有条件 241 | all_passed = True 242 | failed_conditions = [] 243 | 244 | for condition_name, passed in checks: 245 | if not passed: 246 | all_passed = False 247 | failed_conditions.append(condition_name) 248 | 249 | if all_passed: 250 | # 获取股票基本信息 251 | stock_info = stock_sh_a_spot_em_df[stock_sh_a_spot_em_df['代码'] == stock_code].iloc[0] 252 | selected_stocks.append({ 253 | '代码': stock_code, 254 | '名称': stock_info['名称'], 255 | '当前价': stock_info['最新价'], 256 | '市值': stock_info['总市值'] / 100000000, # 亿元 257 | '换手率': stock_info['换手率'] if '换手率' in stock_info else None 258 | }) 259 | print(f"✅ 选中: {stock_code} - {stock_info['名称']}") 260 | 261 | except Exception as e: 262 | continue # 跳过出错的股票 263 | 264 | return selected_stocks 265 | 266 | def save_results(self, stocks): 267 | """保存选股结果""" 268 | if not stocks: 269 | print("\n❌ 未选到符合条件的股票") 270 | return 271 | 272 | df = pd.DataFrame(stocks) 273 | filename = f"selected_stocks_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv" 274 | df.to_csv(filename, index=False, encoding='utf-8-sig') 275 | 276 | print(f"\n✅ 选股完成！") 277 | print(f"共选中 {len(stocks)} 只股票") 278 | print(f"结果已保存到: {filename}") 279 | 280 | # 显示结果 281 | print("\n选中的股票:") 282 | print(df.to_string()) 283 | 284 | def main(): 285 | """主函数""" 286 | selector = StockSelector() 287 | 288 | print("多因子选股策略") 289 | print("=" * 60) 290 | print("策略条件:") 291 | print("1. 股东户数连续3季减少") 292 | print("2. 换手率3%-20%") 293 | print("3. 日线与周线均线多头排列") 294 | print("4. 总市值20-250亿") 295 | print("5. 10日涨幅<15% 且 10日中最大涨幅 < 7%") 296 | print("6. 当日主力资金净流入>1000万") 297 | print("=" * 60) 298 | 299 | # 执行选股 300 | selected_stocks = selector.select_stocks() 301 | 302 | # 保存结果 303 | selector.save_results(selected_stocks) 304 | 305 | if __name__ == "__main__": 306 | main() -------------------------------------------------------------------------------- /test_akshare_direct.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # -*- coding: utf-8 -*- 3 | """ 4 | 直接测试akshare API 5 | """ 6 | 7 | import akshare as ak 8 | from datetime import datetime, timedelta 9 | 10 | def test_akshare_direct(): 11 | """直接测试akshare分钟级数据API""" 12 | print("直接测试akshare分钟级数据API...") 13 | 14 | # 测试参数 - 尝试最近的交易日 15 | symbols = ["000001", "600000"] # 不带前缀的代码 16 | # 不指定具体日期，看看能否获取到最新数据 17 | period = "1" 18 | 19 | print(f"时间间隔: {period} 分钟") 20 | print("不指定日期范围，获取默认数据") 21 | 22 | for symbol in symbols: 23 | print(f"\n=== 测试代码: {symbol} ===") 24 | 25 | # 测试指数分钟级数据 26 | print("\n--- 测试 index_zh_a_hist_min_em ---") 27 | try: 28 | df = ak.index_zh_a_hist_min_em( 29 | symbol=symbol, 30 | period=period 31 | ) 32 | print(f"返回类型: {type(df)}") 33 | if df is not None: 34 | print(f"数据形状: {df.shape}") 35 | if not df.empty: 36 | print(f"列名: {list(df.columns)}") 37 | print(f"前3行数据:") 38 | print(df.head(3)) 39 | else: 40 | print("返回空数据框") 41 | else: 42 | print("返回None") 43 | except Exception as e: 44 | print(f"index_zh_a_hist_min_em 出错: {e}") 45 | 46 | # 测试股票分钟级数据 47 | print("\n--- 测试 stock_zh_a_hist_min_em ---") 48 | try: 49 | df = ak.stock_zh_a_hist_min_em( 50 | symbol=symbol, 51 | period=period 52 | ) 53 | print(f"返回类型: {type(df)}") 54 | if df is not None: 55 | print(f"数据形状: {df.shape}") 56 | if not df.empty: 57 | print(f"列名: {list(df.columns)}") 58 | print(f"前3行数据:") 59 | print(df.head(3)) 60 | else: 61 | print("返回空数据框") 62 | else: 63 | print("返回None") 64 | except Exception as e: 65 | print(f"stock_zh_a_hist_min_em 出错: {e}") 66 | 67 | print("\n测试完成!") 68 | 69 | if __name__ == "__main__": 70 | test_akshare_direct() -------------------------------------------------------------------------------- /test_akshare_hold_num.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | """ 3 | 测试akshare的股东人数数据接口 4 | 测试接口: stock_hold_num_cninfo - 股东人数数据 5 | """ 6 | 7 | import akshare as ak 8 | import pandas as pd 9 | from datetime import datetime 10 | 11 | def test_stock_hold_num_cninfo(): 12 | """测试股东人数数据接口""" 13 | print("=" * 60) 14 | print("测试akshare股东人数数据接口") 15 | print("=" * 60) 16 | 17 | try: 18 | # 测试指定日期的股东人数数据 19 | test_date = "20210630" 20 | print(f"正在获取 {test_date} 的股东人数数据...") 21 | 22 | stock_hold_num_cninfo_df = ak.stock_hold_num_cninfo(date=test_date) 23 | 24 | if stock_hold_num_cninfo_df is not None and not stock_hold_num_cninfo_df.empty: 25 | print(f"✅ 成功获取数据！") 26 | print(f"数据形状: {stock_hold_num_cninfo_df.shape}") 27 | print(f"列名: {list(stock_hold_num_cninfo_df.columns)}") 28 | print() 29 | 30 | # 显示前10条数据 31 | print("前10条数据:") 32 | print(stock_hold_num_cninfo_df.head(10)) 33 | print() 34 | 35 | # 显示数据基本信息 36 | print("数据基本信息:") 37 | print(f"- 总记录数: {len(stock_hold_num_cninfo_df)}") 38 | print(f"- 股票代码范围: {stock_hold_num_cninfo_df['证券代码'].min()} - {stock_hold_num_cninfo_df['证券代码'].max()}") 39 | print(f"- 股东人数范围: {stock_hold_num_cninfo_df['本期股东人数'].min()} - {stock_hold_num_cninfo_df['本期股东人数'].max()}") 40 | 41 | # 保存到CSV文件 42 | output_file = f"hold_num_{test_date}.csv" 43 | stock_hold_num_cninfo_df.to_csv(output_file, index=False, encoding='utf-8-sig') 44 | print(f"\n💾 数据已保存到: {output_file}") 45 | 46 | else: 47 | print("❌ 未获取到任何数据") 48 | 49 | except Exception as e: 50 | print(f"❌ 获取数据时出错: {str(e)}") 51 | print("错误类型:", type(e).__name__) 52 | 53 | # 尝试其他日期 54 | print("\n尝试获取其他日期的数据...") 55 | alt_dates = ["20211231", "20220331", "20220630"] 56 | for alt_date in alt_dates: 57 | try: 58 | alt_df = ak.stock_hold_num_cninfo(date=alt_date) 59 | if alt_df is not None and not alt_df.empty: 60 | print(f"✅ {alt_date} 有数据: {len(alt_df)} 条记录") 61 | except: 62 | continue 63 | else: 64 | print(f"⚠️ {alt_date}: 无数据") 65 | 66 | def test_recent_hold_num(): 67 | """测试获取最近季度的股东人数数据""" 68 | print("\n" + "=" * 60) 69 | print("测试获取最近季度的股东人数数据") 70 | print("=" * 60) 71 | 72 | # 最近几个季度的日期 73 | recent_quarters = [ 74 | "20240930", # 2024年三季报 75 | "20241231", # 2024年年报 76 | "20250331", # 2025年一季报 77 | "20250630", # 2025年中报 78 | ] 79 | 80 | for date in recent_quarters: 81 | try: 82 | print(f"\n尝试获取 {date} 的数据...") 83 | df = ak.stock_hold_num_cninfo(date=date) 84 | if df is not None and not df.empty: 85 | print(f"✅ {date}: 成功获取 {len(df)} 条记录") 86 | # 显示前3条数据作为示例 87 | print("示例数据:") 88 | print(df[df['证券代码'].str.startswith('000001')][['证券代码', '证券简称', '本期股东人数', '股东人数增幅', '变动日期']].to_string()) 89 | else: 90 | print(f"⚠️ {date}: 无数据") 91 | except Exception as e: 92 | print(f"❌ {date}: 错误 - {str(e)}") 93 | 94 | def test_specific_stock(): 95 | """测试查询特定股票的股东人数变化""" 96 | print("\n" + "=" * 60) 97 | print("测试查询特定股票的股东人数变化") 98 | print("=" * 60) 99 | 100 | # 测试几个知名股票 101 | test_stocks = ['000001', '000002', '600000', '600519'] # 平安银行、万科A、浦发银行、贵州茅台 102 | 103 | # 获取最近一个季度的数据 104 | try: 105 | latest_df = ak.stock_hold_num_cninfo(date="20250630") 106 | if latest_df is not None and not latest_df.empty: 107 | # 筛选特定股票 108 | for stock in test_stocks: 109 | stock_data = latest_df[latest_df['证券代码'] == stock] 110 | if not stock_data.empty: 111 | print(f"\n{stock} - {stock_data.iloc[0]['证券简称']}") 112 | print(f"股东人数: {stock_data.iloc[0]['本期股东人数']:,}") 113 | print(f"股东人数增幅: {stock_data.iloc[0]['股东人数增幅']}%") 114 | print(f"变动日期: {stock_data.iloc[0]['变动日期']}") 115 | except Exception as e: 116 | print(f"查询特定股票时出错: {str(e)}") 117 | 118 | if __name__ == "__main__": 119 | print("开始测试akshare股东人数接口...") 120 | 121 | # 运行各种测试 122 | # test_stock_hold_num_cninfo() 123 | test_recent_hold_num() 124 | # test_specific_stock() 125 | 126 | print("\n" + "=" * 60) 127 | print("测试完成！") 128 | print("=" * 60) 129 | 130 | # 使用说明 131 | print("\n📋 使用说明:") 132 | print("1. 股东人数数据按季度更新") 133 | print("2. 日期格式: YYYYMMDD") 134 | print("3. 常用日期: 0331(一季报)、0630(中报)、0930(三季报)、1231(年报)") 135 | print("4. 数据包含: 证券代码、证券简称、本期股东人数、股东人数增幅、变动日期、人均持股数量等") -------------------------------------------------------------------------------- /test_daily_news.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | """ 3 | 测试daily_news工具的脚本 4 | """ 5 | 6 | import sys 7 | import os 8 | import datetime 9 | 10 | # 添加当前目录到路径 11 | sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) 12 | 13 | from qtf_mcp.news_extractor import NewsExtractor 14 | 15 | def test_daily_news_function(date_str): 16 | """测试daily_news功能""" 17 | try: 18 | # 解析日期 19 | target_date = datetime.datetime.strptime(date_str, '%Y-%m-%d').date() 20 | 21 | # 创建新闻提取器实例 22 | extractor = NewsExtractor() 23 | 24 | # 获取指定日期的新闻内容 25 | news_result = extractor.get_news_content(target_date) 26 | 27 | if news_result['status'] == 'success': 28 | print(f"✅ 获取 {date_str} 新闻联播成功") 29 | print(f"📺 标题: {news_result['title']}") 30 | print(f"📅 日期: {news_result['date']}") 31 | print(f"🔗 链接: {news_result['url']}") 32 | print("=" * 60) 33 | print("📋 内容预览:") 34 | print(news_result['content'][:500] + "...") 35 | 36 | if news_result['news_items']: 37 | print(f"\n📊 新闻条目: {len(news_result['news_items'])} 条") 38 | for i, item in enumerate(news_result['news_items'][:3], 1): 39 | print(f" {i}. {item['title'][:50]}...") 40 | 41 | return True 42 | else: 43 | print(f"❌ 获取失败: {news_result.get('error', '未知错误')}") 44 | return False 45 | 46 | except ValueError as e: 47 | print(f"❌ 日期格式错误: {e}") 48 | return False 49 | except Exception as e: 50 | print(f"❌ 发生错误: {e}") 51 | return False 52 | 53 | if __name__ == "__main__": 54 | if len(sys.argv) > 1: 55 | date_str = sys.argv[1] 56 | else: 57 | date_str = "2024-01-15" 58 | 59 | test_daily_news_function(date_str) -------------------------------------------------------------------------------- /test_date.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | import sys 3 | import os 4 | 5 | # 添加项目路径 6 | sys.path.insert(0, os.path.join(os.path.dirname(__file__), '.')) 7 | 8 | from qtf_mcp import research 9 | 10 | async def test_date_format(): 11 | symbol = "SH600276" 12 | 13 | # 获取原始数据 14 | raw_data = await research.load_raw_data(symbol, "2024-08-01", "2024-08-28") 15 | 16 | print("时间戳数据类型:", type(raw_data["DATE"])) 17 | print("时间戳数组:", raw_data["DATE"]) 18 | print("最后一个时间戳:", raw_data["DATE"][-1]) 19 | print("时间戳值:", raw_data["DATE"][-1]) 20 | 21 | # 尝试不同的转换方式 22 | import datetime 23 | ts = raw_data["DATE"][-1] 24 | 25 | # 方式1: 纳秒级时间戳 26 | try: 27 | date1 = datetime.datetime.fromtimestamp(ts / 1e9) 28 | print("纳秒级转换:", date1) 29 | except Exception as e: 30 | print("纳秒级转换失败:", e) 31 | 32 | # 方式2: 毫秒级时间戳 33 | try: 34 | date2 = datetime.datetime.fromtimestamp(ts / 1000) 35 | print("毫秒级转换:", date2) 36 | except Exception as e: 37 | print("毫秒级转换失败:", e) 38 | 39 | # 方式3: 直接作为秒级时间戳 40 | try: 41 | date3 = datetime.datetime.fromtimestamp(ts) 42 | print("秒级转换:", date3) 43 | except Exception as e: 44 | print("秒级转换失败:", e) 45 | 46 | if __name__ == "__main__": 47 | asyncio.run(test_date_format()) -------------------------------------------------------------------------------- /test_full.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | """ 3 | 测试full工具功能 4 | """ 5 | import asyncio 6 | import sys 7 | import os 8 | from io import StringIO 9 | 10 | # 添加项目根目录到路径 11 | sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) 12 | 13 | from qtf_mcp import research 14 | 15 | async def test_full(): 16 | """测试full工具""" 17 | try: 18 | symbol = "SH600276" 19 | print(f"正在测试股票 {symbol} 的full报告...") 20 | 21 | # 直接调用research模块的函数，使用更近的日期 22 | raw_data = await research.load_raw_data(symbol, "2024-08-01", "2024-08-28") 23 | 24 | if len(raw_data) == 0: 25 | print("✗ 没有找到数据") 26 | return False 27 | 28 | buf = StringIO() 29 | research.build_basic_data(buf, symbol, raw_data) 30 | research.build_trading_data(buf, symbol, raw_data) 31 | research.build_financial_data(buf, symbol, raw_data) 32 | research.build_technical_data(buf, symbol, raw_data) 33 | 34 | content = buf.getvalue() 35 | print("✓ full工具执行成功") 36 | print("报告内容预览:") 37 | print("=" * 50) 38 | print(content[:500] + "..." if len(content) > 500 else content) 39 | print("=" * 50) 40 | return True 41 | 42 | except Exception as e: 43 | print(f"✗ full工具执行失败: {str(e)}") 44 | import traceback 45 | traceback.print_exc() 46 | return False 47 | 48 | if __name__ == "__main__": 49 | asyncio.run(test_full()) -------------------------------------------------------------------------------- /test_improved_sector_stocks.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | """ 3 | Test script for improved sector_stocks tool 4 | """ 5 | 6 | import sys 7 | import os 8 | import asyncio 9 | from unittest.mock import AsyncMock, MagicMock 10 | 11 | # Add the project root to path 12 | sys.path.insert(0, '/Users/huangchuang/mcp-cn-a-stock') 13 | 14 | # Import the mcp_app 15 | from qtf_mcp.mcp_app import sector_stocks 16 | 17 | class MockContext: 18 | def __init__(self): 19 | self.request_context = MagicMock() 20 | self.request_context.request.client.host = "test_client" 21 | 22 | async def test_sector_stocks(): 23 | """Test the improved sector_stocks function""" 24 | 25 | test_cases = [ 26 | ("人工智能", "main", 10), 27 | ("新能源", "all", 15), 28 | ("医药", "main", 8), 29 | ("半导体", "gem", 5), 30 | ("电池", "main", 12), 31 | ] 32 | 33 | print("=== 测试改进后的sector_stocks工具 ===\n") 34 | 35 | for sector_name, board_type, limit in test_cases: 36 | print(f"测试板块: {sector_name}, 类型: {board_type}, 限制: {limit}") 37 | print("-" * 50) 38 | 39 | try: 40 | # Create mock context 41 | ctx = MockContext() 42 | 43 | # Call the sector_stocks function 44 | result = await sector_stocks(sector_name, board_type, limit, ctx) 45 | 46 | # Print the result 47 | print(result) 48 | print("\n") 49 | 50 | except Exception as e: 51 | print(f"错误: {str(e)}") 52 | print("\n") 53 | 54 | if __name__ == "__main__": 55 | # Run the test 56 | asyncio.run(test_sector_stocks()) -------------------------------------------------------------------------------- /test_medium_function.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import asyncio 4 | import sys 5 | import os 6 | from io import StringIO 7 | 8 | # 添加项目路径 9 | sys.path.insert(0, os.path.join(os.path.dirname(__file__), '.')) 10 | 11 | from qtf_mcp import research 12 | 13 | class MockContext: 14 | """模拟MCP Context""" 15 | def __init__(self): 16 | class MockClient: 17 | host = "test_client" 18 | 19 | class MockRequest: 20 | client = MockClient() 21 | 22 | class MockRequestContext: 23 | request = MockRequest() 24 | 25 | self.request_context = MockRequestContext() 26 | 27 | async def test_medium_function(): 28 | """测试medium函数是否能正常处理SZ300711""" 29 | symbol = "SZ300711" 30 | 31 | print(f"=== 测试medium函数: {symbol} ===\n") 32 | 33 | try: 34 | # 模拟medium函数的逻辑 35 | who = "test_client" 36 | raw_data = await research.load_raw_data(symbol, None, who) 37 | 38 | if len(raw_data) == 0: 39 | print("❌ 未获取到数据") 40 | return False 41 | 42 | print(f"✅ 成功获取数据，字段数量: {len(raw_data)}") 43 | print(f"数据字段: {list(raw_data.keys())}") 44 | print(f"TCAP字段存在: {'TCAP' in raw_data}") 45 | 46 | # 测试各个构建函数 47 | buf = StringIO() 48 | 49 | print("\n测试build_basic_data...") 50 | research.build_basic_data(buf, symbol, raw_data) 51 | print("✅ build_basic_data 成功") 52 | 53 | print("测试build_trading_data...") 54 | research.build_trading_data(buf, symbol, raw_data) 55 | print("✅ build_trading_data 成功") 56 | 57 | print("测试build_financial_data...") 58 | research.build_financial_data(buf, symbol, raw_data) 59 | print("✅ build_financial_data 成功") 60 | 61 | result = buf.getvalue() 62 | print(f"\n✅ 完整报告生成成功，长度: {len(result)} 字符") 63 | 64 | # 显示报告的前500个字符 65 | print("\n=== 报告预览 ===") 66 | print(result[:500] + "..." if len(result) > 500 else result) 67 | 68 | return True 69 | 70 | except Exception as e: 71 | print(f"❌ 测试失败: {e}") 72 | import traceback 73 | traceback.print_exc() 74 | return False 75 | 76 | if __name__ == "__main__": 77 | print("开始测试medium函数修复效果...\n") 78 | 79 | success = asyncio.run(test_medium_function()) 80 | 81 | if success: 82 | print("\n🎉 medium函数测试通过 - 修复成功") 83 | else: 84 | print("\n❌ medium函数测试失败") 85 | sys.exit(1) -------------------------------------------------------------------------------- /test_minute_data.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # -*- coding: utf-8 -*- 3 | """ 4 | 测试分钟级数据获取功能 5 | """ 6 | 7 | import sys 8 | import os 9 | from datetime import datetime, timedelta 10 | import akshare as ak 11 | 12 | # 添加项目路径 13 | sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'qtf_mcp')) 14 | 15 | from qtf_mcp.datafeed import fetch_minute_data 16 | 17 | def test_minute_data(): 18 | """测试分钟级数据获取""" 19 | print("开始测试分钟级数据获取功能...") 20 | 21 | # 测试参数 - 使用一个确定的交易日期 22 | symbols = ["SZ000001", "SH600000"] # 测试股票和指数 23 | start_datetime = "2025-08-12 09:30:00" # 交易日的开盘时间 24 | end_datetime = "2025-08-12 15:00:00" # 交易日的收盘时间 25 | 26 | print(f"时间范围: {start_datetime} 到 {end_datetime}") 27 | 28 | # 测试不同的股票代码和时间间隔 29 | periods = ["5"] 30 | 31 | for symbol in symbols: 32 | print(f"\n=== 测试股票: {symbol} ===") 33 | 34 | for period in periods: 35 | print(f"\n--- 测试 {period} 分钟级数据 ---") 36 | try: 37 | data = fetch_minute_data(symbol, start_datetime, end_datetime, period) 38 | 39 | if data is not None and not data.empty: 40 | print(f"✓ 成功获取 {len(data)} 条 {period} 分钟级数据") 41 | print(f"数据列: {list(data.columns)}") 42 | print(f"时间范围: {data['datetime'].min()} 到 {data['datetime'].max()}") 43 | print(f"价格范围: {data['close'].min():.2f} - {data['close'].max():.2f}") 44 | 45 | # 显示前3条数据 46 | print("前3条数据:") 47 | for i in range(min(3, len(data))): 48 | row = data.iloc[i] 49 | print(f" {row['datetime']}: 开{row['open']:.2f} 高{row['high']:.2f} 低{row['low']:.2f} 收{row['close']:.2f} 量{row['volume']:.0f}") 50 | break # 如果成功获取数据，跳出period循环 51 | else: 52 | print(f"✗ 未获取到 {period} 分钟级数据") 53 | 54 | except Exception as e: 55 | print(f"✗ 获取 {period} 分钟级数据时出错: {e}") 56 | 57 | print("\n测试完成!") 58 | 59 | if __name__ == "__main__": 60 | # test_minute_data() 61 | stock_zh_a_hist_min_em_df = ak.stock_zh_a_hist_min_em( 62 | symbol="600276", 63 | start_date="2025-08-13 09:30:00", 64 | end_date="2025-08-13 15:00:00", 65 | period="5", 66 | ) 67 | print(stock_zh_a_hist_min_em_df) -------------------------------------------------------------------------------- /test_original_issue.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | """ 3 | Test the original issue: sector_stocks with 人工智能, main, 50 4 | """ 5 | 6 | import sys 7 | import os 8 | import asyncio 9 | from unittest.mock import AsyncMock, MagicMock 10 | 11 | # Add the project root to path 12 | sys.path.insert(0, '/Users/huangchuang/mcp-cn-a-stock') 13 | 14 | # Import the mcp_app 15 | from qtf_mcp.mcp_app import sector_stocks 16 | 17 | class MockContext: 18 | def __init__(self): 19 | self.request_context = MagicMock() 20 | self.request_context.request.client.host = "test_client" 21 | 22 | async def test_original_issue(): 23 | """Test the exact parameters from the original issue""" 24 | 25 | print("=== 测试原始问题参数 ===") 26 | print("参数: sector_name='人工智能', board_type='main', limit=50") 27 | print("-" * 50) 28 | 29 | try: 30 | # Create mock context 31 | ctx = MockContext() 32 | 33 | # Call the sector_stocks function with original parameters 34 | result = await sector_stocks("人工智能", "main", 50, ctx) 35 | 36 | # Print the result 37 | print(result) 38 | 39 | except Exception as e: 40 | print(f"错误: {str(e)}") 41 | 42 | if __name__ == "__main__": 43 | # Run the test 44 | asyncio.run(test_original_issue()) -------------------------------------------------------------------------------- /test_sector.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # -*- coding: utf-8 -*- 3 | """ 4 | 测试板块股票数据获取功能 5 | """ 6 | 7 | import asyncio 8 | import sys 9 | import os 10 | 11 | # 添加项目路径 12 | sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) 13 | 14 | from qtf_mcp.symbols import get_available_sectors, get_symbols_by_sector, filter_main_board_symbols 15 | from qtf_mcp.research import load_sector_basic_data 16 | 17 | 18 | async def test_sector_functions(): 19 | """测试板块相关函数""" 20 | print("=== 测试板块功能 ===") 21 | 22 | # 测试获取可用板块 23 | print("\n1. 测试获取可用板块列表...") 24 | sectors = get_available_sectors() 25 | print(f"共找到 {len(sectors)} 个板块") 26 | print(f"前10个板块: {sectors[:10]}") 27 | 28 | # 测试获取指定板块的股票 29 | if sectors: 30 | test_sector = "新能源汽车" # 选择一个常见的板块 31 | if test_sector in sectors: 32 | print(f"\n2. 测试获取 '{test_sector}' 板块股票...") 33 | sector_symbols = get_symbols_by_sector(test_sector) 34 | print(f"'{test_sector}' 板块共有 {len(sector_symbols)} 只股票") 35 | print(f"前5只股票: {sector_symbols[:5]}") 36 | 37 | # 测试主板过滤 38 | main_board_symbols = filter_main_board_symbols(sector_symbols) 39 | print(f"其中主板股票: {len(main_board_symbols)} 只") 40 | 41 | # 测试获取板块基础数据（限制为5只股票以加快测试） 42 | print(f"\n3. 测试获取 '{test_sector}' 板块基础数据...") 43 | try: 44 | result = await load_sector_basic_data(test_sector, "main", 5, "test") 45 | print("数据获取成功！") 46 | print("结果预览:") 47 | lines = result.split('\n') 48 | for line in lines[:15]: # 只显示前15行 49 | print(line) 50 | if len(lines) > 15: 51 | print("...") 52 | except Exception as e: 53 | print(f"数据获取失败: {e}") 54 | else: 55 | print(f"\n2. 板块 '{test_sector}' 不存在，使用第一个板块进行测试") 56 | test_sector = sectors[0] 57 | sector_symbols = get_symbols_by_sector(test_sector) 58 | print(f"'{test_sector}' 板块共有 {len(sector_symbols)} 只股票") 59 | 60 | print("\n=== 测试完成 ===") 61 | 62 | 63 | if __name__ == "__main__": 64 | asyncio.run(test_sector_functions()) -------------------------------------------------------------------------------- /test_sector_stocks.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | """ 3 | 测试板块股票获取功能 4 | """ 5 | 6 | import asyncio 7 | from qtf_mcp.mcp_app import sector_stocks 8 | from mcp.server.fastmcp import Context 9 | from unittest.mock import Mock 10 | 11 | class MockRequest: 12 | def __init__(self): 13 | self.client = Mock() 14 | self.client.host = "127.0.0.1" 15 | 16 | class MockContext: 17 | def __init__(self): 18 | self.request_context = Mock() 19 | self.request_context.request = MockRequest() 20 | 21 | async def test_sector_stocks(): 22 | """测试获取板块股票功能""" 23 | 24 | # 测试用例 25 | test_cases = [ 26 | {"sector_name": "人工智能", "board_type": "main", "limit": 10}, 27 | {"sector_name": "新能源", "board_type": "all", "limit": 15}, 28 | {"sector_name": "医药", "board_type": "main", "limit": 8}, 29 | {"sector_name": "半导体", "board_type": "gem", "limit": 5}, 30 | ] 31 | 32 | ctx = MockContext() 33 | 34 | for test_case in test_cases: 35 | print(f"\n{'='*60}") 36 | print(f"测试板块: {test_case['sector_name']} ({test_case['board_type']}板)") 37 | print(f"限制数量: {test_case['limit']}") 38 | print(f"{'='*60}") 39 | 40 | try: 41 | result = await sector_stocks( 42 | test_case["sector_name"], 43 | test_case["board_type"], 44 | test_case["limit"], 45 | ctx 46 | ) 47 | print(result) 48 | except Exception as e: 49 | print(f"错误: {e}") 50 | 51 | if __name__ == "__main__": 52 | asyncio.run(test_sector_stocks()) -------------------------------------------------------------------------------- /test_simple_hold_num.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | """ 3 | 简单测试akshare股东人数接口 4 | 测试用户指定的接口调用 5 | """ 6 | 7 | import akshare as ak 8 | 9 | # 测试用户指定的调用 10 | print("测试akshare股东人数接口...") 11 | print("调用: ak.stock_hold_num_cninfo(date='20210630')") 12 | print("-" * 50) 13 | 14 | try: 15 | stock_hold_num_cninfo_df = ak.stock_hold_num_cninfo(date="20250930") 16 | 17 | if stock_hold_num_cninfo_df is not None and not stock_hold_num_cninfo_df.empty: 18 | print("✅ 成功获取数据！") 19 | print(f"数据形状: {stock_hold_num_cninfo_df.shape}") 20 | print(f"列名: {list(stock_hold_num_cninfo_df.columns)}") 21 | print() 22 | print("前5条数据:") 23 | print(stock_hold_num_cninfo_df.head()) 24 | else: 25 | print("❌ 未获取到数据") 26 | 27 | except Exception as e: 28 | print(f"❌ 错误: {e}") 29 | 30 | print("\n" + "=" * 50) 31 | print("测试完成！") -------------------------------------------------------------------------------- /test_symbols.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import asyncio 4 | import sys 5 | import os 6 | sys.path.insert(0, os.path.join(os.path.dirname(__file__), '.')) 7 | 8 | from qtf_mcp.symbols import symbol_with_name, get_symbol_name, get_all_symbols 9 | 10 | async def test_symbols(): 11 | """测试符号管理模块""" 12 | 13 | print("=== 测试股票符号管理 ===") 14 | 15 | # 测试单个股票名称获取 16 | symbol = "SH600276" 17 | name = get_symbol_name(symbol) 18 | print(f"股票 {symbol} 的名称: {name}") 19 | 20 | # 测试多个股票 21 | symbols = ["SH600276", "SZ000001", "SH000001"] 22 | symbol_names = symbol_with_name(symbols) 23 | print(f"\n多个股票测试:") 24 | for sym, name in symbol_names: 25 | print(f" {sym}: {name}") 26 | 27 | # 测试从markets.json加载的数据 28 | all_symbols = get_all_symbols() 29 | print(f"\n从markets.json加载的股票总数: {len(all_symbols)}") 30 | 31 | # 显示前10个作为示例 32 | print("\n前10个股票示例:") 33 | for i, sym in enumerate(all_symbols[:10]): 34 | name = get_symbol_name(sym) 35 | print(f" {i+1}. {sym}: {name}") 36 | 37 | if __name__ == "__main__": 38 | asyncio.run(test_symbols()) -------------------------------------------------------------------------------- /test_tcap_fix.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import sys 4 | import os 5 | from io import StringIO 6 | import numpy as np 7 | 8 | # 添加项目路径 9 | sys.path.insert(0, os.path.join(os.path.dirname(__file__), '.')) 10 | 11 | from qtf_mcp import research 12 | 13 | def test_tcap_fix(): 14 | """测试TCAP字段缺失时的处理""" 15 | symbol = "SZ300711" 16 | 17 | print(f"=== 测试股票: {symbol} ===\n") 18 | 19 | # 模拟没有TCAP字段的数据 20 | mock_data = { 21 | 'DATE': np.array([1640995200, 1641081600, 1641168000]), # 3天的时间戳 22 | 'OPEN': np.array([10.0, 10.5, 11.0]), 23 | 'HIGH': np.array([10.5, 11.0, 11.5]), 24 | 'LOW': np.array([9.5, 10.0, 10.5]), 25 | 'CLOSE': np.array([10.2, 10.8, 11.2]), 26 | 'VOLUME': np.array([1000000, 1200000, 1100000]), 27 | 'AMOUNT': np.array([10200000, 12960000, 12320000]), 28 | 'CLOSE2': np.array([10.2, 10.8, 11.2]), 29 | 'PRICE': np.array([10.2, 10.8, 11.2]), 30 | 'GCASH': np.array([0.0, 0.0, 0.0]), 31 | 'GSHARE': np.array([0.0, 0.0, 0.0]), 32 | 'SECTOR': ['新能源汽车', '锂电池'] 33 | # 注意：这里故意不包含TCAP字段 34 | } 35 | 36 | try: 37 | # 测试build_trading_data函数 38 | buf = StringIO() 39 | research.build_trading_data(buf, symbol, mock_data) 40 | result = buf.getvalue() 41 | 42 | print("=== 交易数据构建成功 ===") 43 | print("输出长度:", len(result)) 44 | print("\n输出内容:") 45 | print(result) 46 | 47 | # 检查是否包含换手率信息 48 | if "换手率" in result: 49 | print("❌ 错误：仍然包含换手率信息（应该被跳过）") 50 | return False 51 | else: 52 | print("✅ 正确：未包含换手率信息（因为TCAP字段缺失）") 53 | 54 | return True 55 | 56 | except Exception as e: 57 | print(f"❌ 测试失败: {e}") 58 | import traceback 59 | traceback.print_exc() 60 | return False 61 | 62 | def test_tcap_present(): 63 | """测试TCAP字段存在时的处理""" 64 | symbol = "SZ300711" 65 | 66 | print(f"\n=== 测试TCAP字段存在的情况 ===\n") 67 | 68 | # 模拟有TCAP字段的数据 69 | mock_data = { 70 | 'DATE': np.array([1640995200, 1641081600, 1641168000]), 71 | 'OPEN': np.array([10.0, 10.5, 11.0]), 72 | 'HIGH': np.array([10.5, 11.0, 11.5]), 73 | 'LOW': np.array([9.5, 10.0, 10.5]), 74 | 'CLOSE': np.array([10.2, 10.8, 11.2]), 75 | 'VOLUME': np.array([1000000, 1200000, 1100000]), 76 | 'AMOUNT': np.array([10200000, 12960000, 12320000]), 77 | 'CLOSE2': np.array([10.2, 10.8, 11.2]), 78 | 'PRICE': np.array([10.2, 10.8, 11.2]), 79 | 'GCASH': np.array([0.0, 0.0, 0.0]), 80 | 'GSHARE': np.array([0.0, 0.0, 0.0]), 81 | 'TCAP': np.array([500000, 520000, 540000]), # 包含TCAP字段 82 | 'SECTOR': ['新能源汽车', '锂电池'] 83 | } 84 | 85 | try: 86 | # 测试build_trading_data函数 87 | buf = StringIO() 88 | research.build_trading_data(buf, symbol, mock_data) 89 | result = buf.getvalue() 90 | 91 | print("=== 交易数据构建成功 ===") 92 | print("输出长度:", len(result)) 93 | 94 | # 检查是否包含换手率信息 95 | if "换手率" in result: 96 | print("✅ 正确：包含换手率信息（因为TCAP字段存在）") 97 | return True 98 | else: 99 | print("❌ 错误：未包含换手率信息（应该包含）") 100 | return False 101 | 102 | except Exception as e: 103 | print(f"❌ 测试失败: {e}") 104 | import traceback 105 | traceback.print_exc() 106 | return False 107 | 108 | if __name__ == "__main__": 109 | print("开始测试TCAP字段处理修复...\n") 110 | 111 | test1 = test_tcap_fix() 112 | test2 = test_tcap_present() 113 | 114 | if test1 and test2: 115 | print("\n🎉 所有测试通过 - TCAP字段处理修复成功") 116 | else: 117 | print("\n❌ 部分测试失败") 118 | sys.exit(1) -------------------------------------------------------------------------------- /tests/test.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | 4 | # `gpt` 是一个大模型命令行工具，支持多种模型和接口，参见 https://github.com/elsejj/gpt 5 | 6 | gpt -M "http://82.156.17.205/cnstock/sse" "请详细分析一下浦发银行的最近走势" 7 | 8 | gpt -M "http://82.156.17.205/cnstock/sse" "请从技术分析角度分析一下贵州茅台的后市走势" --------------------------------------------------------------------------------