# OpsMind

**Repository Path**: impeller1/opsmind

## Basic Information

- **Project Name**: OpsMind
- **Description**: 基于大语言模型的云网运维系统
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-04-20
- **Last Updated**: 2026-04-27

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# OpsMind - 云网运维管理系统

基于大模型的智能云网运维系统，输入一句话需求，自动生成并执行工作流。

## 核心功能

- **自动化工作流生成**：自然语言 → 结构化工作流JSON
- **工作流执行引擎**：解析并执行DAG结构的工作流
- **可视化**：自动生成工作流拓扑图
- **多节点类型**：支持12种节点类型（LLM、代码、数据库、HTTP、条件、循环、并行等）
- **变量引用系统**：支持节点间数据流转（`{{node_id.output_key}}`）
- **网络拓扑可视化**：实时展示 Mininet + ONOS SDN 网络拓扑
- **资源管理**：云资源数据库管理和查询

## 快速开始

### 1. 环境准备

#### 1.1 创建Conda环境

```bash
conda create -n OpsMind python=3.8
conda activate OpsMind
```

#### 1.2 安装依赖

**后端依赖：**
```bash
pip install -r requirements.txt
cd web/backend
pip install -r requirements.txt
```

**前端依赖：**
```bash
cd web/frontend
npm install
```

### 2. 启动Web应用

#### 2.1 启动后端服务（端口：8024）

```bash
conda activate OpsMind
cd web/backend
python main.py
```

后端服务将在 `http://localhost:8024` 启动，可访问：
- API文档：http://localhost:8024/docs
- 健康检查：http://localhost:8024/health

#### 2.2 启动前端服务（端口：8023）

```bash
cd web/frontend
npm start
```

前端应用将在 `http://localhost:8023` 启动，浏览器会自动打开。

#### 2.3 访问应用

打开浏览器访问：http://localhost:8023

应用包含三个主要功能：
- **OpsMind智能体**：输入自然语言需求，自动生成并执行工作流
- **资源列表**：查看和管理云资源数据库中的资源
- **网络管理**：实时查看 Mininet + ONOS 网络拓扑

---

## Demo 场景

OpsMind 提供两个完整的 Demo 场景，展示不同的运维管理能力。

### 场景 1：云资源管理（Cloud Resource Management）

完整的云资源管理场景，包含 MySQL 数据库和 50+ 资源数据。

#### 1.1 启动数据库

使用 Docker Compose 启动 MySQL 数据库：

```bash
cd examples/demo_scenarios/cloud_resource_management
docker-compose up -d
```

**验证数据库：**
```bash
# 检查容器状态
docker ps | grep mysql

# 连接数据库
mysql -h 127.0.0.1 -P 3306 -u root -proot123 cloud_resource_db

# 查看资源数据
mysql> SELECT COUNT(*) FROM resource_pool;
mysql> SELECT * FROM resource_pool LIMIT 5;
```

#### 1.2 配置后端连接

后端会自动连接到本地 MySQL 数据库（配置在 `web/backend/database/connection.py`）。

默认配置：
- Host: `localhost`
- Port: `3306`
- User: `root`
- Password: `root123`
- Database: `cloud_resource_db`

#### 1.3 使用场景

**Web 界面：**
1. 启动后端和前端服务
2. 访问 http://localhost:8023
3. 进入"资源列表"页面，查看和筛选资源
4. 进入"OpsMind智能体"页面，输入需求：
   - "查询北京地区的 A100 GPU 服务器"
   - "查询上海地区可用的 GPU 资源"
   - "统计各地域的资源分布情况"

**命令行测试：**
```bash
cd examples/demo_scenarios/cloud_resource_management

# 场景1：资源查询
python test/scenarios/test_resource_query.py

# 场景2：资源分配
python test/scenarios/test_resource_allocation.py

# 场景3：资源优化
python test/scenarios/test_resource_optimization.py

# 端到端Demo：真实数据库查询
python test/workflow_execution/demo_real_database_query.py
python test/workflow_execution/demo_real_db_shanghai.py
```

#### 1.4 停止数据库

```bash
cd examples/demo_scenarios/cloud_resource_management
docker-compose down
```

---

### 场景 2：网络配置管理（Network Configuration）

完整的 SDN 网络管理场景，使用 ONOS 控制器 + Mininet 网络仿真。

#### 2.1 启动 ONOS 控制器

使用 Docker Compose 启动 ONOS 控制器：

```bash
cd examples/demo_scenarios/network_configuration/control_plane
docker-compose up -d
```

