Motor de memoria de autoaprendizaje para agentes de programación

Un motor de memoria de autoaprendizaje basado en MCP (Model Context Protocol), que proporciona a los agentes de programación una capacidad de aprendizaje en bucle cerrado de cuatro capas: "percepción-reflexión-consolidación-aplicación". Permite que el agente aprenda de sus errores y se vuelva más fuerte con cada uso.

Descripción general de la arquitectura

┌──────────────────────────────────────────────────────┐
│                    编程智能体                          │
│  (Claude Code / Cursor / 任何支持 MCP 的智能体)       │
└──────────┬───────────────────────┬────────────────────┘
           │ MCP Protocol          │
    ┌──────▼──────┐         ┌──────▼──────┐
    │  应用层      │         │  感知层      │
    │  检索+注入   │         │  错误捕获    │
    └──────┬──────┘         └──────┬──────┘
           │                       │
    ┌──────▼──────┐         ┌──────▼──────┐
    │  沉淀层      │         │  反思层      │
    │  技能+记忆   │◄────────│  根因分析    │
    └──────┬──────┘         └─────────────┘
           │
    ┌──────▼──────┐
    │  存储层      │
    │  SQLite+FTS5 │
    └─────────────┘

Related MCP server: Self-Learning MCP

Bucle cerrado de cuatro capas

Instalación

# 进入项目目录（替换为你本机的实际路径）
cd memory-engine

# 安装依赖（绕过代理）
pip install --no-proxy -e .

# 或手动安装
pip install --no-proxy mcp[cli] jieba

Configuración del servidor MCP

ZCode / Claude Code

Añada lo siguiente al archivo de configuración de MCP:

{
  "mcpServers": {
    "memory-engine": {
      "command": "python",
      "args": ["-m", "memory_engine.server"],
      "cwd": "<项目根目录的绝对路径>"
    }
  }
}

Reemplace <ruta absoluta del directorio raíz del proyecto> por la ruta real donde haya clonado/almacenado este proyecto en su máquina (es decir, el directorio que contiene pyproject.toml), por ejemplo, en Windows algo como D:/tools/memory-engine, en macOS/Linux algo como /home/user/tools/memory-engine.

Cursor / VS Code

Añada la misma configuración en .cursor/mcp.json o en la configuración de MCP de VS Code.

Ejecución independiente (para depuración)

cd memory-engine
python -m memory_engine.server

Flujo de trabajo principal

0. Capturar señales de conversación (percepción mejorada)

Durante el proceso de vibe coding, el operador suele dejar señales explícitas en la conversación —instrucciones enfatizadas como "por favor, tenga en cuenta", "por favor, recuerde"—, así como quejas generadas por errores repetidos del agente ("¿otra vez...?", "¿cuántas veces te lo he dicho...?"). Estas frases son el material de aprendizaje de mayor valor y deben capturarse e incorporarse a la memoria:

capture_conversation_signals(
  conversation_text="用户: 请注意，bat文件必须用ANSI编码
用户: 怎么又是编码问题，我说过多少次了",
  auto_record=true
)

El detector identifica cuatro tipos de señales y las ordena por prioridad:

El resultado de la detección se registra automáticamente como una observación de tipo conversation_signal, y durante la reflexión se utiliza un prompt especialmente personalizado (inferir errores anteriores + extraer reglas en forma imperativa), y el flujo posterior es el mismo que el de la reflexión de errores.

1. Registrar errores (percepción)

Cuando falla la ejecución de una herramienta, el agente llama a:

record_observation(
  obs_type="tool_error",
  tool_name="Bash",
  error_message="bat文件执行报错：编码错误",
  context="在Windows上创建的bat文件包含中文注释",
  tags="encoding,windows,bat"
)

2. Análisis de reflexión (reflexión)

Obtener el prompt de análisis:

get_reflection_prompt(obs_id="abc123")

El agente analiza la causa raíz según el prompt devuelto y luego guarda el resultado:

reflect_and_save(
  obs_id="abc123",
  root_cause="Windows的cmd.exe默认使用系统ANSI编码，UTF-8编码的bat文件会导致中文注释被解析错误",
  category="encoding",
  lesson="在Windows上创建bat文件时，文件必须使用ANSI/GBK编码，而非UTF-8",
  solution="将bat文件保存为ANSI编码，或使用chcp 65001切换代码页",
  tags="encoding,windows,bat,cmd",
  generalizable=true
)

3. Refinar habilidades (consolidación)

Tras acumular suficiente experiencia, comprobar si se puede refinar una habilidad:

check_consolidation()

Crear la habilidad:

create_skill(
  name="windows-bat-encoding",
  description="Windows bat文件中文编码问题的处理方法",
  trigger_conditions="创建或编辑.bat文件\n在Windows上运行脚本失败且涉及中文",
  steps="将文件保存为ANSI编码\n或使用chcp 65001 + UTF-8 BOM",
  caveats="chcp 65001仅在当前cmd会话有效\n某些旧版Windows不支持UTF-8 BOM",
  category="encoding"
)

4. Recuperación y aplicación (aplicación)

Antes de comenzar una nueva tarea, obtener la experiencia relevante:

get_context(task_description="需要创建一个Windows批处理脚本来部署应用")

Devuelve un contexto que incluye habilidades y casos relevantes, que se inyecta directamente en el prompt.

Capas de memoria

Almacenamiento de datos

• Base de datos SQLite (data/memories.db): almacenamiento estructurado, compatible con búsqueda de texto completo FTS5

• Registro JSONL (data/observations.jsonl): registro de anexión de observaciones originales

• Archivos Markdown (data/skills/): documentación de habilidades generada, legible por humanos y versionable

Estructura del proyecto

memory-engine/
├── 开发思路.md              # 设计文档
├── README.md                # 本文件
├── pyproject.toml           # Python 项目配置
├── requirements.txt         # 依赖列表
├── config/
│   └── settings.json        # 引擎配置
├── src/memory_engine/
│   ├── __init__.py
│   ├── server.py            # MCP 服务器入口（15个工具）
│   ├── models/
│   │   └── schemas.py       # 数据模型
│   ├── observation/
│   │   ├── collector.py     # 感知层：错误收集器
│   │   └── signal_detector.py # 感知层：对话信号检测器
│   ├── reflection/
│   │   └── analyzer.py      # 反思层：根因分析器
│   ├── consolidation/
│   │   ├── memory_store.py  # 存储层：SQLite + FTS5
│   │   └── skill_generator.py # 沉淀层：技能生成器
│   └── application/
│       └── retriever.py     # 应用层：记忆检索器
├── data/
│   ├── memories.db          # SQLite 数据库（运行后生成）
│   ├── observations.jsonl   # 观察日志（运行后生成）
│   └── skills/              # 技能 Markdown（运行后生成）
└── tests/
    └── test_engine.py       # 测试

Categorías de errores

encoding | build_error | runtime_error | test_failure | dependency | configuration | platform_specific | performance | security | best_practice | api_usage | preference | communication | other

Filosofía de diseño

• No depende de un LLM externo: la reflexión y el refinamiento de habilidades los realiza la parte llamante (el propio agente); el motor solo proporciona el marco y el almacenamiento

• Nativo de MCP: se ejecuta como un servidor MCP estándar; cualquier agente compatible con MCP puede conectarse directamente

• Colaboración humano-máquina: toda la memoria y las habilidades se almacenan en formatos legibles por humanos (Markdown, JSON), lo que facilita su revisión y mantenimiento

• Aprendizaje progresivo: de un error puntual → memoria episódica → memoria semántica → habilidad, con abstracción y refinamiento progresivos en cada capa