AI Agent生产级开发实战：基于Hermes框架的工程化实践指南

最近在AI Agent开发领域，很多开发者反映虽然掌握了基础概念，但在实际项目中总是遇到环境配置复杂、组件集成困难、生产部署不稳定等问题。本文基于2026年最新的Harness Engineering实践，通过Hermes Agent实战案例，系统讲解AI Agent从原理到生产级落地的完整流程，帮助开发者避开99%的常见坑点。

无论你是刚接触AI Agent的新手，还是有一定基础想要深入工程化实践的开发者，都能从本文获得可直接复用的代码示例和配置方案。我们将从核心概念解析开始，逐步深入到环境搭建、技能开发、生产部署全流程，最后分享企业级最佳实践。

1. AI Agent与Harness Engineering核心概念

1.1 什么是AI Agent

AI Agent（人工智能代理）是指能够感知环境、自主决策并执行动作的智能系统。与传统的对话式AI不同，AI Agent具备以下核心特征：

• 自主性：能够在没有人工干预的情况下自主运行
• 反应性：能够感知环境变化并及时响应
• 主动性：能够主动设定目标并采取行动
• 社会能力：能够与其他Agent或人类进行交互

在实际开发中，一个典型的AI Agent通常包含以下组件：

• LLM（大语言模型）作为核心推理引擎
• 工具集（Tools）用于执行具体操作
• 记忆系统（Memory）用于存储对话历史和知识
• 规划器（Planner）用于拆解复杂任务

1.2 Harness Engineering工程化实践

Harness Engineering是一种新兴的AI工程化方法论，它超越了传统的Prompt Engineering和Context Engineering，专注于构建可维护、可扩展、可监控的AI应用系统。其核心思想包括：

• 系统化设计：将AI Agent视为完整的软件系统进行架构设计
• 模块化开发：通过标准化接口实现组件的解耦和复用
• 自动化测试：建立完整的测试流水线确保系统稳定性
• 生产就绪：从第一天就考虑部署、监控、运维需求

与传统的Prompt Engineering相比，Harness Engineering更注重工程实践和系统可靠性，而不仅仅是提示词优化。这种方法特别适合需要长期运行、高可靠性的生产环境AI应用。

1.3 Hermes Agent框架介绍

Hermes Agent是一个开源的AI Agent开发框架，它提供了完整的工具链和运行时环境，支持快速构建和部署生产级AI Agent。主要特性包括：

• 多模型支持：可配置不同的LLM后端（OpenAI、Anthropic、本地模型等）
• 技能市场：提供丰富的预置技能，支持自定义技能开发
• 记忆系统：支持短期记忆和长期记忆，可配置向量数据库
• 可视化界面：提供Web UI和桌面版，便于调试和监控
• 生产工具：集成日志、监控、性能分析等运维能力

2. 环境准备与工具安装

2.1 系统要求与前置条件

在开始Hermes Agent开发之前，需要确保系统满足以下要求：

• 操作系统：Windows 10/11、macOS 10.15+、Ubuntu 18.04+
• Node.js：版本18.0.0或更高（推荐LTS版本）
• Python：版本3.8或更高（某些技能需要Python环境）
• 内存：至少8GB RAM，推荐16GB以上
• 网络：稳定的互联网连接（用于模型调用）

首先检查系统环境：

# 检查Node.js版本 node --version # 检查Python版本 python --version # 检查包管理器 npm --version

2.2 Hermes Agent安装步骤

Hermes Agent支持多种安装方式，推荐使用npm进行全局安装：

# 使用npm安装Hermes Agent CLI npm install -g @hermes-agent/cli # 验证安装是否成功 hermes --version # 初始化Hermes Agent项目 hermes init my-first-agent cd my-first-agent

如果安装过程中遇到Node.js依赖问题，可以尝试以下解决方案：

# 清理npm缓存 npm cache clean --force # 使用yarn替代npm npm install -g yarn yarn global add @hermes-agent/cli # 或者使用cnpm（国内用户） npm install -g cnpm --registry=https://registry.npmmirror.com cnpm install -g @hermes-agent/cli

