up

docs4/background.md

@@ -1,5 +0,0 @@
-核心的parser file store file graph file watcher 可以rust封装 特性之一高性能本地小数据库
-
-增加金融应用场景
-
-我们更加专注于知识加工而不是知识获取，结合qwepaw

docs4/background_backup.md

@@ -0,0 +1,157 @@
+ReMe新版本V4
+1. 目标： 构建个人知识库，集成qwenpaw等harness框架中，实现知识/记忆的自进化和自管理，结合graph高效搜索。
+2. 新的特性：
+   - 支持多种记忆类型，包括个性化记忆、程序化记忆、知识类记忆
+     - [❌ 待补充] 当前 reme4 中只有统一的 `FileNode/FileChunk` 抽象（`reme4/schema/file_node.py`、`reme4/schema/file_chunk.py`），尚未在代码层区分"个性化/程序化/知识类"三类记忆，需要在 schema 与 store 中扩展类型字段或子类。
+   - 支持memory-self-evolving
+     - [❌ 待补充] 没有发现自进化相关的 step/job 实现，目前只有基础的 search/reindex 等 common steps（`reme4/steps/common/`）。需要新增 auto-memory/auto-dream 等 step。
+   - 支持markdown之间的链接，构建graph，更好的渐进式展开
+     - [✅ 已实现 → `reme4/components/file_parser/linked_file_parser.py`（wikilink 解析 + Dataview 谓词）、`reme4/components/file_graph/`（local/nx/neo4j 三种 graph 后端）]
+     - [✅ 已实现 → `reme4/steps/common/search.py:109` `_expand_links`、`reme4/config/default.yaml:86` `expand_links` 参数（搜索结果可附 outlinks/inlinks 邻居元数据）]
+3. 工程实现：
+   1. components
+      - 支持backend切换
+        - [✅ 已实现 → `reme4/components/component_registry.py`（`R.register(name)` 装饰器 + `R.get(ctype, backend)` 查找）；`reme4/application.py:51` 通过 `config.components` 中的 `backend` 字段动态构造]
+      - 生命周期管理 start/close
+        - [✅ 已实现 → `reme4/components/base_component.py:151` `start()` / `:162` `close()` / `:172` `restart()`，含 `is_started` 幂等保护与 `asyncio.Lock`]
+      - components之间相互调用，支持前序依赖还是啥
+        - [✅ 已实现 → `reme4/components/base_component.py:78` `BaseComponent.bind()` 声明依赖（含 `optional`、`default_factory`），`:98` `_resolve_bindings()` 自动注入；`reme4/application.py:80` `_topological_order()` Kahn 算法做拓扑排序、检测循环依赖]
+   2. job/step，借鉴自github action
+      - step是最小的执行单元，可以自由使用components，不需要管理生命周期
+        - [✅ 已实现 → `reme4/steps/base_step.py`、`reme4/steps/common/`（demo/health_check/help/reindex/search/version/stream_demo 等内置 step）]
+      - job是steps的集合，可以自由组合，支持step复用
+        - [✅ 已实现 → `reme4/components/job/base_job.py`（顺序执行 step）、`reme4/components/job/stream_job.py`（流式 job）；`reme4/config/default.yaml:5` 通过 yaml 声明 job→steps 组合]
+      - 对外job可以封装cli命令，mcp_tool，http服务接口等
+        - [✅ 已实现（HTTP / MCP / CLI client） → `reme4/components/service/http_service.py:35` `_add_job` 把 job 注册成 POST 端点；`reme4/components/service/mcp_service.py`；`reme4/components/client/http_client.py`、`reme4/components/client/mcp_client.py`；`reme4/reme.py:27` `main()` 通过 CLI 子命令 `start` / `find_reme` / `<job_name>` 调用 client]
+   3. application：
+      - components的生命周期管理，通过前序依赖构建拓扑图启动应用
+        - [✅ 已实现 → `reme4/application.py:115` `_start()` 按拓扑顺序启动所有 component；`:133` `_close()` 反序关闭]
+      - 集成run_job
+        - [✅ 已实现 → `reme4/application.py:148` `run_job()` / `:154` `run_stream_job()`]
+      - 集成Service能力对外提供能力
+        - [✅ 已实现 → `reme4/application.py:170` `run_app()` 调用 `service.run_app(app=self)`；`reme4/components/service/base_service.py`]
+   4. 对外接口：
+      - skill.md + cli方案，通用方案，支持集成到各种harness框架中
+        - [⚠️ 部分实现] CLI 调用通道已具备（`reme4/reme.py:17` `call_server()` 通过 `http_client` / `mcp_client` 调任意已注册 job），但 [❌ 待补充] 仓库内未发现 `skill.md` 文件，需要为 Claude Code / 其它 harness 编写 skill 描述文件。
+        - 可以选择agent来启动reme服务（后台）
+          - [❌ 待补充] 未见"由 agent 自动拉起后台 reme 服务"的脚本/约定，需要补充进程托管或 launchctl/systemd 集成方案。
+      - skill.md + mcp-tool方案，通用方案
+        - [⚠️ 部分实现] MCP 服务通道存在（`reme4/components/service/mcp_service.py`、`reme4/components/client/mcp_client.py`），但 [❌ 待补充] 同样缺 `skill.md` 模板。
+        - 需要手动启动mcp服务
+          - [✅ 已实现 → `reme service` 模式可通过 `reme4/config/default.yaml:1` `service.backend: mcp` 切换，`reme4/reme.py` `start` 子命令拉起]
+      - sdk集成（qwenpaw集成）
+        - [❌ 待补充] reme4 内未见 qwenpaw / agentscope 相关适配代码（仅 `reme/`、`reme_ai/` 旧版有部分逻辑，但已废弃，按记忆 [[feedback_deprecated_directories]] 不应改动）。需要新建 `reme4/integrations/qwenpaw/` 之类的模块。
+        - str + 封装AgentscopeTools
+          - [❌ 待补充] 没有 `AgentscopeTools` 包装层。
+        - 集成auto-memory、auto-dream、auto-memory-search的能力
+          - [❌ 待补充] 三个能力均未实现。
+4. 记忆存储方案：
+   - resource：原始对话日志，上传的文件，原始的html文件等
+     - [❌ 待补充] `reme4/application.py:20` 仅创建 `metadata_dir` / `daily_dir` / `knowledge_dir`，未见 `resource_dir` 概念；需要在 `ApplicationConfig` 中加入并落地相应目录与抓取/上传逻辑。
+   - daily：
+     - daily/YYYYMMDD.md：主Agent调用write/edit工具修改，兼容上一版，同时承担了当天其他md的索引
+       - [⚠️ 部分实现] `reme4/application.py:23` 已建 `daily_dir`，但目录内 markdown 的"主索引"约定与 write/edit 兼容协议无显式实现，主要靠主 agent 自身行为。需要文档化 + 校验。
+     - daily/YYYYMMDD/{event}.md auto-memory 针对上下文对话，拆分成不同的事件存储，同时在YYYYMMDD.md构建好索引可以链接过来
+       - [❌ 待补充] auto-memory 拆事件的 step / job 不存在。
+   - knowledge:
+     - knowledge/{topic:-personal/agent/financial/work...}/{xxx}.md 在空闲时间整理记忆，按照主题和事件进行分类存储
+       - [⚠️ 部分实现] `knowledge_dir` 已建（`reme4/application.py:24`），但"按主题/事件整理"的后台任务、topic 枚举均缺失。
+   - proactive:
+     - proactive/YYYYMMDD.md 待定。如果存在给用户主动推送的能力，这里可以记录每一天agent给用户推荐的分析和心路历程。
+       - [❌ 待补充] 主动推送/proactive 目录与逻辑均未实现。
+5. Markdown 格式 & Build Graph
+   1. obsidian格式的Markdown文件格式
+      - front matter格式
+        - [✅ 已实现 → `reme4/components/file_parser/linked_file_parser.py:313` `frontmatter.loads(...)`；`reme4/schema/file_front_matter.py`]
+      - file link格式 4种格式
+        - [⚠️ 部分实现] `linked_file_parser.py:88` `_WIKILINK_RE` 已支持 `[[target]]` / `[[target#anchor]]` / `[[target|alias]]` / `![[target]]`（嵌入），并支持 Dataview `predicate:: [[X]]` 与 inline `[predicate:: [[X]]]`。但 [❌ 待补充] 标准 Markdown `[text](url.md)` 链接尚未被解析为 graph 边。
+   2. 更好的文件chunking机制
+      - 旧版 类似rag 带overlap的chunking机制
+        - [📌 历史] V3 旧逻辑，对照说明用，无需在 reme4 中实现。
+      - 解析 Markdown Ast
+        - [✅ 已实现 → `linked_file_parser.py:308` 使用 `mistletoe` 的 `Document`/`MarkdownRenderer`；`:335` `_build_tree` 把扁平 children 折叠成 section 嵌套树（`MdNode`）]
+      - 每一个chunk都带全部标题
+        - [✅ 已实现 → `linked_file_parser.py:381` `_chunk_node`（`before` 累积已经过的标题、`after` 拼剩余 desc_toc）；`:712` `_make_chunk` 用 `_toc_join(before, content, after)` 把全文目录骨架前后包裹]
+   3. 通过link构建graph索引，同时构建反向link索引
+      - [✅ 已实现 → `reme4/components/file_graph/base_file_graph.py`、`reme4/components/file_graph/local_file_graph.py`（含 `get_outlinks`、`get_inlinks` 双向索引）；nx/neo4j 后端同 API；`reme4/steps/common/search.py:114-129` 使用双向 link]
+   4. link的生成有两种，一种是主agent在生成link；另一种是通过后台任务，自动构建文档之间的link
+      - 介绍如何auto-link
+        - [⚠️ 部分实现] 主 agent 显式写 `[[link]]` 已经会被 parser 抓为边（`linked_file_parser.py:152` `_extract_links`）。但 [❌ 待补充] "后台任务自动补 link" 的实现（实体抽取 / 候选文档相似度匹配 / link 写回 markdown）尚不存在，需要单独的 step/job。
+6. 如何做memory自进化
+Auto-memory
+auto-dream
+   - [❌ 待补充] reme4 没有 auto-memory / auto-dream 任何代码。需要：
+     - 新增 step（如 `reme4/steps/auto_memory.py`、`reme4/steps/auto_dream.py`），基于现有 `BaseStep` + LLM component；
+     - 设计触发机制（job 调度、空闲检测）；
+     - 与上面的 daily/knowledge 目录约定打通。
+7. 更好的检索：
+   - 渐进式展开的检索
+     - [⚠️ 部分实现] `reme4/steps/common/search.py:14` `SearchStep` 已做 vector + keyword 的 RRF 融合，并支持 `expand_links` 一跳展开（outlinks/inlinks + 邻居 meta）。但 [❌ 待补充] "多跳渐进展开"、"按需要由 agent 主动展开下一层"的交互式 API 尚未实现。
+8. 结合外部的Agent工具：
+ReMe更加专注于知识加工，而不是知识获取
+- 结合qwenpaw
+  - sdk集成（qwenpaw集成）
+    - [❌ 待补充] 见 §3.4。
+  - str + 封装AgentscopeTools
+    - [❌ 待补充] 同上。
+  - 集成auto-memory、auto-dream、auto-memory-search的能力
+    - [❌ 待补充] 同上。
+- 结合其他的Agent框架
+  - skill.md + cli方案，通用方案，支持集成到各种harness框架中
+    - 可以选择agent来启动reme服务（后台）
+      - [❌ 待补充] 同 §3.4。
+  - skill.md + mcp-tool方案，通用方案
+    - 需要手动启动mcp服务
+      - [⚠️ 部分实现] MCP 服务可启动，但 skill.md 缺失。
+
+## 更好的性能，更稳定和兼容
+V4更加高效的底层记忆索引
+- V3版本基于sqlite/chroma等本地数据库
+  - 在qwenpaw等低版本linux & win系统存在兼容性问题，会存在core dump等问题
+  - 不支持关键词检索，这里需要Keyword倒排索引，对中文的支持较差
+  - [📌 历史] 描述 V3 痛点，不需要代码。
+- V4版本我们重写了file parser，file store，file graph，file watcher，手写了支持增量更新倒排索引
+  - file parser → [✅ `reme4/components/file_parser/`（base/bare/default/linked 四种）]
+  - file store → [✅ `reme4/components/file_store/local_file_store.py`]
+  - file graph → [✅ `reme4/components/file_graph/`（local/nx/neo4j）]
+  - file watcher → [✅ `reme4/components/file_watcher/lite_file_watcher.py` 基于 watchfiles awatch；`base_file_watcher.py` 抽象接口]
+  - 增量倒排索引 → [✅ `reme4/components/keyword_index/bm25_index.py`（增量 BM25）；`reme4/components/tokenizer/`（regex / jieba 两种 tokenizer，jieba 含 stopwords 子目录）]
+- 未来可以使用rust/c++重写，高性能本地知识引擎
+  - [📌 规划]
+
+## 知识库应用场景（重点）
+
+### 金融
+产业链
+   - [❌ 待补充] 没有领域 schema / 产业链知识图谱样例，需要写 demo 数据集 + topic 配置。
+
+### 自己的工作&生活
+xxxx
+   - [❌ 待补充] 文档本身就是占位，需要补充具体场景描述与对应的 daily/knowledge 目录样例。
+
+---
+
+## 标注小结
+
+### ✅ 已经在 `reme4/` 中实现的能力
+1. **组件框架**：backend 注册（`component_registry.py`）、生命周期（`base_component.py`）、依赖声明 + 拓扑启动（`application.py:80`）。
+2. **Job/Step 体系**：`components/job/base_job.py`、`components/job/stream_job.py`、`steps/base_step.py` 与 `steps/common/*`。
+3. **服务/客户端**：HTTP（`service/http_service.py` + `client/http_client.py`）、MCP（`service/mcp_service.py` + `client/mcp_client.py`），CLI 入口 `reme.py:main`。
+4. **Markdown 解析**：`file_parser/linked_file_parser.py`，含 frontmatter、wikilink + Dataview 谓词、AST 树、带全标题骨架的 chunking。
+5. **Graph**：`file_graph/{local,nx,neo4j}_file_graph.py`，双向链接索引。
+6. **存储 / 索引**：`file_store/local_file_store.py` + `keyword_index/bm25_index.py`（增量 BM25）+ `tokenizer/{regex,jieba}_tokenizer.py`。
+7. **文件监听**：`file_watcher/lite_file_watcher.py`（watchfiles 轮询）。
+8. **混合检索 + 一跳展开**：`steps/common/search.py`（vector + keyword RRF 融合，可附 outlinks/inlinks）。
+9. **Embedding / LLM 适配壳**：`components/embedding/openai_embedding_model.py`、`components/as_llm/`、`components/as_llm_formatter/`、`components/as_token_counter/`。
+
+### ❌ 需要额外补充的能力
+1. **记忆类型分层**：个性化 / 程序化 / 知识类的 schema 与路由。
+2. **memory-self-evolving**：auto-memory（拆事件→ daily/YYYYMMDD/{event}.md）、auto-dream（空闲整理→ knowledge/{topic}/）、对应触发器与调度。
+3. **存储目录约定**：`resource/`、`proactive/` 目录、daily 主索引协议、knowledge topic 枚举均未落地。
+4. **auto-link 后台任务**：自动从正文挖出实体并写回 wikilink。
+5. **多跳渐进展开检索 API**：当前只能一跳。
+6. **标准 Markdown `[text](url.md)` 链接**：尚未纳入 graph 边解析。
+7. **skill.md 模板**：CLI 与 MCP 两种集成方式都缺 skill 描述文件。
+8. **Agent 拉起后台 reme 服务**：缺脚本/约定。
+9. **qwenpaw / AgentScope SDK 集成**：包括 `AgentscopeTools` 包装层与 auto-memory/dream/search 暴露。
+10. **应用场景样例**：金融产业链、个人工作&生活的 demo 数据 + topic 配置。

