硬件助手产品系统架构 — AI Agent 方向升级（端·云·第三方 API 分层设计） #

面向职位：传音集团 · 资深后端开发 — 大模型算法部 核心职责 #1：研发硬件助手产品系统架构的智能体（AI Agent）方向升级，考虑端、云、第三方 API 的分层设计 背景：传音 TECNO AI 助手 Ella、覆盖 70+ 国家/地区、2025 年 5 亿+ AI 请求

一、现状与升级目标 #

1.1 当前架构痛点 #

1.2 升级目标 #

升级前：Ella = 功能模块集合（语音 + 翻译 + 视觉 + 写作 ...）
升级后：Ella = AI Agent（意图理解 → 任务规划 → 端/云/三方能力编排 → 结果交付）

核心转变：从"功能调用"到"智能体编排"

二、端·云·第三方 API 三层架构 #

2.1 总体分层 #

┌─────────────────────────────────────────────────────────────────┐
│                        用户交互层                                │
│  语音交互 │ 文本对话 │ 视觉交互 │ 手势/触控 │ 多设备（OneLeap）   │
├─────────────────────────────────────────────────────────────────┤
│                    【端侧层 — On-Device】                         │
│                                                                 │
│  ┌──────────────┐ ┌──────────────┐ ┌────────────────────────┐   │
│  │ 端侧 Agent    │ │ 端侧能力     │ │ 端侧 Memory            │   │
│  │ （轻量编排）  │ │ ├─ 离线翻译  │ │ ├─ 短期对话上下文       │   │
│  │              │ │ ├─ 离线语音  │ │ ├─ 本地偏好设置         │   │
│  │ ├─ 意图路由  │ │ ├─ 轻量 OCR  │ │ └─ 缓存知识             │   │
│  │ ├─ 端云调度  │ │ ├─ AI 降噪   │ │                        │   │
│  │ └─ 离线降级  │ │ ├─ 端侧 AIGC │ │                        │   │
│  └──────────────┘ │ └─ 端侧生图  │ └────────────────────────┘   │
│                   │  (30fps)    │                                │
│                   └──────────────┘                                │
│                   推理引擎：NPU/DSP 量化模型                       │
├─────────────────────────────────────────────────────────────────┤
│                    【云端层 — Cloud Platform】                    │
│                                                                 │
│  ┌──────────────────────────────────────────────────────────┐   │
│  │              Agent 编排引擎（核心）                        │   │
│  │                                                          │   │
│  │  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌────────────┐  │   │
│  │  │ 任务规划  │ │ 工具选择  │ │ 状态管理  │ │ 安全拦截   │  │   │
│  │  │ Planner  │ │ Selector │ │ State    │ │ Guardrail  │  │   │
│  │  └──────────┘ └──────────┘ └──────────┘ └────────────┘  │   │
│  └──────────────────┬───────────────────────────────────────┘   │
│                     │                                           │
│  ┌──────────────────┼──────────────────┬────────────────────┐   │
│  │                  │                  │                    │   │
│  ▼                  ▼                  ▼                    ▼   │
│ ┌────────┐  ┌──────────────┐  ┌──────────────┐  ┌────────────┐ │
│ │ 自研   │  │ 大模型推理   │  │ 记忆/检索    │  │ 数据/业务  │ │
│ │ 能力   │  │ (Gemini等)   │  │ (RAG+向量库) │  │ 服务       │ │
│ │ 服务   │  │              │  │              │  │            │ │
│ │·语音   │  │              │  │              │  │            │ │
│ │·翻译   │  │              │  │              │  │            │ │
│ │·视觉   │  │              │  │              │  │            │ │
│ └────────┘  └──────────────┘  └──────────────┘  └────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│                  【第三方 API 层 — Third-Party】                 │
│                                                                 │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐          │
│  │ 图像生成 │ │ 视频生成 │ │ 地图/    │ │ 生活服务 │ ...       │
│  │ (豆包)   │ │ (Veo)    │ │ 天气     │ │ API      │          │
│  └──────────┘ └──────────┘ └──────────┘ └──────────┘          │
│                                                                 │
│  统一接入：MCP Server 协议 / A2A Agent 协议                     │
│  统一治理：限流 / 熔断 / 降级 / 计量 / 计费                     │
└─────────────────────────────────────────────────────────────────┘

