# 开发低代码智能体平台 - 完整开发提示词

## 📋 项目概述

你是一位资深的全栈开发专家，负责开发一个**工作流和Agent低代码智能体平台**。该平台需要支持可视化工作流设计、智能Agent配置、低代码开发等功能。

---

## 🏗️ 技术架构

### 核心技术栈

**前端技术栈**:
- 框架: Vue 3 + TypeScript + Vite
- 状态管理: Pinia
- UI组件库: Element Plus / Ant Design Vue
- 工作流可视化: Vue Flow
- HTTP客户端: Axios
- WebSocket: Socket.io Client
- 路由: Vue Router
- 表单验证: VeeValidate
- 代码编辑器: Monaco Editor

**后端技术栈**:
- API框架: Python FastAPI
- 任务队列: Celery + Redis
- 缓存/队列: Redis
- 数据库: PostgreSQL
- ORM: SQLAlchemy
- 数据验证: Pydantic
- Agent框架: LangChain
- RAG框架: LlamaIndex
- 向量数据库: ChromaDB
- WebSocket: FastAPI WebSocket
- API文档: Swagger/OpenAPI

**基础设施**:
- 容器化: Docker + Docker Compose
- 反向代理: Nginx
- 进程管理: Supervisor / systemd
- 监控: Prometheus + Grafana
- 日志: ELK Stack (可选)
- CI/CD: GitHub Actions / GitLab CI

---

## 🎯 核心功能需求

### 1. 低代码工作流设计器

**功能要求**:
- 可视化拖拽式工作流编辑器
- 支持多种节点类型（开始、模板、条件、数据、工具、结束）
- 节点间连线配置
- 节点参数配置面板
- 工作流预览和验证
- 工作流版本管理
- 工作流模板库

**技术实现**:
- 使用 Vue Flow 实现可视化编辑器
- 支持节点拖拽、连线、删除、复制等操作
- 节点配置表单动态生成
- 工作流JSON格式存储
- 实时验证工作流逻辑

### 2. 智能Agent平台

**功能要求**:
- Agent角色定义和配置
- Agent工具链管理
- Agent工作流编排
- 多Agent协作支持
- Agent执行监控
- Agent性能分析

**技术实现**:
- 集成 LangChain Agent框架
- 支持多种Agent类型（ReAct、Plan-and-Execute等）
- 工具注册和管理系统
- Agent执行状态实时推送（WebSocket）
- 执行日志和结果存储

### 3. 工作流执行引擎

**功能要求**:
- 异步任务执行（Celery）
- 实时状态推送（WebSocket）
- 错误处理和重试机制
- 执行历史记录
- 性能监控和分析

**技术实现**:
- FastAPI提供RESTful API
- Celery处理长时间运行的任务
- Redis作为消息代理
- WebSocket推送执行状态
- PostgreSQL存储执行记录

### 4. 低代码开发功能

**功能要求**:
- 代码生成器（Python、前端代码）
- 自定义节点开发
- 模板库管理
- 组件市场

**技术实现**:
- 基于工作流定义生成代码
- 支持自定义节点插件系统
- 模板存储和管理
- 组件导入导出功能

---

## 📐 项目结构设计

### 前端项目结构

```
frontend/
├── src/
│   ├── api/              # API接口封装
│   ├── assets/           # 静态资源
│   ├── components/       # 公共组件
│   │   ├── WorkflowEditor/    # 工作流编辑器
│   │   ├── NodePanel/         # 节点配置面板
│   │   ├── AgentConfig/       # Agent配置组件
│   │   └── CodeGenerator/     # 代码生成器
│   ├── composables/      # 组合式函数
│   ├── layouts/          # 布局组件
│   ├── router/           # 路由配置
│   ├── stores/           # Pinia状态管理
│   │   ├── workflow.ts   # 工作流状态
│   │   ├── agent.ts     # Agent状态
│   │   └── user.ts      # 用户状态
│   ├── types/            # TypeScript类型定义
│   ├── utils/            # 工具函数
│   └── views/            # 页面组件
│       ├── WorkflowDesigner.vue
│       ├── AgentStudio.vue
│       └── CodeGenerator.vue
├── public/
└── package.json
```

### 后端项目结构

