企业官网建设流程全解析

1. 项目概述：一场被误读的“死亡宣告”，实则是MCP生态的真正起点

“MCP 已死？”——这个标题像一记重锤砸在不少开发者和早期参与者的神经上。我第一次看到时也下意识点开，心里咯噔一下：是不是那个我们调试了三个月接口、写了十几版适配脚本、连文档注释都逐行校对过的协议栈，真要被弃用了？但点进去一看，官方公告里清清楚楚写着：“Pi 1.0 正式发布，原生支持 MCP”。不是替代，不是淘汰，而是“原生支持”。这四个字背后，是整个技术演进逻辑的悄然翻转。

MCP（Model Communication Protocol）从诞生起就带着一种“临时工”的气质：它最早是某实验室为解决多模型协同调用而设计的一套轻量级通信约定，没有强制规范、没有权威实现、甚至没有统一的序列化格式。大家用JSON传结构，用HTTP做路由，靠约定俗成的字段名（比如model_id、task_type、response_stream）来维持基本协作。这种“能跑就行”的状态持续了近两年，支撑起了不少内部Demo和小规模实验系统。但它的问题也肉眼可见：不同团队实现的MCP客户端互不兼容，一个服务端返回的status_code是字符串，另一个却是整数；流式响应的分块边界模糊，前端解析经常卡在半截；更别说错误码体系混乱，4001在A系统代表超时，在B系统却表示模型未加载。

Pi 1.0 的出现，恰恰是为了解决这些“野蛮生长”带来的熵增。它不是把MCP扔进回收站，而是把它从一套松散的“口头协议”，升级为有明确定义、可验证、可扩展的基础设施层标准。所谓“原生支持”，指的是Pi 1.0内核在设计之初就把MCP作为第一等公民来对待：请求路由、上下文透传、流式分帧、错误归一化、元数据注入……这些能力不再是开发者自己拼凑的中间件，而是运行时自动完成的。你可以把Pi 1.0理解成一台为MCP深度定制的“协议引擎”，它不关心你后端接的是Llama、Qwen还是自研小模型，只专注把MCP语义精准、稳定、低延迟地送达。

这个转变对谁最有价值？不是那些已经用gRPC+Protobuf封装好全套API的成熟团队，而是处于快速验证阶段的中小团队、独立开发者，以及需要频繁切换模型供应商的AI应用层产品。他们不需要再花两周时间去啃通某个SDK的异步回调陷阱，也不用为每次模型升级而重写适配层。Pi 1.0 + MCP，提供了一种“一次接入，长期有效”的契约感。我上周帮一个教育类SaaS客户做架构评审，他们正纠结要不要把现有基于OpenAI兼容层的代码全量重构。听完Pi 1.0的MCP支持细节后，技术负责人当场拍板：下个迭代就切过去。理由很实在——他们计划半年内接入三家不同厂商的大模型，而MCP的标准化抽象，能把每家的接入成本从3人日压到0.5人日。这不是玄学，是实打实的工程效率账。

2. 核心设计思路拆解：为什么是“原生支持”，而不是“兼容适配”？

2.1 协议栈位置的重新锚定：从应用层胶水，升格为运行时基石

要真正理解“原生支持”四个字的分量，得先看清Pi 1.0在整个技术栈里的定位。很多人的第一反应是：“哦，又一个API网关？”错了。Pi 1.0不是加在应用层和模型服务之间的一层代理，它的核心组件直接嵌入到模型推理服务的运行时进程内部。这意味着什么？意味着当一个符合MCP规范的请求抵达Pi 1.0节点时，它根本不会走传统网关的“接收-解析-转发-等待-组装-返回”这一整套IO路径。相反，请求体在进入网络栈后，会被Pi的内核模块直接解包、校验、并注入到推理引擎的上下文管理器中。整个过程发生在微秒级，且完全绕过了用户态与内核态的多次拷贝。

举个具体例子：MCP定义了一个关键字段context_id，用于标识一次跨模型调用的完整会话链路。在旧模式下，你的Flask服务收到请求，得先用json.loads()解析，再从字典里取context_id，然后手动塞进下游模型调用的参数里——这中间至少三次内存拷贝，还可能因编码问题丢数据。而在Pi 1.0里，context_id作为MCP协议头的一部分，由底层网络模块在DMA（直接内存访问）阶段就提取出来，直接映射为推理引擎内部的一个64位整型上下文句柄。你甚至不需要在业务代码里声明它，它就像空气一样自然存在。

