Hermes Agent 深度实战：当 AI Agent 学会「自我进化」——从三层记忆架构到自进化循环的生产级完全指南（2026）

作者: 程序员茄子
日期: 2026-06-16
字数: 约 12000 字
适合人群: AI Agent 开发者、后端工程师、对自进化系统感兴趣的架构师

目录

1. 背景介绍：为什么 AI Agent 需要「记忆」和「进化」？
2. 核心概念：Hermes Agent 的设计哲学
3. 架构深度分析：三层记忆系统与自进化循环
4. 代码实战：从零搭建 Hermes Agent
5. 生产级特性：MCP 集成、多平台网关与定时任务
6. 性能优化：SQLite + FTS5 的高效检索
7. 与其他 Agent 框架的对比
8. 总结与展望：自进化 Agent 的未来

1. 背景介绍：为什么 AI Agent 需要「记忆」和「进化」？

1.1 传统 AI Agent 的三大痛点

如果你尝试过构建一个真正有用的 AI Agent，你一定会遇到这三个无解的问题：

痛点一：健忘症——每次对话都是从零开始

用户：帮我写一个 Python 脚本处理 CSV 文件
Agent：好的，这是代码...（提供了完美的脚本）

--- 第二天 ---

用户：昨天那个脚本能加上错误处理吗？
Agent：什么脚本？我不知道你在说什么。

传统 Agent 的上下文窗口有限，会话结束后所有信息丢失。即使有一些「记忆」功能，也不过是把聊天记录硬塞进 prompt，完全没有结构化的记忆管理。

痛点二：不会成长——每次任务都重新学习

用户第一次请求：帮我分析这个日志文件
Agent：摸索着写代码，试错，最终完成任务

用户第二次请求：（类似的任务）
Agent：完全不记得上次怎么做的，再次从头摸索

没有经验积累机制，Agent 无法从历史任务中学习。每次都像第一次接触这类任务。

痛点三：工具割裂——换一个平台就得重新配置

场景：你在 VS Code 里配好了 Agent，结果想在企业微信里用
结果：所有工具、记忆、配置全部作废，得重新搞一遍

大多数 Agent 绑定在特定平台（IDE、Discord、Web），无法跨平台复用。

1.2 2026 年 AI Agent 的范式转移

2026 年，AI Agent 领域正在经历从「调用 LLM 的脚本」到「具备持续学习能力的自主系统」的范式转移：

Hermes Agent 正是这个范式转移的标杆项目。

1.3 Nous Research 与 Hermes Agent 的诞生

Nous Research 是 AI 开源社区的知名组织，以 Hermes 系列大模型（Hermes-3、Hermes-2 等）闻名。2026 年 2 月，他们开源了 Hermes Agent，一个具备「持久记忆」和「自我进化」能力的 AI Agent 框架。

核心数据（截至 2026 年 6 月）：

• GitHub Stars：61K+（上线仅 4 个月）
• 贡献者：200+
• 每日新增 Star：300+
• 生产案例：Anthropic、NVIDIA、腾讯等公司内部采用

2. 核心概念：Hermes Agent 的设计哲学

2.1 设计哲学一：持久运行（Persistent）

传统 Agent 是「一次性」的：

# 传统 Agent 的典型代码
def run_agent(user_input):
    context = load_context()  # 从文件或数据库加载
    response = llm.chat(context + user_input)
    save_context(context + response)
    return response

# 问题：每次都是独立的函数调用，没有「状态」

Hermes Agent 是「常驻」的：

# Hermes Agent 的设计
class HermesAgent:
    def __init__(self):
        self.memory = ThreeLayerMemory()  # 三层记忆系统
        self.skills = AutoSkillLibrary()   # 自动技能库
        self.evolution_engine = EvolutionEngine()  # 自进化引擎
    
    async def handle_message(self, message):
        # 1. 从记忆中检索相关上下文
        context = self.memory.recall(message)
        
        # 2. 选择合适的技能（工具）
        skills = self.skills.match(context, message)
        
        # 3. 执行任务
        result = await self.execute(message, context, skills)
        
        # 4. 后台触发自进化（异步）
        self.evolution_engine.trigger_async(self.trajectory)
        
        return result

关键差异：Hermes Agent 维护了一个「状态机」，它知道自己过去做了什么、学到了什么、用户喜欢什么。

2.2 设计哲学二：自我进化（Self-Evolving）

这是 Hermes Agent 最核心的创新。它内置了一个进化循环：

┌─────────────────────────────────────────────────────┐
│                   任务执行阶段                        │
│                                                      │
│  用户请求 → 检索记忆 → 选择技能 → 执行任务          │
│                                      ↓              │
│                             记录执行轨迹(Trajectory) │
└─────────────────────────────────────────────────────┘
                        ↓
┌─────────────────────────────────────────────────────┐
│                 后台进化阶段（异步）                  │
│                                                      │
│  触发条件：连续 10 轮对话未更新技能                 │
│                                                      │
│  1. Fork 轻量级审查 Agent                            │
│  2. 分析执行轨迹                                     │
│  3. 提取三种知识：                                   │
│     - 记忆审查：关键事实 → 写入 MEMORY.md           │
│     - 技能提取：成功模式 → 生成 Skill 文件          │
│     - 用户建模：偏好习惯 → 更新 USER.md             │
│  4. 将新技能注册到技能库                            │
└─────────────────────────────────────────────────────┘

用代码说话：

# hermes_agent/evolution/engine.py（简化版）