2.3 开发环境配置

创建完整的开发环境配置文件：

// hermes.config.js module.exports = { // 基础配置 name: "my-first-agent", version: "1.0.0", // LLM配置 llm: { provider: "openai", // 或 "anthropic", "local" model: "gpt-4", apiKey: process.env.OPENAI_API_KEY, temperature: 0.7 }, // 记忆配置 memory: { type: "vector", // "vector" 或 "redis" vectorDatabase: { provider: "pinecone", // 或 " elasticsearch", "local" apiKey: process.env.PINECONE_API_KEY, index: "hermes-memory" } }, // 技能配置 skills: { enabled: ["web-search", "calculator", "file-io"], customSkills: ["./skills/my-skill.js"] }, // 服务器配置 server: { port: 3000, host: "localhost" } };

设置环境变量：

# 创建.env文件 echo "OPENAI_API_KEY=your_openai_api_key_here" > .env echo "PINECONE_API_KEY=your_pinecone_api_key_here" >> .env # 加载环境变量 source .env

3. Hermes Agent核心架构深度解析

3.1 组件化架构设计

Hermes Agent采用模块化架构，每个组件都可以独立开发和测试：

Hermes Agent架构图： [用户输入] → [输入解析器] → [记忆系统] → [规划器] ↓ [技能执行器] → [工具集] → [LLM推理] → [输出生成器]

每个核心组件的职责如下：

• 输入解析器：处理多模态输入（文本、语音、图像）
• 记忆系统：管理对话历史、知识库、状态信息
• 规划器：将复杂任务分解为可执行的子任务
• 技能执行器：调用预定义技能或工具
• LLM推理引擎：提供智能决策能力
• 输出生成器：格式化响应内容

3.2 记忆系统工作原理

记忆系统是AI Agent的核心组件，负责维护Agent的状态和知识：

// memory/system.js - 记忆系统核心实现 class MemorySystem { constructor(config) { this.shortTermMemory = new ShortTermMemory(); this.longTermMemory = new LongTermMemory(config); this.workingMemory = new WorkingMemory(); } // 存储对话记录 async storeConversation(userInput, agentResponse, metadata) { const memoryItem = { id: generateId(), timestamp: Date.now(), userInput, agentResponse, metadata, embedding: await this.generateEmbedding(userInput + agentResponse) }; // 短期记忆（最近对话） this.shortTermMemory.add(memoryItem); // 长期记忆（重要信息） if (this.isImportant(memoryItem)) { await this.longTermMemory.store(memoryItem); } } // 检索相关记忆 async retrieveRelevantMemories(query, limit = 5) { const queryEmbedding = await this.generateEmbedding(query); // 从短期记忆检索 const shortTermResults = this.shortTermMemory.search(queryEmbedding, limit); // 从长期记忆检索 const longTermResults = await this.longTermMemory.search(queryEmbedding, Math.floor(limit / 2)); return [...shortTermResults, ...longTermResults] .sort((a, b) => b.similarity - a.similarity) .slice(0, limit); } // 生成嵌入向量 async generateEmbedding(text) { // 使用LLM或专用嵌入模型生成向量 const response = await fetch(`${this.config.embeddingApi}/embeddings`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ text }) }); return response.json().embedding; } }

3.3 技能开发框架

技能是AI Agent的能力单元，每个技能都有明确的输入输出规范：