**验证 ONOS：**
```bash
# 检查容器状态
docker ps | grep onos

# 测试 REST API
curl -u onos:rocks http://localhost:8181/onos/v1/devices

# 访问 Web UI
# 浏览器打开：http://localhost:8181/onos/ui
# 用户名：onos，密码：rocks
```

**激活必要的应用：**
```bash
# 进入 ONOS 容器
docker exec -it onos bash

# 激活应用
onos-app localhost activate org.onosproject.openflow
onos-app localhost activate org.onosproject.fwd
onos-app localhost activate org.onosproject.gui2

# 退出容器
exit
```

#### 2.2 配置后端连接

编辑 `web/backend/.env` 文件，配置 ONOS 连接：

```bash
# ONOS 控制器配置
ONOS_HOST=localhost        # 如果 ONOS 在远程服务器，改为实际 IP
ONOS_PORT=8181
ONOS_USERNAME=onos
ONOS_PASSWORD=rocks
```

**远程 ONOS 示例：**
```bash
ONOS_HOST=192.168.131.166
ONOS_PORT=8181
ONOS_USERNAME=onos
ONOS_PASSWORD=rocks
```

#### 2.3 启动 Mininet 拓扑

OpsMind 提供两个预定义的网络拓扑脚本：

**选项 1：复杂网络拓扑（6 交换机 + 10 主机）**

```bash
cd examples/demo_scenarios/network_configuration/data_plane/mininet
sudo python3 complex_topology.py
```

拓扑结构：
```
            [Core-S1]
           /    |    \
          /     |     \
      [S2]    [S3]    [S4]
      / \      / \      / \
    H1  H2   H3  H4   H5  H6

      [S5] --- [S6]
      / \       / \
    H7  H8    H9  H10
```

**选项 2：数据中心拓扑（14 交换机 + 8 主机）**

```bash
cd examples/demo_scenarios/network_configuration/data_plane/mininet
sudo python3 datacenter_topology.py
```

拓扑结构：
```
核心层:        [C1]  [C2]
                |  \/  |
                |  /\  |
聚合层:      [A1]  [A2]  [A3]  [A4]
             / \    / \    / \    / \
接入层:    [T1][T2][T3][T4][T5][T6][T7][T8]
            |   |   |   |   |   |   |   |
主机:      H1  H2  H3  H4  H5  H6  H7  H8
```

**在 Mininet CLI 中测试：**
```bash
# 测试所有主机连通性
mininet> pingall

# 测试两个主机之间的连通性
mininet> h1 ping h2

# 显示网络信息
mininet> dump

# 显示网络拓扑
mininet> net

# 显示所有链路
mininet> links

# 退出
mininet> exit
```

**快速测试命令（简单拓扑）：**
```bash
# 使用 mn 命令快速创建测试拓扑
sudo mn --controller=remote,ip=localhost,port=6653 --topo=tree,depth=2,fanout=3
```

#### 2.4 使用场景

**Web 界面：**
1. 启动 ONOS 控制器
2. 启动 Mininet 拓扑
3. 启动后端和前端服务
4. 访问 http://localhost:8023
5. 进入"网络管理"页面，查看：
   - 实时网络拓扑图（交换机、主机、链路）
   - 设备状态监控（在线/离线）
   - 设备详情（点击设备节点）
   - 自动刷新（每 10 秒）

**API 测试：**
```bash
# 测试 ONOS REST API
curl -u onos:rocks http://localhost:8181/onos/v1/devices
curl -u onos:rocks http://localhost:8181/onos/v1/links
curl -u onos:rocks http://localhost:8181/onos/v1/hosts

# 测试 OpsMind 网络 API
curl http://localhost:8024/api/network/topology
curl http://localhost:8024/api/network/devices
curl http://localhost:8024/api/network/stats
```

#### 2.5 清理网络

```bash
# 清理 Mininet
sudo mn -c

# 停止 ONOS 控制器
cd examples/demo_scenarios/network_configuration/control_plane
docker-compose down
```

#### 2.6 防火墙配置（远程 ONOS）

如果 ONOS 在远程服务器，需要开放端口：

```bash
# 在 ONOS 服务器上执行
sudo firewall-cmd --permanent --add-port=8181/tcp  # REST API
sudo firewall-cmd --permanent --add-port=6653/tcp  # OpenFlow
sudo firewall-cmd --permanent --add-port=8101/tcp  # ONOS CLI (可选)
sudo firewall-cmd --reload

# 或使用 iptables
sudo iptables -A INPUT -p tcp --dport 8181 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 6653 -j ACCEPT
```

#### 2.7 故障排查