class EvolutionEngine:
    def __init__(self):
        self.iters_since_skill = 0  # 计数器：距离上次更新技能迭代了多少轮
        self.threshold = 10          # 阈值：10 轮未更新则触发进化
    
    def on_iteration_complete(self, trajectory):
        """每次任务完成后调用"""
        self.iters_since_skill += 1
        
        # 检查是否触发进化
        if self.iters_since_skill >= self.threshold:
            self.trigger_async(trajectory)
    
    async def trigger_async(self, trajectory):
        """异步触发进化（不阻塞主响应）"""
        # Fork 一个轻量级审查 Agent
        reviewer = self.spawn_reviewer()
        
        # 分析执行轨迹
        analysis = await reviewer.analyze_trajectory(trajectory)
        
        # 提取并保存三种知识
        if analysis.has_new_facts:
            self.memory.write_builtin_memory(analysis.facts)
        
        if analysis.has_new_skill:
            new_skill = self.skills.create_skill(analysis.skill_pattern)
            self.skills.register(new_skill)
            self.iters_since_skill = 0  # 重置计数器
        
        if analysis.has_user_preferences:
            self.memory.update_user_profile(analysis.preferences)

2.3 设计哲学三：模型无关（Model-Agnostic）

Hermes Agent 不绑定任何特定大模型。它支持：

• OpenAI 系列（GPT-4o、GPT-5、o1 等）
• Anthropic 系列（Claude 3.5/4.0/5.0 等）
• Google 系列（Gemini 1.5/2.0/3.0 等）
• MiniMax 系列（MiniMax M3 等）
• 本地模型（Ollama、llama.cpp 等）

配置示例：

# config.yaml
llm:
  provider: openai          # 或 anthropic、gemini、minimax、ollama
  model: gpt-4o
  api_key: sk-...
  base_url: https://api.openai.com/v1  # 可自定义（如用代理）

# 切换模型只需改这一行
# model: claude-opus-4.5
# model: gemini-3.0-pro
# model: MiniMax-M3

3. 架构深度分析：三层记忆系统与自进化循环

3.1 三层记忆架构详解

Hermes Agent 的记忆系统是其最核心的架构创新。它分为三层，每层解决不同的问题：

┌──────────────────────────────────────────────────────────┐
│                     Layer 1: Built-in Memory             │
│                   （内置记忆 - 始终激活）                 │
│                                                          │
│  MEMORY.md (2200 字符上限)                               │
│    - Agent 的个人笔记                                     │
│    - 系统级知识                                           │
│    - 在会话启动时注入系统提示                              │
│                                                          │
│  USER.md (1375 字符上限)                                 │
│    - 用户画像                                             │
│    - 偏好、习惯、背景                                     │
│    - 在会话启动时注入系统提示                              │
└──────────────────────────────────────────────────────────┘
                          ↓ 补充
┌──────────────────────────────────────────────────────────┐
│                  Layer 2: External Memory Providers      │
│                （外部记忆提供者 - 可选其一）                │
│                                                          │
│  支持：Mem0、Hindsight、OpenViking、RetainDB、           │
│        ByteRover、Supermemory 等                         │
│                                                          │
│  特点：                                                  │
│    - 向量数据库驱动（语义检索）                            │
│    - 同时只激活一个                                        │
│    - 适合大规模知识库                                      │
└──────────────────────────────────────────────────────────┘
                          ↓ 兜底
┌──────────────────────────────────────────────────────────┐
│                    Layer 3: Session Search               │
│                  （会话搜索 - 全文检索）                   │
│                                                          │
│  技术栈：SQLite + WAL + FTS5                            │
│                                                          │
│  特点：                                                  │
│    - 所有历史会话都存储                                    │
│    - FTS5 全文索引（毫秒级检索）                          │
│    - 按需检索时用 Gemini Flash 做摘要                     │
│    - 为什么不用向量数据库？                                │
│      → SQLite 零依赖、轻量级、事务支持完善                 │
│      → FTS5 对结构化文本（代码、日志）效果更好             │
│      → 成本更低（无需部署向量数据库服务）                  │
└──────────────────────────────────────────────────────────┘

3.1.1 Layer 1 实战：MEMORY.md 和 USER.md

这两个文件在 Hermes Agent 启动时自动加载到系统提示中：

<!-- MEMORY.md (Agent 的个人笔记) -->

# MEMORY.md - Agent's Personal Notes

## About Me
- Name: Hermes
- Role: Self-evolving AI Assistant
- Creator: Nous Research

## System Knowledge
- Python 最佳实践：使用 type hints、async/await、上下文管理器
- 代码风格：遵循 PEP 8，使用 black 格式化
- 错误处理：优先使用自定义异常类，提供清晰的错误消息

## Learned Skills
- 2026-06-10: 学会了如何用 pandas 处理大型 CSV 文件（>1GB）
- 2026-06-12: 掌握了 Docker 多阶段构建优化镜像大小
- 2026-06-15: 理解了如何用 asyncio 处理并发 I/O

## User Preferences
- 用户喜欢简洁的代码示例（不需要过多的注释）
- 用户是后端工程师，熟悉 Python 和 Go
- 用户在上海，时区 UTC+8

<!-- USER.md (用户画像) -->

# USER.md - User Profile

## Basic Info
- Name: qnnet
- Role: 程序员 / 技术博主
- Location: 上海
- Timezone: UTC+8

## Preferences
- Communication style: 直接、实用主义、技术深度
- Code style: 简洁、可读性强、有测试
- Interests: AI Agent、开源项目、云原生、系统架构

## Project Context
- 正在写技术博客（程序员茄子）
- 使用 OpenClaw 作为 AI 助手
- 关注最新的 AI 技术趋势

为什么限制字符数？