// skills/web-search.js - 网页搜索技能实现 class WebSearchSkill { constructor() { this.name = "web-search"; this.description = "使用搜索引擎获取最新信息"; this.parameters = { query: { type: "string", description: "搜索关键词" }, maxResults: { type: "number", description: "最大结果数量", default: 5 } }; } // 技能执行方法 async execute(params, context) { const { query, maxResults = 5 } = params; try { // 调用搜索引擎API const searchResults = await this.performSearch(query, maxResults); // 提取和格式化结果 const formattedResults = searchResults.map((result, index) => ({ title: result.title, url: result.url, snippet: result.snippet, relevance: result.relevanceScore })); return { success: true, data: { query, results: formattedResults, summary: await this.generateSummary(formattedResults) } }; } catch (error) { return { success: false, error: `搜索失败: ${error.message}` }; } } // 实际搜索实现 async performSearch(query, maxResults) { const apiUrl = `https://api.searchprovider.com/search`; const response = await fetch(apiUrl, { method: 'POST', headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${process.env.SEARCH_API_KEY}` }, body: JSON.stringify({ q: query, limit: maxResults }) }); if (!response.ok) { throw new Error(`搜索API错误: ${response.statusText}`); } return response.json().results; } // 生成结果摘要 async generateSummary(results) { if (results.length === 0) { return "未找到相关结果"; } const snippets = results.map(r => r.snippet).join(' '); // 使用LLM生成简洁摘要 return await this.llm.generateSummary(snippets); } } // 注册技能 module.exports = WebSearchSkill;

4. 完整实战：构建生产级AI Agent

4.1 项目需求分析与设计

我们要构建一个"智能技术助手"Agent，具备以下能力：

• 回答技术问题（编程、框架、工具等）
• 搜索最新技术文档和资讯
• 执行代码分析和简单代码生成
• 管理个人技术学习笔记

项目结构设计：

tech-assistant/ ├── src/ │ ├── agents/ │ │ └── tech-assistant.js │ ├── skills/ │ │ ├── code-analyzer.js │ │ ├── tech-searcher.js │ │ └── note-manager.js │ ├── memory/ │ │ ├── short-term.js │ │ └── long-term.js │ └── utils/ ├── config/ │ ├── hermes.config.js │ └── skills.config.js ├── tests/ └── package.json

4.2 核心Agent实现

// src/agents/tech-assistant.js const { BaseAgent } = require('@hermes-agent/core'); const CodeAnalyzerSkill = require('../skills/code-analyzer'); const TechSearcherSkill = require('../skills/tech-searcher'); const NoteManagerSkill = require('../skills/note-manager'); class TechAssistantAgent extends BaseAgent { constructor(config) { super(config); // 初始化技能 this.skills = { codeAnalyzer: new CodeAnalyzerSkill(), techSearcher: new TechSearcherSkill(), noteManager: new NoteManagerSkill() }; // 设置技能路由 this.setupSkillRouting(); } setupSkillRouting() { // 基于意图的技能路由 this.router .addIntent('code_analysis', this.skills.codeAnalyzer) .addIntent('tech_search', this.skills.techSearcher) .addIntent('note_management', this.skills.noteManager) .setDefault(this.handleGeneralQuery.bind(this)); } // 处理一般技术查询 async handleGeneralQuery(input, context) { const { memory, llm } = this; // 检索相关记忆 const relevantMemories = await memory.retrieveRelevantMemories(input.query); // 构建提示词 const prompt = this.buildTechnicalPrompt(input.query, relevantMemories); // 调用LLM生成响应 const response = await llm.generate(prompt); // 存储到记忆 await memory.storeConversation(input.query, response, { type: 'technical_query', topic: this.extractTopics(input.query) }); return response; } buildTechnicalPrompt(query, relevantMemories) { return ` 你是一个专业的技术助手，请回答以下技术问题。 用户问题：${query} ${relevantMemories.length > 0 ? ` 相关上下文： ${relevantMemories.map(m => `- ${m.content}`).join('\n')} ` : ''} 请提供： 1. 准确的技术解释 2. 实用的代码示例（如适用） 3. 最佳实践建议 4. 相关资源推荐 回答要求： - 专业且易于理解 - 包含实际可运行的代码 - 注明技术适用范围和注意事项 `.trim(); } extractTopics(query) { // 简单的主题提取逻辑 const topics = []; const techKeywords = ['javascript', 'python', 'react', 'node', 'database', 'api']; techKeywords.forEach(keyword => { if (query.toLowerCase().includes(keyword)) { topics.push(keyword); } }); return topics.length > 0 ? topics : ['general']; } } module.exports = TechAssistantAgent;