**问题 1: 前端显示"暂无网络设备"**
- 检查 ONOS 是否启动：`curl -u onos:rocks http://localhost:8181/onos/v1/devices`
- 检查 Mininet 是否运行：`sudo mn -c` 然后重新启动拓扑
- 检查 `.env` 文件中的 `ONOS_HOST` 配置
- 检查防火墙是否开放 8181 端口

**问题 2: Mininet 无法连接到 ONOS**
- 检查 ONOS 是否监听 6653 端口：`netstat -tuln | grep 6653`
- 检查拓扑脚本中的控制器 IP 配置
- 检查防火墙是否开放 6653 端口
- 确保 ONOS 的 OpenFlow 应用已激活

**问题 3: 设备连接后立即断开**
- 检查 ONOS 日志：`docker logs onos`
- 确保 Mininet 使用 OpenFlow 1.3：`protocols='OpenFlow13'`
- 重启 ONOS 和 Mininet

**问题 4: 拓扑图显示但设备名称都是 "Switch-0000"**
- 这是旧版本的问题，已修复
- 重启后端服务以加载最新代码

详细配置说明请查看：
- `examples/demo_scenarios/network_configuration/data_plane/mininet/README.md`
- `examples/demo_scenarios/network_configuration/control_plane/README.md`

---

```bash
# 测试工作流生成
python examples/demo_scenarios/cloud_resource_management/test/workflow_generation/test_workflow_generation.py
```

查看生成的工作流：
- JSON: `examples/demo_scenarios/cloud_resource_management/test/workflow_generation/output/*.json`
- 可视化图: `examples/demo_scenarios/cloud_resource_management/test/workflow_generation/output/*.png`

### 4. 工作流执行示例（命令行）

```bash
# 端到端Demo：真实数据库查询
python examples/demo_scenarios/cloud_resource_management/test/workflow_execution/demo_real_database_query.py

# 高级执行器测试（条件、循环、并行等）
python examples/demo_scenarios/cloud_resource_management/test/workflow_execution/test_advanced_executors.py
```

查看执行结果：
- 工作流定义: `*_workflow.json`
- 执行结果: `*_result.json`
- 执行日志: `*_log.txt`
- 结果摘要: `*_summary.txt`

### 5. 使用示例（Python API）

#### 5.1 生成工作流

```python
from core.workflow_orchestration import WorkflowGenerator
from core.llm_client import LLMClient

# 初始化
llm_client = LLMClient(
    provider="aliyun",
    api_key="your-api-key",
    model="qwen-plus"
)
generator = WorkflowGenerator(llm_client)

# 生成工作流
workflow = generator.generate("查询北京地区可用的GPU服务器")

# 保存和可视化
generator.save_workflow(workflow, "output/my_workflow.json")
generator.visualize(workflow, "output/my_workflow")
```

#### 5.2 执行工作流

```python
from core.task_execution import WorkflowExecutor

# 初始化执行器
executor = WorkflowExecutor()

# 执行工作流
context = executor.execute(workflow)

# 获取执行结果
result = context.get_node_output('node_id', 'output_key')
print(f"执行结果: {result}")

# 查看执行日志
for log in context.execution_log:
    print(f"[{log['timestamp']}] {log['message']}")
```

## 工作流生成

OpsMind使用大模型将自然语言需求转换为结构化的工作流JSON。

### 生成流程

1. **需求解析**：LLM分析用户输入，识别任务类型和关键参数
2. **节点规划**：根据任务类型选择合适的节点类型（LLM、CODE、DATABASE_QUERY等）
3. **DAG构建**：生成节点和边，构建有向无环图
4. **变量绑定**：设置节点间的数据流转（`{{node_id.output_key}}`）
5. **验证**：5层验证规则确保工作流正确性

### 工作流JSON结构

```json
{
  "workflow_name": "gpu_resource_query",
  "nodes": [
    {
      "id": "start",
      "type": "start",
      "outputs": {"user_input": "查询GPU服务器"}
    },
    {
      "id": "query_db",
      "type": "database_query",
      "name": "查询数据库",
      "config": {
        "connection": "{{start.db_config}}",
        "query": "SELECT * FROM resource_pool WHERE ..."
      }
    },
    {
      "id": "format_result",
      "type": "code",
      "name": "格式化结果",
      "config": {
        "language": "python",
        "code": "result = context.get_node_output('query_db', 'results')"
      }
    },
    {
      "id": "end",
      "type": "end"
    }
  ],
  "edges": [
    {"source": "start", "target": "query_db"},
    {"source": "query_db", "target": "format_result"},
    {"source": "format_result", "target": "end"}
  ]
}
```

## 工作流执行

OpsMind执行引擎解析工作流JSON，按依赖顺序执行节点。

