---

一、从"写死流程"到"智能编排"：RPA 的进化困境

去年接了一个电商后台自动化的需求，客户要求每天从 5 个不同平台获取订单数据，核对库存，生成发货单，再逐个通知客户。用传统 RPA 工具写流程时，我遇到了一个典型的问题：

每个平台的页面结构都不一样，而且经常改版。 传统 RPA 靠录制和固定 XPath 定位元素，页面一变就全盘崩溃。更麻烦的是，有些步骤需要判断：如果库存不足，要自动切换供应商；如果客户要求加急，要优先处理。这些分支逻辑用传统 RPA 写起来非常痛苦，代码量爆炸，维护成本极高。

当时我在用蓝印RPA做网页自动化，它的本地元素智能生成功能确实比手写 XPath 稳定很多，但面对这种"需要理解业务语义才能决策"的场景，纯 RPA 还是力不从心。

直到 MCP 协议出现，我才找到一条更优雅的路线：让 AI Agent 负责"思考和决策"，让 RPA 负责"动手执行"，中间用 MCP 协议做标准化通信。 这样每个平台改版时，Agent 能自动理解新页面结构，RPA 只需执行具体操作，多步骤业务编排分工明确。

---

二、MCP 协议到底是什么？为什么它能打通 Agent 和 RPA

MCP（Model Context Protocol）是 Anthropic 在 2024 年底提出的开放标准，2025 年捐给 Linux 基金会后，2026 年已经成为 AI Agent 调用外部工具的事实标准。

简单来说，MCP 协议就是 AI 工具的 USB-C 接口。以前每个 Agent 框架接外部工具都要写一套定制代码，现在只要工具提供方实现一个 MCP Server，任何支持 MCP 的 Agent 都能直接调用。

2.1 MCP 的三层架构

MCP Host（宿主应用） 运行 LLM 的应用程序，比如 Claude Desktop、Cursor、或者你自己开发的 Agent 系统。Host 负责理解用户意图，决定是否需要调用外部工具。

MCP Client（客户端） 嵌入在 Host 中的通信层，负责把 LLM 的 Function Calling 请求转换成 MCP 协议格式的 JSON-RPC 2.0 消息，通过 stdio（本地进程）或 HTTP+SSE（远程服务）传输给 Server。

MCP Server（服务端） 工具提供方实现的轻量服务，暴露三类核心能力：

• Tools：可被 LLM 调用的函数，比如"获取网页数据"、"填写表单"、"发送通知"

• Resources：只读数据，比如数据库记录、配置文件

• Prompts：预置提示模板，引导 LLM 在特定场景下的行为

关键优势：一个 MCP Server 可以被 N 个 Agent 复用。你写一次 RPA 工具的封装，Claude、GPT、DeepSeek 都能调用。

2.2 为什么 MCP 比传统 API 集成更适合 RPA？

传统方式给 RPA 加 AI 能力，通常是直接调 OpenAI API，把页面 HTML 丢给 LLM 分析，再解析返回结果执行点击。这种方式有几个坑：

• 上下文丢失：每次调 API 都是独立请求，LLM 记不住上一步点了哪个按钮

• 工具耦合：换了模型或 RPA 工具，集成代码要重写

• 调试困难：LLM 输出不稳定，出了问题很难定位是推理错了还是 RPA 执行错了

MCP 协议通过标准化接口解决了这些问题。MCP Client 维护长连接会话，LLM 的任务分解和工具选择过程被结构化记录，每一步都有审计日志。更重要的是，MCP Server 可以用 stdio 本地启动，RPA 操作完全在本地运行，数据不出本机，这对企业内网环境很重要。

---

三、为什么 Agent + RPA 必须走 MCP 路线？

传统 RPA 的瓶颈不在"执行"，而在"决策"。

场景	传统 RPA	Agent + MCP + RPA
页面结构改版	流程崩溃，需人工重写	Agent 自动理解新结构，RPA 只执行操作
多分支业务逻辑	硬编码 if-else，维护困难	LLM 动态决策，自然语言描述规则
跨系统数据整合	每个系统单独写集成	MCP Server 统一封装，Agent 动态调用
异常处理	预设规则，覆盖不全	LLM 推理判断，灵活应对未预期情况
元素抓取维护	固定 XPath，改版即失效	智能生成元素路径，自适应页面变化

