Simon
901 lines
40 KiB
Markdown
901 lines
40 KiB
Markdown
# 重构方案 - 复杂场景技术实现方案
|
||
|
||
> 文档版本：v1.1
|
||
> 日期：2026-07-03
|
||
> **设计理念**：借鉴 TeliChat "让代码负责业务逻辑，让模型负责语言理解"
|
||
|
||
---
|
||
|
||
## 零、设计理念：TeliChat 三重约束
|
||
|
||
> **核心理念**：借鉴 TeliChat 白盒架构，确保复杂对话场景的可靠性
|
||
|
||
### 0.1 三重约束机制
|
||
|
||
| 约束 | 作用 | 实现方式 |
|
||
|------|------|---------|
|
||
| **拓扑结构限制** | 限制对话可以走到哪里 | Neo4j DAG 边定义 |
|
||
| **信息状态约束** | 决定当前已经知道什么 | 信息项组合状态 |
|
||
| **Python 代码约束** | 负责真正的业务判断 | FastAPI 业务逻辑 |
|
||
|
||
### 0.2 信息项修饰机制
|
||
|
||
| 修饰 | 含义 | 在复杂场景中的应用 |
|
||
|------|------|------------------|
|
||
| `固定` | 用户回答后不再重复询问 | 已通过系统获取的信息（操作系统、用户名） |
|
||
| `增量` | 允许用户补充新信息 | 故障描述、错误信息 — **非线性跳转核心** |
|
||
| `明确` | 必须明确回答 | 紧急程度确认 — **信息更正核心** |
|
||
| `隐含` | 可以从上下文推断 | AI 推断的问题类型 |
|
||
| `复述` | 要求用户确认信息正确性 | 重要操作确认 — **信息更正核心** |
|
||
| `必需` | 必须填写才能进入下一节点 | 必填字段 — **任务中断恢复核心** |
|
||
|
||
### 0.3 全局意图类型
|
||
|
||
| 意图 | 用户表达示例 | 处理策略 | 对应场景 |
|
||
|------|-------------|---------|---------|
|
||
| `SKIP` | "这个问题先不管了" | 跳过当前节点，记录未完成 | 非线性跳转 |
|
||
| `INSERT` | "对了，我的打印机也有问题" | 插入新任务到队列 | 多意图并行 |
|
||
| `RESUME` | "还是说回刚才那个网络问题" | 恢复之前话题 | 任务中断恢复 |
|
||
| `SWITCH` | "先帮我看看VPN吧" | 切换到指定话题 | 非线性跳转 |
|
||
| `CORRECT` | "刚才说错了，是win10" | 更新信息项值 | 信息更正 |
|
||
| `SUPPLEMENT` | "再补充一下，是财务部的电脑" | 增量补充信息 | 信息更正 |
|
||
| `PAUSE` | "我先去开会，等会继续" | 保存状态，等待恢复 | 任务中断恢复 |
|
||
| `RESUME_TASK` | "好了，继续吧" | 恢复中断的任务 | 任务中断恢复 |
|
||
| `ESCALATE` | "叫个人工来" | 转接坐席 | 所有场景 |
|
||
|
||
### 0.4 状态驱动流程
|
||
|
||
```python
|
||
def determine_next_node(topology, information_items, user_intent):
|
||
"""
|
||
根据三重因素确定下一个节点
|
||
"""
|
||
|
||
# 1. 拓扑约束：检查意图是否在允许的路径上
|
||
allowed_paths = topology.get_allowed_paths(current_node)
|
||
if user_intent not in allowed_paths:
|
||
return handle_off_path_intent(user_intent)
|
||
|
||
# 2. 信息项检查：是否满足必填信息要求
|
||
required_items = topology.get_required_items(next_node)
|
||
for item in required_items:
|
||
if not information_items[item].is_filled:
|
||
return PromptForItem(item)
|
||
|
||
# 3. 业务逻辑：Python 代码执行判断
|
||
if should_escalate(information_items):
|
||
return TransferToAgent()
|
||
|
||
return ExecuteNode(next_node)
|
||
```
|
||
|
||
---
|
||
|
||
## 一、非线性跳转
|
||
|
||
### 1.1 场景描述
|
||
|
||
用户在对话过程中不按线性路径跳转，而是随时切换话题或返回上一步。
|
||
|
||
**示例**：
|
||
```
|
||
用户：我想开VPN
|
||
AI：请问是个人用途还是团队用途？
|
||
用户：先说说团队 VPN 是什么（跳转到知识了解）
|
||
AI：（介绍团队VPN）
|
||
用户：算了，我还是开个人的吧（返回原话题）
|
||
AI：好的，个人VPN开通需要...
|
||
```
|
||
|
||
### 1.2 技术架构
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ 用户对话 │
|
||
└─────────────────────────────┬───────────────────────────────────┘
|
||
│
|
||
▼
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ Dify LLM 推理层 │
|
||
│ ┌─────────────────┐ ┌─────────────────┐ ┌───────────────┐ │
|
||
│ │ 意图理解 │ │ 上下文追踪 │ │ 路径规划 │ │
|
||
│ │ Intent Parser │ │ Context Track │ │ Path Planner │ │
|
||
│ └─────────────────┘ └─────────────────┘ └───────────────┘ │
|
||
└─────────────────────────────┬───────────────────────────────────┘
|
||
│
|
||
▼
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ Neo4j 知识图谱 │
|
||
│ ┌─────────────────────────────────────────────────────────┐ │
|
||
│ │ IT_SUPPORT_GRAPH │ │
|
||
│ │ │ │
|
||
│ │ [VPN问题] ──[可选]──> [个人VPN] │ │
|
||
│ │ │ │ │
|
||
│ │ [可选] │ │
|
||
│ │ │ │ │
|
||
│ │ └───[可选]──> [团队VPN] ──[子节点]──> [使用场景] │ │
|
||
│ │ │ │
|
||
│ └─────────────────────────────────────────────────────────┘ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### 1.3 知识图谱设计
|
||
|
||
```cypher
|
||
// 节点设计
|
||
CREATE (vpn:Issue {name: "VPN开通", category: "网络"})
|
||
CREATE (personal:Action {name: "个人VPN开通"})
|
||
CREATE (team:Action {name: "团队VPN开通"})
|
||
CREATE (usage:Info {name: "使用场景说明"})
|
||
|
||
// 关系设计 - 支持非线性跳转
|
||
CREATE (vpn)-[:LEADS_TO {type: "可选", order: 1}]->(personal)
|
||
CREATE (vpn)-[:LEADS_TO {type: "可选", order: 2}]->(team)
|
||
CREATE (team)-[:LINKS_TO {type: "子节点"}]->(usage)
|
||
|
||
// 跳转关系 - 支持任意跳转
|
||
CREATE (personal)-[:CAN_JUMP_TO {type: "跳转"}]->(team)
|
||
CREATE (team)-[:CAN_JUMP_TO {type: "返回"}]->(vpn)
|
||
CREATE (usage)-[:CAN_JUMP_TO {type: "返回"}]->(team)
|
||
```
|
||
|
||
### 1.4 信息项修饰机制（借鉴 TeliChat）
|
||
|
||
**核心设计**：使用信息项的 `增量` 修饰符支持非线性跳转
|
||
|
||
```python
|
||
# 信息项定义
|
||
class InformationItem:
|
||
name: str # 信息项名称，如 "{故障描述}"
|
||
value: Any # 当前值
|
||
modifiers: List[str] # 修饰符: ["增量"]
|
||
|
||
# 状态追踪
|
||
is_filled: bool # 是否已填写
|
||
is_incremental: bool # 是否允许增量（补充）
|
||
|
||
# 非线性跳转示例
|
||
用户：我想开VPN
|
||
AI：请问是个人用途还是团队用途？
|
||
用户：先说说团队 VPN 是什么（用户切换到"了解"意图）
|
||
|
||
# 信息项状态变化
|
||
information_items = {
|
||
"VPN类型": {"value": None, "modifiers": ["增量"], "is_filled": False},
|
||
}
|
||
# 用户切换话题时，信息项"VPN类型"保留（因为是增量修饰）
|
||
# 用户返回时，可以继续之前的流程
|
||
```
|
||
|
||
### 1.5 全局意图识别支持
|
||
|
||
```python
|
||
# 非线性跳转意图识别
|
||
def detect_jump_intent(user_input: str) -> JumpIntent:
|
||
"""检测跳转意图"""
|
||
|
||
# RESUME - 返回之前话题
|
||
if any(kw in user_input for kw in ["还是说回", "继续刚才", "回到"]):
|
||
return JumpIntent.RESUME
|
||
|
||
# SWITCH - 切换到新话题
|
||
if any(kw in user_input for kw in ["先看", "先帮我看看", "算了"]):
|
||
return JumpIntent.SWITCH
|
||
|
||
# SKIP - 跳过当前问题
|
||
if any(kw in user_input for kw in ["先不管", "跳过", "算了"]):
|
||
return JumpIntent.SKIP
|
||
|
||
return JumpIntent.NONE
|
||
```
|
||
|
||
### 1.6 关键设计点
|
||
|
||
| 设计点 | 方案 | 说明 |
|
||
|--------|------|------|
|
||
| 上下文栈 | 使用栈结构维护对话路径 | 支持"返回上一步" |
|
||
| 节点状态 | 每个节点记录 visited/focused 状态 | 区分已访问和当前节点 |
|
||
| 跳转权限 | 边设计 CAN_JUMP_TO 关系 | 控制哪些节点可以互相跳转 |
|
||
| **信息项修饰** | 使用"增量"修饰符 | **借鉴 TeliChat，支持乱序输入** |
|
||
| **全局意图** | 识别 RESUME/SWITCH/SKIP | **借鉴 TeliChat，控制跳转** |
|
||
|
||
---
|
||
|
||
## 二、多意图并行
|
||
|
||
### 2.1 场景描述
|
||
|
||
用户一次输入包含多个意图，系统需要并行处理后再合并结果。
|
||
|
||
**示例**：
|
||
```
|
||
用户：我电脑开不了机，VPN也连不上
|
||
→ 同时处理2个问题：
|
||
1. 电脑开机问题 → 引导检查电源/硬件
|
||
2. VPN连接问题 → 引导检查网络/账号
|
||
→ 合并输出：两个问题的处理指引
|
||
```
|
||
|
||
### 2.2 技术架构
|
||
|
||
```
|
||
用户输入: "我电脑开不了机，VPN也连不上"
|
||
│
|
||
▼
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ Dify 多意图识别节点 │
|
||
│ ┌─────────────────────────────────────────────────────────┐ │
|
||
│ │ Input: "我电脑开不了机，VPN也连不上" │ │
|
||
│ │ Output: │ │
|
||
│ │ [ │ │
|
||
│ │ {intent: "电脑开机故障", entities: []}, │ │
|
||
│ │ {intent: "VPN连接失败", entities: []} │ │
|
||
│ │ ] │ │
|
||
│ └─────────────────────────────────────────────────────────┘ │
|
||
└─────────────────────────────┬───────────────────────────────────┘
|
||
│
|
||
┌───────────────────┼───────────────────┐
|
||
▼ ▼ ▼
|
||
┌───────────┐ ┌───────────┐ ┌───────────┐
|
||
│ 意图1分支 │ │ 意图2分支 │ │ 意图N分支 │
|
||
│ 电脑开机 │ │ VPN连接 │ │ ... │
|
||
│ 路径推理 │ │ 路径推理 │ │ │
|
||
└─────┬─────┘ └─────┬─────┘ └─────┬─────┘
|
||
│ │ │
|
||
└───────────────────┼───────────────────┘
|
||
▼
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ 结果合并节点 │
|
||
│ ┌─────────────────────────────────────────────────────────┐ │
|
||
│ │ 将多个分支的结果合并为统一回复 │ │
|
||
│ └─────────────────────────────────────────────────────────┘ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### 2.3 Dify 工作流设计
|
||
|
||
```yaml
|
||
# Dify 工作流配置（简化版）
|
||
workflow:
|
||
nodes:
|
||
- id: multi_intent_parser
|
||
type: LLM
|
||
prompt: |
|
||
用户输入: {{input}}
|
||
识别所有意图，以JSON数组返回:
|
||
[{"intent": "意图1", "entities": [...]}, {"intent": "意图2", "entities": [...]}]
|
||
|
||
- id: parallel_branches
|
||
type: parallel
|
||
branches:
|
||
- target: intent_1_handler
|
||
- target: intent_2_handler
|
||
|
||
- id: result_merger
|
||
type: LLM
|
||
prompt: |
|
||
合并以下处理结果为统一回复:
|
||
{{intent_1_result}}
|
||
{{intent_2_result}}
|
||
```
|
||
|
||
### 2.4 知识图谱辅助
|
||
|
||
```cypher
|
||
// 为多意图场景设计聚合节点
|
||
CREATE (multi:IntentGroup {name: "多问题聚合", type: "parallel"})
|
||
|
||
// 并行意图关系
|
||
CREATE (multi)-[:CONTAINS {parallel: true}]->(vpn_issue)
|
||
CREATE (multi)-[:CONTAINS {parallel: true}]->(hardware_issue)
|
||
|
||
// 并行度标记
|
||
MATCH (n)-[r:LEADS_TO]->(m)
|
||
SET r.is_parallel = false // 默认串行
|
||
```
|
||
|
||
### 2.5 信息项聚合管理（借鉴 TeliChat）
|
||
|
||
**核心设计**：多意图对应多个独立的信息项集合
|
||
|
||
```python
|
||
# 多意图场景的信息项设计
|
||
class MultiIntentSession:
|
||
"""多意图会话管理"""
|
||
|
||
# 每个意图对应独立的信息项集合
|
||
intent_items: Dict[str, List[InformationItem]] = {
|
||
"电脑开机": [
|
||
{"name": "故障现象", "modifiers": ["增量", "必需"]},
|
||
{"name": "错误信息", "modifiers": ["增量"]},
|
||
],
|
||
"VPN连接": [
|
||
{"name": "错误代码", "modifiers": ["明确"]},
|
||
{"name": "网络环境", "modifiers": ["隐含"]},
|
||
]
|
||
}
|
||
|
||
def add_intent(self, intent: str):
|
||
"""添加新意图，创建独立信息项集合"""
|
||
if intent not in self.intent_items:
|
||
self.intent_items[intent] = []
|
||
|
||
def get_all_items(self) -> List[InformationItem]:
|
||
"""获取所有意图的信息项"""
|
||
items = []
|
||
for intent_items in self.intent_items.values():
|
||
items.extend(intent_items)
|
||
return items
|
||
```
|
||
|
||
### 2.6 全局意图 INSERT 支持
|
||
|
||
```python
|
||
# INSERT 意图处理
|
||
def handle_insert_intent(user_input: str, session: MultiIntentSession):
|
||
"""处理插入新意图"""
|
||
|
||
# 检测 INSERT 意图
|
||
insert_keywords = ["对了", "还有", "另外", "顺便"]
|
||
if any(kw in user_input for kw in insert_keywords):
|
||
# 识别新意图
|
||
new_intent = llm_recognize_intent(user_input)
|
||
session.add_intent(new_intent)
|
||
|
||
# 并行处理新旧意图
|
||
return process_parallel_intents(session)
|
||
|
||
return None
|
||
```
|
||
|
||
### 2.7 关键设计点
|
||
|
||
| 设计点 | 方案 | 说明 |
|
||
|--------|------|------|
|
||
| 意图识别 | Dify LLM 并行识别 | 使用 Few-shot 提示词模板 |
|
||
| 分支并行 | Dify Parallel Branch | 同时触发多个处理分支 |
|
||
| 结果合并 | Dify LLM 合并 | 智能合并多分支输出 |
|
||
| 冲突检测 | 边设计 CONFLICTS_WITH | 检测意图间冲突 |
|
||
| **信息项聚合** | 每个意图独立信息项集合 | **借鉴 TeliChat，管理多意图状态** |
|
||
| **INSERT 意图** | 检测"对了/还有"等插入语 | **借鉴 TeliChat 全局意图** |
|
||
|
||
---
|
||
|
||
## 三、信息更正
|
||
|
||
### 3.1 场景描述
|
||
|
||
用户在对话过程中更正之前提供的信息，系统需要理解更正并更新上下文。
|
||
|
||
**示例**：
|
||
```
|
||
用户：帮我重置密码，用户名是 zhangsan
|
||
AI：好的，正在为 zhangsan 重置密码...
|
||
用户：不好意思，用户名是 lisi，不是 zhangsan
|
||
AI：好的，已更正，为 lisi 重置密码
|
||
```
|
||
|
||
### 3.2 技术架构
|
||
|
||
```
|
||
用户输入: "不好意思，用户名是 lisi，不是 zhangsan"
|
||
│
|
||
▼
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ Dify 意图理解层 │
|
||
│ ┌─────────────────────────────────────────────────────────┐ │
|
||
│ │ 识别更正意图: │ │
|
||
│ │ { │ │
|
||
│ │ "type": "correction", │ │
|
||
│ │ "field": "username", │ │
|
||
│ │ "old_value": "zhangsan", │ │
|
||
│ │ "new_value": "lisi" │ │
|
||
│ │ } │ │
|
||
│ └─────────────────────────────────────────────────────────┘ │
|
||
└─────────────────────────────┬───────────────────────────────────┘
|
||
│
|
||
▼
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ Neo4j 会话状态图谱 │
|
||
│ ┌─────────────────────────────────────────────────────────┐ │
|
||
│ │ Session(id: xxx) │ │
|
||
│ │ │ │ │
|
||
│ │ ├── [:PROVIDED]─> Field(name: "username", value: "zhangsan") │ │
|
||
│ │ │ │ │
|
||
│ │ └── [:CORRECTED]─> (标记旧值为已更正) │ │
|
||
│ │ │ │ │
|
||
│ │ └──> Field(name: "username", value: "lisi") │ │
|
||
│ └─────────────────────────────────────────────────────────┘ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### 3.3 知识图谱设计
|
||
|
||
```cypher
|
||
// 会话状态节点
|
||
CREATE (session:Session {
|
||
id: "session_123",
|
||
user_id: "user_001",
|
||
created_at: datetime(),
|
||
current_node: "password_reset"
|
||
})
|
||
|
||
// 用户提供的字段（可更正）
|
||
CREATE (session)-[:PROVIDED]->(field1:Field {
|
||
name: "username",
|
||
value: "zhangsan",
|
||
timestamp: datetime(),
|
||
status: "corrected" // 标记为已更正
|
||
})
|
||
|
||
// 更正后的字段
|
||
CREATE (session)-[:PROVIDED]->(field2:Field {
|
||
name: "username",
|
||
value: "lisi",
|
||
timestamp: datetime(),
|
||
status: "active" // 当前有效值
|
||
})
|
||
|
||
// 更正历史关系
|
||
CREATE (field1)-[:CORRECTED_TO {new_value: "lisi", timestamp: datetime()}]->(field2)
|
||
```
|
||
|
||
### 3.4 Dify 工作流设计
|
||
|
||
```yaml
|
||
# 更正处理节点
|
||
nodes:
|
||
- id: correction_detector
|
||
type: LLM
|
||
prompt: |
|
||
检测用户输入是否为信息更正:
|
||
用户输入: {{input}}
|
||
当前已知信息: {{known_fields}}
|
||
|
||
输出JSON:
|
||
{
|
||
"is_correction": true/false,
|
||
"corrected_field": "字段名",
|
||
"old_value": "旧值",
|
||
"new_value": "新值",
|
||
"confidence": 0.0-1.0
|
||
}
|
||
|
||
- id: field_updater
|
||
type: code
|
||
action: |
|
||
# 更新 Neo4j 中的字段状态
|
||
# 1. 标记旧值为 corrected
|
||
# 2. 创建新值节点
|
||
# 3. 建立更正关系
|
||
```
|
||
|
||
### 3.5 信息项修饰机制（借鉴 TeliChat）
|
||
|
||
**核心设计**：使用"增量"+"复述"双修饰实现智能信息更正
|
||
|
||
```python
|
||
# 信息项修饰与更正策略
|
||
class InformationItem:
|
||
modifiers: List[str] # 修饰符组合
|
||
|
||
def handle_update(self, new_value: str, is_correction: bool = False):
|
||
"""处理信息更新"""
|
||
|
||
if "增量" in self.modifiers and not is_correction:
|
||
# 增量模式：追加新值，不覆盖旧值
|
||
self.value = f"{self.value}; {new_value}"
|
||
elif "复述" in self.modifiers:
|
||
# 复述模式：要求用户确认
|
||
self.pending_confirmation = new_value
|
||
return ConfirmationRequest(new_value)
|
||
else:
|
||
# 默认模式：直接覆盖
|
||
self.value = new_value
|
||
|
||
self.is_filled = True
|
||
self.last_updated = datetime.now()
|
||
return None
|
||
|
||
|
||
# 更正示例
|
||
# 用户：不好意思，用户名是 lisi，不是 zhangsan
|
||
# 系统识别 CORRECT 意图，更新信息项
|
||
information_items["用户名"] = {
|
||
"value": "lisi",
|
||
"modifiers": ["明确"], # 原来是"明确"修饰
|
||
"is_filled": True,
|
||
"update_history": ["zhangsan"] # 保留更正历史
|
||
}
|
||
```
|
||
|
||
### 3.6 全局意图 CORRECT/SUPPLEMENT 支持
|
||
|
||
```python
|
||
# 更正意图识别
|
||
def detect_correction_intent(user_input: str) -> CorrectionInfo:
|
||
"""检测更正意图"""
|
||
|
||
correction_patterns = [
|
||
(r"不是(.+)，是(.+)", "swap"), # 不是A，是B
|
||
(r"应该是(.+)", "replace"), # 应该是A
|
||
(r"更正.*?为(.+)", "replace"), # 更正为A
|
||
(r"说错了.*?是(.+)", "replace"), # 说错了是A
|
||
]
|
||
|
||
for pattern, correction_type in correction_patterns:
|
||
match = re.search(pattern, user_input)
|
||
if match:
|
||
return CorrectionInfo(
|
||
type=correction_type,
|
||
old_value=match.group(1) if match.lastindex >= 1 else None,
|
||
new_value=match.group(2) if match.lastindex >= 2 else match.group(1),
|
||
is_correction=True
|
||
)
|
||
|
||
return None
|
||
```
|
||
|
||
### 3.7 关键设计点
|
||
|
||
| 设计点 | 方案 | 说明 |
|
||
|--------|------|------|
|
||
| 更正识别 | Dify LLM | 检测"不是/应该是/更正为"等模式 |
|
||
| 字段版本 | Neo4j 节点版本 | 维护字段历史，支持回溯 |
|
||
| 状态同步 | WS 实时推送 | 更正后立即更新前端状态 |
|
||
| **增量修饰** | 追加而非覆盖 | **借鉴 TeliChat，支持补充** |
|
||
| **复述修饰** | 要求用户确认 | **借鉴 TeliChat，关键信息确认** |
|
||
| **CORRECT 意图** | 识别更正表达 | **借鉴 TeliChat 全局意图** |
|
||
|
||
---
|
||
|
||
## 四、任务中断与恢复
|
||
|
||
### 4.1 场景描述
|
||
|
||
用户在任务进行过程中中断（离开/超时），后续可以恢复继续。
|
||
|
||
**示例**：
|
||
```
|
||
用户：我要开VPN
|
||
AI：请问是个人还是团队用途？
|
||
用户：（离开/超时/未回复）
|
||
|
||
--- 2小时后 ---
|
||
用户：继续刚才的VPN申请
|
||
AI：好的，您刚才选择的是VPN开通，请问是个人还是团队用途？
|
||
（恢复上下文，继续流程）
|
||
```
|
||
|
||
### 4.2 技术架构
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ 任务状态机设计 │
|
||
│ │
|
||
│ ┌─────────┐ 用户输入 ┌─────────┐ 选择个人 ┌─────┐ │
|
||
│ │ START │ ───────────> │ ASK_TYPE│ ──────────> │INPUT│ │
|
||
│ └─────────┘ └─────────┘ └──┬──┘ │
|
||
│ ^ │ │ │
|
||
│ │ │ 恢复 │ │
|
||
│ │ ▼ ▼ │
|
||
│ │ ┌─────────┐ ┌────────┐ │
|
||
│ └─────────────── │ PAUSED │ <──────────── │ RESUME │ │
|
||
│ 恢复 └─────────┘ 用户恢复 └────────┘ │
|
||
│ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### 4.3 知识图谱设计
|
||
|
||
```cypher
|
||
// 任务节点
|
||
CREATE (task:Task {
|
||
id: "task_vpn_001",
|
||
type: "VPN开通",
|
||
status: "paused", // paused / active / completed / cancelled
|
||
created_at: datetime(),
|
||
updated_at: datetime(),
|
||
current_node: "ASK_TYPE",
|
||
user_id: "user_001"
|
||
})
|
||
|
||
// 任务路径历史
|
||
CREATE (task)-[:HAS_HISTORY]->(step1:TaskStep {
|
||
node: "START",
|
||
status: "completed",
|
||
timestamp: datetime()
|
||
})
|
||
CREATE (task)-[:HAS_HISTORY]->(step2:TaskStep {
|
||
node: "ASK_TYPE",
|
||
status: "active",
|
||
timestamp: datetime()
|
||
})
|
||
|
||
// 恢复点
|
||
CREATE (task)-[:CAN_RESUME_FROM {node: "ASK_TYPE"}]->(resume_point:ResumePoint {
|
||
prompt: "请问是个人还是团队用途？",
|
||
options: ["个人", "团队"],
|
||
timestamp: datetime()
|
||
})
|
||
```
|
||
|
||
### 4.4 状态管理
|
||
|
||
```python
|
||
# 任务状态机
|
||
class TaskState:
|
||
STATES = {
|
||
"created": ["active", "cancelled"],
|
||
"active": ["paused", "completed", "cancelled"],
|
||
"paused": ["active", "cancelled", "expired"],
|
||
"completed": [],
|
||
"cancelled": [],
|
||
"expired": ["active"]
|
||
}
|
||
|
||
def pause(self):
|
||
"""任务中断"""
|
||
self.status = "paused"
|
||
self.paused_at = datetime.now()
|
||
self._save_to_neo4j()
|
||
|
||
def resume(self):
|
||
"""任务恢复"""
|
||
if self.status != "paused":
|
||
raise InvalidStateError("只有暂停的任务可以恢复")
|
||
self.status = "active"
|
||
self.resumed_at = datetime.now()
|
||
self._save_to_neo4j()
|
||
```
|
||
|
||
### 4.5 恢复触发
|
||
|
||
| 触发方式 | 说明 |
|
||
|----------|------|
|
||
| 关键字恢复 | 用户输入"继续/恢复/接着刚才" |
|
||
| 菜单恢复 | 提供"我的任务"入口 |
|
||
| 超时恢复 | 定时任务检测暂停任务，恢复后通知用户 |
|
||
| 坐席恢复 | 坐席手动恢复用户任务 |
|
||
|
||
```cypher
|
||
// 恢复点查询
|
||
MATCH (task:Task {user_id: $user_id, status: "paused"})
|
||
MATCH (task)-[:CAN_RESUME_FROM]->(rp)
|
||
RETURN task, rp.prompt as resume_prompt
|
||
ORDER BY rp.timestamp DESC
|
||
LIMIT 1
|
||
```
|
||
|
||
### 4.6 信息项与任务状态（借鉴 TeliChat）
|
||
|
||
**核心设计**：任务状态 = 信息项组合，使用结构化状态空间
|
||
|
||
```python
|
||
# 任务状态 - 结构化信息项组合
|
||
class TaskState:
|
||
"""借鉴 TeliChat 的结构化状态空间"""
|
||
|
||
# 任务元信息
|
||
task_id: str
|
||
status: str # created/active/paused/completed/cancelled/expired
|
||
|
||
# 信息项组合 - 决定任务能否继续
|
||
information_items: Dict[str, InformationItem] = {}
|
||
|
||
# 当前节点
|
||
current_node: str
|
||
visited_nodes: List[str] = []
|
||
|
||
def can_proceed_to(self, next_node: str) -> bool:
|
||
"""检查是否可以进入下一节点"""
|
||
|
||
# 检查必需信息项是否已填写
|
||
required_items = get_required_items(next_node)
|
||
for item_name in required_items:
|
||
if item_name not in self.information_items:
|
||
return False
|
||
if not self.information_items[item_name].is_filled:
|
||
return False
|
||
|
||
return True
|
||
|
||
def get_pending_items(self) -> List[str]:
|
||
"""获取未完成的必需信息项"""
|
||
pending = []
|
||
# 检查所有节点的必需信息项
|
||
all_required = get_all_required_items(self.current_node)
|
||
for item_name in all_required:
|
||
if item_name not in self.information_items:
|
||
pending.append(item_name)
|
||
elif not self.information_items[item_name].is_filled:
|
||
pending.append(item_name)
|
||
return pending
|
||
```
|
||
|
||
### 4.7 全局意图 PAUSE/RESUME 支持
|
||
|
||
```python
|
||
# 任务中断与恢复意图
|
||
class TaskIntent(Enum):
|
||
PAUSE = "暂停" # 用户主动暂停
|
||
RESUME_TASK = "继续" # 用户恢复任务
|
||
EXPIRED = "过期" # 任务超时过期
|
||
|
||
def handle_task_intent(user_input: str, task_state: TaskState) -> Action:
|
||
"""处理任务控制意图"""
|
||
|
||
# PAUSE - 用户离开
|
||
pause_keywords = ["先去开会", "等会继续", "先处理别的"]
|
||
if any(kw in user_input for kw in pause_keywords):
|
||
task_state.status = "paused"
|
||
task_state.paused_at = datetime.now()
|
||
save_to_redis(task_state) # 持久化
|
||
return Action(message="好的，您先忙，需要时 say一声继续")
|
||
|
||
# RESUME_TASK - 用户返回
|
||
resume_keywords = ["继续", "好了", "继续刚才", "接着来"]
|
||
if any(kw in user_input for kw in resume_keywords):
|
||
task_state = load_from_redis(task_state.task_id)
|
||
task_state.status = "active"
|
||
pending = task_state.get_pending_items()
|
||
|
||
if pending:
|
||
return Action(message=f"好的，您刚才说到{pending[0]}，请继续")
|
||
else:
|
||
return Action(message="继续刚才的流程...")
|
||
|
||
return None
|
||
```
|
||
|
||
### 4.8 关键设计点
|
||
|
||
| 设计点 | 方案 | 说明 |
|
||
|--------|------|------|
|
||
| 状态持久化 | Neo4j 节点 | 保存任务完整上下文 |
|
||
| 恢复点 | ResumePoint 节点 | 保存每个步骤的恢复信息 |
|
||
| 超时处理 | 定时任务 | 24小时未恢复则标记 expired |
|
||
| 坐席可见 | 状态同步 | 坐席工作台可查看用户任务状态 |
|
||
| **结构化状态** | 信息项组合决定状态 | **借鉴 TeliChat，可靠的状态管理** |
|
||
| **必需修饰** | 缺失必填项则阻塞 | **借鉴 TeliChat，保证任务完整性** |
|
||
| **PAUSE/RESUME 意图** | 任务控制意图 | **借鉴 TeliChat 全局意图** |
|
||
|
||
---
|
||
|
||
## 五、综合架构
|
||
|
||
### 5.1 完整技术栈
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ 用户层 (H5端) │
|
||
│ 用户发起对话，接收AI/坐席回复 │
|
||
└─────────────────────────────┬───────────────────────────────────┘
|
||
│
|
||
▼
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ Dify AI 推理层 │
|
||
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────────────┐ │
|
||
│ │ 意图理解 │ │ 多意图并行 │ │ 信息更正检测 │ │
|
||
│ │ Intent │ │ Parallel │ │ Correction Detector │ │
|
||
│ └──────────────┘ └──────────────┘ └──────────────────────┘ │
|
||
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────────────┐ │
|
||
│ │ 结果合并 │ │ 路径规划 │ │ 任务状态机 │ │
|
||
│ │ Merger │ │ Path Plan │ │ Task FSM │ │
|
||
│ └──────────────┘ └──────────────┘ └──────────────────────┘ │
|
||
└─────────────────────────────┬───────────────────────────────────┘
|
||
│
|
||
▼
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ Neo4j 知识图谱层 │
|
||
│ ┌───────────────────────────────────────────────────────────┐ │
|
||
│ │ │ │
|
||
│ │ [Issue] ──[LEADS_TO]──> [Action] │ │
|
||
│ │ │ │ │
|
||
│ │ [:CAN_JUMP_TO] ←──→ [:CAN_JUMP_TO] │ │
|
||
│ │ │ │ │
|
||
│ │ [Session] ──[PROVIDED]──> [Field] │ │
|
||
│ │ │ │ │
|
||
│ │ [Task] ──[HAS_HISTORY]──> [TaskStep] │ │
|
||
│ │ │ │ │
|
||
│ │ [:CAN_RESUME_FROM] ──> [ResumePoint] │ │
|
||
│ │ │ │
|
||
│ └───────────────────────────────────────────────────────────┘ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### 5.2 TeliChat 风格架构
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ TeliChat 风格架构 │
|
||
├─────────────────────────────────────────────────────────────────┤
|
||
│ │
|
||
│ ┌─────────────────────────────────────────────────────────┐ │
|
||
│ │ 信息项状态管理层 │ │
|
||
│ │ (InformationItem: name/value/modifiers/is_filled) │ │
|
||
│ └─────────────────────────────┬───────────────────────────┘ │
|
||
│ │ │
|
||
│ ┌─────────────────────────────▼───────────────────────────┐ │
|
||
│ │ 全局意图识别层 │ │
|
||
│ │ (SKIP/INSERT/RESUME/SWITCH/CORRECT/SUPPLEMENT/ │ │
|
||
│ │ PAUSE/RESUME_TASK/CANCEL/ESCALATE) │ │
|
||
│ └─────────────────────────────┬───────────────────────────┘ │
|
||
│ │ │
|
||
│ ┌─────────────────────────────▼───────────────────────────┐ │
|
||
│ │ 状态驱动引擎 │ │
|
||
│ │ f(拓扑结构, 信息项组合, 用户意图) = 下一节点 │ │
|
||
│ └─────────────────────────────┬───────────────────────────┘ │
|
||
│ │ │
|
||
│ ┌─────────────────────────────▼───────────────────────────┐ │
|
||
│ │ Dify AI 执行层 │ │
|
||
│ │ (意图理解 + 路径推理 + 结果生成) │ │
|
||
│ └─────────────────────────────┬───────────────────────────┘ │
|
||
│ │ │
|
||
│ ┌─────────────────────────────▼───────────────────────────┐ │
|
||
│ │ Neo4j 图数据库层 │ │
|
||
│ │ (知识图谱 + 会话状态 + 任务状态) │ │
|
||
│ └─────────────────────────────────────────────────────────┘ │
|
||
│ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### 5.3 核心能力矩阵
|
||
|
||
| 场景 | TeliChat 设计 | Dify 能力 | Neo4j 能力 | 综合支持 |
|
||
|------|--------------|-----------|-------------|---------|
|
||
| 非线性跳转 | 增量修饰 + SWITCH/SKIP/RESUME 意图 | 路径规划 | 图谱遍历 + 跳转关系 | ✅ 完全支持 |
|
||
| 多意图并行 | INSERT 意图 + 信息项聚合 | 并行分支 + 结果合并 | 聚合节点 | ✅ 完全支持 |
|
||
| 信息更正 | 增量+复述修饰 + CORRECT/SUPPLEMENT 意图 | 更正检测 | 字段版本管理 | ✅ 完全支持 |
|
||
| 中断恢复 | 必需修饰 + PAUSE/RESUME_TASK 意图 | 状态触发 | 任务状态机 + 恢复点 | ✅ 完全支持 |
|
||
|
||
---
|
||
|
||
## 六、实施建议
|
||
|
||
### 6.1 TeliChat 架构落地计划
|
||
|
||
#### 短期（1-2周）
|
||
|
||
1. **信息项数据模型设计**
|
||
- 设计 InformationItem 数据结构
|
||
- 定义 6 种修饰符的交互策略
|
||
- 开发 CRUD 接口
|
||
|
||
2. **全局意图识别 Agent**
|
||
- 在 Dify 中创建意图识别工作流
|
||
- 支持 10 种全局意图类型
|
||
|
||
#### 中期（1个月）
|
||
|
||
3. **状态驱动引擎**
|
||
- 开发对话状态管理服务
|
||
- 实现"拓扑+信息项+意图"三因素路由
|
||
|
||
4. **Neo4j 融合**
|
||
- 图谱节点携带信息项定义
|
||
- 支持信息项状态查询
|
||
|
||
### 6.2 实施优先级
|
||
|
||
| 优先级 | 场景 | TeliChat 核心 | 工作量 | 建议 |
|
||
|--------|------|--------------|--------|------|
|
||
| P0 | 任务中断恢复 | 必需修饰 + PAUSE/RESUME | 中 | 核心场景，优先实现 |
|
||
| P1 | 信息更正 | 增量+复述 + CORRECT | 小 | 用户体验关键 |
|
||
| P1 | 非线性跳转 | 增量修饰 + SWITCH/SKIP | 大 | 知识图谱扩展 |
|
||
| P2 | 多意图并行 | INSERT + 信息项聚合 | 中 | 高级场景，后续迭代 |
|
||
|
||
### 6.3 技术债务
|
||
|
||
| 项 | 说明 | 规避方案 |
|
||
|----|------|----------|
|
||
| 图谱复杂度 | 跳转关系过多导致图谱复杂 | 设计跳转权限控制 |
|
||
| 状态一致性 | 中断恢复可能产生状态不一致 | 使用事务保证 |
|
||
| 性能 | 多意图并行增加响应时间 | 添加缓存层 |
|
||
| **LLM 幻觉** | **TeliChat 解决的核心问题** | **代码约束 + 拓扑限制** |
|
||
|
||
---
|
||
|
||
*本文档为技术实现方案详细设计 v1.1*
|
||
*新增 TeliChat 风格设计理念*
|