2.1.1 架构说明 #

（1）三层职责与数据流向

┌─────────┐     请求上行      ┌─────────┐     能力调用      ┌────────────┐
│  端侧   │ ─────────────────→ │  云端   │ ────────────────→ │ 第三方 API  │
│ (决策层) │ ←───────────────── │ (编排层) │ ←─────────────── │ (能力层)    │
└─────────┘     结果下行      └─────────┘     结果返回      └────────────┘

数据流向说明：
• 上行：端侧 → 云端（携带意图分类结果、网络状态、设备能力、用户输入）
• 编排：云端 Agent 编排引擎接收请求，进行任务规划 + 工具选择
• 外调：云端按需调用第三方 API（MCP/A2A 协议），获取垂类专业能力
• 下行：结果经云端聚合/格式化后返回端侧渲染
• 端侧直出：部分请求在端侧即可闭环，不经过云端

（2）各层关键组件说明

（3）层级间通信协议

（4）端云部署拓扑

                        ┌──────────────────┐
                        │   CDN / Edge     │
                        │  (静态资源缓存)   │
                        └────────┬─────────┘
                                 │
                        ┌────────▼─────────┐
                        │  API Gateway     │
                        │  (鉴权/限流/路由) │
                        └────────┬─────────┘
                                 │
              ┌──────────────────┼──────────────────┐
              ▼                  ▼                  ▼
        ┌──────────┐      ┌──────────┐      ┌──────────┐
        │  Agent    │      │  业务    │      │  数据    │
        │  编排引擎  │      │  服务    │      │  服务    │
        │          │      │          │      │          │
        │·Planner  │      │·语音服务 │      │·RAG检索  │
        │·Selector │      │·翻译服务 │      │·Memory   │
        │·State    │      │·视觉服务 │      │·Analytics│
        └────┬─────┘      └────┬─────┘      └────┬─────┘
             │                 │                  │
             └─────────────────┼──────────────────┘
                               │
                        ┌──────▼──────┐
                        │  MCP/A2A   │
                        │  治理网关    │
                        └──────┬──────┘
                               │
                    ┌──────────┼──────────┐
                    ▼          ▼          ▼
                 ┌────┐   ┌────┐   ┌────┐
                 │豆包│   │Veo │   │... │
                 └────┘   └────┘   └────┘

（5）资源预算约束

2.2 三层边界与职责划分 #

2.2.1 核心职责矩阵 #

2.2.2 边界判定原则 #

三层之间不是随意分工，而是有明确的边界判定原则，确保每个请求都能被最合适的层级处理：

判定维度：

① 算力需求
   低算力（文本分类、简单翻译、规则匹配）
     → 端侧

   中高算力（多轮对话、逻辑推理、代码生成）
     → 云端

   专业算力（图像/视频生成、3D 渲染）
     → 第三方

② 数据敏感性
   高敏感（健康数据、通讯录、密码、生物特征）
     → 优先端侧

   中敏感（位置信息、个人偏好）
     → 端侧 or 云端（用户授权）

   低敏感（天气、新闻、公开知识）
     → 云端 or 第三方

③ 实时性要求
   强实时（< 200ms：语音通话、实时翻译）
     → 端侧

   弱实时（< 3s：问答、写作）
     → 云端

   非实时（> 3s：生图、生视频、搜索）
     → 云端 + 第三方（可异步）

④ 网络依赖
   离线可用
     → 端侧

   需要联网但弱网可接受
     → 云端（带降级策略）

   必须联网
     → 云端 + 第三方（带熔断保护）

2.2.3 能力分层清单 #

将 Ella 的核心能力按层级归类，形成清晰的能力清单：

2.2.4 数据流转边界 #

三层之间的数据流动遵循最小必要原则：

数据流转规则：

┌─────────────┐      最小必要数据       ┌─────────────┐
│             │ ──────────────────────→ │             │
│   端侧       │                        │   云端       │
│             │ ←────────────────────── │             │
└─────────────┘     处理结果 / 配置      └─────────────┘

