A Simple and Universal Swarm Intelligence Engine, Predicting Anything. 简洁通用的群体智能引擎,预测万物
Python agent-memoryfinancial-forecastingfuture-predictionknowledge-graphllmsmulti-agent-simulationpublic-opinion-analysispython3social-predictionswarm-intelligence
Enhance backend functionality with OASIS simulation features
666ghj5f159f6d88e8
diff --git a/backend/README.md b/backend/README.mdindex ee54adb9..2521693c 100644--- a/backend/README.md+++ b/backend/README.md@@ -7,23 +7,37 @@```backend/├── app/-│ ├── __init__.py # Flask应用工厂-│ ├── config.py # 配置管理-│ ├── api/ # API路由-│ │ ├── __init__.py-│ │ └── graph.py # 图谱相关接口-│ ├── services/ # 业务逻辑层-│ │ ├── ontology_generator.py # 本体生成服务-│ │ ├── graph_builder.py # 图谱构建服务-│ │ └── text_processor.py # 文本处理服务-│ ├── models/ # 数据模型-│ │ ├── task.py # 任务状态管理-│ │ └── project.py # 项目上下文管理-│ └── utils/ # 工具模块-│ ├── file_parser.py # 文件解析-│ └── llm_client.py # LLM客户端+│ ├── __init__.py # Flask应用工厂+│ ├── config.py # 配置管理+│ ├── api/ # API路由+│ │ ├── __init__.py # Blueprint注册+│ │ ├── graph.py # Step1: 图谱相关接口+│ │ └── simulation.py # Step2: 模拟相关接口+│ ├── services/ # 业务逻辑层+│ │ ├── __init__.py # 服务模块导出+│ │ ├── ontology_generator.py # 本体生成服务+│ │ ├── graph_builder.py # 图谱构建服务+│ │ ├── text_processor.py # 文本处理服务+│ │ ├── zep_entity_reader.py # Zep实体读取与过滤+│ │ ├── oasis_profile_generator.py # Agent Profile生成器+│ │ ├── simulation_config_generator.py # LLM智能配置生成器(核心)+│ │ └── simulation_manager.py # 模拟管理器+│ ├── models/ # 数据模型+│ │ ├── task.py # 任务状态管理+│ │ └── project.py # 项目上下文管理+│ └── utils/ # 工具模块+│ ├── file_parser.py # 文件解析+│ ├── llm_client.py # LLM客户端+│ └── logger.py # 日志工具+├── scripts/ # 预设模拟脚本+│ ├── run_twitter_simulation.py # Twitter模拟脚本+│ ├── run_reddit_simulation.py # Reddit模拟脚本+│ └── run_parallel_simulation.py # 双平台并行脚本+├── uploads/ # 上传文件存储+│ ├── projects/ # 项目文件+│ └── simulations/ # 模拟数据(含配置和脚本副本)├── requirements.txt-└── run.py # 启动入口+└── run.py # 启动入口```## 安装@@ -39,13 +53,16 @@ pip install -r requirements.txt在项目根目录 `MiroFish/.env` 中配置:```bash-# LLM配置+# LLM配置(统一使用OpenAI格式)LLM_API_KEY=your-llm-api-keyLLM_BASE_URL=https://openrouter.ai/api/v1LLM_MODEL_NAME=gpt-4o-mini# Zep配置ZEP_API_KEY=your-zep-api-key++# OASIS模拟配置(可选)+OASIS_DEFAULT_MAX_ROUNDS=10```## 启动服务@@ -54,22 +71,63 @@ ZEP_API_KEY=your-zep-api-keypython run.py```-服务默认运行在 http://localhost:5000+服务默认运行在 http://localhost:5001++---++# 系统架构++## 完整工作流程++```+┌─────────────────────────────────────────────────────────────────────────┐+│ Step 1: 图谱构建 │+├─────────────────────────────────────────────────────────────────────────┤+│ │+│ 上传文档 ──→ 生成本体定义 ──→ 构建Zep图谱 ──→ 图谱数据 │+│ (PDF/MD/TXT) (LLM分析) (异步任务) (节点/边) │+│ │+└─────────────────────────────────────────────────────────────────────────┘+ │+ ▼+┌─────────────────────────────────────────────────────────────────────────┐+│ Step 2: 实体读取与模拟准备 │+├─────────────────────────────────────────────────────────────────────────┤+│ │+│ 读取图谱节点 ──→ 过滤符合条件实体 ──→ 生成Agent Profile ──→ 生成脚本 │+│ (Zep API) (按Labels筛选) (LLM生成人设) (OASIS启动) │+│ │+└─────────────────────────────────────────────────────────────────────────┘+ │+ ▼+┌─────────────────────────────────────────────────────────────────────────┐+│ Step 3: 双平台并行模拟 │+├─────────────────────────────────────────────────────────────────────────┤+│ │+│ ┌─────────────────┐ ┌─────────────────┐ │+│ │ Twitter模拟 │ │ Reddit模拟 │ │+│ │ (短平快交互) │ 并行运行 │ (深度话题讨论) │ │+│ └─────────────────┘ └─────────────────┘ │+│ │ │+│ ▼ │+│ 同一批智能体,模拟真实社交环境 │+│ │+└─────────────────────────────────────────────────────────────────────────┘+```----## API接口+# Step 1: 图谱构建 API-### 核心工作流程+## 核心工作流程```-1. 上传文件 + 生成本体(接口1)+1. 上传文件 + 生成本体POST /api/graph/ontology/generate- → 自动创建项目,返回 project_id+ → 返回 project_id-2. 构建图谱(接口2)+2. 构建图谱POST /api/graph/build- → 传入 project_id→ 返回 task_id3. 查询任务进度@@ -91,10 +149,10 @@ python run.py| 字段 | 类型 | 必填 | 说明 ||------|------|------|------|-| `files` | File | ✅ | PDF/MD/TXT文件,可多个 |-| `simulation_requirement` | Text | ✅ | 模拟需求描述 |-| `project_name` | Text | ❌ | 项目名称 |-| `additional_context` | Text | ❌ | 额外说明 |+| `files` | File | 是 | PDF/MD/TXT文件,可多个 |+| `simulation_requirement` | Text | 是 | 模拟需求描述 |+| `project_name` | Text | 否 | 项目名称 |+| `additional_context` | Text | 否 | 额外说明 |**响应示例:**```json@@ -106,23 +164,26 @@ python run.py"ontology": {"entity_types": [{- "name": "Person",- "description": "Individuals who can express opinions",- "attributes": [...]+ "name": "Student",+ "description": "Students enrolled in educational institutions",+ "attributes": [+ {"name": "student_id", "type": "text", "description": "Unique identifier"},+ {"name": "major", "type": "text", "description": "Field of study"}+ ]}],"edge_types": [{"name": "AFFILIATED_WITH",- "description": "Indicates affiliation",- "source_targets": [...]+ "description": "Indicates affiliation between entities",+ "source_targets": [+ {"source": "Student", "target": "University"}+ ]}]},"analysis_summary": "分析说明...",- "files": [- {"filename": "报告.pdf", "size": 123456}- ],+ "files": [{"filename": "报告.pdf", "size": 123456}],"total_text_length": 20833}}@@ -148,10 +209,10 @@ python run.py| 字段 | 类型 | 必填 | 说明 ||------|------|------|------|-| `project_id` | string | ✅ | 来自接口1的返回 |-| `graph_name` | string | ❌ | 图谱名称 |-| `chunk_size` | int | ❌ | 文本块大小,默认500 |-| `chunk_overlap` | int | ❌ | 块重叠字符,默认50 |+| `project_id` | string | 是 | 来自接口1的返回 |+| `graph_name` | string | 否 | 图谱名称 |+| `chunk_size` | int | 否 | 文本块大小,默认500 |+| `chunk_overlap` | int | 否 | 块重叠字符,默认50 |**响应:**```json@@ -178,7 +239,7 @@ python run.py"task_id": "task_xyz789","status": "processing","progress": 45,- "message": "添加文本块 (15/30)...",+ "message": "Zep处理中... 15/30 完成","result": null}}@@ -211,17 +272,1191 @@ python run.py----## 实体设计原则+# Step 2: 实体读取与模拟运行 API++## 核心设计理念++**全程自动化,无需人工设置参数:**+- 脚本是**预设的**,不是动态生成+- 所有模拟参数由**LLM智能生成**+- LLM读取模拟需求+文档+图谱信息,自动设置最佳参数+- **通过API接口启动和监控模拟**,前端可实时展示++## 核心工作流程++```+1. 创建模拟+ POST /api/simulation/create+ → 返回 simulation_id++2. 准备模拟环境(异步任务)+ POST /api/simulation/prepare+ Body: { "simulation_id": "sim_xxxx" }+ → 返回 task_id(立即响应)++ 查询进度:+ POST /api/simulation/prepare/status+ Body: { "task_id": "task_xxxx" }+ → 返回 status, progress, result++3. 开始模拟+ POST /api/simulation/start+ Body: { "simulation_id": "sim_xxxx", "platform": "parallel" }+ → 在后台启动OASIS模拟进程+ → 返回运行状态++4. 实时监控(前端轮询)+ GET /api/simulation/{simulation_id}/run-status/detail+ → 返回当前进度、最近Agent动作++5. 停止模拟(可选)+ POST /api/simulation/stop+ Body: { "simulation_id": "sim_xxxx" }+```++---++## 实体读取接口++### 获取图谱实体(已过滤)++**GET** `/api/simulation/entities/{graph_id}`++获取图谱中符合预定义实体类型的节点。++**实体过滤逻辑:**+- Zep对符合预定义类型的实体,Labels为 `["Entity", "Student"]`+- 对不符合预定义类型的实体,Labels仅为 `["Entity"]`+- **筛选规则**:只保留Labels中包含除"Entity"和"Node"之外标签的节点++**Query参数:**++| 参数 | 类型 | 必填 | 说明 |+|------|------|------|------|+| `entity_types` | string | 否 | 逗号分隔的实体类型,用于进一步过滤 |+| `enrich` | boolean | 否 | 是否获取相关边信息,默认true |++**响应示例:**+```json+{+ "success": true,+ "data": {+ "entities": [+ {+ "uuid": "node_uuid_123",+ "name": "杨景媛",+ "labels": ["Entity", "Student"],+ "summary": "武汉大学学生,图书馆事件当事人",+ "attributes": {+ "student_id": "2021001",+ "major": "计算机科学"+ },+ "related_edges": [+ {+ "direction": "outgoing",+ "edge_name": "AFFILIATED_WITH",+ "fact": "杨景媛是武汉大学的学生",+ "target_node_uuid": "node_uuid_456"+ }+ ],+ "related_nodes": [+ {+ "uuid": "node_uuid_456",+ "name": "武汉大学",+ "labels": ["Entity", "University"],+ "summary": "中国著名高等学府"+ }+ ]+ }+ ],+ "entity_types": ["Student", "University", "PublicFigure"],+ "total_count": 100,+ "filtered_count": 45+ }+}+```++---++### 获取单个实体详情++**GET** `/api/simulation/entities/{graph_id}/{entity_uuid}`++获取单个实体的完整信息,包含所有相关边和关联节点。++---++### 按类型获取实体++**GET** `/api/simulation/entities/{graph_id}/by-type/{entity_type}`++获取指定类型(如Student、PublicFigure)的所有实体。++---++## 模拟管理接口++### 创建模拟++**POST** `/api/simulation/create`++**请求(JSON):**+```json+{+ "project_id": "proj_abc123def456",+ "graph_id": "mirofish_xxxx",+ "enable_twitter": true,+ "enable_reddit": true,+ "max_rounds": 10,+ "agents_per_round": -1+}+```++| 字段 | 类型 | 必填 | 说明 |+|------|------|------|------|+| `project_id` | string | 是 | 项目ID |+| `graph_id` | string | 否 | 图谱ID,不提供则从project获取 |+| `enable_twitter` | boolean | 否 | 启用Twitter模拟,默认true |+| `enable_reddit` | boolean | 否 | 启用Reddit模拟,默认true |+| `max_rounds` | int | 否 | 最大模拟轮数,默认10 |+| `agents_per_round` | int | 否 | 每轮激活智能体数,-1表示全部 |++**响应示例:**+```json+{+ "success": true,+ "data": {+ "simulation_id": "sim_abc123def456",+ "config": {+ "project_id": "proj_xxxx",+ "graph_id": "mirofish_xxxx",+ "enable_twitter": true,+ "enable_reddit": true,+ "max_rounds": 10+ },+ "status": "created",+ "created_at": "2025-12-01T10:00:00"+ }+}+```++---++### 准备模拟环境(异步任务)++**POST** `/api/simulation/prepare`++**异步接口**:这是一个耗时操作,接口会立即返回`task_id`,通过`/prepare/status`查询进度。++执行模拟准备流程(LLM智能生成所有参数,带自动重试机制):+1. 从Zep图谱读取并过滤实体+2. 为每个实体生成OASIS Agent Profile(带重试)+3. LLM智能生成模拟配置(带重试)+4. 保存配置文件和复制预设脚本++**请求(JSON):**+```json+{+ "simulation_id": "sim_xxxx",+ "entity_types": ["Student", "PublicFigure"],+ "use_llm_for_profiles": true+}+```++**响应示例:**+```json+{+ "success": true,+ "data": {+ "simulation_id": "sim_xxxx",+ "task_id": "task_xxxx",+ "status": "preparing",+ "message": "准备任务已启动,请通过 /api/simulation/prepare/status 查询进度"+ }+}+```++---++### 查询准备进度++**POST** `/api/simulation/prepare/status`++查询准备任务的执行进度。++**请求(JSON):**+```json+{+ "task_id": "task_xxxx"+}+```++**响应示例:**+```json+{+ "success": true,+ "data": {+ "task_id": "task_xxxx",+ "task_type": "simulation_prepare",+ "status": "processing",+ "progress": 45,+ "message": "[2/4] 生成Agent人设: 35/93 - 生成 教授张三 的人设...",+ "progress_detail": {+ "current_stage": "generating_profiles",+ "current_stage_name": "生成Agent人设",+ "stage_index": 2,+ "total_stages": 4,+ "stage_progress": 38,+ "current_item": 35,+ "total_items": 93,+ "item_description": "生成 教授张三 的人设..."+ },+ "result": null,+ "error": null,+ "metadata": {+ "project_id": "proj_xxxx",+ "simulation_id": "sim_xxxx"+ }+ }+}+```++**进度详情字段(progress_detail):**++| 字段 | 类型 | 说明 |+|------|------|------|+| `current_stage` | string | 当前阶段标识 (reading/generating_profiles/generating_config/copying_scripts) |+| `current_stage_name` | string | 当前阶段中文名称 |+| `stage_index` | int | 当前阶段序号 (1-4) |+| `total_stages` | int | 总阶段数 (4) |+| `stage_progress` | int | 当前阶段内进度 (0-100) |+| `current_item` | int | 当前处理的项目序号 |+| `total_items` | int | 当前阶段总项目数 |+| `item_description` | string | 当前项目描述 |++**阶段说明:**++| 阶段 | 名称 | 权重 | 说明 |+|------|------|------|------|+| 1 | 读取图谱实体 | 0-20% | 从Zep读取并过滤实体 |+| 2 | 生成Agent人设 | 20-70% | 为每个实体生成OASIS Profile |+| 3 | 生成模拟配置 | 70-90% | LLM智能生成模拟参数 |+| 4 | 准备模拟脚本 | 90-100% | 复制预设脚本到模拟目录 |++**状态值(status):**+- `pending` - 等待中+- `processing` - 处理中+- `completed` - 已完成(此时result包含结果)+- `failed` - 失败(此时error包含错误信息)++**完成后的响应:**+```json+{+ "success": true,+ "data": {+ "task_id": "task_xxxx",+ "status": "completed",+ "progress": 100,+ "message": "任务完成",+ "result": {+ "simulation_id": "sim_xxxx",+ "project_id": "proj_xxxx",+ "graph_id": "mirofish_xxxx",+ "status": "ready",+ "entities_count": 93,+ "profiles_count": 93,+ "entity_types": ["University", "Student", ...],+ "config_generated": true,+ "error": null+ }+ }+}+```++| 字段 | 类型 | 必填 | 说明 |+|------|------|------|------|+| `entity_types` | array | 否 | 指定实体类型进行过滤 |+| `use_llm_for_profiles` | boolean | 否 | 是否使用LLM生成人设,默认true |++**注意**:`simulation_requirement`和`document_text`自动从项目中获取++**响应示例:**+```json+{+ "success": true,+ "data": {+ "simulation_id": "sim_abc123def456",+ "status": "ready",+ "entities_count": 45,+ "profiles_count": 45,+ "entity_types": ["Student", "PublicFigure", "University"],+ "config_generated": true,+ "config_reasoning": "根据武汉大学图书馆事件的特点,设置72小时模拟时长...",+ "run_instructions": {+ "simulation_dir": "/path/to/sim_xxx",+ "commands": {...},+ "instructions": "..."+ }+ }+}+```++---++### 获取模拟状态++**GET** `/api/simulation/{simulation_id}`++**响应示例:**+```json+{+ "success": true,+ "data": {+ "simulation_id": "sim_abc123def456",+ "status": "ready",+ "entities_count": 45,+ "profiles_count": 45,+ "entity_types": ["Student", "PublicFigure"],+ "current_round": 0,+ "twitter_status": "not_started",+ "reddit_status": "not_started"+ }+}+```++---++### 列出所有模拟++**GET** `/api/simulation/list`++| Query参数 | 类型 | 说明 |+|-----------|------|------|+| `project_id` | string | 按项目ID过滤(可选) |++---++### 获取Agent Profile++**GET** `/api/simulation/{simulation_id}/profiles`++| Query参数 | 类型 | 说明 |+|-----------|------|------|+| `platform` | string | 平台类型:reddit 或 twitter |++**响应示例:**+```json+{+ "success": true,+ "data": {+ "platform": "reddit",+ "count": 45,+ "profiles": [+ {+ "user_id": 0,+ "user_name": "yangjingyuan_123",+ "name": "杨景媛",+ "bio": "武汉大学学生,关注教育公平与学生权益",+ "persona": "杨景媛是一名积极参与社会讨论的大学生,性格内敛但观点鲜明...",+ "karma": 1500,+ "age": 22,+ "gender": "female",+ "mbti": "INFJ",+ "country": "China",+ "profession": "Student",+ "interested_topics": ["Education", "Social Issues"]+ }+ ]+ }+}+```++---++### 获取模拟配置++**GET** `/api/simulation/{simulation_id}/config`++获取LLM智能生成的完整配置,包含:+- `time_config`: 时间配置+- `agent_configs`: 每个Agent的活动配置+- `event_config`: 事件配置+- `generation_reasoning`: LLM的配置推理说明++---++### 下载文件++| 接口 | 说明 |+|------|------|+| GET `/api/simulation/{id}/config/download` | 下载配置文件 |+| GET `/api/simulation/{id}/script/{script_name}/download` | 下载脚本文件 |++**脚本名称:**+- `run_twitter_simulation.py`+- `run_reddit_simulation.py`+- `run_parallel_simulation.py`++---++### 直接生成Profile++**POST** `/api/simulation/generate-profiles`++不创建模拟,直接从图谱生成Agent Profile。++```json+{+ "graph_id": "mirofish_xxxx",+ "entity_types": ["Student", "PublicFigure"],+ "use_llm": true,+ "platform": "reddit"+}+```++---++## 模拟运行控制接口++### 开始模拟++**POST** `/api/simulation/start`++启动OASIS模拟,在后台运行。++**请求(JSON):**+```json+{+ "simulation_id": "sim_xxxx", // 必填+ "platform": "parallel" // 可选: twitter / reddit / parallel (默认)+}+```++**响应示例:**+```json+{+ "success": true,+ "data": {+ "simulation_id": "sim_xxxx",+ "runner_status": "running",+ "process_pid": 12345,+ "twitter_running": true,+ "reddit_running": true,+ "total_rounds": 144,+ "total_simulation_hours": 72,+ "started_at": "2025-12-01T10:00:00"+ }+}+```++---++### 停止模拟++**POST** `/api/simulation/stop`++停止正在运行的模拟。++**请求(JSON):**+```json+{+ "simulation_id": "sim_xxxx" // 必填+}+```++**响应示例:**+```json+{+ "success": true,+ "data": {+ "simulation_id": "sim_xxxx",+ "runner_status": "stopped",+ "completed_at": "2025-12-01T12:00:00",+ "twitter_actions_count": 500,+ "reddit_actions_count": 650+ }+}+```++---++## 实时状态监控接口++### 获取运行状态(基础)++**GET** `/api/simulation/{simulation_id}/run-status`++获取模拟运行的实时状态,用于前端轮询。++**响应示例:**+```json+{+ "success": true,+ "data": {+ "simulation_id": "sim_xxxx",+ "runner_status": "running",+ "current_round": 25,+ "total_rounds": 144,+ "progress_percent": 17.4,+ "simulated_hours": 12,+ "total_simulation_hours": 72,+ "twitter_running": true,+ "reddit_running": true,+ "twitter_actions_count": 150,+ "reddit_actions_count": 200,+ "total_actions_count": 350,+ "started_at": "2025-12-01T10:00:00",+ "updated_at": "2025-12-01T10:30:00"+ }+}+```++**运行状态值(runner_status):**+- `idle` - 未运行+- `starting` - 启动中+- `running` - 运行中+- `paused` - 已暂停+- `stopping` - 停止中+- `stopped` - 已停止+- `completed` - 已完成+- `failed` - 失败++---++### 获取运行状态(详细,含最近动作)++**GET** `/api/simulation/{simulation_id}/run-status/detail`++获取详细运行状态,包含最近的Agent动作列表,**用于前端实时展示动态**。++**响应示例:**+```json+{+ "success": true,+ "data": {+ "simulation_id": "sim_xxxx",+ "runner_status": "running",+ "current_round": 25,+ "progress_percent": 17.4,+ "recent_actions": [+ {+ "round_num": 25,+ "timestamp": "2025-12-01T10:30:00",+ "platform": "twitter",+ "agent_id": 3,+ "agent_name": "Entity Name",+ "action_type": "CREATE_POST",+ "action_args": {"content": "Post content..."},+ "result": null,+ "success": true+ },+ {+ "round_num": 25,+ "timestamp": "2025-12-01T10:29:55",+ "platform": "reddit",+ "agent_id": 7,+ "agent_name": "Another Entity",+ "action_type": "LIKE_POST",+ "action_args": {"post_id": 5},+ "success": true+ }+ ]+ }+}+```++---++### 获取动作历史++**GET** `/api/simulation/{simulation_id}/actions`++获取完整的Agent动作历史记录。++**Query参数:**++| 参数 | 类型 | 说明 |+|------|------|------|+| `limit` | int | 返回数量(默认100) |+| `offset` | int | 偏移量(默认0) |+| `platform` | string | 过滤平台(twitter/reddit) |+| `agent_id` | int | 过滤Agent ID |+| `round_num` | int | 过滤轮次 |++---++### 获取时间线++**GET** `/api/simulation/{simulation_id}/timeline`++获取按轮次汇总的时间线,用于前端展示进度条和时间线视图。++**Query参数:**++| 参数 | 类型 | 说明 |+|------|------|------|+| `start_round` | int | 起始轮次(默认0) |+| `end_round` | int | 结束轮次(默认全部) |++**响应示例:**+```json+{+ "success": true,+ "data": {+ "rounds_count": 25,+ "timeline": [+ {+ "round_num": 1,+ "twitter_actions": 10,+ "reddit_actions": 15,+ "total_actions": 25,+ "active_agents_count": 8,+ "active_agents": [0, 1, 3, 5, 7, 10, 12, 15],+ "action_types": {"CREATE_POST": 5, "LIKE_POST": 10, "LLM_ACTION": 10},+ "first_action_time": "2025-12-01T10:00:00",+ "last_action_time": "2025-12-01T10:05:00"+ }+ ]+ }+}+```++---++### 获取Agent统计++**GET** `/api/simulation/{simulation_id}/agent-stats`++获取每个Agent的活跃度统计,用于展示排行榜。++**响应示例:**+```json+{+ "success": true,+ "data": {+ "agents_count": 45,+ "stats": [+ {+ "agent_id": 3,+ "agent_name": "Active Agent",+ "total_actions": 50,+ "twitter_actions": 30,+ "reddit_actions": 20,+ "action_types": {"CREATE_POST": 10, "LIKE_POST": 25, "REPOST": 15},+ "first_action_time": "2025-12-01T10:00:00",+ "last_action_time": "2025-12-01T12:30:00"+ }+ ]+ }+}+```++---++## 数据库查询接口++### 获取帖子++**GET** `/api/simulation/{simulation_id}/posts`++从模拟数据库获取帖子列表。++**Query参数:**++| 参数 | 类型 | 说明 |+|------|------|------|+| `platform` | string | 平台类型(twitter/reddit,默认reddit) |+| `limit` | int | 返回数量(默认50) |+| `offset` | int | 偏移量 |++---++### 获取评论++**GET** `/api/simulation/{simulation_id}/comments`++从Reddit模拟数据库获取评论列表。++**Query参数:**++| 参数 | 类型 | 说明 |+|------|------|------|+| `post_id` | string | 过滤帖子ID(可选) |+| `limit` | int | 返回数量(默认50) |+| `offset` | int | 偏移量 |++---++# 服务层实现细节++## 1. ZepEntityReader(Zep实体读取服务)++**文件:** `app/services/zep_entity_reader.py`++### 核心功能++| 方法 | 说明 |+|------|------|+| `get_all_nodes(graph_id)` | 获取图谱所有节点 |+| `get_all_edges(graph_id)` | 获取图谱所有边 |+| `filter_defined_entities(graph_id, ...)` | 筛选符合条件的实体 |+| `get_entity_with_context(graph_id, uuid)` | 获取实体完整上下文 |+| `get_entities_by_type(graph_id, type)` | 按类型获取实体 |++### 数据结构++```python+@dataclass+class EntityNode:+ uuid: str # 节点UUID+ name: str # 实体名称+ labels: List[str] # 标签列表 ["Entity", "Student"]+ summary: str # 实体摘要+ attributes: Dict[str, Any] # 属性字典+ related_edges: List[Dict] # 相关边信息+ related_nodes: List[Dict] # 关联节点信息++ def get_entity_type(self) -> Optional[str]:+ """获取实体类型(排除默认Entity标签)"""++@dataclass+class FilteredEntities:+ entities: List[EntityNode] # 实体列表+ entity_types: Set[str] # 发现的实体类型+ total_count: int # 总节点数+ filtered_count: int # 过滤后数量+```++### 过滤逻辑示例++```python+# Zep返回的节点Labels示例:+# 符合预定义类型: ["Entity", "Student"]+# 不符合预定义类型: ["Entity"]++for node in all_nodes:+ labels = node.get("labels", [])+ custom_labels = [l for l in labels if l not in ["Entity", "Node"]]++ if not custom_labels:+ # 只有默认标签,跳过+ continue++ # 保留符合条件的实体+ entity_type = custom_labels[0]+ filtered_entities.append(node)+```++---++## 2. OasisProfileGenerator(Agent Profile生成器)++**文件:** `app/services/oasis_profile_generator.py`++### 核心功能++| 方法 | 说明 |+|------|------|+| `generate_profile_from_entity(entity, user_id)` | 从实体生成单个Profile |+| `generate_profiles_from_entities(entities)` | 批量生成Profile |+| `save_profiles_to_json(profiles, path, platform)` | 保存到JSON文件 |++### Profile数据结构++```python+@dataclass+class OasisAgentProfile:+ # 基础字段+ user_id: int # 用户ID+ user_name: str # 用户名+ name: str # 显示名称+ bio: str # 简介(max 150字符)+ persona: str # 详细人设描述++ # Reddit字段+ karma: int = 1000++ # Twitter字段+ friend_count: int = 100+ follower_count: int = 150+ statuses_count: int = 500++ # 人设详情+ age: Optional[int] = None+ gender: Optional[str] = None+ mbti: Optional[str] = None # INTJ, ENFP等+ country: Optional[str] = None+ profession: Optional[str] = None+ interested_topics: List[str] = []++ # 来源信息+ source_entity_uuid: Optional[str] = None+ source_entity_type: Optional[str] = None+```++### Profile生成策略++**1. LLM生成(默认)**++使用LLM根据实体信息生成详细人设:++```python+prompt = f"""+Entity: {entity_name} ({entity_type})+Summary: {entity_summary}+Context: {related_edges_and_nodes}++Generate a social media user profile with:+- bio (max 150 chars)+- persona (detailed description)+- age, gender, mbti, country+- profession, interested_topics+"""+```++**2. 规则生成(Fallback)**++根据实体类型使用预定义模板:++| 实体类型 | 生成策略 |+|----------|----------|+| Student/Alumni | 年龄18-30,学生身份,关注教育话题 |+| PublicFigure/Expert | 年龄35-60,专业人士,政治经济话题 |+| MediaOutlet | 媒体官方账号,新闻时事话题 |+| University/GovernmentAgency | 机构官方账号,政策公告话题 |++---++## 3. SimulationConfigGenerator(模拟配置智能生成器)++**文件:** `app/services/simulation_config_generator.py`++### 核心功能++使用LLM分析模拟需求、文档内容、图谱实体信息,自动生成最佳的模拟参数配置。++| 方法 | 说明 |+|------|------|+| `generate_config(...)` | 智能生成完整模拟配置 |+| `_build_context(...)` | 构建LLM上下文(最大5万字) |+| `_generate_config_with_llm(...)` | 调用LLM生成配置 |+| `_generate_default_config(...)` | 默认配置(LLM失败时) |++### LLM智能生成的配置内容++**1. TimeSimulationConfig(时间配置)**+```python+@dataclass+class TimeSimulationConfig:+ total_simulation_hours: int = 72 # 模拟总时长(小时)+ minutes_per_round: int = 30 # 每轮代表的时间(分钟)+ agents_per_hour_min: int = 5 # 每小时激活Agent数量(最小)+ agents_per_hour_max: int = 20 # 每小时激活Agent数量(最大)+ peak_hours: List[int] # 高峰时段 [9,10,11,14,15,20,21,22]+ off_peak_hours: List[int] # 低谷时段 [0,1,2,3,4,5]+ peak_activity_multiplier: float = 1.5 # 高峰活跃度乘数+ off_peak_activity_multiplier: float = 0.3 # 低谷活跃度乘数+```++**2. AgentActivityConfig(每个Agent的活动配置)**+```python+@dataclass+class AgentActivityConfig:+ agent_id: int+ entity_uuid: str+ entity_name: str+ entity_type: str++ activity_level: float = 0.5 # 整体活跃度 (0.0-1.0)+ posts_per_hour: float = 1.0 # 每小时发帖频率+ comments_per_hour: float = 2.0 # 每小时评论频率+ active_hours: List[int] # 活跃时间段 (0-23)+ response_delay_min: int = 5 # 响应延迟最小值(分钟)+ response_delay_max: int = 60 # 响应延迟最大值(分钟)+ sentiment_bias: float = 0.0 # 情感倾向 (-1到1)+ stance: str = "neutral" # 立场 (supportive/opposing/neutral/observer)+ influence_weight: float = 1.0 # 影响力权重+```++**3. 不同实体类型的默认参数差异**++| 实体类型 | 活跃度 | 发帖频率 | 响应延迟 | 影响力 |+|----------|--------|----------|----------|--------|+| University/GovernmentAgency | 0.2 | 0.1/小时 | 60-240分钟 | 3.0 |+| MediaOutlet | 0.6 | 1.0/小时 | 5-30分钟 | 2.5 |+| PublicFigure/Expert | 0.5 | 0.3/小时 | 10-60分钟 | 2.0 |+| Student/Person | 0.7 | 0.5/小时 | 1-20分钟 | 1.0 |++---++## 4. SimulationManager(模拟管理器)++**文件:** `app/services/simulation_manager.py`++### 核心功能++| 方法 | 说明 |+|------|------|+| `create_simulation(project_id, graph_id, ...)` | 创建模拟 |+| `prepare_simulation(simulation_id, ...)` | 准备模拟环境(调用配置生成器) |+| `get_simulation(simulation_id)` | 获取模拟状态 |+| `get_profiles(simulation_id, platform)` | 获取Profile |+| `get_simulation_config(simulation_id)` | 获取模拟配置 |+| `get_run_instructions(simulation_id)` | 获取运行说明 |++### 模拟状态流转++```+created → preparing → ready → running → completed+ ↓ ↓+ failed paused+```++### 生成的文件结构++```+uploads/simulations/sim_xxxx/+├── state.json # 模拟状态+├── simulation_config.json # LLM生成的模拟配置(核心文件)+├── reddit_profiles.json # Reddit Agent Profile(JSON格式)+├── twitter_profiles.csv # Twitter Agent Profile(CSV格式)+├── run_reddit_simulation.py # 预设Reddit模拟脚本+├── run_twitter_simulation.py # 预设Twitter模拟脚本+├── run_parallel_simulation.py # 预设双平台并行脚本+├── reddit_simulation.db # Reddit数据库(运行后生成)+└── twitter_simulation.db # Twitter数据库(运行后生成)+```++**重要:OASIS平台的Profile格式要求不同:**+- **Twitter**: 使用CSV格式,字段:`user_id,user_name,name,bio,friend_count,follower_count,statuses_count,created_at`+- **Reddit**: 使用JSON格式,支持详细人设字段:`realname,username,bio,persona,age,gender,mbti,country,profession,interested_topics`++### 配置文件示例 (simulation_config.json)++```json+{+ "simulation_id": "sim_abc123",+ "project_id": "proj_xxx",+ "graph_id": "mirofish_xxx",+ "simulation_requirement": "分析武汉大学图书馆事件舆论传播",++ "time_config": {+ "total_simulation_hours": 72,+ "minutes_per_round": 30,+ "agents_per_hour_min": 5,+ "agents_per_hour_max": 15,+ "peak_hours": [9, 10, 11, 14, 15, 20, 21, 22],+ "off_peak_hours": [0, 1, 2, 3, 4, 5],+ "peak_activity_multiplier": 1.5,+ "off_peak_activity_multiplier": 0.3+ },++ "agent_configs": [+ {+ "agent_id": 0,+ "entity_name": "武汉大学",+ "entity_type": "University",+ "activity_level": 0.15,+ "posts_per_hour": 0.08,+ "comments_per_hour": 0.02,+ "active_hours": [9, 10, 11, 14, 15, 16, 17],+ "response_delay_min": 120,+ "response_delay_max": 360,+ "sentiment_bias": 0.1,+ "stance": "neutral",+ "influence_weight": 4.0+ },+ {+ "agent_id": 1,+ "entity_name": "杨景媛",+ "entity_type": "Student",+ "activity_level": 0.8,+ "posts_per_hour": 0.5,+ "comments_per_hour": 2.0,+ "active_hours": [7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],+ "response_delay_min": 1,+ "response_delay_max": 15,+ "sentiment_bias": -0.3,+ "stance": "opposing",+ "influence_weight": 1.5+ }+ ],++ "event_config": {+ "initial_posts": [+ {+ "poster_agent_id": 1,+ "content": "今天在图书馆发生的事情让我非常失望..."+ }+ ],+ "hot_topics": ["图书馆事件", "学生权益", "校方回应"],+ "narrative_direction": "事件发酵后各方反应的模拟"+ },++ "generation_reasoning": "根据武汉大学图书馆事件的特点:1)涉及学生与校方的冲突,设置学生高活跃度、校方低频但高影响力;2)事件性质属于短期热点,设置72小时模拟时长;3)主要当事人杨景媛设置为高活跃度且持opposing立场..."+}++---++## 5. 预设模拟脚本++**目录:** `backend/scripts/`++脚本是**预设的**,不是动态生成。每次准备模拟时,脚本会被复制到模拟目录。++### 脚本说明++| 脚本 | 说明 |+|------|------|+| `run_twitter_simulation.py` | Twitter单平台模拟 |+| `run_reddit_simulation.py` | Reddit单平台模拟 |+| `run_parallel_simulation.py` | 双平台并行模拟(推荐) |++### 脚本工作原理++```python+# 脚本读取配置文件,自动设置所有参数+class TwitterSimulationRunner:+ def __init__(self, config_path: str):+ self.config = self._load_config() # 读取simulation_config.json++ def _get_active_agents_for_round(self, env, current_hour, round_num):+ """根据时间和配置决定本轮激活哪些Agent"""+ time_config = self.config.get("time_config", {})+ agent_configs = self.config.get("agent_configs", [])++ # 1. 检查是否高峰/低谷时段,调整激活数量+ # 2. 遍历每个Agent配置,检查是否在活跃时间+ # 3. 根据activity_level计算激活概率+ # 4. 返回本轮应激活的Agent列表+ ...++ async def run(self):+ # 1. 创建LLM模型+ # 2. 加载Agent图+ # 3. 执行初始事件(从event_config读取)+ # 4. 主循环:根据配置激活不同Agent+ ...+```++### 使用方式++```bash+# 进入模拟目录+cd backend/uploads/simulations/sim_xxxx/++# 运行模拟+python run_parallel_simulation.py --config simulation_config.json++# 其他选项+python run_parallel_simulation.py --config simulation_config.json --twitter-only+python run_parallel_simulation.py --config simulation_config.json --reddit-only+```++---++## 6. Profile文件格式说明++**OASIS对两个平台的Profile格式有不同要求:**++### Twitter Profile (CSV格式)++```csv+user_id,user_name,name,bio,friend_count,follower_count,statuses_count,created_at+0,user0,User Zero,I am user zero with interests in technology.,100,150,500,2023-01-01+1,user1,User One,Tech enthusiast and coffee lover.,200,250,1000,2023-01-02+```++| 字段 | 类型 | 说明 |+|------|------|------|+| `user_id` | int | 用户ID |+| `user_name` | string | 用户名 |+| `name` | string | 显示名称 |+| `bio` | string | 简介 |+| `friend_count` | int | 关注数 |+| `follower_count` | int | 粉丝数 |+| `statuses_count` | int | 发帖数 |+| `created_at` | string | 创建日期 |++### Reddit Profile (JSON详细格式)++```json+[+ {+ "realname": "Test User",+ "username": "test_user_123",+ "bio": "A test user for validation",+ "persona": "Test User is an enthusiastic participant in social discussions.",+ "age": 25,+ "gender": "male",+ "mbti": "INTJ",+ "country": "China",+ "profession": "Student",+ "interested_topics": ["Technology", "Education"]+ }+]+```++| 字段 | 类型 | 必填 | 说明 |+|------|------|------|------|+| `realname` | string | 是 | 真实姓名 |+| `username` | string | 是 | 用户名 |+| `bio` | string | 是 | 简介(最大150字符) |+| `persona` | string | 是 | 详细人设描述 |+| `age` | int | 否 | 年龄 |+| `gender` | string | 否 | 性别 |+| `mbti` | string | 否 | MBTI人格类型 |+| `country` | string | 否 | 国家 |+| `profession` | string | 否 | 职业 |+| `interested_topics` | array | 否 | 感兴趣话题列表 |++---++## 7. OASIS平台动作类型++### Twitter可用动作++| 动作 | 说明 |+|------|------|+| `CREATE_POST` | 发布推文 |+| `LIKE_POST` | 点赞推文 |+| `REPOST` | 转发推文 |+| `FOLLOW` | 关注用户 |+| `QUOTE_POST` | 引用转发 |+| `DO_NOTHING` | 不执行动作 |++### Reddit可用动作++| 动作 | 说明 |+|------|------|+| `CREATE_POST` | 发布帖子 |+| `CREATE_COMMENT` | 发表评论 |+| `LIKE_POST` | 点赞帖子 |+| `DISLIKE_POST` | 踩帖子 |+| `LIKE_COMMENT` | 点赞评论 |+| `DISLIKE_COMMENT` | 踩评论 |+| `SEARCH_POSTS` | 搜索帖子 |+| `SEARCH_USER` | 搜索用户 |+| `TREND` | 查看热门 |+| `REFRESH` | 刷新推荐 |+| `FOLLOW` | 关注用户 |+| `MUTE` | 屏蔽用户 |+| `DO_NOTHING` | 不执行动作 |++---++# 实体设计原则本系统专为社会舆论模拟设计,实体必须是:-**✅ 可以是:**+**可以是:**- 具体的个人(有名有姓)- 注册的公司、组织、机构- 媒体机构- 政府部门+- 高校、NGO等-**❌ 不可以是:**+**不可以是:**- 抽象概念(如"技术"、"创新")- 情绪、观点、趋势- 泛指的群体(如"用户"、"消费者")@@ -230,10 +1465,127 @@ python run.py----## 项目状态流转+# 项目状态流转```created → ontology_generated → graph_building → graph_completed↓failed```++---++# 运行模拟++准备完成后,进入模拟数据目录运行预设脚本:++```bash+# 激活conda环境+conda activate MiroFish++# 进入模拟目录+cd backend/uploads/simulations/sim_xxxx/++# 运行单平台模拟+python run_reddit_simulation.py --config simulation_config.json+# 或+python run_twitter_simulation.py --config simulation_config.json++# 运行双平台并行模拟(推荐)+python run_parallel_simulation.py --config simulation_config.json+```++### 脚本参数++| 参数 | 说明 |+|------|------|+| `--config` | 配置文件路径(必填) |+| `--twitter-only` | 只运行Twitter模拟(仅parallel脚本) |+| `--reddit-only` | 只运行Reddit模拟(仅parallel脚本) |++### 输出文件++模拟运行后会生成:+- `twitter_simulation.db` - Twitter模拟数据库+- `reddit_simulation.db` - Reddit模拟数据库++可使用SQLite工具查看模拟结果(帖子、评论、点赞等)++---++# API调用重试机制++**文件:** `app/utils/retry.py`++为LLM等外部API调用提供自动重试功能,提高系统稳定性。++## 重试策略++- **最大重试次数**:3次+- **退避策略**:指数退避(1s → 2s → 4s)+- **最大延迟**:30秒+- **随机抖动**:避免请求堆积++## 使用方式++**装饰器方式:**+```python+from app.utils.retry import retry_with_backoff++@retry_with_backoff(max_retries=3)+def call_llm_api():+ return client.chat.completions.create(...)+```++**客户端方式:**+```python+from app.utils.retry import RetryableAPIClient++retry_client = RetryableAPIClient(max_retries=3)+result = retry_client.call_with_retry(some_function, arg1, arg2)+```++**批量处理(单项失败不影响其他):**+```python+results, failures = retry_client.call_batch_with_retry(+ items=entities,+ process_func=generate_profile,+ continue_on_failure=True+)+```++## 已应用重试机制的模块++| 模块 | 说明 |+|------|------|+| `OasisProfileGenerator` | LLM生成Agent人设 |+| `SimulationConfigGenerator` | LLM生成模拟配置 |++---++# 依赖说明++```+# Flask框架+flask>=3.0.0+flask-cors>=4.0.0++# Zep Cloud SDK+zep-cloud>=2.0.0++# OpenAI SDK(LLM调用)+openai>=1.0.0++# PDF处理+PyMuPDF>=1.24.0++# 环境变量+python-dotenv>=1.0.0++# 数据验证+pydantic>=2.0.0++# OASIS社交媒体模拟+oasis-ai>=0.1.0+camel-ai>=0.2.0+```diff --git a/backend/app/__init__.py b/backend/app/__init__.pyindex 7ad7c697..b11dc70c 100644--- a/backend/app/__init__.py+++ b/backend/app/__init__.py@@ -46,8 +46,9 @@ def create_app(config_class=Config):return response# 注册蓝图- from .api import graph_bp+ from .api import graph_bp, simulation_bpapp.register_blueprint(graph_bp, url_prefix='/api/graph')+ app.register_blueprint(simulation_bp, url_prefix='/api/simulation')# 健康检查@app.route('/health')diff --git a/backend/app/api/__init__.py b/backend/app/api/__init__.pyindex 9723f92a..ad7a7220 100644--- a/backend/app/api/__init__.py+++ b/backend/app/api/__init__.py@@ -5,6 +5,8 @@ API路由模块from flask import Blueprintgraph_bp = Blueprint('graph', __name__)+simulation_bp = Blueprint('simulation', __name__)from . import graph # noqa: E402, F401+from . import simulation # noqa: E402, F401diff --git a/backend/app/api/simulation.py b/backend/app/api/simulation.pynew file mode 100644index 00000000..6d8651b2--- /dev/null+++ b/backend/app/api/simulation.py@@ -0,0 +1,1330 @@+"""+模拟相关API路由+Step2: Zep实体读取与过滤、OASIS模拟准备与运行(全程自动化)+"""++import os+import traceback+from flask import request, jsonify, send_file++from . import simulation_bp+from ..config import Config+from ..services.zep_entity_reader import ZepEntityReader+from ..services.oasis_profile_generator import OasisProfileGenerator+from ..services.simulation_manager import SimulationManager, SimulationStatus+from ..services.simulation_runner import SimulationRunner, RunnerStatus+from ..utils.logger import get_logger+from ..models.project import ProjectManager++logger = get_logger('mirofish.api.simulation')+++# ============== 实体读取接口 ==============++@simulation_bp.route('/entities/<graph_id>', methods=['GET'])+def get_graph_entities(graph_id: str):+ """+ 获取图谱中的所有实体(已过滤)++ 只返回符合预定义实体类型的节点(Labels不只是Entity的节点)++ Query参数:+ entity_types: 逗号分隔的实体类型列表(可选,用于进一步过滤)+ enrich: 是否获取相关边信息(默认true)+ """+ try:+ if not Config.ZEP_API_KEY:+ return jsonify({+ "success": False,+ "error": "ZEP_API_KEY未配置"+ }), 500++ entity_types_str = request.args.get('entity_types', '')+ entity_types = [t.strip() for t in entity_types_str.split(',') if t.strip()] if entity_types_str else None+ enrich = request.args.get('enrich', 'true').lower() == 'true'++ logger.info(f"获取图谱实体: graph_id={graph_id}, entity_types={entity_types}, enrich={enrich}")++ reader = ZepEntityReader()+ result = reader.filter_defined_entities(+ graph_id=graph_id,+ defined_entity_types=entity_types,+ enrich_with_edges=enrich+ )++ 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+++@simulation_bp.route('/entities/<graph_id>/<entity_uuid>', methods=['GET'])+def get_entity_detail(graph_id: str, entity_uuid: str):+ """获取单个实体的详细信息"""+ try:+ if not Config.ZEP_API_KEY:+ return jsonify({+ "success": False,+ "error": "ZEP_API_KEY未配置"+ }), 500++ reader = ZepEntityReader()+ entity = reader.get_entity_with_context(graph_id, entity_uuid)++ if not entity:+ return jsonify({+ "success": False,+ "error": f"实体不存在: {entity_uuid}"+ }), 404++ return jsonify({+ "success": True,+ "data": entity.to_dict()+ })++ except Exception as e:+ logger.error(f"获取实体详情失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@simulation_bp.route('/entities/<graph_id>/by-type/<entity_type>', methods=['GET'])+def get_entities_by_type(graph_id: str, entity_type: str):+ """获取指定类型的所有实体"""+ try:+ if not Config.ZEP_API_KEY:+ return jsonify({+ "success": False,+ "error": "ZEP_API_KEY未配置"+ }), 500++ enrich = request.args.get('enrich', 'true').lower() == 'true'++ reader = ZepEntityReader()+ entities = reader.get_entities_by_type(+ graph_id=graph_id,+ entity_type=entity_type,+ enrich_with_edges=enrich+ )++ return jsonify({+ "success": True,+ "data": {+ "entity_type": entity_type,+ "count": len(entities),+ "entities": [e.to_dict() for e in entities]+ }+ })++ except Exception as e:+ logger.error(f"获取实体失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++# ============== 模拟管理接口 ==============++@simulation_bp.route('/create', methods=['POST'])+def create_simulation():+ """+ 创建新的模拟++ 注意:max_rounds等参数由LLM智能生成,无需手动设置++ 请求(JSON):+ {+ "project_id": "proj_xxxx", // 必填+ "graph_id": "mirofish_xxxx", // 可选,如不提供则从project获取+ "enable_twitter": true, // 可选,默认true+ "enable_reddit": true // 可选,默认true+ }++ 返回:+ {+ "success": true,+ "data": {+ "simulation_id": "sim_xxxx",+ "project_id": "proj_xxxx",+ "graph_id": "mirofish_xxxx",+ "status": "created",+ "enable_twitter": true,+ "enable_reddit": true,+ "created_at": "2025-12-01T10:00:00"+ }+ }+ """+ try:+ data = request.get_json() or {}++ project_id = data.get('project_id')+ if not project_id:+ return jsonify({+ "success": False,+ "error": "请提供 project_id"+ }), 400++ project = ProjectManager.get_project(project_id)+ if not project:+ return jsonify({+ "success": False,+ "error": f"项目不存在: {project_id}"+ }), 404++ graph_id = data.get('graph_id') or project.graph_id+ if not graph_id:+ return jsonify({+ "success": False,+ "error": "项目尚未构建图谱,请先调用 /api/graph/build"+ }), 400++ manager = SimulationManager()+ state = manager.create_simulation(+ project_id=project_id,+ graph_id=graph_id,+ enable_twitter=data.get('enable_twitter', True),+ enable_reddit=data.get('enable_reddit', True),+ )++ return jsonify({+ "success": True,+ "data": state.to_dict()+ })++ except Exception as e:+ logger.error(f"创建模拟失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@simulation_bp.route('/prepare', methods=['POST'])+def prepare_simulation():+ """+ 准备模拟环境(异步任务,LLM智能生成所有参数)++ 这是一个耗时操作,接口会立即返回task_id,+ 使用 GET /api/simulation/prepare/status 查询进度++ 步骤:+ 1. 从Zep图谱读取并过滤实体+ 2. 为每个实体生成OASIS Agent Profile(带重试机制)+ 3. LLM智能生成模拟配置(带重试机制)+ 4. 保存配置文件和预设脚本++ 请求(JSON):+ {+ "simulation_id": "sim_xxxx", // 必填,模拟ID+ "entity_types": ["Student", "PublicFigure"], // 可选,指定实体类型+ "use_llm_for_profiles": true // 可选,是否用LLM生成人设+ }++ 返回:+ {+ "success": true,+ "data": {+ "simulation_id": "sim_xxxx",+ "task_id": "task_xxxx",+ "status": "preparing",+ "message": "准备任务已启动"+ }+ }+ """+ import threading+ from ..models.task import TaskManager, TaskStatus++ try:+ data = request.get_json() or {}++ simulation_id = data.get('simulation_id')+ if not simulation_id:+ return jsonify({+ "success": False,+ "error": "请提供 simulation_id"+ }), 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++ # 获取模拟需求+ simulation_requirement = project.simulation_requirement or ""+ if not simulation_requirement:+ return jsonify({+ "success": False,+ "error": "项目缺少模拟需求描述 (simulation_requirement)"+ }), 400++ # 获取文档文本+ document_text = ProjectManager.get_extracted_text(state.project_id) or ""++ entity_types_list = data.get('entity_types')+ use_llm_for_profiles = data.get('use_llm_for_profiles', True)++ # 创建异步任务+ task_manager = TaskManager()+ task_id = task_manager.create_task(+ task_type="simulation_prepare",+ metadata={+ "simulation_id": simulation_id,+ "project_id": state.project_id+ }+ )++ # 更新模拟状态+ state.status = SimulationStatus.PREPARING+ manager._save_simulation_state(state)++ # 定义后台任务+ def run_prepare():+ try:+ task_manager.update_task(+ task_id,+ status=TaskStatus.PROCESSING,+ progress=0,+ message="开始准备模拟环境..."+ )++ # 准备模拟(带进度回调)+ # 存储阶段进度详情+ stage_details = {}++ def progress_callback(stage, progress, message, **kwargs):+ # 计算总进度+ stage_weights = {+ "reading": (0, 20), # 0-20%+ "generating_profiles": (20, 70), # 20-70%+ "generating_config": (70, 90), # 70-90%+ "copying_scripts": (90, 100) # 90-100%+ }++ start, end = stage_weights.get(stage, (0, 100))+ current_progress = int(start + (end - start) * progress / 100)++ # 构建详细进度信息+ stage_names = {+ "reading": "读取图谱实体",+ "generating_profiles": "生成Agent人设",+ "generating_config": "生成模拟配置",+ "copying_scripts": "准备模拟脚本"+ }++ stage_index = list(stage_weights.keys()).index(stage) + 1 if stage in stage_weights else 1+ total_stages = len(stage_weights)++ # 更新阶段详情+ stage_details[stage] = {+ "stage_name": stage_names.get(stage, stage),+ "stage_progress": progress,+ "current": kwargs.get("current", 0),+ "total": kwargs.get("total", 0),+ "item_name": kwargs.get("item_name", "")+ }++ # 构建详细进度信息+ detail = stage_details[stage]+ progress_detail_data = {+ "current_stage": stage,+ "current_stage_name": stage_names.get(stage, stage),+ "stage_index": stage_index,+ "total_stages": total_stages,+ "stage_progress": progress,+ "current_item": detail["current"],+ "total_items": detail["total"],+ "item_description": message+ }++ # 构建简洁消息+ if detail["total"] > 0:+ detailed_message = (+ f"[{stage_index}/{total_stages}] {stage_names.get(stage, stage)}: "+ f"{detail['current']}/{detail['total']} - {message}"+ )+ else:+ detailed_message = f"[{stage_index}/{total_stages}] {stage_names.get(stage, stage)}: {message}"++ task_manager.update_task(+ task_id,+ progress=current_progress,+ message=detailed_message,+ progress_detail=progress_detail_data+ )++ result_state = manager.prepare_simulation(+ simulation_id=simulation_id,+ simulation_requirement=simulation_requirement,+ document_text=document_text,+ defined_entity_types=entity_types_list,+ use_llm_for_profiles=use_llm_for_profiles,+ progress_callback=progress_callback+ )++ # 任务完成+ task_manager.complete_task(+ task_id,+ result=result_state.to_simple_dict()+ )++ except Exception as e:+ logger.error(f"准备模拟失败: {str(e)}")+ task_manager.fail_task(task_id, str(e))++ # 更新模拟状态为失败+ state = manager.get_simulation(simulation_id)+ if state:+ state.status = SimulationStatus.FAILED+ state.error = str(e)+ manager._save_simulation_state(state)++ # 启动后台线程+ thread = threading.Thread(target=run_prepare, daemon=True)+ thread.start()++ return jsonify({+ "success": True,+ "data": {+ "simulation_id": simulation_id,+ "task_id": task_id,+ "status": "preparing",+ "message": "准备任务已启动,请通过 /api/simulation/prepare/status 查询进度"+ }+ })++ except ValueError as e:+ return jsonify({+ "success": False,+ "error": str(e)+ }), 404++ except Exception as e:+ logger.error(f"启动准备任务失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@simulation_bp.route('/prepare/status', methods=['POST'])+def get_prepare_status():+ """+ 查询准备任务进度++ 请求(JSON):+ {+ "task_id": "task_xxxx" // 必填,prepare返回的task_id+ }++ 返回:+ {+ "success": true,+ "data": {+ "task_id": "task_xxxx",+ "status": "processing", // pending/processing/completed/failed+ "progress": 45, // 0-100 总进度+ "message": "[2/4] 生成Agent人设: 35/93 - 生成 教授张三 的人设...",+ "progress_detail": { // 详细进度信息+ "current_stage": "generating_profiles",+ "current_stage_name": "生成Agent人设",+ "stage_index": 2, // 当前阶段序号+ "total_stages": 4, // 总阶段数+ "stage_progress": 38, // 阶段内进度 0-100+ "current_item": 35, // 当前处理项目序号+ "total_items": 93, // 当前阶段总项目数+ "item_description": "生成 教授张三 的人设..."+ },+ "result": null, // 完成后返回结果+ "error": null // 失败时返回错误信息+ }+ }+ """+ from ..models.task import TaskManager++ try:+ data = request.get_json() or {}++ task_id = data.get('task_id')+ if not task_id:+ return jsonify({+ "success": False,+ "error": "请提供 task_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+++@simulation_bp.route('/<simulation_id>', methods=['GET'])+def get_simulation(simulation_id: str):+ """获取模拟状态"""+ try:+ manager = SimulationManager()+ state = manager.get_simulation(simulation_id)++ if not state:+ return jsonify({+ "success": False,+ "error": f"模拟不存在: {simulation_id}"+ }), 404++ result = state.to_dict()++ # 如果模拟已准备好,附加运行说明+ if state.status == SimulationStatus.READY:+ result["run_instructions"] = manager.get_run_instructions(simulation_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()+ }), 500+++@simulation_bp.route('/list', methods=['GET'])+def list_simulations():+ """+ 列出所有模拟++ Query参数:+ project_id: 按项目ID过滤(可选)+ """+ try:+ project_id = request.args.get('project_id')++ manager = SimulationManager()+ simulations = manager.list_simulations(project_id=project_id)++ return jsonify({+ "success": True,+ "data": [s.to_dict() for s in simulations],+ "count": len(simulations)+ })++ except Exception as e:+ logger.error(f"列出模拟失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@simulation_bp.route('/<simulation_id>/profiles', methods=['GET'])+def get_simulation_profiles(simulation_id: str):+ """+ 获取模拟的Agent Profile++ Query参数:+ platform: 平台类型(reddit/twitter,默认reddit)+ """+ try:+ platform = request.args.get('platform', 'reddit')++ manager = SimulationManager()+ profiles = manager.get_profiles(simulation_id, platform=platform)++ return jsonify({+ "success": True,+ "data": {+ "platform": platform,+ "count": len(profiles),+ "profiles": profiles+ }+ })++ except ValueError as e:+ return jsonify({+ "success": False,+ "error": str(e)+ }), 404++ except Exception as e:+ logger.error(f"获取Profile失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@simulation_bp.route('/<simulation_id>/config', methods=['GET'])+def get_simulation_config(simulation_id: str):+ """+ 获取模拟配置(LLM智能生成的完整配置)++ 返回包含:+ - time_config: 时间配置(模拟时长、轮次、高峰/低谷时段)+ - agent_configs: 每个Agent的活动配置(活跃度、发言频率、立场等)+ - event_config: 事件配置(初始帖子、热点话题)+ - platform_configs: 平台配置+ - generation_reasoning: LLM的配置推理说明+ """+ try:+ manager = SimulationManager()+ config = manager.get_simulation_config(simulation_id)++ if not config:+ return jsonify({+ "success": False,+ "error": f"模拟配置不存在,请先调用 /prepare 接口"+ }), 404++ return jsonify({+ "success": True,+ "data": config+ })++ except Exception as e:+ logger.error(f"获取配置失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@simulation_bp.route('/<simulation_id>/config/download', methods=['GET'])+def download_simulation_config(simulation_id: str):+ """下载模拟配置文件"""+ try:+ manager = SimulationManager()+ sim_dir = manager._get_simulation_dir(simulation_id)+ config_path = os.path.join(sim_dir, "simulation_config.json")++ if not os.path.exists(config_path):+ return jsonify({+ "success": False,+ "error": "配置文件不存在,请先调用 /prepare 接口"+ }), 404++ return send_file(+ config_path,+ as_attachment=True,+ download_name="simulation_config.json"+ )++ except Exception as e:+ logger.error(f"下载配置失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@simulation_bp.route('/<simulation_id>/script/<script_name>/download', methods=['GET'])+def download_simulation_script(simulation_id: str, script_name: str):+ """+ 下载模拟脚本文件++ script_name可选值:+ - run_twitter_simulation.py+ - run_reddit_simulation.py+ - run_parallel_simulation.py+ """+ try:+ manager = SimulationManager()+ sim_dir = manager._get_simulation_dir(simulation_id)++ # 验证脚本名称+ allowed_scripts = [+ "run_twitter_simulation.py",+ "run_reddit_simulation.py",+ "run_parallel_simulation.py"+ ]++ if script_name not in allowed_scripts:+ return jsonify({+ "success": False,+ "error": f"未知脚本: {script_name},可选: {allowed_scripts}"+ }), 400++ script_path = os.path.join(sim_dir, script_name)++ if not os.path.exists(script_path):+ return jsonify({+ "success": False,+ "error": "脚本文件不存在,请先调用 /prepare 接口"+ }), 404++ return send_file(+ script_path,+ as_attachment=True,+ download_name=script_name+ )++ except Exception as e:+ logger.error(f"下载脚本失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++# ============== Profile生成接口(独立使用) ==============++@simulation_bp.route('/generate-profiles', methods=['POST'])+def generate_profiles():+ """+ 直接从图谱生成OASIS Agent Profile(不创建模拟)++ 请求(JSON):+ {+ "graph_id": "mirofish_xxxx", // 必填+ "entity_types": ["Student"], // 可选+ "use_llm": true, // 可选+ "platform": "reddit" // 可选+ }+ """+ try:+ data = request.get_json() or {}++ graph_id = data.get('graph_id')+ if not graph_id:+ return jsonify({+ "success": False,+ "error": "请提供 graph_id"+ }), 400++ entity_types = data.get('entity_types')+ use_llm = data.get('use_llm', True)+ platform = data.get('platform', 'reddit')++ reader = ZepEntityReader()+ filtered = reader.filter_defined_entities(+ graph_id=graph_id,+ defined_entity_types=entity_types,+ enrich_with_edges=True+ )++ if filtered.filtered_count == 0:+ return jsonify({+ "success": False,+ "error": "没有找到符合条件的实体"+ }), 400++ generator = OasisProfileGenerator()+ profiles = generator.generate_profiles_from_entities(+ entities=filtered.entities,+ use_llm=use_llm+ )++ if platform == "reddit":+ profiles_data = [p.to_reddit_format() for p in profiles]+ elif platform == "twitter":+ profiles_data = [p.to_twitter_format() for p in profiles]+ else:+ profiles_data = [p.to_dict() for p in profiles]++ return jsonify({+ "success": True,+ "data": {+ "platform": platform,+ "entity_types": list(filtered.entity_types),+ "count": len(profiles_data),+ "profiles": profiles_data+ }+ })++ except Exception as e:+ logger.error(f"生成Profile失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++# ============== 模拟运行控制接口 ==============++@simulation_bp.route('/start', methods=['POST'])+def start_simulation():+ """+ 开始运行模拟++ 请求(JSON):+ {+ "simulation_id": "sim_xxxx", // 必填,模拟ID+ "platform": "parallel" // 可选: twitter / reddit / parallel (默认)+ }++ 返回:+ {+ "success": true,+ "data": {+ "simulation_id": "sim_xxxx",+ "runner_status": "running",+ "process_pid": 12345,+ "twitter_running": true,+ "reddit_running": true,+ "started_at": "2025-12-01T10:00:00"+ }+ }+ """+ try:+ data = request.get_json() or {}++ simulation_id = data.get('simulation_id')+ if not simulation_id:+ return jsonify({+ "success": False,+ "error": "请提供 simulation_id"+ }), 400++ platform = data.get('platform', 'parallel')++ if platform not in ['twitter', 'reddit', 'parallel']:+ return jsonify({+ "success": False,+ "error": f"无效的平台类型: {platform},可选: twitter/reddit/parallel"+ }), 400++ # 检查模拟是否已准备好+ manager = SimulationManager()+ state = manager.get_simulation(simulation_id)++ if not state:+ return jsonify({+ "success": False,+ "error": f"模拟不存在: {simulation_id}"+ }), 404++ if state.status != SimulationStatus.READY:+ return jsonify({+ "success": False,+ "error": f"模拟未准备好,当前状态: {state.status.value},请先调用 /prepare 接口"+ }), 400++ # 启动模拟+ run_state = SimulationRunner.start_simulation(simulation_id, platform)++ # 更新模拟状态+ state.status = SimulationStatus.RUNNING+ manager._save_simulation_state(state)++ return jsonify({+ "success": True,+ "data": run_state.to_dict()+ })++ except ValueError as e:+ return jsonify({+ "success": False,+ "error": str(e)+ }), 400++ except Exception as e:+ logger.error(f"启动模拟失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@simulation_bp.route('/stop', methods=['POST'])+def stop_simulation():+ """+ 停止模拟++ 请求(JSON):+ {+ "simulation_id": "sim_xxxx" // 必填,模拟ID+ }++ 返回:+ {+ "success": true,+ "data": {+ "simulation_id": "sim_xxxx",+ "runner_status": "stopped",+ "completed_at": "2025-12-01T12:00:00"+ }+ }+ """+ try:+ data = request.get_json() or {}++ simulation_id = data.get('simulation_id')+ if not simulation_id:+ return jsonify({+ "success": False,+ "error": "请提供 simulation_id"+ }), 400++ run_state = SimulationRunner.stop_simulation(simulation_id)++ # 更新模拟状态+ manager = SimulationManager()+ state = manager.get_simulation(simulation_id)+ if state:+ state.status = SimulationStatus.PAUSED+ manager._save_simulation_state(state)++ return jsonify({+ "success": True,+ "data": run_state.to_dict()+ })++ except ValueError as e:+ return jsonify({+ "success": False,+ "error": str(e)+ }), 400++ except Exception as e:+ logger.error(f"停止模拟失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++# ============== 实时状态监控接口 ==============++@simulation_bp.route('/<simulation_id>/run-status', methods=['GET'])+def get_run_status(simulation_id: str):+ """+ 获取模拟运行实时状态(用于前端轮询)++ 返回:+ {+ "success": true,+ "data": {+ "simulation_id": "sim_xxxx",+ "runner_status": "running",+ "current_round": 5,+ "total_rounds": 144,+ "progress_percent": 3.5,+ "simulated_hours": 2,+ "total_simulation_hours": 72,+ "twitter_running": true,+ "reddit_running": true,+ "twitter_actions_count": 150,+ "reddit_actions_count": 200,+ "total_actions_count": 350,+ "started_at": "2025-12-01T10:00:00",+ "updated_at": "2025-12-01T10:30:00"+ }+ }+ """+ try:+ run_state = SimulationRunner.get_run_state(simulation_id)++ if not run_state:+ return jsonify({+ "success": True,+ "data": {+ "simulation_id": simulation_id,+ "runner_status": "idle",+ "current_round": 0,+ "total_rounds": 0,+ "progress_percent": 0,+ "twitter_actions_count": 0,+ "reddit_actions_count": 0,+ "total_actions_count": 0,+ }+ })++ return jsonify({+ "success": True,+ "data": run_state.to_dict()+ })++ except Exception as e:+ logger.error(f"获取运行状态失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@simulation_bp.route('/<simulation_id>/run-status/detail', methods=['GET'])+def get_run_status_detail(simulation_id: str):+ """+ 获取模拟运行详细状态(包含最近动作)++ 用于前端展示实时动态++ 返回:+ {+ "success": true,+ "data": {+ "simulation_id": "sim_xxxx",+ "runner_status": "running",+ "current_round": 5,+ ...+ "recent_actions": [+ {+ "round_num": 5,+ "timestamp": "2025-12-01T10:30:00",+ "platform": "twitter",+ "agent_id": 3,+ "agent_name": "Agent Name",+ "action_type": "CREATE_POST",+ "action_args": {"content": "..."},+ "result": null,+ "success": true+ },+ ...+ ]+ }+ }+ """+ try:+ run_state = SimulationRunner.get_run_state(simulation_id)++ if not run_state:+ return jsonify({+ "success": True,+ "data": {+ "simulation_id": simulation_id,+ "runner_status": "idle",+ "recent_actions": []+ }+ })++ return jsonify({+ "success": True,+ "data": run_state.to_detail_dict()+ })++ except Exception as e:+ logger.error(f"获取详细状态失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@simulation_bp.route('/<simulation_id>/actions', methods=['GET'])+def get_simulation_actions(simulation_id: str):+ """+ 获取模拟中的Agent动作历史++ Query参数:+ limit: 返回数量(默认100)+ offset: 偏移量(默认0)+ platform: 过滤平台(twitter/reddit)+ agent_id: 过滤Agent ID+ round_num: 过滤轮次++ 返回:+ {+ "success": true,+ "data": {+ "count": 100,+ "actions": [...]+ }+ }+ """+ try:+ limit = request.args.get('limit', 100, type=int)+ offset = request.args.get('offset', 0, type=int)+ platform = request.args.get('platform')+ agent_id = request.args.get('agent_id', type=int)+ round_num = request.args.get('round_num', type=int)++ actions = SimulationRunner.get_actions(+ simulation_id=simulation_id,+ limit=limit,+ offset=offset,+ platform=platform,+ agent_id=agent_id,+ round_num=round_num+ )++ return jsonify({+ "success": True,+ "data": {+ "count": len(actions),+ "actions": [a.to_dict() for a in actions]+ }+ })++ except Exception as e:+ logger.error(f"获取动作历史失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@simulation_bp.route('/<simulation_id>/timeline', methods=['GET'])+def get_simulation_timeline(simulation_id: str):+ """+ 获取模拟时间线(按轮次汇总)++ 用于前端展示进度条和时间线视图++ Query参数:+ start_round: 起始轮次(默认0)+ end_round: 结束轮次(默认全部)++ 返回每轮的汇总信息+ """+ try:+ start_round = request.args.get('start_round', 0, type=int)+ end_round = request.args.get('end_round', type=int)++ timeline = SimulationRunner.get_timeline(+ simulation_id=simulation_id,+ start_round=start_round,+ end_round=end_round+ )++ return jsonify({+ "success": True,+ "data": {+ "rounds_count": len(timeline),+ "timeline": timeline+ }+ })++ except Exception as e:+ logger.error(f"获取时间线失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@simulation_bp.route('/<simulation_id>/agent-stats', methods=['GET'])+def get_agent_stats(simulation_id: str):+ """+ 获取每个Agent的统计信息++ 用于前端展示Agent活跃度排行、动作分布等+ """+ try:+ stats = SimulationRunner.get_agent_stats(simulation_id)++ return jsonify({+ "success": True,+ "data": {+ "agents_count": len(stats),+ "stats": stats+ }+ })++ except Exception as e:+ logger.error(f"获取Agent统计失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++# ============== 数据库查询接口 ==============++@simulation_bp.route('/<simulation_id>/posts', methods=['GET'])+def get_simulation_posts(simulation_id: str):+ """+ 获取模拟中的帖子++ Query参数:+ platform: 平台类型(twitter/reddit)+ limit: 返回数量(默认50)+ offset: 偏移量++ 返回帖子列表(从SQLite数据库读取)+ """+ try:+ platform = request.args.get('platform', 'reddit')+ limit = request.args.get('limit', 50, type=int)+ offset = request.args.get('offset', 0, type=int)++ sim_dir = os.path.join(+ os.path.dirname(__file__),+ f'../../uploads/simulations/{simulation_id}'+ )++ db_file = f"{platform}_simulation.db"+ db_path = os.path.join(sim_dir, db_file)++ if not os.path.exists(db_path):+ return jsonify({+ "success": True,+ "data": {+ "platform": platform,+ "count": 0,+ "posts": [],+ "message": "数据库不存在,模拟可能尚未运行"+ }+ })++ import sqlite3+ conn = sqlite3.connect(db_path)+ conn.row_factory = sqlite3.Row+ cursor = conn.cursor()++ try:+ cursor.execute("""+ SELECT * FROM post+ ORDER BY created_at DESC+ LIMIT ? OFFSET ?+ """, (limit, offset))++ posts = [dict(row) for row in cursor.fetchall()]++ cursor.execute("SELECT COUNT(*) FROM post")+ total = cursor.fetchone()[0]++ except sqlite3.OperationalError:+ posts = []+ total = 0++ conn.close()++ return jsonify({+ "success": True,+ "data": {+ "platform": platform,+ "total": total,+ "count": len(posts),+ "posts": posts+ }+ })++ except Exception as e:+ logger.error(f"获取帖子失败: {str(e)}")+ return jsonify({+ "success": False,+ "error": str(e),+ "traceback": traceback.format_exc()+ }), 500+++@simulation_bp.route('/<simulation_id>/comments', methods=['GET'])+def get_simulation_comments(simulation_id: str):+ """+ 获取模拟中的评论(仅Reddit)++ Query参数:+ post_id: 过滤帖子ID(可选)+ limit: 返回数量+ offset: 偏移量+ """+ try:+ post_id = request.args.get('post_id')+ limit = request.args.get('limit', 50, type=int)+ offset = request.args.get('offset', 0, type=int)++ sim_dir = os.path.join(+ os.path.dirname(__file__),+ f'../../uploads/simulations/{simulation_id}'+ )++ db_path = os.path.join(sim_dir, "reddit_simulation.db")++ if not os.path.exists(db_path):+ return jsonify({+ "success": True,+ "data": {+ "count": 0,+ "comments": []+ }+ })++ import sqlite3+ conn = sqlite3.connect(db_path)+ conn.row_factory = sqlite3.Row+ cursor = conn.cursor()++ try:+ if post_id:+ cursor.execute("""+ SELECT * FROM comment+ WHERE post_id = ?+ ORDER BY created_at DESC+ LIMIT ? OFFSET ?+ """, (post_id, limit, offset))+ else:+ cursor.execute("""+ SELECT * FROM comment+ ORDER BY created_at DESC+ LIMIT ? OFFSET ?+ """, (limit, offset))++ comments = [dict(row) for row in cursor.fetchall()]++ except sqlite3.OperationalError:+ comments = []++ conn.close()++ return jsonify({+ "success": True,+ "data": {+ "count": len(comments),+ "comments": comments+ }+ })++ 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 32ad5133..a23556cc 100644--- a/backend/app/config.py+++ b/backend/app/config.py@@ -41,6 +41,20 @@ class Config:DEFAULT_CHUNK_SIZE = 500 # 默认切块大小DEFAULT_CHUNK_OVERLAP = 50 # 默认重叠大小+ # OASIS模拟配置+ OASIS_DEFAULT_MAX_ROUNDS = int(os.environ.get('OASIS_DEFAULT_MAX_ROUNDS', '10'))+ OASIS_SIMULATION_DATA_DIR = os.path.join(os.path.dirname(__file__), '../uploads/simulations')++ # OASIS平台可用动作配置+ OASIS_TWITTER_ACTIONS = [+ 'CREATE_POST', 'LIKE_POST', 'REPOST', 'FOLLOW', 'DO_NOTHING', 'QUOTE_POST'+ ]+ OASIS_REDDIT_ACTIONS = [+ 'LIKE_POST', 'DISLIKE_POST', 'CREATE_POST', 'CREATE_COMMENT',+ 'LIKE_COMMENT', 'DISLIKE_COMMENT', 'SEARCH_POSTS', 'SEARCH_USER',+ 'TREND', 'REFRESH', 'DO_NOTHING', 'FOLLOW', 'MUTE'+ ]+@classmethoddef validate(cls):"""验证必要配置"""diff --git a/backend/app/models/task.py b/backend/app/models/task.pyindex 2741f116..e15f35fb 100644--- a/backend/app/models/task.py+++ b/backend/app/models/task.py@@ -27,11 +27,12 @@ class Task:status: TaskStatuscreated_at: datetimeupdated_at: datetime- progress: int = 0 # 进度百分比 0-100+ progress: int = 0 # 总进度百分比 0-100message: str = "" # 状态消息result: Optional[Dict] = None # 任务结果error: Optional[str] = None # 错误信息metadata: Dict = field(default_factory=dict) # 额外元数据+ progress_detail: Dict = field(default_factory=dict) # 详细进度信息def to_dict(self) -> Dict[str, Any]:"""转换为字典"""@@ -43,6 +44,7 @@ class Task:"updated_at": self.updated_at.isoformat(),"progress": self.progress,"message": self.message,+ "progress_detail": self.progress_detail,"result": self.result,"error": self.error,"metadata": self.metadata,@@ -108,7 +110,8 @@ class TaskManager:progress: Optional[int] = None,message: Optional[str] = None,result: Optional[Dict] = None,- error: Optional[str] = None+ error: Optional[str] = None,+ progress_detail: Optional[Dict] = None):"""更新任务状态@@ -120,6 +123,7 @@ class TaskManager:message: 消息result: 结果error: 错误信息+ progress_detail: 详细进度信息"""with self._task_lock:task = self._tasks.get(task_id)@@ -135,6 +139,8 @@ class TaskManager:task.result = resultif error is not None:task.error = error+ if progress_detail is not None:+ task.progress_detail = progress_detaildef complete_task(self, task_id: str, result: Dict):"""标记任务完成"""diff --git a/backend/app/services/__init__.py b/backend/app/services/__init__.pyindex 42cdc5ba..b8f2e676 100644--- a/backend/app/services/__init__.py+++ b/backend/app/services/__init__.py@@ -5,6 +5,47 @@from .ontology_generator import OntologyGeneratorfrom .graph_builder import GraphBuilderServicefrom .text_processor import TextProcessor+from .zep_entity_reader import ZepEntityReader, EntityNode, FilteredEntities+from .oasis_profile_generator import OasisProfileGenerator, OasisAgentProfile+from .simulation_manager import SimulationManager, SimulationState, SimulationStatus+from .simulation_config_generator import (+ SimulationConfigGenerator,+ SimulationParameters,+ AgentActivityConfig,+ TimeSimulationConfig,+ EventConfig,+ PlatformConfig+)+from .simulation_runner import (+ SimulationRunner,+ SimulationRunState,+ RunnerStatus,+ AgentAction,+ RoundSummary+)-__all__ = ['OntologyGenerator', 'GraphBuilderService', 'TextProcessor']+__all__ = [+ 'OntologyGenerator',+ 'GraphBuilderService',+ 'TextProcessor',+ 'ZepEntityReader',+ 'EntityNode',+ 'FilteredEntities',+ 'OasisProfileGenerator',+ 'OasisAgentProfile',+ 'SimulationManager',+ 'SimulationState',+ 'SimulationStatus',+ 'SimulationConfigGenerator',+ 'SimulationParameters',+ 'AgentActivityConfig',+ 'TimeSimulationConfig',+ 'EventConfig',+ 'PlatformConfig',+ 'SimulationRunner',+ 'SimulationRunState',+ 'RunnerStatus',+ 'AgentAction',+ 'RoundSummary',+]diff --git a/backend/app/services/oasis_profile_generator.py b/backend/app/services/oasis_profile_generator.pynew file mode 100644index 00000000..fe0144ab--- /dev/null+++ b/backend/app/services/oasis_profile_generator.py@@ -0,0 +1,561 @@+"""+OASIS Agent Profile生成器+将Zep图谱中的实体转换为OASIS模拟平台所需的Agent Profile格式+"""++import json+import random+from typing import Dict, Any, List, Optional+from dataclasses import dataclass, field+from datetime import datetime++from openai import OpenAI++from ..config import Config+from ..utils.logger import get_logger+from .zep_entity_reader import EntityNode, ZepEntityReader++logger = get_logger('mirofish.oasis_profile')+++@dataclass+class OasisAgentProfile:+ """OASIS Agent Profile数据结构"""+ # 通用字段+ user_id: int+ user_name: str+ name: str+ bio: str+ persona: str++ # 可选字段 - Reddit风格+ karma: int = 1000++ # 可选字段 - Twitter风格+ friend_count: int = 100+ follower_count: int = 150+ statuses_count: int = 500++ # 额外人设信息+ age: Optional[int] = None+ gender: Optional[str] = None+ mbti: Optional[str] = None+ country: Optional[str] = None+ profession: Optional[str] = None+ interested_topics: List[str] = field(default_factory=list)++ # 来源实体信息+ source_entity_uuid: Optional[str] = None+ source_entity_type: Optional[str] = None++ created_at: str = field(default_factory=lambda: datetime.now().strftime("%Y-%m-%d"))++ def to_reddit_format(self) -> Dict[str, Any]:+ """转换为Reddit平台格式"""+ profile = {+ "user_id": self.user_id,+ "user_name": self.user_name,+ "name": self.name,+ "bio": self.bio,+ "persona": self.persona,+ "karma": self.karma,+ "created_at": self.created_at,+ }++ # 添加额外人设信息(如果有)+ if self.age:+ profile["age"] = self.age+ if self.gender:+ profile["gender"] = self.gender+ if self.mbti:+ profile["mbti"] = self.mbti+ if self.country:+ profile["country"] = self.country+ if self.profession:+ profile["profession"] = self.profession+ if self.interested_topics:+ profile["interested_topics"] = self.interested_topics++ return profile++ def to_twitter_format(self) -> Dict[str, Any]:+ """转换为Twitter平台格式"""+ profile = {+ "user_id": self.user_id,+ "user_name": self.user_name,+ "name": self.name,+ "bio": self.bio,+ "persona": self.persona,+ "friend_count": self.friend_count,+ "follower_count": self.follower_count,+ "statuses_count": self.statuses_count,+ "created_at": self.created_at,+ }++ # 添加额外人设信息+ if self.age:+ profile["age"] = self.age+ if self.gender:+ profile["gender"] = self.gender+ if self.mbti:+ profile["mbti"] = self.mbti+ if self.country:+ profile["country"] = self.country+ if self.profession:+ profile["profession"] = self.profession+ if self.interested_topics:+ profile["interested_topics"] = self.interested_topics++ return profile++ def to_dict(self) -> Dict[str, Any]:+ """转换为完整字典格式"""+ return {+ "user_id": self.user_id,+ "user_name": self.user_name,+ "name": self.name,+ "bio": self.bio,+ "persona": self.persona,+ "karma": self.karma,+ "friend_count": self.friend_count,+ "follower_count": self.follower_count,+ "statuses_count": self.statuses_count,+ "age": self.age,+ "gender": self.gender,+ "mbti": self.mbti,+ "country": self.country,+ "profession": self.profession,+ "interested_topics": self.interested_topics,+ "source_entity_uuid": self.source_entity_uuid,+ "source_entity_type": self.source_entity_type,+ "created_at": self.created_at,+ }+++class OasisProfileGenerator:+ """+ OASIS Profile生成器++ 将Zep图谱中的实体转换为OASIS模拟所需的Agent Profile+ """++ # MBTI类型列表+ MBTI_TYPES = [+ "INTJ", "INTP", "ENTJ", "ENTP",+ "INFJ", "INFP", "ENFJ", "ENFP",+ "ISTJ", "ISFJ", "ESTJ", "ESFJ",+ "ISTP", "ISFP", "ESTP", "ESFP"+ ]++ # 常见国家列表+ COUNTRIES = [+ "China", "US", "UK", "Japan", "Germany", "France",+ "Canada", "Australia", "Brazil", "India", "South Korea"+ ]++ def __init__(+ self,+ api_key: Optional[str] = None,+ base_url: Optional[str] = None,+ model_name: Optional[str] = None+ ):+ self.api_key = api_key or Config.LLM_API_KEY+ self.base_url = base_url or Config.LLM_BASE_URL+ self.model_name = model_name or Config.LLM_MODEL_NAME++ if not self.api_key:+ raise ValueError("LLM_API_KEY 未配置")++ self.client = OpenAI(+ api_key=self.api_key,+ base_url=self.base_url+ )++ def generate_profile_from_entity(+ self,+ entity: EntityNode,+ user_id: int,+ use_llm: bool = True+ ) -> OasisAgentProfile:+ """+ 从Zep实体生成OASIS Agent Profile++ Args:+ entity: Zep实体节点+ user_id: 用户ID(用于OASIS)+ use_llm: 是否使用LLM生成详细人设++ Returns:+ OasisAgentProfile+ """+ entity_type = entity.get_entity_type() or "Entity"++ # 基础信息+ name = entity.name+ user_name = self._generate_username(name)++ # 构建上下文信息+ context = self._build_entity_context(entity)++ if use_llm:+ # 使用LLM生成详细人设+ profile_data = self._generate_profile_with_llm(+ entity_name=name,+ entity_type=entity_type,+ entity_summary=entity.summary,+ entity_attributes=entity.attributes,+ context=context+ )+ else:+ # 使用规则生成基础人设+ profile_data = self._generate_profile_rule_based(+ entity_name=name,+ entity_type=entity_type,+ entity_summary=entity.summary,+ entity_attributes=entity.attributes+ )++ return OasisAgentProfile(+ user_id=user_id,+ user_name=user_name,+ name=name,+ bio=profile_data.get("bio", f"{entity_type}: {name}"),+ persona=profile_data.get("persona", entity.summary or f"A {entity_type} named {name}."),+ karma=profile_data.get("karma", random.randint(500, 5000)),+ friend_count=profile_data.get("friend_count", random.randint(50, 500)),+ follower_count=profile_data.get("follower_count", random.randint(100, 1000)),+ statuses_count=profile_data.get("statuses_count", random.randint(100, 2000)),+ age=profile_data.get("age"),+ gender=profile_data.get("gender"),+ mbti=profile_data.get("mbti"),+ country=profile_data.get("country"),+ profession=profile_data.get("profession"),+ interested_topics=profile_data.get("interested_topics", []),+ source_entity_uuid=entity.uuid,+ source_entity_type=entity_type,+ )++ def _generate_username(self, name: str) -> str:+ """生成用户名"""+ # 移除特殊字符,转换为小写+ username = name.lower().replace(" ", "_")+ username = ''.join(c for c in username if c.isalnum() or c == '_')++ # 添加随机后缀避免重复+ suffix = random.randint(100, 999)+ return f"{username}_{suffix}"++ def _build_entity_context(self, entity: EntityNode) -> str:+ """构建实体的上下文信息"""+ context_parts = []++ # 添加相关边信息+ if entity.related_edges:+ relationships = []+ for edge in entity.related_edges[:10]: # 最多取10条+ if edge.get("fact"):+ relationships.append(edge["fact"])++ if relationships:+ context_parts.append("Related facts:\n" + "\n".join(f"- {r}" for r in relationships))++ # 添加关联节点信息+ if entity.related_nodes:+ related_names = [n["name"] for n in entity.related_nodes[:5]]+ if related_names:+ context_parts.append(f"Related to: {', '.join(related_names)}")++ return "\n\n".join(context_parts)++ def _generate_profile_with_llm(+ self,+ entity_name: str,+ entity_type: str,+ entity_summary: str,+ entity_attributes: Dict[str, Any],+ context: str+ ) -> Dict[str, Any]:+ """使用LLM生成详细人设"""++ prompt = f"""Based on the following entity information, generate a detailed social media user profile for simulation purposes.++Entity Information:+- Name: {entity_name}+- Type: {entity_type}+- Summary: {entity_summary}+- Attributes: {json.dumps(entity_attributes, ensure_ascii=False)}++Context:+{context}++Generate a JSON object with the following fields:+{{+ "bio": "A short bio (max 150 chars) suitable for social media",+ "persona": "A detailed persona description (2-3 sentences) describing personality, interests, and behavior patterns",+ "age": <integer between 18-65, or null if not applicable>,+ "gender": "<male/female/other, or null if not applicable>",+ "mbti": "<MBTI type like INTJ, ENFP, etc., or null>",+ "country": "<country name, or null>",+ "profession": "<profession/occupation, or null>",+ "interested_topics": ["topic1", "topic2", ...]+}}++Important:+- The profile should be consistent with the entity type and context+- Make the persona feel realistic and suitable for social media simulation+- If the entity is an organization, institution, or non-person, adapt the profile accordingly (e.g., as an official account)+- Return ONLY the JSON object, no additional text"""++ try:+ # 使用重试机制调用LLM API+ from ..utils.retry import RetryableAPIClient++ retry_client = RetryableAPIClient(max_retries=3, initial_delay=1.0)++ def call_llm():+ return self.client.chat.completions.create(+ model=self.model_name,+ messages=[+ {"role": "system", "content": "You are a profile generator for social media simulation. Generate realistic user profiles based on entity information."},+ {"role": "user", "content": prompt}+ ],+ response_format={"type": "json_object"},+ temperature=0.7+ )++ response = retry_client.call_with_retry(call_llm)+ result = json.loads(response.choices[0].message.content)+ return result++ except Exception as e:+ logger.warning(f"LLM生成人设失败(已重试): {str(e)}, 使用规则生成")+ return self._generate_profile_rule_based(+ entity_name, entity_type, entity_summary, entity_attributes+ )++ def _generate_profile_rule_based(+ self,+ entity_name: str,+ entity_type: str,+ entity_summary: str,+ entity_attributes: Dict[str, Any]+ ) -> Dict[str, Any]:+ """使用规则生成基础人设"""++ # 根据实体类型生成不同的人设+ entity_type_lower = entity_type.lower()++ if entity_type_lower in ["student", "alumni"]:+ return {+ "bio": f"{entity_type} with interests in academics and social issues.",+ "persona": f"{entity_name} is a {entity_type.lower()} who is actively engaged in academic and social discussions. They enjoy sharing perspectives and connecting with peers.",+ "age": random.randint(18, 30),+ "gender": random.choice(["male", "female"]),+ "mbti": random.choice(self.MBTI_TYPES),+ "country": random.choice(self.COUNTRIES),+ "profession": "Student",+ "interested_topics": ["Education", "Social Issues", "Technology"],+ }++ elif entity_type_lower in ["publicfigure", "expert", "faculty"]:+ return {+ "bio": f"Expert and thought leader in their field.",+ "persona": f"{entity_name} is a recognized {entity_type.lower()} who shares insights and opinions on important matters. They are known for their expertise and influence in public discourse.",+ "age": random.randint(35, 60),+ "gender": random.choice(["male", "female"]),+ "mbti": random.choice(["ENTJ", "INTJ", "ENTP", "INTP"]),+ "country": random.choice(self.COUNTRIES),+ "profession": entity_attributes.get("occupation", "Expert"),+ "interested_topics": ["Politics", "Economics", "Culture & Society"],+ }++ elif entity_type_lower in ["mediaoutlet", "socialmediaplatform"]:+ return {+ "bio": f"Official account for {entity_name}. News and updates.",+ "persona": f"{entity_name} is a media entity that reports news and facilitates public discourse. The account shares timely updates and engages with the audience on current events.",+ "profession": "Media",+ "interested_topics": ["General News", "Current Events", "Public Affairs"],+ }++ elif entity_type_lower in ["university", "governmentagency", "ngo", "organization"]:+ return {+ "bio": f"Official account of {entity_name}.",+ "persona": f"{entity_name} is an institutional entity that communicates official positions, announcements, and engages with stakeholders on relevant matters.",+ "profession": entity_type,+ "interested_topics": ["Public Policy", "Community", "Official Announcements"],+ }++ else:+ # 默认人设+ return {+ "bio": entity_summary[:150] if entity_summary else f"{entity_type}: {entity_name}",+ "persona": entity_summary or f"{entity_name} is a {entity_type.lower()} participating in social discussions.",+ "age": random.randint(25, 50),+ "gender": random.choice(["male", "female"]),+ "mbti": random.choice(self.MBTI_TYPES),+ "country": random.choice(self.COUNTRIES),+ "profession": entity_type,+ "interested_topics": ["General", "Social Issues"],+ }++ def generate_profiles_from_entities(+ self,+ entities: List[EntityNode],+ use_llm: bool = True,+ progress_callback: Optional[callable] = None+ ) -> List[OasisAgentProfile]:+ """+ 批量从实体生成Agent Profile++ Args:+ entities: 实体列表+ use_llm: 是否使用LLM生成详细人设+ progress_callback: 进度回调函数 (current, total, message)++ Returns:+ Agent Profile列表+ """+ profiles = []+ total = len(entities)++ for idx, entity in enumerate(entities):+ if progress_callback:+ progress_callback(idx + 1, total, f"生成 {entity.name} 的人设...")++ try:+ profile = self.generate_profile_from_entity(+ entity=entity,+ user_id=idx,+ use_llm=use_llm+ )+ profiles.append(profile)++ except Exception as e:+ logger.error(f"生成实体 {entity.name} 的人设失败: {str(e)}")+ # 创建一个基础profile+ profiles.append(OasisAgentProfile(+ user_id=idx,+ user_name=self._generate_username(entity.name),+ name=entity.name,+ bio=f"{entity.get_entity_type() or 'Entity'}: {entity.name}",+ persona=entity.summary or f"A participant in social discussions.",+ source_entity_uuid=entity.uuid,+ source_entity_type=entity.get_entity_type(),+ ))++ return profiles++ def save_profiles(+ self,+ profiles: List[OasisAgentProfile],+ file_path: str,+ platform: str = "reddit"+ ):+ """+ 保存Profile到文件(根据平台选择正确格式)++ OASIS平台格式要求:+ - Twitter: CSV格式+ - Reddit: JSON格式++ Args:+ profiles: Profile列表+ file_path: 文件路径+ platform: 平台类型 ("reddit" 或 "twitter")+ """+ if platform == "twitter":+ self._save_twitter_csv(profiles, file_path)+ else:+ self._save_reddit_json(profiles, file_path)++ def _save_twitter_csv(self, profiles: List[OasisAgentProfile], file_path: str):+ """+ 保存Twitter Profile为CSV格式++ OASIS Twitter要求的CSV字段:+ user_id, user_name, name, bio, friend_count, follower_count, statuses_count, created_at+ """+ import csv++ # 确保文件扩展名是.csv+ if not file_path.endswith('.csv'):+ file_path = file_path.replace('.json', '.csv')++ with open(file_path, 'w', newline='', encoding='utf-8') as f:+ writer = csv.writer(f)++ # 写入表头+ headers = ['user_id', 'user_name', 'name', 'bio', 'friend_count',+ 'follower_count', 'statuses_count', 'created_at']+ writer.writerow(headers)++ # 写入数据行+ for profile in profiles:+ # bio需要处理换行符和逗号+ bio = profile.bio.replace('\n', ' ').replace('\r', ' ')+ row = [+ profile.user_id,+ profile.user_name,+ profile.name,+ bio,+ profile.friend_count,+ profile.follower_count,+ profile.statuses_count,+ profile.created_at+ ]+ writer.writerow(row)++ logger.info(f"已保存 {len(profiles)} 个Twitter Profile到 {file_path} (CSV格式)")++ def _save_reddit_json(self, profiles: List[OasisAgentProfile], file_path: str):+ """+ 保存Reddit Profile为JSON格式++ OASIS Reddit支持两种JSON格式:+ 1. 基础格式: user_id, user_name, name, bio, karma, created_at+ 2. 详细格式: realname, username, bio, persona, age, gender, mbti, country, profession, interested_topics++ 我们使用详细格式,与用户示例数据(36个简单人设.json)保持一致+ """+ data = []+ for profile in profiles:+ # 使用详细格式(与用户示例兼容)+ item = {+ "realname": profile.name,+ "username": profile.user_name,+ "bio": profile.bio[:150] if profile.bio else "", # OASIS bio限制150字符+ "persona": profile.persona or f"{profile.name} is a participant in social discussions.",+ }++ # 添加人设详情字段+ if profile.age:+ item["age"] = profile.age+ if profile.gender:+ item["gender"] = profile.gender+ if profile.mbti:+ item["mbti"] = profile.mbti+ if profile.country:+ item["country"] = profile.country+ if profile.profession:+ item["profession"] = profile.profession+ if profile.interested_topics:+ item["interested_topics"] = profile.interested_topics++ data.append(item)++ with open(file_path, 'w', encoding='utf-8') as f:+ json.dump(data, f, ensure_ascii=False, indent=2)++ logger.info(f"已保存 {len(profiles)} 个Reddit Profile到 {file_path} (JSON详细格式)")++ # 保留旧方法名作为别名,保持向后兼容+ def save_profiles_to_json(+ self,+ profiles: List[OasisAgentProfile],+ file_path: str,+ platform: str = "reddit"+ ):+ """[已废弃] 请使用 save_profiles() 方法"""+ logger.warning("save_profiles_to_json已废弃,请使用save_profiles方法")+ self.save_profiles(profiles, file_path, platform)+diff --git a/backend/app/services/simulation_config_generator.py b/backend/app/services/simulation_config_generator.pynew file mode 100644index 00000000..b75ee24e--- /dev/null+++ b/backend/app/services/simulation_config_generator.py@@ -0,0 +1,584 @@+"""+模拟配置智能生成器+使用LLM根据模拟需求、文档内容、图谱信息自动生成细致的模拟参数+实现全程自动化,无需人工设置参数+"""++import json+from typing import Dict, Any, List, Optional+from dataclasses import dataclass, field, asdict+from datetime import datetime++from openai import OpenAI++from ..config import Config+from ..utils.logger import get_logger+from .zep_entity_reader import EntityNode, ZepEntityReader++logger = get_logger('mirofish.simulation_config')+++@dataclass+class AgentActivityConfig:+ """单个Agent的活动配置"""+ agent_id: int+ entity_uuid: str+ entity_name: str+ entity_type: str++ # 活跃度配置 (0.0-1.0)+ activity_level: float = 0.5 # 整体活跃度++ # 发言频率(每小时预期发言次数)+ posts_per_hour: float = 1.0+ comments_per_hour: float = 2.0++ # 活跃时间段(24小时制,0-23)+ active_hours: List[int] = field(default_factory=lambda: list(range(8, 23)))++ # 响应速度(对热点事件的反应延迟,单位:模拟分钟)+ response_delay_min: int = 5+ response_delay_max: int = 60++ # 情感倾向 (-1.0到1.0,负面到正面)+ sentiment_bias: float = 0.0++ # 立场(对特定话题的态度)+ stance: str = "neutral" # supportive, opposing, neutral, observer++ # 影响力权重(决定其发言被其他Agent看到的概率)+ influence_weight: float = 1.0+++@dataclass+class TimeSimulationConfig:+ """时间模拟配置"""+ # 模拟总时长(模拟小时数)+ total_simulation_hours: int = 72 # 默认模拟72小时(3天)++ # 每轮代表的时间(模拟分钟)+ minutes_per_round: int = 30++ # 每小时激活的Agent数量范围+ agents_per_hour_min: int = 5+ agents_per_hour_max: int = 20++ # 高峰时段(活跃度提升)+ peak_hours: List[int] = field(default_factory=lambda: [9, 10, 11, 14, 15, 20, 21, 22])+ peak_activity_multiplier: float = 1.5++ # 低谷时段(活跃度降低)+ off_peak_hours: List[int] = field(default_factory=lambda: [0, 1, 2, 3, 4, 5, 6])+ off_peak_activity_multiplier: float = 0.3+++@dataclass+class EventConfig:+ """事件配置"""+ # 初始事件(模拟开始时的触发事件)+ initial_posts: List[Dict[str, Any]] = field(default_factory=list)++ # 定时事件(在特定时间触发的事件)+ scheduled_events: List[Dict[str, Any]] = field(default_factory=list)++ # 热点话题关键词+ hot_topics: List[str] = field(default_factory=list)++ # 舆论引导方向+ narrative_direction: str = ""+++@dataclass+class PlatformConfig:+ """平台特定配置"""+ platform: str # twitter or reddit++ # 推荐算法权重+ recency_weight: float = 0.4 # 时间新鲜度+ popularity_weight: float = 0.3 # 热度+ relevance_weight: float = 0.3 # 相关性++ # 病毒传播阈值(达到多少互动后触发扩散)+ viral_threshold: int = 10++ # 回声室效应强度(相似观点聚集程度)+ echo_chamber_strength: float = 0.5+++@dataclass+class SimulationParameters:+ """完整的模拟参数配置"""+ # 基础信息+ simulation_id: str+ project_id: str+ graph_id: str+ simulation_requirement: str++ # 时间配置+ time_config: TimeSimulationConfig = field(default_factory=TimeSimulationConfig)++ # Agent配置列表+ agent_configs: List[AgentActivityConfig] = field(default_factory=list)++ # 事件配置+ event_config: EventConfig = field(default_factory=EventConfig)++ # 平台配置+ twitter_config: Optional[PlatformConfig] = None+ reddit_config: Optional[PlatformConfig] = None++ # LLM配置+ llm_model: str = ""+ llm_base_url: str = ""++ # 生成元数据+ generated_at: str = field(default_factory=lambda: datetime.now().isoformat())+ generation_reasoning: str = "" # LLM的推理说明++ def to_dict(self) -> Dict[str, Any]:+ """转换为字典"""+ return {+ "simulation_id": self.simulation_id,+ "project_id": self.project_id,+ "graph_id": self.graph_id,+ "simulation_requirement": self.simulation_requirement,+ "time_config": asdict(self.time_config),+ "agent_configs": [asdict(a) for a in self.agent_configs],+ "event_config": asdict(self.event_config),+ "twitter_config": asdict(self.twitter_config) if self.twitter_config else None,+ "reddit_config": asdict(self.reddit_config) if self.reddit_config else None,+ "llm_model": self.llm_model,+ "llm_base_url": self.llm_base_url,+ "generated_at": self.generated_at,+ "generation_reasoning": self.generation_reasoning,+ }++ def to_json(self, indent: int = 2) -> str:+ """转换为JSON字符串"""+ return json.dumps(self.to_dict(), ensure_ascii=False, indent=indent)+++class SimulationConfigGenerator:+ """+ 模拟配置智能生成器++ 使用LLM分析模拟需求、文档内容、图谱实体信息,+ 自动生成最佳的模拟参数配置+ """++ # 上下文最大字符数+ MAX_CONTEXT_LENGTH = 50000++ def __init__(+ self,+ api_key: Optional[str] = None,+ base_url: Optional[str] = None,+ model_name: Optional[str] = None+ ):+ self.api_key = api_key or Config.LLM_API_KEY+ self.base_url = base_url or Config.LLM_BASE_URL+ self.model_name = model_name or Config.LLM_MODEL_NAME++ if not self.api_key:+ raise ValueError("LLM_API_KEY 未配置")++ self.client = OpenAI(+ api_key=self.api_key,+ base_url=self.base_url+ )++ def generate_config(+ self,+ simulation_id: str,+ project_id: str,+ graph_id: str,+ simulation_requirement: str,+ document_text: str,+ entities: List[EntityNode],+ enable_twitter: bool = True,+ enable_reddit: bool = True,+ ) -> SimulationParameters:+ """+ 智能生成完整的模拟配置++ Args:+ simulation_id: 模拟ID+ project_id: 项目ID+ graph_id: 图谱ID+ simulation_requirement: 模拟需求描述+ document_text: 原始文档内容+ entities: 过滤后的实体列表+ enable_twitter: 是否启用Twitter+ enable_reddit: 是否启用Reddit++ Returns:+ SimulationParameters: 完整的模拟参数+ """+ logger.info(f"开始智能生成模拟配置: simulation_id={simulation_id}")++ # 1. 构建上下文信息(截断到50000字符)+ context = self._build_context(+ simulation_requirement=simulation_requirement,+ document_text=document_text,+ entities=entities+ )++ # 2. 调用LLM生成配置+ llm_result = self._generate_config_with_llm(+ context=context,+ entities=entities,+ enable_twitter=enable_twitter,+ enable_reddit=enable_reddit+ )++ # 3. 构建SimulationParameters对象+ params = self._build_parameters(+ simulation_id=simulation_id,+ project_id=project_id,+ graph_id=graph_id,+ simulation_requirement=simulation_requirement,+ entities=entities,+ llm_result=llm_result,+ enable_twitter=enable_twitter,+ enable_reddit=enable_reddit+ )++ logger.info(f"模拟配置生成完成: {len(params.agent_configs)} 个Agent配置")++ return params++ def _build_context(+ self,+ simulation_requirement: str,+ document_text: str,+ entities: List[EntityNode]+ ) -> str:+ """构建LLM上下文,截断到最大长度"""++ # 实体摘要+ entity_summary = self._summarize_entities(entities)++ # 构建上下文+ context_parts = [+ f"## 模拟需求\n{simulation_requirement}",+ f"\n## 实体信息 ({len(entities)}个)\n{entity_summary}",+ ]++ current_length = sum(len(p) for p in context_parts)+ remaining_length = self.MAX_CONTEXT_LENGTH - current_length - 500 # 留500字符余量++ if remaining_length > 0 and document_text:+ doc_text = document_text[:remaining_length]+ if len(document_text) > remaining_length:+ doc_text += "\n...(文档已截断)"+ context_parts.append(f"\n## 原始文档内容\n{doc_text}")++ return "\n".join(context_parts)++ def _summarize_entities(self, entities: List[EntityNode]) -> str:+ """生成实体摘要"""+ lines = []++ # 按类型分组+ by_type: Dict[str, List[EntityNode]] = {}+ for e in entities:+ t = e.get_entity_type() or "Unknown"+ if t not in by_type:+ by_type[t] = []+ by_type[t].append(e)++ for entity_type, type_entities in by_type.items():+ lines.append(f"\n### {entity_type} ({len(type_entities)}个)")+ for e in type_entities[:10]: # 每类最多显示10个+ summary_preview = (e.summary[:100] + "...") if len(e.summary) > 100 else e.summary+ lines.append(f"- {e.name}: {summary_preview}")+ if len(type_entities) > 10:+ lines.append(f" ... 还有 {len(type_entities) - 10} 个")++ return "\n".join(lines)++ def _generate_config_with_llm(+ self,+ context: str,+ entities: List[EntityNode],+ enable_twitter: bool,+ enable_reddit: bool+ ) -> Dict[str, Any]:+ """调用LLM生成配置"""++ # 构建实体列表用于Agent配置+ entity_list = []+ for i, e in enumerate(entities):+ entity_list.append({+ "agent_id": i,+ "entity_uuid": e.uuid,+ "entity_name": e.name,+ "entity_type": e.get_entity_type() or "Unknown",+ "summary": e.summary[:200] if e.summary else ""+ })++ prompt = f"""你是一个社交媒体舆论模拟专家。请根据以下信息,生成详细的模拟参数配置。++{context}++## 实体列表(需要为每个实体生成活动配置)+```json+{json.dumps(entity_list, ensure_ascii=False, indent=2)}+```++## 任务+请生成一个JSON配置,包含以下部分:++1. **time_config** - 时间模拟配置+ - total_simulation_hours: 模拟总时长(小时),根据事件性质决定(短期热点24-72小时,长期舆论168-336小时)+ - minutes_per_round: 每轮代表的时间(分钟),建议15-60+ - agents_per_hour_min/max: 每小时激活的Agent数量范围+ - peak_hours: 高峰时段列表(0-23)+ - off_peak_hours: 低谷时段列表++2. **agent_configs** - 每个Agent的活动配置(必须为每个实体生成)+ 对于每个agent_id,设置:+ - activity_level: 活跃度(0.0-1.0),官方机构通常0.1-0.3,媒体0.3-0.5,个人0.5-0.9+ - posts_per_hour: 每小时发帖频率,官方机构0.05-0.2,媒体0.5-2,个人0.1-1+ - comments_per_hour: 每小时评论频率+ - active_hours: 活跃时间段列表,官方通常工作时间,个人更分散+ - response_delay_min/max: 响应延迟(模拟分钟),官方较慢(30-180),个人较快(1-30)+ - sentiment_bias: 情感倾向(-1到1),根据实体立场设置+ - stance: 立场(supportive/opposing/neutral/observer)+ - influence_weight: 影响力权重,知名人物和媒体较高++3. **event_config** - 事件配置+ - initial_posts: 初始帖子列表,包含content和poster_agent_id+ - hot_topics: 热点话题关键词列表+ - narrative_direction: 舆论发展方向描述++4. **platform_configs** - 平台配置(如果启用)+ - viral_threshold: 病毒传播阈值+ - echo_chamber_strength: 回声室效应强度(0-1)++5. **reasoning** - 你的推理说明,解释为什么这样设置参数++## 重要原则+- 官方机构(University、GovernmentAgency)发言频率低但影响力大+- 媒体(MediaOutlet)发言频率中等,传播速度快+- 个人(Student、PublicFigure)发言频率高但影响力分散+- 根据模拟需求判断各实体的立场和情感倾向+- 时间配置要符合真实社交媒体的使用规律++请返回JSON格式,不要包含markdown代码块标记。"""++ try:+ # 使用重试机制调用LLM API+ from ..utils.retry import RetryableAPIClient++ retry_client = RetryableAPIClient(max_retries=3, initial_delay=2.0, max_delay=60.0)++ def call_llm():+ return self.client.chat.completions.create(+ model=self.model_name,+ messages=[+ {+ "role": "system",+ "content": "你是社交媒体舆论模拟专家,擅长设计真实的模拟参数。返回纯JSON格式,不要markdown。"+ },+ {"role": "user", "content": prompt}+ ],+ response_format={"type": "json_object"},+ temperature=0.7,+ max_tokens=8000+ )++ response = retry_client.call_with_retry(call_llm)+ result = json.loads(response.choices[0].message.content)+ logger.info(f"LLM配置生成成功")+ return result++ except Exception as e:+ logger.error(f"LLM配置生成失败(已重试): {str(e)}")+ # 返回默认配置+ return self._generate_default_config(entities)++ def _generate_default_config(self, entities: List[EntityNode]) -> Dict[str, Any]:+ """生成默认配置(LLM失败时的fallback)"""+ agent_configs = []++ for i, e in enumerate(entities):+ entity_type = (e.get_entity_type() or "Unknown").lower()++ # 根据实体类型设置默认参数+ if entity_type in ["university", "governmentagency", "ngo"]:+ config = {+ "agent_id": i,+ "activity_level": 0.2,+ "posts_per_hour": 0.1,+ "comments_per_hour": 0.05,+ "active_hours": list(range(9, 18)),+ "response_delay_min": 60,+ "response_delay_max": 240,+ "sentiment_bias": 0.0,+ "stance": "neutral",+ "influence_weight": 3.0+ }+ elif entity_type in ["mediaoutlet"]:+ config = {+ "agent_id": i,+ "activity_level": 0.6,+ "posts_per_hour": 1.0,+ "comments_per_hour": 0.5,+ "active_hours": list(range(6, 24)),+ "response_delay_min": 5,+ "response_delay_max": 30,+ "sentiment_bias": 0.0,+ "stance": "observer",+ "influence_weight": 2.5+ }+ elif entity_type in ["publicfigure", "expert"]:+ config = {+ "agent_id": i,+ "activity_level": 0.5,+ "posts_per_hour": 0.3,+ "comments_per_hour": 0.5,+ "active_hours": list(range(8, 23)),+ "response_delay_min": 10,+ "response_delay_max": 60,+ "sentiment_bias": 0.0,+ "stance": "neutral",+ "influence_weight": 2.0+ }+ else: # Student, Person, etc.+ config = {+ "agent_id": i,+ "activity_level": 0.7,+ "posts_per_hour": 0.5,+ "comments_per_hour": 1.0,+ "active_hours": list(range(7, 24)),+ "response_delay_min": 1,+ "response_delay_max": 20,+ "sentiment_bias": 0.0,+ "stance": "neutral",+ "influence_weight": 1.0+ }++ agent_configs.append(config)++ return {+ "time_config": {+ "total_simulation_hours": 72,+ "minutes_per_round": 30,+ "agents_per_hour_min": max(1, len(entities) // 10),+ "agents_per_hour_max": max(5, len(entities) // 3),+ "peak_hours": [9, 10, 11, 14, 15, 20, 21, 22],+ "off_peak_hours": [0, 1, 2, 3, 4, 5]+ },+ "agent_configs": agent_configs,+ "event_config": {+ "initial_posts": [],+ "hot_topics": [],+ "narrative_direction": ""+ },+ "reasoning": "使用默认配置(LLM生成失败)"+ }++ def _build_parameters(+ self,+ simulation_id: str,+ project_id: str,+ graph_id: str,+ simulation_requirement: str,+ entities: List[EntityNode],+ llm_result: Dict[str, Any],+ enable_twitter: bool,+ enable_reddit: bool+ ) -> SimulationParameters:+ """根据LLM结果构建SimulationParameters对象"""++ # 时间配置+ time_cfg = llm_result.get("time_config", {})+ time_config = TimeSimulationConfig(+ total_simulation_hours=time_cfg.get("total_simulation_hours", 72),+ minutes_per_round=time_cfg.get("minutes_per_round", 30),+ agents_per_hour_min=time_cfg.get("agents_per_hour_min", 5),+ agents_per_hour_max=time_cfg.get("agents_per_hour_max", 20),+ peak_hours=time_cfg.get("peak_hours", [9, 10, 11, 14, 15, 20, 21, 22]),+ off_peak_hours=time_cfg.get("off_peak_hours", [0, 1, 2, 3, 4, 5]),+ peak_activity_multiplier=time_cfg.get("peak_activity_multiplier", 1.5),+ off_peak_activity_multiplier=time_cfg.get("off_peak_activity_multiplier", 0.3)+ )++ # Agent配置+ agent_configs = []+ llm_agent_configs = {cfg["agent_id"]: cfg for cfg in llm_result.get("agent_configs", [])}++ for i, entity in enumerate(entities):+ cfg = llm_agent_configs.get(i, {})++ agent_config = AgentActivityConfig(+ agent_id=i,+ entity_uuid=entity.uuid,+ entity_name=entity.name,+ entity_type=entity.get_entity_type() or "Unknown",+ activity_level=cfg.get("activity_level", 0.5),+ posts_per_hour=cfg.get("posts_per_hour", 0.5),+ comments_per_hour=cfg.get("comments_per_hour", 1.0),+ active_hours=cfg.get("active_hours", list(range(8, 23))),+ response_delay_min=cfg.get("response_delay_min", 5),+ response_delay_max=cfg.get("response_delay_max", 60),+ sentiment_bias=cfg.get("sentiment_bias", 0.0),+ stance=cfg.get("stance", "neutral"),+ influence_weight=cfg.get("influence_weight", 1.0)+ )+ agent_configs.append(agent_config)++ # 事件配置+ event_cfg = llm_result.get("event_config", {})+ event_config = EventConfig(+ initial_posts=event_cfg.get("initial_posts", []),+ scheduled_events=event_cfg.get("scheduled_events", []),+ hot_topics=event_cfg.get("hot_topics", []),+ narrative_direction=event_cfg.get("narrative_direction", "")+ )++ # 平台配置+ twitter_config = None+ reddit_config = None++ platform_cfgs = llm_result.get("platform_configs", {})++ if enable_twitter:+ tw_cfg = platform_cfgs.get("twitter", {})+ twitter_config = PlatformConfig(+ platform="twitter",+ recency_weight=tw_cfg.get("recency_weight", 0.4),+ popularity_weight=tw_cfg.get("popularity_weight", 0.3),+ relevance_weight=tw_cfg.get("relevance_weight", 0.3),+ viral_threshold=tw_cfg.get("viral_threshold", 10),+ echo_chamber_strength=tw_cfg.get("echo_chamber_strength", 0.5)+ )++ if enable_reddit:+ rd_cfg = platform_cfgs.get("reddit", {})+ reddit_config = PlatformConfig(+ platform="reddit",+ recency_weight=rd_cfg.get("recency_weight", 0.3),+ popularity_weight=rd_cfg.get("popularity_weight", 0.4),+ relevance_weight=rd_cfg.get("relevance_weight", 0.3),+ viral_threshold=rd_cfg.get("viral_threshold", 15),+ echo_chamber_strength=rd_cfg.get("echo_chamber_strength", 0.6)+ )++ return SimulationParameters(+ simulation_id=simulation_id,+ project_id=project_id,+ graph_id=graph_id,+ simulation_requirement=simulation_requirement,+ time_config=time_config,+ agent_configs=agent_configs,+ event_config=event_config,+ twitter_config=twitter_config,+ reddit_config=reddit_config,+ llm_model=self.model_name,+ llm_base_url=self.base_url,+ generation_reasoning=llm_result.get("reasoning", "")+ )++diff --git a/backend/app/services/simulation_manager.py b/backend/app/services/simulation_manager.pynew file mode 100644index 00000000..fbb42a6a--- /dev/null+++ b/backend/app/services/simulation_manager.py@@ -0,0 +1,546 @@+"""+OASIS模拟管理器+管理Twitter和Reddit双平台并行模拟+使用预设脚本 + LLM智能生成配置参数+"""++import os+import json+import shutil+from typing import Dict, Any, List, Optional+from dataclasses import dataclass, field+from datetime import datetime+from enum import Enum++from ..config import Config+from ..utils.logger import get_logger+from .zep_entity_reader import ZepEntityReader, FilteredEntities+from .oasis_profile_generator import OasisProfileGenerator, OasisAgentProfile+from .simulation_config_generator import SimulationConfigGenerator, SimulationParameters++logger = get_logger('mirofish.simulation')+++class SimulationStatus(str, Enum):+ """模拟状态"""+ CREATED = "created"+ PREPARING = "preparing"+ READY = "ready"+ RUNNING = "running"+ PAUSED = "paused"+ COMPLETED = "completed"+ FAILED = "failed"+++class PlatformType(str, Enum):+ """平台类型"""+ TWITTER = "twitter"+ REDDIT = "reddit"+++@dataclass+class SimulationState:+ """模拟状态"""+ simulation_id: str+ project_id: str+ graph_id: str++ # 平台启用状态+ enable_twitter: bool = True+ enable_reddit: bool = True++ # 状态+ status: SimulationStatus = SimulationStatus.CREATED++ # 准备阶段数据+ entities_count: int = 0+ profiles_count: int = 0+ entity_types: List[str] = field(default_factory=list)++ # 配置生成信息+ config_generated: bool = False+ config_reasoning: str = ""++ # 运行时数据+ current_round: int = 0+ twitter_status: str = "not_started"+ reddit_status: str = "not_started"++ # 时间戳+ created_at: str = field(default_factory=lambda: datetime.now().isoformat())+ updated_at: str = field(default_factory=lambda: datetime.now().isoformat())++ # 错误信息+ error: Optional[str] = None++ def to_dict(self) -> Dict[str, Any]:+ """完整状态字典(内部使用)"""+ return {+ "simulation_id": self.simulation_id,+ "project_id": self.project_id,+ "graph_id": self.graph_id,+ "enable_twitter": self.enable_twitter,+ "enable_reddit": self.enable_reddit,+ "status": self.status.value,+ "entities_count": self.entities_count,+ "profiles_count": self.profiles_count,+ "entity_types": self.entity_types,+ "config_generated": self.config_generated,+ "config_reasoning": self.config_reasoning,+ "current_round": self.current_round,+ "twitter_status": self.twitter_status,+ "reddit_status": self.reddit_status,+ "created_at": self.created_at,+ "updated_at": self.updated_at,+ "error": self.error,+ }++ def to_simple_dict(self) -> Dict[str, Any]:+ """简化状态字典(API返回使用)"""+ return {+ "simulation_id": self.simulation_id,+ "project_id": self.project_id,+ "graph_id": self.graph_id,+ "status": self.status.value,+ "entities_count": self.entities_count,+ "profiles_count": self.profiles_count,+ "entity_types": self.entity_types,+ "config_generated": self.config_generated,+ "error": self.error,+ }+++class SimulationManager:+ """+ 模拟管理器++ 核心功能:+ 1. 从Zep图谱读取实体并过滤+ 2. 生成OASIS Agent Profile+ 3. 使用LLM智能生成模拟配置参数+ 4. 准备预设脚本所需的所有文件+ """++ # 模拟数据存储目录+ SIMULATION_DATA_DIR = os.path.join(+ os.path.dirname(__file__),+ '../../uploads/simulations'+ )++ # 预设脚本目录+ SCRIPTS_DIR = os.path.join(+ os.path.dirname(__file__),+ '../../scripts'+ )++ def __init__(self):+ # 确保目录存在+ os.makedirs(self.SIMULATION_DATA_DIR, exist_ok=True)++ # 内存中的模拟状态缓存+ self._simulations: Dict[str, SimulationState] = {}++ def _get_simulation_dir(self, simulation_id: str) -> str:+ """获取模拟数据目录"""+ sim_dir = os.path.join(self.SIMULATION_DATA_DIR, simulation_id)+ os.makedirs(sim_dir, exist_ok=True)+ return sim_dir++ def _save_simulation_state(self, state: SimulationState):+ """保存模拟状态到文件"""+ sim_dir = self._get_simulation_dir(state.simulation_id)+ state_file = os.path.join(sim_dir, "state.json")++ state.updated_at = datetime.now().isoformat()++ with open(state_file, 'w', encoding='utf-8') as f:+ json.dump(state.to_dict(), f, ensure_ascii=False, indent=2)++ self._simulations[state.simulation_id] = state++ def _load_simulation_state(self, simulation_id: str) -> Optional[SimulationState]:+ """从文件加载模拟状态"""+ if simulation_id in self._simulations:+ return self._simulations[simulation_id]++ sim_dir = self._get_simulation_dir(simulation_id)+ state_file = os.path.join(sim_dir, "state.json")++ if not os.path.exists(state_file):+ return None++ with open(state_file, 'r', encoding='utf-8') as f:+ data = json.load(f)++ state = SimulationState(+ simulation_id=simulation_id,+ project_id=data.get("project_id", ""),+ graph_id=data.get("graph_id", ""),+ enable_twitter=data.get("enable_twitter", True),+ enable_reddit=data.get("enable_reddit", True),+ status=SimulationStatus(data.get("status", "created")),+ entities_count=data.get("entities_count", 0),+ profiles_count=data.get("profiles_count", 0),+ entity_types=data.get("entity_types", []),+ config_generated=data.get("config_generated", False),+ config_reasoning=data.get("config_reasoning", ""),+ current_round=data.get("current_round", 0),+ twitter_status=data.get("twitter_status", "not_started"),+ reddit_status=data.get("reddit_status", "not_started"),+ created_at=data.get("created_at", datetime.now().isoformat()),+ updated_at=data.get("updated_at", datetime.now().isoformat()),+ error=data.get("error"),+ )++ self._simulations[simulation_id] = state+ return state++ def create_simulation(+ self,+ project_id: str,+ graph_id: str,+ enable_twitter: bool = True,+ enable_reddit: bool = True,+ ) -> SimulationState:+ """+ 创建新的模拟++ Args:+ project_id: 项目ID+ graph_id: Zep图谱ID+ enable_twitter: 是否启用Twitter模拟+ enable_reddit: 是否启用Reddit模拟++ Returns:+ SimulationState+ """+ import uuid+ simulation_id = f"sim_{uuid.uuid4().hex[:12]}"++ state = SimulationState(+ simulation_id=simulation_id,+ project_id=project_id,+ graph_id=graph_id,+ enable_twitter=enable_twitter,+ enable_reddit=enable_reddit,+ status=SimulationStatus.CREATED,+ )++ self._save_simulation_state(state)+ logger.info(f"创建模拟: {simulation_id}, project={project_id}, graph={graph_id}")++ return state++ def prepare_simulation(+ self,+ simulation_id: str,+ simulation_requirement: str,+ document_text: str,+ defined_entity_types: Optional[List[str]] = None,+ use_llm_for_profiles: bool = True,+ progress_callback: Optional[callable] = None+ ) -> SimulationState:+ """+ 准备模拟环境(全程自动化)++ 步骤:+ 1. 从Zep图谱读取并过滤实体+ 2. 为每个实体生成OASIS Agent Profile(可选LLM增强)+ 3. 使用LLM智能生成模拟配置参数(时间、活跃度、发言频率等)+ 4. 保存配置文件和Profile文件+ 5. 复制预设脚本到模拟目录++ Args:+ simulation_id: 模拟ID+ simulation_requirement: 模拟需求描述(用于LLM生成配置)+ document_text: 原始文档内容(用于LLM理解背景)+ defined_entity_types: 预定义的实体类型(可选)+ use_llm_for_profiles: 是否使用LLM生成详细人设+ progress_callback: 进度回调函数 (stage, progress, message)++ Returns:+ SimulationState+ """+ state = self._load_simulation_state(simulation_id)+ if not state:+ raise ValueError(f"模拟不存在: {simulation_id}")++ try:+ state.status = SimulationStatus.PREPARING+ self._save_simulation_state(state)++ sim_dir = self._get_simulation_dir(simulation_id)++ # ========== 阶段1: 读取并过滤实体 ==========+ if progress_callback:+ progress_callback("reading", 0, "正在连接Zep图谱...")++ reader = ZepEntityReader()++ if progress_callback:+ progress_callback("reading", 30, "正在读取节点数据...")++ filtered = reader.filter_defined_entities(+ graph_id=state.graph_id,+ defined_entity_types=defined_entity_types,+ enrich_with_edges=True+ )++ state.entities_count = filtered.filtered_count+ state.entity_types = list(filtered.entity_types)++ if progress_callback:+ progress_callback(+ "reading", 100,+ f"完成,共 {filtered.filtered_count} 个实体",+ current=filtered.filtered_count,+ total=filtered.filtered_count+ )++ if filtered.filtered_count == 0:+ state.status = SimulationStatus.FAILED+ state.error = "没有找到符合条件的实体,请检查图谱是否正确构建"+ self._save_simulation_state(state)+ return state++ # ========== 阶段2: 生成Agent Profile ==========+ total_entities = len(filtered.entities)++ if progress_callback:+ progress_callback(+ "generating_profiles", 0,+ "开始生成...",+ current=0,+ total=total_entities+ )++ generator = OasisProfileGenerator()++ def profile_progress(current, total, msg):+ if progress_callback:+ progress_callback(+ "generating_profiles",+ int(current / total * 100),+ msg,+ current=current,+ total=total,+ item_name=msg+ )++ profiles = generator.generate_profiles_from_entities(+ entities=filtered.entities,+ use_llm=use_llm_for_profiles,+ progress_callback=profile_progress+ )++ state.profiles_count = len(profiles)++ # 保存Profile文件(注意:Twitter使用CSV格式,Reddit使用JSON格式)+ if progress_callback:+ progress_callback(+ "generating_profiles", 95,+ "保存Profile文件...",+ current=total_entities,+ total=total_entities+ )++ if state.enable_reddit:+ generator.save_profiles(+ profiles=profiles,+ file_path=os.path.join(sim_dir, "reddit_profiles.json"),+ platform="reddit"+ )++ if state.enable_twitter:+ # Twitter使用CSV格式!这是OASIS的要求+ generator.save_profiles(+ profiles=profiles,+ file_path=os.path.join(sim_dir, "twitter_profiles.csv"),+ platform="twitter"+ )++ if progress_callback:+ progress_callback(+ "generating_profiles", 100,+ f"完成,共 {len(profiles)} 个Profile",+ current=len(profiles),+ total=len(profiles)+ )++ # ========== 阶段3: LLM智能生成模拟配置 ==========+ if progress_callback:+ progress_callback(+ "generating_config", 0,+ "正在分析模拟需求...",+ current=0,+ total=3+ )++ config_generator = SimulationConfigGenerator()++ if progress_callback:+ progress_callback(+ "generating_config", 30,+ "正在调用LLM生成配置...",+ current=1,+ total=3+ )++ sim_params = config_generator.generate_config(+ simulation_id=simulation_id,+ project_id=state.project_id,+ graph_id=state.graph_id,+ simulation_requirement=simulation_requirement,+ document_text=document_text,+ entities=filtered.entities,+ enable_twitter=state.enable_twitter,+ enable_reddit=state.enable_reddit+ )++ if progress_callback:+ progress_callback(+ "generating_config", 70,+ "正在保存配置文件...",+ current=2,+ total=3+ )++ # 保存配置文件+ config_path = os.path.join(sim_dir, "simulation_config.json")+ with open(config_path, 'w', encoding='utf-8') as f:+ f.write(sim_params.to_json())++ state.config_generated = True+ state.config_reasoning = sim_params.generation_reasoning++ if progress_callback:+ progress_callback(+ "generating_config", 100,+ "配置生成完成",+ current=3,+ total=3+ )++ # ========== 阶段4: 复制预设脚本 ==========+ script_files = ["run_twitter_simulation.py", "run_reddit_simulation.py",+ "run_parallel_simulation.py", "action_logger.py"]++ if progress_callback:+ progress_callback(+ "copying_scripts", 0,+ "开始准备脚本...",+ current=0,+ total=len(script_files)+ )++ self._copy_preset_scripts(sim_dir)++ if progress_callback:+ progress_callback(+ "copying_scripts", 100,+ f"完成,共 {len(script_files)} 个脚本",+ current=len(script_files),+ total=len(script_files)+ )++ # 更新状态+ state.status = SimulationStatus.READY+ self._save_simulation_state(state)++ logger.info(f"模拟准备完成: {simulation_id}, "+ f"entities={state.entities_count}, profiles={state.profiles_count}")++ return state++ except Exception as e:+ logger.error(f"模拟准备失败: {simulation_id}, error={str(e)}")+ import traceback+ logger.error(traceback.format_exc())+ state.status = SimulationStatus.FAILED+ state.error = str(e)+ self._save_simulation_state(state)+ raise++ def _copy_preset_scripts(self, sim_dir: str):+ """复制预设脚本到模拟目录"""+ scripts = [+ "run_twitter_simulation.py",+ "run_reddit_simulation.py",+ "run_parallel_simulation.py"+ ]++ for script in scripts:+ src = os.path.join(self.SCRIPTS_DIR, script)+ dst = os.path.join(sim_dir, script)++ if os.path.exists(src):+ shutil.copy2(src, dst)+ logger.debug(f"复制脚本: {script}")+ else:+ logger.warning(f"预设脚本不存在: {src}")++ def get_simulation(self, simulation_id: str) -> Optional[SimulationState]:+ """获取模拟状态"""+ return self._load_simulation_state(simulation_id)++ def list_simulations(self, project_id: Optional[str] = None) -> List[SimulationState]:+ """列出所有模拟"""+ simulations = []++ if os.path.exists(self.SIMULATION_DATA_DIR):+ for sim_id in os.listdir(self.SIMULATION_DATA_DIR):+ state = self._load_simulation_state(sim_id)+ if state:+ if project_id is None or state.project_id == project_id:+ simulations.append(state)++ return simulations++ def get_profiles(self, simulation_id: str, platform: str = "reddit") -> List[Dict[str, Any]]:+ """获取模拟的Agent Profile"""+ state = self._load_simulation_state(simulation_id)+ if not state:+ raise ValueError(f"模拟不存在: {simulation_id}")++ sim_dir = self._get_simulation_dir(simulation_id)+ profile_path = os.path.join(sim_dir, f"{platform}_profiles.json")++ if not os.path.exists(profile_path):+ return []++ with open(profile_path, 'r', encoding='utf-8') as f:+ return json.load(f)++ def get_simulation_config(self, simulation_id: str) -> Optional[Dict[str, Any]]:+ """获取模拟配置"""+ sim_dir = self._get_simulation_dir(simulation_id)+ config_path = os.path.join(sim_dir, "simulation_config.json")++ if not os.path.exists(config_path):+ return None++ with open(config_path, 'r', encoding='utf-8') as f:+ return json.load(f)++ def get_run_instructions(self, simulation_id: str) -> Dict[str, str]:+ """获取运行说明"""+ sim_dir = self._get_simulation_dir(simulation_id)+ config_path = os.path.join(sim_dir, "simulation_config.json")++ return {+ "simulation_dir": sim_dir,+ "config_file": config_path,+ "commands": {+ "twitter": f"python run_twitter_simulation.py --config simulation_config.json",+ "reddit": f"python run_reddit_simulation.py --config simulation_config.json",+ "parallel": f"python run_parallel_simulation.py --config simulation_config.json",+ },+ "instructions": (+ f"1. 进入模拟目录: cd {sim_dir}\n"+ f"2. 激活conda环境: conda activate MiroFish\n"+ f"3. 运行模拟:\n"+ f" - 单独运行Twitter: python run_twitter_simulation.py --config simulation_config.json\n"+ f" - 单独运行Reddit: python run_reddit_simulation.py --config simulation_config.json\n"+ f" - 并行运行双平台: python run_parallel_simulation.py --config simulation_config.json"+ )+ }diff --git a/backend/app/services/simulation_runner.py b/backend/app/services/simulation_runner.pynew file mode 100644index 00000000..68d4b418--- /dev/null+++ b/backend/app/services/simulation_runner.py@@ -0,0 +1,670 @@+"""+OASIS模拟运行器+在后台运行模拟并记录每个Agent的动作,支持实时状态监控+"""++import os+import sys+import json+import time+import asyncio+import threading+import subprocess+from typing import Dict, Any, List, Optional+from dataclasses import dataclass, field+from datetime import datetime+from enum import Enum+from queue import Queue++from ..config import Config+from ..utils.logger import get_logger++logger = get_logger('mirofish.simulation_runner')+++class RunnerStatus(str, Enum):+ """运行器状态"""+ IDLE = "idle"+ STARTING = "starting"+ RUNNING = "running"+ PAUSED = "paused"+ STOPPING = "stopping"+ STOPPED = "stopped"+ COMPLETED = "completed"+ FAILED = "failed"+++@dataclass+class AgentAction:+ """Agent动作记录"""+ round_num: int+ timestamp: str+ platform: str # twitter / reddit+ agent_id: int+ agent_name: str+ action_type: str # CREATE_POST, LIKE_POST, etc.+ action_args: Dict[str, Any] = field(default_factory=dict)+ result: Optional[str] = None+ success: bool = True++ def to_dict(self) -> Dict[str, Any]:+ return {+ "round_num": self.round_num,+ "timestamp": self.timestamp,+ "platform": self.platform,+ "agent_id": self.agent_id,+ "agent_name": self.agent_name,+ "action_type": self.action_type,+ "action_args": self.action_args,+ "result": self.result,+ "success": self.success,+ }+++@dataclass+class RoundSummary:+ """每轮摘要"""+ round_num: int+ start_time: str+ end_time: Optional[str] = None+ simulated_hour: int = 0+ twitter_actions: int = 0+ reddit_actions: int = 0+ active_agents: List[int] = field(default_factory=list)+ actions: List[AgentAction] = field(default_factory=list)++ def to_dict(self) -> Dict[str, Any]:+ return {+ "round_num": self.round_num,+ "start_time": self.start_time,+ "end_time": self.end_time,+ "simulated_hour": self.simulated_hour,+ "twitter_actions": self.twitter_actions,+ "reddit_actions": self.reddit_actions,+ "active_agents": self.active_agents,+ "actions_count": len(self.actions),+ "actions": [a.to_dict() for a in self.actions],+ }+++@dataclass+class SimulationRunState:+ """模拟运行状态(实时)"""+ simulation_id: str+ runner_status: RunnerStatus = RunnerStatus.IDLE++ # 进度信息+ current_round: int = 0+ total_rounds: int = 0+ simulated_hours: int = 0+ total_simulation_hours: int = 0++ # 平台状态+ twitter_running: bool = False+ reddit_running: bool = False+ twitter_actions_count: int = 0+ reddit_actions_count: int = 0++ # 每轮摘要+ rounds: List[RoundSummary] = field(default_factory=list)++ # 最近动作(用于前端实时展示)+ recent_actions: List[AgentAction] = field(default_factory=list)+ max_recent_actions: int = 50++ # 时间戳+ started_at: Optional[str] = None+ updated_at: str = field(default_factory=lambda: datetime.now().isoformat())+ completed_at: Optional[str] = None++ # 错误信息+ error: Optional[str] = None++ # 进程ID(用于停止)+ process_pid: Optional[int] = None++ def add_action(self, action: AgentAction):+ """添加动作到最近动作列表"""+ self.recent_actions.insert(0, action)+ if len(self.recent_actions) > self.max_recent_actions:+ self.recent_actions = self.recent_actions[:self.max_recent_actions]++ if action.platform == "twitter":+ self.twitter_actions_count += 1+ else:+ self.reddit_actions_count += 1++ self.updated_at = datetime.now().isoformat()++ def to_dict(self) -> Dict[str, Any]:+ return {+ "simulation_id": self.simulation_id,+ "runner_status": self.runner_status.value,+ "current_round": self.current_round,+ "total_rounds": self.total_rounds,+ "simulated_hours": self.simulated_hours,+ "total_simulation_hours": self.total_simulation_hours,+ "progress_percent": round(self.current_round / max(self.total_rounds, 1) * 100, 1),+ "twitter_running": self.twitter_running,+ "reddit_running": self.reddit_running,+ "twitter_actions_count": self.twitter_actions_count,+ "reddit_actions_count": self.reddit_actions_count,+ "total_actions_count": self.twitter_actions_count + self.reddit_actions_count,+ "started_at": self.started_at,+ "updated_at": self.updated_at,+ "completed_at": self.completed_at,+ "error": self.error,+ "process_pid": self.process_pid,+ }++ def to_detail_dict(self) -> Dict[str, Any]:+ """包含最近动作的详细信息"""+ result = self.to_dict()+ result["recent_actions"] = [a.to_dict() for a in self.recent_actions]+ result["rounds_count"] = len(self.rounds)+ return result+++class SimulationRunner:+ """+ 模拟运行器++ 负责:+ 1. 在后台进程中运行OASIS模拟+ 2. 解析运行日志,记录每个Agent的动作+ 3. 提供实时状态查询接口+ 4. 支持暂停/停止/恢复操作+ """++ # 运行状态存储目录+ RUN_STATE_DIR = os.path.join(+ os.path.dirname(__file__),+ '../../uploads/simulations'+ )++ # 内存中的运行状态+ _run_states: Dict[str, SimulationRunState] = {}+ _processes: Dict[str, subprocess.Popen] = {}+ _action_queues: Dict[str, Queue] = {}+ _monitor_threads: Dict[str, threading.Thread] = {}++ @classmethod+ def get_run_state(cls, simulation_id: str) -> Optional[SimulationRunState]:+ """获取运行状态"""+ if simulation_id in cls._run_states:+ return cls._run_states[simulation_id]++ # 尝试从文件加载+ state = cls._load_run_state(simulation_id)+ if state:+ cls._run_states[simulation_id] = state+ return state++ @classmethod+ def _load_run_state(cls, simulation_id: str) -> Optional[SimulationRunState]:+ """从文件加载运行状态"""+ state_file = os.path.join(cls.RUN_STATE_DIR, simulation_id, "run_state.json")+ if not os.path.exists(state_file):+ return None++ try:+ with open(state_file, 'r', encoding='utf-8') as f:+ data = json.load(f)++ state = SimulationRunState(+ simulation_id=simulation_id,+ runner_status=RunnerStatus(data.get("runner_status", "idle")),+ current_round=data.get("current_round", 0),+ total_rounds=data.get("total_rounds", 0),+ simulated_hours=data.get("simulated_hours", 0),+ total_simulation_hours=data.get("total_simulation_hours", 0),+ twitter_running=data.get("twitter_running", False),+ reddit_running=data.get("reddit_running", False),+ twitter_actions_count=data.get("twitter_actions_count", 0),+ reddit_actions_count=data.get("reddit_actions_count", 0),+ started_at=data.get("started_at"),+ updated_at=data.get("updated_at", datetime.now().isoformat()),+ completed_at=data.get("completed_at"),+ error=data.get("error"),+ process_pid=data.get("process_pid"),+ )++ # 加载最近动作+ actions_data = data.get("recent_actions", [])+ for a in actions_data:+ state.recent_actions.append(AgentAction(+ round_num=a.get("round_num", 0),+ timestamp=a.get("timestamp", ""),+ platform=a.get("platform", ""),+ agent_id=a.get("agent_id", 0),+ agent_name=a.get("agent_name", ""),+ action_type=a.get("action_type", ""),+ action_args=a.get("action_args", {}),+ result=a.get("result"),+ success=a.get("success", True),+ ))++ return state+ except Exception as e:+ logger.error(f"加载运行状态失败: {str(e)}")+ return None++ @classmethod+ def _save_run_state(cls, state: SimulationRunState):+ """保存运行状态到文件"""+ sim_dir = os.path.join(cls.RUN_STATE_DIR, state.simulation_id)+ os.makedirs(sim_dir, exist_ok=True)+ state_file = os.path.join(sim_dir, "run_state.json")++ data = state.to_detail_dict()++ with open(state_file, 'w', encoding='utf-8') as f:+ json.dump(data, f, ensure_ascii=False, indent=2)++ cls._run_states[state.simulation_id] = state++ @classmethod+ def start_simulation(+ cls,+ simulation_id: str,+ platform: str = "parallel" # twitter / reddit / parallel+ ) -> SimulationRunState:+ """+ 启动模拟++ Args:+ simulation_id: 模拟ID+ platform: 运行平台 (twitter/reddit/parallel)++ Returns:+ SimulationRunState+ """+ # 检查是否已在运行+ existing = cls.get_run_state(simulation_id)+ if existing and existing.runner_status in [RunnerStatus.RUNNING, RunnerStatus.STARTING]:+ raise ValueError(f"模拟已在运行中: {simulation_id}")++ # 加载模拟配置+ sim_dir = os.path.join(cls.RUN_STATE_DIR, simulation_id)+ config_path = os.path.join(sim_dir, "simulation_config.json")++ if not os.path.exists(config_path):+ raise ValueError(f"模拟配置不存在,请先调用 /prepare 接口")++ with open(config_path, 'r', encoding='utf-8') as f:+ config = json.load(f)++ # 初始化运行状态+ time_config = config.get("time_config", {})+ total_hours = time_config.get("total_simulation_hours", 72)+ minutes_per_round = time_config.get("minutes_per_round", 30)+ total_rounds = int(total_hours * 60 / minutes_per_round)++ state = SimulationRunState(+ simulation_id=simulation_id,+ runner_status=RunnerStatus.STARTING,+ total_rounds=total_rounds,+ total_simulation_hours=total_hours,+ started_at=datetime.now().isoformat(),+ )++ cls._save_run_state(state)++ # 确定运行哪个脚本+ if platform == "twitter":+ script_name = "run_twitter_simulation.py"+ state.twitter_running = True+ elif platform == "reddit":+ script_name = "run_reddit_simulation.py"+ state.reddit_running = True+ else:+ script_name = "run_parallel_simulation.py"+ state.twitter_running = True+ state.reddit_running = True++ script_path = os.path.join(sim_dir, script_name)++ if not os.path.exists(script_path):+ raise ValueError(f"脚本不存在: {script_path}")++ # 创建动作队列+ action_queue = Queue()+ cls._action_queues[simulation_id] = action_queue++ # 启动模拟进程+ try:+ # 构建运行命令+ cmd = [+ sys.executable, # Python解释器+ script_path,+ "--config", "simulation_config.json",+ "--action-log", "actions.jsonl", # 动作日志文件+ ]++ # 设置工作目录为模拟目录+ process = subprocess.Popen(+ cmd,+ cwd=sim_dir,+ stdout=subprocess.PIPE,+ stderr=subprocess.PIPE,+ text=True,+ bufsize=1,+ )++ state.process_pid = process.pid+ state.runner_status = RunnerStatus.RUNNING+ cls._processes[simulation_id] = process+ cls._save_run_state(state)++ # 启动监控线程+ monitor_thread = threading.Thread(+ target=cls._monitor_simulation,+ args=(simulation_id,),+ daemon=True+ )+ monitor_thread.start()+ cls._monitor_threads[simulation_id] = monitor_thread++ logger.info(f"模拟启动成功: {simulation_id}, pid={process.pid}, platform={platform}")++ except Exception as e:+ state.runner_status = RunnerStatus.FAILED+ state.error = str(e)+ cls._save_run_state(state)+ raise++ return state++ @classmethod+ def _monitor_simulation(cls, simulation_id: str):+ """监控模拟进程,解析动作日志"""+ sim_dir = os.path.join(cls.RUN_STATE_DIR, simulation_id)+ actions_log = os.path.join(sim_dir, "actions.jsonl")++ process = cls._processes.get(simulation_id)+ state = cls.get_run_state(simulation_id)++ if not process or not state:+ return++ last_position = 0++ try:+ while process.poll() is None: # 进程仍在运行+ # 读取动作日志+ if os.path.exists(actions_log):+ with open(actions_log, 'r', encoding='utf-8') as f:+ f.seek(last_position)+ for line in f:+ line = line.strip()+ if line:+ try:+ action_data = json.loads(line)+ action = AgentAction(+ round_num=action_data.get("round", 0),+ timestamp=action_data.get("timestamp", datetime.now().isoformat()),+ platform=action_data.get("platform", "unknown"),+ agent_id=action_data.get("agent_id", 0),+ agent_name=action_data.get("agent_name", ""),+ action_type=action_data.get("action_type", ""),+ action_args=action_data.get("action_args", {}),+ result=action_data.get("result"),+ success=action_data.get("success", True),+ )+ state.add_action(action)++ # 更新轮次+ if action.round_num > state.current_round:+ state.current_round = action.round_num++ except json.JSONDecodeError:+ pass+ last_position = f.tell()++ # 定期保存状态+ cls._save_run_state(state)+ time.sleep(1) # 每秒检查一次++ # 进程结束+ exit_code = process.returncode++ if exit_code == 0:+ state.runner_status = RunnerStatus.COMPLETED+ state.completed_at = datetime.now().isoformat()+ logger.info(f"模拟完成: {simulation_id}")+ else:+ state.runner_status = RunnerStatus.FAILED+ stderr = process.stderr.read() if process.stderr else ""+ state.error = f"进程退出码: {exit_code}, 错误: {stderr[:500]}"+ logger.error(f"模拟失败: {simulation_id}, error={state.error}")++ state.twitter_running = False+ state.reddit_running = False+ cls._save_run_state(state)++ except Exception as e:+ logger.error(f"监控线程异常: {simulation_id}, error={str(e)}")+ state.runner_status = RunnerStatus.FAILED+ state.error = str(e)+ cls._save_run_state(state)++ finally:+ # 清理+ cls._processes.pop(simulation_id, None)+ cls._action_queues.pop(simulation_id, None)++ @classmethod+ def stop_simulation(cls, simulation_id: str) -> SimulationRunState:+ """停止模拟"""+ state = cls.get_run_state(simulation_id)+ if not state:+ raise ValueError(f"模拟不存在: {simulation_id}")++ if state.runner_status not in [RunnerStatus.RUNNING, RunnerStatus.PAUSED]:+ raise ValueError(f"模拟未在运行: {simulation_id}, status={state.runner_status}")++ state.runner_status = RunnerStatus.STOPPING+ cls._save_run_state(state)++ # 终止进程+ process = cls._processes.get(simulation_id)+ if process:+ process.terminate()+ try:+ process.wait(timeout=10)+ except subprocess.TimeoutExpired:+ process.kill()++ state.runner_status = RunnerStatus.STOPPED+ state.twitter_running = False+ state.reddit_running = False+ state.completed_at = datetime.now().isoformat()+ cls._save_run_state(state)++ logger.info(f"模拟已停止: {simulation_id}")+ return state++ @classmethod+ def get_actions(+ cls,+ simulation_id: str,+ limit: int = 100,+ offset: int = 0,+ platform: Optional[str] = None,+ agent_id: Optional[int] = None,+ round_num: Optional[int] = None+ ) -> List[AgentAction]:+ """+ 获取动作历史++ Args:+ simulation_id: 模拟ID+ limit: 返回数量限制+ offset: 偏移量+ platform: 过滤平台+ agent_id: 过滤Agent+ round_num: 过滤轮次++ Returns:+ 动作列表+ """+ sim_dir = os.path.join(cls.RUN_STATE_DIR, simulation_id)+ actions_log = os.path.join(sim_dir, "actions.jsonl")++ if not os.path.exists(actions_log):+ return []++ actions = []++ with open(actions_log, 'r', encoding='utf-8') as f:+ for line in f:+ line = line.strip()+ if not line:+ continue++ try:+ data = json.loads(line)++ # 过滤+ if platform and data.get("platform") != platform:+ continue+ if agent_id is not None and data.get("agent_id") != agent_id:+ continue+ if round_num is not None and data.get("round") != round_num:+ continue++ actions.append(AgentAction(+ round_num=data.get("round", 0),+ timestamp=data.get("timestamp", ""),+ platform=data.get("platform", ""),+ agent_id=data.get("agent_id", 0),+ agent_name=data.get("agent_name", ""),+ action_type=data.get("action_type", ""),+ action_args=data.get("action_args", {}),+ result=data.get("result"),+ success=data.get("success", True),+ ))++ except json.JSONDecodeError:+ continue++ # 按时间倒序排列+ actions.reverse()++ # 分页+ return actions[offset:offset + limit]++ @classmethod+ def get_timeline(+ cls,+ simulation_id: str,+ start_round: int = 0,+ end_round: Optional[int] = None+ ) -> List[Dict[str, Any]]:+ """+ 获取模拟时间线(按轮次汇总)++ Args:+ simulation_id: 模拟ID+ start_round: 起始轮次+ end_round: 结束轮次++ Returns:+ 每轮的汇总信息+ """+ actions = cls.get_actions(simulation_id, limit=10000)++ # 按轮次分组+ rounds: Dict[int, Dict[str, Any]] = {}++ for action in actions:+ round_num = action.round_num++ if round_num < start_round:+ continue+ if end_round is not None and round_num > end_round:+ continue++ if round_num not in rounds:+ rounds[round_num] = {+ "round_num": round_num,+ "twitter_actions": 0,+ "reddit_actions": 0,+ "active_agents": set(),+ "action_types": {},+ "first_action_time": action.timestamp,+ "last_action_time": action.timestamp,+ }++ r = rounds[round_num]++ if action.platform == "twitter":+ r["twitter_actions"] += 1+ else:+ r["reddit_actions"] += 1++ r["active_agents"].add(action.agent_id)+ r["action_types"][action.action_type] = r["action_types"].get(action.action_type, 0) + 1+ r["last_action_time"] = action.timestamp++ # 转换为列表+ result = []+ for round_num in sorted(rounds.keys()):+ r = rounds[round_num]+ result.append({+ "round_num": round_num,+ "twitter_actions": r["twitter_actions"],+ "reddit_actions": r["reddit_actions"],+ "total_actions": r["twitter_actions"] + r["reddit_actions"],+ "active_agents_count": len(r["active_agents"]),+ "active_agents": list(r["active_agents"]),+ "action_types": r["action_types"],+ "first_action_time": r["first_action_time"],+ "last_action_time": r["last_action_time"],+ })++ return result++ @classmethod+ def get_agent_stats(cls, simulation_id: str) -> List[Dict[str, Any]]:+ """+ 获取每个Agent的统计信息++ Returns:+ Agent统计列表+ """+ actions = cls.get_actions(simulation_id, limit=10000)++ agent_stats: Dict[int, Dict[str, Any]] = {}++ for action in actions:+ agent_id = action.agent_id++ if agent_id not in agent_stats:+ agent_stats[agent_id] = {+ "agent_id": agent_id,+ "agent_name": action.agent_name,+ "total_actions": 0,+ "twitter_actions": 0,+ "reddit_actions": 0,+ "action_types": {},+ "first_action_time": action.timestamp,+ "last_action_time": action.timestamp,+ }++ stats = agent_stats[agent_id]+ stats["total_actions"] += 1++ if action.platform == "twitter":+ stats["twitter_actions"] += 1+ else:+ stats["reddit_actions"] += 1++ stats["action_types"][action.action_type] = stats["action_types"].get(action.action_type, 0) + 1+ stats["last_action_time"] = action.timestamp++ # 按总动作数排序+ result = sorted(agent_stats.values(), key=lambda x: x["total_actions"], reverse=True)++ return result+diff --git a/backend/app/services/zep_entity_reader.py b/backend/app/services/zep_entity_reader.pynew file mode 100644index 00000000..b2a3a3b9--- /dev/null+++ b/backend/app/services/zep_entity_reader.py@@ -0,0 +1,386 @@+"""+Zep实体读取与过滤服务+从Zep图谱中读取节点,筛选出符合预定义实体类型的节点+"""++from typing import Dict, Any, List, Optional, Set+from dataclasses import dataclass, field++from zep_cloud.client import Zep++from ..config import Config+from ..utils.logger import get_logger++logger = get_logger('mirofish.zep_entity_reader')+++@dataclass+class EntityNode:+ """实体节点数据结构"""+ uuid: str+ name: str+ labels: List[str]+ summary: str+ attributes: Dict[str, Any]+ # 相关的边信息+ related_edges: List[Dict[str, Any]] = field(default_factory=list)+ # 相关的其他节点信息+ related_nodes: List[Dict[str, Any]] = field(default_factory=list)++ def to_dict(self) -> Dict[str, Any]:+ return {+ "uuid": self.uuid,+ "name": self.name,+ "labels": self.labels,+ "summary": self.summary,+ "attributes": self.attributes,+ "related_edges": self.related_edges,+ "related_nodes": self.related_nodes,+ }++ def get_entity_type(self) -> Optional[str]:+ """获取实体类型(排除默认的Entity标签)"""+ for label in self.labels:+ if label not in ["Entity", "Node"]:+ return label+ return None+++@dataclass+class FilteredEntities:+ """过滤后的实体集合"""+ entities: List[EntityNode]+ entity_types: Set[str]+ total_count: int+ filtered_count: int++ def to_dict(self) -> Dict[str, Any]:+ return {+ "entities": [e.to_dict() for e in self.entities],+ "entity_types": list(self.entity_types),+ "total_count": self.total_count,+ "filtered_count": self.filtered_count,+ }+++class ZepEntityReader:+ """+ Zep实体读取与过滤服务++ 主要功能:+ 1. 从Zep图谱读取所有节点+ 2. 筛选出符合预定义实体类型的节点(Labels不只是Entity的节点)+ 3. 获取每个实体的相关边和关联节点信息+ """++ 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)++ def get_all_nodes(self, graph_id: str) -> List[Dict[str, Any]]:+ """+ 获取图谱的所有节点++ Args:+ graph_id: 图谱ID++ Returns:+ 节点列表+ """+ logger.info(f"获取图谱 {graph_id} 的所有节点...")++ nodes = self.client.graph.node.get_by_graph_id(graph_id=graph_id)++ nodes_data = []+ for node in nodes:+ nodes_data.append({+ "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(nodes_data)} 个节点")+ return nodes_data++ def get_all_edges(self, graph_id: str) -> List[Dict[str, Any]]:+ """+ 获取图谱的所有边++ Args:+ graph_id: 图谱ID++ Returns:+ 边列表+ """+ logger.info(f"获取图谱 {graph_id} 的所有边...")++ edges = self.client.graph.edge.get_by_graph_id(graph_id=graph_id)++ edges_data = []+ for edge in edges:+ edges_data.append({+ "uuid": getattr(edge, 'uuid_', None) or getattr(edge, 'uuid', ''),+ "name": edge.name or "",+ "fact": edge.fact or "",+ "source_node_uuid": edge.source_node_uuid,+ "target_node_uuid": edge.target_node_uuid,+ "attributes": edge.attributes or {},+ })++ logger.info(f"共获取 {len(edges_data)} 条边")+ return edges_data++ def get_node_edges(self, node_uuid: str) -> List[Dict[str, Any]]:+ """+ 获取指定节点的所有相关边++ Args:+ node_uuid: 节点UUID++ Returns:+ 边列表+ """+ try:+ edges = self.client.graph.node.get_entity_edges(node_uuid=node_uuid)++ edges_data = []+ for edge in edges:+ edges_data.append({+ "uuid": getattr(edge, 'uuid_', None) or getattr(edge, 'uuid', ''),+ "name": edge.name or "",+ "fact": edge.fact or "",+ "source_node_uuid": edge.source_node_uuid,+ "target_node_uuid": edge.target_node_uuid,+ "attributes": edge.attributes or {},+ })++ return edges_data+ except Exception as e:+ logger.warning(f"获取节点 {node_uuid} 的边失败: {str(e)}")+ return []++ def filter_defined_entities(+ self,+ graph_id: str,+ defined_entity_types: Optional[List[str]] = None,+ enrich_with_edges: bool = True+ ) -> FilteredEntities:+ """+ 筛选出符合预定义实体类型的节点++ 筛选逻辑:+ - 如果节点的Labels只有一个"Entity",说明这个实体不符合我们预定义的类型,跳过+ - 如果节点的Labels包含除"Entity"和"Node"之外的标签,说明符合预定义类型,保留++ Args:+ graph_id: 图谱ID+ defined_entity_types: 预定义的实体类型列表(可选,如果提供则只保留这些类型)+ enrich_with_edges: 是否获取每个实体的相关边信息++ Returns:+ FilteredEntities: 过滤后的实体集合+ """+ logger.info(f"开始筛选图谱 {graph_id} 的实体...")++ # 获取所有节点+ all_nodes = self.get_all_nodes(graph_id)+ total_count = len(all_nodes)++ # 获取所有边(用于后续关联查找)+ all_edges = self.get_all_edges(graph_id) if enrich_with_edges else []++ # 构建节点UUID到节点数据的映射+ node_map = {n["uuid"]: n for n in all_nodes}++ # 筛选符合条件的实体+ filtered_entities = []+ entity_types_found = set()++ for node in all_nodes:+ labels = node.get("labels", [])++ # 筛选逻辑:Labels必须包含除"Entity"和"Node"之外的标签+ custom_labels = [l for l in labels if l not in ["Entity", "Node"]]++ if not custom_labels:+ # 只有默认标签,跳过+ continue++ # 如果指定了预定义类型,检查是否匹配+ if defined_entity_types:+ matching_labels = [l for l in custom_labels if l in defined_entity_types]+ if not matching_labels:+ continue+ entity_type = matching_labels[0]+ else:+ entity_type = custom_labels[0]++ entity_types_found.add(entity_type)++ # 创建实体节点对象+ entity = EntityNode(+ uuid=node["uuid"],+ name=node["name"],+ labels=labels,+ summary=node["summary"],+ attributes=node["attributes"],+ )++ # 获取相关边和节点+ if enrich_with_edges:+ related_edges = []+ related_node_uuids = set()++ for edge in all_edges:+ if edge["source_node_uuid"] == node["uuid"]:+ related_edges.append({+ "direction": "outgoing",+ "edge_name": edge["name"],+ "fact": edge["fact"],+ "target_node_uuid": edge["target_node_uuid"],+ })+ related_node_uuids.add(edge["target_node_uuid"])+ elif edge["target_node_uuid"] == node["uuid"]:+ related_edges.append({+ "direction": "incoming",+ "edge_name": edge["name"],+ "fact": edge["fact"],+ "source_node_uuid": edge["source_node_uuid"],+ })+ related_node_uuids.add(edge["source_node_uuid"])++ entity.related_edges = related_edges++ # 获取关联节点的基本信息+ related_nodes = []+ for related_uuid in related_node_uuids:+ if related_uuid in node_map:+ related_node = node_map[related_uuid]+ related_nodes.append({+ "uuid": related_node["uuid"],+ "name": related_node["name"],+ "labels": related_node["labels"],+ "summary": related_node.get("summary", ""),+ })++ entity.related_nodes = related_nodes++ filtered_entities.append(entity)++ logger.info(f"筛选完成: 总节点 {total_count}, 符合条件 {len(filtered_entities)}, "+ f"实体类型: {entity_types_found}")++ return FilteredEntities(+ entities=filtered_entities,+ entity_types=entity_types_found,+ total_count=total_count,+ filtered_count=len(filtered_entities),+ )++ def get_entity_with_context(+ self,+ graph_id: str,+ entity_uuid: str+ ) -> Optional[EntityNode]:+ """+ 获取单个实体及其完整上下文(边和关联节点)++ Args:+ graph_id: 图谱ID+ entity_uuid: 实体UUID++ Returns:+ EntityNode或None+ """+ try:+ # 获取节点+ node = self.client.graph.node.get(uuid_=entity_uuid)++ if not node:+ return None++ # 获取节点的边+ edges = self.get_node_edges(entity_uuid)++ # 获取所有节点用于关联查找+ all_nodes = self.get_all_nodes(graph_id)+ node_map = {n["uuid"]: n for n in all_nodes}++ # 处理相关边和节点+ related_edges = []+ related_node_uuids = set()++ for edge in edges:+ if edge["source_node_uuid"] == entity_uuid:+ related_edges.append({+ "direction": "outgoing",+ "edge_name": edge["name"],+ "fact": edge["fact"],+ "target_node_uuid": edge["target_node_uuid"],+ })+ related_node_uuids.add(edge["target_node_uuid"])+ else:+ related_edges.append({+ "direction": "incoming",+ "edge_name": edge["name"],+ "fact": edge["fact"],+ "source_node_uuid": edge["source_node_uuid"],+ })+ related_node_uuids.add(edge["source_node_uuid"])++ # 获取关联节点信息+ related_nodes = []+ for related_uuid in related_node_uuids:+ if related_uuid in node_map:+ related_node = node_map[related_uuid]+ related_nodes.append({+ "uuid": related_node["uuid"],+ "name": related_node["name"],+ "labels": related_node["labels"],+ "summary": related_node.get("summary", ""),+ })++ return EntityNode(+ 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 {},+ related_edges=related_edges,+ related_nodes=related_nodes,+ )++ except Exception as e:+ logger.error(f"获取实体 {entity_uuid} 失败: {str(e)}")+ return None++ def get_entities_by_type(+ self,+ graph_id: str,+ entity_type: str,+ enrich_with_edges: bool = True+ ) -> List[EntityNode]:+ """+ 获取指定类型的所有实体++ Args:+ graph_id: 图谱ID+ entity_type: 实体类型(如 "Student", "PublicFigure" 等)+ enrich_with_edges: 是否获取相关边信息++ Returns:+ 实体列表+ """+ result = self.filter_defined_entities(+ graph_id=graph_id,+ defined_entity_types=[entity_type],+ enrich_with_edges=enrich_with_edges+ )+ return result.entities++diff --git a/backend/app/utils/retry.py b/backend/app/utils/retry.pynew file mode 100644index 00000000..819b1cfc--- /dev/null+++ b/backend/app/utils/retry.py@@ -0,0 +1,238 @@+"""+API调用重试机制+用于处理LLM等外部API调用的重试逻辑+"""++import time+import random+import functools+from typing import Callable, Any, Optional, Type, Tuple+from ..utils.logger import get_logger++logger = get_logger('mirofish.retry')+++def retry_with_backoff(+ max_retries: int = 3,+ initial_delay: float = 1.0,+ max_delay: float = 30.0,+ backoff_factor: float = 2.0,+ jitter: bool = True,+ exceptions: Tuple[Type[Exception], ...] = (Exception,),+ on_retry: Optional[Callable[[Exception, int], None]] = None+):+ """+ 带指数退避的重试装饰器++ Args:+ max_retries: 最大重试次数+ initial_delay: 初始延迟(秒)+ max_delay: 最大延迟(秒)+ backoff_factor: 退避因子+ jitter: 是否添加随机抖动+ exceptions: 需要重试的异常类型+ on_retry: 重试时的回调函数 (exception, retry_count)++ Usage:+ @retry_with_backoff(max_retries=3)+ def call_llm_api():+ ...+ """+ def decorator(func: Callable) -> Callable:+ @functools.wraps(func)+ def wrapper(*args, **kwargs) -> Any:+ last_exception = None+ delay = initial_delay++ for attempt in range(max_retries + 1):+ try:+ return func(*args, **kwargs)++ except exceptions as e:+ last_exception = e++ if attempt == max_retries:+ logger.error(f"函数 {func.__name__} 在 {max_retries} 次重试后仍失败: {str(e)}")+ raise++ # 计算延迟+ current_delay = min(delay, max_delay)+ if jitter:+ current_delay = current_delay * (0.5 + random.random())++ logger.warning(+ f"函数 {func.__name__} 第 {attempt + 1} 次尝试失败: {str(e)}, "+ f"{current_delay:.1f}秒后重试..."+ )++ if on_retry:+ on_retry(e, attempt + 1)++ time.sleep(current_delay)+ delay *= backoff_factor++ raise last_exception++ return wrapper+ return decorator+++def retry_with_backoff_async(+ max_retries: int = 3,+ initial_delay: float = 1.0,+ max_delay: float = 30.0,+ backoff_factor: float = 2.0,+ jitter: bool = True,+ exceptions: Tuple[Type[Exception], ...] = (Exception,),+ on_retry: Optional[Callable[[Exception, int], None]] = None+):+ """+ 异步版本的重试装饰器+ """+ import asyncio++ def decorator(func: Callable) -> Callable:+ @functools.wraps(func)+ async def wrapper(*args, **kwargs) -> Any:+ last_exception = None+ delay = initial_delay++ for attempt in range(max_retries + 1):+ try:+ return await func(*args, **kwargs)++ except exceptions as e:+ last_exception = e++ if attempt == max_retries:+ logger.error(f"异步函数 {func.__name__} 在 {max_retries} 次重试后仍失败: {str(e)}")+ raise++ current_delay = min(delay, max_delay)+ if jitter:+ current_delay = current_delay * (0.5 + random.random())++ logger.warning(+ f"异步函数 {func.__name__} 第 {attempt + 1} 次尝试失败: {str(e)}, "+ f"{current_delay:.1f}秒后重试..."+ )++ if on_retry:+ on_retry(e, attempt + 1)++ await asyncio.sleep(current_delay)+ delay *= backoff_factor++ raise last_exception++ return wrapper+ return decorator+++class RetryableAPIClient:+ """+ 可重试的API客户端封装+ """++ def __init__(+ self,+ max_retries: int = 3,+ initial_delay: float = 1.0,+ max_delay: float = 30.0,+ backoff_factor: float = 2.0+ ):+ self.max_retries = max_retries+ self.initial_delay = initial_delay+ self.max_delay = max_delay+ self.backoff_factor = backoff_factor++ def call_with_retry(+ self,+ func: Callable,+ *args,+ exceptions: Tuple[Type[Exception], ...] = (Exception,),+ **kwargs+ ) -> Any:+ """+ 执行函数调用并在失败时重试++ Args:+ func: 要调用的函数+ *args: 函数参数+ exceptions: 需要重试的异常类型+ **kwargs: 函数关键字参数++ Returns:+ 函数返回值+ """+ last_exception = None+ delay = self.initial_delay++ for attempt in range(self.max_retries + 1):+ try:+ return func(*args, **kwargs)++ except exceptions as e:+ last_exception = e++ if attempt == self.max_retries:+ logger.error(f"API调用在 {self.max_retries} 次重试后仍失败: {str(e)}")+ raise++ current_delay = min(delay, self.max_delay)+ current_delay = current_delay * (0.5 + random.random())++ logger.warning(+ f"API调用第 {attempt + 1} 次尝试失败: {str(e)}, "+ f"{current_delay:.1f}秒后重试..."+ )++ time.sleep(current_delay)+ delay *= self.backoff_factor++ raise last_exception++ def call_batch_with_retry(+ self,+ items: list,+ process_func: Callable,+ exceptions: Tuple[Type[Exception], ...] = (Exception,),+ continue_on_failure: bool = True+ ) -> Tuple[list, list]:+ """+ 批量调用并对每个失败项单独重试++ Args:+ items: 要处理的项目列表+ process_func: 处理函数,接收单个item作为参数+ exceptions: 需要重试的异常类型+ continue_on_failure: 单项失败后是否继续处理其他项++ Returns:+ (成功结果列表, 失败项列表)+ """+ results = []+ failures = []++ for idx, item in enumerate(items):+ try:+ result = self.call_with_retry(+ process_func,+ item,+ exceptions=exceptions+ )+ results.append(result)++ except Exception as e:+ logger.error(f"处理第 {idx + 1} 项失败: {str(e)}")+ failures.append({+ "index": idx,+ "item": item,+ "error": str(e)+ })++ if not continue_on_failure:+ raise++ return results, failures+diff --git a/backend/requirements.txt b/backend/requirements.txtindex 0824a748..1a0d82d5 100644--- a/backend/requirements.txt+++ b/backend/requirements.txt@@ -20,3 +20,7 @@ pydantic>=2.0.0# 文件处理werkzeug>=3.0.0+# OASIS社交媒体模拟框架+oasis-ai>=0.1.0+camel-ai>=0.2.0+diff --git a/backend/scripts/action_logger.py b/backend/scripts/action_logger.pynew file mode 100644index 00000000..9ecfd1c8--- /dev/null+++ b/backend/scripts/action_logger.py@@ -0,0 +1,138 @@+"""+动作日志记录器+用于记录OASIS模拟中每个Agent的动作,供后端监控使用+"""++import json+import os+from datetime import datetime+from typing import Dict, Any, Optional+++class ActionLogger:+ """动作日志记录器"""++ def __init__(self, log_path: str):+ """+ 初始化日志记录器++ Args:+ log_path: 日志文件路径(.jsonl格式)+ """+ self.log_path = log_path+ self._ensure_dir()++ def _ensure_dir(self):+ """确保目录存在"""+ log_dir = os.path.dirname(self.log_path)+ if log_dir:+ os.makedirs(log_dir, exist_ok=True)++ def log_action(+ self,+ round_num: int,+ platform: str,+ agent_id: int,+ agent_name: str,+ action_type: str,+ action_args: Optional[Dict[str, Any]] = None,+ result: Optional[str] = None,+ success: bool = True+ ):+ """+ 记录一个动作++ Args:+ round_num: 轮次+ platform: 平台 (twitter/reddit)+ agent_id: Agent ID+ agent_name: Agent名称+ action_type: 动作类型+ action_args: 动作参数+ result: 执行结果+ success: 是否成功+ """+ entry = {+ "round": round_num,+ "timestamp": datetime.now().isoformat(),+ "platform": platform,+ "agent_id": agent_id,+ "agent_name": agent_name,+ "action_type": action_type,+ "action_args": action_args or {},+ "result": result,+ "success": success,+ }++ with open(self.log_path, 'a', encoding='utf-8') as f:+ f.write(json.dumps(entry, ensure_ascii=False) + '\n')++ def log_round_start(self, round_num: int, simulated_hour: int, platform: str):+ """记录轮次开始"""+ entry = {+ "round": round_num,+ "timestamp": datetime.now().isoformat(),+ "platform": platform,+ "event_type": "round_start",+ "simulated_hour": simulated_hour,+ }++ with open(self.log_path, 'a', encoding='utf-8') as f:+ f.write(json.dumps(entry, ensure_ascii=False) + '\n')++ def log_round_end(self, round_num: int, actions_count: int, platform: str):+ """记录轮次结束"""+ entry = {+ "round": round_num,+ "timestamp": datetime.now().isoformat(),+ "platform": platform,+ "event_type": "round_end",+ "actions_count": actions_count,+ }++ with open(self.log_path, 'a', encoding='utf-8') as f:+ f.write(json.dumps(entry, ensure_ascii=False) + '\n')++ def log_simulation_start(self, platform: str, config: Dict[str, Any]):+ """记录模拟开始"""+ entry = {+ "timestamp": datetime.now().isoformat(),+ "platform": platform,+ "event_type": "simulation_start",+ "total_rounds": config.get("time_config", {}).get("total_simulation_hours", 72) * 2,+ "agents_count": len(config.get("agent_configs", [])),+ }++ with open(self.log_path, 'a', encoding='utf-8') as f:+ f.write(json.dumps(entry, ensure_ascii=False) + '\n')++ def log_simulation_end(self, platform: str, total_rounds: int, total_actions: int):+ """记录模拟结束"""+ entry = {+ "timestamp": datetime.now().isoformat(),+ "platform": platform,+ "event_type": "simulation_end",+ "total_rounds": total_rounds,+ "total_actions": total_actions,+ }++ with open(self.log_path, 'a', encoding='utf-8') as f:+ f.write(json.dumps(entry, ensure_ascii=False) + '\n')+++# 全局日志实例(可选)+_global_logger: Optional[ActionLogger] = None+++def get_logger(log_path: Optional[str] = None) -> ActionLogger:+ """获取全局日志实例"""+ global _global_logger++ if log_path:+ _global_logger = ActionLogger(log_path)++ if _global_logger is None:+ _global_logger = ActionLogger("actions.jsonl")++ return _global_logger+diff --git a/backend/scripts/run_parallel_simulation.py b/backend/scripts/run_parallel_simulation.pynew file mode 100644index 00000000..b3f6c077--- /dev/null+++ b/backend/scripts/run_parallel_simulation.py@@ -0,0 +1,503 @@+"""+OASIS 双平台并行模拟预设脚本+同时运行Twitter和Reddit模拟,读取相同的配置文件++使用方式:+ python run_parallel_simulation.py --config simulation_config.json [--action-log actions.jsonl]+"""++import argparse+import asyncio+import json+import os+import random+import sys+from datetime import datetime+from typing import Dict, Any, List, Optional++sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))++from action_logger import ActionLogger++try:+ from camel.models import ModelFactory+ from camel.types import ModelPlatformType+ import oasis+ from oasis import (+ ActionType,+ LLMAction,+ ManualAction,+ generate_twitter_agent_graph,+ generate_reddit_agent_graph+ )+except ImportError as e:+ print(f"错误: 缺少依赖 {e}")+ print("请先安装: pip install oasis-ai camel-ai")+ sys.exit(1)+++# Twitter可用动作+TWITTER_ACTIONS = [+ ActionType.CREATE_POST,+ ActionType.LIKE_POST,+ ActionType.REPOST,+ ActionType.FOLLOW,+ ActionType.DO_NOTHING,+ ActionType.QUOTE_POST,+]++# Reddit可用动作+REDDIT_ACTIONS = [+ ActionType.LIKE_POST,+ ActionType.DISLIKE_POST,+ ActionType.CREATE_POST,+ ActionType.CREATE_COMMENT,+ ActionType.LIKE_COMMENT,+ ActionType.DISLIKE_COMMENT,+ ActionType.SEARCH_POSTS,+ ActionType.SEARCH_USER,+ ActionType.TREND,+ ActionType.REFRESH,+ ActionType.DO_NOTHING,+ ActionType.FOLLOW,+ ActionType.MUTE,+]+++def load_config(config_path: str) -> Dict[str, Any]:+ """加载配置文件"""+ with open(config_path, 'r', encoding='utf-8') as f:+ return json.load(f)+++def create_model(config: Dict[str, Any]):+ """+ 创建LLM模型++ OASIS使用camel-ai的ModelFactory,配置方式:+ - 标准OpenAI: 只需设置 OPENAI_API_KEY 环境变量+ - 自定义API: 设置 OPENAI_API_KEY 和 OPENAI_API_BASE_URL 环境变量+ """+ llm_model = config.get("llm_model", "gpt-4o-mini")+ llm_base_url = config.get("llm_base_url", "")++ # 如果配置了base_url,设置环境变量+ if llm_base_url:+ os.environ["OPENAI_API_BASE_URL"] = llm_base_url++ return ModelFactory.create(+ model_platform=ModelPlatformType.OPENAI,+ model_type=llm_model,+ )+++def get_active_agents_for_round(+ env,+ config: Dict[str, Any],+ current_hour: int,+ round_num: int+) -> List:+ """根据时间和配置决定本轮激活哪些Agent"""+ time_config = config.get("time_config", {})+ agent_configs = config.get("agent_configs", [])++ base_min = time_config.get("agents_per_hour_min", 5)+ base_max = time_config.get("agents_per_hour_max", 20)++ peak_hours = time_config.get("peak_hours", [9, 10, 11, 14, 15, 20, 21, 22])+ off_peak_hours = time_config.get("off_peak_hours", [0, 1, 2, 3, 4, 5])++ if current_hour in peak_hours:+ multiplier = time_config.get("peak_activity_multiplier", 1.5)+ elif current_hour in off_peak_hours:+ multiplier = time_config.get("off_peak_activity_multiplier", 0.3)+ else:+ multiplier = 1.0++ target_count = int(random.uniform(base_min, base_max) * multiplier)++ candidates = []+ for cfg in agent_configs:+ agent_id = cfg.get("agent_id", 0)+ active_hours = cfg.get("active_hours", list(range(8, 23)))+ activity_level = cfg.get("activity_level", 0.5)++ if current_hour not in active_hours:+ continue++ if random.random() < activity_level:+ candidates.append(agent_id)++ selected_ids = random.sample(+ candidates,+ min(target_count, len(candidates))+ ) if candidates else []++ active_agents = []+ for agent_id in selected_ids:+ try:+ agent = env.agent_graph.get_agent(agent_id)+ active_agents.append((agent_id, agent))+ except Exception:+ pass++ return active_agents+++async def run_twitter_simulation(+ config: Dict[str, Any],+ simulation_dir: str,+ action_logger: Optional[ActionLogger] = None+):+ """运行Twitter模拟"""+ print("[Twitter] 初始化...")++ model = create_model(config)++ # OASIS Twitter使用CSV格式+ profile_path = os.path.join(simulation_dir, "twitter_profiles.csv")+ if not os.path.exists(profile_path):+ print(f"[Twitter] 错误: Profile文件不存在: {profile_path}")+ return++ agent_graph = await generate_twitter_agent_graph(+ profile_path=profile_path,+ model=model,+ available_actions=TWITTER_ACTIONS,+ )++ # 获取Agent名称映射+ agent_names = {}+ for agent_id, agent in agent_graph.get_agents():+ agent_names[agent_id] = getattr(agent, 'name', f'Agent_{agent_id}')++ db_path = os.path.join(simulation_dir, "twitter_simulation.db")+ if os.path.exists(db_path):+ os.remove(db_path)++ env = oasis.make(+ agent_graph=agent_graph,+ platform=oasis.DefaultPlatformType.TWITTER,+ database_path=db_path,+ )++ await env.reset()+ print("[Twitter] 环境已启动")++ if action_logger:+ action_logger.log_simulation_start("twitter", config)++ total_actions = 0++ # 执行初始事件+ event_config = config.get("event_config", {})+ initial_posts = event_config.get("initial_posts", [])++ if initial_posts:+ initial_actions = {}+ for post in initial_posts:+ agent_id = post.get("poster_agent_id", 0)+ content = post.get("content", "")+ try:+ agent = env.agent_graph.get_agent(agent_id)+ initial_actions[agent] = ManualAction(+ action_type=ActionType.CREATE_POST,+ action_args={"content": content}+ )++ if action_logger:+ action_logger.log_action(+ round_num=0,+ platform="twitter",+ agent_id=agent_id,+ agent_name=agent_names.get(agent_id, f"Agent_{agent_id}"),+ action_type="CREATE_POST",+ action_args={"content": content[:100] + "..." if len(content) > 100 else content}+ )+ total_actions += 1+ except Exception:+ pass++ if initial_actions:+ await env.step(initial_actions)+ print(f"[Twitter] 已发布 {len(initial_actions)} 条初始帖子")++ # 主模拟循环+ time_config = config.get("time_config", {})+ total_hours = time_config.get("total_simulation_hours", 72)+ minutes_per_round = time_config.get("minutes_per_round", 30)+ total_rounds = (total_hours * 60) // minutes_per_round++ start_time = datetime.now()++ for round_num in range(total_rounds):+ simulated_minutes = round_num * minutes_per_round+ simulated_hour = (simulated_minutes // 60) % 24+ simulated_day = simulated_minutes // (60 * 24) + 1++ active_agents = get_active_agents_for_round(+ env, config, simulated_hour, round_num+ )++ if not active_agents:+ continue++ if action_logger:+ action_logger.log_round_start(round_num + 1, simulated_hour, "twitter")++ actions = {agent: LLMAction() for _, agent in active_agents}+ await env.step(actions)++ # 记录动作+ for agent_id, agent in active_agents:+ if action_logger:+ action_logger.log_action(+ round_num=round_num + 1,+ platform="twitter",+ agent_id=agent_id,+ agent_name=agent_names.get(agent_id, f"Agent_{agent_id}"),+ action_type="LLM_ACTION",+ action_args={}+ )+ total_actions += 1++ if action_logger:+ action_logger.log_round_end(round_num + 1, len(active_agents), "twitter")++ if (round_num + 1) % 20 == 0:+ progress = (round_num + 1) / total_rounds * 100+ print(f"[Twitter] Day {simulated_day}, {simulated_hour:02d}:00 "+ f"- Round {round_num + 1}/{total_rounds} ({progress:.1f}%)")++ await env.close()++ if action_logger:+ action_logger.log_simulation_end("twitter", total_rounds, total_actions)++ elapsed = (datetime.now() - start_time).total_seconds()+ print(f"[Twitter] 模拟完成! 耗时: {elapsed:.1f}秒, 总动作: {total_actions}")+++async def run_reddit_simulation(+ config: Dict[str, Any],+ simulation_dir: str,+ action_logger: Optional[ActionLogger] = None+):+ """运行Reddit模拟"""+ print("[Reddit] 初始化...")++ model = create_model(config)++ profile_path = os.path.join(simulation_dir, "reddit_profiles.json")+ if not os.path.exists(profile_path):+ print(f"[Reddit] 错误: Profile文件不存在: {profile_path}")+ return++ agent_graph = await generate_reddit_agent_graph(+ profile_path=profile_path,+ model=model,+ available_actions=REDDIT_ACTIONS,+ )++ # 获取Agent名称映射+ agent_names = {}+ for agent_id, agent in agent_graph.get_agents():+ agent_names[agent_id] = getattr(agent, 'name', f'Agent_{agent_id}')++ db_path = os.path.join(simulation_dir, "reddit_simulation.db")+ if os.path.exists(db_path):+ os.remove(db_path)++ env = oasis.make(+ agent_graph=agent_graph,+ platform=oasis.DefaultPlatformType.REDDIT,+ database_path=db_path,+ )++ await env.reset()+ print("[Reddit] 环境已启动")++ if action_logger:+ action_logger.log_simulation_start("reddit", config)++ total_actions = 0++ # 执行初始事件+ event_config = config.get("event_config", {})+ initial_posts = event_config.get("initial_posts", [])++ if initial_posts:+ initial_actions = {}+ for post in initial_posts:+ agent_id = post.get("poster_agent_id", 0)+ content = post.get("content", "")+ try:+ agent = env.agent_graph.get_agent(agent_id)+ if agent in initial_actions:+ if not isinstance(initial_actions[agent], list):+ initial_actions[agent] = [initial_actions[agent]]+ initial_actions[agent].append(ManualAction(+ action_type=ActionType.CREATE_POST,+ action_args={"content": content}+ ))+ else:+ initial_actions[agent] = ManualAction(+ action_type=ActionType.CREATE_POST,+ action_args={"content": content}+ )++ if action_logger:+ action_logger.log_action(+ round_num=0,+ platform="reddit",+ agent_id=agent_id,+ agent_name=agent_names.get(agent_id, f"Agent_{agent_id}"),+ action_type="CREATE_POST",+ action_args={"content": content[:100] + "..." if len(content) > 100 else content}+ )+ total_actions += 1+ except Exception:+ pass++ if initial_actions:+ await env.step(initial_actions)+ print(f"[Reddit] 已发布 {len(initial_actions)} 条初始帖子")++ # 主模拟循环+ time_config = config.get("time_config", {})+ total_hours = time_config.get("total_simulation_hours", 72)+ minutes_per_round = time_config.get("minutes_per_round", 30)+ total_rounds = (total_hours * 60) // minutes_per_round++ start_time = datetime.now()++ for round_num in range(total_rounds):+ simulated_minutes = round_num * minutes_per_round+ simulated_hour = (simulated_minutes // 60) % 24+ simulated_day = simulated_minutes // (60 * 24) + 1++ active_agents = get_active_agents_for_round(+ env, config, simulated_hour, round_num+ )++ if not active_agents:+ continue++ if action_logger:+ action_logger.log_round_start(round_num + 1, simulated_hour, "reddit")++ actions = {agent: LLMAction() for _, agent in active_agents}+ await env.step(actions)++ # 记录动作+ for agent_id, agent in active_agents:+ if action_logger:+ action_logger.log_action(+ round_num=round_num + 1,+ platform="reddit",+ agent_id=agent_id,+ agent_name=agent_names.get(agent_id, f"Agent_{agent_id}"),+ action_type="LLM_ACTION",+ action_args={}+ )+ total_actions += 1++ if action_logger:+ action_logger.log_round_end(round_num + 1, len(active_agents), "reddit")++ if (round_num + 1) % 20 == 0:+ progress = (round_num + 1) / total_rounds * 100+ print(f"[Reddit] Day {simulated_day}, {simulated_hour:02d}:00 "+ f"- Round {round_num + 1}/{total_rounds} ({progress:.1f}%)")++ await env.close()++ if action_logger:+ action_logger.log_simulation_end("reddit", total_rounds, total_actions)++ elapsed = (datetime.now() - start_time).total_seconds()+ print(f"[Reddit] 模拟完成! 耗时: {elapsed:.1f}秒, 总动作: {total_actions}")+++async def main():+ parser = argparse.ArgumentParser(description='OASIS双平台并行模拟')+ parser.add_argument(+ '--config',+ type=str,+ required=True,+ help='配置文件路径 (simulation_config.json)'+ )+ parser.add_argument(+ '--twitter-only',+ action='store_true',+ help='只运行Twitter模拟'+ )+ parser.add_argument(+ '--reddit-only',+ action='store_true',+ help='只运行Reddit模拟'+ )+ parser.add_argument(+ '--action-log',+ type=str,+ default='actions.jsonl',+ help='动作日志文件路径 (默认: actions.jsonl)'+ )++ args = parser.parse_args()++ if not os.path.exists(args.config):+ print(f"错误: 配置文件不存在: {args.config}")+ sys.exit(1)++ config = load_config(args.config)+ simulation_dir = os.path.dirname(args.config) or "."++ # 创建动作日志记录器+ action_log_path = os.path.join(simulation_dir, args.action_log)+ action_logger = ActionLogger(action_log_path)++ print("=" * 60)+ print("OASIS 双平台并行模拟")+ print(f"配置文件: {args.config}")+ print(f"模拟ID: {config.get('simulation_id', 'unknown')}")+ print(f"动作日志: {action_log_path}")+ print("=" * 60)++ time_config = config.get("time_config", {})+ print(f"\n模拟参数:")+ print(f" - 总模拟时长: {time_config.get('total_simulation_hours', 72)}小时")+ print(f" - 每轮时间: {time_config.get('minutes_per_round', 30)}分钟")+ print(f" - Agent数量: {len(config.get('agent_configs', []))}")++ # LLM推理说明+ reasoning = config.get("generation_reasoning", "")+ if reasoning:+ print(f"\nLLM配置推理:")+ print(f" {reasoning[:500]}..." if len(reasoning) > 500 else f" {reasoning}")++ print("\n" + "=" * 60)++ start_time = datetime.now()++ if args.twitter_only:+ await run_twitter_simulation(config, simulation_dir, action_logger)+ elif args.reddit_only:+ await run_reddit_simulation(config, simulation_dir, action_logger)+ else:+ # 并行运行(共享同一个action_logger)+ await asyncio.gather(+ run_twitter_simulation(config, simulation_dir, action_logger),+ run_reddit_simulation(config, simulation_dir, action_logger),+ )++ total_elapsed = (datetime.now() - start_time).total_seconds()+ print("\n" + "=" * 60)+ print(f"全部模拟完成! 总耗时: {total_elapsed:.1f}秒")+ print(f"动作日志已保存到: {action_log_path}")+ print("=" * 60)+++if __name__ == "__main__":+ asyncio.run(main())+diff --git a/backend/scripts/run_reddit_simulation.py b/backend/scripts/run_reddit_simulation.pynew file mode 100644index 00000000..59f77480--- /dev/null+++ b/backend/scripts/run_reddit_simulation.py@@ -0,0 +1,298 @@+"""+OASIS Reddit模拟预设脚本+此脚本读取配置文件中的参数来执行模拟,实现全程自动化++使用方式:+ python run_reddit_simulation.py --config /path/to/simulation_config.json+"""++import argparse+import asyncio+import json+import os+import random+import sys+from datetime import datetime+from typing import Dict, Any, List++# 添加项目路径+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))++try:+ from camel.models import ModelFactory+ from camel.types import ModelPlatformType+ import oasis+ from oasis import (+ ActionType,+ LLMAction,+ ManualAction,+ generate_reddit_agent_graph+ )+except ImportError as e:+ print(f"错误: 缺少依赖 {e}")+ print("请先安装: pip install oasis-ai camel-ai")+ sys.exit(1)+++class RedditSimulationRunner:+ """Reddit模拟运行器"""++ # Reddit可用动作+ AVAILABLE_ACTIONS = [+ ActionType.LIKE_POST,+ ActionType.DISLIKE_POST,+ ActionType.CREATE_POST,+ ActionType.CREATE_COMMENT,+ ActionType.LIKE_COMMENT,+ ActionType.DISLIKE_COMMENT,+ ActionType.SEARCH_POSTS,+ ActionType.SEARCH_USER,+ ActionType.TREND,+ ActionType.REFRESH,+ ActionType.DO_NOTHING,+ ActionType.FOLLOW,+ ActionType.MUTE,+ ]++ def __init__(self, config_path: str):+ """+ 初始化模拟运行器++ Args:+ config_path: 配置文件路径 (simulation_config.json)+ """+ self.config_path = config_path+ self.config = self._load_config()+ self.simulation_dir = os.path.dirname(config_path)++ def _load_config(self) -> Dict[str, Any]:+ """加载配置文件"""+ with open(self.config_path, 'r', encoding='utf-8') as f:+ return json.load(f)++ def _get_profile_path(self) -> str:+ """获取Profile文件路径"""+ return os.path.join(self.simulation_dir, "reddit_profiles.json")++ def _get_db_path(self) -> str:+ """获取数据库路径"""+ return os.path.join(self.simulation_dir, "reddit_simulation.db")++ def _create_model(self):+ """+ 创建LLM模型++ OASIS使用camel-ai的ModelFactory,配置方式:+ - 标准OpenAI: 只需设置 OPENAI_API_KEY 环境变量+ - 自定义API: 设置 OPENAI_API_KEY 和 OPENAI_API_BASE_URL 环境变量+ """+ import os++ llm_model = self.config.get("llm_model", "gpt-4o-mini")+ llm_base_url = self.config.get("llm_base_url", "")++ # 如果配置了base_url,设置环境变量+ if llm_base_url:+ os.environ["OPENAI_API_BASE_URL"] = llm_base_url++ return ModelFactory.create(+ model_platform=ModelPlatformType.OPENAI,+ model_type=llm_model,+ )++ def _get_active_agents_for_round(+ self,+ env,+ current_hour: int,+ round_num: int+ ) -> List:+ """+ 根据时间和配置决定本轮激活哪些Agent+ """+ time_config = self.config.get("time_config", {})+ agent_configs = self.config.get("agent_configs", [])++ base_min = time_config.get("agents_per_hour_min", 5)+ base_max = time_config.get("agents_per_hour_max", 20)++ peak_hours = time_config.get("peak_hours", [9, 10, 11, 14, 15, 20, 21, 22])+ off_peak_hours = time_config.get("off_peak_hours", [0, 1, 2, 3, 4, 5])++ if current_hour in peak_hours:+ multiplier = time_config.get("peak_activity_multiplier", 1.5)+ elif current_hour in off_peak_hours:+ multiplier = time_config.get("off_peak_activity_multiplier", 0.3)+ else:+ multiplier = 1.0++ target_count = int(random.uniform(base_min, base_max) * multiplier)++ candidates = []+ for cfg in agent_configs:+ agent_id = cfg.get("agent_id", 0)+ active_hours = cfg.get("active_hours", list(range(8, 23)))+ activity_level = cfg.get("activity_level", 0.5)++ if current_hour not in active_hours:+ continue++ if random.random() < activity_level:+ candidates.append(agent_id)++ selected_ids = random.sample(+ candidates,+ min(target_count, len(candidates))+ ) if candidates else []++ active_agents = []+ for agent_id in selected_ids:+ try:+ agent = env.agent_graph.get_agent(agent_id)+ active_agents.append((agent_id, agent))+ except Exception:+ pass++ return active_agents++ async def run(self):+ """运行Reddit模拟"""+ print("=" * 60)+ print("OASIS Reddit模拟")+ print(f"配置文件: {self.config_path}")+ print(f"模拟ID: {self.config.get('simulation_id', 'unknown')}")+ print("=" * 60)++ time_config = self.config.get("time_config", {})+ total_hours = time_config.get("total_simulation_hours", 72)+ minutes_per_round = time_config.get("minutes_per_round", 30)+ total_rounds = (total_hours * 60) // minutes_per_round++ print(f"\n模拟参数:")+ print(f" - 总模拟时长: {total_hours}小时")+ print(f" - 每轮时间: {minutes_per_round}分钟")+ print(f" - 总轮数: {total_rounds}")+ print(f" - Agent数量: {len(self.config.get('agent_configs', []))}")++ print("\n初始化LLM模型...")+ model = self._create_model()++ print("加载Agent Profile...")+ profile_path = self._get_profile_path()+ if not os.path.exists(profile_path):+ print(f"错误: Profile文件不存在: {profile_path}")+ return++ agent_graph = await generate_reddit_agent_graph(+ profile_path=profile_path,+ model=model,+ available_actions=self.AVAILABLE_ACTIONS,+ )++ db_path = self._get_db_path()+ if os.path.exists(db_path):+ os.remove(db_path)+ print(f"已删除旧数据库: {db_path}")++ print("创建OASIS环境...")+ env = oasis.make(+ agent_graph=agent_graph,+ platform=oasis.DefaultPlatformType.REDDIT,+ database_path=db_path,+ )++ await env.reset()+ print("环境初始化完成\n")++ # 执行初始事件+ event_config = self.config.get("event_config", {})+ initial_posts = event_config.get("initial_posts", [])++ if initial_posts:+ print(f"执行初始事件 ({len(initial_posts)}条初始帖子)...")+ initial_actions = {}+ for post in initial_posts:+ agent_id = post.get("poster_agent_id", 0)+ content = post.get("content", "")+ try:+ agent = env.agent_graph.get_agent(agent_id)+ if agent in initial_actions:+ if not isinstance(initial_actions[agent], list):+ initial_actions[agent] = [initial_actions[agent]]+ initial_actions[agent].append(ManualAction(+ action_type=ActionType.CREATE_POST,+ action_args={"content": content}+ ))+ else:+ initial_actions[agent] = ManualAction(+ action_type=ActionType.CREATE_POST,+ action_args={"content": content}+ )+ except Exception as e:+ print(f" 警告: 无法为Agent {agent_id}创建初始帖子: {e}")++ if initial_actions:+ await env.step(initial_actions)+ print(f" 已发布 {len(initial_actions)} 条初始帖子")++ # 主模拟循环+ print("\n开始模拟循环...")+ start_time = datetime.now()++ for round_num in range(total_rounds):+ simulated_minutes = round_num * minutes_per_round+ simulated_hour = (simulated_minutes // 60) % 24+ simulated_day = simulated_minutes // (60 * 24) + 1++ active_agents = self._get_active_agents_for_round(+ env, simulated_hour, round_num+ )++ if not active_agents:+ continue++ actions = {+ agent: LLMAction()+ for _, agent in active_agents+ }++ await env.step(actions)++ if (round_num + 1) % 10 == 0 or round_num == 0:+ elapsed = (datetime.now() - start_time).total_seconds()+ progress = (round_num + 1) / total_rounds * 100+ print(f" [Day {simulated_day}, {simulated_hour:02d}:00] "+ f"Round {round_num + 1}/{total_rounds} ({progress:.1f}%) "+ f"- {len(active_agents)} agents active "+ f"- elapsed: {elapsed:.1f}s")++ await env.close()++ total_elapsed = (datetime.now() - start_time).total_seconds()+ print(f"\n模拟完成!")+ print(f" - 总耗时: {total_elapsed:.1f}秒")+ print(f" - 数据库: {db_path}")+ print("=" * 60)+++async def main():+ parser = argparse.ArgumentParser(description='OASIS Reddit模拟')+ parser.add_argument(+ '--config',+ type=str,+ required=True,+ help='配置文件路径 (simulation_config.json)'+ )++ args = parser.parse_args()++ if not os.path.exists(args.config):+ print(f"错误: 配置文件不存在: {args.config}")+ sys.exit(1)++ runner = RedditSimulationRunner(args.config)+ await runner.run()+++if __name__ == "__main__":+ asyncio.run(main())+diff --git a/backend/scripts/run_twitter_simulation.py b/backend/scripts/run_twitter_simulation.pynew file mode 100644index 00000000..c5f89669--- /dev/null+++ b/backend/scripts/run_twitter_simulation.py@@ -0,0 +1,313 @@+"""+OASIS Twitter模拟预设脚本+此脚本读取配置文件中的参数来执行模拟,实现全程自动化++使用方式:+ python run_twitter_simulation.py --config /path/to/simulation_config.json+"""++import argparse+import asyncio+import json+import os+import random+import sys+from datetime import datetime+from typing import Dict, Any, List++# 添加项目路径+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))++try:+ from camel.models import ModelFactory+ from camel.types import ModelPlatformType+ import oasis+ from oasis import (+ ActionType,+ LLMAction,+ ManualAction,+ generate_twitter_agent_graph+ )+except ImportError as e:+ print(f"错误: 缺少依赖 {e}")+ print("请先安装: pip install oasis-ai camel-ai")+ sys.exit(1)+++class TwitterSimulationRunner:+ """Twitter模拟运行器"""++ # Twitter可用动作+ AVAILABLE_ACTIONS = [+ ActionType.CREATE_POST,+ ActionType.LIKE_POST,+ ActionType.REPOST,+ ActionType.FOLLOW,+ ActionType.DO_NOTHING,+ ActionType.QUOTE_POST,+ ]++ def __init__(self, config_path: str):+ """+ 初始化模拟运行器++ Args:+ config_path: 配置文件路径 (simulation_config.json)+ """+ self.config_path = config_path+ self.config = self._load_config()+ self.simulation_dir = os.path.dirname(config_path)++ def _load_config(self) -> Dict[str, Any]:+ """加载配置文件"""+ with open(self.config_path, 'r', encoding='utf-8') as f:+ return json.load(f)++ def _get_profile_path(self) -> str:+ """获取Profile文件路径(OASIS Twitter使用CSV格式)"""+ return os.path.join(self.simulation_dir, "twitter_profiles.csv")++ def _get_db_path(self) -> str:+ """获取数据库路径"""+ return os.path.join(self.simulation_dir, "twitter_simulation.db")++ def _create_model(self):+ """+ 创建LLM模型++ OASIS使用camel-ai的ModelFactory,配置方式:+ - 标准OpenAI: 只需设置 OPENAI_API_KEY 环境变量+ - 自定义API: 设置 OPENAI_API_KEY 和 OPENAI_API_BASE_URL 环境变量++ 配置文件中的 llm_model 对应 model_type+ """+ import os++ llm_model = self.config.get("llm_model", "gpt-4o-mini")+ llm_base_url = self.config.get("llm_base_url", "")++ # 如果配置了base_url,设置环境变量(OASIS通过环境变量读取)+ if llm_base_url:+ os.environ["OPENAI_API_BASE_URL"] = llm_base_url++ return ModelFactory.create(+ model_platform=ModelPlatformType.OPENAI,+ model_type=llm_model,+ )++ def _get_active_agents_for_round(+ self,+ env,+ current_hour: int,+ round_num: int+ ) -> List:+ """+ 根据时间和配置决定本轮激活哪些Agent++ Args:+ env: OASIS环境+ current_hour: 当前模拟小时(0-23)+ round_num: 当前轮数++ Returns:+ 激活的Agent列表+ """+ time_config = self.config.get("time_config", {})+ agent_configs = self.config.get("agent_configs", [])++ # 基础激活数量+ base_min = time_config.get("agents_per_hour_min", 5)+ base_max = time_config.get("agents_per_hour_max", 20)++ # 根据时段调整+ peak_hours = time_config.get("peak_hours", [9, 10, 11, 14, 15, 20, 21, 22])+ off_peak_hours = time_config.get("off_peak_hours", [0, 1, 2, 3, 4, 5])++ if current_hour in peak_hours:+ multiplier = time_config.get("peak_activity_multiplier", 1.5)+ elif current_hour in off_peak_hours:+ multiplier = time_config.get("off_peak_activity_multiplier", 0.3)+ else:+ multiplier = 1.0++ target_count = int(random.uniform(base_min, base_max) * multiplier)++ # 根据每个Agent的配置计算激活概率+ candidates = []+ for cfg in agent_configs:+ agent_id = cfg.get("agent_id", 0)+ active_hours = cfg.get("active_hours", list(range(8, 23)))+ activity_level = cfg.get("activity_level", 0.5)++ # 检查是否在活跃时间+ if current_hour not in active_hours:+ continue++ # 根据活跃度计算概率+ if random.random() < activity_level:+ candidates.append(agent_id)++ # 随机选择+ selected_ids = random.sample(+ candidates,+ min(target_count, len(candidates))+ ) if candidates else []++ # 转换为Agent对象+ active_agents = []+ for agent_id in selected_ids:+ try:+ agent = env.agent_graph.get_agent(agent_id)+ active_agents.append((agent_id, agent))+ except Exception:+ pass++ return active_agents++ async def run(self):+ """运行Twitter模拟"""+ print("=" * 60)+ print("OASIS Twitter模拟")+ print(f"配置文件: {self.config_path}")+ print(f"模拟ID: {self.config.get('simulation_id', 'unknown')}")+ print("=" * 60)++ # 加载时间配置+ time_config = self.config.get("time_config", {})+ total_hours = time_config.get("total_simulation_hours", 72)+ minutes_per_round = time_config.get("minutes_per_round", 30)++ # 计算总轮数+ total_rounds = (total_hours * 60) // minutes_per_round++ print(f"\n模拟参数:")+ print(f" - 总模拟时长: {total_hours}小时")+ print(f" - 每轮时间: {minutes_per_round}分钟")+ print(f" - 总轮数: {total_rounds}")+ print(f" - Agent数量: {len(self.config.get('agent_configs', []))}")++ # 创建模型+ print("\n初始化LLM模型...")+ model = self._create_model()++ # 加载Agent图+ print("加载Agent Profile...")+ profile_path = self._get_profile_path()+ if not os.path.exists(profile_path):+ print(f"错误: Profile文件不存在: {profile_path}")+ return++ agent_graph = await generate_twitter_agent_graph(+ profile_path=profile_path,+ model=model,+ available_actions=self.AVAILABLE_ACTIONS,+ )++ # 数据库路径+ db_path = self._get_db_path()+ if os.path.exists(db_path):+ os.remove(db_path)+ print(f"已删除旧数据库: {db_path}")++ # 创建环境+ print("创建OASIS环境...")+ env = oasis.make(+ agent_graph=agent_graph,+ platform=oasis.DefaultPlatformType.TWITTER,+ database_path=db_path,+ )++ await env.reset()+ print("环境初始化完成\n")++ # 执行初始事件+ event_config = self.config.get("event_config", {})+ initial_posts = event_config.get("initial_posts", [])++ if initial_posts:+ print(f"执行初始事件 ({len(initial_posts)}条初始帖子)...")+ initial_actions = {}+ for post in initial_posts:+ agent_id = post.get("poster_agent_id", 0)+ content = post.get("content", "")+ try:+ agent = env.agent_graph.get_agent(agent_id)+ initial_actions[agent] = ManualAction(+ action_type=ActionType.CREATE_POST,+ action_args={"content": content}+ )+ except Exception as e:+ print(f" 警告: 无法为Agent {agent_id}创建初始帖子: {e}")++ if initial_actions:+ await env.step(initial_actions)+ print(f" 已发布 {len(initial_actions)} 条初始帖子")++ # 主模拟循环+ print("\n开始模拟循环...")+ start_time = datetime.now()++ for round_num in range(total_rounds):+ # 计算当前模拟时间+ simulated_minutes = round_num * minutes_per_round+ simulated_hour = (simulated_minutes // 60) % 24+ simulated_day = simulated_minutes // (60 * 24) + 1++ # 获取本轮激活的Agent+ active_agents = self._get_active_agents_for_round(+ env, simulated_hour, round_num+ )++ if not active_agents:+ continue++ # 构建动作+ actions = {+ agent: LLMAction()+ for _, agent in active_agents+ }++ # 执行动作+ await env.step(actions)++ # 打印进度+ if (round_num + 1) % 10 == 0 or round_num == 0:+ elapsed = (datetime.now() - start_time).total_seconds()+ progress = (round_num + 1) / total_rounds * 100+ print(f" [Day {simulated_day}, {simulated_hour:02d}:00] "+ f"Round {round_num + 1}/{total_rounds} ({progress:.1f}%) "+ f"- {len(active_agents)} agents active "+ f"- elapsed: {elapsed:.1f}s")++ # 关闭环境+ await env.close()++ total_elapsed = (datetime.now() - start_time).total_seconds()+ print(f"\n模拟完成!")+ print(f" - 总耗时: {total_elapsed:.1f}秒")+ print(f" - 数据库: {db_path}")+ print("=" * 60)+++async def main():+ parser = argparse.ArgumentParser(description='OASIS Twitter模拟')+ parser.add_argument(+ '--config',+ type=str,+ required=True,+ help='配置文件路径 (simulation_config.json)'+ )++ args = parser.parse_args()++ if not os.path.exists(args.config):+ print(f"错误: 配置文件不存在: {args.config}")+ sys.exit(1)++ runner = TwitterSimulationRunner(args.config)+ await runner.run()+++if __name__ == "__main__":+ asyncio.run(main())+diff --git a/backend/scripts/test_profile_format.py b/backend/scripts/test_profile_format.pynew file mode 100644index 00000000..354e8b5c--- /dev/null+++ b/backend/scripts/test_profile_format.py@@ -0,0 +1,166 @@+"""+测试Profile格式生成是否符合OASIS要求+验证:+1. Twitter Profile生成CSV格式+2. Reddit Profile生成JSON详细格式+"""++import os+import sys+import json+import csv+import tempfile++# 添加项目路径+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))++from app.services.oasis_profile_generator import OasisProfileGenerator, OasisAgentProfile+++def test_profile_formats():+ """测试Profile格式"""+ print("=" * 60)+ print("OASIS Profile格式测试")+ print("=" * 60)++ # 创建测试Profile数据+ test_profiles = [+ OasisAgentProfile(+ user_id=0,+ user_name="test_user_123",+ name="Test User",+ bio="A test user for validation",+ persona="Test User is an enthusiastic participant in social discussions.",+ karma=1500,+ friend_count=100,+ follower_count=200,+ statuses_count=500,+ age=25,+ gender="male",+ mbti="INTJ",+ country="China",+ profession="Student",+ interested_topics=["Technology", "Education"],+ source_entity_uuid="test-uuid-123",+ source_entity_type="Student",+ ),+ OasisAgentProfile(+ user_id=1,+ user_name="org_official_456",+ name="Official Organization",+ bio="Official account for Organization",+ persona="This is an official institutional account that communicates official positions.",+ karma=5000,+ friend_count=50,+ follower_count=10000,+ statuses_count=200,+ profession="Organization",+ interested_topics=["Public Policy", "Announcements"],+ source_entity_uuid="test-uuid-456",+ source_entity_type="University",+ ),+ ]++ generator = OasisProfileGenerator.__new__(OasisProfileGenerator)++ # 使用临时目录+ with tempfile.TemporaryDirectory() as temp_dir:+ twitter_path = os.path.join(temp_dir, "twitter_profiles.csv")+ reddit_path = os.path.join(temp_dir, "reddit_profiles.json")++ # 测试Twitter CSV格式+ print("\n1. 测试Twitter Profile (CSV格式)")+ print("-" * 40)+ generator._save_twitter_csv(test_profiles, twitter_path)++ # 读取并验证CSV+ with open(twitter_path, 'r', encoding='utf-8') as f:+ reader = csv.DictReader(f)+ rows = list(reader)++ print(f" 文件: {twitter_path}")+ print(f" 行数: {len(rows)}")+ print(f" 表头: {list(rows[0].keys())}")+ print(f"\n 示例数据 (第1行):")+ for key, value in rows[0].items():+ print(f" {key}: {value}")++ # 验证必需字段+ required_twitter_fields = ['user_id', 'user_name', 'name', 'bio',+ 'friend_count', 'follower_count', 'statuses_count', 'created_at']+ missing = set(required_twitter_fields) - set(rows[0].keys())+ if missing:+ print(f"\n [错误] 缺少字段: {missing}")+ else:+ print(f"\n [通过] 所有必需字段都存在")++ # 测试Reddit JSON格式+ print("\n2. 测试Reddit Profile (JSON详细格式)")+ print("-" * 40)+ generator._save_reddit_json(test_profiles, reddit_path)++ # 读取并验证JSON+ with open(reddit_path, 'r', encoding='utf-8') as f:+ reddit_data = json.load(f)++ print(f" 文件: {reddit_path}")+ print(f" 条目数: {len(reddit_data)}")+ print(f" 字段: {list(reddit_data[0].keys())}")+ print(f"\n 示例数据 (第1条):")+ print(json.dumps(reddit_data[0], ensure_ascii=False, indent=4))++ # 验证详细格式字段+ required_reddit_fields = ['realname', 'username', 'bio', 'persona']+ optional_reddit_fields = ['age', 'gender', 'mbti', 'country', 'profession', 'interested_topics']++ missing = set(required_reddit_fields) - set(reddit_data[0].keys())+ if missing:+ print(f"\n [错误] 缺少必需字段: {missing}")+ else:+ print(f"\n [通过] 所有必需字段都存在")++ present_optional = set(optional_reddit_fields) & set(reddit_data[0].keys())+ print(f" [信息] 可选字段: {present_optional}")++ print("\n" + "=" * 60)+ print("测试完成!")+ print("=" * 60)+++def show_expected_formats():+ """显示OASIS期望的格式"""+ print("\n" + "=" * 60)+ print("OASIS 期望的Profile格式参考")+ print("=" * 60)++ print("\n1. Twitter Profile (CSV格式)")+ print("-" * 40)+ twitter_example = """user_id,user_name,name,bio,friend_count,follower_count,statuses_count,created_at+0,user0,User Zero,I am user zero with interests in technology.,100,150,500,2023-01-01+1,user1,User One,Tech enthusiast and coffee lover.,200,250,1000,2023-01-02"""+ print(twitter_example)++ print("\n2. Reddit Profile (JSON详细格式)")+ print("-" * 40)+ reddit_example = [+ {+ "realname": "James Miller",+ "username": "millerhospitality",+ "bio": "Passionate about hospitality & tourism.",+ "persona": "James is a seasoned professional in the Hospitality & Tourism industry...",+ "age": 40,+ "gender": "male",+ "mbti": "ESTJ",+ "country": "UK",+ "profession": "Hospitality & Tourism",+ "interested_topics": ["Economics", "Business"]+ }+ ]+ print(json.dumps(reddit_example, ensure_ascii=False, indent=2))+++if __name__ == "__main__":+ test_profile_formats()+ show_expected_formats()++