1. 项目概述：从Express.js到Agent Express的范式跃迁

如果你和我一样，是从Web开发领域一路摸爬滚打过来的，那么对Express.js这个名字一定不会陌生。它几乎是Node.js生态里构建API和Web应用的代名词，其核心哲学—— 中间件（Middleware） ——更是深入人心。一个请求进来，经过一系列中间件的处理，最终返回响应，这种“管道式”的处理流程清晰、灵活，也成就了Express的辉煌。

但最近，我在尝试将AI Agent（智能体）集成到实际业务流中时，遇到了一个有趣的困境。我们习惯于为Agent设计复杂的框架、状态机和编排逻辑，试图用一套全新的、沉重的架构去承载“智能”。这让我不禁回想起Express的优雅： 为什么我们不能用处理HTTP请求的思维，来处理AI Agent的“思考”与“行动”呢？

这就是“Agent Express”概念的由来。它不是一个具体的开源库（至少目前还不是），而是一种架构思想和设计模式。其核心主张是： 构建智能体驱动的应用，你真正需要的可能只是一套精心设计的中间件体系。 我们无需抛弃在Web开发中积累的宝贵经验，相反，我们可以将其升华，用来编排AI的能力。本文将深入探讨为何中间件模式是构建Agentic AI（智能体化AI）应用的“银弹”，并拆解如何将Express.js的中间件思想，应用于AI智能体的工作流设计、工具调用、记忆管理和错误处理中。

2. 核心思路拆解：为什么是中间件？

2.1 重新审视Express.js中间件的本质

在深入Agent领域之前，我们有必要重温一下Express中间件究竟解决了什么问题。一个典型的Express中间件函数签名是 (req, res, next) => {} 。它接收请求对象（req）、响应对象（res）和一个关键的回调函数（next）。其工作流可以抽象为：

1. 拦截与检查 ：中间件可以查看或修改 req 对象（例如，解析JSON body、验证JWT令牌）。
2. 执行逻辑 ：完成其特定的任务（例如，记录日志、查询数据库）。
3. 决策与传递 ：决定是结束响应（调用 res.send() ）还是将控制权交给下一个中间件（调用 next() ）。

这种模式的威力在于它的 可组合性 和 责任链 。你可以将认证、授权、日志、数据转换等关注点分离成独立的中间件，然后像搭积木一样按需组合它们。每个中间件只关心一件事，并通过 req 和 res 这两个共享的上下文对象进行协作。

2.2 Agentic AI的核心挑战与中间件的天然契合

现在，让我们看看一个典型的AI智能体工作流面临哪些挑战：

• 流程编排 ：用户输入 -> 意图理解 -> 工具调用 -> 处理结果 -> 生成回复。这是一个清晰的、阶段化的管道。
• 上下文管理 ：需要在不同步骤间传递和更新对话历史、工具执行结果、临时变量等状态。
• 工具集成 ：智能体需要能调用各种外部功能（API、数据库、计算）。
• 错误与边界处理 ：工具调用失败、模型生成不合规内容、流程超时等都需要妥善处理。
• 可观测性 ：我们需要记录和追踪智能体的“思考”过程，用于调试和优化。

是不是感觉似曾相识？ 这几乎就是一个高度定制化的“请求-响应”流程。 用户的查询或指令就是 req ，智能体的最终回复就是 res ，而中间那些步骤（意图识别、工具执行、结果格式化）就是一个个 中间件 。共享的上下文对象（类比 req ）可以承载对话历史、工具参数、中间结果等所有状态。

因此，中间件模式为Agentic AI提供了以下无可替代的优势：

• 架构一致性 ：开发团队无需学习一套全新的、复杂的框架，可以沿用成熟的中间件心智模型。
• 极致模块化 ：每个能力（如“调用搜索API”、“总结网页内容”、“检查安全策略”）都可以封装成一个独立的中间件，易于开发、测试和复用。
• 灵活编排 ：通过调整中间件的顺序，你可以轻松创建不同的智能体“人格”或工作流。例如，一个客服Agent可能先经过“敏感词过滤”中间件，再进入“问题分类”中间件；而一个数据分析Agent可能直接进入“SQL生成与执行”中间件。
• 强大的可扩展性 ：在任何环节插入新的中间件（如日志、监控、缓存）都轻而易举，符合开闭原则。