### 执行流程

1. **工作流解析**：加载JSON，提取节点和边
2. **拓扑排序**：基于DAG计算节点执行顺序
3. **上下文初始化**：创建执行上下文，存储节点输出
4. **节点执行**：
   - 解析变量引用（`{{node_id.output_key}}`）
   - 调用对应的节点执行器
   - 保存执行结果到上下文
5. **错误处理**：捕获异常，记录日志

### 变量引用系统

节点间通过变量引用传递数据：

```python
# 节点A的输出
{
  "id": "query_db",
  "outputs": {
    "results": [...],
    "row_count": 10
  }
}

# 节点B引用节点A的输出
{
  "id": "process_data",
  "config": {
    "input_data": "{{query_db.results}}",  # 引用节点A的results
    "count": "{{query_db.row_count}}"      # 引用节点A的row_count
  }
}
```

### 执行上下文

```python
class ExecutionContext:
    node_outputs = {}      # {node_id: {output_key: value}}
    global_vars = {}       # 全局变量
    execution_log = []     # 执行日志
    errors = []            # 错误记录
```

## 节点类型

OpsMind支持12种节点类型：

| 节点类型 | 说明 | 用途 |
|---------|------|------|
| `start` | 开始节点 | 工作流入口，定义初始变量 |
| `end` | 结束节点 | 工作流出口 |
| `llm` | 大模型调用 | 调用LLM生成文本、分析数据 |
| `code` | 代码执行 | 执行Python/Shell代码 |
| `database_query` | 数据库查询 | 查询MySQL等数据库 |
| `http_request` | HTTP请求 | 调用REST API |
| `tool` | 工具调用 | 执行SSH、K8s等工具命令 |
| `condition` | 条件判断 | 根据条件选择分支 |
| `loop` | 循环 | 固定次数或条件循环 |
| `parallel` | 并行执行 | 并行执行多个子任务 |
| `variable_assign` | 变量赋值 | 设置变量值 |
| `data_transform` | 数据转换 | 转换数据格式（JSON、CSV等） |

### 节点配置示例

#### LLM节点
```json
{
  "id": "analyze",
  "type": "llm",
  "config": {
    "prompt": "分析以下数据：{{query_db.results}}",
    "model": "qwen-plus",
    "temperature": 0.7
  }
}
```

#### DATABASE_QUERY节点
```json
{
  "id": "query_resources",
  "type": "database_query",
  "config": {
    "connection": {
      "host": "localhost",
      "port": 3306,
      "user": "root",
      "password": "xxx",
      "database": "cloud_resource_db"
    },
    "query": "SELECT * FROM resource_pool WHERE region = 'beijing'"
  }
}
```

#### CODE节点
```json
{
  "id": "process",
  "type": "code",
  "config": {
    "language": "python",
    "code": "result = sum([r['cost'] for r in context.get_node_output('query_db', 'results')])"
  }
}
```

#### CONDITION节点
```json
{
  "id": "check_status",
  "type": "condition",
  "config": {
    "condition": "{{query_db.row_count}} > 0",
    "true_branch": "process_data",
    "false_branch": "send_alert"
  }
}
```

#### LOOP节点
```json
{
  "id": "batch_process",
  "type": "loop",
  "config": {
    "loop_type": "foreach",
    "items": "{{query_db.results}}",
    "body": ["process_item", "save_result"]
  }
}
```

#### PARALLEL节点
```json
{
  "id": "parallel_query",
  "type": "parallel",
  "config": {
    "branches": [
      ["query_beijing", "process_beijing"],
      ["query_shanghai", "process_shanghai"]
    ]
  }
}
```

## 项目结构