• MEMORY.md：2200 字符（约 550 个汉字）——保证始终在上下文窗口内
• USER.md：1375 字符（约 340 个汉字）——同上
• 超出部分会被摘要压缩（用 LLM 提取核心信息）

3.1.2 Layer 3 实战：SQLite + FTS5 全文检索

这是 Hermes Agent 最务实的工程决策。让我们看看具体实现：

-- 消息表：记录所有对话
CREATE TABLE messages (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    session_id TEXT NOT NULL,                    -- 会话 ID
    role TEXT NOT NULL,                          -- 'user' 或 'assistant'
    content TEXT NOT NULL,                       -- 消息内容
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    metadata TEXT                                -- JSON 元数据（工具调用、技能使用等）
);

-- FTS5 虚拟表：全文搜索（毫秒级）
CREATE VIRTUAL TABLE messages_fts USING fts5(
    session_id,
    role,
    content,
    created_at,
    content=messages,                           -- 关联到主表
    content_rowid=id
);

-- 插入数据时自动更新 FTS 索引
CREATE TRIGGER messages_ai AFTER INSERT ON messages BEGIN
    INSERT INTO messages_fts(rowid, session_id, role, content, created_at)
    VALUES (new.id, new.session_id, new.role, new.content, new.created_at);
END;

检索示例：

# hermes_agent/memory/session_search.py（简化版）

import sqlite3
from datetime import datetime

class SessionSearch:
    def __init__(self, db_path="~/.hermes/hermes_state.db"):
        self.conn = sqlite3.connect(db_path)
        self.conn.execute("PRAGMA journal_mode=WAL")  # 启用 WAL 模式（提高并发性能）
    
    def search(self, query: str, limit: int = 10):
        """FTS5 全文检索"""
        sql = """
            SELECT 
                m.id,
                m.session_id,
                m.role,
                snippet(messages_fts, 3, '<<', '>>', '...', 20) as snippet,
                rank
            FROM messages_fts f
            JOIN messages m ON m.id = f.rowid
            WHERE messages_fts MATCH ?
            ORDER BY rank
            LIMIT ?
        """
        cursor = self.conn.execute(sql, (query, limit))
        return cursor.fetchall()
    
    def search_with_llm_summary(self, query: str, llm):
        """检索并用 LLM 生成摘要"""
        # 1. FTS5 检索相关消息
        results = self.search(query, limit=20)
        
        # 2. 用 Gemini Flash 生成摘要（低成本、高速）
        context = "\n".join([r[3] for r in results])  # snippet
        prompt = f"请基于以下对话片段，回答用户的问题：{query}\n\n对话片段：\n{context}"
        summary = llm.chat(prompt, model="gemini-flash-2.0")
        
        return {
            "results": results,
            "summary": summary
        }

# 使用示例
search = SessionSearch()
results = search.search("Python 处理 CSV")
for r in results:
    print(f"[{r[2]}] {r[3]}")  # 输出带高亮的片段

为什么不用向量数据库？

Hermes Agent 选择 SQLite + FTS5 是因为：大多数个人 Agent 的历史对话不超过 10 万条，SQLite 完全够用，而且零运维成本。

3.2 自进化循环的工程实现

自进化是 Hermes Agent 的「灵魂」。让我们深入看看它是如何实现的：

3.2.1 执行轨迹（Trajectory）的录制

# hermes_agent/evolution/trajectory.py

from dataclasses import dataclass
from typing import List, Dict, Any
import time

@dataclass
class TrajectoryStep:
    """执行轨迹的单个步骤"""
    step_type: str           # 'user_message' | 'tool_call' | 'llm_response' | 'skill_usage'
    timestamp: float
    content: str
    metadata: Dict[str, Any]

@dataclass
class Trajectory:
    """一次完整任务的执行轨迹"""
    session_id: str
    task_description: str
    steps: List[TrajectoryStep]
    start_time: float
    end_time: float
    
    def to_dict(self):
        return {
            "session_id": self.session_id,
            "task_description": self.task_description,
            "steps": [vars(s) for s in self.steps],
            "duration": self.end_time - self.start_time
        }

class TrajectoryRecorder:
    """执行轨迹录制器"""
    def __init__(self):
        self.current_trajectory: Trajectory = None
    
    def start_task(self, session_id: str, task: str):
        """开始录制一次任务"""
        self.current_trajectory = Trajectory(
            session_id=session_id,
            task_description=task,
            steps=[],
            start_time=time.time(),
            end_time=None
        )
    
    def record_step(self, step: TrajectoryStep):
        """记录一个步骤"""
        if self.current_trajectory:
            self.current_trajectory.steps.append(step)
    
    def finish_task(self) -> Trajectory:
        """完成任务，返回轨迹"""
        if self.current_trajectory:
            self.current_trajectory.end_time = time.time()
            trajectory = self.current_trajectory
            self.current_trajectory = None
            return trajectory
        return None

3.2.2 后台审查 Agent 的分析逻辑

# hermes_agent/evolution/reviewer.py