3. 构建Agent Express：核心中间件设计

理解了“为什么”之后，我们来具体设计“怎么做”。我们将定义一个Agent的上下文（ AgentContext ）对象，并设计一系列核心中间件。

3.1 定义核心上下文（AgentContext）

这是贯穿整个智能体生命周期的共享状态对象，相当于Express中的 req 和 res 的合体。

class AgentContext {
  constructor(userInput) {
    // 初始输入
    this.originalInput = userInput;
    // 处理过程中的消息链（对话历史）
    this.messageChain = [{ role: 'user', content: userInput }];
    // 可供LLM使用的工具列表
    this.availableTools = [];
    // 当前步骤的中间结果（如解析出的意图、工具调用参数）
    this.intermediateResults = {};
    // 最终要返回给用户的结果
    this.finalResponse = null;
    // 错误信息
    this.error = null;
    // 元数据，如开始时间、调用次数等
    this.metadata = { startTime: Date.now() };
  }

  // 添加消息到链中
  addMessage(role, content) {
    this.messageChain.push({ role, content });
  }

  // 设置最终响应并结束流程
  setFinalResponse(response) {
    this.finalResponse = response;
  }
}

3.2 基础中间件骨架

一个Agent中间件的骨架与Express中间件高度相似：

/**
 * Agent中间件标准格式
 * @param {AgentContext} context - 智能体上下文
 * @param {Function} next - 调用下一个中间件
 */
async function agentMiddleware(context, next) {
  // 1. 前置处理：可以修改context，或决定是否跳过后续中间件
  // 例如：检查context.error，如果有错误则直接返回，不执行next

  // 2. 执行核心逻辑
  // await doSomething(context);

  // 3. 调用next，将控制权移交，除非你想终止链条
  await next();

  // 4. 后置处理：next()之后的代码会在后续中间件执行完毕后运行
  // 例如：统一记录日志、清理资源
}

3.3 关键中间件实现示例

3.3.1 意图解析与路由中间件

这个中间件扮演着“路由器”的角色，它分析用户输入，决定智能体该走哪条处理管道。

async function intentRouterMiddleware(context, next) {
  // 避免重复解析或已有错误
  if (context.intermediateResults.intent || context.error) {
    return await next();
  }

  const userInput = context.originalInput.toLowerCase();

  // 基于规则或简单分类的意图识别（生产环境可用更复杂的NLU模型）
  if (userInput.includes('天气') || userInput.includes('weather')) {
    context.intermediateResults.intent = 'query_weather';
    context.intermediateResults.entities = { location: extractLocation(userInput) }; // 假设的实体抽取函数
  } else if (userInput.includes('计算') || userInput.includes('+') || userInput.includes('-')) {
    context.intermediateResults.intent = 'calculate';
  } else {
    // 默认视为通用对话
    context.intermediateResults.intent = 'general_chat';
  }

  // 将意图信息加入消息链，供后续LLM参考
  context.addMessage('system', `用户意图已被识别为：${context.intermediateResults.intent}`);

  await next();
}

实操心得 ：在初期，基于关键词或规则的意图路由足够简单有效。当意图复杂时，可以将其升级为一个调用小型分类LLM的中间件。关键是 将路由逻辑独立出来 ，使其易于迭代和优化，而不会污染核心业务中间件。

3.3.2 工具调用中间件

这是智能体“行动”的关键。它根据上下文决定是否需要以及如何调用外部工具。

async function toolExecutorMiddleware(context, next) {
  // 检查是否已有工具调用决策（可能由上游的LLM中间件生成）
  const toolDecision = context.intermediateResults.toolCall;
  if (!toolDecision) {
    return await next(); // 不需要调用工具，直接聊天
  }

  try {
    const { toolName, parameters } = toolDecision;
    const tool = context.availableTools.find(t => t.name === toolName);

    if (!tool) {
      throw new Error(`工具 ${toolName} 不可用`);
    }

    // 执行工具
    const toolResult = await tool.execute(parameters);
    context.intermediateResults.toolResult = toolResult;

    // 将工具执行结果以系统消息形式加入对话历史，供LLM合成最终回复
    context.addMessage('system', `【工具 ${toolName} 调用结果】: ${JSON.stringify(toolResult)}`);

  } catch (error) {
    // 工具调用失败，记录错误，错误处理中间件会捕获它
    context.error = new Error(`工具执行失败: ${error.message}`);
  }

  await next();
}

