一、引言：政务帮办的挑战与智能化需求
在数字化转型浪潮中，政务服务正从传统的人工办理向智能化帮办演进。然而，当前政务帮办系统普遍存在三类典型问题：
1.1 现有三类系统的局限性
基于预定义规则的传统流程系统
- 优势：处理标准化业务（如社保基数核定、公积金提取）时表现稳定
- 劣势：依赖人工配置，灵活性极差，无法适应政策频繁更新，缺乏动态引导与补救能力
基于LLM的单智能体问答系统
- 优势：利用大语言模型理解用户提问，生成操作指令
- 劣势：单一智能体承担多重职责（政策解读、意图识别、材料收集、流程控制），易出现意图混淆、上下文丢失、"幻觉"回答或流程逻辑混乱
结合知识图谱的检索增强系统
- 优势：通过知识图谱增强领域知识，解决LLM专业知识不足问题
- 劣势：仍依赖"LLM+知识图谱"单点决策模式，知识检索与对话管理耦合紧密，缺乏精细感知和动态调整能力
1.2 五大关键痛点
| 痛点 | 具体表现 |
|---|---|
| 1. 服务模式停留在问答层面 | 缺乏与RPA深度集成，无法主动替用户完成信息填报、材料提交、进度跟踪等实际操作 |
| 2. 缺乏动态环境感知与闭环反馈 | 无法实时感知办理状态变化，流程中断后缺乏自动恢复能力，鲁棒性差 |
| 3. 参数收集与管理能力薄弱 | 单一LLM难以持续维护全局参数状态（待收集、已收集、校验失败），导致信息重复采集或遗漏 |
| 4. 人机交互引导能力不足 | 要么完全依赖预定义表单（不灵活），要么由LLM自由发挥（提问不聚焦、冗长） |
| 5. 单点决策脆弱性与意图处理混乱 | 单一LLM承担规划、对话、执行等多重角色，易超出上下文处理能力，对混合意图处理能力弱 |
二、核心创新概述：四层智能体架构
本系统创新性地提出基于检索增强与大模型多智能体协同的政务帮办系统，采用四层智能体职责分离架构，实现功能解耦与专业化协作。
graph TB
subgraph 用户层
U[用户输入/回复]
end
subgraph 中央决策层
P[RPA规划智能体<br/>中央决策枢纽]
end
subgraph 协同执行层
G[对话引导智能体<br/>交互管理]
E[参数提取智能体<br/>信息采集]
X[RPA执行智能体<br/>业务操作]
end
subgraph 状态管理层
M[Memory<br/>全局状态存储器]
end
subgraph 外部系统层
RPA[RPA执行接口]
KG[知识图谱/政策库]
end
U --> P
P -->|意图识别| G
P -->|参数提取| E
P -->|提交执行| X
G --> U
E --> P
X -->|执行结果| P
P --> M
G --> M
M --> P
X --> RPA
P --> KG
style P fill:#e1f5ff
style G fill:#fff4e1
style E fill:#ffe1f5
style X fill:#e1ffe1
style M fill:#f5f5f5
架构核心思想：
- 职责分离：每个智能体专注单一职责，避免单点过载
- 协同协作：通过中央决策枢纽协调多智能体协作
- 闭环反馈：基于执行结果动态调整策略
- 状态管理：全局记忆模块实现跨轮次状态传递
三、技术架构详解
3.1 多智能体协同流程
flowchart TB
Start([流程开始]) --> Input{用户输入是否<br/>包含业务?}
Input -->|否| Init[首次RPA执行<br/>系统初始化]
Input -->|是| Plan1[RPA规划<br/>生成待收集参数列表]
Init --> Result1[获取首轮需收集的<br/>所有参数]
Result1 --> Plan1
Plan1 --> Guide[对话引导<br/>生成提问话术]
Guide --> User[用户回复]
User --> Plan2[RPA规划<br/>意图识别]
Plan2 -->|自由提问| Reply[生成回复话术]
Reply --> Guide
Plan2 -->|参数提供| Extract[参数提取<br/>并发提取+样式验证]
Plan2 -->|混合意图| Memory[参考Memory决策]
Memory --> Plan3[根据决策选择<br/>对话引导或参数提取]
Plan3 --> Guide
Plan3 --> Extract
Extract --> Check{参数是否<br/>收集完毕?}
Check -->|否| Update[更新待收集参数列表]
Update --> Guide
Check -->|是| Submit[提交当前轮参数]
Submit --> Exec[RPA执行<br/>监控执行结果]
Exec --> Feedback[提取执行状态]
Feedback --> Plan4[根据执行结果<br/>更新待收集参数列表]
Plan4 --> Collect{所有参数<br/>是否收集完毕?}
Collect -->|否| Guide
Collect -->|是| End([流程结束])
style Start fill:#e1ffe1
style End fill:#ffe1e1
style Plan1 fill:#e1f5ff
style Plan2 fill:#e1f5ff
style Plan4 fill:#e1f5ff
style Extract fill:#fff4e1
style Exec fill:#ffe1f5
3.2 三个核心数据结构详解
(1) Required_params（待收集参数列表）
格式定义：
Required_params = ["参数1", "参数2", ..., "参数n"]
详细说明：
参数n：表示第n个需要从用户处收集的参数名称（如"年龄"、"民族"、"证件类型"）- 该列表由RPA规划智能体基于上一轮RPA执行结果动态生成
- 列表中的参数按照优先级和依赖关系排序
- 每轮参数收集完成后，列表会根据执行结果更新
使用场景：
- 对话引导智能体根据此列表生成针对性提问
- 参数提取智能体根据此列表进行并发提取
- RPA规划智能体通过对比
Required_params和Collected_params判断收集进度
(2) Collected_params（已收集参数列表）
格式定义：
Collected_params = [
{"参数1": "参数1的值"},
{"参数2": "参数2的值"},
...
{"参数n": "参数n的值"}
]
详细说明：
- 每个元素是一个键值对字典
- 键：参数名称（与
Required_params对应） - 值：从用户输入中提取的具体值（需经过格式和逻辑校验）
- 该列表由参数提取智能体生成，包含当前轮次成功提取的所有参数
校验规则示例：
# 日期参数校验
if param_type == "date":
if extracted_date > current_date:
return None # 日期不能超过当前日期
# 枚举值校验
if param_type == "enum" and value not in enum_values:
return None # 值不在枚举范围内
(3) Memory（全局记忆模块）
结构定义：
Memory = {
"决策记录": [
{
"轮次": 1,
"用户输入": "我想办理社保业务",
"决策结果": "RPA执行",
"执行智能体": "RPA执行",
"决策依据": "待收集参数列表为空，需初始化"
},
...
],
"对话记录": [
{
"role": "assistant",
"content": "您好，请问您需要办理什么业务？"
},
{
"role": "user",
"content": "我想办理社保业务"
}
]
}
详细说明：
- 决策记录：记录每轮的决策过程，用于混合意图处理时的上下文参考
- 对话记录：存储完整的交互历史，供参数提取时获取最新轮次对话
- 该模块在每次
RPA规划和对话引导后更新 - 实现跨轮次状态传递和决策可追溯性
四、RPA规划智能体：中央决策枢纽
4.1 职责与功能
RPA规划智能体是整个系统的大脑和指挥中心，承担以下核心职责：
- 参数规划：基于RPA执行结果生成动态待收集参数列表
- 意图识别：判断用户回复是"参数提供"、"自由提问"还是"混合意图"
- 决策调度：根据当前状态决定下一步执行哪个智能体（对话引导/参数提取/RPA执行）
- 完备性检查：对比
Required_params和Collected_params判断参数是否收集完毕 - 状态管理：更新Memory中的决策记录和对话记录
4.2 混合意图处理决策树
flowchart TB
Start([用户输入]) --> CheckInput{输入是否为空?}
CheckInput -->|是| Check1{待收集参数列表<br/>是否为空?}
Check1 -->|是| Check2{执行结果<br/>是否为空?}
Check2 -->|是| Action1[调用RPA执行<br/>参数: Query=用户回复]
Check2 -->|否| Action2[提取失败参数<br/>生成待收集参数列表<br/>→ 调用对话引导]
CheckInput -->|否| Intent{意图识别<br/>参数提供/自由提问/混合?}
Intent -->|自由提问| Action3[调用对话引导<br/>参数1: Query=用户回复<br/>参数2: Required_params]
Intent -->|参数提供| Action4[调用参数提取<br/>参数1: Query=用户回复<br/>参数2: Required_params]
Intent -->|混合意图| MemoryCheck[参考Memory<br/>决策记录]
MemoryCheck --> Check3{历史决策中<br/>优先处理何种意图?}
Check3 -->|优先解答| Action3
Check3 -->|优先提取| Action4
Action4 --> Complete{参数是否<br/>收集完毕?}
Complete -->|是| Action5[调用RPA执行<br/>参数: Collected_params]
Complete -->|否| Action6[生成未收集参数列表<br/>→ 调用对话引导]
style Start fill:#e1ffe1
style Action1 fill:#fff4e1
style Action2 fill:#fff4e1
style Action3 fill:#fff4e1
style Action4 fill:#fff4e1
style Action5 fill:#fff4e1
style Action6 fill:#fff4e1
4.3 提示词设计与决策逻辑
# RPA规划智能体提示词模板
PLANNER_PROMPT = """
任务：你是中央决策枢纽，你的任务是基于输入数据执行规划决策，给出下一步要执行的智能体名称和所需参数。
要求：请按照如下规则进行规划决策：
- 若待收集参数列表和执行结果均为空，则下一步需要执行的智能体为"RPA执行"，
所需参数名为"Query"，参数值为用户回复的内容。
- 若待收集参数列表为空，执行结果不为空，则从执行结果中提取出状态为"填写失败"和"未填写"的参数，
整理成待收集参数列表，格式为["参数1", "参数2", ..., "参数n"]，
下一步需要执行的智能体为"对话引导"，所需参数名为"Required_params"，值为待收集的参数列表。
- 若用户回复和待收集参数列表均不为空，则判断用户回复的意图是参数提供还是自由提问，
若意图为自由提问，则下一步需要执行的智能体为"对话引导"，
所需参数1的名称为"Query"，值为用户回复的内容，
所需参数2的名称为"Required_params"，值为待收集参数列表。
- 若用户回复和待收集参数列表均不为空，且用户回复的意图为参数提供，
则下一步需要执行的智能体为"参数提取"，
所需参数1的名称为"Query"，值为用户回复的内容，
所需参数2的名称为"Required_params"，值为待收集参数列表。
- 若用户回复和待收集参数列表均不为空，且用户回复的意图同时包含参数提供和自由提问，
则参考历史决策记录Memory，决定下一步执行"对话引导"还是"参数提取"，
所需参数1的名称为"Query"，值为用户回复的内容，
所需参数2的名称为"Required_params"，值为待收集参数列表。
- 若待收集参数列表和已收集参数列表均不为空，
则判断是否已收集了所有的待收集参数，
若已收集完毕，则下一步需要执行的智能体为"RPA执行"，所需参数为已收集参数列表；
若还没有收集完毕，则整理出未收集的参数，格式为["参数1", "参数2", ..., "参数n"]，
下一步需要执行的智能体为"对话引导"，所需参数名为"Required_params"，值为未收集的参数列表。
- 按照以下格式进行输出：
{{"Agent":智能体名称,"Params":[{参数名1:参数值},{参数名2:参数值}...]}}
只能输出一个待执行的智能体名称和对应的所需参数。
输入：
1.待收集参数列表Required_params
2.已收集参数列表Collected_params
3.RPA执行结果
4.用户回复Query
5.历史决策记录Mermory
输出：需要执行的智能体名称和所需参数，示例如下：
{{"Agent":"对话引导","Params":{{"Required_params":["年龄","民族"]}}}}
"""
4.4 代码实现示例
import json
from typing import Dict, List, Optional
class RPAPlannerAgent:
"""
RPA规划智能体：中央决策枢纽
职责：
1. 基于RPA执行结果进行参数规划
2. 识别用户回复意图（参数提供/自由提问/混合意图）
3. 决定下一步执行哪个智能体
4. 检查参数收集完备性
"""
def __init__(self, llm_client):
"""
初始化RPA规划智能体
参数：
llm_client: 大语言模型客户端，用于生成决策
"""
self.llm_client = llm_client
self.memory = {"决策记录": [], "对话记录": []} # 全局记忆模块
def plan(self, required_params: List[str], collected_params: List[Dict],
rpa_result: Optional[List], query: str) -> Dict:
"""
执行规划决策
参数：
required_params: 待收集参数列表，如["年龄", "民族"]
collected_params: 已收集参数列表，如[{"年龄": "25"}, {"民族": "汉族"}]
rpa_result: RPA执行结果，包含各参数的执行状态
query: 用户当前回复
返回：
dict: 决策结果，格式为{"Agent": "智能体名称", "Params": {参数名: 参数值}}
"""
# 构造提示词输入
input_data = {
"Required_params": required_params,
"Collected_params": collected_params,
"RPA执行结果": rpa_result,
"Query": query,
"Mermory": self.memory["决策记录"]
}
# 调用LLM生成决策
response = self.llm_client.generate(
prompt=PLANNER_PROMPT,
input_data=input_data
)
# 解析决策结果
decision = json.loads(response)
# 更新记忆模块
self.memory["决策记录"].append({
"轮次": len(self.memory["决策记录"]) + 1,
"用户输入": query,
"决策结果": decision["Agent"],
"执行智能体": decision["Agent"],
"输入参数": decision["Params"]
})
return decision
def check_completeness(self, required_params: List[str],
collected_params: List[Dict]) -> bool:
"""
检查参数收集完备性
参数：
required_params: 待收集参数列表
collected_params: 已收集参数列表
返回：
bool: True表示所有参数已收集完毕，False表示仍有参数待收集
"""
# 从Collected_params中提取已收集的参数名
collected_names = [list(param.keys())[0] for param in collected_params]
# 检查是否所有待收集参数都已收集
for param in required_params:
if param not in collected_names:
return False # 还有参数未收集
return True # 所有参数已收集完毕
def extract_failed_params(self, rpa_result: List[Dict]) -> List[str]:
"""
从RPA执行结果中提取失败和未填写的参数
参数：
rpa_result: RPA执行结果列表，格式：
[
{"参数名": "年龄", "状态": "填写成功"},
{"参数名": "证件类型", "状态": "填写失败", "失败理由": "证件类型不存在"},
{"参数名": "民族", "状态": "未填写"}
]
返回：
list: 失败和未填写的参数名列表
"""
failed_params = []
for result in rpa_result:
# 提取状态为"填写失败"或"未填写"的参数
if result["状态"] in ["填写失败", "未填写"]:
failed_params.append(result["参数名"])
return failed_params
# 使用示例
if __name__ == "__main__":
# 假设已初始化LLM客户端
llm_client = None # 实际使用时传入真实的LLM客户端
# 创建RPA规划智能体
planner = RPAPlannerAgent(llm_client)
# 场景1：首次启动，待收集参数和执行结果均为空
decision1 = planner.plan(
required_params=[],
collected_params=[],
rpa_result=None,
query="我想办理社保业务"
)
# 输出: {"Agent": "RPA执行", "Params": {"Query": "我想办理社保业务"}}
# 场景2：RPA执行后，有参数填写失败
decision2 = planner.plan(
required_params=[],
collected_params=[],
rpa_result=[
{"参数名": "年龄", "状态": "填写成功"},
{"参数名": "证件类型", "状态": "填写失败", "失败理由": "证件类型不存在"}
],
query=""
)
# 输出: {"Agent": "对话引导", "Params": {"Required_params": ["证件类型"]}}
# 场景3：用户自由提问
decision3 = planner.plan(
required_params=["民族"],
collected_params=[],
rpa_result=None,
query="证件类型有哪几种？"
)
# 输出: {"Agent": "对话引导", "Params": {"Query": "证件类型有哪几种？", "Required_params": ["民族"]}}
五、对话引导智能体：优化人机交互体验
5.1 双优先级对话机制
对话引导智能体采用**"答疑优先、引导其次"**的双优先级机制：
-
优先级1：解答用户自由提问
- 优先回复用户的政策咨询、业务疑问等
- 确保用户感到被关注和理解
-
优先级2：引导参数收集
- 在解答问题后，自然过渡到参数引导
- 避免"盘问式"交互，提升用户体验
5.2 话术生成策略
# 对话引导智能体提示词模板
GUIDANCE_PROMPT = """
任务：你是一个问答助手，你的任务是根据输入内容，回答用户问题并对输入内容中的一些信息进行询问。
要求：请按照以下规则进行引导话术的生成：
- 若输入内容中不包含用户回复或回复内容为空，则直接对输入内容中待收集参数列表中的待收集参数信息进行询问或要求用户提供相应材料。
- 若输入内容中包含用户回复，则优先回复用户问题，再对待收集参数信息进行询问。
- 生成的引导话术需要自然流畅、简单明了。
- 一次最多询问两个参数信息。
输入：
1.待收集参数列表Required_params
2.用户回复
输出：引导话术
示例：
示例1：
Required_params：["证件类型"]
用户回复：证件类型有哪几种？
引导话术：证件类型有居民身份证、社会保障卡、港澳台居住证和护照等四种类型，请问您的证件类型是哪一种呢？
示例2：
Required_params：["身份证扫描件"]
用户回复：身份证
引导话术：好的，请将您的身份证放在扫描仪上。
示例3：
Required_params：["年龄", "民族"]
用户回复：（空）
引导话术：您好，请问您的年龄和民族分别是多少呢？
"""
5.3 代码实现示例
class DialogueGuidanceAgent:
"""
对话引导智能体
职责：
1. 优先解答用户自由提问
2. 自然引导用户提供所需参数
3. 控制单次引导参数数量（最多2个）
"""
def __init__(self, llm_client):
"""
初始化对话引导智能体
参数：
llm_client: 大语言模型客户端，用于生成引导话术
"""
self.llm_client = llm_client
def generate_guidance(self, required_params: List[str],
query: Optional[str] = None) -> str:
"""
生成引导话术
参数：
required_params: 待收集参数列表
query: 用户当前回复，可能为空
返回：
str: 生成的引导话术
"""
# 构造输入数据
input_data = {
"Required_params": required_params,
"用户回复": query if query else ""
}
# 调用LLM生成引导话术
response = self.llm_client.generate(
prompt=GUIDANCE_PROMPT,
input_data=input_data
)
return response
def limit_params_per_turn(self, required_params: List[str],
max_count: int = 2) -> List[str]:
"""
限制单轮引导的参数数量
参数：
required_params: 待收集参数列表
max_count: 单轮最多引导的参数数量，默认为2
返回：
list: 当前轮需要引导的参数列表
"""
return required_params[:max_count]
# 使用示例
if __name__ == "__main__":
# 假设已初始化LLM客户端
llm_client = None # 实际使用时传入真实的LLM客户端
# 创建对话引导智能体
guidance_agent = DialogueGuidanceAgent(llm_client)
# 场景1：用户自由提问 + 参数引导
response1 = guidance_agent.generate_guidance(
required_params=["民族"],
query="证件类型有哪几种？"
)
# 输出示例: "证件类型有居民身份证、社会保障卡、港澳台居住证和护照等四种类型，请问您的民族是哪个呢？"
# 场景2：无用户回复，直接参数引导
response2 = guidance_agent.generate_guidance(
required_params=["年龄", "民族"],
query=None
)
# 输出示例: "您好，请问您的年龄和民族分别是多少呢？"
六、参数提取智能体：并发提取与样式验证
6.1 参数提取流程
flowchart TB
Start([参数提取开始]) --> Split[Required_params拆分<br/>生成各个参数对象]
Split --> Search[参数样式搜索<br/>获取格式/描述/枚举值]
Search --> Concurrent[并发调用参数提取Agent]
subgraph 并发提取
direction TB
Agent1[提取Agent1<br/>参数: param1]
Agent2[提取Agent2<br/>参数: param2]
Agent3[提取Agent3<br/>参数: param3]
AgentN[提取AgentN<br/>参数: paramN]
end
Concurrent --> Validate[格式一致性校验<br/>逻辑性校验]
Validate --> CheckResult{校验是否通过?}
CheckResult -->|是| Merge[结果合并<br/>生成Collected_params]
CheckResult -->|否| Retry[标记失败<br/>保留在待收集列表]
Merge --> Record[提取结果记录<br/>Name: param, Value: xx]
Retry --> Merge
Record --> End([参数提取结束])
style Start fill:#e1ffe1
style End fill:#ffe1e1
style Concurrent fill:#fff4e1
style Validate fill:#ffe1f5
6.2 并发提取+样式验证机制
核心优势：
- 并发执行：多个参数提取Agent并行工作，提升提取效率
- 样式验证：每个参数提取时都参考预定义的样式约束，提高准确性
- 错误隔离：单个参数提取失败不影响其他参数的提取
参数样式定义：
{
"properties": {
"证件类型": {
"type": "string",
"description": "证件类型",
"enum": ["居民身份证", "社会保障卡", "港澳台居住证", "护照"]
},
"年龄": {
"type": "integer",
"description": "年龄（周岁）",
"minimum": 0,
"maximum": 150
},
"出生日期": {
"type": "date",
"description": "出生日期，格式：YYYY-MM-DD"
}
}
}
6.3 完整Python代码示例
import json
from typing import List, Dict, Optional
from concurrent.futures import ThreadPoolExecutor, as_completed
from datetime import datetime
# 参数提取智能体提示词模板
EXTRACTOR_PROMPT = """
任务：你是一个专业的AI助手，你的任务是从用户的输入中抽取所需的参数并以json格式进行输出。
要求：
- 你必须输出json格式。
- 对于日期和时间等信息，请在抽取后进行验证，若抽取的日期大于当前日期，则该参数返回空值。
- 请按照以下示例进行参数提取：
参数样式：{{"properties":{{"证件类型":{{"type":"string","description":"证件类型","enum":["居民身份证","社会保障卡"]}}}}
对话记录：[
{{"role":"assistant","content":"您好，请提供您的证件类型"}},
{{"role":"user","content":"身份证"}}
]
抽取结果：{{"Name":"证件类型","Value":"居民身份证"}}
- 直接输出最终的结果，不要输出中间过程等任何多余的内容
输入：
1.对话记录
2.参数样式
输出：抽取出来的参数，示例如下：
{{"Name":"证件类型","Value":"居民身份证"}}
"""
class ParameterExtractorAgent:
"""
参数提取智能体
职责：
1. 从用户回复中并发提取多个参数
2. 进行样式验证（格式、枚举值、逻辑校验）
3. 输出结构化的提取结果
"""
def __init__(self, llm_client):
"""
初始化参数提取智能体
参数：
llm_client: 大语言模型客户端，用于参数提取
"""
self.llm_client = llm_client
def extract_single_parameter(self, dialogue_history: List[Dict],
param_name: str, param_schema: Dict) -> Dict:
"""
提取单个参数
参数：
dialogue_history: 对话记录，包含历史交互内容
param_name: 待提取的参数名
param_schema: 参数样式定义，包含格式、枚举值等信息
返回：
dict: 提取结果，格式为{"Name": 参数名, "Value": 提取值}
"""
# 构造输入数据
input_data = {
"对话记录": dialogue_history,
"参数样式": {"properties": {param_name: param_schema}}
}
# 调用LLM进行参数提取
response = self.llm_client.generate(
prompt=EXTRACTOR_PROMPT,
input_data=input_data
)
# 解析提取结果
try:
result = json.loads(response)
# 进行样式验证
validated_result = self._validate_parameter(
param_name,
result.get("Value"),
param_schema
)
return validated_result
except json.JSONDecodeError:
return {"Name": param_name, "Value": None}
def _validate_parameter(self, param_name: str, value: Optional[str],
param_schema: Dict) -> Dict:
"""
参数样式验证
参数：
param_name: 参数名
value: 待验证的值
param_schema: 参数样式定义
返回：
dict: 验证后的结果
"""
if value is None:
return {"Name": param_name, "Value": None}
param_type = param_schema.get("type")
# 日期类型验证
if param_type == "date":
try:
extracted_date = datetime.strptime(value, "%Y-%m-%d")
if extracted_date > datetime.now():
return {"Name": param_name, "Value": None} # 日期不能超过当前日期
except ValueError:
return {"Name": param_name, "Value": None}
# 整数类型验证
elif param_type == "integer":
try:
int_value = int(value)
# 检查范围
if "minimum" in param_schema and int_value < param_schema["minimum"]:
return {"Name": param_name, "Value": None}
if "maximum" in param_schema and int_value > param_schema["maximum"]:
return {"Name": param_name, "Value": None}
except ValueError:
return {"Name": param_name, "Value": None}
# 枚举值验证
elif "enum" in param_schema:
if value not in param_schema["enum"]:
return {"Name": param_name, "Value": None}
return {"Name": param_name, "Value": value}
def extract_parameters_concurrently(
self,
dialogue_history: List[Dict],
required_params: List[str],
param_schemas: Dict[str, Dict],
max_workers: int = 5
) -> List[Dict]:
"""
并发提取多个参数
参数：
dialogue_history: 对话记录
required_params: 待提取的参数列表
param_schemas: 参数样式字典，格式为{参数名: 样式定义}
max_workers: 并发线程数，默认为5
返回：
list: 已收集参数列表，格式为[{参数名: 参数值}, ...]
"""
collected_params = []
# 使用线程池并发提取参数
with ThreadPoolExecutor(max_workers=max_workers) as executor:
# 提交所有提取任务
future_to_param = {
executor.submit(
self.extract_single_parameter,
dialogue_history,
param_name,
param_schemas.get(param_name, {})
): param_name
for param_name in required_params
}
# 等待所有任务完成并收集结果
for future in as_completed(future_to_param):
param_name = future_to_param[future]
try:
result = future.result()
# 如果提取成功（值不为None），则加入已收集列表
if result["Value"] is not None:
collected_params.append({
result["Name"]: result["Value"]
})
except Exception as e:
print(f"参数 {param_name} 提取失败: {e}")
return collected_params
def get_latest_dialogue_turn(self, memory: Dict) -> List[Dict]:
"""
从Memory中获取最新一轮对话
参数：
memory: 全局记忆模块
返回：
list: 最新一轮对话记录
"""
dialogue_records = memory.get("对话记录", [])
if len(dialogue_records) >= 2:
# 返回最后两轮对话（用户最新回复和助手的引导话术）
return dialogue_records[-2:]
return dialogue_records
# 使用示例
if __name__ == "__main__":
# 假设已初始化LLM客户端
llm_client = None # 实际使用时传入真实的LLM客户端
# 创建参数提取智能体
extractor = ParameterExtractorAgent(llm_client)
# 构造测试数据
dialogue_history = [
{"role": "assistant", "content": "您好，请提供您的证件类型"},
{"role": "user", "content": "身份证"}
]
param_schemas = {
"证件类型": {
"type": "string",
"description": "证件类型",
"enum": ["居民身份证", "社会保障卡", "港澳台居住证", "护照"]
}
}
# 并发提取参数
collected_params = extractor.extract_parameters_concurrently(
dialogue_history=dialogue_history,
required_params=["证件类型"],
param_schemas=param_schemas
)
print("已收集参数:", collected_params)
# 输出: [{"证件类型": "居民身份证"}]
七、RPA执行智能体：闭环反馈与状态监控
7.1 RPA执行流程
flowchart TB
Start([RPA执行开始]) --> Submit[提交Collected_params<br/>调用RPA执行接口]
Submit --> Interface[RPA执行接口<br/>完成实际业务操作]
Interface --> TextResult[获取文本执行结果<br/>各参数执行状态]
Interface --> ImageCapture[网页截图<br/>获取视觉状态]
TextResult --> ExtractAgent[执行状态提取Agent<br/>多模态分析]
ImageCapture --> ExtractAgent
ExtractAgent --> Classify[状态分类<br/>填写成功/填写失败/未填写]
Classify --> ExtractFail{是否有<br/>填写失败?}
ExtractFail -->|是| ExtractReason[提取失败原因<br/>从文本或图片中识别]
ExtractFail -->|否| Format[格式化输出<br/>生成执行状态列表]
ExtractReason --> Format
Format --> Feedback[反馈给RPA规划<br/>更新待收集参数列表]
Feedback --> End([RPA执行结束])
style Start fill:#e1ffe1
style End fill:#ffe1e1
style Interface fill:#fff4e1
style ExtractAgent fill:#ffe1f5
style Format fill:#e1f5ff
7.2 多模态状态分析
RPA执行智能体融合文本+图像进行多模态分析：
-
文本分析：
- 从RPA接口返回的文本结果中提取各参数的执行状态
- 识别"填写成功"、"填写失败"、"未填写"三类状态
- 提取失败原因（如"证件类型不存在"、"格式错误"等）
-
图像分析：
- 分析执行完毕后的网页截图
- 识别未填写的参数（空白字段、默认值等）
- 补充文本分析的盲区，提高识别完整度
7.3 闭环反馈机制
闭环流程：
RPA执行 → 状态提取 → 反馈给RPA规划 → 更新待收集参数列表 → 继续收集/提交
核心价值：
- 自动恢复：参数提交失败后自动启动补正流程
- 弹性调整：根据执行结果动态调整后续策略
- 状态可见：用户可实时了解办理进度
7.4 代码实现示例
import json
from typing import List, Dict, Optional
# 执行状态提取智能体提示词模板
STATUS_EXTRACTOR_PROMPT = """
任务：你是一个多模态数据分析助手，你的任务是根据输入内容，分析并返回各个参数的执行状态。
要求：
1.从输入内容提取出各个参数的执行状态，将执行状态归入以下三类：
①填写成功 ②填写失败 ③未填写
对于填写失败的参数，还需从输入内容中提取其填写失败的原因。
2.分析图片内容，找出图片中仍未填写的参数，并记录其名称。
3.结合1、2步的结果，将所有参数的执行状态整理为以下格式并输出：
[{{"参数名":"xxx","状态":"填写成功/填写失败/未填写","失败理由":"xxx"}}...]
4.参数状态只能为"填写成功"、"填写失败"和"未填写"中的一种，
对于状态为"填写成功"或"未填写"的参数，状态信息中舍弃"失败理由"字段。
输入：
RPA执行接口的返回内容，包括：
- 本轮各个参数的执行结果（文字形式）
- 执行完毕后的网页截图（图片形式）
输出：执行状态列表，示例如下：
[
{{"参数名":"年龄","状态":"填写成功"}},
{{"参数名":"证件类型","状态":"填写失败","失败理由":"证件类型不存在"}},
{{"参数名":"民族","状态":"未填写"}}
]
"""
class RPAExecutionAgent:
"""
RPA执行智能体
职责：
1. 调用RPA执行接口完成实际业务操作
2. 多模态分析执行状态（文本+图像）
3. 闭环反馈给RPA规划智能体
"""
def __init__(self, llm_client, rpa_api_client):
"""
初始化RPA执行智能体
参数：
llm_client: 大语言模型客户端，用于状态提取
rpa_api_client: RPA接口客户端，用于调用RPA服务
"""
self.llm_client = llm_client
self.rpa_api_client = rpa_api_client
def execute(self, collected_params: List[Dict]) -> Dict:
"""
执行RPA操作
参数：
collected_params: 已收集参数列表，格式：[{"参数名": 参数值}, ...]
返回：
dict: 执行结果，包含文本结果和网页截图
"""
# 将参数列表转换为RPA接口所需的格式
rpa_params = {}
for param in collected_params:
rpa_params.update(param)
# 调用RPA执行接口
execution_result = self.rpa_api_client.submit_params(rpa_params)
return execution_result
def extract_execution_status(self, execution_result: Dict) -> List[Dict]:
"""
提取执行状态
参数：
execution_result: RPA执行结果，包含：
- text_result: 文本执行结果
- screenshot: 网页截图（Base64编码）
返回：
list: 执行状态列表，格式：
[
{"参数名": "xxx", "状态": "填写成功/填写失败/未填写", "失败理由": "xxx"},
...
]
"""
# 构造输入数据
input_data = {
"文本执行结果": execution_result.get("text_result", ""),
"网页截图": execution_result.get("screenshot", "")
}
# 调用LLM进行多模态状态提取
response = self.llm_client.generate(
prompt=STATUS_EXTRACTOR_PROMPT,
input_data=input_data
)
# 解析状态列表
try:
status_list = json.loads(response)
return status_list
except json.JSONDecodeError:
return []
def execute_and_feedback(self, collected_params: List[Dict]) -> List[Dict]:
"""
执行RPA并反馈状态
参数：
collected_params: 已收集参数列表
返回：
list: 执行状态列表
"""
# 执行RPA操作
execution_result = self.execute(collected_params)
# 提取执行状态
status_list = self.extract_execution_status(execution_result)
return status_list
# RPAApiClient模拟类
class RPAApiClient:
"""
RPA接口客户端（模拟）
用于与实际的RPA服务进行交互
"""
def __init__(self, api_endpoint: str):
"""
初始化RPA接口客户端
参数：
api_endpoint: RPA接口地址
"""
self.api_endpoint = api_endpoint
def submit_params(self, params: Dict) -> Dict:
"""
提交参数到RPA接口
参数：
params: 参数字典
返回：
dict: 执行结果
"""
# 实际使用时，这里会调用真实的RPA接口
# 这里仅返回模拟数据
return {
"text_result": json.dumps([
{"参数名": "年龄", "备注": "填写成功"},
{"参数名": "证件类型", "备注": "填写失败，该证件类型不存在！"},
{"参数名": "民族", "备注": "未填写"}
]),
"screenshot": "base64_encoded_image_data"
}
# 使用示例
if __name__ == "__main__":
# 假设已初始化LLM客户端和RPA接口客户端
llm_client = None # 实际使用时传入真实的LLM客户端
rpa_api_client = RPAApiClient("http://api.example.com/rpa")
# 创建RPA执行智能体
rpa_agent = RPAExecutionAgent(llm_client, rpa_api_client)
# 构造测试数据
collected_params = [
{"年龄": "25"},
{"证件类型": "护照"},
{"民族": "汉族"}
]
# 执行RPA并获取状态
status_list = rpa_agent.execute_and_feedback(collected_params)
print("执行状态列表:", status_list)
# 输出示例:
# [
# {"参数名": "年龄", "状态": "填写成功"},
# {"参数名": "证件类型", "状态": "填写失败", "失败理由": "证件类型不存在"},
# {"参数名": "民族", "状态": "未填写"}
# ]
八、数据流转全貌：完整的业务闭环
8.1 数据流转时序图
sequenceDiagram
participant User as 用户
participant Planner as RPA规划智能体
participant Guidance as 对话引导智能体
participant Extractor as 参数提取智能体
participant Executor as RPA执行智能体
participant Memory as Memory<br/>全局状态存储器
participant RPA as RPA执行接口
User->>Planner: 输入业务需求
Planner->>Memory: 记录决策
Planner->>Executor: 首次RPA执行（初始化）
Executor->>RPA: 调用接口
RPA-->>Executor: 返回参数需求
Executor-->>Planner: 返回执行结果
Planner->>Planner: 生成Required_params
Planner->>Memory: 更新决策记录
Planner->>Guidance: 调用对话引导
Guidance->>Memory: 读取Required_params
Guidance->>User: 生成引导话术
User->>Planner: 提供参数/自由提问
Planner->>Memory: 参考决策记录
alt 意图为自由提问
Planner->>Guidance: 优先答疑
Guidance->>User: 回答问题+引导参数
else 意图为参数提供
Planner->>Extractor: 调用参数提取
Note over Extractor: 并发提取+样式验证
Extractor->>Memory: 读取对话记录
Extractor-->>Planner: 返回Collected_params
Planner->>Planner: 对比参数收集状态
end
alt 参数未收集完毕
Planner->>Guidance: 继续引导
else 参数收集完毕
Planner->>Executor: 提交参数执行
Executor->>RPA: 调用接口
RPA-->>Executor: 返回执行结果+截图
Note over Executor: 多模态状态分析
Executor->>Executor: 提取执行状态
Executor-->>Planner: 返回状态列表
alt 有失败/未填参数
Planner->>Planner: 更新Required_params
Planner->>Guidance: 重新引导
else 全部成功
Planner->>User: 办理完成通知
end
end
8.2 数据结构关系总结
| 数据结构 | 生成来源 | 使用对象 | 作用 |
|---|---|---|---|
| Required_params | RPA规划智能体 | 对话引导、参数提取 | 定义当前轮需收集的参数 |
| Collected_params | 参数提取智能体 | RPA规划、RPA执行 | 存储已成功提取的参数值 |
| Memory | RPA规划、对话引导 | RPA规划、参数提取 | 全局状态记忆，支持跨轮次传递 |
九、技术亮点与价值总结
9.1 六大核心技术创新
| 创新点 | 技术实现 | 价值体现 |
|---|---|---|
| 1. 四层智能体职责分离 | 规划、引导、提取、执行四层架构 | 功能解耦，避免单点过载 |
| 2. 闭环反馈驱动 | 感知-规划-执行-反馈闭环 | 动态适应环境变化，自动恢复 |
| 3. 混合意图处理 | 决策树+Memory参考 | 准确区分参数提供/自由提问/混合意图 |
| 4. 并发参数提取 | 线程池+样式验证 | 提升效率，提高准确性 |
| 5. 双优先级对话 | 答疑优先、引导其次 | 优化用户体验，避免"盘问式"交互 |
| 6. 多模态状态监控 | 文本+图像融合分析 | 补充识别盲区，提高完整度 |
9.2 四大应用价值
（1）实现"智能问答"到"智能帮办"的服务跃升
- 深度集成RPA技术，不仅理解用户意图，更可主动驱动业务流程
- 自动完成信息填写、材料提交、进度跟踪等实际操作
- 显著提升政务服务自动化水平和办事效率
（2）提升动态环境适应性与鲁棒性
- 构建"感知-规划-执行-反馈"闭环控制机制
- 基于执行结果动态调整策略，有效应对表单结构变更
- Memory全局记忆实现跨轮次状态追踪，支持异常恢复
（3）优化参数管理与提取效率
- 并发参数提取+样式验证机制，避免多参数联合提取的性能瓶颈
- 动态生成待收集参数列表，减少交互轮次
- 专用模块处理参数提取，精度远高于LLM附带任务
（4）提升决策可靠度与系统可解释性
- 智能体职责分离，各模块专司其职，从根本上避免单点决策超载
- 规则化提示词设计，决策逻辑清晰可追溯
- 混合意图处理依托全局记忆，保证上下文一致性
9.3 对比传统方案的优势
| 维度 | 传统方案 | 本系统方案 |
|---|---|---|
| 服务深度 | 停留在问答层面 | 深入业务办理，主动帮办 |
| 适应性 | 脚本固化，难以应对变化 | 动态规划，自动恢复 |
| 参数管理 | 重复采集、遗漏严重 | 显式状态管理，精确追踪 |
| 交互体验 | 机械盘问或自由发挥 | 双优先级机制，自然流畅 |
| 决策可靠性 | 单点决策易出幻觉 | 多智能体协同，可解释性强 |
| 状态监控 | 仅依赖文本分析 | 文本+图像多模态分析 |
十、结语
本系统通过引入基于检索增强与大模型多智能体协同架构，实现了智能体规划、对话引导、参数提取与RPA执行的四层职责分离，有效克服了传统方法在动态适应性、参数管理、人机交互、混合意图处理和复杂决策方面的固有缺陷。
未来，我们将持续优化以下方向：
- 扩展知识检索范围：引入更丰富的政策法规、办事指南等知识源
- 强化RPA能力：支持更多政务业务场景的自动化操作
- 提升个性化服务：基于用户画像提供定制化帮办服务
- 增强可解释性：提供决策过程可视化，提升用户信任度
通过技术创新与业务场景深度融合，我们致力于为用户提供高度自动化、体验友好且鲁棒高效的智能政务帮办服务，推动政务服务智能化升级。