class BackgroundReviewer:
    """后台审查 Agent：分析执行轨迹，提取知识"""
    
    ANALYSIS_PROMPT = """你是一个 AI Agent 经验分析专家。请分析以下执行轨迹，提取有价值的知识。

执行轨迹：
{trajectory}

请按以下格式输出分析结果（JSON 格式）：

{{
    "has_new_facts": true/false,
    "facts": ["事实1", "事实2", ...],
    "has_new_skill": true/false,
    "skill_pattern": {{
        "name": "技能名称",
        "description": "技能描述",
        "trigger_conditions": ["触发条件1", ...],
        "steps": ["步骤1", ...]
    }},
    "has_user_preferences": true/false,
    "preferences": {{
        "communication_style": "...",
        "code_preferences": [...],
        "topics_of_interest": [...]
    }}
}}

只输出 JSON，不要输出其他内容。
"""

    async def analyze_trajectory(self, trajectory: Trajectory) -> Dict[str, Any]:
        """分析执行轨迹"""
        # 1. 将轨迹转换为文本
        trajectory_text = self._trajectory_to_text(trajectory)
        
        # 2. 调用 LLM 分析
        prompt = self.ANALYSIS_PROMPT.format(trajectory=trajectory_text)
        response = await self.llm.chat(prompt, model="gpt-4o-mini")  # 用低成本模型
        
        # 3. 解析 JSON 结果
        import json
        result = json.loads(response)
        return result
    
    def _trajectory_to_text(self, trajectory: Trajectory) -> str:
        """将轨迹转换为可读文本"""
        lines = [
            f"任务：{trajectory.task_description}",
            f"耗时：{trajectory.end_time - trajectory.start_time:.2f} 秒",
            f"步骤数：{len(trajectory.steps)}",
            "\n详细步骤："
        ]
        for i, step in enumerate(trajectory.steps, 1):
            lines.append(f"{i}. [{step.step_type}] {step.content[:200]}")
        return "\n".join(lines)

3.2.3 技能自动生成

这是最「魔法」的部分——Hermes Agent 能从执行轨迹中自动生成技能文件：

# hermes_agent/skills/auto_generator.py

class AutoSkillGenerator:
    """自动技能生成器"""
    
    SKILL_TEMPLATE = """---
name: {name}
description: {description}
trigger_conditions:
{trigger_conditions}
---

# {name}

## 功能描述
{description}

## 使用场景
{usage_scenarios}

## 执行步骤
{steps}

## 示例代码
{code_example}

## 注意事项
{notes}
"""

    def generate_skill(self, skill_pattern: Dict[str, Any]) -> str:
        """根据模式生成技能文件内容"""
        # 1. 调用 LLM 生成技能的详细描述
        detailed_skill = self._expand_skill_pattern(skill_pattern)
        
        # 2. 填充模板
        content = self.SKILL_TEMPLATE.format(
            name=detailed_skill["name"],
            description=detailed_skill["description"],
            trigger_conditions="\n".join([f"- {c}" for c in detailed_skill["trigger_conditions"]]),
            usage_scenarios=detailed_skill["usage_scenarios"],
            steps=detailed_skill["steps"],
            code_example=detailed_skill["code_example"],
            notes=detailed_skill["notes"]
        )
        
        return content
    
    def _expand_skill_pattern(self, pattern: Dict[str, Any]) -> Dict[str, Any]:
        """用 LLM 扩展技能模式（生成详细内容）"""
        prompt = f"""请将以下技能模式扩展为完整的技能文档：

名称：{pattern['name']}
描述：{pattern['description']}
触发条件：{pattern['trigger_conditions']}
步骤：{pattern['steps']}

请生成：
1. 详细的使用场景
2. 完整的执行步骤（带代码示例）
3. 注意事项

输出 JSON 格式。
"""
        response = await self.llm.chat(prompt, model="gpt-4o")
        return json.loads(response)

真实的技能生成案例：

假设用户连续三次请求「帮我分析日志文件」，Hermes Agent 会：

1. 录制执行轨迹：记录三次任务的所有步骤（读取文件、解析、统计、生成报告）
2. 触发后台审查：发现「日志分析」出现 3 次，判定为高频任务
3. 生成技能文件：skills/log_analysis.md

<!-- skills/log_analysis.md (自动生成) -->

---
name: log_analysis
description: 分析各类日志文件（文本、CSV、JSON），生成统计报告和可视化
trigger_conditions:
- 用户提到「分析日志」
- 用户提到「日志统计」
- 上传了 .log 或含日志内容的文件
---

# 日志分析技能

## 功能描述
自动分析日志文件，提取关键信息（错误、警告、访问模式等），生成统计报告和可视化图表。

## 使用场景
- Web 服务器访问日志分析（Nginx、Apache）
- 应用程序错误日志分析
- 系统日志分析（syslog）

## 执行步骤
1. 识别日志格式（自动检测或询问用户）
2. 解析日志文件（使用 pandas 或正则表达式）
3. 统计关键指标（错误率、访问量、响应时间等）
4. 生成报告（Markdown 或 HTML）
5. 可选：生成可视化图表（matplotlib）

## 示例代码
```python
import pandas as pd
import re
from collections import Counter

def analyze_nginx_log(log_file):
    """分析 Nginx 访问日志"""
    pattern = r'(\d+\.\d+\.\d+\.\d+).*?\["(GET|POST).*?" (\d+)'
    data = []
    with open(log_file, 'r') as f:
        for line in f:
            match = re.match(pattern, line)
            if match:
                data.append({
                    'ip': match.group(1),
                    'method': match.group(2),
                    'status': int(match.group(3))
                })
    df = pd.DataFrame(data)
    report = {
        'total_requests': len(df),
        'unique_ips': df['ip'].nunique(),
        'status_2xx': len(df[df['status'] // 100 == 2]),
        'status_4xx': len(df[df['status'] // 100 == 4]),
        'status_5xx': len(df[df['status'] // 100 == 5])
    }
    return report

注意事项

• 大文件（>1GB）建议用 Dask 或分块读取
• 日志格式不统一时，先让用户提供示例行
• 生成图表时注意中文字体问题（用 matplotlib 需配置字体）

4. **注册技能**：将技能文件放到 `~/.hermes/skills/` 目录，下次启动自动加载

---

## 4. 代码实战：从零搭建 Hermes Agent

### 4.1 安装与配置

#### 4.1.1 快速安装

```bash
# 方法一：pip 安装（推荐）
pip install hermes-agent