```
OpsMind/
├── core/                                # 核心引擎
│   ├── llm_client.py                    # 大模型客户端（支持Anthropic和阿里云）
│   ├── workflow_orchestration/          # 工作流编排子系统
│   │   ├── workflow_generator.py        # 工作流生成器
│   │   ├── workflow_validator.py        # 工作流验证器（5层验证）
│   │   └── node_types.py                # 节点类型定义
│   └── task_execution/                  # 工作流执行子系统
│       ├── workflow_executor.py         # 工作流执行引擎
│       ├── execution_context.py         # 执行上下文
│       ├── variable_resolver.py         # 变量解析器
│       ├── node_executor.py             # 节点执行器基类
│       └── executors/                   # 具体节点执行器
│           ├── llm_executor.py          # LLM执行器
│           ├── code_executor.py         # CODE执行器
│           ├── database_executor.py     # 数据库执行器
│           ├── http_executor.py         # HTTP执行器
│           ├── tool_executor.py         # 工具执行器
│           ├── condition_executor.py    # 条件执行器
│           ├── loop_executor.py         # 循环执行器
│           └── parallel_executor.py     # 并行执行器
├── web/                                 # Web应用
│   ├── backend/                         # FastAPI后端（端口：8024）
│   │   ├── main.py                      # 应用入口
│   │   ├── config.py                    # 配置管理
│   │   ├── api/                         # API路由
│   │   │   ├── workflow.py              # 工作流API
│   │   │   ├── execution.py             # 执行API
│   │   │   └── resource.py              # 资源管理API
│   │   ├── database/                    # 数据库连接
│   │   │   └── connection.py            # 数据库管理器
│   │   └── websocket/                   # WebSocket支持
│   │       └── execution.py             # 实时执行推送
│   └── frontend/                        # React前端（端口：8023）
│       ├── src/
│       │   ├── App.tsx                  # 主应用（路由配置）
│       │   ├── pages/                   # 页面组件
│       │   │   ├── WorkflowPage.tsx     # 工作流页面
│       │   │   └── ResourceListPage.tsx # 资源列表页面
│       │   ├── components/              # UI组件
│       │   │   ├── ChatBox.tsx          # 对话框
│       │   │   ├── WorkflowCanvas.tsx   # 工作流画布
│       │   │   ├── ExecutionMonitor.tsx # 执行监控
│       │   │   ├── NodeDetailPanel.tsx  # 节点详情面板
│       │   │   └── ResourceTable.tsx    # 资源表格
│       │   ├── services/                # API服务
│       │   │   ├── api.ts               # 工作流API
│       │   │   └── resourceApi.ts       # 资源API
│       │   └── types/                   # TypeScript类型
│       │       ├── workflow.ts          # 工作流类型
│       │       └── resource.ts          # 资源类型
│       └── package.json                 # 前端依赖
├── examples/
│   └── demo_scenarios/
│       └── cloud_resource_management/   # 云资源管理Demo
│           ├── database/                # MySQL数据库schema
│           ├── scripts/                 # 数据库初始化脚本
│           └── test/                    # 测试脚本
│               ├── workflow_generation/ # 工作流生成测试
│               ├── workflow_execution/  # 工作流执行测试
│               └── scenarios/           # 业务场景测试
└── utils/                               # 工具函数
```

## 开发进度

- [x] **Phase 1**: 工作流自动生成 + 可视化
  - [x] 自然语言 → 工作流JSON
  - [x] 5层验证规则
  - [x] Graphviz可视化
  - [x] 12种节点类型定义
- [x] **Phase 2**: 工作流执行引擎
  - [x] DAG拓扑排序
  - [x] 变量引用系统
  - [x] 12种节点执行器
  - [x] 执行上下文管理
  - [x] 错误处理和日志
- [x] **Phase 3**: Web应用
  - [x] FastAPI后端（工作流生成、执行、资源管理API）
  - [x] React前端（工作流可视化、实时执行监控）
  - [x] WebSocket实时推送
  - [x] 资源列表管理（查询、筛选、分页）
  - [x] 节点详情面板
- [ ] **Phase 4**: 高级特性
  - [ ] 工作流调试器（断点、单步执行）
  - [ ] 工作流监控（实时状态、性能指标）
  - [ ] 工作流持久化（保存执行历史）
  - [ ] 用户认证和权限管理

## Demo场景

### 云资源管理

完整的云资源管理场景，包含MySQL数据库和50+资源数据。

**启动数据库：**
```bash
cd examples/demo_scenarios/cloud_resource_management
bash scripts/setup_database.sh
```

**测试场景：**
```bash
# 场景1：资源查询
python test/scenarios/test_resource_query.py

# 场景2：资源分配
python test/scenarios/test_resource_allocation.py

# 场景3：资源优化
python test/scenarios/test_resource_optimization.py
```

**端到端Demo：**
```bash
# 真实数据库查询（北京地区A100 GPU）
python test/workflow_execution/demo_real_database_query.py

# 真实数据库查询（上海地区GPU）
python test/workflow_execution/demo_real_db_shanghai.py
```

## 技术栈

**后端：**
- Python 3.8+
- FastAPI（Web框架）
- PyMySQL（数据库连接）
- WebSocket（实时通信）
- 大模型：Claude / 阿里云通义千问

**前端：**
- React 19 + TypeScript
- Ant Design（UI组件库）
- React Flow（工作流可视化）
- Axios（HTTP客户端）
- React Router（路由管理）

**可视化：**
- Graphviz（命令行工作流图）
- React Flow（Web工作流画布）


## License

## TODO
1. Host的终端命令输入

MIT