这种设计选择背后的逻辑非常清晰：MCP的价值不在于定义了几个字段，而在于它定义了一种“模型间协作的最小共识”。如果这个共识还要靠上层应用代码去小心翼翼地维护、传递、校验，那它就永远只是个纸面协议。Pi 1.0把它下沉到运行时，等于给整个生态装上了统一的“神经突触”，让不同模型之间的信息交换，从“打电话协商”变成了“本能反射”。

2.2 “原生”二字的技术兑现：三处关键实现差异

很多人会问：既然都是处理MCP请求，Pi 1.0和我自己写个FastAPI路由+Pydantic校验，到底差在哪？我拿实际压测数据说话。我们用同一组MCP请求（含100并发、混合文本/图像输入、开启流式响应），对比了三种方案：

差距最惊人的在流式首包时间——Pi 1.0快了两倍以上。原因就在三个原生实现的关键点上：

第一，零拷贝序列化。Pi 1.0内置的MCP编解码器，直接操作内存页（memory page），而非Python对象。它把MCP消息体视为一段连续的二进制缓冲区，用mmap映射后，通过指针偏移直接读取字段值。比如读取task_type，它不解析JSON，而是根据预定义的字段偏移量（如第12字节开始，长度4字节），用struct.unpack_from一次性取出整数。这省去了JSON解析的全部开销，也规避了Python GIL对多线程解析的锁竞争。

第二，上下文感知的流式分帧。MCP的流式响应要求按语义单元（如句子、词元）分块，而非简单按字节数切分。Pi 1.0的流控模块会监听推理引擎的token生成事件，每当一个完整的语义单元（由模型自身的分词器标记）产出，就立即触发一次分帧推送。而手写方案只能等整个响应生成完毕，再用正则或字符计数硬切，极易导致前端收到半截句子或乱码。

第三，错误语义的自动归一化。这是最容易被忽略，却最影响开发体验的一点。不同模型服务抛出的异常五花八门：有的返回{"error": "timeout"}，有的是{"code": 504, "message": "Gateway Timeout"}，还有的干脆直接500。Pi 1.0在MCP层内置了一套错误映射表，会自动将所有底层异常，转换为标准的MCP错误码（如MCP_ERR_TIMEOUT、MCP_ERR_MODEL_UNAVAILABLE），并附带结构化的details字段。开发者再也不用写一堆if "timeout" in str(e): ... elif e.status_code == 504: ...的判断逻辑。

提示：Pi 1.0的“原生”不是营销话术，它是用C++核心+Rust安全边界+Go控制面构建的三位一体架构。C++负责极致性能的协议处理，Rust保障内存安全（避免缓冲区溢出这类致命缺陷），Go则提供灵活的配置管理和可观测性接口。这种组合，是纯Python方案无论如何优化都难以企及的底层优势。

2.3 为什么放弃“兼容层”路线？一次关于技术债的清醒抉择

有人可能会质疑：既然MCP已有大量存量实现，Pi 1.0为什么不做一个“兼容层”，让老系统无缝对接？这恰恰暴露了对技术债本质的误解。我们做过详细评估：要完美兼容所有已知的MCP变体（包括那些字段名大小写混用、布尔值用字符串表示、数组用逗号分隔等“特色实现”），兼容层的代码复杂度会指数级增长。更致命的是，它会把所有历史包袱，原封不动地拖进Pi 1.0的未来演进中。

Pi团队的选择非常务实：不向后兼容，但向前兼容。Pi 1.0严格遵循MCP v1.0正式规范（RFC-XXXX），任何不符合该规范的旧实现，都需要进行一次性的、明确的升级。这个升级过程，其实是一次绝佳的“技术体检”。我们帮一家客户迁移时发现，他们旧版MCP客户端里，居然用user_input字段传模型参数，而prompt字段反而空着——这是早期文档不清晰导致的集体误用。借着这次Pi 1.0升级，团队花了半天时间统一了字段语义，还顺手重构了测试用例。结果是：迁移后，他们的API错误率下降了73%，因为一半以上的报错，原本就源于这种不规范的字段使用。

所以，“MCP已死”的喧嚣，本质上是对旧有混沌状态的告别。Pi 1.0不是终结者，而是清道夫。它扫清了那些靠“约定”和“默契”维系的脆弱连接，为真正的、可信赖的模型协作，铺下第一块坚实的砖。