4.3 自定义技能开发：代码分析器

// src/skills/code-analyzer.js const { BaseSkill } = require('@hermes-agent/core'); class CodeAnalyzerSkill extends BaseSkill { constructor() { super({ name: 'code-analyzer', description: '分析代码质量、识别问题、提供改进建议', parameters: { code: { type: 'string', required: true }, language: { type: 'string', required: true }, analysisType: { type: 'string', enum: ['quality', 'security', 'performance', 'all'], default: 'all' } } }); } async execute(params, context) { const { code, language, analysisType } = params; try { // 代码预处理和解析 const parsedCode = await this.parseCode(code, language); // 执行分析 const analyses = []; if (analysisType === 'quality' || analysisType === 'all') { analyses.push(await this.analyzeCodeQuality(parsedCode, language)); } if (analysisType === 'security' || analysisType === 'all') { analyses.push(await this.analyzeSecurity(parsedCode, language)); } if (analysisType === 'performance' || analysisType === 'all') { analyses.push(await this.analyzePerformance(parsedCode, language)); } // 生成综合报告 const report = await this.generateReport(analyses, code, language); return { success: true, data: { originalCode: code, language: language, analysisType: analysisType, report: report, suggestions: await this.generateSuggestions(report), confidence: this.calculateConfidence(parsedCode, analyses) } }; } catch (error) { return { success: false, error: `代码分析失败: ${error.message}`, suggestion: '请检查代码语法和语言设置是否正确' }; } } async parseCode(code, language) { // 使用相应的解析器解析代码 switch (language.toLowerCase()) { case 'javascript': return this.parseJavaScript(code); case 'python': return this.parsePython(code); case 'java': return this.parseJava(code); default: throw new Error(`不支持的语言: ${language}`); } } async parseJavaScript(code) { // 使用Babel或其他解析器进行AST分析 const parser = require('@babel/parser'); try { return parser.parse(code, { sourceType: 'module', plugins: ['jsx', 'typescript'] }); } catch (error) { throw new Error(`JavaScript解析错误: ${error.message}`); } } async analyzeCodeQuality(ast, language) { // 代码质量分析逻辑 const issues = []; // 检查代码复杂度 const complexity = this.calculateComplexity(ast); if (complexity > 10) { issues.push({ type: 'high_complexity', message: `代码复杂度较高: ${complexity}，建议重构`, severity: 'warning' }); } // 检查代码重复 const duplication = await this.checkDuplication(ast); if (duplication > 0.3) { issues.push({ type: 'code_duplication', message: `代码重复率: ${(duplication * 100).toFixed(1)}%`, severity: 'info' }); } return { type: 'quality', issues: issues, metrics: { complexity: complexity, duplication: duplication, maintainability: this.calculateMaintainability(ast) } }; } async generateReport(analyses, originalCode, language) { // 使用LLM生成人性化的分析报告 const analysisSummary = analyses.map(a => ({ type: a.type, issueCount: a.issues.length, mainIssues: a.issues.slice(0, 3).map(i => i.message) })); const prompt = ` 请基于以下代码分析结果生成技术报告： 代码语言：${language} 原始代码： \`\`\`${language} ${originalCode} \`\`\` 分析结果： ${JSON.stringify(analysisSummary, null, 2)} 请生成包含以下部分的报告： 1. 总体评价 2. 主要问题分析 3. 具体改进建议 4. 最佳实践推荐 要求：专业、具体、可操作 `.trim(); return await this.llm.generate(prompt); } } module.exports = CodeAnalyzerSkill;

4.4 配置与集成测试

创建完整的配置文件：