```
backend/
├── app/
│   ├── api/              # API路由
│   │   ├── workflows.py  # 工作流API
│   │   ├── agents.py    # Agent API
│   │   └── executions.py # 执行API
│   ├── core/             # 核心功能
│   │   ├── config.py     # 配置
│   │   ├── security.py   # 安全
│   │   └── database.py   # 数据库
│   ├── models/           # 数据模型
│   │   ├── workflow.py
│   │   ├── agent.py
│   │   └── execution.py
│   ├── services/         # 业务逻辑
│   │   ├── workflow_engine.py  # 工作流引擎
│   │   ├── agent_service.py   # Agent服务
│   │   └── code_generator.py  # 代码生成
│   ├── tasks/            # Celery任务
│   │   ├── workflow_tasks.py
│   │   └── agent_tasks.py
│   ├── websocket/        # WebSocket处理
│   └── utils/            # 工具函数
├── tests/                # 测试
├── alembic/              # 数据库迁移
├── requirements.txt
└── main.py
```

---

## 🔧 开发任务清单

### 阶段一: 项目初始化（1-2周）

#### 1.1 前端项目搭建
- [ ] 使用 Vite 创建 Vue 3 + TypeScript 项目
- [ ] 配置 ESLint、Prettier
- [ ] 安装核心依赖（Vue Flow、Pinia、Element Plus等）
- [ ] 配置路由和布局
- [ ] 设置API请求拦截器
- [ ] 配置WebSocket连接

#### 1.2 后端项目搭建
- [ ] 创建 FastAPI 项目结构
- [ ] 配置数据库连接（PostgreSQL）
- [ ] 配置 Redis 连接
- [ ] 设置 Celery 任务队列
- [ ] 配置 CORS 和中间件
- [ ] 设置日志系统
- [ ] 配置环境变量管理

#### 1.3 数据库设计
- [ ] 设计工作流表结构
- [ ] 设计Agent表结构
- [ ] 设计执行记录表结构
- [ ] 设计用户和权限表
- [ ] 创建数据库迁移脚本

### 阶段二: 核心功能开发（4-6周）

#### 2.1 工作流编辑器开发
- [ ] 实现 Vue Flow 基础编辑器
- [ ] 实现节点拖拽功能
- [ ] 实现节点连线功能
- [ ] 实现节点配置面板
- [ ] 实现工作流保存和加载
- [ ] 实现工作流验证逻辑
- [ ] 实现节点类型扩展机制

#### 2.2 工作流引擎开发
- [ ] 实现工作流执行引擎核心逻辑
- [ ] 实现节点执行器（模板、条件、数据等）
- [ ] 实现数据流转机制
- [ ] 实现错误处理和重试
- [ ] 实现执行状态管理
- [ ] 集成 Celery 异步任务

#### 2.3 Agent平台开发
- [ ] 实现Agent配置界面
- [ ] 集成 LangChain Agent框架
- [ ] 实现工具注册和管理
- [ ] 实现Agent执行逻辑
- [ ] 实现多Agent协作机制
- [ ] 实现Agent监控和分析

#### 2.4 实时通信开发
- [ ] 实现 FastAPI WebSocket
- [ ] 实现前端 WebSocket 客户端
- [ ] 实现执行状态实时推送
- [ ] 实现消息队列集成

### 阶段三: 低代码功能开发（2-3周）

#### 3.1 代码生成器开发
- [ ] 实现Python工作流引擎代码生成
- [ ] 实现前端组件代码生成
- [ ] 实现API接口代码生成
- [ ] 实现代码模板管理
- [ ] 实现代码预览和下载

#### 3.2 模板和组件库
- [ ] 实现工作流模板库
- [ ] 实现自定义节点开发
- [ ] 实现组件导入导出
- [ ] 实现模板市场功能

### 阶段四: 系统集成和优化（2-3周）

#### 4.1 系统集成
- [ ] 集成向量数据库（ChromaDB）
- [ ] 集成RAG框架（LlamaIndex）
- [ ] 实现第三方API集成
- [ ] 实现数据库集成
- [ ] 实现消息队列集成

#### 4.2 性能优化
- [ ] 优化工作流执行性能
- [ ] 优化前端渲染性能
- [ ] 实现缓存机制
- [ ] 优化数据库查询
- [ ] 实现负载均衡