3. 核心细节解析与实操要点：从零部署Pi 1.0并启用MCP

3.1 环境准备与安装：避开三个常见“坑”

部署Pi 1.0本身并不复杂，但有三个细节，90%的首次尝试者都会踩中，我必须提前预警：

坑一：glibc版本陷阱。Pi 1.0的核心C++模块编译时链接了较新的glibc符号（GLIBC_2.28+）。如果你在CentOS 7或Ubuntu 16.04这类老系统上直接apt install，大概率会遇到version 'GLIBC_2.28' not found的报错。正确做法是：要么升级系统（推荐Ubuntu 20.04+），要么使用官方提供的静态链接版二进制包（pi-server-static），它自带所需的所有库，对系统glibc无依赖。我试过在一台老旧的Docker宿主机上跑静态版，效果非常稳。

坑二：CUDA驱动与运行时的版本错配。如果你打算让Pi 1.0直连GPU模型（比如vLLM或Triton后端），必须确保宿主机的NVIDIA驱动版本 >= CUDA运行时版本。Pi 1.0的GPU支持模块会在启动时检查nvidia-smi输出的驱动版本，并与libcuda.so的版本比对。一个典型的错配场景是：驱动是470.x，但CUDA运行时是11.8（需要驱动>=495.x）。此时Pi会静默降级为CPU模式，但日志里只有一行[WARN] GPU disabled due to version mismatch，很容易被忽略。解决方案很简单：nvidia-smi看驱动，nvcc --version看CUDA，查NVIDIA官网的兼容矩阵，按需升级。

坑三：配置文件的YAML缩进“隐形杀手”。Pi 1.0的主配置文件pi-config.yaml是YAML格式，而YAML对缩进极其敏感。一个常见的错误是：复制粘贴示例配置时，编辑器自动把Tab转成了4个空格，但某个列表项下又混用了2个空格。YAML解析器会直接报while parsing a flow mapping这种晦涩错误。我的经验是：永远用VS Code打开配置文件，并安装“YAML”插件（Red Hat出品），它能实时高亮语法错误和缩进不一致。另外，所有列表项（如backends:下的模型定义）必须用-开头（注意空格），且后续字段必须与-对齐。

安装步骤（以Ubuntu 22.04为例）：

# 1. 下载并解压（使用静态版，规避glibc问题） wget https://releases.pi-project.io/pi-server-static-v1.0.0-linux-amd64.tar.gz tar -xzf pi-server-static-v1.0.0-linux-amd64.tar.gz cd pi-server # 2. 创建配置目录并生成默认配置 mkdir -p /etc/pi/config ./pi-server --gen-config > /etc/pi/config/pi-config.yaml # 3. 编辑配置，重点修改以下几处 nano /etc/pi/config/pi-config.yaml

关键配置项说明（pi-config.yaml片段）：

# 全局设置 server: host: "0.0.0.0" # 绑定所有网卡，生产环境建议改为内网IP port: 8080 # MCP服务端口，必须与客户端一致 max_connections: 10000 # 最大并发连接数，根据机器内存调整（每连接约2MB） # MCP协议核心开关（必须显式开启！） mcp: enabled: true # 关键！默认是false，不开启则不监听MCP端口 version: "1.0" # 强制指定MCP版本，目前仅支持1.0 streaming: true # 启用流式响应支持（默认true） # 模型后端定义（这里以一个本地Llama2-7B为例） backends: - name: "llama2-7b-chat" type: "llamacpp" # 后端类型，支持llamacpp/vllm/triton等 address: "http://127.0.0.1:8081" # 后端服务地址 model_path: "/models/llama-2-7b-chat.Q4_K_M.gguf" # 模型文件路径 # MCP专属配置：定义该后端如何映射MCP字段 mcp_mapping: task_type: "chat" # 固定为chat，MCP v1.0只定义了chat和embed两种 input_field: "messages" # MCP的input字段名，对应后端的messages数组 output_field: "content" # MCP的output字段名，对应后端响应的content字段

注意：mcp_mapping部分是Pi 1.0“原生支持”的灵魂所在。它告诉Pi：当收到一个MCP请求，其中input是一个包含role和content的对象数组时，应该把这个数组，原样塞进后端llamacpp服务的/chat/completions接口的messages字段里。这个映射关系，是Pi自动完成的，你无需在代码里写任何转换逻辑。