3.3.3 LLM核心驱动中间件

这个中间件负责与大型语言模型交互，它是智能体的“大脑”。它读取当前消息链和上下文，决定下一步是直接回复、调用工具还是结束对话。

async function llmDriverMiddleware(context, next) {
  // 如果已有最终响应或错误，跳过LLM调用
  if (context.finalResponse || context.error) {
    return await next();
  }

  const messages = context.messageChain;
  const availableTools = context.availableTools;

  try {
    // 调用LLM API（这里以OpenAI格式为例）
    const response = await openai.chat.completions.create({
      model: 'gpt-4',
      messages: messages,
      tools: availableTools.map(tool => tool.schema), // 传入工具的模式定义
      tool_choice: 'auto', // 让模型决定是否调用工具
    });

    const message = response.choices[0].message;

    // 将LLM的回复加入消息链
    context.addMessage(message.role, message.content || '');

    // 处理工具调用
    if (message.tool_calls && message.tool_calls.length > 0) {
      // 记录工具调用决策，等待下一个循环或专门的工具执行中间件处理
      context.intermediateResults.toolCall = {
        toolName: message.tool_calls[0].function.name,
        parameters: JSON.parse(message.tool_calls[0].function.arguments)
      };
      // 注意：这里我们选择不立即调用next()，而是让中间件链条重新开始或进入工具执行子流程。
      // 一种常见模式是使用“子管道”或“循环”来处理工具调用迭代。
      // 为简化，我们假设流程设计会重新处理带有toolCall的上下文。
      return; // 暂停当前主链条，进入工具执行分支
    }

    // 如果是普通回复，且内容完整，可设为最终响应
    if (message.content && isCompleteResponse(message.content)) {
      context.setFinalResponse(message.content);
    }

  } catch (error) {
    context.error = new Error(`LLM调用失败: ${error.message}`);
  }

  await next();
}

注意事项 ：LLM中间件是异步且耗时的核心。 必须实施严格的超时控制和重试逻辑 ，避免单个请求阻塞整个系统。同时，对模型的输入（messages）进行精心裁剪和总结，以防止超出token限制，这部分逻辑可以放在另一个独立的“上下文窗口管理”中间件中。

3.3.4 错误处理与降级中间件

这是一个 后置中间件 （在 next() 之后执行逻辑），用于捕获和处理整个链条中发生的任何错误。

async function errorHandlerMiddleware(context, next) {
  try {
    await next(); // 先执行后续所有中间件
  } catch (err) {
    context.error = err; // 确保错误被记录
  }

  // next()执行后，检查context.error
  if (context.error) {
    console.error(`Agent流程错误:`, context.error);
    // 降级策略：使用更稳定的模型生成友好错误提示
    context.finalResponse = `抱歉，在处理您的请求时遇到了点问题：${context.error.message}。您可以尝试重新提问。`;
    // 或者，可以根据错误类型设置不同的降级回复
  }
}

4. 工作流编排与中间件链执行引擎

有了独立的中间件，我们需要一个“引擎”来按需组合和执行它们，这就是我们的 AgentExpress 核心。

4.1 中间件注册与管道构建

class AgentExpress {
  constructor() {
    this.middlewareStack = [];
  }

  // 注册中间件，支持传入多个
  use(...middlewares) {
    this.middlewareStack.push(...middlewares);
  }

  // 为特定意图注册专用管道
  useForIntent(intent, ...middlewares) {
    // 实现逻辑：当context.intent匹配时，动态插入这些中间件
    // 这里简化表示
    this.intentSpecificMap.set(intent, middlewares);
  }

  // 核心执行方法
  async run(context) {
    const stack = this.middlewareStack;
    // 可能根据context.intent动态插入中间件
    const finalStack = this._composeStack(context, stack);

    // 执行组合后的中间件函数
    await this._executeMiddleware(finalStack, context);
  }