规则：
• 端侧 → 云端：仅上传任务所需最小数据（意图类型 + 输入内容 + 设备上下文）
• 云端 → 第三方：经 Agent 编排引擎过滤后的结构化请求，不暴露用户原始输入
• 云端 → 端侧：返回聚合/格式化后的结果，不暴露内部处理细节
• 敏感数据默认不出端，除非用户明确授权

隐私保护分级：
┌──────┬──────────────────┬──────────────┬───────────────┐
│ 级别 │ 数据类型          │ 处理位置      │ 传输方式       │
├──────┼──────────────────┼──────────────┼───────────────┤
│ L0   │ 公开信息（天气等） │ 云端/第三方   │ 明文/HTTPS     │
│ L1   │ 个人偏好          │ 云端（授权）  │ 加密传输       │
│ L2   │ 位置/通讯录       │ 优先端侧      │ 加密传输 + 脱敏│
│ L3   │ 生物特征/密码     │ 仅端侧        │ 不出端         │
└──────┴──────────────────┴──────────────┴───────────────┘

2.2.5 端云能力的协同与互补 #

三层不是孤立存在，而是协同互补的关系：

协同模式：

1. 串联协同（Pipeline）
   端侧预处理 → 云端推理 → 第三方能力补充 → 端侧渲染
   例：拍照解题 = 端侧 OCR → 云端 LLM 解题 → 端侧展示

2. 并行协同（Parallel）
   云端同时调用多个第三方能力，汇总结果
   例：行程规划 = 天气 API + 地图 API + 餐饮 API → LLM 整合

3. 竞争协同（Fallback）
   主能力不可用时，自动切换到备选能力
   例：豆包不可用 → SD 自建 → 返回缓存

4. 增强协同（Augmentation）
   端侧轻量模型 + 云端大模型协同推理
   例：端侧意图初判 → 云端深度理解 → 结果回灌端侧模型

2.3 端云智能调度策略 #

2.3.1 端侧 Agent 轻量编排 #

端侧 Agent 是 Ella 的"第一道关卡"，负责在 50ms 内做出路由决策。其核心是一个轻量级意图分类器 + 规则调度引擎，不依赖大模型。

┌─────────────────────────────────────────────────────────┐
│                  端侧 Agent 轻量编排                      │
│                                                         │
│  ┌───────────┐    ┌───────────┐    ┌──────────────────┐ │
│  │ 输入解析   │───→│ 意图分类  │───→│ 路由决策引擎      │ │
│  │ (文本/音频 │    │ (LiteModel│    │                  │ │
│  │  /图像)    │    │  <100M)   │    │ 5 维决策因子:     │ │
│  └───────────┘    └───────────┘    │                  │ │
│                   ┌───────────┐    │ ① 意图复杂度      │ │
│  ┌───────────┐    │ 能力注册表 │    │ ② 网络质量        │ │
│  │ 网络探针   │───→│ (Capability│    │ ③ 能力可用性      │ │
│  │ (RTT/BW)  │    │  Registry) │    │ ④ 隐私分级        │ │
│  └───────────┘    └───────────┘    │ ⑤ 延迟预算        │ │
│                   ┌───────────┐    │                  │ │
│  ┌───────────┐    │ 本地 Memory│    │ 输出: 路由目标    │ │
│  │ 隐私分级器 │───→│ (上下文/   │    │ DEVICE/CLOUD/    │ │
│  │ (数据敏感度│    │  偏好/缓存) │    │ HYBRID/DEGRADED  │ │
│  │  判定)     │    └───────────┘    │                  │ │
│  └───────────┘                     └──────────────────┘ │
└─────────────────────────────────────────────────────────┘

五大决策因子详解：

决策伪代码：