// config/hermes.config.js module.exports = { agent: { name: "tech-assistant", version: "1.0.0", description: "智能技术助手AI Agent" }, llm: { provider: "openai", model: "gpt-4", apiKey: process.env.OPENAI_API_KEY, temperature: 0.3, // 技术场景使用较低温度值 maxTokens: 2000 }, memory: { shortTerm: { type: "in-memory", maxEntries: 100 }, longTerm: { type: "vector", provider: "pinecone", index: "tech-assistant-memory", dimension: 1536 } }, skills: { enabled: ["code-analyzer", "tech-searcher", "note-manager"], configs: { "code-analyzer": { enabledLanguages: ["javascript", "python", "java", "typescript"], maxCodeLength: 5000 }, "tech-searcher": { searchProviders: ["google", "stackoverflow", "github"], maxResults: 10 } } }, server: { port: process.env.PORT || 3000, cors: { origin: ["http://localhost:3000", "https://yourdomain.com"] } }, monitoring: { enabled: true, provider: "langfuse", // 集成Langfuse进行评测和监控 langfuse: { secretKey: process.env.LANGFUSE_SECRET_KEY, publicKey: process.env.LANGFUSE_PUBLIC_KEY } } };

编写集成测试：

// tests/integration/tech-assistant.test.js const { describe, it, before, after } = require('mocha'); const { expect } = require('chai'); const TechAssistantAgent = require('../../src/agents/tech-assistant'); describe('TechAssistantAgent 集成测试', function() { this.timeout(10000); // 设置超时时间 let agent; before(async () => { // 初始化Agent实例 agent = new TechAssistantAgent(require('../../config/hermes.config.js')); await agent.initialize(); }); after(async () => { await agent.shutdown(); }); describe('代码分析功能', () => { it('应该能正确分析JavaScript代码', async () => { const testCode = ` function calculateSum(arr) { return arr.reduce((acc, curr) => acc + curr, 0); } `.trim(); const result = await agent.executeSkill('code-analyzer', { code: testCode, language: 'javascript', analysisType: 'quality' }); expect(result.success).to.be.true; expect(result.data).to.have.property('report'); expect(result.data.report).to.include('总体评价'); }); it('应该能处理语法错误的代码', async () => { const invalidCode = 'function test { return ;'; const result = await agent.executeSkill('code-analyzer', { code: invalidCode, language: 'javascript' }); expect(result.success).to.be.false; expect(result.error).to.include('语法错误'); }); }); describe('技术搜索功能', () => { it('应该能搜索技术文档', async () => { const result = await agent.executeSkill('tech-searcher', { query: 'React Hooks最佳实践', maxResults: 5 }); expect(result.success).to.be.true; expect(result.data.results).to.be.an('array'); expect(result.data.results.length).to.be.at.least(1); }); }); describe('对话记忆功能', () => { it('应该能记住之前的对话', async () => { const firstQuery = '什么是React Hooks？'; const secondQuery = '刚才说的Hooks有什么优点？'; // 第一次查询 await agent.handleQuery(firstQuery); // 第二次查询（应该能引用之前的对话） const response = await agent.handleQuery(secondQuery); expect(response).to.include('React Hooks'); expect(response).to.include('优点'); }); }); });

4.5 部署与运行验证

创建启动脚本：

// index.js - 应用入口文件 const TechAssistantAgent = require('./src/agents/tech-assistant'); const config = require('./config/hermes.config'); async function startAgent() { try { console.log('🚀 启动智能技术助手Agent...'); // 创建Agent实例 const agent = new TechAssistantAgent(config); // 初始化Agent await agent.initialize(); console.log('✅ Agent初始化完成'); // 启动HTTP服务器 const server = await agent.startServer(); console.log(`🌐 服务已启动: http://localhost:${config.server.port}`); // 优雅关闭处理 process.on('SIGINT', async () => { console.log('\n🛑 收到关闭信号，正在优雅退出...'); await agent.shutdown(); server.close(() => { console.log('✅ Agent已安全关闭'); process.exit(0); }); }); } catch (error) { console.error('❌ 启动失败:', error); process.exit(1); } } // 启动应用 startAgent();