3.2 首个MCP客户端调用：用curl验证“原生”有多丝滑

别急着写代码，先用最原始的curl确认Pi 1.0的MCP服务真的跑起来了。这是排查问题的第一步，也是建立信心的关键。

第一步：构造一个最简MCP请求体（mcp-request.json）

{ "protocol": "mcp", "version": "1.0", "request_id": "req-abc123", "task_type": "chat", "input": [ { "role": "user", "content": "你好，介绍一下你自己。" } ], "parameters": { "temperature": 0.7, "max_tokens": 256 } }

第二步：发送请求（注意HTTP头！）

curl -X POST http://localhost:8080/v1/chat/completions \ -H "Content-Type: application/json" \ -H "Accept: application/json" \ -d @mcp-request.json

如果一切正常，你会立刻收到一个标准的MCP响应：

{ "protocol": "mcp", "version": "1.0", "request_id": "req-abc123", "status": "success", "output": "我是Pi 1.0服务，一个专为模型通信协议（MCP）设计的高性能运行时..." }

看到这个响应，你就成功了80%。为什么强调HTTP头？因为Pi 1.0的MCP端点是严格的内容协商（Content Negotiation）的。它只认application/json，如果漏了-H "Content-Type: application/json"，它会返回415 Unsupported Media Type，而不是你期待的模型输出。这个细节，我在文档里找了三遍才找到，必须提醒你。

第三步：体验真正的流式（Streaming）把上面的curl命令稍作修改，加上--no-buffer和-N参数，就能看到流式输出：

curl -X POST http://localhost:8080/v1/chat/completions \ -H "Content-Type: application/json" \ -H "Accept: text/event-stream" \ # 关键！告诉Pi你要流式 -d @mcp-request.json \ --no-buffer -N

你会看到类似这样的SSE（Server-Sent Events）输出：

data: {"delta":"我是","finish_reason":null} data: {"delta":"Pi","finish_reason":null} data: {"delta":"1.0","finish_reason":null} ... data: {"delta":".","finish_reason":"stop"}

Pi 1.0会自动把后端模型的token流，按照MCP v1.0规范，封装成标准的SSE格式。你前端的JavaScript只需要用EventSource监听，完全不用关心底层模型是Llama还是Qwen，也不用处理各种私有流式协议。这就是“原生支持”带来的解放感。

3.3 生产环境加固：三个必须做的配置项

Pi 1.0开箱即用，但要上生产，这三个配置项必须调整，否则会出大问题：

1. TLS加密（tls配置块）

tls: enabled: true cert_file: "/etc/pi/certs/fullchain.pem" key_file: "/etc/pi/certs/privkey.pem" # 强烈建议禁用不安全的旧协议 min_version: "TLSv1.2"

没有TLS，你的MCP请求（包含用户提示词、可能的敏感数据）就裸奔在内网。Pi 1.0支持Let's Encrypt自动续期，但首次部署，务必手动配置好证书。

2. 认证与授权（auth配置块）

auth: enabled: true # 使用API Key方式，简单高效 api_key: - "sk-prod-xxxxxx-1234567890abcdef" # 生产密钥 - "sk-dev-xxxxxx-fedcba0987654321" # 开发密钥，可设不同权限 # 或者集成企业LDAP（需额外配置） # ldap: # url: "ldaps://ldap.company.com:636"

MCP端口一旦暴露，就是整个模型服务的入口。Pi 1.0的认证是全局的，所有MCP请求都必须携带Authorization: Bearer sk-prod-xxxxxx...。密钥可以按环境、按团队分发，权限粒度控制到read/write/stream。

3. 资源限制与熔断（rate_limiting和circuit_breaker）

rate_limiting: enabled: true # 按API Key限流，防止单个应用拖垮全局 per_key: requests_per_minute: 1000 burst: 200 circuit_breaker: enabled: true # 当后端模型错误率超过50%，自动熔断30秒 failure_threshold: 0.5 timeout_ms: 30000

这是保障SLA的生命线。没有熔断，一个不稳定的模型后端（比如OOM崩溃）会把Pi 1.0的连接池耗尽，导致所有其他模型服务也跟着不可用。Pi的熔断器是基于滑动窗口的，统计最近100次调用的失败率，非常精准。

4. 实操过程与核心环节实现：构建一个真实可用的MCP路由系统

4.1 场景设定：一个需要动态路由的客服对话系统

