Skip to content

RAGFlow 工作流系统可视化架构图表

1. 系统总体架构图

mermaid
graph TB
    subgraph "用户界面层 UI Layer"
        A1[工作流编辑器] --> A2[节点库面板]
        A2 --> A3[属性配置面板] 
        A3 --> A4[执行控制台]
        A4 --> A5[调试面板]
    end
    
    subgraph "前端核心层 Frontend Core"
        B1[React Flow Canvas] --> B2[节点管理器]
        B2 --> B3[状态管理 Zustand]
        B3 --> B4[表单系统]
        B4 --> B5[API服务层]
    end
    
    subgraph "通信层 Communication"
        C1[RESTful API] --> C2[Server-Sent Events]
        C2 --> C3[WebSocket备用]
        C3 --> C4[错误处理]
    end
    
    subgraph "后端核心层 Backend Core"
        D1[Flask路由层] --> D2[Canvas执行引擎]
        D2 --> D3[组件工厂]
        D3 --> D4[依赖解析器]
        D4 --> D5[并行调度器]
    end
    
    subgraph "组件生态 Component Ecosystem"
        E1[核心组件库] --> E2[RAG组件]
        E2 --> E3[流控制组件]
        E3 --> E4[外部服务组件]
        E4 --> E5[自定义组件]
    end
    
    subgraph "数据存储层 Data Layer"
        F1[工作流定义] --> F2[执行历史]
        F2 --> F3[组件配置]
        F3 --> F4[用户会话]
        F4 --> F5[缓存系统]
    end
    
    subgraph "外部集成 External Integration"
        G1[LLM服务商] --> G2[向量数据库]
        G2 --> G3[搜索引擎]
        G3 --> G4[第三方API]
        G4 --> G5[文件存储]
    end
    
    A1 --> B1
    B5 --> C1
    C1 --> D1
    D2 --> E1
    D2 --> F1
    E2 --> G1
    E4 --> G3

2. 前端节点开发生命周期

mermaid
sequenceDiagram
    participant Dev as 开发者
    participant Enum as 操作符枚举
    participant Comp as 节点组件
    participant Form as 配置表单
    participant Store as 状态管理
    participant Canvas as 画布
    
    Dev->>Enum: 1. 定义新操作符类型
    Dev->>Comp: 2. 创建节点组件
    Comp->>Store: 注册节点类型
    
    Dev->>Form: 3. 创建配置表单
    Form->>Store: 注册表单组件
    
    Dev->>Canvas: 4. 更新映射关系
    Canvas->>Store: 更新节点配置
    
    Note over Dev,Canvas: 运行时流程
    
    Store->>Canvas: 拖拽创建节点
    Canvas->>Comp: 渲染节点组件
    Comp->>Form: 点击配置节点
    Form->>Store: 更新节点数据
    Store->>Canvas: 实时更新显示

3. 后端组件架构层次图

mermaid
classDiagram
    direction TB
    
    class ComponentParamBase {
        <<abstract>>
        +_vars: Dict
        +_req_vars: Set[str]
        +update(dict) void
        +check() void
        +to_dict() Dict
    }
    
    class ComponentBase {
        <<abstract>>
        +component_id: str
        +_param: ComponentParamBase
        +_canvas: Canvas
        +_upstream: List[str]
        +_downstream: List[str]
        +_run(history) DataFrame*
        +get_input() DataFrame
        +output(start_at) DataFrame
    }
    
    class GenerateParam {
        +llm_id: str
        +prompt: str
        +temperature: float
        +max_tokens: int
        +cite: bool
    }
    
    class Generate {
        +_run(history) DataFrame
        +_chat(query, history) str
        +_stream_chat(query, history) Iterator
    }
    
    class RetrievalParam {
        +kb_ids: List[str]
        +similarity_threshold: float
        +keywords_similarity_weight: float
        +top_n: int
    }
    
    class Retrieval {
        +_run(history) DataFrame
        +_search(query) List[Chunk]
        +_rerank(chunks, query) List[Chunk]
    }
    
    class SwitchParam {
        +conditions: List[Condition]
        +logical_operator: str
    }
    
    class Switch {
        +_run(history) DataFrame
        +_evaluate_conditions(data) bool
        +_route_output(condition_result) str
    }
    
    ComponentParamBase <|-- GenerateParam
    ComponentParamBase <|-- RetrievalParam
    ComponentParamBase <|-- SwitchParam
    
    ComponentBase <|-- Generate
    ComponentBase <|-- Retrieval
    ComponentBase <|-- Switch
    
    Generate --> GenerateParam
    Retrieval --> RetrievalParam
    Switch --> SwitchParam

4. 工作流执行引擎状态机