// 端侧路由决策（Go 伪代码）
func (d *DeviceDispatcher) Route(req Request) RouteTarget {
    // 1. 意图分类
    intent := d.intentClassifier.Predict(req.Input)
    complexity := intent.Complexity  // SIMPLE / MEDIUM / COMPLEX
    
    // 2. 隐私分级
    privacyLevel := d.privacyScorer.Score(req.Input)  // PUBLIC / PERSONAL / SENSITIVE
    
    // 3. 网络探测
    netStatus := d.networkProbe.Measure()  // GOOD / FAIR / POOR / OFFLINE
    
    // 4. 能力匹配
    capMatch := d.capRegistry.Match(intent)
    capOnDevice := capMatch != nil && capMatch.IsAvailableOnDevice()
    
    // 5. 路由决策
    switch {
    case netStatus == OFFLINE && capOnDevice:
        return DEVICE  // 离线 + 端侧有能力 → 端侧处理
    case netStatus == OFFLINE:
        return DEGRADED  // 离线 + 无能力 → 降级
    
    case privacyLevel == SENSITIVE && capOnDevice:
        return DEVICE  // 敏感数据 + 端侧有能力 → 端侧处理（数据不出端）
    
    case complexity == SIMPLE && capOnDevice && netStatus != GOOD:
        return DEVICE  // 简单任务 + 端侧有能力 + 弱网 → 端侧处理
    
    case complexity == COMPLEX:
        return HYBRID  // 复杂任务 → 混合处理（端侧预处理 + 云端推理 + 端侧渲染）
    
    case netStatus == GOOD:
        return CLOUD  // 网络好 → 云端处理（体验最佳）
    
    default:
        return CLOUD  // 兜底：云端
    }
}

2.3.2 端云调度场景矩阵 #

以下列举 Ella 产品的典型场景，展示不同条件下端云调度的差异化路径：

场景 1：实时翻译（端侧直出）

用户："这句话用斯瓦希里语怎么说？"

┌──────────┐    意图: 翻译    ┌──────────┐
│  端侧    │ ──────────────→ │  端侧    │
│  输入    │                  │ 离线翻译  │
│          │ ←─────────────── │  引擎    │
│  输出    │    翻译结果       │ (NPU)    │
└──────────┘                  └──────────┘

• 路由: DEVICE（端侧直出）
• 延迟: < 100ms
• 网络: 不需要
• 特点: 高频、低复杂度、端侧能力成熟

场景 2：拍照解题（混合处理 — 端侧预处理 + 云端推理 + 端侧渲染）

用户：拍摄数学题照片，请求解答

端侧预处理                    云端推理                      端侧渲染
┌──────────┐               ┌──────────┐               ┌──────────┐
│ 图像采集  │               │          │               │          │
│ 图像增强  │───压缩上传───→│ OCR 提取 │───解题请求───→│ LLM 解题 │
│ 端侧 OCR  │               │ 文本理解  │←──解题结果────│          │
│ (轻量)    │               │ (Gemini) │               │          │
│          │               │          │               │ 结果展示  │
│          │               │          │               │ 图文排版  │
│          │               │          │               │ 语音播报  │
└──────────┘               └──────────┘               └──────────┘

• 路由: HYBRID（端云混合）
• 延迟: 端侧预处理 < 200ms + 云端推理 < 2s + 渲染 < 100ms
• 特点: 端侧完成计算密集型预处理，云端负责复杂推理

场景 3：AI 写作（云端主导）

用户："帮我写一封英文求职信"

┌──────────┐              ┌──────────────────────┐              ┌──────────┐
│  端侧    │───文本请求───→│       云端            │              │          │
│  输入    │              │  Agent 编排引擎       │              │  第三方   │
│          │              │  ├─ Planner: 写作规划  │───MCP调用───→│ 词典/语料 │
│          │←──长文本返回──│  ├─ Gemini: 内容生成   │←──结果──────│ API      │
│          │              │  └─ Guardrail: 安全检查│              │          │
│  输出    │              │  Memory: 写入用户画像  │              │          │
└──────────┘              └──────────────────────┘              └──────────┘

• 路由: CLOUD（云端主导）
• 延迟: 首 Token < 500ms，完整回复 < 3s
• 特点: 需要大模型推理 + 知识增强 + 可能的第三方 API

场景 4：AI 图像生成（云端 + 第三方 API）

用户："帮我生成一张非洲日落的水彩画"

端侧                  云端编排                  MCP Server              第三方
┌──────┐           ┌──────────┐             ┌──────────┐            ┌──────┐
│ 文本  │───请求───→│ Agent    │───选择工具──→│ 图像生成  │───API 调用──→│ 豆包  │
│ 输入  │           │ 编排引擎  │             │ MCP Server│             │ API  │
│      │←──图片────│          │←──图片URL────│           │←──生成结果───│      │
│ 展示  │           │          │             │           │             │      │
└──────┘           └──────────┘             └──────────┘            └──────┘