举个例子：你要从某电商平台获取订单数据。传统 RPA 需要预先知道"订单列表在第几个 div"、"金额字段的 class 名是什么"。但用 MCP 封装后，Agent 可以问 LLM："这个页面哪个元素包含订单金额？" LLM 看了页面结构后，告诉 RPA 具体的元素路径，RPA 执行点击和提取。页面改版了，LLM 重新看一遍就能适应。

智能编排的核心就在这里：Agent 负责"看懂页面"，RPA 负责"动手操作"，MCP 负责"传话"。

---

四、实战：用 Python 搭建 Agent-RPA 协同框架

下面是一个可运行的核心架构，基于 mcp Python SDK 和 LangChain 的 ReAct Agent。

4.1 环境准备

pip install mcp langchain langchain-openai playwright

4.2 封装 RPA 操作为 MCP Server

# rpa_mcp_server.py
from mcp.server.fastmcp import FastMCP
import asyncio
from playwright.async_api import async_playwright

app = FastMCP("rpa-web-automation")

@app.tool()
async def navigate_to_url(url: str) -> str:
    """打开指定网页"""
    # 实际项目中这里连接 Playwright 或 RPA 工具的浏览器实例
    return f"Navigated to {url}"

@app.tool()
async def extract_data(selector: str, attribute: str = "textContent") -> str:
    """根据 CSS 选择器提取网页元素数据"""
    # 封装网页数据提取逻辑
    return f"Extracted {attribute} from {selector}"

@app.tool()
async def fill_form(selector: str, value: str) -> str:
    """在指定输入框填写内容"""
    return f"Filled {selector} with {value}"

@app.tool()
async def click_element(selector: str) -> str:
    """点击指定元素"""
    return f"Clicked {selector}"

@app.tool()
async def take_screenshot() -> str:
    """截取当前页面截图，用于 LLM 视觉分析"""
    return "Screenshot captured for analysis"

if __name__ == "__main__":
    app.run(transport="stdio")

这个 Server 暴露了 5 个 RPA 核心操作：导航、提取、填写、点击、截图。每个工具都有类型注解，FastMCP 会自动生成 JSON Schema，LLM 据此理解每个工具的输入输出格式。

4.3 Agent 编排层：ReAct + MCP Client

# agent_orchestrator.py
from langchain.agents import AgentExecutor, create_react_agent
from langchain_openai import ChatOpenAI
from langchain import hub
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
import asyncio

class MCPRPAAgent:
    def __init__(self):
        self.llm = ChatOpenAI(model="gpt-4", temperature=0)
        self.mcp_tools = []
    
    async def connect_mcp_server(self):
        """连接 RPA 的 MCP Server"""
        server_params = StdioServerParameters(
            command="python",
            args=["rpa_mcp_server.py"]
        )
        
        async with stdio_client(server_params) as (read, write):
            async with ClientSession(read, write) as session:
                await session.initialize()
                # 动态发现可用工具
                tools = await session.list_tools()
                self.mcp_tools = [
                    {
                        "name": tool.name,
                        "description": tool.description,
                        "parameters": tool.inputSchema
                    }
                    for tool in tools
                ]
                return self.mcp_tools
    
    def create_agent(self):
        """创建 ReAct Agent，集成 MCP 工具"""
        prompt = hub.pull("hwchase17/react")
        
        # 将 MCP 工具转换为 LangChain 格式
        langchain_tools = []
        for tool in self.mcp_tools:
            from langchain.tools import Tool
            langchain_tools.append(
                Tool(
                    name=tool["name"],
                    description=tool["description"],
                    func=lambda x: f"Executing {tool['name']} with {x}"
                )
            )
        
        agent = create_react_agent(self.llm, langchain_tools, prompt)
        return AgentExecutor(agent=agent, tools=langchain_tools, verbose=True)
    
    async def execute_task(self, task_description: str):
        """执行多步骤业务任务"""
        # 1. 连接 MCP Server，获取可用工具
        await self.connect_mcp_server()
        
        # 2. 创建 Agent
        agent_executor = self.create_agent()
        
        # 3. 执行：LLM 自动分解任务 -> 选择工具 -> 调用 RPA
        result = await agent_executor.ainvoke({"input": task_description})
        return result