mermaid
stateDiagram-v2
    [*] --> Idle: 初始化
    
    Idle --> Loading: 加载DSL
    Loading --> Ready: 解析成功
    Loading --> Error: 解析失败
    
    Ready --> Running: 开始执行
    
    state Running {
        [*] --> ComponentInit: 初始化组件
        ComponentInit --> DependencyCheck: 检查依赖
        DependencyCheck --> WaitingDeps: 等待依赖
        DependencyCheck --> Executing: 依赖就绪
        WaitingDeps --> Executing: 依赖完成
        
        Executing --> ComponentComplete: 组件完成
        Executing --> ComponentError: 组件错误
        
        ComponentComplete --> NextComponent: 继续下一个
        NextComponent --> DependencyCheck: 检查下一组件
        NextComponent --> Finished: 所有组件完成
        
        ComponentError --> ErrorHandling: 错误处理
        ErrorHandling --> Finished: 终止执行
        ErrorHandling --> NextComponent: 跳过错误
    }
    
    Running --> Completed: 正常完成
    Running --> Failed: 执行失败
    Running --> Cancelled: 用户取消
    
    Completed --> [*]
    Failed --> [*]
    Cancelled --> [*]
    Error --> [*]

5. 前后端数据流架构

mermaid
flowchart LR
    subgraph "前端数据层"
        A1[React Flow Nodes] --> A2[DSL转换器]
        A2 --> A3[JSON Schema]
        A3 --> A4[API请求]
    end
    
    subgraph "网络传输层"
        B1[HTTP POST] --> B2[SSE Stream]
        B2 --> B3[Error Handler]
        B3 --> B4[Retry Logic]
    end
    
    subgraph "后端处理层"
        C1[Flask Route] --> C2[DSL Parser]
        C2 --> C3[Canvas Engine]
        C3 --> C4[Component Graph]
        C4 --> C5[Execution Queue]
    end
    
    subgraph "组件执行层"
        D1[Component Factory] --> D2[Param Validation]
        D2 --> D3[Input Processing]
        D3 --> D4[Core Logic]
        D4 --> D5[Output Formatting]
    end
    
    subgraph "结果流"
        E1[Streaming Results] --> E2[Progress Updates]
        E2 --> E3[Final Output]
        E3 --> E4[Reference Links]
        E4 --> E5[Error Reports]
    end
    
    A4 --> B1
    B2 --> C1
    C5 --> D1
    D5 --> E1
    E1 --> B2

6. 节点配置系统架构

mermaid
graph TB
    subgraph "配置界面层"
        A1[节点选择] --> A2[配置面板]
        A2 --> A3[表单渲染]
        A3 --> A4[实时预览]
        A4 --> A5[验证提示]
    end
    
    subgraph "表单组件库"
        B1[基础输入组件] --> B2[选择器组件]
        B2 --> B3[富文本编辑器]
        B3 --> B4[JSON编辑器]
        B4 --> B5[条件字段]
    end
    
    subgraph "数据绑定层"
        C1[表单状态] --> C2[变化监听]
        C2 --> C3[数据验证]
        C3 --> C4[格式转换]
        C4 --> C5[节点更新]
    end
    
    subgraph "配置模板"
        D1[默认配置] --> D2[预设模板]
        D2 --> D3[用户模板]
        D3 --> D4[配置导入]
        D4 --> D5[配置导出]
    end
    
    A3 --> B1
    B5 --> C1
    C5 --> D1
    D5 --> A2

7. 组件注册和发现机制

mermaid
sequenceDiagram
    participant Loader as 组件加载器
    participant Factory as 组件工厂
    participant Registry as 组件注册表
    participant Param as 参数类
    participant Comp as 组件类
    participant Canvas as 执行画布
    
    Note over Loader,Canvas: 系统启动阶段
    
    Loader->>Factory: 扫描组件目录
    Factory->>Registry: 注册组件类型
    Registry->>Param: 验证参数类
    Registry->>Comp: 验证组件类
    
    Note over Loader,Canvas: 运行时阶段
    
    Canvas->>Factory: 请求创建组件
    Factory->>Registry: 查找组件类型
    Registry->>Factory: 返回组件类
    Factory->>Param: 创建参数实例
    Factory->>Comp: 创建组件实例
    Comp->>Canvas: 返回可执行组件

8. 实时执行监控架构