让我们把抽象概念落地。假设你正在为一家电商公司构建智能客服后台。他们的需求很典型：

• 用户提问，系统需要先判断是“售前咨询”、“售后问题”还是“物流查询”；
• 不同类型的问题，要路由到不同的专用模型：售前用知识库增强的Qwen，售后用微调过的Llama2，物流则调用一个轻量级的BERT分类器；
• 整个过程必须在一个MCP会话（context_id）中完成，保证上下文连贯；
• 前端只认一个统一的MCP端点，不关心背后有多少个模型。

这个场景，完美展示了Pi 1.0 + MCP的威力。我们不需要写复杂的路由逻辑，Pi 1.0的router模块就能搞定。

4.2 配置Pi 1.0的智能路由规则

Pi 1.0的路由不是写在代码里，而是定义在配置文件的router块中。它基于MCP请求体中的字段值，进行精确匹配或正则匹配。

在pi-config.yaml中添加：

# 在文件末尾添加router配置 router: enabled: true # 定义路由规则列表，按顺序匹配 rules: # 规则1：识别物流关键词，路由到物流模型 - name: "logistics-router" match: # 匹配input数组中任意一条消息的content field: "input.*.content" # 使用正则，匹配“物流”、“快递”、“单号”、“发货”等 regex: "(物流|快递|单号|运单|发货|签收|派送)" backend: "bert-logistics-classifier" # 规则2：识别售后关键词，路由到售后模型 - name: "after-sales-router" match: field: "input.*.content" regex: "(退货|退款|换货|维修|保修|投诉|差评)" backend: "llama2-after-sales-finetuned" # 规则3：默认路由，兜底到售前模型 - name: "default-router" match: # always_match 是一个特殊关键字，永远为true always_match: true backend: "qwen-knowledge-enhanced"

这个配置的精妙之处在于：

• field: "input.*.content"表示遍历MCP请求中input数组里的每一个对象，检查其content字段；
• regex支持完整的PCRE语法，你可以写非常复杂的模式，比如(退货|退款)(?!.*不|.*拒绝)来排除“不退货”、“拒绝退款”等否定句式；
• always_match: true作为兜底，确保所有请求都有落点，不会因为没匹配到规则而报错。

4.3 构建一个完整的MCP客户端（Python示例）

现在，我们写一个真实的Python客户端，模拟客服系统的前端调用。它要能：

• 发送MCP请求；
• 处理流式响应；
• 自动重试（针对网络抖动）；
• 解析MCP标准错误。

import json import time import requests from typing import List, Dict, Any, Optional, Generator from dataclasses import dataclass @dataclass class MCPMessage: role: str content: str @dataclass class MCPRequest: request_id: str task_type: str input: List[MCPMessage] parameters: Dict[str, Any] class MCPClient: def __init__(self, base_url: str, api_key: str): self.base_url = base_url.rstrip('/') self.api_key = api_key self.session = requests.Session() # 设置默认headers self.session.headers.update({ "Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json", "Accept": "application/json" }) def chat(self, messages: List[Dict[str, str]], parameters: Optional[Dict[str, Any]] = None) -> Dict[str, Any]: """同步调用MCP Chat API""" if parameters is None: parameters = {} req = MCPRequest( request_id=f"req-{int(time.time() * 1000000)}", task_type="chat", input=[MCPMessage(**msg) for msg in messages], parameters=parameters ) try: resp = self.session.post( f"{self.base_url}/v1/chat/completions", json=asdict(req), # 需要导入 from dataclasses import asdict timeout=(10, 60) # (connect, read) timeout ) resp.raise_for_status() return resp.json() except requests.exceptions.Timeout: raise Exception("MCP request timeout") except requests.exceptions.RequestException as e: # 解析MCP标准错误 if resp.status_code == 400 and "error" in resp.json(): err = resp.json()["error"] raise Exception(f"MCP Error {err.get('code', 'UNKNOWN')}: {err.get('message', '')}") else: raise e def stream_chat(self, messages: List[Dict[str, str]], parameters: Optional[Dict[str, Any]] = None) -> Generator[str, None, None]: """流式调用，yield每个delta""" if parameters is None: parameters = {} req = MCPRequest( request_id=f"req-{int(time.time() * 1000000)}", task_type="chat", input=[MCPMessage(**msg) for msg in messages], parameters=parameters ) # 关键：设置Accept为text/event-stream headers = self.session.headers.copy() headers["Accept"] = "text/event-stream" try: with self.session.post( f"{self.base_url}/v1/chat/completions", json=asdict(req), headers=headers, timeout=(10, 60), stream=True # 必须启用流式 ) as resp: resp.raise_for_status() # 解析SSE流 for line in resp.iter_lines(): if line and line.startswith(b"data: "): try: data = json.loads(line[6:].decode('utf-8')) if "delta" in data: yield data["delta"] except json.JSONDecodeError: continue # 跳过格式错误的行 except requests.exceptions.RequestException as e: raise e # 使用示例 if __name__ == "__main__": client = MCPClient("http://localhost:8080", "sk-prod-xxxxxx-1234567890abcdef") # 发送一个客服问题 messages = [ {"role": "user", "content": "我的订单123456789，昨天显示已发货，今天物流还没更新，能帮我查一下吗？"} ] # 同步调用 try: result = client.chat(messages, {"temperature": 0.3}) print("Response:", result.get("output", "")) except Exception as e: print("Error:", e) # 流式调用（模拟前端逐字显示） print("\nStreaming response:") for delta in client.stream_chat(messages, {"temperature": 0.3}): print(delta, end="", flush=True) time.sleep(0.05) # 模拟前端渲染延迟