# 使用示例
async def main():
    agent = MCPRPAAgent()
    
    # 复杂多步骤任务：Agent 自动分解执行
    task = """
    帮我处理今天的电商订单：
    1. 打开 https://seller.example.com/orders
    2. 获取所有待发货订单列表
    3. 对每个订单，查询库存系统确认是否有货
    4. 有货的生成发货单，没货的记录缺货
    5. 最后给所有有货订单的客户发送发货通知
    """
    
    result = await agent.execute_task(task)
    print(result)

if __name__ == "__main__":
    asyncio.run(main())

4.4 关键设计点与生产选型

ReAct 循环：Agent 每轮执行都遵循"推理（Reasoning）→ 行动（Acting）→ 观察（Observation）"的循环。LLM 先思考当前步骤该做什么，然后选择工具，执行后观察结果，再决定下一步。

动态工具发现：通过 list_tools() 在运行时获取可用工具，而不是硬编码。这意味着你可以随时给 RPA Server 加新工具，Agent 自动就能用，不用改 Agent 代码。

部署分发痛点：这个框架本地跑没问题，但给客户部署时，要求对方装 Python、配环境变量、装 Playwright，基本不现实。实际项目中，建议把 RPA 流程打包成独立 EXE，同时暴露 MCP Server 接口给 Agent 调用。我测试过几种方案，EXE 打包配合 API 触发是最实用的，客户侧零环境依赖，还能设置定时执行。

---

五、生产环境落地的三个关键问题

5.1 安全：数据不出本地是底线

MCP 虽然方便，但安全问题不能忽视。2026 年火山引擎的安全团队已经梳理出 MCP 面临的七大风险，包括工具描述投毒、间接提示词注入等。

生产环境建议：

• 每个 MCP Server 必须配置访问令牌（PAT），不能用裸接口

• 工具执行前加人工确认层，特别是涉及资金、数据修改的操作

• Server 端记录完整审计日志，谁调用了什么、返回了什么，全程可追溯

• 数据本地存储，流程应用数据不出本机，符合企业合规要求

5.2 性能：别让 LLM 推理拖垮 RPA

Agent 每次决策都要调 LLM，如果任务有 20 步，就是 20 次 API 调用，延迟和成本都吃不消。

优化方案：

• 批量决策：让 LLM 一次生成多步计划，而不是每步都问

• 本地缓存：常用页面结构、元素路径缓存到本地，减少重复推理

• 混合模式：简单步骤用传统 RPA 直接执行，只有需要决策的分支点才调 LLM

5.3 模型选型：别只盯着 GPT-4

Agent 的推理质量直接取决于 LLM 的工具调用能力。2026 年的实测数据显示，DeepSeekV4 在中文场景下的 MCP 工具调用准确率已经超过 GPT-4，而且成本更低。Kimi、文心一言也陆续支持了 Function Calling 规范。

建议根据场景选模型：英文场景用 GPT-4，中文业务用 DeepSeekV4，需要长上下文处理用 Kimi。

---

六、总结：MCP 让 Agent 和 RPA 真正"各司其职"

这套架构的核心价值在于解耦：

• Agent 负责"大脑"：理解业务意图、任务分解、决策分支、异常处理

• MCP 负责"神经"：标准化通信协议，让任何 Agent 能调用任何工具

• RPA 负责"手脚"：执行具体的网页自动化操作、数据获取、系统交互

2026 年 MCP 生态已经相当成熟，SDK 月下载量超过 9700 万，主流 AI 平台全部支持。 如果你正在做企业级自动化项目，建议现在就开始把 RPA 操作封装成 MCP Server，未来接入新模型、新 Agent 框架时，成本会低很多。

最后放一个我整理的技术栈选型建议：

组件	推荐方案	理由
MCP SDK	Python mcp 官方包	生态最成熟，文档完善
Agent 框架	LangChain ReAct / LangGraph	状态管理强，适合复杂流程
LLM	DeepSeekV4 / GPT-4	推理能力强，工具调用稳定
RPA 执行	Playwright + 蓝印RPA	元素定位稳定，支持打包 EXE
部署	EXE 打包 + API 触发	零环境依赖，客户友好