运行和测试：

# 安装依赖 npm install # 运行测试 npm test # 启动开发服务器 npm run dev # 构建生产版本 npm run build # 启动生产服务器 npm start

5. 常见问题与解决方案

5.1 安装与环境配置问题

问题1：Node.js依赖安装失败

错误：安装卡在"installing node.js dependencies"

解决方案：

# 1. 清理缓存并重新安装 npm cache clean --force rm -rf node_modules package-lock.json npm install # 2. 使用国内镜像源 npm config set registry https://registry.npmmirror.com npm install # 3. 检查Node.js版本兼容性 node --version # 需要 >= 18.0.0 # 4. 使用yarn安装 npm install -g yarn yarn install

问题2：API密钥配置错误

错误：LLM API调用返回认证失败

解决方案：

# 检查环境变量设置 echo $OPENAI_API_KEY # 创建正确的.env文件 cat > .env << EOF OPENAI_API_KEY=sk-your-actual-key-here PINECONE_API_KEY=your-pinecone-key-here LANGFUSE_SECRET_KEY=your-langfuse-secret EOF # 重新加载环境变量 source .env

5.2 运行时性能问题

问题3：Agent响应速度慢

优化方案：

// config/optimization.js - 性能优化配置 module.exports = { // 启用响应缓存 caching: { enabled: true, ttl: 300, // 5分钟缓存 maxSize: 1000 }, // LLM调用优化 llm: { timeout: 30000, // 30秒超时 retry: { attempts: 2, delay: 1000 }, // 使用流式响应改善用户体验 stream: true }, // 记忆系统优化 memory: { // 限制检索数量提高速度 maxRetrieval: 5, // 启用记忆压缩 compression: { enabled: true, threshold: 1000 // 超过1000字符进行压缩 } } };

问题4：内存使用过高

监控和优化方案：

// utils/memory-monitor.js - 内存监控 class MemoryMonitor { constructor(threshold = 500) { // MB阈值 this.threshold = threshold; this.setupMonitoring(); } setupMonitoring() { setInterval(() => { const usage = process.memoryUsage(); const usedMB = Math.round(usage.heapUsed / 1024 / 1024); if (usedMB > this.threshold) { console.warn(`⚠️ 内存使用过高: ${usedMB}MB`); this.triggerCleanup(); } }, 30000); // 每30秒检查一次 } triggerCleanup() { // 清理短期记忆 if (global.agent && global.agent.memory) { global.agent.memory.cleanup(); } // 强制垃圾回收（Node.js特定） if (global.gc) { global.gc(); } } } module.exports = MemoryMonitor;

5.3 技能开发常见错误

问题5：技能执行超时

解决方案：

// skills/base-skill.js - 添加超时控制 class BaseSkill { async executeWithTimeout(params, context, timeout = 30000) { return new Promise((resolve, reject) => { const timeoutId = setTimeout(() => { reject(new Error(`技能执行超时: ${timeout}ms`)); }, timeout); this.execute(params, context) .then(result => { clearTimeout(timeoutId); resolve(result); }) .catch(error => { clearTimeout(timeoutId); reject(error); }); }); } }

问题6：技能参数验证失败

改进方案：

// utils/param-validator.js - 参数验证工具 class ParamValidator { static validate(skillParams, userParams) { const errors = []; for (const [key, definition] of Object.entries(skillParams)) { const value = userParams[key]; // 检查必填参数 if (definition.required && (value === undefined || value === null)) { errors.push(`缺少必填参数: ${key}`); continue; } // 检查类型 if (value !== undefined && !this.checkType(value, definition.type)) { errors.push(`参数 ${key} 类型错误，期望 ${definition.type}`); } // 检查枚举值 if (definition.enum && !definition.enum.includes(value)) { errors.push(`参数 ${key} 值无效，可选值: ${definition.enum.join(', ')}`); } } if (errors.length > 0) { throw new Error(`参数验证失败:\n${errors.join('\n')}`); } return true; } static checkType(value, expectedType) { const actualType = Array.isArray(value) ? 'array' : typeof value; return actualType === expectedType; } }