#### 4.3 监控和日志
- [ ] 集成 Prometheus 监控
- [ ] 配置 Grafana 仪表板
- [ ] 实现日志收集和分析
- [ ] 实现告警机制

### 阶段五: 测试和部署（1-2周）

#### 5.1 测试
- [ ] 编写单元测试
- [ ] 编写集成测试
- [ ] 编写端到端测试
- [ ] 性能测试
- [ ] 安全测试

#### 5.2 部署
- [ ] 编写 Dockerfile
- [ ] 编写 docker-compose.yml
- [ ] 配置 Nginx 反向代理
- [ ] 配置 CI/CD 流水线
- [ ] 编写部署文档

---

## 💻 关键代码实现示例

### 1. 工作流执行引擎（Python）

```python
# app/services/workflow_engine.py
from typing import Dict, Any, List
from celery import Task
import asyncio
from langchain.llms import OpenAI
from langchain.agents import initialize_agent

class WorkflowEngine:
    def __init__(self, workflow_id: str):
        self.workflow_id = workflow_id
        self.llm = OpenAI(temperature=0.7)
        self.nodes = []
        self.edges = []
    
    async def execute_node(self, node: Dict[str, Any], input_data: Dict[str, Any]) -> Dict[str, Any]:
        """执行单个节点"""
        node_type = node.get('type')
        
        if node_type == 'template':
            # 模板节点：调用AI模型
            prompt = self.build_prompt(node, input_data)
            result = await self.llm.agenerate([prompt])
            return {'output': result.generations[0][0].text}
        
        elif node_type == 'condition':
            # 条件节点：判断分支
            condition = node.get('condition')
            result = self.evaluate_condition(condition, input_data)
            return {'output': result, 'branch': 'true' if result else 'false'}
        
        elif node_type == 'data':
            # 数据节点：数据转换
            mapping = node.get('mapping')
            result = self.transform_data(input_data, mapping)
            return {'output': result}
        
        elif node_type == 'agent':
            # Agent节点：执行Agent
            agent = initialize_agent(
                tools=node.get('tools', []),
                llm=self.llm,
                agent="zero-shot-react-description"
            )
            result = await agent.arun(node.get('task'))
            return {'output': result}
        
        else:
            raise ValueError(f"Unknown node type: {node_type}")
    
    async def execute(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
        """执行完整工作流"""
        workflow = self.load_workflow()
        self.nodes = workflow['nodes']
        self.edges = workflow['edges']
        
        # 构建执行图
        execution_graph = self.build_execution_graph()
        
        # 按拓扑顺序执行
        results = {}
        node_outputs = {'start': input_data}
        
        for node_id in execution_graph:
            node = self.get_node_by_id(node_id)
            node_input = self.get_node_input(node_id, node_outputs)
            
            result = await self.execute_node(node, node_input)
            results[node_id] = result
            node_outputs[node_id] = result['output']
        
        return results
```

### 2. 工作流编辑器（Vue 3）

```vue
<!-- src/components/WorkflowEditor/WorkflowEditor.vue -->
<template>
  <div class="workflow-editor">
    <VueFlow
      v-model="nodes"
      v-model:edges="edges"
      :node-types="nodeTypes"
      @node-click="onNodeClick"
      @edge-click="onEdgeClick"
      @pane-ready="onPaneReady"
    >
      <Background />
      <Controls />
      <MiniMap />
      <NodeToolbar />
    </VueFlow>
    
    <NodeConfigPanel
      v-if="selectedNode"
      :node="selectedNode"
      @save="handleNodeSave"
      @close="selectedNode = null"
    />
  </div>
</template>

<script setup lang="ts">
import { ref, computed } from 'vue'
import { VueFlow, useVueFlow, Background, Controls, MiniMap } from '@vue-flow/core'
import NodeConfigPanel from './NodeConfigPanel.vue'
import { useWorkflowStore } from '@/stores/workflow'

const workflowStore = useWorkflowStore()
const { nodes, edges, addNodes, addEdges } = useVueFlow()
const selectedNode = ref(null)

const nodeTypes = {
  start: StartNode,
  template: TemplateNode,
  condition: ConditionNode,
  data: DataNode,
  agent: AgentNode,
  end: EndNode
}

const onNodeClick = (event: NodeClickEvent) => {
  selectedNode.value = event.node
}

const handleNodeSave = (nodeData: any) => {
  workflowStore.updateNode(nodeData)
  selectedNode.value = null
}

const saveWorkflow = async () => {
  const workflow = {
    nodes: nodes.value,
    edges: edges.value
  }
  await workflowStore.saveWorkflow(workflow)
}
</script>
```