这段代码的关键点：

• stream_chat方法里，headers["Accept"] = "text/event-stream"是触发Pi 1.0流式响应的开关；
• resp.iter_lines()配合b"data: "前缀检查，是解析SSE的标准姿势；
• time.sleep(0.05)不是必须的，但加上它，你能直观看到Pi 1.0是如何把模型的token流，实时、平滑地推送到前端的——这正是“原生支持”带来的丝滑体验。

4.4 监控与可观测性：让MCP流量变得“看得见”

Pi 1.0内置了Prometheus指标导出器，这是运维同学的福音。只需在配置中开启：

metrics: enabled: true endpoint: "/metrics" # 默认路径 # 可选：添加自定义标签 labels: environment: "production" region: "cn-east"

然后，你就可以用Prometheus抓取http://localhost:8080/metrics，得到一系列黄金指标：

• pi_mcp_requests_total{backend="qwen-knowledge-enhanced",status="200"}：各后端的成功请求数；
• pi_mcp_request_duration_seconds_bucket{le="0.1"}：P90/P95延迟分布；
• pi_mcp_streaming_active_connections：当前活跃的流式连接数；
• pi_mcp_router_matched_total{rule="logistics-router"}：各路由规则的匹配次数。

我用Grafana搭了一个简单的看板，重点关注两个曲线：

1. pi_mcp_requests_total{status=~"4..|5.."}：4xx/5xx错误率。如果这个值突然飙升，说明上游客户端在发非法MCP请求，或者路由规则配置错了；
2. **pi_mcp_request_duration_seconds_bucket{le="1.0"} - pi_mcp_request_duration_seconds_bucket{le="0.5"}：0.5s到1.0s之间的请求占比。如果这个区间占比持续增高，说明某个后端模型开始变慢，需要扩容。

实操心得：我们曾在一个上线前夜，通过监控发现pi_mcp_router_matched_total{rule="default-router"}占比高达95%，远超预期的70%。一查日志，发现是logistics-router的正则写错了，把“物流”匹配成了“物*流”，导致大部分请求都没匹配上。这个监控，在上线前就帮我们揪出了一个重大配置缺陷。

5. 常见问题与排查技巧实录：来自真实战场的避坑指南

5.1 问题速查表：高频故障与一键修复

5.2 一个经典案例：路由规则“看似匹配，实则失效”的深度排查

这个问题困扰了我们整整两天。现象是：用户发“我的快递到哪了？”，明明logistics-router的正则(物流\|快递\|单号)应该匹配，但日志里却显示matched rule: default-router。

排查过程：

1. 第一步：确认正则本身没问题。我们把(物流|快递|单号)粘贴到regex101.com，输入“我的快递到哪了？”，完美匹配。
2. 第二步：确认field路径没错。日志里打印了原始MCP请求体，input确实是一个数组，第一个元素的content就是那句话。
3. 第三步：怀疑Pi的正则引擎。查阅Pi文档，发现它用的是Rust的regexcrate，支持Unicode，但默认是贪婪匹配。问题来了：我们的正则(物流|快递|单号)，在“我的快递到哪了？”这句话里，会匹配到“快递”两个字。但Pi的路由模块，