A Simple and Universal Swarm Intelligence Engine, Predicting Anything. 简洁通用的群体智能引擎,预测万物
Python agent-memoryfinancial-forecastingfuture-predictionknowledge-graphllmsmulti-agent-simulationpublic-opinion-analysispython3social-predictionswarm-intelligence
Implement Report Agent for automated report generation and interaction
666ghj5ece3f670bef
diff --git a/backend/README.md b/backend/README.mdindex 72ece0cc..44d437e1 100644--- a/backend/README.md+++ b/backend/README.md@@ -28,6 +28,8 @@4. **模拟配置智能生成**: 使用 LLM 根据需求自动生成模拟参数(时间、活跃度、事件等)5. **双平台模拟**: 支持 Twitter 和 Reddit 双平台并行舆论模拟(基于 OASIS 框架)6. **图谱记忆动态更新**: 可选功能,将模拟中Agent的活动实时更新到Zep图谱,让图谱"记住"模拟过程+7. **智能报告生成**: 使用 LangChain + Zep 实现 ReACT 模式的模拟分析报告自动生成+8. **Report Agent对话**: 报告生成后可与Report Agent对话,自主调用检索工具回答问题---@@ -42,10 +44,11 @@│ │ API层 │ │ 服务层 │ │ 模型层 │ ││ │ - graph.py │→ │ - 本体生成 │→ │ - Project │ ││ │ - simulation │ │ - 图谱构建 │ │ - Task │ │-│ └────────────────┘ │ - 实体读取 │ └─────────────────┘ │-│ │ - 人设生成 │ │+│ │ - report.py │ │ - 实体读取 │ │ - Report │ │+│ └────────────────┘ │ - 人设生成 │ └─────────────────┘ ││ │ - 配置生成 │ ││ │ - 模拟运行 │ │+│ │ - 报告生成 │ ││ └──────────────┘ │├─────────────────────────────────────────────────────────────┤│ 外部服务集成 │@@ -78,6 +81,16 @@模拟完成 → 环境进入等待模式 → 发送Interview命令 → Agent回答 → 获取结果 → (可选)关闭环境```+5. **报告生成流程**:+ ```+ 模拟完成 → 调用Report API → ReACT规划大纲 → 逐章节生成(多次工具调用) → 生成Markdown报告 → 解锁Interview功能+ ```++6. **Report Agent对话流程**:+ ```+ 用户提问 → Agent分析 → 调用Zep检索工具 → 整合信息 → 返回回答+ ```+---## 技术栈@@ -89,6 +102,7 @@### AI & 知识图谱- **Zep Cloud SDK 2.0+**: 知识图谱构建与管理- **OpenAI SDK 1.0+**: LLM 调用(支持 OpenAI 兼容接口)+- **LangChain 0.2+**: Report Agent框架(ReACT模式)- **OASIS-AI**: 社交媒体模拟框架- **CAMEL-AI**: Agent 行为模拟@@ -117,6 +131,10 @@ backend/│ │ ├── project.json # 项目元数据│ │ ├── files/ # 上传的文件│ │ └── extracted_text.txt # 提取的文本+│ ├── reports/ # 报告数据+│ │ └── report_xxx/+│ │ ├── report_xxx.json # 报告元数据+│ │ └── report_xxx.md # Markdown报告│ └── simulations/ # 模拟数据│ └── sim_xxx/│ ├── state.json # 模拟状态@@ -142,7 +160,8 @@ backend/├── api/ # API路由│ ├── __init__.py│ ├── graph.py # 图谱相关接口- │ └── simulation.py # 模拟相关接口+ │ ├── simulation.py # 模拟相关接口+ │ └── report.py # 报告相关接口├── models/ # 数据模型│ ├── __init__.py│ ├── project.py # 项目模型@@ -153,12 +172,14 @@ backend/│ ├── graph_builder.py # 图谱构建│ ├── text_processor.py # 文本处理│ ├── zep_entity_reader.py # 实体读取+ │ ├── zep_tools.py # Zep检索工具服务│ ├── oasis_profile_generator.py # 人设生成│ ├── simulation_config_generator.py # 配置生成│ ├── simulation_manager.py # 模拟管理│ ├── simulation_runner.py # 模拟运行│ ├── simulation_ipc.py # 模拟IPC通信(Interview功能)- │ └── zep_graph_memory_updater.py # 图谱记忆动态更新+ │ ├── zep_graph_memory_updater.py # 图谱记忆动态更新+ │ └── report_agent.py # 报告生成Agent(ReACT模式)└── utils/ # 工具类├── __init__.py├── file_parser.py # 文件解析@@ -240,6 +261,55 @@ backend/- `SimulationIPCClient`: IPC客户端(Flask端使用)- `SimulationIPCServer`: IPC服务器(模拟脚本端使用)+### 5. Report Agent模块(报告生成)++**功能**: 模拟完成后自动生成分析报告,支持与用户对话++**特点**:+- **ReACT模式**: Reasoning + Acting,多轮思考与工具调用+- **大纲规划**: LLM分析模拟需求,自动规划报告目录结构+- **分段生成**: 逐章节生成,每章节可多次调用Zep检索工具+- **Markdown输出**: 生成专业的Markdown格式报告+- **对话功能**: 报告完成后可与Report Agent对话,自主调用工具回答问题++**工具(MCP封装)**:+- `search_graph`: 图谱语义搜索+- `get_graph_statistics`: 获取图谱统计信息+- `get_entity_summary`: 获取实体关系摘要+- `get_simulation_context`: 获取模拟上下文+- `get_entities_by_type`: 按类型获取实体++**核心服务**:+- `ZepToolsService`: Zep检索工具封装+- `ReportAgent`: 报告生成Agent(ReACT模式)+- `ReportManager`: 报告持久化管理++**工作原理**:+```+┌─────────────────────────────────────────────────────────────┐+│ Report Agent (ReACT) │+├─────────────────────────────────────────────────────────────┤+│ │+│ 1. 规划阶段 │+│ ┌─────────────────────────────────────────────────┐ │+│ │ LLM分析模拟需求 → 获取图谱上下文 → 生成报告大纲 │ │+│ └─────────────────────────────────────────────────┘ │+│ │+│ 2. 生成阶段 (每章节) │+│ ┌─────────────────────────────────────────────────┐ │+│ │ Thought → Action → Observation → ... → Final │ │+│ │ ↓ ↓ ↓ │ │+│ │ 分析需求 调用工具 分析结果 生成内容 │ │+│ └─────────────────────────────────────────────────┘ │+│ │+│ 3. 输出阶段 │+│ ┌─────────────────────────────────────────────────┐ │+│ │ 组装章节 → 生成Markdown → 保存JSON/MD文件 │ │+│ └─────────────────────────────────────────────────┘ │+│ │+└─────────────────────────────────────────────────────────────┘+```+**工作原理**:```Flask后端 模拟脚本@@ -964,6 +1034,245 @@ Flask后端 模拟脚本- `/stop`: 强制终止模拟进程- `/close-env`: 优雅地关闭环境,让模拟进程正常退出+---++### Report 报告接口++> **说明**: 报告生成完成后才能解锁Interview功能。Report Agent使用ReACT模式,可以在对话中自主调用Zep检索工具。++#### 1. 生成报告++**接口**: `POST /api/report/generate`++**请求参数**:+```json+{+ "simulation_id": "sim_xxxx",+ "force_regenerate": false+}+```++| 参数 | 类型 | 必填 | 默认值 | 说明 |+|------|------|------|--------|------|+| simulation_id | String | 是 | - | 模拟ID |+| force_regenerate | Boolean | 否 | false | 强制重新生成 |++**返回示例**:+```json+{+ "success": true,+ "data": {+ "simulation_id": "sim_xxxx",+ "task_id": "task_xxxx",+ "status": "generating",+ "message": "报告生成任务已启动",+ "already_generated": false+ }+}+```++**如果报告已存在**:+```json+{+ "success": true,+ "data": {+ "simulation_id": "sim_xxxx",+ "report_id": "report_xxxx",+ "status": "completed",+ "message": "报告已存在",+ "already_generated": true+ }+}+```++---++#### 2. 查询生成进度++**接口**: `POST /api/report/generate/status`++**请求参数**:+```json+{+ "task_id": "task_xxxx",+ "simulation_id": "sim_xxxx"+}+```++**返回示例**:+```json+{+ "success": true,+ "data": {+ "task_id": "task_xxxx",+ "status": "processing",+ "progress": 45,+ "message": "[generating] 正在生成章节: 关键发现 (3/5)"+ }+}+```++---++#### 3. 获取报告++**接口**: `GET /api/report/{report_id}`++**返回示例**:+```json+{+ "success": true,+ "data": {+ "report_id": "report_xxxx",+ "simulation_id": "sim_xxxx",+ "graph_id": "mirofish_xxxx",+ "simulation_requirement": "模拟武汉大学撤销处分后的舆情走向",+ "status": "completed",+ "outline": {+ "title": "武汉大学撤销处分事件舆情分析报告",+ "summary": "基于模拟结果的全面舆情分析",+ "sections": [+ {"title": "执行摘要", "content": "..."},+ {"title": "模拟背景", "content": "..."},+ {"title": "关键发现", "content": "..."},+ {"title": "舆情分析", "content": "..."},+ {"title": "建议与展望", "content": "..."}+ ]+ },+ "markdown_content": "# 武汉大学撤销处分事件舆情分析报告\n\n...",+ "created_at": "2025-12-09T10:00:00",+ "completed_at": "2025-12-09T10:05:00"+ }+}+```++---++#### 4. 根据模拟ID获取报告++**接口**: `GET /api/report/by-simulation/{simulation_id}`++**返回示例**:+```json+{+ "success": true,+ "data": {...},+ "has_report": true+}+```++---++#### 5. 下载报告++**接口**: `GET /api/report/{report_id}/download`++**返回**: Markdown文件下载++---++#### 6. 与Report Agent对话++**接口**: `POST /api/report/chat`++**请求参数**:+```json+{+ "simulation_id": "sim_xxxx",+ "message": "请详细解释一下舆情的主要趋势",+ "chat_history": [+ {"role": "user", "content": "报告提到了哪些关键人物?"},+ {"role": "assistant", "content": "根据分析,关键人物包括..."}+ ]+}+```++| 参数 | 类型 | 必填 | 默认值 | 说明 |+|------|------|------|--------|------|+| simulation_id | String | 是 | - | 模拟ID |+| message | String | 是 | - | 用户消息 |+| chat_history | Array | 否 | [] | 对话历史(用于上下文) |++**返回示例**:+```json+{+ "success": true,+ "data": {+ "response": "根据模拟数据分析,舆情的主要趋势表现为...\n\n1. **初期阶段**:...\n2. **发酵阶段**:...\n3. **高峰阶段**:...",+ "tool_calls": [+ {"name": "search_graph", "parameters": {"query": "舆情趋势"}},+ {"name": "get_graph_statistics", "parameters": {}}+ ],+ "sources": []+ }+}+```++---++#### 7. 检查报告状态++**接口**: `GET /api/report/check/{simulation_id}`++**用途**: 判断是否解锁Interview功能++**返回示例**:+```json+{+ "success": true,+ "data": {+ "simulation_id": "sim_xxxx",+ "has_report": true,+ "report_status": "completed",+ "report_id": "report_xxxx",+ "interview_unlocked": true+ }+}+```++---++#### 8. 列出所有报告++**接口**: `GET /api/report/list?simulation_id=sim_xxxx&limit=50`++**返回示例**:+```json+{+ "success": true,+ "data": [...],+ "count": 5+}+```++---++#### 9. 删除报告++**接口**: `DELETE /api/report/{report_id}`++---++#### 10. 工具调试接口++**图谱搜索**: `POST /api/report/tools/search`+```json+{+ "graph_id": "mirofish_xxxx",+ "query": "舆情走向",+ "limit": 10+}+```++**图谱统计**: `POST /api/report/tools/statistics`+```json+{+ "graph_id": "mirofish_xxxx"+}+```++---+#### 6. 获取运行状态**接口**: `GET /api/simulation/{simulation_id}/run-status`@@ -1192,7 +1501,50 @@ created_at: str # 创建时间----### 6. SimulationParameters (模拟参数)+### 6. Report (报告模型)++**文件**: `app/services/report_agent.py`++**字段**:+```python+report_id: str # 报告ID (report_xxx)+simulation_id: str # 模拟ID+graph_id: str # 图谱ID+simulation_requirement: str # 模拟需求+status: ReportStatus # 状态+outline: ReportOutline # 报告大纲+markdown_content: str # Markdown内容+created_at: str # 创建时间+completed_at: str # 完成时间+error: str # 错误信息+```++**状态枚举**:+```python+PENDING = "pending" # 等待中+PLANNING = "planning" # 规划大纲中+GENERATING = "generating" # 生成内容中+COMPLETED = "completed" # 已完成+FAILED = "failed" # 失败+```++**ReportOutline字段**:+```python+title: str # 报告标题+summary: str # 报告摘要+sections: List[ReportSection] # 章节列表+```++**ReportSection字段**:+```python+title: str # 章节标题+content: str # 章节内容+subsections: List[ReportSection] # 子章节+```++---++### 7. SimulationParameters (模拟参数)**文件**: `app/services/simulation_config_generator.py`@@ -1815,6 +2167,270 @@ result = SimulationRunner.interview_all_agents(---+### 10. ZepToolsService (Zep检索工具服务)++**文件**: `app/services/zep_tools.py`++**功能**: 封装多种Zep图谱检索工具,供Report Agent调用++**核心方法**:++```python+def search_graph(+ graph_id: str,+ query: str,+ limit: int = 10+) -> SearchResult:+ """+ 图谱语义搜索++ 使用混合搜索(语义+BM25)查找相关信息+ 返回: facts列表、edges列表、nodes列表+ """++def get_all_nodes(graph_id: str) -> List[NodeInfo]:+ """获取图谱所有节点"""++def get_all_edges(graph_id: str) -> List[EdgeInfo]:+ """获取图谱所有边"""++def get_node_detail(node_uuid: str) -> Optional[NodeInfo]:+ """获取单个节点详情"""++def get_node_edges(node_uuid: str) -> List[EdgeInfo]:+ """获取节点相关的边"""++def get_entities_by_type(+ graph_id: str,+ entity_type: str+) -> List[NodeInfo]:+ """按类型获取实体"""++def get_entity_summary(+ graph_id: str,+ entity_name: str+) -> Dict[str, Any]:+ """获取实体关系摘要"""++def get_graph_statistics(graph_id: str) -> Dict[str, Any]:+ """+ 获取图谱统计信息++ 返回:+ - total_nodes: 节点总数+ - total_edges: 边总数+ - entity_types: 实体类型分布+ - relation_types: 关系类型分布+ """++def get_simulation_context(+ graph_id: str,+ simulation_requirement: str,+ limit: int = 30+) -> Dict[str, Any]:+ """+ 获取模拟相关上下文++ 综合搜索与模拟需求相关的所有信息+ """+```++**容错机制**:+- 所有API调用带3次重试+- 指数退避策略+- 搜索失败返回空结果而非抛出异常++---++### 11. ReportAgent (报告生成Agent)++**文件**: `app/services/report_agent.py`++**功能**: 使用ReACT模式生成模拟分析报告++**核心类**:++```python+class ReportAgent:+ """+ Report Agent - 模拟报告生成Agent++ 采用ReACT(Reasoning + Acting)模式:+ 1. 规划阶段:分析模拟需求,规划报告目录结构+ 2. 生成阶段:逐章节生成内容,每章节可多次调用工具获取信息+ 3. 对话阶段:支持与用户对话,自主调用检索工具+ """++ # 配置+ MAX_TOOL_CALLS_PER_SECTION = 5 # 每章节最大工具调用次数+ MAX_REFLECTION_ROUNDS = 2 # 最大反思轮数+```++**核心方法**:++```python+def plan_outline(+ progress_callback: Optional[Callable] = None+) -> ReportOutline:+ """+ 规划报告大纲++ 步骤:+ 1. 获取模拟上下文(图谱统计、相关事实)+ 2. 使用LLM分析并生成大纲结构+ 3. 返回包含章节列表的大纲对象+ """++def _generate_section_react(+ section: ReportSection,+ outline: ReportOutline,+ previous_sections: List[str],+ progress_callback: Optional[Callable] = None+) -> str:+ """+ 使用ReACT模式生成单个章节++ ReACT循环:+ 1. Thought(思考)- 分析需要什么信息+ 2. Action(行动)- 调用工具获取信息+ 3. Observation(观察)- 分析工具返回结果+ 4. 重复直到信息足够或达到最大次数+ 5. Final Answer(最终回答)- 生成章节内容+ """++def generate_report(+ progress_callback: Optional[Callable] = None+) -> Report:+ """+ 生成完整报告++ 步骤:+ 1. 规划大纲+ 2. 逐章节生成(ReACT模式)+ 3. 组装Markdown报告+ 4. 保存报告文件+ """++def chat(+ message: str,+ chat_history: List[Dict[str, str]] = None+) -> Dict[str, Any]:+ """+ 与Report Agent对话++ 在对话中Agent可以自主调用检索工具来回答问题++ Returns:+ {+ "response": "Agent回复",+ "tool_calls": [调用的工具列表],+ "sources": [信息来源]+ }+ """+```++**工具调用格式**:++Agent使用以下格式调用工具:++```+<tool_call>+{"name": "search_graph", "parameters": {"query": "舆情走向", "limit": 10}}+</tool_call>+```++或者:++```+[TOOL_CALL] search_graph(query="舆情走向", limit="10")+```++**报告大纲结构示例**:++```json+{+ "title": "武汉大学撤销处分事件舆情分析报告",+ "summary": "基于模拟结果的全面舆情分析",+ "sections": [+ {+ "title": "执行摘要",+ "description": "简要总结模拟结果和关键发现"+ },+ {+ "title": "模拟背景",+ "description": "描述模拟的初始条件和场景设定"+ },+ {+ "title": "关键发现",+ "description": "分析模拟中的重要发现和趋势"+ },+ {+ "title": "舆情分析",+ "description": "分析舆论走向、情绪变化、关键意见领袖"+ },+ {+ "title": "影响评估",+ "description": "评估事件的影响范围和程度"+ },+ {+ "title": "建议与展望",+ "description": "基于分析结果提出建议"+ }+ ]+}+```++---++### 12. ReportManager (报告管理器)++**文件**: `app/services/report_agent.py`++**功能**: 报告的持久化存储和检索++**核心方法**:++```python+@classmethod+def save_report(cls, report: Report) -> None:+ """+ 保存报告++ 同时保存:+ - JSON文件(报告元数据)+ - Markdown文件(报告内容)+ """++@classmethod+def get_report(cls, report_id: str) -> Optional[Report]:+ """获取报告"""++@classmethod+def get_report_by_simulation(cls, simulation_id: str) -> Optional[Report]:+ """根据模拟ID获取报告"""++@classmethod+def list_reports(+ cls,+ simulation_id: Optional[str] = None,+ limit: int = 50+) -> List[Report]:+ """列出报告"""++@classmethod+def delete_report(cls, report_id: str) -> bool:+ """删除报告"""+```++**存储结构**:+```+uploads/reports/+├── report_abc123.json # 报告元数据+└── report_abc123.md # Markdown报告+```++---+## 工具类### 1. FileParser (文件解析器)@@ -1962,6 +2578,11 @@ ZEP_API_KEY=z_xxx# OASIS模拟配置OASIS_DEFAULT_MAX_ROUNDS=10++# Report Agent配置(可选)+REPORT_AGENT_MAX_TOOL_CALLS=5+REPORT_AGENT_MAX_REFLECTION_ROUNDS=2+REPORT_AGENT_TEMPERATURE=0.5```### 配置项说明@@ -1977,6 +2598,9 @@ OASIS_DEFAULT_MAX_ROUNDS=10| LLM_MODEL_NAME | String | gpt-4o-mini | LLM模型名称 || ZEP_API_KEY | String | - | Zep API密钥(必填) || OASIS_DEFAULT_MAX_ROUNDS | Integer | 10 | 默认模拟轮数 |+| REPORT_AGENT_MAX_TOOL_CALLS | Integer | 5 | 每章节最大工具调用次数 |+| REPORT_AGENT_MAX_REFLECTION_ROUNDS | Integer | 2 | 最大反思轮数 |+| REPORT_AGENT_TEMPERATURE | Float | 0.5 | 报告生成温度参数 |---@@ -2102,7 +2726,40 @@ curl -X POST http://localhost:5001/api/simulation/{sim_xxx}/interview/all \# Step 12: 获取Interview历史curl http://localhost:5001/api/simulation/{sim_xxx}/interview/history-# Step 13: 关闭模拟环境(优雅退出)+# Step 13: 生成模拟分析报告+curl -X POST http://localhost:5001/api/report/generate \+ -H "Content-Type: application/json" \+ -d '{+ "simulation_id": "sim_xxx"+ }'++# 返回: task_id++# Step 14: 查询报告生成进度+curl -X POST http://localhost:5001/api/report/generate/status \+ -H "Content-Type: application/json" \+ -d '{+ "task_id": "task_xxx",+ "simulation_id": "sim_xxx"+ }'++# 等待status=completed++# Step 15: 获取报告+curl http://localhost:5001/api/report/by-simulation/sim_xxx++# Step 16: 与Report Agent对话+curl -X POST http://localhost:5001/api/report/chat \+ -H "Content-Type: application/json" \+ -d '{+ "simulation_id": "sim_xxx",+ "message": "请解释一下舆情的主要趋势"+ }'++# Step 17: 下载Markdown报告+curl -O http://localhost:5001/api/report/{report_id}/download++# Step 18: 关闭模拟环境(优雅退出)curl -X POST http://localhost:5001/api/simulation/close-env \-H "Content-Type: application/json" \-d '{@@ -2278,11 +2935,31 @@ MIT License----**最后更新**: 2025-12-08-**版本**: v1.2.0+**最后更新**: 2025-12-09+**版本**: v1.3.0### 更新日志+**v1.3.0 (2025-12-09)**:+- 新增 Report Agent 模拟报告生成功能+ - 使用 LangChain + Zep 实现 ReACT 模式+ - 自动规划报告大纲,分段生成内容+ - 每章节可多次调用Zep检索工具获取信息+ - 生成专业的Markdown格式报告+- 新增 Report Agent 对话功能+ - 报告完成后可与Agent对话+ - Agent自主调用检索工具回答问题+- 新增 Zep 检索工具服务+ - 封装图谱搜索、节点读取、边查询等工具+ - 支持语义搜索、统计分析、上下文获取+- 新增报告管理接口+ - 报告生成、查询、下载、删除+ - 报告状态检查(解锁Interview功能)+- 依赖更新+ - 新增 langchain>=0.2.0+ - 新增 langchain-core>=0.2.0+ - 新增 langchain-openai>=0.1.0+**v1.2.0 (2025-12-08)**:- 新增 Interview 采访功能- 支持单个Agent采访diff --git a/backend/app/__init__.py b/backend/app/__init__.pyindex 5b7f1fcb..aba624bb 100644--- a/backend/app/__init__.py+++ b/backend/app/__init__.py@@ -63,9 +63,10 @@ def create_app(config_class=Config):return response# 注册蓝图- from .api import graph_bp, simulation_bp+ from .api import graph_bp, simulation_bp, report_bpapp.register_blueprint(graph_bp, url_prefix='/api/graph')app.register_blueprint(simulation_bp, url_prefix='/api/simulation')+ app.register_blueprint(report_bp, url_prefix='/api/report')# 健康检查@app.route('/health')diff --git a/backend/app/api/__init__.py b/backend/app/api/__init__.pyindex ad7a7220..ffda743a 100644--- a/backend/app/api/__init__.py+++ b/backend/app/api/__init__.py@@ -6,7 +6,9 @@ from flask import Blueprintgraph_bp = Blueprint('graph', __name__)simulation_bp = Blueprint('simulation', __name__)+report_bp = Blueprint('report', __name__)from . import graph # noqa: E402, F401from . import simulation # noqa: E402, F401+from . import report # noqa: E402, F401diff --git a/backend/app/api/report.py b/backend/app/api/report.pynew file mode 100644index 00000000..ce44db9e--- /dev/null+++ b/backend/app/api/report.py@@ -0,0 +1,829 @@+"""+Report API路由+提供模拟报告生成、获取、对话等接口+"""++import os+import traceback+import threading+from flask import request, jsonify, send_file++from . import report_bp+from ..config import Config+from ..services.report_agent import ReportAgent, ReportManager, ReportStatus+from ..services.simulation_manager import SimulationManager+from ..models.project import ProjectManager+from ..models.task import TaskManager, TaskStatus+from ..utils.logger import get_logger++logger = get_logger('mirofish.api.report')+++# ============== 报告生成接口 ==============++@report_bp.route('/generate', methods=['POST'])+def generate_report():+ """+ 生成模拟分析报告(异步任务)++ 这是一个耗时操作,接口会立即返回task_id,+ 使用 GET /api/report/generate/status 查询进度++ 请求(JSON):+ {+ "simulation_id": "sim_xxxx", // 必填,模拟ID+ "force_regenerate": false // 可选,强制重新生成+ }++ 返回:+ {+ "success": true,+ "data": {+ "simulation_id": "sim_xxxx",+ "task_id": "task_xxxx",+ "status": "generating",+ "message": "报告生成任务已启动"+ }+ }+ """+ try:+ data = request.get_json() or {}++ simulation_id = data.get('simulation_id')+ if not simulation_id:+ return jsonify({+ "success": False,+ "error": "请提供 simulation_id"+ }), 400++ force_regenerate = data.get('force_regenerate', False)++ # 获取模拟信息+ manager = SimulationManager()+ state = manager.get_simulation(simulation_id)++ if not state:+ return jsonify({+ "success": False,+ "error": f"模拟不存在: {simulation_id}"+ }), 404++ # 检查是否已有报告+ if not force_regenerate:+ existing_report = ReportManager.get_report_by_simulation(simulation_id)+ if existing_report and existing_report.status == ReportStatus.COMPLETED:+ return jsonify({+ "success": True,+ "data": {+ "simulation_id": simulation_id,+ "report_id": existing_report.report_id,+ "status": "completed",+ "message": "报告已存在",+ "already_generated": True+ }+ })++ # 获取项目信息+ project = ProjectManager.get_project(state.project_id)+ if not project:+ return jsonify({+ "success": False,+ "error": f"项目不存在: {state.project_id}"+ }), 404++ graph_id = state.graph_id or project.graph_id+ if not graph_id:+ return jsonify({+ "success": False,+ "error": "缺少图谱ID,请确保已构建图谱"+ }), 400++ simulation_requirement = project.simulation_requirement+ if not simulation_requirement:+ return jsonify({+ "success": False,+ "error": "缺少模拟需求描述"+ }), 400++ # 创建异步任务+ task_manager = TaskManager()+ task_id = task_manager.create_task(+ task_type="report_generate",+ metadata={+ "simulation_id": simulation_id,+ "graph_id": graph_id+ }+ )++ # 定义后台任务+ def run_generate():+ try:+ task_manager.update_task(+ task_id,+ status=TaskStatus.PROCESSING,+ progress=0,+ message="初始化Report Agent..."+ )++ # 创建Report Agent+ agent = ReportAgent(+ graph_id=graph_id,+ simulation_id=simulation_id,+ simulation_requirement=simulation_requirement+ )++ # 进度回调+ def progress_callback(stage, progress, message):+ task_manager.update_task(+ task_id,+ progress=progress,+ message=f"[{stage}] {message}"+ )++ # 生成报告+ report = agent.generate_report(progress_callback=progress_callback)++ # 保存报告+ ReportManager.save_report(report)++ if report.status == ReportStatus.COMPLETED:+ task_manager.complete_task(+ task_id,+ result={+ "report_id": report.report_id,+ "simulation_id": simulation_id,+ "status": "completed"+ }+ )+ else:+ task_manager.fail_task(task_id, report.error or "报告生成失败")++ except Exception as e:+ logger.error(f"报告生成失败: {str(e)}")+ task_manager.fail_task(task_id, str(e))++ # 启动后台线程+ thread = threading.Thread(target=run_generate, daemon=True)+ thread.start()++ return jsonify({+ "success": True,+ "data": {+ "simulation_id": simulation_id,+ "task_id": task_id,+ "status": "generating",+ "message": "报告生成任务已启动,请通过 /api/report/generate/status 查询进度",+ "already_generated": False+ }+ })++ except Exception as e:+ logger.error(f"启动报告生成任务失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@report_bp.route('/generate/status', methods=['POST'])+def get_generate_status():+ """+ 查询报告生成任务进度++ 请求(JSON):+ {+ "task_id": "task_xxxx", // 可选,generate返回的task_id+ "simulation_id": "sim_xxxx" // 可选,模拟ID+ }++ 返回:+ {+ "success": true,+ "data": {+ "task_id": "task_xxxx",+ "status": "processing|completed|failed",+ "progress": 45,+ "message": "..."+ }+ }+ """+ try:+ data = request.get_json() or {}++ task_id = data.get('task_id')+ simulation_id = data.get('simulation_id')++ # 如果提供了simulation_id,先检查是否已有完成的报告+ if simulation_id:+ existing_report = ReportManager.get_report_by_simulation(simulation_id)+ if existing_report and existing_report.status == ReportStatus.COMPLETED:+ return jsonify({+ "success": True,+ "data": {+ "simulation_id": simulation_id,+ "report_id": existing_report.report_id,+ "status": "completed",+ "progress": 100,+ "message": "报告已生成",+ "already_completed": True+ }+ })++ if not task_id:+ return jsonify({+ "success": False,+ "error": "请提供 task_id 或 simulation_id"+ }), 400++ task_manager = TaskManager()+ task = task_manager.get_task(task_id)++ if not task:+ return jsonify({+ "success": False,+ "error": f"任务不存在: {task_id}"+ }), 404++ return jsonify({+ "success": True,+ "data": task.to_dict()+ })++ except Exception as e:+ logger.error(f"查询任务状态失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e)+ }), 500+++# ============== 报告获取接口 ==============++@report_bp.route('/<report_id>', methods=['GET'])+def get_report(report_id: str):+ """+ 获取报告详情++ 返回:+ {+ "success": true,+ "data": {+ "report_id": "report_xxxx",+ "simulation_id": "sim_xxxx",+ "status": "completed",+ "outline": {...},+ "markdown_content": "...",+ "created_at": "...",+ "completed_at": "..."+ }+ }+ """+ try:+ report = ReportManager.get_report(report_id)++ if not report:+ return jsonify({+ "success": False,+ "error": f"报告不存在: {report_id}"+ }), 404++ return jsonify({+ "success": True,+ "data": report.to_dict()+ })++ except Exception as e:+ logger.error(f"获取报告失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@report_bp.route('/by-simulation/<simulation_id>', methods=['GET'])+def get_report_by_simulation(simulation_id: str):+ """+ 根据模拟ID获取报告++ 返回:+ {+ "success": true,+ "data": {+ "report_id": "report_xxxx",+ ...+ }+ }+ """+ try:+ report = ReportManager.get_report_by_simulation(simulation_id)++ if not report:+ return jsonify({+ "success": False,+ "error": f"该模拟暂无报告: {simulation_id}",+ "has_report": False+ }), 404++ return jsonify({+ "success": True,+ "data": report.to_dict(),+ "has_report": True+ })++ except Exception as e:+ logger.error(f"获取报告失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@report_bp.route('/list', methods=['GET'])+def list_reports():+ """+ 列出所有报告++ Query参数:+ simulation_id: 按模拟ID过滤(可选)+ limit: 返回数量限制(默认50)++ 返回:+ {+ "success": true,+ "data": [...],+ "count": 10+ }+ """+ try:+ simulation_id = request.args.get('simulation_id')+ limit = request.args.get('limit', 50, type=int)++ reports = ReportManager.list_reports(+ simulation_id=simulation_id,+ limit=limit+ )++ return jsonify({+ "success": True,+ "data": [r.to_dict() for r in reports],+ "count": len(reports)+ })++ except Exception as e:+ logger.error(f"列出报告失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@report_bp.route('/<report_id>/download', methods=['GET'])+def download_report(report_id: str):+ """+ 下载报告(Markdown格式)++ 返回Markdown文件+ """+ try:+ report = ReportManager.get_report(report_id)++ if not report:+ return jsonify({+ "success": False,+ "error": f"报告不存在: {report_id}"+ }), 404++ md_path = ReportManager._get_report_markdown_path(report_id)++ if not os.path.exists(md_path):+ # 如果MD文件不存在,生成一个临时文件+ import tempfile+ with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False) as f:+ f.write(report.markdown_content)+ temp_path = f.name++ return send_file(+ temp_path,+ as_attachment=True,+ download_name=f"{report_id}.md"+ )++ return send_file(+ md_path,+ as_attachment=True,+ download_name=f"{report_id}.md"+ )++ except Exception as e:+ logger.error(f"下载报告失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@report_bp.route('/<report_id>', methods=['DELETE'])+def delete_report(report_id: str):+ """删除报告"""+ try:+ success = ReportManager.delete_report(report_id)++ if not success:+ return jsonify({+ "success": False,+ "error": f"报告不存在: {report_id}"+ }), 404++ return jsonify({+ "success": True,+ "message": f"报告已删除: {report_id}"+ })++ except Exception as e:+ logger.error(f"删除报告失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++# ============== Report Agent对话接口 ==============++@report_bp.route('/chat', methods=['POST'])+def chat_with_report_agent():+ """+ 与Report Agent对话++ Report Agent可以在对话中自主调用检索工具来回答问题++ 请求(JSON):+ {+ "simulation_id": "sim_xxxx", // 必填,模拟ID+ "message": "请解释一下舆情走向", // 必填,用户消息+ "chat_history": [ // 可选,对话历史+ {"role": "user", "content": "..."},+ {"role": "assistant", "content": "..."}+ ]+ }++ 返回:+ {+ "success": true,+ "data": {+ "response": "Agent回复...",+ "tool_calls": [调用的工具列表],+ "sources": [信息来源]+ }+ }+ """+ try:+ data = request.get_json() or {}++ simulation_id = data.get('simulation_id')+ message = data.get('message')+ chat_history = data.get('chat_history', [])++ if not simulation_id:+ return jsonify({+ "success": False,+ "error": "请提供 simulation_id"+ }), 400++ if not message:+ return jsonify({+ "success": False,+ "error": "请提供 message"+ }), 400++ # 获取模拟和项目信息+ manager = SimulationManager()+ state = manager.get_simulation(simulation_id)++ if not state:+ return jsonify({+ "success": False,+ "error": f"模拟不存在: {simulation_id}"+ }), 404++ project = ProjectManager.get_project(state.project_id)+ if not project:+ return jsonify({+ "success": False,+ "error": f"项目不存在: {state.project_id}"+ }), 404++ graph_id = state.graph_id or project.graph_id+ if not graph_id:+ return jsonify({+ "success": False,+ "error": "缺少图谱ID"+ }), 400++ simulation_requirement = project.simulation_requirement or ""++ # 创建Agent并进行对话+ agent = ReportAgent(+ graph_id=graph_id,+ simulation_id=simulation_id,+ simulation_requirement=simulation_requirement+ )++ result = agent.chat(message=message, chat_history=chat_history)++ return jsonify({+ "success": True,+ "data": result+ })++ except Exception as e:+ logger.error(f"对话失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++# ============== 报告进度与分章节接口 ==============++@report_bp.route('/<report_id>/progress', methods=['GET'])+def get_report_progress(report_id: str):+ """+ 获取报告生成进度(实时)++ 返回:+ {+ "success": true,+ "data": {+ "status": "generating",+ "progress": 45,+ "message": "正在生成章节: 关键发现",+ "current_section": "关键发现",+ "completed_sections": ["执行摘要", "模拟背景"],+ "updated_at": "2025-12-09T..."+ }+ }+ """+ try:+ progress = ReportManager.get_progress(report_id)++ if not progress:+ return jsonify({+ "success": False,+ "error": f"报告不存在或进度信息不可用: {report_id}"+ }), 404++ return jsonify({+ "success": True,+ "data": progress+ })++ except Exception as e:+ logger.error(f"获取报告进度失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@report_bp.route('/<report_id>/sections', methods=['GET'])+def get_report_sections(report_id: str):+ """+ 获取已生成的章节列表(分章节输出)++ 前端可以轮询此接口获取已生成的章节内容,无需等待整个报告完成++ 返回:+ {+ "success": true,+ "data": {+ "report_id": "report_xxxx",+ "sections": [+ {+ "filename": "section_01.md",+ "section_index": 1,+ "content": "## 执行摘要\\n\\n..."+ },+ ...+ ],+ "total_sections": 3,+ "is_complete": false+ }+ }+ """+ try:+ sections = ReportManager.get_generated_sections(report_id)++ # 获取报告状态+ report = ReportManager.get_report(report_id)+ is_complete = report is not None and report.status == ReportStatus.COMPLETED++ return jsonify({+ "success": True,+ "data": {+ "report_id": report_id,+ "sections": sections,+ "total_sections": len(sections),+ "is_complete": is_complete+ }+ })++ except Exception as e:+ logger.error(f"获取章节列表失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@report_bp.route('/<report_id>/section/<int:section_index>', methods=['GET'])+def get_single_section(report_id: str, section_index: int):+ """+ 获取单个章节内容++ 返回:+ {+ "success": true,+ "data": {+ "filename": "section_01.md",+ "content": "## 执行摘要\\n\\n..."+ }+ }+ """+ try:+ section_path = ReportManager._get_section_path(report_id, section_index)++ if not os.path.exists(section_path):+ return jsonify({+ "success": False,+ "error": f"章节不存在: section_{section_index:02d}.md"+ }), 404++ with open(section_path, 'r', encoding='utf-8') as f:+ content = f.read()++ return jsonify({+ "success": True,+ "data": {+ "filename": f"section_{section_index:02d}.md",+ "section_index": section_index,+ "content": content+ }+ })++ except Exception as e:+ logger.error(f"获取章节内容失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++# ============== 报告状态检查接口 ==============++@report_bp.route('/check/<simulation_id>', methods=['GET'])+def check_report_status(simulation_id: str):+ """+ 检查模拟是否有报告,以及报告状态++ 用于前端判断是否解锁Interview功能++ 返回:+ {+ "success": true,+ "data": {+ "simulation_id": "sim_xxxx",+ "has_report": true,+ "report_status": "completed",+ "report_id": "report_xxxx",+ "interview_unlocked": true+ }+ }+ """+ try:+ report = ReportManager.get_report_by_simulation(simulation_id)++ has_report = report is not None+ report_status = report.status.value if report else None+ report_id = report.report_id if report else None++ # 只有报告完成后才解锁interview+ interview_unlocked = has_report and report.status == ReportStatus.COMPLETED++ return jsonify({+ "success": True,+ "data": {+ "simulation_id": simulation_id,+ "has_report": has_report,+ "report_status": report_status,+ "report_id": report_id,+ "interview_unlocked": interview_unlocked+ }+ })++ except Exception as e:+ logger.error(f"检查报告状态失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++# ============== 工具调用接口(供调试使用)==============++@report_bp.route('/tools/search', methods=['POST'])+def search_graph_tool():+ """+ 图谱搜索工具接口(供调试使用)++ 请求(JSON):+ {+ "graph_id": "mirofish_xxxx",+ "query": "搜索查询",+ "limit": 10+ }+ """+ try:+ data = request.get_json() or {}++ graph_id = data.get('graph_id')+ query = data.get('query')+ limit = data.get('limit', 10)++ if not graph_id or not query:+ return jsonify({+ "success": False,+ "error": "请提供 graph_id 和 query"+ }), 400++ from ..services.zep_tools import ZepToolsService++ tools = ZepToolsService()+ result = tools.search_graph(+ graph_id=graph_id,+ query=query,+ limit=limit+ )++ return jsonify({+ "success": True,+ "data": result.to_dict()+ })++ except Exception as e:+ logger.error(f"图谱搜索失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@report_bp.route('/tools/statistics', methods=['POST'])+def get_graph_statistics_tool():+ """+ 图谱统计工具接口(供调试使用)++ 请求(JSON):+ {+ "graph_id": "mirofish_xxxx"+ }+ """+ try:+ data = request.get_json() or {}++ graph_id = data.get('graph_id')++ if not graph_id:+ return jsonify({+ "success": False,+ "error": "请提供 graph_id"+ }), 400++ from ..services.zep_tools import ZepToolsService++ tools = ZepToolsService()+ result = tools.get_graph_statistics(graph_id)++ return jsonify({+ "success": True,+ "data": result+ })++ except Exception as e:+ logger.error(f"获取图谱统计失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500diff --git a/backend/app/config.py b/backend/app/config.pyindex 10b18f7a..3dd3f513 100644--- a/backend/app/config.py+++ b/backend/app/config.py@@ -58,6 +58,11 @@ class Config:'TREND', 'REFRESH', 'DO_NOTHING', 'FOLLOW', 'MUTE']+ # Report Agent配置+ REPORT_AGENT_MAX_TOOL_CALLS = int(os.environ.get('REPORT_AGENT_MAX_TOOL_CALLS', '5'))+ REPORT_AGENT_MAX_REFLECTION_ROUNDS = int(os.environ.get('REPORT_AGENT_MAX_REFLECTION_ROUNDS', '2'))+ REPORT_AGENT_TEMPERATURE = float(os.environ.get('REPORT_AGENT_TEMPERATURE', '0.5'))+@classmethoddef validate(cls):"""验证必要配置"""diff --git a/backend/app/services/report_agent.py b/backend/app/services/report_agent.pynew file mode 100644index 00000000..3ec4be35--- /dev/null+++ b/backend/app/services/report_agent.py@@ -0,0 +1,1296 @@+"""+Report Agent服务+使用LangChain + Zep实现ReACT模式的模拟报告生成++功能:+1. 根据模拟需求和Zep图谱信息生成报告+2. 先规划目录结构,然后分段生成+3. 每段采用ReACT多轮思考与反思模式+4. 支持与用户对话,在对话中自主调用检索工具+"""++import os+import json+import time+import re+from typing import Dict, Any, List, Optional, Callable+from dataclasses import dataclass, field+from datetime import datetime+from enum import Enum++from ..config import Config+from ..utils.llm_client import LLMClient+from ..utils.logger import get_logger+from .zep_tools import ZepToolsService, SearchResult++logger = get_logger('mirofish.report_agent')+++class ReportStatus(str, Enum):+ """报告状态"""+ PENDING = "pending"+ PLANNING = "planning"+ GENERATING = "generating"+ COMPLETED = "completed"+ FAILED = "failed"+++@dataclass+class ReportSection:+ """报告章节"""+ title: str+ content: str = ""+ subsections: List['ReportSection'] = field(default_factory=list)++ def to_dict(self) -> Dict[str, Any]:+ return {+ "title": self.title,+ "content": self.content,+ "subsections": [s.to_dict() for s in self.subsections]+ }++ def to_markdown(self, level: int = 2) -> str:+ """转换为Markdown格式"""+ md = f"{'#' * level} {self.title}\n\n"+ if self.content:+ md += f"{self.content}\n\n"+ for sub in self.subsections:+ md += sub.to_markdown(level + 1)+ return md+++@dataclass+class ReportOutline:+ """报告大纲"""+ title: str+ summary: str+ sections: List[ReportSection]++ def to_dict(self) -> Dict[str, Any]:+ return {+ "title": self.title,+ "summary": self.summary,+ "sections": [s.to_dict() for s in self.sections]+ }++ def to_markdown(self) -> str:+ """转换为Markdown格式"""+ md = f"# {self.title}\n\n"+ md += f"> {self.summary}\n\n"+ for section in self.sections:+ md += section.to_markdown()+ return md+++@dataclass+class Report:+ """完整报告"""+ report_id: str+ simulation_id: str+ graph_id: str+ simulation_requirement: str+ status: ReportStatus+ outline: Optional[ReportOutline] = None+ markdown_content: str = ""+ created_at: str = ""+ completed_at: str = ""+ error: Optional[str] = None++ def to_dict(self) -> Dict[str, Any]:+ return {+ "report_id": self.report_id,+ "simulation_id": self.simulation_id,+ "graph_id": self.graph_id,+ "simulation_requirement": self.simulation_requirement,+ "status": self.status.value,+ "outline": self.outline.to_dict() if self.outline else None,+ "markdown_content": self.markdown_content,+ "created_at": self.created_at,+ "completed_at": self.completed_at,+ "error": self.error+ }+++class ReportAgent:+ """+ Report Agent - 模拟报告生成Agent++ 采用ReACT(Reasoning + Acting)模式:+ 1. 规划阶段:分析模拟需求,规划报告目录结构+ 2. 生成阶段:逐章节生成内容,每章节可多次调用工具获取信息+ 3. 反思阶段:检查内容完整性和准确性++ 工具(MCP封装):+ - search_graph: 图谱语义搜索+ - get_graph_statistics: 获取图谱统计+ - get_entity_summary: 获取实体摘要+ - get_simulation_context: 获取模拟上下文+ """++ # 最大工具调用次数(每个章节)+ MAX_TOOL_CALLS_PER_SECTION = 5++ # 最大反思轮数+ MAX_REFLECTION_ROUNDS = 2++ def __init__(+ self,+ graph_id: str,+ simulation_id: str,+ simulation_requirement: str,+ llm_client: Optional[LLMClient] = None,+ zep_tools: Optional[ZepToolsService] = None+ ):+ """+ 初始化Report Agent++ Args:+ graph_id: 图谱ID+ simulation_id: 模拟ID+ simulation_requirement: 模拟需求描述+ llm_client: LLM客户端(可选)+ zep_tools: Zep工具服务(可选)+ """+ self.graph_id = graph_id+ self.simulation_id = simulation_id+ self.simulation_requirement = simulation_requirement++ self.llm = llm_client or LLMClient()+ self.zep_tools = zep_tools or ZepToolsService()++ # 工具定义+ self.tools = self._define_tools()++ logger.info(f"ReportAgent 初始化完成: graph_id={graph_id}, simulation_id={simulation_id}")++ def _define_tools(self) -> Dict[str, Dict[str, Any]]:+ """定义可用工具"""+ return {+ "search_graph": {+ "name": "search_graph",+ "description": "在知识图谱中搜索相关信息。输入搜索查询,返回与查询相关的事实和关系。",+ "parameters": {+ "query": "搜索查询字符串",+ "limit": "返回结果数量(可选,默认10)"+ }+ },+ "get_graph_statistics": {+ "name": "get_graph_statistics",+ "description": "获取知识图谱的统计信息,包括节点数量、边数量、实体类型分布等。",+ "parameters": {}+ },+ "get_entity_summary": {+ "name": "get_entity_summary",+ "description": "获取指定实体的详细信息和关系摘要。",+ "parameters": {+ "entity_name": "实体名称"+ }+ },+ "get_simulation_context": {+ "name": "get_simulation_context",+ "description": "获取与模拟需求相关的上下文信息,包括相关事实、实体列表等。",+ "parameters": {+ "query": "额外的查询条件(可选)"+ }+ },+ "get_entities_by_type": {+ "name": "get_entities_by_type",+ "description": "按类型获取实体列表,如获取所有Student类型或PublicFigure类型的实体。",+ "parameters": {+ "entity_type": "实体类型名称"+ }+ }+ }++ def _execute_tool(self, tool_name: str, parameters: Dict[str, Any]) -> str:+ """+ 执行工具调用++ Args:+ tool_name: 工具名称+ parameters: 工具参数++ Returns:+ 工具执行结果(文本格式)+ """+ logger.info(f"执行工具: {tool_name}, 参数: {parameters}")++ try:+ if tool_name == "search_graph":+ query = parameters.get("query", "")+ limit = parameters.get("limit", 10)+ result = self.zep_tools.search_graph(+ graph_id=self.graph_id,+ query=query,+ limit=limit+ )+ return result.to_text()++ elif tool_name == "get_graph_statistics":+ result = self.zep_tools.get_graph_statistics(self.graph_id)+ return json.dumps(result, ensure_ascii=False, indent=2)++ elif tool_name == "get_entity_summary":+ entity_name = parameters.get("entity_name", "")+ result = self.zep_tools.get_entity_summary(+ graph_id=self.graph_id,+ entity_name=entity_name+ )+ return json.dumps(result, ensure_ascii=False, indent=2)++ elif tool_name == "get_simulation_context":+ query = parameters.get("query", self.simulation_requirement)+ result = self.zep_tools.get_simulation_context(+ graph_id=self.graph_id,+ simulation_requirement=query+ )+ return json.dumps(result, ensure_ascii=False, indent=2)++ elif tool_name == "get_entities_by_type":+ entity_type = parameters.get("entity_type", "")+ nodes = self.zep_tools.get_entities_by_type(+ graph_id=self.graph_id,+ entity_type=entity_type+ )+ result = [n.to_dict() for n in nodes]+ return json.dumps(result, ensure_ascii=False, indent=2)++ else:+ return f"未知工具: {tool_name}"++ except Exception as e:+ logger.error(f"工具执行失败: {tool_name}, 错误: {str(e)}")+ return f"工具执行失败: {str(e)}"++ def _parse_tool_calls(self, response: str) -> List[Dict[str, Any]]:+ """+ 从LLM响应中解析工具调用++ 支持的格式:+ <tool_call>+ {"name": "tool_name", "parameters": {"param1": "value1"}}+ </tool_call>++ 或者:+ [TOOL_CALL] tool_name(param1="value1", param2="value2")+ """+ tool_calls = []++ # 格式1: XML风格+ xml_pattern = r'<tool_call>\s*(\{.*?\})\s*</tool_call>'+ for match in re.finditer(xml_pattern, response, re.DOTALL):+ try:+ call_data = json.loads(match.group(1))+ tool_calls.append(call_data)+ except json.JSONDecodeError:+ pass++ # 格式2: 函数调用风格+ func_pattern = r'\[TOOL_CALL\]\s*(\w+)\s*\((.*?)\)'+ for match in re.finditer(func_pattern, response, re.DOTALL):+ tool_name = match.group(1)+ params_str = match.group(2)++ # 解析参数+ params = {}+ for param_match in re.finditer(r'(\w+)\s*=\s*["\']([^"\']*)["\']', params_str):+ params[param_match.group(1)] = param_match.group(2)++ tool_calls.append({+ "name": tool_name,+ "parameters": params+ })++ return tool_calls++ def _get_tools_description(self) -> str:+ """生成工具描述文本"""+ desc_parts = ["可用工具:"]+ for name, tool in self.tools.items():+ params_desc = ", ".join([f"{k}: {v}" for k, v in tool["parameters"].items()])+ desc_parts.append(f"- {name}: {tool['description']}")+ if params_desc:+ desc_parts.append(f" 参数: {params_desc}")+ return "\n".join(desc_parts)++ def plan_outline(+ self,+ progress_callback: Optional[Callable] = None+ ) -> ReportOutline:+ """+ 规划报告大纲++ 使用LLM分析模拟需求,规划报告的目录结构++ Args:+ progress_callback: 进度回调函数++ Returns:+ ReportOutline: 报告大纲+ """+ logger.info("开始规划报告大纲...")++ if progress_callback:+ progress_callback("planning", 0, "正在分析模拟需求...")++ # 首先获取模拟上下文+ context = self.zep_tools.get_simulation_context(+ graph_id=self.graph_id,+ simulation_requirement=self.simulation_requirement+ )++ if progress_callback:+ progress_callback("planning", 30, "正在生成报告大纲...")++ # 构建规划prompt+ system_prompt = """你是一个专业的舆情分析报告撰写专家。你需要根据用户的模拟需求和已有的知识图谱信息,规划一份精炼的模拟分析报告大纲。++【重要】报告章节数量限制:+- 报告最多包含5个主章节+- 每个章节可以有0-2个子章节+- 内容要精炼,避免冗余++报告应聚焦以下核心内容(选择最相关的3-5项):+1. 执行摘要 - 简要总结模拟结果和关键发现+2. 模拟背景 - 描述模拟的初始条件和场景设定+3. 关键发现 - 分析模拟中的重要发现和趋势+4. 舆情分析 - 分析舆论走向、情绪变化、关键意见领袖等+5. 建议与展望 - 基于分析结果提出建议++请输出JSON格式的报告大纲,格式如下:+{+ "title": "报告标题",+ "summary": "报告摘要(一句话概括)",+ "sections": [+ {+ "title": "章节标题",+ "description": "章节内容描述",+ "subsections": [+ {"title": "子章节标题", "description": "子章节描述"}+ ]+ }+ ]+}++注意:sections数组最多包含5个元素!"""++ user_prompt = f"""模拟需求:+{self.simulation_requirement}++已有的知识图谱信息:+- 总节点数: {context.get('graph_statistics', {}).get('total_nodes', 0)}+- 总边数: {context.get('graph_statistics', {}).get('total_edges', 0)}+- 实体类型: {list(context.get('graph_statistics', {}).get('entity_types', {}).keys())}+- 实体数量: {context.get('total_entities', 0)}++相关事实:+{json.dumps(context.get('related_facts', [])[:10], ensure_ascii=False, indent=2)}++请根据以上信息,生成一份针对此模拟场景的报告大纲。++【再次提醒】报告必须控制在最多5个章节以内,内容要精炼聚焦。"""++ try:+ response = self.llm.chat_json(+ messages=[+ {"role": "system", "content": system_prompt},+ {"role": "user", "content": user_prompt}+ ],+ temperature=0.3+ )++ if progress_callback:+ progress_callback("planning", 80, "正在解析大纲结构...")++ # 解析大纲+ sections = []+ for section_data in response.get("sections", []):+ subsections = []+ for sub_data in section_data.get("subsections", []):+ subsections.append(ReportSection(+ title=sub_data.get("title", ""),+ content=""+ ))++ sections.append(ReportSection(+ title=section_data.get("title", ""),+ content="",+ subsections=subsections+ ))++ outline = ReportOutline(+ title=response.get("title", "模拟分析报告"),+ summary=response.get("summary", ""),+ sections=sections+ )++ if progress_callback:+ progress_callback("planning", 100, "大纲规划完成")++ logger.info(f"大纲规划完成: {len(sections)} 个章节")+ return outline++ except Exception as e:+ logger.error(f"大纲规划失败: {str(e)}")+ # 返回默认大纲(5个章节)+ return ReportOutline(+ title="模拟分析报告",+ summary="基于模拟结果的分析报告",+ sections=[+ ReportSection(title="执行摘要"),+ ReportSection(title="模拟背景与场景设定"),+ ReportSection(title="关键发现与趋势分析"),+ ReportSection(title="舆情走向与情绪演化"),+ ReportSection(title="总结与建议")+ ]+ )++ def _generate_section_react(+ self,+ section: ReportSection,+ outline: ReportOutline,+ previous_sections: List[str],+ progress_callback: Optional[Callable] = None+ ) -> str:+ """+ 使用ReACT模式生成单个章节内容++ ReACT循环:+ 1. Thought(思考)- 分析需要什么信息+ 2. Action(行动)- 调用工具获取信息+ 3. Observation(观察)- 分析工具返回结果+ 4. 重复直到信息足够或达到最大次数+ 5. Final Answer(最终回答)- 生成章节内容++ Args:+ section: 要生成的章节+ outline: 完整大纲+ previous_sections: 之前章节的内容(用于保持连贯性)+ progress_callback: 进度回调++ Returns:+ 章节内容(Markdown格式)+ """+ logger.info(f"ReACT生成章节: {section.title}")++ # 构建系统prompt+ system_prompt = f"""你是一个专业的舆情分析报告撰写专家,正在撰写报告的一个章节。++报告标题: {outline.title}+报告摘要: {outline.summary}+模拟需求: {self.simulation_requirement}++当前要撰写的章节: {section.title}++你可以使用以下工具来获取信息,每次最多调用{self.MAX_TOOL_CALLS_PER_SECTION}次:++{self._get_tools_description()}++请按照以下ReACT格式进行思考和行动:++Thought: [分析当前需要什么信息来撰写这个章节]+Action: [如果需要信息,调用工具]+<tool_call>+{{"name": "工具名称", "parameters": {{"参数名": "参数值"}}}}+</tool_call>++当收集到足够信息后,输出:+Final Answer:+[章节的完整Markdown内容]++注意:+1. 内容要专业、客观、有深度+2. 引用具体的数据和事实+3. 保持与其他章节的逻辑连贯性+4. 使用适当的Markdown格式(列表、强调等)+5. 不要重复前面章节已经详细描述的内容"""++ # 构建用户prompt+ previous_content = "\n\n".join(previous_sections) if previous_sections else "(这是第一个章节)"+ user_prompt = f"""已完成的章节内容:+{previous_content[:2000]}++现在请撰写章节: {section.title}++首先思考需要什么信息,然后调用工具获取,最后生成内容。"""++ messages = [+ {"role": "system", "content": system_prompt},+ {"role": "user", "content": user_prompt}+ ]++ # ReACT循环+ tool_calls_count = 0+ max_iterations = self.MAX_TOOL_CALLS_PER_SECTION + 2++ for iteration in range(max_iterations):+ if progress_callback:+ progress_callback(+ "generating",+ int((iteration / max_iterations) * 100),+ f"思考与行动中 ({tool_calls_count}/{self.MAX_TOOL_CALLS_PER_SECTION})"+ )++ # 调用LLM+ response = self.llm.chat(+ messages=messages,+ temperature=0.5,+ max_tokens=4096+ )++ logger.debug(f"LLM响应: {response[:200]}...")++ # 检查是否有最终答案+ if "Final Answer:" in response:+ # 提取最终答案+ final_answer = response.split("Final Answer:")[-1].strip()+ logger.info(f"章节 {section.title} 生成完成")+ return final_answer++ # 解析工具调用+ tool_calls = self._parse_tool_calls(response)++ if not tool_calls:+ # 没有工具调用也没有最终答案,提示生成最终答案+ messages.append({"role": "assistant", "content": response})+ messages.append({+ "role": "user",+ "content": "请基于已有信息,输出 Final Answer: 并生成章节内容。"+ })+ continue++ # 执行工具调用+ tool_results = []+ for call in tool_calls:+ if tool_calls_count >= self.MAX_TOOL_CALLS_PER_SECTION:+ break++ result = self._execute_tool(call["name"], call.get("parameters", {}))+ tool_results.append(f"工具 {call['name']} 返回:\n{result}")+ tool_calls_count += 1++ # 将结果添加到消息+ messages.append({"role": "assistant", "content": response})+ messages.append({+ "role": "user",+ "content": f"Observation:\n" + "\n\n".join(tool_results) + "\n\n请继续思考或输出 Final Answer:"+ })++ # 达到最大迭代次数,强制生成内容+ logger.warning(f"章节 {section.title} 达到最大迭代次数,强制生成")+ messages.append({+ "role": "user",+ "content": "已达到工具调用限制,请直接输出 Final Answer: 并生成章节内容。"+ })++ response = self.llm.chat(+ messages=messages,+ temperature=0.5,+ max_tokens=4096+ )++ if "Final Answer:" in response:+ return response.split("Final Answer:")[-1].strip()++ return response++ def generate_report(+ self,+ progress_callback: Optional[Callable[[str, int, str], None]] = None+ ) -> Report:+ """+ 生成完整报告(分章节实时输出)++ 每个章节生成完成后立即保存到文件夹,不需要等待整个报告完成。+ 文件结构:+ reports/{report_id}/+ meta.json - 报告元信息+ outline.json - 报告大纲+ progress.json - 生成进度+ section_01.md - 第1章节+ section_02.md - 第2章节+ ...+ full_report.md - 完整报告++ Args:+ progress_callback: 进度回调函数 (stage, progress, message)++ Returns:+ Report: 完整报告+ """+ import uuid++ report_id = f"report_{uuid.uuid4().hex[:12]}"++ report = Report(+ report_id=report_id,+ simulation_id=self.simulation_id,+ graph_id=self.graph_id,+ simulation_requirement=self.simulation_requirement,+ status=ReportStatus.PENDING,+ created_at=datetime.now().isoformat()+ )++ # 已完成的章节标题列表(用于进度追踪)+ completed_section_titles = []++ try:+ # 初始化:创建报告文件夹并保存初始状态+ ReportManager._ensure_report_folder(report_id)+ ReportManager.update_progress(+ report_id, "pending", 0, "初始化报告...",+ completed_sections=[]+ )+ ReportManager.save_report(report)++ # 阶段1: 规划大纲+ report.status = ReportStatus.PLANNING+ ReportManager.update_progress(+ report_id, "planning", 5, "开始规划报告大纲...",+ completed_sections=[]+ )++ if progress_callback:+ progress_callback("planning", 0, "开始规划报告大纲...")++ outline = self.plan_outline(+ progress_callback=lambda stage, prog, msg:+ progress_callback(stage, prog // 5, msg) if progress_callback else None+ )+ report.outline = outline++ # 保存大纲到文件+ ReportManager.save_outline(report_id, outline)+ ReportManager.update_progress(+ report_id, "planning", 15, f"大纲规划完成,共{len(outline.sections)}个章节",+ completed_sections=[]+ )+ ReportManager.save_report(report)++ logger.info(f"大纲已保存到文件: {report_id}/outline.json")++ # 阶段2: 逐章节生成(分章节保存)+ report.status = ReportStatus.GENERATING++ total_sections = len(outline.sections)+ generated_sections = [] # 保存内容用于上下文++ for i, section in enumerate(outline.sections):+ section_num = i + 1+ base_progress = 20 + int((i / total_sections) * 70)++ # 更新进度+ ReportManager.update_progress(+ report_id, "generating", base_progress,+ f"正在生成章节: {section.title} ({section_num}/{total_sections})",+ current_section=section.title,+ completed_sections=completed_section_titles+ )++ if progress_callback:+ progress_callback(+ "generating",+ base_progress,+ f"正在生成章节: {section.title} ({section_num}/{total_sections})"+ )++ # 生成章节内容+ section_content = self._generate_section_react(+ section=section,+ outline=outline,+ previous_sections=generated_sections,+ progress_callback=lambda stage, prog, msg:+ progress_callback(+ stage,+ base_progress + int(prog * 0.7 / total_sections),+ msg+ ) if progress_callback else None+ )++ section.content = section_content+ generated_sections.append(f"## {section.title}\n\n{section_content}")++ # 【关键】立即保存章节到文件+ ReportManager.save_section(report_id, section_num, section)+ completed_section_titles.append(section.title)++ logger.info(f"章节已保存: {report_id}/section_{section_num:02d}.md")++ # 更新进度+ ReportManager.update_progress(+ report_id, "generating",+ base_progress + int(70 / total_sections),+ f"章节 {section.title} 已完成",+ current_section=None,+ completed_sections=completed_section_titles+ )++ # 生成并保存子章节+ for j, subsection in enumerate(section.subsections):+ subsection_num = j + 1++ if progress_callback:+ progress_callback(+ "generating",+ base_progress + int(((j + 1) / len(section.subsections)) * 5),+ f"正在生成子章节: {subsection.title}"+ )++ ReportManager.update_progress(+ report_id, "generating",+ base_progress + int(((j + 1) / len(section.subsections)) * 5),+ f"正在生成子章节: {subsection.title}",+ current_section=subsection.title,+ completed_sections=completed_section_titles+ )++ subsection_content = self._generate_section_react(+ section=subsection,+ outline=outline,+ previous_sections=generated_sections,+ progress_callback=None+ )+ subsection.content = subsection_content+ generated_sections.append(f"### {subsection.title}\n\n{subsection_content}")++ # 【关键】立即保存子章节到文件+ ReportManager.save_section(+ report_id, subsection_num, subsection,+ is_subsection=True, parent_index=section_num+ )+ completed_section_titles.append(f" └─ {subsection.title}")++ logger.info(f"子章节已保存: {report_id}/section_{section_num:02d}_{subsection_num:02d}.md")++ # 阶段3: 组装完整报告+ if progress_callback:+ progress_callback("generating", 95, "正在组装完整报告...")++ ReportManager.update_progress(+ report_id, "generating", 95, "正在组装完整报告...",+ completed_sections=completed_section_titles+ )++ # 使用ReportManager组装完整报告+ report.markdown_content = ReportManager.assemble_full_report(report_id, outline)+ report.status = ReportStatus.COMPLETED+ report.completed_at = datetime.now().isoformat()++ # 保存最终报告+ ReportManager.save_report(report)+ ReportManager.update_progress(+ report_id, "completed", 100, "报告生成完成",+ completed_sections=completed_section_titles+ )++ if progress_callback:+ progress_callback("completed", 100, "报告生成完成")++ logger.info(f"报告生成完成: {report_id}")+ return report++ except Exception as e:+ logger.error(f"报告生成失败: {str(e)}")+ report.status = ReportStatus.FAILED+ report.error = str(e)++ # 保存失败状态+ try:+ ReportManager.save_report(report)+ ReportManager.update_progress(+ report_id, "failed", -1, f"报告生成失败: {str(e)}",+ completed_sections=completed_section_titles+ )+ except Exception:+ pass # 忽略保存失败的错误++ return report++ def chat(+ self,+ message: str,+ chat_history: List[Dict[str, str]] = None+ ) -> Dict[str, Any]:+ """+ 与Report Agent对话++ 在对话中Agent可以自主调用检索工具来回答问题++ Args:+ message: 用户消息+ chat_history: 对话历史++ Returns:+ {+ "response": "Agent回复",+ "tool_calls": [调用的工具列表],+ "sources": [信息来源]+ }+ """+ logger.info(f"Report Agent对话: {message[:50]}...")++ chat_history = chat_history or []++ system_prompt = f"""你是一个专业的舆情分析助手,负责回答关于模拟分析报告的问题。++模拟需求: {self.simulation_requirement}+图谱ID: {self.graph_id}++你可以使用以下工具来获取信息:++{self._get_tools_description()}++工具调用格式:+<tool_call>+{{"name": "工具名称", "parameters": {{"参数名": "参数值"}}}}+</tool_call>++回答要求:+1. 基于事实和数据回答+2. 引用具体信息来源+3. 如果不确定,说明信息限制+4. 保持专业和客观"""++ # 构建消息+ messages = [{"role": "system", "content": system_prompt}]++ # 添加历史对话+ for h in chat_history[-10:]: # 限制历史长度+ messages.append(h)++ messages.append({"role": "user", "content": message})++ # ReACT循环+ tool_calls_made = []+ max_iterations = 3++ for iteration in range(max_iterations):+ response = self.llm.chat(+ messages=messages,+ temperature=0.5,+ max_tokens=2048+ )++ # 解析工具调用+ tool_calls = self._parse_tool_calls(response)++ if not tool_calls:+ # 没有工具调用,返回响应+ # 清理响应中的工具调用标记+ clean_response = re.sub(r'<tool_call>.*?</tool_call>', '', response, flags=re.DOTALL)+ clean_response = re.sub(r'\[TOOL_CALL\].*?\)', '', clean_response)++ return {+ "response": clean_response.strip(),+ "tool_calls": tool_calls_made,+ "sources": []+ }++ # 执行工具调用+ tool_results = []+ for call in tool_calls:+ result = self._execute_tool(call["name"], call.get("parameters", {}))+ tool_results.append({+ "tool": call["name"],+ "result": result[:1000] # 限制长度+ })+ tool_calls_made.append(call)++ # 将结果添加到消息+ messages.append({"role": "assistant", "content": response})+ observation = "工具调用结果:\n" + "\n\n".join([+ f"[{r['tool']}]: {r['result']}" for r in tool_results+ ])+ messages.append({"role": "user", "content": observation + "\n\n请基于以上信息回答问题。"})++ # 达到最大迭代,获取最终响应+ final_response = self.llm.chat(+ messages=messages,+ temperature=0.5,+ max_tokens=2048+ )++ return {+ "response": final_response,+ "tool_calls": tool_calls_made,+ "sources": []+ }+++class ReportManager:+ """+ 报告管理器++ 负责报告的持久化存储和检索++ 文件结构(分章节输出):+ reports/+ {report_id}/+ meta.json - 报告元信息和状态+ outline.json - 报告大纲+ progress.json - 生成进度+ section_01.md - 第1章节+ section_02.md - 第2章节+ ...+ full_report.md - 完整报告+ """++ # 报告存储目录+ REPORTS_DIR = os.path.join(Config.UPLOAD_FOLDER, 'reports')++ @classmethod+ def _ensure_reports_dir(cls):+ """确保报告根目录存在"""+ os.makedirs(cls.REPORTS_DIR, exist_ok=True)++ @classmethod+ def _get_report_folder(cls, report_id: str) -> str:+ """获取报告文件夹路径"""+ return os.path.join(cls.REPORTS_DIR, report_id)++ @classmethod+ def _ensure_report_folder(cls, report_id: str) -> str:+ """确保报告文件夹存在并返回路径"""+ folder = cls._get_report_folder(report_id)+ os.makedirs(folder, exist_ok=True)+ return folder++ @classmethod+ def _get_report_path(cls, report_id: str) -> str:+ """获取报告元信息文件路径"""+ return os.path.join(cls._get_report_folder(report_id), "meta.json")++ @classmethod+ def _get_report_markdown_path(cls, report_id: str) -> str:+ """获取完整报告Markdown文件路径"""+ return os.path.join(cls._get_report_folder(report_id), "full_report.md")++ @classmethod+ def _get_outline_path(cls, report_id: str) -> str:+ """获取大纲文件路径"""+ return os.path.join(cls._get_report_folder(report_id), "outline.json")++ @classmethod+ def _get_progress_path(cls, report_id: str) -> str:+ """获取进度文件路径"""+ return os.path.join(cls._get_report_folder(report_id), "progress.json")++ @classmethod+ def _get_section_path(cls, report_id: str, section_index: int) -> str:+ """获取章节Markdown文件路径"""+ return os.path.join(cls._get_report_folder(report_id), f"section_{section_index:02d}.md")++ @classmethod+ def save_outline(cls, report_id: str, outline: ReportOutline) -> None:+ """+ 保存报告大纲++ 在规划阶段完成后立即调用+ """+ cls._ensure_report_folder(report_id)++ with open(cls._get_outline_path(report_id), 'w', encoding='utf-8') as f:+ json.dump(outline.to_dict(), f, ensure_ascii=False, indent=2)++ logger.info(f"大纲已保存: {report_id}")++ @classmethod+ def save_section(+ cls,+ report_id: str,+ section_index: int,+ section: ReportSection,+ is_subsection: bool = False,+ parent_index: int = None+ ) -> str:+ """+ 保存单个章节++ 在每个章节生成完成后立即调用,实现分章节输出++ Args:+ report_id: 报告ID+ section_index: 章节索引(从1开始)+ section: 章节对象+ is_subsection: 是否是子章节+ parent_index: 父章节索引(子章节时使用)++ Returns:+ 保存的文件路径+ """+ cls._ensure_report_folder(report_id)++ # 确定章节级别和标题格式+ if is_subsection and parent_index is not None:+ level = "###"+ file_suffix = f"section_{parent_index:02d}_{section_index:02d}.md"+ else:+ level = "##"+ file_suffix = f"section_{section_index:02d}.md"++ # 构建章节Markdown内容+ md_content = f"{level} {section.title}\n\n"+ if section.content:+ md_content += f"{section.content}\n\n"++ # 保存文件+ file_path = os.path.join(cls._get_report_folder(report_id), file_suffix)+ with open(file_path, 'w', encoding='utf-8') as f:+ f.write(md_content)++ logger.info(f"章节已保存: {report_id}/{file_suffix}")+ return file_path++ @classmethod+ def update_progress(+ cls,+ report_id: str,+ status: str,+ progress: int,+ message: str,+ current_section: str = None,+ completed_sections: List[str] = None+ ) -> None:+ """+ 更新报告生成进度++ 前端可以通过读取progress.json获取实时进度+ """+ cls._ensure_report_folder(report_id)++ progress_data = {+ "status": status,+ "progress": progress,+ "message": message,+ "current_section": current_section,+ "completed_sections": completed_sections or [],+ "updated_at": datetime.now().isoformat()+ }++ with open(cls._get_progress_path(report_id), 'w', encoding='utf-8') as f:+ json.dump(progress_data, f, ensure_ascii=False, indent=2)++ @classmethod+ def get_progress(cls, report_id: str) -> Optional[Dict[str, Any]]:+ """获取报告生成进度"""+ path = cls._get_progress_path(report_id)++ if not os.path.exists(path):+ return None++ with open(path, 'r', encoding='utf-8') as f:+ return json.load(f)++ @classmethod+ def get_generated_sections(cls, report_id: str) -> List[Dict[str, Any]]:+ """+ 获取已生成的章节列表++ 返回所有已保存的章节文件信息+ """+ folder = cls._get_report_folder(report_id)++ if not os.path.exists(folder):+ return []++ sections = []+ for filename in sorted(os.listdir(folder)):+ if filename.startswith('section_') and filename.endswith('.md'):+ file_path = os.path.join(folder, filename)+ with open(file_path, 'r', encoding='utf-8') as f:+ content = f.read()++ # 从文件名解析章节索引+ parts = filename.replace('.md', '').split('_')+ section_index = int(parts[1])+ subsection_index = int(parts[2]) if len(parts) > 2 else None++ sections.append({+ "filename": filename,+ "section_index": section_index,+ "subsection_index": subsection_index,+ "content": content,+ "is_subsection": subsection_index is not None+ })++ return sections++ @classmethod+ def assemble_full_report(cls, report_id: str, outline: ReportOutline) -> str:+ """+ 组装完整报告++ 从已保存的章节文件组装完整报告+ """+ folder = cls._get_report_folder(report_id)++ # 构建报告头部+ md_content = f"# {outline.title}\n\n"+ md_content += f"> {outline.summary}\n\n"+ md_content += f"---\n\n"++ # 按顺序读取所有章节文件+ sections = cls.get_generated_sections(report_id)+ for section_info in sections:+ md_content += section_info["content"]++ # 保存完整报告+ full_path = cls._get_report_markdown_path(report_id)+ with open(full_path, 'w', encoding='utf-8') as f:+ f.write(md_content)++ logger.info(f"完整报告已组装: {report_id}")+ return md_content++ @classmethod+ def save_report(cls, report: Report) -> None:+ """保存报告元信息和完整报告"""+ cls._ensure_report_folder(report.report_id)++ # 保存元信息JSON+ with open(cls._get_report_path(report.report_id), 'w', encoding='utf-8') as f:+ json.dump(report.to_dict(), f, ensure_ascii=False, indent=2)++ # 保存大纲+ if report.outline:+ cls.save_outline(report.report_id, report.outline)++ # 保存完整Markdown报告+ if report.markdown_content:+ with open(cls._get_report_markdown_path(report.report_id), 'w', encoding='utf-8') as f:+ f.write(report.markdown_content)++ logger.info(f"报告已保存: {report.report_id}")++ @classmethod+ def get_report(cls, report_id: str) -> Optional[Report]:+ """获取报告"""+ path = cls._get_report_path(report_id)++ if not os.path.exists(path):+ # 兼容旧格式:检查直接存储在reports目录下的文件+ old_path = os.path.join(cls.REPORTS_DIR, f"{report_id}.json")+ if os.path.exists(old_path):+ path = old_path+ else:+ return None++ with open(path, 'r', encoding='utf-8') as f:+ data = json.load(f)++ # 重建Report对象+ outline = None+ if data.get('outline'):+ outline_data = data['outline']+ sections = []+ for s in outline_data.get('sections', []):+ subsections = [+ ReportSection(title=sub['title'], content=sub.get('content', ''))+ for sub in s.get('subsections', [])+ ]+ sections.append(ReportSection(+ title=s['title'],+ content=s.get('content', ''),+ subsections=subsections+ ))+ outline = ReportOutline(+ title=outline_data['title'],+ summary=outline_data['summary'],+ sections=sections+ )++ # 如果markdown_content为空,尝试从full_report.md读取+ markdown_content = data.get('markdown_content', '')+ if not markdown_content:+ full_report_path = cls._get_report_markdown_path(report_id)+ if os.path.exists(full_report_path):+ with open(full_report_path, 'r', encoding='utf-8') as f:+ markdown_content = f.read()++ return Report(+ report_id=data['report_id'],+ simulation_id=data['simulation_id'],+ graph_id=data['graph_id'],+ simulation_requirement=data['simulation_requirement'],+ status=ReportStatus(data['status']),+ outline=outline,+ markdown_content=markdown_content,+ created_at=data.get('created_at', ''),+ completed_at=data.get('completed_at', ''),+ error=data.get('error')+ )++ @classmethod+ def get_report_by_simulation(cls, simulation_id: str) -> Optional[Report]:+ """根据模拟ID获取报告"""+ cls._ensure_reports_dir()++ for item in os.listdir(cls.REPORTS_DIR):+ item_path = os.path.join(cls.REPORTS_DIR, item)+ # 新格式:文件夹+ if os.path.isdir(item_path):+ report = cls.get_report(item)+ if report and report.simulation_id == simulation_id:+ return report+ # 兼容旧格式:JSON文件+ elif item.endswith('.json'):+ report_id = item[:-5]+ report = cls.get_report(report_id)+ if report and report.simulation_id == simulation_id:+ return report++ return None++ @classmethod+ def list_reports(cls, simulation_id: Optional[str] = None, limit: int = 50) -> List[Report]:+ """列出报告"""+ cls._ensure_reports_dir()++ reports = []+ for item in os.listdir(cls.REPORTS_DIR):+ item_path = os.path.join(cls.REPORTS_DIR, item)+ # 新格式:文件夹+ if os.path.isdir(item_path):+ report = cls.get_report(item)+ if report:+ if simulation_id is None or report.simulation_id == simulation_id:+ reports.append(report)+ # 兼容旧格式:JSON文件+ elif item.endswith('.json'):+ report_id = item[:-5]+ report = cls.get_report(report_id)+ if report:+ if simulation_id is None or report.simulation_id == simulation_id:+ reports.append(report)++ # 按创建时间倒序+ reports.sort(key=lambda r: r.created_at, reverse=True)++ return reports[:limit]++ @classmethod+ def delete_report(cls, report_id: str) -> bool:+ """删除报告(整个文件夹)"""+ import shutil++ folder_path = cls._get_report_folder(report_id)++ # 新格式:删除整个文件夹+ if os.path.exists(folder_path) and os.path.isdir(folder_path):+ shutil.rmtree(folder_path)+ logger.info(f"报告文件夹已删除: {report_id}")+ return True++ # 兼容旧格式:删除单独的文件+ deleted = False+ old_json_path = os.path.join(cls.REPORTS_DIR, f"{report_id}.json")+ old_md_path = os.path.join(cls.REPORTS_DIR, f"{report_id}.md")++ if os.path.exists(old_json_path):+ os.remove(old_json_path)+ deleted = True+ if os.path.exists(old_md_path):+ os.remove(old_md_path)+ deleted = True++ return deleteddiff --git a/backend/app/services/zep_tools.py b/backend/app/services/zep_tools.pynew file mode 100644index 00000000..166cc97a--- /dev/null+++ b/backend/app/services/zep_tools.py@@ -0,0 +1,621 @@+"""+Zep检索工具服务+封装图谱搜索、节点读取、边查询等工具,供Report Agent使用+"""++import time+from typing import Dict, Any, List, Optional+from dataclasses import dataclass++from zep_cloud.client import Zep++from ..config import Config+from ..utils.logger import get_logger++logger = get_logger('mirofish.zep_tools')+++@dataclass+class SearchResult:+ """搜索结果"""+ facts: List[str]+ edges: List[Dict[str, Any]]+ nodes: List[Dict[str, Any]]+ query: str+ total_count: int++ def to_dict(self) -> Dict[str, Any]:+ return {+ "facts": self.facts,+ "edges": self.edges,+ "nodes": self.nodes,+ "query": self.query,+ "total_count": self.total_count+ }++ def to_text(self) -> str:+ """转换为文本格式,供LLM理解"""+ text_parts = [f"搜索查询: {self.query}", f"找到 {self.total_count} 条相关信息"]++ if self.facts:+ text_parts.append("\n### 相关事实:")+ for i, fact in enumerate(self.facts, 1):+ text_parts.append(f"{i}. {fact}")++ return "\n".join(text_parts)+++@dataclass+class NodeInfo:+ """节点信息"""+ uuid: str+ name: str+ labels: List[str]+ summary: str+ attributes: Dict[str, Any]++ def to_dict(self) -> Dict[str, Any]:+ return {+ "uuid": self.uuid,+ "name": self.name,+ "labels": self.labels,+ "summary": self.summary,+ "attributes": self.attributes+ }++ def to_text(self) -> str:+ """转换为文本格式"""+ entity_type = next((l for l in self.labels if l not in ["Entity", "Node"]), "未知类型")+ return f"实体: {self.name} (类型: {entity_type})\n摘要: {self.summary}"+++@dataclass+class EdgeInfo:+ """边信息"""+ uuid: str+ name: str+ fact: str+ source_node_uuid: str+ target_node_uuid: str+ source_node_name: Optional[str] = None+ target_node_name: Optional[str] = None++ def to_dict(self) -> Dict[str, Any]:+ return {+ "uuid": self.uuid,+ "name": self.name,+ "fact": self.fact,+ "source_node_uuid": self.source_node_uuid,+ "target_node_uuid": self.target_node_uuid,+ "source_node_name": self.source_node_name,+ "target_node_name": self.target_node_name+ }++ def to_text(self) -> str:+ """转换为文本格式"""+ source = self.source_node_name or self.source_node_uuid[:8]+ target = self.target_node_name or self.target_node_uuid[:8]+ return f"关系: {source} --[{self.name}]--> {target}\n事实: {self.fact}"+++class ZepToolsService:+ """+ Zep检索工具服务++ 提供多种图谱检索工具,可以被Report Agent调用:+ 1. search_graph - 图谱语义搜索+ 2. get_all_nodes - 获取图谱所有节点+ 3. get_all_edges - 获取图谱所有边+ 4. get_node_detail - 获取节点详细信息+ 5. get_node_edges - 获取节点相关的边+ 6. get_entities_by_type - 按类型获取实体+ 7. get_entity_summary - 获取实体的关系摘要+ """++ # 重试配置+ MAX_RETRIES = 3+ RETRY_DELAY = 2.0++ def __init__(self, api_key: Optional[str] = None):+ self.api_key = api_key or Config.ZEP_API_KEY+ if not self.api_key:+ raise ValueError("ZEP_API_KEY 未配置")++ self.client = Zep(api_key=self.api_key)+ logger.info("ZepToolsService 初始化完成")++ def _call_with_retry(self, func, operation_name: str, max_retries: int = None):+ """带重试机制的API调用"""+ max_retries = max_retries or self.MAX_RETRIES+ last_exception = None+ delay = self.RETRY_DELAY++ for attempt in range(max_retries):+ try:+ return func()+ except Exception as e:+ last_exception = e+ if attempt < max_retries - 1:+ logger.warning(+ f"Zep {operation_name} 第 {attempt + 1} 次尝试失败: {str(e)[:100]}, "+ f"{delay:.1f}秒后重试..."+ )+ time.sleep(delay)+ delay *= 2+ else:+ logger.error(f"Zep {operation_name} 在 {max_retries} 次尝试后仍失败: {str(e)}")++ raise last_exception++ def search_graph(+ self,+ graph_id: str,+ query: str,+ limit: int = 10,+ scope: str = "edges"+ ) -> SearchResult:+ """+ 图谱语义搜索++ 使用混合搜索(语义+BM25)在图谱中搜索相关信息。+ 如果Zep Cloud的search API不可用,则降级为本地关键词匹配。++ Args:+ graph_id: 图谱ID (Standalone Graph)+ query: 搜索查询+ limit: 返回结果数量+ scope: 搜索范围,"edges" 或 "nodes"++ Returns:+ SearchResult: 搜索结果+ """+ logger.info(f"图谱搜索: graph_id={graph_id}, query={query[:50]}...")++ # 尝试使用Zep Cloud Search API+ try:+ search_results = self._call_with_retry(+ func=lambda: self.client.graph.search(+ graph_id=graph_id,+ query=query,+ limit=limit,+ scope=scope,+ reranker="cross_encoder"+ ),+ operation_name=f"图谱搜索(graph={graph_id})"+ )++ facts = []+ edges = []+ nodes = []++ # 解析边搜索结果+ if hasattr(search_results, 'edges') and search_results.edges:+ for edge in search_results.edges:+ if hasattr(edge, 'fact') and edge.fact:+ facts.append(edge.fact)+ edges.append({+ "uuid": getattr(edge, 'uuid_', None) or getattr(edge, 'uuid', ''),+ "name": getattr(edge, 'name', ''),+ "fact": getattr(edge, 'fact', ''),+ "source_node_uuid": getattr(edge, 'source_node_uuid', ''),+ "target_node_uuid": getattr(edge, 'target_node_uuid', ''),+ })++ # 解析节点搜索结果+ if hasattr(search_results, 'nodes') and search_results.nodes:+ for node in search_results.nodes:+ nodes.append({+ "uuid": getattr(node, 'uuid_', None) or getattr(node, 'uuid', ''),+ "name": getattr(node, 'name', ''),+ "labels": getattr(node, 'labels', []),+ "summary": getattr(node, 'summary', ''),+ })+ # 节点摘要也算作事实+ if hasattr(node, 'summary') and node.summary:+ facts.append(f"[{node.name}]: {node.summary}")++ logger.info(f"搜索完成: 找到 {len(facts)} 条相关事实")++ return SearchResult(+ facts=facts,+ edges=edges,+ nodes=nodes,+ query=query,+ total_count=len(facts)+ )++ except Exception as e:+ logger.warning(f"Zep Search API失败,降级为本地搜索: {str(e)}")+ # 降级:使用本地关键词匹配搜索+ return self._local_search(graph_id, query, limit, scope)++ def _local_search(+ self,+ graph_id: str,+ query: str,+ limit: int = 10,+ scope: str = "edges"+ ) -> SearchResult:+ """+ 本地关键词匹配搜索(作为Zep Search API的降级方案)++ 获取所有边/节点,然后在本地进行关键词匹配++ Args:+ graph_id: 图谱ID+ query: 搜索查询+ limit: 返回结果数量+ scope: 搜索范围++ Returns:+ SearchResult: 搜索结果+ """+ logger.info(f"使用本地搜索: query={query[:30]}...")++ facts = []+ edges_result = []+ nodes_result = []++ # 提取查询关键词(简单分词)+ query_lower = query.lower()+ keywords = [w.strip() for w in query_lower.replace(',', ' ').replace(',', ' ').split() if len(w.strip()) > 1]++ def match_score(text: str) -> int:+ """计算文本与查询的匹配分数"""+ if not text:+ return 0+ text_lower = text.lower()+ # 完全匹配查询+ if query_lower in text_lower:+ return 100+ # 关键词匹配+ score = 0+ for keyword in keywords:+ if keyword in text_lower:+ score += 10+ return score++ try:+ if scope in ["edges", "both"]:+ # 获取所有边并匹配+ all_edges = self.get_all_edges(graph_id)+ scored_edges = []+ for edge in all_edges:+ score = match_score(edge.fact) + match_score(edge.name)+ if score > 0:+ scored_edges.append((score, edge))++ # 按分数排序+ scored_edges.sort(key=lambda x: x[0], reverse=True)++ for score, edge in scored_edges[:limit]:+ if edge.fact:+ facts.append(edge.fact)+ edges_result.append({+ "uuid": edge.uuid,+ "name": edge.name,+ "fact": edge.fact,+ "source_node_uuid": edge.source_node_uuid,+ "target_node_uuid": edge.target_node_uuid,+ })++ if scope in ["nodes", "both"]:+ # 获取所有节点并匹配+ all_nodes = self.get_all_nodes(graph_id)+ scored_nodes = []+ for node in all_nodes:+ score = match_score(node.name) + match_score(node.summary)+ if score > 0:+ scored_nodes.append((score, node))++ scored_nodes.sort(key=lambda x: x[0], reverse=True)++ for score, node in scored_nodes[:limit]:+ nodes_result.append({+ "uuid": node.uuid,+ "name": node.name,+ "labels": node.labels,+ "summary": node.summary,+ })+ if node.summary:+ facts.append(f"[{node.name}]: {node.summary}")++ logger.info(f"本地搜索完成: 找到 {len(facts)} 条相关事实")++ except Exception as e:+ logger.error(f"本地搜索失败: {str(e)}")++ return SearchResult(+ facts=facts,+ edges=edges_result,+ nodes=nodes_result,+ query=query,+ total_count=len(facts)+ )++ def get_all_nodes(self, graph_id: str) -> List[NodeInfo]:+ """+ 获取图谱的所有节点++ Args:+ graph_id: 图谱ID++ Returns:+ 节点列表+ """+ logger.info(f"获取图谱 {graph_id} 的所有节点...")++ nodes = self._call_with_retry(+ func=lambda: self.client.graph.node.get_by_graph_id(graph_id=graph_id),+ operation_name=f"获取节点(graph={graph_id})"+ )++ result = []+ for node in nodes:+ result.append(NodeInfo(+ uuid=getattr(node, 'uuid_', None) or getattr(node, 'uuid', ''),+ name=node.name or "",+ labels=node.labels or [],+ summary=node.summary or "",+ attributes=node.attributes or {}+ ))++ logger.info(f"获取到 {len(result)} 个节点")+ return result++ def get_all_edges(self, graph_id: str) -> List[EdgeInfo]:+ """+ 获取图谱的所有边++ Args:+ graph_id: 图谱ID++ Returns:+ 边列表+ """+ logger.info(f"获取图谱 {graph_id} 的所有边...")++ edges = self._call_with_retry(+ func=lambda: self.client.graph.edge.get_by_graph_id(graph_id=graph_id),+ operation_name=f"获取边(graph={graph_id})"+ )++ result = []+ for edge in edges:+ result.append(EdgeInfo(+ uuid=getattr(edge, 'uuid_', None) or getattr(edge, 'uuid', ''),+ name=edge.name or "",+ fact=edge.fact or "",+ source_node_uuid=edge.source_node_uuid or "",+ target_node_uuid=edge.target_node_uuid or ""+ ))++ logger.info(f"获取到 {len(result)} 条边")+ return result++ def get_node_detail(self, node_uuid: str) -> Optional[NodeInfo]:+ """+ 获取单个节点的详细信息++ Args:+ node_uuid: 节点UUID++ Returns:+ 节点信息或None+ """+ logger.info(f"获取节点详情: {node_uuid[:8]}...")++ try:+ node = self._call_with_retry(+ func=lambda: self.client.graph.node.get(uuid_=node_uuid),+ operation_name=f"获取节点详情(uuid={node_uuid[:8]}...)"+ )++ if not node:+ return None++ return NodeInfo(+ uuid=getattr(node, 'uuid_', None) or getattr(node, 'uuid', ''),+ name=node.name or "",+ labels=node.labels or [],+ summary=node.summary or "",+ attributes=node.attributes or {}+ )+ except Exception as e:+ logger.error(f"获取节点详情失败: {str(e)}")+ return None++ def get_node_edges(self, graph_id: str, node_uuid: str) -> List[EdgeInfo]:+ """+ 获取节点相关的所有边++ 通过获取图谱所有边,然后过滤出与指定节点相关的边++ Args:+ graph_id: 图谱ID+ node_uuid: 节点UUID++ Returns:+ 边列表+ """+ logger.info(f"获取节点 {node_uuid[:8]}... 的相关边")++ try:+ # 获取图谱所有边,然后过滤+ all_edges = self.get_all_edges(graph_id)++ result = []+ for edge in all_edges:+ # 检查边是否与指定节点相关(作为源或目标)+ if edge.source_node_uuid == node_uuid or edge.target_node_uuid == node_uuid:+ result.append(edge)++ logger.info(f"找到 {len(result)} 条与节点相关的边")+ return result++ except Exception as e:+ logger.warning(f"获取节点边失败: {str(e)}")+ return []++ def get_entities_by_type(+ self,+ graph_id: str,+ entity_type: str+ ) -> List[NodeInfo]:+ """+ 按类型获取实体++ Args:+ graph_id: 图谱ID+ entity_type: 实体类型(如 Student, PublicFigure 等)++ Returns:+ 符合类型的实体列表+ """+ logger.info(f"获取类型为 {entity_type} 的实体...")++ all_nodes = self.get_all_nodes(graph_id)++ filtered = []+ for node in all_nodes:+ # 检查labels是否包含指定类型+ if entity_type in node.labels:+ filtered.append(node)++ logger.info(f"找到 {len(filtered)} 个 {entity_type} 类型的实体")+ return filtered++ def get_entity_summary(+ self,+ graph_id: str,+ entity_name: str+ ) -> Dict[str, Any]:+ """+ 获取指定实体的关系摘要++ 搜索与该实体相关的所有信息,并生成摘要++ Args:+ graph_id: 图谱ID+ entity_name: 实体名称++ Returns:+ 实体摘要信息+ """+ logger.info(f"获取实体 {entity_name} 的关系摘要...")++ # 先搜索该实体相关的信息+ search_result = self.search_graph(+ graph_id=graph_id,+ query=entity_name,+ limit=20+ )++ # 尝试在所有节点中找到该实体+ all_nodes = self.get_all_nodes(graph_id)+ entity_node = None+ for node in all_nodes:+ if node.name.lower() == entity_name.lower():+ entity_node = node+ break++ related_edges = []+ if entity_node:+ # 传入graph_id参数+ related_edges = self.get_node_edges(graph_id, entity_node.uuid)++ return {+ "entity_name": entity_name,+ "entity_info": entity_node.to_dict() if entity_node else None,+ "related_facts": search_result.facts,+ "related_edges": [e.to_dict() for e in related_edges],+ "total_relations": len(related_edges)+ }++ def get_graph_statistics(self, graph_id: str) -> Dict[str, Any]:+ """+ 获取图谱的统计信息++ Args:+ graph_id: 图谱ID++ Returns:+ 统计信息+ """+ logger.info(f"获取图谱 {graph_id} 的统计信息...")++ nodes = self.get_all_nodes(graph_id)+ edges = self.get_all_edges(graph_id)++ # 统计实体类型分布+ entity_types = {}+ for node in nodes:+ for label in node.labels:+ if label not in ["Entity", "Node"]:+ entity_types[label] = entity_types.get(label, 0) + 1++ # 统计关系类型分布+ relation_types = {}+ for edge in edges:+ relation_types[edge.name] = relation_types.get(edge.name, 0) + 1++ return {+ "graph_id": graph_id,+ "total_nodes": len(nodes),+ "total_edges": len(edges),+ "entity_types": entity_types,+ "relation_types": relation_types+ }++ def get_simulation_context(+ self,+ graph_id: str,+ simulation_requirement: str,+ limit: int = 30+ ) -> Dict[str, Any]:+ """+ 获取模拟相关的上下文信息++ 综合搜索与模拟需求相关的所有信息++ Args:+ graph_id: 图谱ID+ simulation_requirement: 模拟需求描述+ limit: 每类信息的数量限制++ Returns:+ 模拟上下文信息+ """+ logger.info(f"获取模拟上下文: {simulation_requirement[:50]}...")++ # 搜索与模拟需求相关的信息+ search_result = self.search_graph(+ graph_id=graph_id,+ query=simulation_requirement,+ limit=limit+ )++ # 获取图谱统计+ stats = self.get_graph_statistics(graph_id)++ # 获取所有实体节点+ all_nodes = self.get_all_nodes(graph_id)++ # 筛选有实际类型的实体(非纯Entity节点)+ entities = []+ for node in all_nodes:+ custom_labels = [l for l in node.labels if l not in ["Entity", "Node"]]+ if custom_labels:+ entities.append({+ "name": node.name,+ "type": custom_labels[0],+ "summary": node.summary+ })++ return {+ "simulation_requirement": simulation_requirement,+ "related_facts": search_result.facts,+ "graph_statistics": stats,+ "entities": entities[:limit], # 限制数量+ "total_entities": len(entities)+ }diff --git a/backend/requirements.txt b/backend/requirements.txtindex 1a0d82d5..80cc5fac 100644--- a/backend/requirements.txt+++ b/backend/requirements.txt@@ -24,3 +24,8 @@ werkzeug>=3.0.0oasis-ai>=0.1.0camel-ai>=0.2.0+# LangChain框架(用于Report Agent)+langchain>=0.2.0+langchain-core>=0.2.0+langchain-openai>=0.1.0+