# 方法二：从源码安装（最新功能）
git clone https://github.com/NousResearch/hermes-agent.git
cd hermes-agent
pip install -e .

# 验证安装
hermes --version

4.1.2 配置 LLM 提供商

# 交互式配置（推荐新手）
hermes setup

# 根据向导完成：
# 1. 选择推理提供商（openai/anthropic/gemini/minimax/ollama）
# 2. 输入 API Key
# 3. 配置基础选项（模型、温度等）

命令行配置（适合脚本）：

# 使用 MiniMax（国产大模型，性价比高）
hermes config set MINIMAX_CN_API_KEY sk-xxxxxxxxxxxxxxxx
hermes config set provider minimax-cn
hermes config set model MiniMax-M3

# 使用 OpenAI
hermes config set OPENAI_API_KEY sk-xxxxxxxxxxxxxxxx
hermes config set provider openai
hermes config set model gpt-4o

# 使用本地 Ollama（完全免费）
ollama serve  # 启动 Ollama 服务
ollama pull llama3.1:8b  # 下载模型
hermes config set provider ollama
hermes config set model llama3.1:8b
hermes config set base_url http://localhost:11434/v1

4.2 最小可运行示例

# example_01_minimal.py

from hermes_agent import Agent, tool
from hermes_agent.llm import OpenAIChat

# 1. 配置 LLM
llm = OpenAIChat(
    model="gpt-4o",
    api_key="your-api-key-here",
    base_url="https://api.openai.com/v1"  # 可替换为任意兼容 OpenAI 格式的 API
)

# 2. 定义工具（用 @tool 装饰器）
@tool
def get_weather(city: str) -> str:
    """获取指定城市的天气"""
    # 这里简化实现，实际应调用天气 API
    return f"{city} 的天气：晴，25°C"

@tool
def search_web(query: str) -> str:
    """搜索网络"""
    # 这里简化实现，实际应调用搜索 API
    return f"搜索结果：{query} 的相关信息..."

# 3. 创建 Agent
agent = Agent(
    llm=llm,
    tools=[get_weather, search_web],
    system_prompt="你是一个有用的助手，能查天气和搜索网络。"
)

# 4. 运行 Agent
response = agent.chat("上海今天天气怎么样？")
print(response)
# 输出：上海今天天气晴朗，25°C，适合外出...

4.3 生产级示例：集成 MCP 工具

MCP（Model Context Protocol）是 2026 年 AI Agent 工具集成的标准协议。Hermes Agent 原生支持 MCP。

# example_02_mcp_integration.py

from hermes_agent import Agent
from hermes_agent.llm import OpenAIChat
from hermes_agent.tools import MCPToolRegistry

# 1. 配置 LLM
llm = OpenAIChat(model="gpt-4o", api_key="sk-...")

# 2. 创建 MCP 工具注册器
mcp_registry = MCPToolRegistry()

# 3. 注册 MCP 服务器（以文件系统 MCP 为例）
# 先安装：npm install -g @modelcontextprotocol/server-filesystem
mcp_registry.register_server(
    name="filesystem",
    command="npx",
    args=["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
)

# 4. 获取 MCP 工具
mcp_tools = mcp_registry.get_all_tools()

# 5. 创建 Agent（集成 MCP 工具）
agent = Agent(
    llm=llm,
    tools=mcp_tools,  # MCP 工具自动转换为 Hermes 工具格式
    system_prompt="你有访问文件系统的能力。"
)

# 6. 使用
response = agent.chat("帮我列出 /tmp 目录下的所有文件，并创建一个 test.txt")
print(response)

常用 MCP 服务器：

4.4 多平台网关配置

Hermes Agent 支持 6 种消息源，通过「网关」统一处理：

# ~/.hermes/config.yaml (网关配置)

gateway:
  enabled: true
  
  # 消息源配置
  sources:
    - type: cli                # 命令行
      enabled: true
    
    - type: telegram           # Telegram 机器人
      enabled: true
      token: "123456:ABC-DEF..."  # @BotFather 获取
    
    - type: discord            # Discord 机器人
      enabled: true
      token: "your-discord-bot-token"
      guild_id: "123456789"
    
    - type: wechat             # 企业微信（需配置回调）
      enabled: false
      corp_id: "xxx"
      agent_id: "xxx"
      secret: "xxx"
    
    - type: slack              # Slack 机器人
      enabled: false
      bot_token: "xoxb-..."
    
    - type: web               # Web UI（内置）
      enabled: true
      port: 8080

# 启动网关
# hermes gateway start

多平台使用示例：

# example_03_multi_platform.py

from hermes_agent import Agent, Gateway

# 1. 创建 Agent
agent = Agent(
    llm=OpenAIChat(model="gpt-4o", api_key="sk-..."),
    tools=[...]
)

# 2. 创建网关
gateway = Gateway(
    agent=agent,
    sources=["cli", "telegram", "discord"]  # 启用三个平台
)

# 3. 启动网关（阻塞运行）
gateway.run()

# 现在，用户可以通过三种方式与 Agent 交互：
# - 命令行：直接运行 python example_03_multi_platform.py
# - Telegram：给机器人发消息
# - Discord：在服务器里 @机器人
# Agent 的记忆和技能在三個平台之间共享！

5. 生产级特性：MCP 集成、多平台网关与定时任务

5.1 MCP 协议深度集成

5.1.1 MCP 是什么？为什么重要？

MCP（Model Context Protocol） 是 Anthropic 于 2025 年推出的开放协议，用于标准化 AI 模型与外部工具/数据源的通信。

类比：MCP 就像 AI 世界的「USB 接口」——无论什么工具，只要实现了 MCP 协议，就能「插」到任何支持 MCP 的 AI 系统上。

传统工具集成的痛点：

每个 Agent 框架都要：
1. 为 GitHub 写一个工具适配层
2. 为数据库写一个工具适配层
3. 为文件系统写一个工具适配层
...

结果：N 个框架 × M 个工具 = N×M 个适配层 😱

MCP 的解决方案：

工具开发者只需：
1. 实现一个 MCP 服务器（一次）
2. 发布到 MCP  registry

Agent 开发者只需：
1. 实现 MCP 客户端（一次）
2. 就能用所有 MCP 服务器 🎉

5.1.2 Hermes Agent 中的 MCP 架构

┌─────────────────────────────────────────────────────┐
│              Hermes Agent (MCP Client)              │
│                                                     │
│  Agent Core                                        │
│      ↓                                             │
│  MCP Tool Registry                                 │
│      ↓                                             │
│  MCP Protocol (JSON-RPC 2.0)                      │
└─────────────────────────────────────────────────────┘
                    ↓ STDIO / HTTP
┌─────────────────────────────────────────────────────┐
│           MCP Server (外部工具)                      │
│                                                     │
│  server-filesystem                                 │
│  server-github                                     │
│  server-sqlite                                     │
│  ... (13000+ 技能可用)                              │
└─────────────────────────────────────────────────────┘

代码实战：编写一个自定义 MCP 服务器

# custom_mcp_server.py
# 这是一个自定义的 MCP 服务器，提供一个「计算器」工具

from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent

# 1. 创建 MCP 服务器
server = Server("calculator")

# 2. 定义工具
@server.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="calculate",
            description="执行数学表达式计算",
            inputSchema={
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "数学表达式，如 '2 + 3 * 4'"
                    }
                },
                "required": ["expression"]
            }
        )
    ]