• 路由: CLOUD + Third-Party
• 延迟: 3-8s（依赖第三方生成速度）
• 降级: 豆包不可用 → 切 Stable Diffusion（自建）→ 返回缓存示例图

场景 5：跨设备协同（云端主导 + 端侧分发）

用户：在手机语音说"把我的会议日程同步到手表"

手机（发起端）                  云端                      手表（目标端）
┌──────────┐               ┌──────────┐               ┌──────────┐
│ 语音唤醒  │               │          │               │          │
│ 语音识别  │───请求───────→│ Agent    │───查询日历───→│ 推送日程  │
│ 意图:同步 │               │ 编排引擎  │←──日程数据────│ 卡片渲染  │
│          │               │          │               │          │
│ 确认提示  │←──执行结果────│ 路由结果  │───写入日历───→│ 震动提醒  │
└──────────┘               └──────────┘               └──────────┘

• 路由: CLOUD（多设备协同需要云端中转）
• 延迟: < 1s（端到端）
• 特点: 涉及多个设备，必须云端统一调度

场景 6：弱网下的简单问答（端侧降级）

用户在 2G 网络下："明天天气怎么样？"

┌──────────┐                              ┌──────────┐
│  端侧    │                              │  端侧    │
│  输入    │── 意图:天气 ──→ ┌──────────┐ │  降级    │
│          │                 │ 端侧缓存  │ │ "当前网络 │
│          │                 │ 中有最近  │ │  不佳，显 │
│          │←── 展示缓存数据 │ 一次结果  │ │ 示最近一次 │
│  输出    │    + "数据可能  │ (30min前) │ │ 查询结果" │
│          │    非最新"提示   │          │ │          │
└──────────┘                 └──────────┘ └──────────┘

• 路由: DEGRADED（降级）
• 延迟: < 200ms（直接读缓存）
• 特点: 弱网场景下，用旧数据 + 友好提示，优于直接报错

场景 7：多步任务规划（云端 Agent 编排）

用户："帮我规划明天去内罗毕的行程，查天气、找路线、预订餐厅"

                        云端 Agent 编排引擎
                    ┌──────────────────────────┐
                    │ Planner:                  │
                    │  Step 1: 查内罗毕天气      │────→ 天气 API
                    │  Step 2: 查询路线          │────→ 地图 API
                    │  Step 3: 推荐当地餐厅      │────→ 本地生活 API
                    │  Step 4: 整合生成行程方案   │────→ Gemini 整合
                    └──────────────────────────┘
                          │
                    ┌─────▼─────┐
                    │  端侧渲染  │
                    │ 行程卡片展示│
                    │ 语音播报概要│
                    └───────────┘

• 路由: CLOUD（云端多步编排）
• 延迟: 5-10s（多个 API 调用 + LLM 整合）
• 特点: 典型的 Agent 场景——理解复杂意图 → 拆解步骤 → 多工具调用 → 整合输出

2.3.3 调度决策矩阵（汇总） #

三、第三方 API 统一接入层 #

3.1 MCP 协议接入 #

第三方能力                    MCP Server                    Agent 编排引擎
┌──────────┐                ┌──────────────┐               ┌──────────────┐
│ 豆包生图  │────JSON-RPC───→│ MCP Server   │───工具描述────→│              │
│          │                │ (Registry)   │               │   工具选择器  │
│ 天气 API  │────JSON-RPC───→│ MCP Server   │───工具描述────→│              │
│          │                │              │               │   调用执行器  │
│ 地图服务  │────JSON-RPC───→│ MCP Server   │───工具描述────→│              │
└──────────┘                └──────────────┘               └──────────────┘

MCP 接入流程：

1. 第三方能力封装为 MCP Server
2. 自动向 Agent 编排引擎注册工具描述（JSON Schema）
3. 编排引擎将工具描述注入 LLM 的 Function Calling
4. LLM 根据用户意图选择工具 → 编排引擎调用对应 MCP Server

3.2 A2A 协议接入（Agent 间协作） #

当第三方能力本身是一个 Agent（需要自主决策、多轮交互），使用 A2A 协议：