6. 生产环境最佳实践

6.1 安全配置指南

API密钥安全管理：

// config/security.js - 安全配置 module.exports = { // 密钥管理 secrets: { // 使用环境变量或密钥管理服务 storage: process.env.SECRETS_STORAGE || 'env', // 'env', 'aws-secrets', 'vault' rotation: { enabled: true, interval: 30 // 天 } }, // API访问控制 accessControl: { enabled: true, allowedOrigins: process.env.ALLOWED_ORIGINS ? process.env.ALLOWED_ORIGINS.split(',') : ['http://localhost:3000'], rateLimiting: { enabled: true, windowMs: 15 * 60 * 1000, // 15分钟 max: 100 // 每窗口最大请求数 } }, // 输入验证 inputValidation: { maxLength: { query: 1000, code: 10000 }, sanitization: { enabled: true, rules: [ 'stripScriptTags', 'escapeSpecialChars', 'validateUrls' ] } } };

安全中间件实现：

// middleware/security.js - 安全中间件 const rateLimit = require('express-rate-limit'); const securityMiddleware = { // 速率限制 rateLimiter: rateLimit({ windowMs: 15 * 60 * 1000, max: 100, message: '请求过于频繁，请稍后重试', standardHeaders: true, legacyHeaders: false }), // CORS配置 corsOptions: { origin: function (origin, callback) { const allowedOrigins = process.env.ALLOWED_ORIGINS ? process.env.ALLOWED_ORIGINS.split(',') : ['http://localhost:3000']; if (!origin || allowedOrigins.indexOf(origin) !== -1) { callback(null, true); } else { callback(new Error('CORS策略禁止此来源')); } }, credentials: true }, // 输入清理 sanitizeInput: (req, res, next) => { if (req.body && req.body.query) { // 移除潜在的恶意内容 req.body.query = req.body.query .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '') .replace(/javascript:/gi, '') .trim(); } next(); } }; module.exports = securityMiddleware;

6.2 监控与日志记录

完整的监控配置：

// config/monitoring.js - 监控配置 module.exports = { // 应用指标监控 metrics: { enabled: true, provider: 'prometheus', // 或 'datadog', 'newrelic' collectionInterval: 30000 // 30秒收集一次 }, // 业务日志 logging: { level: process.env.LOG_LEVEL || 'info', format: 'json', // 生产环境使用JSON格式 transports: [ { type: 'file', filename: 'logs/app.log', maxsize: 10485760, // 10MB maxFiles: 5 }, { type: 'console' // 开发环境保留控制台输出 } ] }, // 性能追踪 tracing: { enabled: true, provider: 'jaeger', // 或 'zipkin' samplingRate: 0.1 // 10%的请求采样 }, // 健康检查 healthCheck: { path: '/health', interval: 30000 } };

日志记录最佳实践：

// utils/logger.js - 结构化日志记录 const winston = require('winston'); class AgentLogger { constructor(agentName) { this.logger = winston.createLogger({ level: process.env.LOG_LEVEL || 'info', format: winston.format.combine( winston.format.timestamp(), winston.format.json() ), defaultMeta: { service: 'hermes-agent', agent: agentName, version: process.env.npm_package_version }, transports: [ new winston.transports.File({ filename: `logs/${agentName}-error.log`, level: 'error' }), new winston.transports.File({ filename: `logs/${agentName}-combined.log` }) ] }); // 开发环境添加控制台输出 if (process.env.NODE_ENV !== 'production') { this.logger.add(new winston.transports.Console({ format: winston.format.simple() })); } } // 记录技能执行日志 logSkillExecution(skillName, params, result, duration) { this.logger.info('skill_executed', { skill: skillName, params: this.sanitizeParams(params), success: result.success, duration: duration, timestamp: new Date().toISOString() }); } // 记录LLM调用