docs4/reme4_index.md

@@ -0,0 +1,212 @@
+# reme4 代码模块索引
+
+> 本文档梳理 `reme4/` 下各能力模块、核心类和代码路径，便于快速定位与扩展。
+> 所有路径相对仓库根目录 `/Users/yuli/workspace/ReMe/`。
+
+## 1. 顶层入口与运行流程
+
+| 文件 | 作用 |
+| --- | --- |
+| `reme4/reme.py` | CLI 入口（`main()`）：`start` 启动应用；`find_reme` 探活；其他动作转发到 client。 |
+| `reme4/application.py` | `Application` 基类：解析 config → 注册 service / components / jobs → 拓扑排序启动 → `run_job` / `run_stream_job` / `run_app`。 |
+| `reme4/constants.py` | 服务发现常量：`REME_SERVICE_INFO`、默认 host/port (`127.0.0.1:2333`)。 |
+| `reme4/__init__.py` | 包入口。 |
+
+启动流程：`reme.main()` → `parse_args` → `resolve_app_config` → `precheck_start` → `ReMe(...).run_app()` → `service.run_app(app)` → `app.start()`（按拓扑序启动 components 与 jobs）。
+
+## 2. 配置与枚举
+
+| 文件 | 作用 |
+| --- | --- |
+| `reme4/config/default.yaml` | 默认配置：service / jobs / components 全套样例。 |
+| `reme4/config/config_parser.py` | `parse_args`、`resolve_app_config`、env 变量展开、点号配置覆盖、YAML/JSON 加载。 |
+| `reme4/enumeration/component_enum.py` | `ComponentEnum`：所有组件类型枚举（service/client/job/step/file_*/embedding/keyword_index/tokenizer/as_*）。 |
+| `reme4/enumeration/chunk_enum.py` | `ChunkEnum`：流式分块类型 (THINK/CONTENT/TOOL_*/USAGE/ERROR/DONE)。 |
+
+## 3. Schema（Pydantic 数据模型）
+
+代码：`reme4/schema/`
+
+| 类 | 文件 | 说明 |
+| --- | --- | --- |
+| `ApplicationConfig` / `ComponentConfig` / `JobConfig` | `application_config.py` | 顶层配置模型；包含 service/jobs/components/working_dir 等字段。 |
+| `EmbNode` | `emb_node.py` | 文本+embedding 节点基类，`np.ndarray` 序列化为列表存储。 |
+| `FileChunk` | `file_chunk.py` | 文件切片（继承 `EmbNode`）：`path/start_line/end_line/scores`，含 `set_hash_id()`。 |
+| `FileNode` | `file_node.py` | 文件级图节点：`path/st_mtime/links/chunk_ids/front_matter`。 |
+| `FileLink` | `file_link.py` | 文件间 wikilink 边：`source_path → target_path`，可选 `target_anchor` / `predicate`。 |
+| `FileFrontMatter` | `file_front_matter.py` | YAML 头：`title/description/tags`，`extra="allow"` 保留未知键。 |
+| `Request` / `Response` | `request.py` / `response.py` | 服务端请求/响应封装。 |
+| `StreamChunk` | `stream_chunk.py` | 流式分块：`chunk_type/chunk/done/metadata`。 |
+
+## 4. Components（核心能力组件）
+
+> 所有组件继承 `BaseComponent`（`reme4/components/base_component.py`），提供：
+> - `start/close/restart` 生命周期；
+> - `bind(name, base_cls, default_factory, optional)` 声明依赖（启动时通过拓扑排序解析）；
+> - `working_path` / `working_metadata_path` 工作目录；
+> - `dump/load` 持久化钩子。
+>
+> 组件通过 `ComponentRegistry`（`R`，`reme4/components/component_registry.py`）按 `(ComponentEnum, name)` 注册和查找；上下文容器为 `ApplicationContext`（`application_context.py`），运行期上下文为 `RuntimeContext`（`runtime_context.py`）。
+
+### 4.1 Tokenizer — `reme4/components/tokenizer/`
+
+| 类 | 文件 | 说明 |
+| --- | --- | --- |
+| `BaseTokenizer` | `base_tokenizer.py` | 抽象基类，启动时加载 `stopwords` 文件。 |
+| `RegexTokenizer` (`@R "regex"`) | `regex_tokenizer.py` | 正则切词；中文按字符切分，非中文按词切分。 |
+| `JiebaTokenizer` (`@R "jieba"`) | `jieba_tokenizer.py` | 基于 jieba 的中文分词。 |
+
+### 4.2 Keyword Index — `reme4/components/keyword_index/`
+
+| 类 | 文件 | 说明 |
+| --- | --- | --- |
+| `BaseKeywordIndex` | `base_keyword_index.py` | 抽象基类：`add_docs/delete_docs/retrieve/clear/optimize_index`，依赖 tokenizer。 |
+| `BM25Index` (`@R "bm25"`) | `bm25_index.py` | 自实现 Okapi BM25 倒排索引：`vocab` / `inverted_index` / `doc_meta`，pickle 持久化，支持增量更新与 `optimize_index` 紧凑化。 |
+
+### 4.3 Embedding — `reme4/components/embedding/`
+
+| 类 | 文件 | 说明 |
+| --- | --- | --- |
+| `BaseEmbeddingModel` | `base_embedding_model.py` | LRU 缓存 + npz 磁盘持久化、批量、重试、健康检查（`is_healthy`）；提供 `get_embedding/get_embeddings/get_node_embeddings`。 |
+| `OpenAIEmbeddingModel` (`@R "openai"`) | `openai_embedding_model.py` | OpenAI 兼容协议（dashscope/qwen 等），`AsyncOpenAI` 客户端。 |
+
+### 4.4 File Graph — `reme4/components/file_graph/`
+
+存储 `FileNode` 节点与 `FileLink` 边，支持「虚节点」(被指但尚未导入的目标占位)。
+
+| 类 | 文件 | 说明 |
+| --- | --- | --- |
+| `BaseFileGraph` | `base_file_graph.py` | 抽象接口：`upsert_nodes/delete_nodes/get_nodes/rebuild_links/clear/get_outlinks/get_inlinks`。 |
+| `LocalFileGraph` (`@R "local"`) | `local_file_graph.py` | 纯 dict 实现 + JSONL 持久化；维护 `_nodes`/`_inverse`/`_pending`。 |
+| `NxFileGraph` (`@R "nx"`) | `nx_file_graph.py` | networkx `MultiDiGraph` + pickle 持久化，虚节点用「无 node 属性」标识。 |
+| `Neo4jFileGraph` (`@R "neo4j"`) | `neo4j_file_graph.py` | Neo4j 后端（bolt 驱动），`(:File)-[:LINKS]->(:File)`，支持升降级虚节点、`rebuild_links` 修复重建。 |
+
+### 4.5 File Parser — `reme4/components/file_parser/`
+
+| 类 | 文件 | 说明 |
+| --- | --- | --- |
+| `BaseFileParser` | `base_file_parser.py` | 抽象接口：`parse(path) -> (FileNode, list[FileChunk])`，提供 `_get_relative_path`。 |
+| `BareFileParser` (`@R "bare"`) | `bare_file_parser.py` | 仅 stat：附件/二进制不读内容、不切块、不抽链接。 |
+| `DefaultFileParser` (`@R "default"`) | `default_file_parser.py` | 字节级带 overlap 切片 + YAML front matter + wikilink 抽取（含 Dataview `predicate::`）。 |
+| `LinkedFileParser` (`@R "md"`) | `linked_file_parser.py` | Markdown 专用：mistletoe AST → MdNode 树 → 章节递归分块；每个 chunk 携带完整 heading skeleton（TOC）；wikilink 解析支持隐式 `.md`、folder-note、短路径歧义扇出，需注入 `file_graph` 解析目标。 |
+
+### 4.6 File Store — `reme4/components/file_store/`
+
+聚合 `embedding_model` + `keyword_index` + `file_graph`，统一 chunk 写入与混合检索。
+
+| 类 | 文件 | 说明 |
+| --- | --- | --- |
+| `BaseFileStore` | `base_file_store.py` | 抽象基类：`upsert_file/delete_by_path/clear/vector_search/keyword_search/rebuild_links/get_nodes/get_outlinks/get_inlinks`；启动时探活 embedding，失败则降级为纯关键字检索。 |
+| `LocalFileStore` (`@R "local"`) | `local_file_store.py` | 内存 chunk 字典 + JSONL 持久化；upsert 时复用旧 chunk 的 embedding（按 chunk.id 命中）；`vector_search` 用 `batch_cosine_similarity`，`keyword_search` 委托给 keyword_index。 |
+
+### 4.7 File Watcher — `reme4/components/file_watcher/`
+
+| 类 | 文件 | 说明 |
+| --- | --- | --- |
+| `BaseFileWatcher` | `base_file_watcher.py` | 抽象接口：`watch_loop/update_store/on_added/on_modified/on_deleted`；启动后台任务先做一次全量同步再进入监听循环。 |
+| `LiteFileWatcher` (`@R "lite"`) | `lite_file_watcher.py` | 基于 `watchfiles.awatch` 的轮询监听；变更分类后调用 file_parser 解析、写 file_store；`update_store` 通过 mtime 对比做增量。 |
+
+### 4.8 Job — `reme4/components/job/`
+
+| 类 | 文件 | 说明 |
+| --- | --- | --- |
+| `BaseJob` (`@R "base"`) | `base_job.py` | 顺序执行 `steps`：每个 step 共享 `RuntimeContext`，最终返回 `Response`；启动时把 step config 实例化为 `BaseStep`。 |
+| `StreamJob` (`@R "stream"`) | `stream_job.py` | 流式执行：异常包装为 ERROR chunk，结束时 emit DONE 终止流。 |
+
+### 4.9 Service — `reme4/components/service/`
+
+把 jobs 暴露给外部协议。
+
+| 类 | 文件 | 说明 |
+| --- | --- | --- |
+| `BaseService` | `base_service.py` | 抽象接口：`build_service/add_job/start_service`，`run_app` 串起来。 |
+| `HttpService` (`@R "http"`) | `http_service.py` | FastAPI + uvicorn；普通 job → POST JSON 端点，stream job → SSE 流；CORS 全开。 |
+| `MCPService` (`@R "mcp"`) | `mcp_service.py` | FastMCP；把 job 注册为 MCP `FunctionTool`（StreamJob 跳过）；transport 支持 sse/stdio/streamable-http。 |
+
+### 4.10 Client — `reme4/components/client/`
+
+| 类 | 文件 | 说明 |
+| --- | --- | --- |
+| `BaseClient` | `base_client.py` | 抽象接口：`__call__` 分发 `list`/`_execute`，`list_actions` 列出 server 能力。 |
+| `HttpClient` (`@R "http"`) | `http_client.py` | httpx 异步流式：根据 `Content-Type` 自适应 JSON/SSE；`/openapi.json` 列出 actions；CLI 友好格式化。 |
+| `MCPClient` (`@R "mcp"`) | `mcp_client.py` | fastmcp Client 包装；transport=`sse/stdio/streamable-http`；`list_tools` 列出工具。 |
+
+### 4.11 AgentScope 适配（as_*） — `reme4/components/as_*/`
+
+把 AgentScope 的 LLM / Formatter / TokenCounter 包成 ReMe 组件，供 step 通过 `step.as_llm` / `step.as_llm_formatter` / `step.as_token_counter` 访问。
+
+| 类 | 文件 | 说明 |
+| --- | --- | --- |
+| `BaseAsLLM` / `OpenAIAsLLM` (`openai`) / `AnthropicAsLLM` (`anthropic`) | `as_llm/__init__.py` | 包装 `agentscope.model.OpenAIChatModel / AnthropicChatModel`，启动时实例化 `self.model`。 |
+| `BaseAsLLMFormatter` / `AsOpenAIChatFormatter` (`openai`) / `AsAnthropicChatFormatter` (`anthropic`) | `as_llm_formatter/__init__.py` | 包装 AgentScope formatter；OpenAI 版用 `ReMeOpenAIChatFormatter` 扩展 |
+| `ReMeOpenAIChatFormatter` | `as_llm_formatter/reme_openai_chat_formatter.py` | OpenAI formatter 扩展：tool_result 中的 image 提升为 user 消息；thinking 块合并为 `reasoning_content`；新增 video block 支持。 |
+| `BaseAsTokenCounter` / `EstimatedAsTokenCounter` (`estimated`) | `as_token_counter/__init__.py` | 字符级估算 token 计数器（`encoded_byte_len / divisor`）。 |
+| `EstimatedTokenCounter` | `as_token_counter/estimate_token_counter.py` | 实现类。 |
+
+### 4.12 Prompt Handler — `reme4/components/prompt_handler.py`
+
+`PromptHandler`：YAML/JSON 加载或类同名文件加载；多语言后缀（`key_zh/key_en`）；`prompt_format` 支持 `[flag]` 行级条件、`{var}` 参数校验。
+
+## 5. Steps（最小执行单元）
+
+代码：`reme4/steps/`
+
+| 类 | 注册名 | 文件 | 作用 |
+| --- | --- | --- | --- |
+| `BaseStep` | — | `base_step.py` | 抽象基类：`execute()` + `RuntimeContext` 注入 + `input/output_mapping` + 通过 `_resolve` 自动取组件（`as_llm/as_llm_formatter/as_token_counter/file_parser/file_store/embedding/file_watcher`）；`add_as_tool(toolkit, job_name)` 把 job 包成 AgentScope tool。 |
+| `DemoEchoStep1/2` | `demo_echo_step1` / `demo_echo_step2` | `common/demo.py` | 烟雾测试：query 处理 + 应答。 |
+| `HealthCheckStep` | `health_check_step` | `common/health_check.py` | 各组件健康/规模快照（embedding/file_graph/file_store/file_watcher/keyword_index）+ 内存深度估算。 |
+| `HelpStep` | `help_step` | `common/help.py` | 一行式列出全部 job 元信息（含参数 schema）。 |
+| `ReindexStep` | `reindex_step` | `common/reindex.py` | 全量重建：停 watcher → clear store → `update_store` → 重启 watcher。 |
+| `SearchStep` | `search_step` | `common/search.py` | 混合检索：vector_search + keyword_search 并发 → RRF 融合 → 阈值过滤 → 截断 → 可选 outlinks/inlinks 邻居展开（含元数据）。 |
+| `StreamDemoStep1/2` | `stream_demo_step1` / `stream_demo_step2` | `common/stream_demo.py` | 流式烟雾测试：逐字符 emit CONTENT。 |
+| `VersionStep` | `version_step` | `common/version.py` | 输出 `reme4.__version__`。 |
+
+## 6. Utils — `reme4/utils/`
+
+| 文件 | 主要导出 |
+| --- | --- |
+| `common_utils.py` | `hash_text`(SHA-256)、`execute_stream_task`(SSE 流转发)、`mock_reme_server`(子进程启动测试服务器)、`call_action` / `call_and_check`(HTTP 调用与断言)。 |
+| `service_utils.py` | `find_reme` / `locate_reme` / `precheck_start` / `cli_find_reme`：服务发现，`lsof` + `pgrep` 扫描运行实例，端口冲突预检。 |
+| `env_utils.py` | `load_env`：加载 `.env`。 |
+| `logger_utils.py` | `get_logger`：loguru 日志（控制台 + 文件）。 |
+| `logo_utils.py` | `print_logo`：启动 ASCII logo。 |
+| `similarity_utils.py` | `cosine_similarity` / `batch_cosine_similarity`：numpy 向量相似度。 |
+
+## 7. 内置 Jobs（`reme4/config/default.yaml`）
+
+| Job | Backend | 步骤 | 说明 |
+| --- | --- | --- | --- |
+| `demo` | `base` | `demo_echo_step1` → `demo_echo_step2` | 端到端 demo。 |
+| `version` | `base` | `version_step` | 返回包版本。 |
+| `health_check` | `base` | `health_check_step` | 组件健康快照。 |
+| `help` | `base` | `help_step` | 列出全部 job。 |
+| `reindex` | `base` | `reindex_step` | 全量重建索引。 |
+| `search` | `base` | `search_step` | 混合检索（vector+keyword RRF，可展开邻居）。 |
+| `stream_demo` | `stream` | `stream_demo_step1` → `stream_demo_step2` | 流式 demo。 |
+
+## 8. 默认依赖关系（来自 `default.yaml`）
+
+```
+tokenizer (regex)        ──┐
+embedding_model (openai) ──┤── file_store (local) ── file_watcher (lite)
+file_graph (local)       ──┤            (持有 embedding/keyword_index/file_graph)
+file_parser (default)    ──┘                                    │
+keyword_index (bm25)  ── tokenizer ──────────────┘              │
+                                                  file_parser ──┘
+```
+
+启动时由 `Application._topological_order()`（Kahn 算法）按依赖拓扑序启动；关闭时反向。
+
+## 9. 扩展点速查
+
+| 需求 | 入口 |
+| --- | --- |
+| 新增检索后端 | 实现 `BaseFileStore` 子类，`@R.register("xxx")` |
+| 新增图后端 | 实现 `BaseFileGraph` 子类（参考 `Neo4jFileGraph` 处理虚节点） |
+| 新增分词器 | 实现 `BaseTokenizer.tokenize` |
+| 新增解析器 | 实现 `BaseFileParser.parse`（返回 `(FileNode, list[FileChunk])`） |
+| 新增 Job | 在 `default.yaml`（或自定义 yaml）`jobs:` 段声明 + 写步骤实现 |
+| 新增 Step | 继承 `BaseStep`，实现 `execute()` 并 `@R.register("xxx_step")` |
+| 暴露新协议 | 实现 `BaseService`（参考 `HttpService` / `MCPService`） |
+| 接入新 LLM | 实现 `BaseAsLLM` 子类（`agentscope.model` 适配） |