Ella Agent                          第三方 Agent
┌─────────────┐                    ┌─────────────┐
│             │─── Agent Card ────→│             │
│  发现能力    │                    │  能力声明     │
│             │←── Agent Card ─────│             │
│             │                    │             │
│             │─── Task Request ──→│             │
│  发起任务    │                    │  自主执行     │
│             │←── Task Result ────│             │
└─────────────┘                    └─────────────┘

3.3 统一治理 #

四、核心技术实现 #

4.1 端侧 Agent 运行时 #

// 端侧 Agent 轻量编排（Go 伪代码）
type DeviceAgent struct {
    intentClassifier  *LiteModel    // 轻量意图分类模型
    capabilityRegistry map[string]Capability  // 端侧能力注册表
    cloudRouter       *CloudRouter  // 云端路由器
    localMemory       *LocalMemory  // 本地 Memory
}

func (a *DeviceAgent) HandleRequest(req Request) Response {
    // 1. 意图分类
    intent := a.intentClassifier.Predict(req.Input)
    
    // 2. 能力匹配
    cap := a.capabilityRegistry.Match(intent)
    
    // 3. 调度决策
    switch {
    case cap != nil && cap.IsAvailableOnDevice():
        return cap.ExecuteOnDevice(req)
    case a.shouldOffloadToCloud(req, intent):
        return a.cloudRouter.Offload(req, intent)
    default:
        return a.offlineFallback(req)
    }
}

4.2 云端 Agent 编排引擎 #

// 云端 Agent 编排（Go 伪代码）
type AgentOrchestrator struct {
    planner       *TaskPlanner      // 任务规划器
    toolSelector *ToolSelector     // 工具选择器
    memory       *MemoryManager    // 全局 Memory
    ragEngine    *RAGEngine        // RAG 引擎
    guardrails   *GuardrailEngine  // 安全拦截
}

func (o *AgentOrchestrator) Execute(userInput string, sessionID string) Response {
    // 1. 安全拦截
    if !o.guardrails.Check(userInput) {
        return RejectResponse
    }
    
    // 2. 检索增强
    context := o.ragEngine.Retrieve(userInput, sessionID)
    
    // 3. 记忆注入
    memory := o.memory.Get(sessionID)
    
    // 4. 任务规划（LLM 驱动的 Planning）
    plan := o.planner.Plan(userInput, context, memory)
    
    // 5. 工具选择与执行
    for _, step := range plan.Steps {
        tool := o.toolSelector.Select(step)
        result := tool.Execute(step)
        plan.Update(step, result)
    }
    
    // 6. 记忆更新
    o.memory.Update(sessionID, plan)
    
    return plan.Finalize()
}

4.3 端云协同通信协议 #

// 端云通信 Protobuf 定义
message AgentRequest {
  string session_id = 1;
  string user_input = 2;
  InputModality modality = 3;       // TEXT / AUDIO / IMAGE / VIDEO
  bytes payload = 4;                 // 实际输入数据
  DeviceInfo device_info = 5;        // 设备能力信息
  NetworkStatus network = 6;         // 网络状态
  repeated string device_capabilities = 7;  // 端侧可用能力列表
  PriorityLevel priority = 8;        // 优先级
}

message AgentResponse {
  string session_id = 1;
  ResponseModality modality = 2;
  bytes payload = 3;
  ResponseSource source = 4;         // DEVICE / CLOUD / HYBRID
  bool is_cached = 5;
  LatencyMetrics latency = 6;
}

五、性能与稳定性保障 #

5.1 关键性能指标 #

5.2 高可用架构 #

                          ┌─────────────┐
                          │  全球流量调度 │
                          │  (GFE/Anycast)│
                          └──────┬──────┘
                                 │
              ┌──────────────────┼──────────────────┐
              ▼                  ▼                  ▼
        ┌──────────┐      ┌──────────┐      ┌──────────┐
        │ 区域 A    │      │ 区域 B    │      │ 区域 C    │
        │ (非洲)    │      │ (东南亚)  │      │ (拉美)    │
        │          │      │          │      │          │
        ├──────────┤      ├──────────┤      ├──────────┤
        │ 多实例    │      │ 多实例    │      │ 多实例    │
        │ 负载均衡  │      │ 负载均衡  │      │ 负载均衡  │
        │ 数据本地  │      │ 数据本地  │      │ 数据本地  │
        └──────────┘      └──────────┘      └──────────┘