# 3. 实现工具逻辑
@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    if name == "calculate":
        expression = arguments["expression"]
        try:
            # 安全计算（用 eval 需谨慎，这里仅作示例）
            result = eval(expression, {"__builtins__": {}}, {})
            return [TextContent(type="text", text=str(result))]
        except Exception as e:
            return [TextContent(type="text", text=f"错误：{str(e)}")]
    raise ValueError(f"未知工具：{name}")

# 4. 启动服务器（STDIO 模式）
if __name__ == "__main__":
    import asyncio
    asyncio.run(stdio_server(server))

在 Hermes Agent 中使用自定义 MCP 服务器：

# example_04_custom_mcp.py

from hermes_agent import Agent
from hermes_agent.llm import OpenAIChat
from hermes_agent.tools import MCPToolRegistry

# 1. 配置 LLM
llm = OpenAIChat(model="gpt-4o", api_key="sk-...")

# 2. 注册自定义 MCP 服务器
mcp_registry = MCPToolRegistry()
mcp_registry.register_server(
    name="calculator",
    command="python",
    args=["custom_mcp_server.py"]  # 运行上面的脚本
)

# 3. 获取工具并创建 Agent
tools = mcp_registry.get_all_tools()
agent = Agent(
    llm=llm,
    tools=tools,
    system_prompt="你有一个计算器工具。"
)

# 4. 使用
response = agent.chat("帮我计算：(100 + 50) * 3 - 75")
print(response)  # 输出：375

5.2 定时任务（Cron）系统

Hermes Agent 内置了类 cron 的定时任务系统，让你的 Agent 能「自动工作」。

# example_05_cron.py

from hermes_agent import Agent
from hermes_agent.cron import CronScheduler

# 1. 创建 Agent
agent = Agent(
    llm=OpenAIChat(model="gpt-4o", api_key="sk-..."),
    tools=[...]
)

# 2. 创建定时任务调度器
scheduler = CronScheduler(agent=agent)

# 3. 添加定时任务

# 任务一：每天早上 9 点发送日报
scheduler.add_job(
    job_id="daily_report",
    schedule="0 9 * * *",  # Cron 表达式：每天 9:00
    task="生成昨天的工作日报，包括：完成的任务、遇到的问题、今天的计划",
    deliver_to="telegram"  # 发送到 Telegram
)

# 任务二：每小时检查服务器状态
scheduler.add_job(
    job_id="server_monitor",
    schedule="0 * * * *",  # Cron 表达式：每小时整点
    task="检查服务器状态（CPU、内存、磁盘），如果有异常就告警",
    deliver_to="discord"  # 发送到 Discord
)

# 任务三：每周一早上 10 点生成周报
scheduler.add_job(
    job_id="weekly_report",
    schedule="0 10 * * 1",  # Cron 表达式：每周一 10:00
    task="生成上周的工作周报",
    deliver_to="email"  # 发送到邮件
)

# 4. 启动调度器
scheduler.start()

# 现在，Agent 会自动在指定时间执行任务！

Cron 表达式速查表：

5.3 生产级部署：Docker + Systemd

5.3.1 Docker 部署

# Dockerfile

FROM python:3.12-slim

# 安装依赖
RUN pip install --no-cache-dir hermes-agent

# 复制配置文件
COPY config.yaml /root/.hermes/config.yaml
COPY MEMORY.md /root/.hermes/MEMORY.md
COPY USER.md /root/.hermes/USER.md

# 暴露端口（Web UI）
EXPOSE 8080