docs4/reme4_report.md

@@ -0,0 +1,574 @@
+# ReMe 新版本：可自进化的个人知识与记忆引擎
+
+> 面向 Leader / 决策者的能力报告
+> 关键词：个人知识库 · 记忆自进化 · 多模检索 · Agent 接入 · 本地优先
+
+---
+
+## 一、引言：为什么要做新版本
+
+### 1.1 ReMe 新版本 的一句话定位
+
+> **ReMe 是一个把本地 Markdown 自进化成知识图谱的个人记忆引擎。**
+
+这句话的内在逻辑是**递进**而非并列——三个支柱按"载体 → 机制 → 结果"层层咬合：
+
+- **本地 Markdown（载体）** → 所有记忆都是普通 .md 文件，用户可读、可备份、可迁移，Obsidian 直接打开，对抗黑盒。
+- **自进化（机制）** → 不需要用户手工整理，Agent 在后台让笔记自己长出结构。这一点把 ReMe 同时与"手动建图的 Obsidian"和"扁平存储的
+  Mem0"拉开。
+- **知识图谱（结果）** → 自进化的产出物不是一堆扁平笔记，而是一张通过 wikilink 互相串联、可视化浏览、可多模检索的图。
+
+它同时**可被任意 Agent / Harness 框架接入**——qwenpaw、Claude Code、Cursor 都可以把 ReMe 当作能力调用，不绑定任何特定 Agent
+产品。
+
+### 1.2 为什么是现在：Agent 时代的记忆缺口
+
+模型能力快速趋同的当下，差异化已经从模型本身转移到**「这个 Agent 是不是了解我」**
+：它知不知道我的工作背景、过往项目、失败教训？能不能记住我半年前提过的偏好，并在今天的对话里自然用上？
+
+**模型是大家共享的，记忆是每个用户独有的。** 长期、可信、可进化的个人记忆，才是 Agent 时代真正的差异化护城河。
+
+而当前业界的记忆方案 —— 无论是 Memo、Mem0 还是 Letta —— 都存在三个共性问题，正好对应 ReMe 新版本 的三个核心主张：
+
+| 业界痛点                              | ReMe 新版本 的回应                                         |
+|-----------------------------------|------------------------------------------------------|
+| **黑盒不可读**：记忆存在专有数据库里，用户看不到、改不了    | 本地 Markdown，Obsidian 直接打开                            |
+| **不可移植**：换 Agent 框架就要重新积累，记忆被产品锁死 | 任意 Harness 接入，记忆跟着用户走                                |
+| **缺乏自进化**：只是写入 + 检索，不会自己整理、归类、关联  | auto-memory / auto-dream / auto-link 三件套合力长成可浏览的知识图谱 |
+
+### 1.3 老版本 → 新版本的关键升级
+
+| 维度         | 老版本                  | 新版本                                              |
+|------------|----------------------|--------------------------------------------------|
+| 记忆动作       | 只是把对话存下来             | 主动整理、归档、关联，长成可浏览的知识图谱                            |
+| 检索方式       | 单一向量检索               | 向量 + 关键词（中文 BM25）+ 图谱 多模融合                       |
+| 与 Agent 关系 | ReMe 内置 Agent        | ReMe 作为能力被 qwenpaw / Claude Code / 其它 Harness 接入 |
+| 底层依赖       | sqlite / chroma 等三方库 | 自研轻量内核，跨平台稳定                                     |
+| 数据格式       | 内部数据库                | Obsidian 兼容的 Markdown 文件                         |
+
+---
+
+## 二、产品全景图
+
+### 2.1 一张图看 ReMe 新版本
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  外部 Agent / Harness                                   │
+│  qwenpaw · Claude Code · Cursor · 其它                  │
+└──────────┬──────────────┬───────────────┬───────────────┘
+           │ SDK          │ MCP Tool      │ CLI / skill.md
+┌──────────▼──────────────▼───────────────▼───────────────┐
+│                ReMe Service Layer                        │
+│   HTTP / MCP / CLI · 服务发现 · 进程托管                 │
+├─────────────────────────────────────────────────────────┤
+│                ReMe Job/Step 编排                        │
+│   search · auto_memory · auto_dream · auto_link …       │
+├─────────────────────────────────────────────────────────┤
+│        Markdown 知识内核（本地文件即数据库）              │
+│   FileParser · FileStore · FileGraph · FileWatcher      │
+│   BM25 倒排 · 向量索引 · Wiki Link 图谱                 │
+├─────────────────────────────────────────────────────────┤
+│        文件目录约定                                      │
+│   resource/ · daily/ · knowledge/ · proactive/          │
+└─────────────────────────────────────────────────────────┘
+```
+
+四层结构从上到下：
+
+- **接入层**：让任何 Agent 框架都能用。
+- **服务层**：HTTP / MCP / CLI 三种协议同时暴露，按 Harness 需求选用。
+- **编排层**：把能力拆成 Job/Step，可组合、可流式。
+- **内核层**：Markdown 解析、存储、图谱、监听一体化。
+- **目录层**：用户最直观看到的文件夹结构，本身就是 ReMe 的"产品形态"。
+
+### 2.2 三个最直观的故事场景
+
+**场景一：金融分析师的产业链知识库**
+盘后，分析师和 Agent 对话讨论今天看到的几条新能源新闻。第二天打开知识库，发现昨天的对话已经被自动拆分成「钴价波动」「下游电池厂动向」「上游矿企并购」三条事件笔记，分别归档到
+`knowledge/产业链/` 下相应主题；笔记之间通过 `[[钴]]` `[[宁德时代]]` 这样的 wikilink 互相串联。下周再问"钴的下游应用"，ReMe
+沿着图谱渐进展开，从一个节点跳到相关的全部上下文。
+
+**场景二：个人工作 & 生活第二大脑**
+日常对话、会议讨论、学习笔记都被主 Agent 实时写入 daily 笔记。夜晚 Agent 空闲时，ReMe 在后台把零散的 daily 内容按"
+客户/项目/学习/生活"主题重新整理到 knowledge 库，并自动补全笔记之间的链接。三个月后，用户拥有一份完全属于自己的、可视化的"
+第二大脑"，可以用 Obsidian 直接打开浏览。
+
+**场景三：Agent 框架开箱接入**
+开发者在 qwenpaw 或 Claude Code 中安装 ReMe，不需要改 Agent 一行代码 —— Agent 立刻拥有"长期记忆 + 个人知识检索 +
+自动整理"三项能力。SDK 集成是无感的：每次对话自动落入 daily，每次检索自动走多模融合，每天空闲自动整理归档。
+
+---
+
+## 三、记忆模型：ReMe 把什么存下来
+
+### 3.1 四类记忆分层
+
+ReMe 不把对话一股脑塞进数据库，而是让记忆**像人脑一样有层次**：
+
+| 类型                  | 存什么                       | 典型场景                 |
+|---------------------|---------------------------|----------------------|
+| **Resource（原始资料）**  | 原始对话日志、上传的文件、网页 HTML、邮件附件 | 溯源 / 审计 / 二次加工       |
+| **Daily（日记记忆）**     | 每天的事件性记忆，主 Agent 实时写入     | "我今天和谁聊了什么"、"今天工作内容" |
+| **Knowledge（知识记忆）** | 主题化、结构化的长期知识              | "光伏产业链"、"我的工作框架"     |
+| **Proactive（主动推送）** | Agent 给用户的分析、推荐、心路历程      | 主动提醒、复盘建议、洞察记录       |
+
+短期日记、长期知识、原始素材、主动洞察各司其职 —— 这是 ReMe 区别于"对话历史搜索"类方案的根本差异。
+
+### 3.2 三种记忆的覆盖
+
+正交于上面的"层次"，按"内容性质"也分三类：
+
+- **个性化记忆** — 用户的偏好、习惯、个人事件（"用户喜欢简洁回复"、"昨天去了上海"）
+- **程序化记忆** — Agent 完成任务的过程性经验（"修这类 bug 通常先看日志"、"上次部署失败因为环境变量"）
+- **知识类记忆** — 客观知识、领域参考资料（"产业链结构"、"框架文档"）
+
+不同类型的记忆在写入策略、检索权重、过期规则上都会有差异化处理。
+
+### 3.3 目录约定（用户可读、可备份、可迁移）
+
+```
+~/reme_workspace/
+├── resource/              # 原始素材
+│   └── 2026-05-18-conversation.json
+├── daily/
+│   ├── 20260518.md        # 当天主索引（兼容 write/edit）
+│   └── 20260518/
+│       ├── meeting-with-alice.md
+│       ├── debug-login.md
+│       └── reading-paper.md
+├── knowledge/
+│   ├── personal/
+│   ├── work/
+│   ├── financial/
+│   │   ├── 光伏产业链.md
+│   │   └── 钴.md
+│   └── agent/
+└── proactive/
+    └── 20260518.md        # Agent 主动产出的建议
+```
+
+**所有记忆都是普通 Markdown 文件**，用户随时可以：
+
+- 用 Obsidian / Typora / VSCode 打开浏览编辑
+- 用 Git / iCloud / 网盘做版本控制和跨设备同步
+- 迁移到任何机器，复制目录即可
+- **没有黑盒数据库，没有产品锁定**
+
+这一点对 Leader 视角尤其重要：用户对自己数据的掌控感，是所有"个人记忆"产品的信任基础。
+
+---
+
+## 四、记忆的自进化（核心差异化）
+
+> 这是新版本最重要的能力，也是和市面所有「记忆即数据库」产品的根本分野。
+>
+> **ReMe 的记忆不是被动存的，是主动长成知识图谱的。**
+
+定位句中"自进化成知识图谱"的具体路径，由下面三件套共同承担：**auto-memory** 在前线把对话拆成事件，**auto-dream**
+在空闲时把事件归档成主题，**auto-link** 把这一切用 wikilink 串成图。三者协作，daily 流水最终被织成一张越用越密的个人知识图谱。
+
+### 4.1 Auto-Memory：实时拆事件
+
+主对话进行时，ReMe 在后台把上下文按"事件"自动拆分：
+
+- 用户和 Agent 的连续对话，被识别为若干个独立事件（一次会议、一次 debug、一次学习）。
+- 每个事件成为一个独立的 `daily/YYYYMMDD/{event}.md` 笔记。
+- 同时在 `daily/YYYYMMDD.md` 维护主索引，所有事件可被反向追溯。
+
+**用户体验**
+：不需要手动整理。打开当天主索引，事件已经分章节列好，每条都能跳转到独立笔记。这就像有一个秘书在你说话的同时帮你做"
+会议纪要的分章节"。
+
+### 4.2 Auto-Dream：空闲整理
+
+借鉴人在睡眠中"记忆巩固"的机制：
+
+- Agent 检测到空闲（夜晚、用户离开、长时间无交互）时触发。
+- 把若干天的 daily 笔记按主题、实体重新组织到 `knowledge/{topic}/` 下。
+- 抽取共性、合并重复、生成总结。
+
+**用户体验**：第二天打开知识库，会发现昨天散落在不同对话里的内容已经按"客户/项目/学习"自动归档，关键概念已经被抽成独立的主题笔记。
+
+这是 ReMe 区别于"对话历史搜索"的关键 —— **它会自己整理**。
+
+### 4.3 Auto-Link：自动建图
+
+后台任务自动从正文里识别实体、候选链接，把隐式关系写回 wikilink：
+
+- 在「光伏产业链」笔记里提到「隆基」，ReMe 自动补 `[[隆基]]` 链接到对应主题笔记。
+- 在 daily 事件里提到「Alice」，自动链到 `[[Alice]]` 个人档案。
+- 生成的 link 是可见的、可编辑的（写在 Markdown 文件里），用户随时可以修正。
+
+**用户体验**：知识库随时间自然"越长越密"。浏览时可以从任意一处跳转到相关全部上下文，类似于在自己的脑子里"联想"。
+
+### 4.4 三者协同：从对话到知识图谱的自然演化
+
+```
+[实时]                    [离线]                    [持续]
+原始对话  ─Auto-Memory─►  daily 事件  ─Auto-Dream─►  knowledge 主题
+                                            │
+                                       Auto-Link
+                                            │
+                                            ▼
+                                       知识图谱
+```
+
+整个过程**不需要用户操心**。用户只需要正常和 Agent
+对话，三个月后回头看，就有了一张按主题组织、互相关联、可视化浏览的个人知识图谱——这就是一句话定位里"自进化成知识图谱"的物理产物。
+
+---
+
+## 五、检索体验：多模检索 + 渐进式展开
+
+### 5.1 三路融合的混合检索
+
+ReMe 新版本 同时跑三种检索通路，结果通过 RRF（Reciprocal Rank Fusion）排序融合：
+
+- **向量检索** —— 捕捉语义相似度（"钴" ≈ "锂电正极原料"）
+- **关键词检索（BM25）** —— 精确匹配，对中文友好（"宁德时代" 一定要命中）
+- **图谱检索** —— 通过 wikilink 邻居展开（找到"钴" → 自动带上"刚果(金)"、"嘉能可"）
+
+单一通路都有盲区：
+
+- 纯向量 → 名词术语容易错配。
+- 纯关键词 → 同义改写抓不到。
+- 纯图谱 → 起点选错就全盘错。
+
+三路融合让检索像"三个人各自查一遍再开会确认"，结果鲁棒得多。
+
+### 5.2 渐进式展开
+
+传统 RAG 是一次性把 top-K 切片塞进上下文，token 利用率低，而且经常带进不相关的噪音。ReMe 的检索（`reme4/steps/common/search.py`）是**分跳**的，且每一跳的"信息密度"刻意不同：
+
+- **第一跳：直接命中的切片**——返回 chunk 全文 + 章节骨架。
+- **第二跳：1-hop 邻居**——只返回邻居的 path + meta（title/tags）+ 边的语义（predicate/anchor），**不展开正文**。
+- **第 N 跳：Agent 主动追问**——基于二跳的"目录"，挑出真正相关的邻居，再发起新一次 search 拿正文。
+
+#### 一个具体例子：分析师查询"钴的下游应用"
+
+第一跳直接命中 `knowledge/产业链/钴.md` 的某一段切片，answer 里这一段长这样：
+
+```
+========== knowledge/产业链/钴.md:42-78 [score=0.0234 vector=0.0123 keyword=0.0111] ==========
+# 钴
+## 应用
+钴是锂电正极材料的关键原料，主要用于动力电池、消费电子和储能……
+
+  → outlinks (3):
+    → knowledge/矿产/刚果(金).md  title="刚果(金) - 钴矿主产区"  tags=['矿产', '非洲']
+        via predicate=producer, anchor=#钴矿带
+    → knowledge/公司/嘉能可.md  title="嘉能可 Glencore"  tags=['矿企', '海外']
+        via plain
+    → knowledge/产品/三元正极.md  title="三元正极材料"  tags=['锂电', '正极']
+        via predicate=downstream
+  ← inlinks (2):
+    ← knowledge/产业链/锂电产业链.md  title="锂电产业链总览"  tags=['新能源', '锂电']
+        via predicate=upstream
+    ← daily/20260318/宁德调研纪要.md  title="宁德时代调研纪要"  tags=['公司调研']
+        via plain
+```
+
+注意第二跳的信息只有"路径 + 标题 + 标签 + 边的 predicate/anchor"，**没有邻居正文**。这是关键设计：
+
+- 一次检索就让 Agent 看到"这个主题周围长什么样"——上游是刚果(金)、嘉能可，下游是三元正极，被锂电产业链当作 upstream 引用，最近还在 3 月 18 日的宁德调研里被提到。
+- Agent 可以基于这份"目录"判断哪个邻居才是用户真正想要的，再调一次 search 拉对应文件的正文（比如挑 `三元正极.md` 的细节）。
+
+#### 为什么不一次把邻居正文也带回来
+
+如果第二跳直接返回正文，三跳网络很容易把上下文撑爆。当前实现里 `max_links_per_direction` 默认 10，单跳最多吐出 10 个 outlink + 10 个 inlink 的 meta，每条只占一行，**整张二跳目录的成本不到一个 chunk 的 token**。
+
+#### 工程层面的关键参数
+
+- `candidate_multiplier=3.0`：候选池预拉 `limit*3` 条（最多 200），给 RRF 融合留余量。
+- `min_score`：过低分切片直接丢弃，避免噪音。
+- `expand_links=True`：开关二跳展开；关闭则退化为传统 RAG。
+- `max_links_per_direction=10`：单方向（出/入）最多展示几个邻居，防爆。
+
+**用户体验**：检索像"翻知识网络"——先看一眼周边目录，再决定要不要深入某一条线，而不是"拉一坨切片塞进上下文"。
+**工程价值**：上下文窗口永远只装最相关的部分，token 成本可控；Agent 也能更精确地解释"我为什么知道这个"——因为它能引用 predicate=upstream、anchor=#应用 这种带语义的边。
+
+### 5.3 关键词索引的工程价值
+
+很多人忽视：**做中文知识库，关键词检索比向量更重要**。
+
+ReMe 新版本 自研增量 BM25 倒排索引，配合 jieba 中文分词：
+
+- 增量更新：新增/删除文件无需重建全索引。
+- 跨平台：纯 Python + 文件落盘，没有 sqlite/chroma 这类原生扩展。
+- 这一点直接解决了老版本在 qwenpaw 等老旧 Linux/Win 系统上的 core dump 兼容问题。
+
+---
+
+## 六、Markdown 内核：把文件当数据库
+
+### 6.1 Obsidian 兼容的 Markdown 格式
+
+ReMe 没有发明新格式，而是完全复用 Obsidian 生态的约定：
+
+- **YAML front matter**：标题、标签、描述、自定义字段。
+
+  ```markdown
+  ---
+  title: 光伏产业链研究
+  description: 从硅料到组件的全链条梳理
+  tags: [新能源, 光伏, 产业链]
+  parent: 新能源
+  author: 张三
+  updated: 2026-05-19
+  ---
+
+  # 正文从这里开始
+  ```
+
+  `title` / `description` / `tags` 是约定字段（参见 `reme4/schema/file_front_matter.py`），其余键值对作为 extras
+  全部保留，可被检索和图索引消费。
+
+- **4 种 wikilink 写法**：
+    - `[[X]]`：标准链接
+    - `[[X#anchor]]`：链接到文件中的章节
+    - `[[X|alias]]`：自定义显示文本
+    - `![[X]]`：嵌入引用
+- **Dataview 风格语义关系**：`predicate:: [[X]]`，例如 `parent:: [[新能源]]`、`founder:: [[张三]]`，把 link 升级为带类型的"
+  边"。
+- 标准 `[text](xxx.md)` 链接也会被识别为图边。
+
+**意义**：用户的知识库可以直接用 Obsidian 打开做可视化浏览，可以用 Obsidian 插件做扩展。ReMe 不是替代 Obsidian，而是**给
+Obsidian 加上一个会自己写笔记的 Agent**。
+
+### 6.2 比 RAG 更聪明的切片
+
+传统 RAG 用固定 token 长度 + overlap 切片，经常切坏文档结构。ReMe 用 Markdown AST 切片：
+
+- 解析为章节嵌套树（按 H1/H2/H3 分层）。
+- 按章节边界递归切分，保留语义完整性。
+- **每个 chunk 自带完整的标题骨架（TOC）**：检索回来的片段一眼就能看出"这段在哪个章节、什么主题下"。
+
+```
+某 chunk 实际内容长这样：
+─────────────────────
+# 光伏产业链
+## 上游：硅料
+### 多晶硅工艺
+[chunk 正文]
+## 中游：硅片
+## 下游：组件
+─────────────────────
+```
+
+Agent 拿到这个 chunk，立刻知道层级位置，不会断章取义。
+
+### 6.3 Graph 索引：双向链接
+
+定位句里"自进化成**知识图谱**"的物理形态，就落在这一节——每个文件参与两套索引：
+
+- **正向（outlinks）**：A → B（A 引用了 B）
+- **反向（inlinks）**：B ← {A, C, D}（谁引用了 B）
+
+**反向链接**是知识库可用性的关键 —— 让你站在任意一个概念上，看到"还有哪些地方提到过我"。
+
+ReMe 提供三种 graph backend，按规模和需求切换：
+
+- **本地 dict + JSONL**：轻量、零依赖、适合个人规模。
+- **NetworkX + pickle**：方便做图算法分析。
+- **Neo4j**：企业规模、Cypher 查询、可视化丰富。
+
+切换只需配置一行。
+
+---
+
+## 七、工程架构：可扩展、可替换、可演进
+
+### 7.1 Component 框架
+
+ReMe 把所有能力封装为 Component：
+
+```
+embedding · file_store · file_graph · file_parser · file_watcher
+tokenizer · keyword_index · LLM 适配 · service · client
+```
+
+每个 Component 都可以：
+
+- **Backend 热切换**：`local` ↔ `nx` ↔ `neo4j` 一行配置改完。
+- **生命周期托管**：start / close / restart 全自动，幂等保护。
+- **依赖声明**：组件间相互调用，按依赖图拓扑排序自动启动。
+- **持久化钩子**：dump/load 标准接口。
+
+这意味着 ReMe 有非常强的**可演进性** —— 当某个 backend 不够用了（比如个人 Neo4j 改用云上 Neo4j），换的成本极低。
+
+### 7.2 Job / Step 编排（借鉴 GitHub Actions）
+
+- **Step**：最小执行单元，做一件具体的事（如检索、解析、调 LLM）。
+- **Job**：steps 的有序组合，可复用、可流式。
+- **对外**：每个 Job 同时暴露为 HTTP API / MCP Tool / CLI 命令，无需重复开发。
+
+新增一个能力的标准动作是：
+
+1. 写一个 Step（继承 BaseStep，实现 execute）。
+2. 在配置里把它组合进 Job。
+3. 自动获得 HTTP / MCP / CLI 三种调用方式。
+
+### 7.3 配置即应用
+
+一份 `default.yaml` 描述完整应用：service / components / jobs。
+
+```yaml
+service:
+  backend: http
+components:
+  file_store:
+    backend: local
+  file_graph:
+    backend: local
+jobs:
+  search:
+    steps:
+      - search_step
+```
+
+替换 backend、增删 Job、调整依赖，全部通过配置完成，部署上线无需改代码。
+
+---
+
+## 八、生态接入：ReMe 如何被使用
+
+### 8.1 三种集成路径
+
+| 路径                 | 适用对象                                                | 体验                                                                 |
+|--------------------|-----------------------------------------------------|--------------------------------------------------------------------|
+| **SDK 集成**         | qwenpaw / AgentScope 等深度合作框架                        | 直接调用 `AgentscopeTools`，无感拥有 auto-memory / auto-dream / auto-search |
+| **MCP Tool**       | 任何支持 MCP 的客户端（Claude Code / Cursor / Cherry Studio） | 配 skill.md，开箱即用                                                    |
+| **CLI + skill.md** | 通用方案，兜底所有 Harness                                   | 一条命令调用，shell 友好                                                    |
+
+三条路径的设计哲学是：**不强迫任何 Agent 框架做 ReMe-specific 的改造**。
+
+- 对深度合作方，给最丝滑的 SDK。
+- 对支持 MCP 的产品，靠 MCP 标准协议。
+- 对什么都不支持的环境，CLI + skill.md 兜底。
+
+### 8.2 服务托管
+
+- **按需拉起**：Agent 检测到 ReMe 服务未运行时，可以自动后台拉起，用户无感知。
+- **服务发现**：`find_reme` 一键探活，避免端口冲突；多个 ReMe 实例共存时也能精准定位。
+
+### 8.3 ReMe 的边界
+
+> **ReMe 专注于知识加工，不做知识获取。**
+
+- **数据采集** —— 网页抓取、邮件接入、Slack 同步、文件上传 —— 由上游 Agent 完成。
+- **ReMe 负责** —— 把这些资料消化、整理、链接、检索、自进化。
+
+这个边界划得清楚的好处：
+
+- ReMe 不和上游的数据接入工具竞争。
+- ReMe 不需要为每种数据源写适配，专注做记忆引擎本职。
+- 让 ReMe 在"被集成"路线上更纯粹、更通用。
+
+---
+
+## 九、应用场景
+
+### 9.1 金融场景：产业链知识库
+
+**输入**：研报、调研纪要、行业新闻、对话讨论。
+**产出**：按"产业链 → 公司 → 产品"组织的知识图谱，每个节点都有可追溯的原始素材。
+**体验**：
+
+- 分析师问"锂电下游有哪些应用"，ReMe 沿图谱渐进展开，从"锂电"到"动力电池/储能/消费电子"，再到具体公司案例。
+- 发生重大事件时，ReMe 主动在 proactive 笔记里推送"这条新闻和您 3 月份关注的 XX 主题相关"。
+
+### 9.2 个人工作 & 生活
+
+**输入**：日常对话、会议记录、学习笔记、思考片段、阅读资料。
+**产出**：daily 流水 + knowledge 主题库 + proactive 主动建议。
+**体验**：
+
+- 使用 1 周：daily 已经在帮你做"今天发生了什么"的自动化日记。
+- 使用 1 个月：knowledge 库开始浮现你高频关注的主题（"工作流"、"团队管理"、"读过的书"）。
+- 使用 3 个月：知识库已经长成你"第二大脑"，Obsidian Graph View 打开是密集的网状结构。
+
+### 9.3 Agent 长期陪伴
+
+- Agent 跨会话记得用户偏好、过往任务、失败教训。
+- **任务复用**：相似任务自动召回过去的程序化记忆作为参考（"上次修这类 bug 你试过 A 方案，没成功；试过 B 方案，成了"）。
+- **个性化进化**：Agent 越用越懂用户，差异化体验来自 ReMe 维护的个人记忆，而不是模型本身。
+
+---
+
+## 十、性能与稳定性
+
+### 10.1 自研轻量内核
+
+新版本重写了知识引擎的核心模块：
+
+- **file parser** —— Markdown AST + 章节切片 + wikilink 抽取
+- **file store** —— 内存 chunk 字典 + JSONL 持久化
+- **file graph** —— 双向链接索引，多 backend
+- **file watcher** —— 基于 watchfiles 的轻量监听
+- **keyword index** —— 自研增量 BM25 倒排，原生支持中文
+
+整体**纯 Python + 文件持久化**，无 sqlite/chroma 等三方原生依赖。
+
+### 10.2 跨平台稳定性
+
+老版本在 qwenpaw 等低版本 Linux/Win 环境会出现 sqlite 段错误、chroma core dump，这些问题在新版本完全规避：
+
+- 没有 native 扩展依赖。
+- 老旧 glibc / 老旧 Python 版本也能跑。
+- 安装简单，不需要 cmake、build-essential。
+
+这对一个**要被部署到大量异构用户机器**的产品至关重要。
+
+### 10.3 未来：Rust / C++ 高性能内核
+
+- 当前 Python 版本已能覆盖个人规模知识库（万级文件）。
+- 规划用 Rust / C++ 重写关键路径（BM25 索引、文件解析、向量计算），支撑：
+    - 更大规模（十万级文件）
+    - 更低延迟（亚秒级冷启动）
+    - 更小内存
+- 上层 API 不变，对用户和 Agent 接入方完全透明。
+
+---
+
+## 十一、Roadmap：未来 6–12 个月
+
+| 阶段        | 关键里程碑                                                                                                  |
+|-----------|--------------------------------------------------------------------------------------------------------|
+| **Now**   | 组件框架、Job/Step、Markdown 内核、混合检索（向量+BM25+图谱）、HTTP / MCP / CLI 三协议服务                                      |
+| **Next**  | auto-memory / auto-dream / auto-link 全套自进化能力；记忆类型分层；resource / proactive 目录；skill.md 模板；qwenpaw SDK 集成 |
+| **Later** | 多跳渐进检索 API、领域 demo（金融产业链）、个人场景模板包、Rust 高性能内核、可视化管理面板                                                   |
+
+每个阶段都有清晰的对外可演示成果：
+
+- Now → 可以现场演示 ReMe 检索 + Agent 集成。
+- Next → 可以演示"今天聊的内容明天自动整理好"。
+- Later → 可以演示十万级知识库下的亚秒检索 + 主动推送闭环。
+
+---
+
+## 十二、结语：ReMe 想成为什么
+
+> ReMe 不止是「记忆库」。
+>
+> 它的目标是：**让每个用户拥有一张由本地 Markdown 自进化而成、可携带、可被任意 Agent 调用的个人知识图谱。**
+>
+> 当 Agent 时代真正到来时，差异化的不是模型，而是「这个 Agent 是不是了解我」。
+>
+> ReMe 想做的，就是这份「了解」的载体——一张属于用户自己、Agent 可读可写、会自己生长的图谱。
+
+**三个判断**：
+
+1. 个人记忆是 Agent 时代必然出现的基础设施 —— 不是 ReMe 不做就没人做，而是早做的人有先发优势。
+2. **本地 Markdown + 自进化 + 知识图谱**（叠加被集成路线）—— 这套组合在当下市场是空缺的。
+3. ReMe 新版本 的工程内核已经就位，剩下是**自进化能力 + 生态集成 + 场景模板**的三件套加固，路径明确。
+
+---
+
+## 附：建议补充材料
+
+- **系统架构图**：基于 §2.1 的 ASCII 图重绘为正式设计图。
+- **自进化时序图**：auto-memory / auto-dream / auto-link 三者的触发和协作时序。
+- **演示截图**：知识库三个月"自动生长"的 Obsidian Graph View 演示。
+- **30 秒 Demo 视频脚本**：用户说一句话 → ReMe 自动拆事件 → 第二天看到归档好的知识库。
+- **竞品对比表**：ReMe vs Memo vs Mem0 vs Letta，重点突出"本地 + 自进化 + 被集成"三个差异点。

docs4/reme4_report_outline.md

@@ -0,0 +1,256 @@
+# ReMe V4 能力报告 · 文档大纲
+
+> 面向受众：Leader / 决策者
+> 叙事视角：「未来 ReMe 长什么样」 —— 以产品愿景与最终用户体验为主线，
+> 不区分已实现 / 未实现，将在建能力作为完整版图的一部分自然描述。
+
+---
+
+## 一、引言：为什么要做 V4
+
+### 1.1 个人知识/记忆为什么是 Agent 时代的关键基建
+- Agent 不只是「工具调用」，更是「带着上下文长期陪伴用户」的角色。
+- 行业里大模型能力快速趋同，但**用户专属上下文**（个人知识库、工作记忆、长期偏好）才是差异化的护城河。
+- 当前业界（Memo / Mem0 / Letta 等）方案普遍存在三个问题：黑盒不可读、不可移植、缺乏自进化。
+
+### 1.2 ReMe V4 的一句话定位
+> **ReMe 是一个以本地 Markdown 为载体、可被 Agent 读写、可自进化、可被任意 Harness 框架接入的个人知识与记忆引擎。**
+
+### 1.3 V3 → V4 的关键升级
+- 从「只是把对话存下来」 → 「会主动整理、会自己长出新结构」
+- 从「单一向量检索」 → 「向量 + 关键词 + 图谱 多模检索」
+- 从「ReMe 内置 Agent」 → 「ReMe 作为能力被 qwenpaw / Claude Code / 其它 Harness 接入」
+- 从「sqlite/chroma 等三方依赖」 → 「自研轻量内核，跨平台稳定」
+
+---
+
+## 二、产品全景图
+
+### 2.1 一张图看 ReMe V4
+
+> 这一节用一张概念图收束全篇，建议绘制：
+>
+> ```
+> ┌─────────────────────────────────────────────────────────┐
+> │  外部 Agent / Harness                                    │
+> │  qwenpaw · Claude Code · Cursor · 其它                   │
+> └──────────┬──────────────┬───────────────┬───────────────┘
+>            │ SDK          │ MCP Tool      │ CLI / skill.md
+> ┌──────────▼──────────────▼───────────────▼───────────────┐
+> │                     ReMe Service Layer                   │
+> │   HTTP / MCP / CLI · 服务发现 · 进程托管                  │
+> ├──────────────────────────────────────────────────────────┤
+> │                     ReMe Job/Step 编排                   │
+> │   search · auto_memory · auto_dream · auto_link …        │
+> ├──────────────────────────────────────────────────────────┤
+> │     Markdown 知识内核（本地文件即数据库）                  │
+> │   FileParser · FileStore · FileGraph · FileWatcher       │
+> │   BM25 倒排 · 向量索引 · Wiki Link 图谱                  │
+> ├──────────────────────────────────────────────────────────┤
+> │     文件目录约定                                          │
+> │   resource/ · daily/ · knowledge/ · proactive/           │
+> └──────────────────────────────────────────────────────────┘
+> ```
+
+### 2.2 三个最直观的故事场景
+- **金融分析师**：每天盘后聊行情，ReMe 自动把对话拆成事件笔记，按产业链聚成知识库；下次问「钴的下游应用」时，能从历史对话中渐进式展开相关上下文。
+- **个人工作助理**：日常 Slack/邮件/会议讨论沉淀为 daily 笔记，ReMe 在空闲时自动整理为按主题归档的 knowledge 库。
+- **AI Agent 框架接入**：开发者在 qwenpaw / Claude Code 中只要安装 ReMe，Agent 就立刻拥有「长期记忆 + 个人知识检索」的能力，无需改 Agent 代码。
+
+---
+
+## 三、记忆模型：ReMe 把什么存下来
+
+### 3.1 四类记忆分层
+| 类型 | 存什么 | 典型场景 |
+| --- | --- | --- |
+| **Resource（原始资料）** | 原始对话日志、上传的文件、网页 HTML | 溯源 / 审计 / 二次加工 |
+| **Daily（日记记忆）** | 每天的事件性记忆，主 Agent 实时写入 | 「我今天和谁聊了什么」「今天工作内容」 |
+| **Knowledge（知识记忆）** | 主题化、结构化的长期知识 | 「光伏产业链」「我的工作框架」 |
+| **Proactive（主动推送）** | Agent 给用户的分析、推荐、心路历程 | 主动提醒、复盘建议 |
+
+> **重点表达**：ReMe 不是把对话一股脑塞进数据库，而是让记忆**像人脑一样有层次** —— 短期日记、长期知识、原始素材、主动洞察各司其职。
+
+### 3.2 目录约定（用户可读、可备份、可迁移）
+- `resource/` — 原始素材
+- `daily/YYYYMMDD.md` — 当天主索引（兼容主 Agent 的 write/edit 工具）
+- `daily/YYYYMMDD/{event}.md` — 当天拆分出的事件笔记
+- `knowledge/{topic}/{xxx}.md` — 主题化整理后的知识
+- `proactive/YYYYMMDD.md` — Agent 主动产出的建议与分析
+
+> **重点表达**：所有记忆都是普通 Markdown 文件，用户随时可以用 Obsidian 打开、用 Git 备份、跨设备同步、迁移到任何机器。**没有黑盒数据库，没有锁定。**
+
+### 3.3 三种记忆的覆盖
+- **个性化记忆** — 用户的偏好、习惯、个人事件
+- **程序化记忆** — Agent 完成任务的过程性经验（工作流模板、失败教训）
+- **知识类记忆** — 客观知识、领域参考资料
+
+---
+
+## 四、记忆的自进化（核心差异化）
+
+> 这是 V4 最重要的一节，决定了 ReMe 能不能真正长期陪伴用户。
+
+### 4.1 Auto-Memory：实时拆事件
+- 主对话进行时，ReMe 把上下文按「事件」自动拆分，写入 `daily/YYYYMMDD/{event}.md`。
+- 同时在 `daily/YYYYMMDD.md` 维护主索引，让所有事件可被反向追溯。
+- 体验：用户不需要手动整理，ReMe 替他做日记的「分章节」。
+
+### 4.2 Auto-Dream：空闲整理
+- Agent 空闲时（夜晚 / 用户离开），ReMe 主动把 daily 笔记按主题、实体重新整理到 `knowledge/{topic}/`。
+- 类比人在睡眠中做的「记忆巩固」。
+- 体验：用户第二天打开知识库，会发现昨天散落的对话已经按「客户/项目/学习」自动归档。
+
+### 4.3 Auto-Link：自动建图
+- 后台任务自动从正文里识别实体、候选链接，把隐式关系写回 wikilink。
+- 例如：在「光伏产业链」笔记里提到「隆基」，ReMe 自动补 `[[隆基]]` 链接到对应主题笔记。
+- 体验：随着使用时间增长，知识库自动「越长越密」，浏览时可以从任意一处跳转到相关全部上下文。
+
+### 4.4 三者协同：从对话到知识图谱的自然演化
+> 用一张时间轴图说明：原始对话 → daily 事件 → knowledge 主题 → graph 链接，
+> 整个过程**不需要用户操心**。
+
+---
+
+## 五、检索体验：多模检索 + 渐进式展开
+
+### 5.1 三路融合的混合检索
+- **向量检索**：语义层面的相似度
+- **关键词检索（BM25）**：精确匹配，对中文友好
+- **图谱检索**：通过 wikilink 邻居展开
+- 三路结果通过 RRF 排序融合，避免单一检索的盲区。
+
+### 5.2 渐进式展开
+- 第一跳：直接命中的笔记
+- 第二跳：链接邻居（outlinks/inlinks）
+- 第 N 跳：Agent 按需要主动「再看一层」
+- 体验：检索像「翻知识网络」，而不是「拉一坨切片塞进上下文」。
+- 价值：上下文窗口永远只装最相关的部分，token 利用率高。
+
+### 5.3 关键词索引的工程价值
+- 中文关键词检索（jieba 分词 + 自研 BM25 增量倒排）
+- 旧版 sqlite/chroma 在 Linux/Win 老系统会 core dump → V4 用纯 Python + 文件落盘，**跨平台零依赖**。
+
+---
+
+## 六、Markdown 内核：把文件当数据库
+
+### 6.1 Obsidian 兼容的 Markdown 格式
+- YAML front matter（标题/标签/描述）
+- 4 种 wikilink 写法：`[[X]]` / `[[X#anchor]]` / `[[X|alias]]` / `![[X]]`
+- Dataview 风格的语义关系：`predicate:: [[X]]`
+- 标准 `[text](xxx.md)` 链接也会被识别为图边（计划中）
+
+### 6.2 比 RAG 更聪明的切片
+- 解析 Markdown AST，按章节嵌套切分
+- 每个 chunk 自带**完整的标题骨架**（TOC），保留层级上下文
+- 检索回来的片段，Agent 一眼就能看出「这段在哪个章节、什么主题下」
+
+### 6.3 Graph 索引：双向链接
+- 正向：A → B（A 引用了 B）
+- 反向：B ← {A, C, D}（谁引用了 B）
+- 三种 backend：本地 dict / NetworkX / Neo4j，按规模与可视化需求切换
+
+---
+
+## 七、工程架构：可扩展、可替换、可演进
+
+### 7.1 Component 框架
+- 所有能力封装为 Component（embedding / file_store / file_graph / parser / watcher / tokenizer / index / LLM 适配 / service / client）
+- 支持 backend 热切换：`local` ↔ `nx` ↔ `neo4j` 一行配置改完
+- 生命周期托管：start / close / restart 全自动
+- 拓扑依赖解析：组件间相互调用，按依赖图自动启动
+
+### 7.2 Job / Step 编排（借鉴 GitHub Actions）
+- **Step**：最小执行单元，调用 components 完成一件事
+- **Job**：steps 的有序组合，可复用、可流式
+- **对外**：每个 Job 可同时暴露为 HTTP API / MCP Tool / CLI 命令
+
+### 7.3 配置即应用
+- 一份 `default.yaml` 描述完整应用：service / components / jobs
+- 替换 backend、增删 Job、调整依赖，全部通过配置完成
+- 部署上线无需改代码
+
+---
+
+## 八、生态接入：ReMe 如何被使用
+
+### 8.1 三种集成路径
+| 路径 | 适用对象 | 体验 |
+| --- | --- | --- |
+| **SDK 集成** | qwenpaw / AgentScope 等深度合作框架 | 直接调用 `AgentscopeTools`，无感拥有 auto-memory/auto-dream/auto-search |
+| **MCP Tool** | 任何支持 MCP 的客户端（Claude Code / Cursor / Cherry Studio） | 配 skill.md，开箱即用 |
+| **CLI + skill.md** | 通用方案，兜底所有 Harness | 一条命令调用，shell 友好 |
+
+### 8.2 服务托管
+- Agent 可以「按需拉起」后台 ReMe 服务，无需用户提前启动
+- 服务发现机制：`find_reme` 一键探活，避免端口冲突
+
+### 8.3 ReMe 的边界
+> ReMe **专注于知识加工，不做知识获取**。
+> 数据采集、网页抓取、邮件接入、Slack 同步等，由上游 Agent 完成；
+> ReMe 负责把这些资料**消化、整理、链接、检索**。
+
+---
+
+## 九、应用场景
+
+### 9.1 金融场景：产业链知识库
+- 输入：研报、调研纪要、新闻、对话讨论
+- 产出：按「产业链 → 公司 → 产品」组织的知识图谱
+- 体验：分析师问「锂电下游有哪些应用」，ReMe 沿着图谱渐进展开，回答既具体又有上下文。
+
+### 9.2 个人工作 & 生活
+- 输入：日常对话、会议记录、学习笔记、思考片段
+- 产出：daily 流水 + knowledge 主题库 + proactive 主动建议
+- 体验：使用三个月后，知识库自然形成个人「第二大脑」。
+
+### 9.3 Agent 长期陪伴
+- Agent 跨会话记得用户偏好、过往任务、失败教训
+- 任务复用：相似任务自动召回过去的程序化记忆作为参考
+
+---
+
+## 十、性能与稳定性
+
+### 10.1 自研轻量内核
+- 重写 file parser / file store / file graph / file watcher
+- 自研增量 BM25 倒排索引，支持中文
+- 纯 Python + 文件持久化，无 sqlite/chroma 等三方依赖
+
+### 10.2 跨平台稳定性
+- 解决 V3 在 qwenpaw 等低版本 Linux/Win 的 core dump 兼容问题
+- 老旧环境也能跑
+
+### 10.3 未来：Rust / C++ 高性能内核
+- 当前 Python 版本已能覆盖个人规模知识库（万级文件）
+- 规划用 Rust/C++ 重写关键路径，支撑更大规模与更低延迟
+
+---
+
+## 十一、Roadmap：未来 6–12 个月
+
+| 阶段 | 关键里程碑 |
+| --- | --- |
+| **Now** | 组件框架、Job/Step、Markdown 内核、混合检索、HTTP/MCP 服务（已就绪） |
+| **Next** | auto-memory / auto-dream / auto-link、记忆类型分层、resource/proactive 目录、skill.md 模板、qwenpaw SDK 集成 |
+| **Later** | 多跳渐进检索 API、领域 demo（金融产业链）、个人场景模板、Rust 内核 |
+
+---
+
+## 十二、结语：ReMe 想成为什么
+
+> ReMe 不止是「记忆库」。
+> 它的目标是：**让每个用户拥有一份属于自己的、可携带的、可自进化的、可被任意 Agent 调用的知识身份。**
+>
+> 当 Agent 时代真正到来时，差异化的不是模型，而是「这个 Agent 是不是了解我」。
+> ReMe 想做的，就是这份「了解」的载体。
+
+---
+
+## 附：建议补充材料
+
+- 一张系统架构图（基于 §2.1 的 ASCII 图重绘为正式图）
+- 一张 auto-memory / auto-dream / auto-link 的时序图
+- 一张知识库三个月「自动生长」的演示截图（Obsidian Graph View）
+- 一段 30 秒 Demo 视频脚本：用户说一句话 → ReMe 自动拆事件 → 第二天看到归档好的知识库