六、云端 API 与第三方 API 不可用/不稳定的应对方案 #

6.1 核心原则：多级降级，逐级兜底 #

Level 0 ── 主云 API（正常态）
   │  异常
   ▼
Level 1 ── 备用云 API（同厂商不同 region / 同能力不同 model）
   │  异常
   ▼
Level 2 ── 端侧轻量模型 / 本地缓存
   │  异常
   ▼
Level 3 ── 优雅降级（友好提示 + 异步队列 + 稍后推送）

设计原则：

• 每一级都明确触发条件和降级路径
• 降级对用户尽可能透明，最差体验也是"友好的失败提示"
• 自动恢复：上游恢复后自动切回，无需人工介入

6.2 云端 API 不可用应对 #

6.2.1 多模型/多厂商冗余 #

// 云端 API 多供应商路由（Go 伪代码）
type CloudAPIRouter struct {
    primary   APIClient
    secondary APIClient
    fallback  APIClient
    circuit   *CircuitBreaker
}

func (r *CloudAPIRouter) Call(req APIRequest) APIResponse {
    // 1. 优先主供应商
    if r.circuit.PrimaryOK() {
        resp, err := r.primary.Call(req)
        if err == nil {
            return resp
        }
        r.circuit.RecordFailure("primary")
    }
    
    // 2. 切备用供应商
    if r.circuit.SecondaryOK() {
        resp, err := r.secondary.Call(req)
        if err == nil {
            return resp
        }
        r.circuit.RecordFailure("secondary")
    }
    
    // 3. 降级到端侧 / 本地缓存
    return r.fallback.Call(req)
}

6.2.2 区域级容灾 #

正常态：                          区域故障态：

  ┌──────────┐                     ┌──────────┐  ✗ 不可用
  │ 非洲节点  │── 服务非洲用户 ───→ │ 非洲节点  │
  └──────────┘                     └──────────┘
  ┌──────────┐                     ┌──────────┐
  │ 东南亚节点│── 服务东南亚用户 ──→│ 东南亚节点│── 接管非洲流量
  └──────────┘                     └──────────┘
  ┌──────────┐                     ┌──────────┐
  │ 拉美节点  │── 服务拉美用户 ───→ │ 拉美节点  │
  └──────────┘                     └──────────┘

• GSLB（全局负载均衡）：DNS 级 + Anycast 自动切换
• 数据同步：跨区域异步复制，RPO < 5 分钟
• 切换策略：健康检查失败 3 次 → 流量切到最近健康区域

6.2.3 云端完全不可用（极端场景） #

6.3 第三方 API 不可用应对 #

6.3.1 多供应商策略 #

针对关键第三方能力，至少接入 2 家供应商：

6.3.2 结果缓存 + 异步队列 #

请求流程：

用户请求 ──→ 检查缓存 ──→ 命中？ ──YES──→ 返回缓存结果（标记 "可能非最新"）
                    │
                    NO
                    │
                    ▼
              调用第三方 API ──→ 成功？ ──YES──→ 缓存结果 + 返回
                                    │
                                    NO
                                    │
                                    ▼
                              加入异步队列
                                    │
                                    ▼
                              返回 "处理中，稍后推送"
                              （后台重试，最多 3 次，指数退避）

• 热缓存：Redis 缓存高频查询结果（天气、汇率等），TTL 5-30 分钟
• 持久缓存：用户历史请求结果持久化，第三方不可用时返回最近一次结果
• 异步队列：非实时需求的请求进入队列，后台自动重试

6.3.3 功能降级矩阵 #

6.4 熔断 · 重试 · 限流机制 #

6.4.1 熔断器设计 #

状态机：

  ┌──────────┐   连续失败 ≥ N    ┌──────────┐   冷却时间到期    ┌──────────┐
  │  CLOSED  │ ────────────────→ │  OPEN    │ ────────────────→ │ HALF_OPEN│
  │ (正常)   │                   │ (熔断)   │                   │ (试探)   │
  └──────────┘                   └──────────┘                   └────┬─────┘
       ▲                                                             │
       │                     ┌──────────┐                            │
       │                     │  CLOSED  │ ←── 试探成功 ──────────────┘
       │                     │ (恢复)   │
       │                     └──────────┘
       │                     ┌──────────┐
       └──────────────────── │  OPEN    │ ←── 试探失败
                             │ (继续熔断)│
                             └──────────┘