mermaid
graph TB
    subgraph "执行监控前端"
        A1[执行状态显示] --> A2[进度条]
        A2 --> A3[实时日志]
        A3 --> A4[性能指标]
        A4 --> A5[错误警报]
    end
    
    subgraph "SSE通信层"
        B1[事件源连接] --> B2[消息解析]
        B2 --> B3[状态更新]
        B3 --> B4[断线重连]
        B4 --> B5[缓冲管理]
    end
    
    subgraph "后端监控系统"
        C1[执行追踪] --> C2[状态收集]
        C2 --> C3[指标计算]
        C3 --> C4[事件推送]
        C4 --> C5[历史记录]
    end
    
    subgraph "调试工具"
        D1[断点设置] --> D2[单步执行]
        D2 --> D3[变量检查]
        D3 --> D4[调用栈]
        D4 --> D5[性能分析]
    end
    
    A1 --> B1
    B3 --> C1
    C4 --> B2
    A5 --> D1

9. 错误处理和恢复机制

mermaid
flowchart TD
    A[组件执行] --> B{执行成功?}
    
    B -->|是| C[记录成功状态]
    B -->|否| D[捕获错误信息]
    
    D --> E{错误类型}
    
    E -->|参数错误| F[显示配置提示]
    E -->|网络错误| G[自动重试机制]
    E -->|逻辑错误| H[错误日志记录]
    E -->|系统错误| I[紧急停止]
    
    F --> J[用户修正参数]
    G --> K{重试次数}
    H --> L[继续执行下一组件]
    I --> M[工作流终止]
    
    K -->|< 3次| N[延迟重试]
    K -->|>= 3次| O[标记失败]
    
    N --> A
    O --> P[通知用户]
    
    J --> Q{参数验证}
    Q -->|通过| A
    Q -->|失败| F
    
    C --> R[继续执行]
    L --> R
    P --> S[错误报告]
    M --> S

10. 性能优化策略图

mermaid
mindmap
  root((性能优化))
    前端优化
      虚拟化渲染
        大型工作流视窗内渲染
        节点懒加载
        边线简化
      状态管理优化
        Immer不可变更新
        选择性重渲染
        缓存计算结果
      网络优化
        请求去重
        结果缓存
        预加载机制
    
    后端优化
      并行执行
        依赖分析
        任务调度
        资源管理
      缓存策略
        组件结果缓存
        参数化缓存
        LRU过期策略
      资源管理
        连接池
        内存管理
        异步处理
    
    架构优化
      微服务分离
        组件服务化
        独立部署
        水平扩展
      数据库优化
        索引优化
        查询优化
        分片策略
      CDN加速
        静态资源
        全球分发
        边缘计算

11. 扩展开发路径图

mermaid
journey
    title 新组件开发旅程
    
    section 需求分析
      确定组件功能: 3: 产品经理
      设计API接口: 4: 架构师
      评估技术可行性: 4: 技术专家
    
    section 后端开发
      创建参数类: 5: 后端开发
      实现组件逻辑: 5: 后端开发
      编写单元测试: 4: 后端开发
      集成测试验证: 3: 测试工程师
    
    section 前端开发
      设计节点UI: 4: 前端开发
      实现配置表单: 5: 前端开发
      添加交互逻辑: 4: 前端开发
      样式优化调整: 3: UI设计师
    
    section 集成测试
      端到端测试: 4: 全栈开发
      性能测试: 3: 性能工程师
      用户体验测试: 5: UX设计师
    
    section 部署发布
      代码审查: 4: 技术专家
      文档编写: 3: 技术写作
      发布部署: 5: DevOps工程师
      用户培训: 4: 产品经理

12. 系统监控大屏架构

mermaid
graph TB
    subgraph "数据采集层"
        A1[前端性能指标] --> A2[用户行为统计]
        A2 --> A3[API响应时间]
        A3 --> A4[组件执行时间]
        A4 --> A5[错误率统计]
    end
    
    subgraph "数据处理层"
        B1[实时流处理] --> B2[批量数据处理]
        B2 --> B3[指标聚合]
        B3 --> B4[异常检测]
        B4 --> B5[趋势分析]
    end
    
    subgraph "存储层"
        C1[时序数据库] --> C2[关系数据库]
        C2 --> C3[缓存系统]
        C3 --> C4[搜索引擎]
        C4 --> C5[文件存储]
    end
    
    subgraph "可视化层"
        D1[实时监控大屏] --> D2[历史趋势图表]
        D2 --> D3[告警仪表板]
        D3 --> D4[性能分析报告]
        D4 --> D5[用户行为分析]
    end
    
    subgraph "告警系统"
        E1[阈值监控] --> E2[异常检测]
        E2 --> E3[告警规则引擎]
        E3 --> E4[通知分发]
        E4 --> E5[告警升级]
    end
    
    A1 --> B1
    B5 --> C1
    C1 --> D1
    B4 --> E1

这些图表全面展示了RAGFlow工作流系统的架构设计、开发流程、数据流向、错误处理、性能优化和扩展策略,为开发者提供了清晰的可视化指导。