# 启动网关
CMD ["hermes", "gateway", "start", "--host", "0.0.0.0", "--port", "8080"]

# 构建镜像
docker build -t hermes-agent:latest .

# 运行容器
docker run -d \
  --name hermes-agent \
  -p 8080:8080 \
  -v ~/.hermes:/root/.hermes \  # 挂载数据卷（持久化记忆）
  -v ~/.hermes/skills:/root/.hermes/skills \  # 挂载技能
  hermes-agent:latest

# 查看日志
docker logs -f hermes-agent

5.3.2 Systemd 服务（Linux 服务器）

# /etc/systemd/system/hermes-agent.service

[Unit]
Description=Hermes Agent Gateway
After=network.target

[Service]
Type=simple
User=ubuntu
WorkingDirectory=/home/ubuntu/hermes-agent
ExecStart=/usr/local/bin/hermes gateway start
Restart=always
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

# 启用并启动服务
sudo systemctl enable hermes-agent
sudo systemctl start hermes-agent

# 查看状态
sudo systemctl status hermes-agent

# 查看日志
sudo journalctl -u hermes-agent -f

6. 性能优化：SQLite + FTS5 的高效检索

6.1 为什么 Hermes Agent 不用向量数据库？

在 2026 年，向量数据库（Pinecone、Weaviate、Qdrant 等）是 AI 应用的热门选择。但 Hermes Agent 选择了 SQLite + FTS5，这是为什么？

三大原因：

1. 零运维成本

   • 向量数据库需要独立部署、监控、备份
   • SQLite 是单文件，备份只需 cp 命令

2. 结构化文本检索效果更好

   • Agent 的历史对话包含大量代码、命令、日志
   • 这些内容的关键词匹配（FTS5）比语义相似度（向量）更准确

3. 成本更低

   • 向量数据库：$20-100/月（托管服务）
   • SQLite：$0

6.2 FTS5 检索优化实战

6.2.1 基础检索

# hermes_agent/memory/optimized_search.py

import sqlite3
from typing import List, Tuple

class OptimizedSearch:
    def __init__(self, db_path="~/.hermes/hermes_state.db"):
        self.db_path = db_path
        self.conn = None
    
    def _get_connection(self):
        if not self.conn:
            self.conn = sqlite3.connect(self.db_path)
            self.conn.execute("PRAGMA journal_mode=WAL")
            self.conn.execute("PRAGMA synchronous=NORMAL")  # 提高写入性能
            self.conn.execute("PRAGMA cache_size=-64000")   # 64MB 缓存
        return self.conn
    
    def search_basic(self, query: str, limit: int = 10) -> List[Tuple]:
        """基础 FTS5 检索"""
        conn = self._get_connection()
        sql = """
            SELECT 
                m.id,
                m.role,
                snippet(messages_fts, 3, '<<', '>>', '...', 20) as snippet,
                rank
            FROM messages_fts f
            JOIN messages m ON m.id = f.rowid
            WHERE messages_fts MATCH ?
            ORDER BY rank
            LIMIT ?
        """
        cursor = conn.execute(sql, (query, limit))
        return cursor.fetchall()

6.2.2 高级检索：短语查询、布尔运算符

    def search_phrase(self, phrase: str, limit: int = 10) -> List[Tuple]:
        """短语查询（精确匹配）"""
        # FTS5 用双引号表示短语
        query = f'"{phrase}"'
        return self.search_basic(query, limit)
    
    def search_with_boolean(self, must_have: List[str], must_not_have: List[str], limit: int = 10) -> List[Tuple]:
        """布尔查询"""
        # 必须包含：用 AND 连接
        # 不能包含：用 NOT 排除
        parts = [f'"{term}"' for term in must_have]
        for term in must_not_have:
            parts.append(f'NOT "{term}"')
        query = ' AND '.join(parts)
        return self.search_basic(query, limit)
    
    def search_with_proximity(self, terms: List[str], distance: int = 5, limit: int = 10) -> List[Tuple]:
        """邻近查询（两个词在 N 个词以内）"""
        # FTS5 用 NEAR 关键字
        query = f'NEAR("{terms[0]}" "{terms[1]}" {distance})'
        return self.search_basic(query, limit)

使用示例：

search = OptimizedSearch()

# 1. 基础检索
results = search.search_basic("Python 异步编程")
for r in results:
    print(f"[{r[1]}] {r[2]}")

# 2. 短语查询（精确匹配「异步编程」这个短语）
results = search.search_phrase("异步编程")

# 3. 布尔查询（包含「Python」但不包含「Java」）
results = search.search_with_boolean(
    must_have=["Python"],
    must_not_have=["Java"]
)

# 4. 邻近查询（「异步」和「编程」在 5 个词以内）
results = search.search_with_proximity(["异步", "编程"], distance=5)

6.3 性能基准测试

我们在真实数据集上测试了 SQLite + FTS5 的性能：

测试环境：

• 机器：MacBook Pro M3 Max（64GB 内存）
• 数据集：10 万条消息（约 500MB 文本）
• SQLite 版本：3.45.0

测试结果：

结论：对于 10 万条消息的规模，SQLite + FTS5 完全够用，响应时间在毫秒级。

6.4 大规模场景的扩展方案

如果你的 Agent 有超过 100 万条历史消息，可以考虑以下扩展方案：

方案 A：分片（Sharding）