6.4.2 重试策略 #

// 指数退避 + 抖动（Go 伪代码）
func RetryWithBackoff(fn func() error, maxRetries int) error {
    for i := 0; i <= maxRetries; i++ {
        err := fn()
        if err == nil {
            return nil
        }
        if !isRetryable(err) {
            return err  // 非可重试错误，直接返回
        }
        // 指数退避: 1s → 2s → 4s → 8s + 随机抖动
        backoff := (1 << i) * time.Second
        jitter := time.Duration(rand.Int63n(int64(backoff / 2)))
        time.Sleep(backoff + jitter)
    }
    return ErrMaxRetriesExceeded
}

• 可重试错误：超时、5xx、连接拒绝、限流（429）
• 不可重试：4xx（参数错误）、认证失败、业务拒绝
• 最大重试：3 次，总超时不超过用户可接受延迟

6.4.3 限流与优先级 #

6.5 监控与告警 #

监控维度：
┌───────────────────────────────────────────────────────┐
│  实时监控                                             │
│  ├─ API 错误率（按供应商 / 按能力 / 按区域）            │
│  ├─ P50/P95/P99 延迟                                  │
│  ├─ 熔断器状态（OPEN/CLOSED/HALF_OPEN）               │
│  ├─ 降级次数与类型                                     │
│  ├─ 缓存命中率                                         │
│  └─ 队列积压量                                         │
├───────────────────────────────────────────────────────┤
│  告警规则                                             │
│  ├─ 单 API 错误率 > 5% 持续 1 分钟 → P2 告警           │
│  ├─ 单 API 错误率 > 20% 持续 1 分钟 → P1 告警          │
│  ├─ 熔断器进入 OPEN 状态 → P2 告警                     │
│  ├─ 多 API 同时异常 → P0 告警（可能区域故障）           │
│  └─ 降级率 > 30% → P1 告警                             │
├───────────────────────────────────────────────────────┤
│  自动恢复                                             │
│  ├─ API 恢复后自动切回主供应商                          │
│  ├─ 熔断器 HALF_OPEN 试探成功 → 自动关闭               │
│  └─ 队列中积压请求自动重放                             │
└───────────────────────────────────────────────────────┘

6.6 降级决策流程图 #

用户请求
    │
    ▼
┌─────────────────────┐
│ 端侧能否处理？       │
└─────────┬───────────┘
     YES  │  NO
     │    ▼
     │  ┌─────────────────────┐
     │  │ 云端主 API 可用？    │
     │  └─────────┬───────────┘
     │       YES  │  NO
     │       │    ▼
     │       │  ┌─────────────────────┐
     │       │  │ 云端备用 API 可用？  │
     │       │  └─────────┬───────────┘
     │       │       YES  │  NO
     │       │       │    ▼
     │       │       │  ┌─────────────────────┐
     │       │       │  │ 缓存中有结果？       │
     │       │       │  └─────────┬───────────┘
     │       │       │       YES  │  NO
     │       │       │       │    ▼
     │       │       │       │  ┌─────────────────────┐
     │       │       │       │  │ 加入异步队列         │
     │       │       │       │  │ + 返回"处理中"      │
     │       │       │       │  └─────────────────────┘
     │       │       │       ▼
     │       │       │   返回缓存（标记"非最新"）
     │       ▼       ▼
     │    路由到备用供应商
     ▼
  端侧处理（离线/降级模型）

七、落地路线 #

七、总结 #

端·云·第三方 API 分层设计的核心价值：

1. 端侧 — 快（< 50ms）、省（离线可用）、安全（隐私数据不出端）
2. 云端 — 强（大模型推理）、全（多步任务编排）、智（全局记忆 + RAG）
3. 第三方 — 活（MCP/A2A 标准接入）、丰（生态能力补充）、稳（统一治理）

这三层不是替代关系，而是互补关系 — 端侧覆盖高频低复杂度场景，云端覆盖低频高复杂度场景，第三方覆盖垂类专业场景。最终统一通过 Agent 编排引擎，给 Ella 用户一个一致的智能体验。