  // 经典的中间件组合函数（类似koa-compose）
  _composeStack(context, middlewareList) {
    return async () => {
      let index = -1;
      const dispatch = async (i) => {
        if (i <= index) {
          throw new Error('next() called multiple times');
        }
        index = i;
        const fn = middlewareList[i];
        if (!fn) return;
        // 关键：将“下一个中间件”作为next参数传入
        return await fn(context, dispatch.bind(null, i + 1));
      };
      return dispatch(0);
    };
  }

  async _executeMiddleware(composedFn, context) {
    await composedFn();
  }
}

4.2 典型智能体管道配置示例

下面我们配置一个具备完整功能的智能体：

const agent = new AgentExpress();

// 全局前置中间件：日志、输入清洗、速率限制
agent.use(loggingMiddleware);
agent.use(inputSanitizationMiddleware);
agent.use(rateLimitMiddleware);

// 核心决策管道
agent.use(intentRouterMiddleware); // 1. 识别意图
agent.use(contextWindowManagerMiddleware); // 2. 管理对话历史长度
agent.use(llmDriverMiddleware); // 3. LLM驱动决策
agent.use(toolExecutorMiddleware); // 4. 执行工具（如果被调用）

// 全局后置中间件：错误处理、响应格式化、最终日志
agent.use(errorHandlerMiddleware);
agent.use(responseFormatMiddleware);
agent.use(finalLoggingMiddleware);

// 运行智能体
const context = new AgentContext(“北京今天天气怎么样？”);
await agent.run(context);
console.log(context.finalResponse);

4.3 高级编排：条件管道与循环执行

真正的智能体往往需要循环（多轮工具调用）和条件分支。这可以通过在中间件内控制 next() 的调用和修改中间件栈来实现。

示例：实现循环直到满足条件

async function loopUntilConditionMiddleware(context, next) {
  const maxIterations = 5;
  let iteration = 0;

  while (iteration < maxIterations && !context.finalResponse && !context.error) {
    iteration++;
    context.metadata.iteration = iteration;

    // 关键：在循环内，我们创建一个子管道并执行
    const subStack = [llmDriverMiddleware, toolExecutorMiddleware, checkCompletionMiddleware];
    const composed = this._composeStack(context, subStack);
    await composed();

    // checkCompletionMiddleware 会设置 context.finalResponse 或 context.continueLoop
    if (context.intermediateResults.shouldBreakLoop) {
      break;
    }
  }

  // 循环结束后，继续主链条后面的中间件（如错误处理）
  await next();
}

5. 实战：构建一个多功能查询智能体

让我们用一个更复杂的例子来巩固概念：构建一个能处理天气、计算、百科查询的智能体。

5.1 定义工具

// 工具定义
const availableTools = [
  {
    name: 'get_weather',
    description: '获取指定城市的当前天气',
    schema: { /* OpenAI工具调用格式的JSON Schema */ },
    async execute(params) {
      // 模拟调用天气API
      return `北京：晴，15-25°C，东南风2级`;
    }
  },
  {
    name: 'calculator',
    description: '执行数学计算',
    schema: { /* ... */ },
    async execute(params) {
      // 注意：安全起见，应使用安全的数学表达式求值库，如math.js
      return eval(params.expression); // 仅为示例，生产环境禁用eval
    }
  },
  {
    name: 'search_web',
    description: '联网搜索最新信息',
    schema: { /* ... */ },
    async execute(params) {
      // 调用搜索API
      return `关于“${params.query}”的搜索结果摘要...`;
    }
  }
];

5.2 组装智能体管道

const queryAgent = new AgentExpress();

// 1. 通用预处理
queryAgent.use(async (ctx, next) => {
  ctx.availableTools = availableTools; // 注入工具
  ctx.metadata.agentType = 'multi-query';
  await next();
});

// 2. 意图识别与增强
queryAgent.use(intentRouterMiddleware);
queryAgent.use(async (ctx, next) => {
  // 基于意图，为LLM提供更具体的系统提示
  if (ctx.intermediateResults.intent === 'query_weather') {
    ctx.addMessage('system', '你是一个天气助手，请根据工具返回的信息，用友好、简洁的语言告知用户天气情况。');
  } else if (ctx.intermediateResults.intent === 'calculate') {
    ctx.addMessage('system', '你是一个计算助手，确保计算准确，并以清晰的方式呈现结果。');
  }
  await next();
});