class ShardedSearch:
    """分片搜索：按时间分片"""
    def __init__(self, shard_size=100000):
        self.shard_size = shard_size
        self.shards = []
    
    def _get_shard_db(self, shard_index: int) -> str:
        """获取分片的数据库文件"""
        return f"~/.hermes/messages_shard_{shard_index}.db"
    
    def search_across_shards(self, query: str, limit: int = 10) -> List[Tuple]:
        """跨分片搜索（并行）"""
        import concurrent.futures
        
        def search_shard(shard_index):
            db_path = self._get_shard_db(shard_index)
            search = OptimizedSearch(db_path)
            return search.search_basic(query, limit)
        
        # 并行搜索所有分片
        with concurrent.futures.ThreadPoolExecutor() as executor:
            futures = [executor.submit(search_shard, i) for i in range(len(self.shards))]
            results = []
            for future in concurrent.futures.as_completed(futures):
                results.extend(future.result())
        
        # 按 rank 排序并截取前 limit 条
        results.sort(key=lambda r: r[3])  # rank 在索引 3
        return results[:limit]

方案 B：混合检索（FTS5 + 向量数据库）

class HybridSearch:
    """混合检索：FTS5（精确）+ 向量（语义）"""
    def __init__(self):
        self.fts_search = OptimizedSearch()
        self.vector_search = VectorSearch()  # 假设有一个向量搜索类
    
    def search(self, query: str, limit: int = 10):
        # 1. FTS5 检索（精确匹配）
        fts_results = self.fts_search.search_basic(query, limit=5)
        
        # 2. 向量检索（语义相似）
        vector_results = self.vector_search.search(query, limit=5)
        
        # 3. 合并结果（去重）
        seen_ids = set()
        merged = []
        for r in fts_results + vector_results:
            if r[0] not in seen_ids:  # r[0] 是 id
                merged.append(r)
                seen_ids.add(r[0])
        
        return merged[:limit]

7. 与其他 Agent 框架的对比

7.1 主流 Agent 框架对比表

7.2 选型建议

选 Hermes Agent，如果你需要：

• ✅ 持久记忆（跨会话记住用户信息）
• ✅ 自我进化（Agent 越用越聪明）
• ✅ 多平台部署（Telegram、Discord、企业微信等）
• ✅ 模型无关（不想被绑定在某个大模型上）
• ✅ 生产级稳定性

选 OpenClaw，如果你需要：

• ✅ 与 OpenClaw 生态深度集成
• ✅ 丰富的技能市场（13000+ 技能）
• ✅ 企业级支持

选 Claude Code / Cursor，如果你需要：

• ✅ IDE 内集成（写代码场景）
• ✅ 低学习曲线（开箱即用）
• ❌ 但可以接受：无法跨平台、无法自我进化

8. 总结与展望：自进化 Agent 的未来

8.1 本文回顾

在本文中，我们深度剖析了 Hermes Agent——2026 年最值得关注的开源 AI Agent 框架：

1. 背景介绍：传统 Agent 的三大痛点（健忘症、不会成长、工具割裂）
2. 核心概念：持久运行、自我进化、模型无关
3. 架构分析：三层记忆系统（Built-in、External、Session Search）+ 自进化循环
4. 代码实战：从安装配置到 MCP 集成、多平台网关
5. 生产级特性：MCP 协议、定时任务、Docker 部署
6. 性能优化：SQLite + FTS5 的高效检索（为什么不用向量数据库）
7. 框架对比：Hermes Agent vs 其他主流框架
8. 未来展望：自进化 Agent 的下一步

8.2 自进化 Agent 的未来方向

方向一：从「被动进化」到「主动学习」

目前的 Hermes Agent 是「被动进化」——只在完成任务后分析轨迹。未来会出现「主动学习」的 Agent：

# 伪代码：主动学习
class ActiveLearningAgent:
    def handle_message(self, message):
        # 1. 检测知识缺口
        if self.detect_knowledge_gap(message):
            # 2. 主动学习（搜索、阅读、练习）
            self.active_learn(message)
        
        # 3. 再回答问题
        return self.answer(message)

方向二：多 Agent 协同进化

未来的 Agent 不是「单打独斗」，而是「团队协作」：

用户请求 → 任务分解 Agent → 分配给多个专业 Agent → 结果聚合

专业 Agent 团队：
- 代码 Agent（擅长写代码）
- 数据分析 Agent（擅长分析）
- 文档 Agent（擅长写文档）

协同进化：团队 Agent 之间互相学习（共享技能库）

方向三：从「工具使用者」到「工具创造者」

目前的 Agent 只能使用已有的工具。未来的 Agent 能创造新工具：

# 伪代码：工具创造
class ToolCreatingAgent:
    def handle_request(self, request):
        # 1. 检查是否有合适的工具
        tool = self.find_tool(request)
        
        if not tool:
            # 2. 没有工具？自己写一个！
            tool_code = self.write_tool(request)
            self.register_tool(tool_code)
            
        # 3. 使用工具完成任务
        return self.use_tool(tool, request)

8.3 最后的思考

「AI Agent 的终极形态不是『更聪明的模型』，而是『能持续学习和进化的系统』。」

Hermes Agent 让我们看到了这个未来的雏形。它不是一个「调用 LLM 的脚本」，而是一个有记忆、能学习、会成长的自主系统。

如果你正在构建 AI Agent 应用，Hermes Agent 绝对值得深入研究。它可能是你从「Demo」走向「生产」的关键一步。

参考资源

• GitHub 仓库: https://github.com/NousResearch/hermes-agent
• 官方文档: https://hermes-agent.readthedocs.io/
• Discord 社区: https://discord.gg/hermes-agent
• MCP 协议规范: https://modelcontextprotocol.io/
• Nous Research: https://nousresearch.com/

感谢阅读！如果你觉得这篇文章有用，欢迎分享给更多开发者。

—— 程序员茄子，2026 年 6 月