### 3. FastAPI工作流API

```python
# app/api/workflows.py
from fastapi import APIRouter, Depends, WebSocket
from sqlalchemy.orm import Session
from app.core.database import get_db
from app.services.workflow_engine import WorkflowEngine
from app.tasks.workflow_tasks import execute_workflow_task
from app.models.workflow import Workflow

router = APIRouter(prefix="/api/workflows", tags=["workflows"])

@router.post("/")
async def create_workflow(workflow_data: dict, db: Session = Depends(get_db)):
    """创建工作流"""
    workflow = Workflow(**workflow_data)
    db.add(workflow)
    db.commit()
    return {"id": workflow.id, "status": "created"}

@router.post("/{workflow_id}/execute")
async def execute_workflow(workflow_id: str, input_data: dict, db: Session = Depends(get_db)):
    """执行工作流"""
    task = execute_workflow_task.delay(workflow_id, input_data)
    return {"task_id": task.id, "status": "pending"}

@router.get("/executions/{task_id}")
async def get_execution_status(task_id: str):
    """获取执行状态"""
    from app.core.celery_app import celery_app
    task = celery_app.AsyncResult(task_id)
    return {
        "task_id": task_id,
        "status": task.status,
        "result": task.result if task.ready() else None
    }

@router.websocket("/executions/{task_id}/ws")
async def websocket_execution_status(websocket: WebSocket, task_id: str):
    """WebSocket实时推送执行状态"""
    await websocket.accept()
    # 实现实时状态推送逻辑
    while True:
        status = get_task_status(task_id)
        await websocket.send_json(status)
        await asyncio.sleep(1)
```

### 4. Celery任务定义

```python
# app/tasks/workflow_tasks.py
from celery import Task
from app.core.celery_app import celery_app
from app.services.workflow_engine import WorkflowEngine
from app.websocket.manager import WebSocketManager

@celery_app.task(bind=True)
def execute_workflow_task(self, workflow_id: str, input_data: dict):
    """执行工作流任务"""
    try:
        engine = WorkflowEngine(workflow_id)
        
        # 更新任务状态
        self.update_state(state='PROGRESS', meta={'progress': 0})
        
        # 执行工作流
        result = asyncio.run(engine.execute(input_data))
        
        # 通过WebSocket推送结果
        WebSocketManager.broadcast(workflow_id, {
            'status': 'completed',
            'result': result
        })
        
        return result
    except Exception as e:
        # 错误处理
        WebSocketManager.broadcast(workflow_id, {
            'status': 'failed',
            'error': str(e)
        })
        raise
```

---

## 🎨 UI/UX设计要点

### 1. 工作流编辑器界面
- 左侧：节点工具箱（可拖拽的节点类型）
- 中间：画布区域（工作流可视化编辑）
- 右侧：节点配置面板（选中节点时显示）
- 顶部：工具栏（保存、运行、预览等）
- 底部：执行日志和状态栏

### 2. Agent配置界面
- Agent基本信息配置
- 工具链选择和管理
- 提示词编辑器
- 参数调优面板
- 测试和预览功能

### 3. 代码生成器界面
- 代码模板选择
- 参数配置表单
- 代码预览（语法高亮）
- 下载和导出功能

---

## 🔒 安全和权限

### 1. 认证和授权
- JWT Token认证
- 基于角色的访问控制（RBAC）
- API接口权限控制
- 工作流和Agent的访问权限

### 2. 数据安全
- 敏感数据加密存储
- API请求加密传输（HTTPS）
- 工作流执行日志脱敏
- 数据备份和恢复机制

### 3. 安全审计
- 操作日志记录
- 异常行为检测
- 安全漏洞扫描
- 合规性检查

---

## 📊 性能优化策略

### 1. 前端优化
- 代码分割