// 3. 核心LLM驱动与工具执行循环
queryAgent.use(loopUntilConditionMiddleware); // 此中间件内嵌了llmDriver和toolExecutor

// 4. 后处理与安全过滤
queryAgent.use(async (ctx, next) => {
  if (ctx.finalResponse) {
    // 内容安全过滤中间件
    if (containsSensitiveContent(ctx.finalResponse)) {
      ctx.finalResponse = '我的回复可能包含不合适内容，已进行过滤。';
    }
    // 统一格式化
    ctx.finalResponse = `【智能体回复】\n${ctx.finalResponse}`;
  }
  await next();
});

queryAgent.use(errorHandlerMiddleware);

// 运行测试
const testContexts = [
  new AgentContext(“上海明天适合穿什么衣服？”),
  new AgentContext(“计算一下(15 + 7) * 3 / 2的值”),
  new AgentContext(“特斯拉最新的车型有什么特点？”),
];

for (const ctx of testContexts) {
  await queryAgent.run(ctx);
  console.log(`Q: ${ctx.originalInput}`);
  console.log(`A: ${ctx.finalResponse}\n`);
}

6. 生产环境考量与最佳实践

将Agent Express模式用于生产，需要关注以下方面：

6.1 性能与可扩展性

• 中间件异步化 ：确保所有中间件都是异步函数，避免阻塞事件循环。
• 缓存层 ：为LLM调用、工具查询结果添加缓存中间件，显著减少延迟和成本。
• 连接池与限流 ：对数据库、外部API的访问通过中间件管理连接池和限流。
• 流式响应 ：对于生成时间较长的内容，可以实现支持流式传输的中间件，逐步返回 ctx.finalResponse 。

6.2 可观测性与调试

• 结构化日志中间件 ：在每个中间件前后记录详细的、结构化的日志（包括 context 快照、耗时），便于追踪整个决策链。
• 追踪ID ：为每个请求生成唯一的 traceId ，并贯穿所有中间件和工具调用，实现端到端追踪。
• 上下文快照存储 ：将重要的 AgentContext 状态持久化到数据库，便于事后分析和复现问题。

6.3 测试策略

• 中间件单元测试 ：每个中间件应独立可测，只需模拟 context 和 next 函数。
• 管道集成测试 ：测试整个中间件链对不同输入的处理结果。
• 模拟与桩 ：在测试中，用模拟工具（Mock Tools）和模拟LLM响应来替代真实外部依赖，保证测试的稳定性和速度。

6.4 常见陷阱与避坑指南

• 中间件顺序至关重要 ：例如，错误处理中间件通常应该放在最后（作为后置中间件），以确保能捕获所有错误。身份验证中间件则需要放在很前面。
• 避免修改 next 函数 ：永远不要直接调用或修改传入的 next 参数，这会导致执行流混乱。
• 管理好上下文状态 ：明确 context 对象中哪些属性是只读的，哪些是可写的，并做好文档。避免不同的中间件意外覆盖对方的中间结果。
• 处理异步错误 ：确保在异步操作中使用 try...catch ，并将错误妥善赋值给 context.error 或抛出，以便错误处理中间件能捕获。
• 循环与递归的终止条件 ：实现类似 loopUntilConditionMiddleware 的中间件时， 必须设置最大迭代次数 ，防止因LLM的异常输出导致无限循环。

从Express.js到Agent Express，本质上是一次设计模式的迁移和复用。中间件这种经过大规模实践验证的架构模式，为我们管理AI智能体的复杂性提供了清晰、灵活且强大的范式。它降低了智能体系统的开发门槛，提升了可维护性和可观测性。当你下次为如何设计一个稳健的Agent系统而烦恼时，不妨想想那句老话：“一切皆中间件”。从一个简单的 AgentContext 和几个基础中间件开始，你就能搭建出功能丰富的智能体管道，并随着业务增长，像搭积木一样不断扩展它的能力。这种架构上的统一与简洁，或许正是应对AI时代软件复杂性的关键之一。