From 54e81aba113526c712ea4e3288e1c41fd82fac40 Mon Sep 17 00:00:00 2001 From: zhayujie Date: Thu, 9 Apr 2026 21:22:43 +0800 Subject: [PATCH 1/8] feat(memory+knowledge): add knowledge wiki system and Light Dream memory extraction - Add knowledge/ directory structure and knowledge-wiki skill for structured knowledge accumulation - Auto-inject MEMORY.md into system prompt with truncation (last 200 lines) - Light Dream: extend flush_memory to extract long-term memories into MEMORY.md with date stamps - Add mandatory knowledge auto-write rules in system prompt (no user confirmation needed) - Expand MemoryManager.sync() to index knowledge/ files for vector search - Update RULE.md template with workspace conventions and knowledge guidelines --- agent/memory/manager.py | 10 ++ agent/memory/summarizer.py | 177 ++++++++++++++++++++++++--------- agent/prompt/builder.py | 101 ++++++++++++++----- agent/prompt/workspace.py | 134 +++++++++++++++++++++---- skills/knowledge-wiki/SKILL.md | 90 +++++++++++++++++ 5 files changed, 427 insertions(+), 85 deletions(-) create mode 100644 skills/knowledge-wiki/SKILL.md diff --git a/agent/memory/manager.py b/agent/memory/manager.py index 197c9ffd..967270f7 100644 --- a/agent/memory/manager.py +++ b/agent/memory/manager.py @@ -285,6 +285,10 @@ class MemoryManager: # Scan memory directory (including daily summaries) if memory_dir.exists(): for file_path in memory_dir.rglob("*.md"): + # Skip hidden directories (e.g. .dreams/) + if any(part.startswith('.') for part in file_path.relative_to(workspace_dir).parts): + continue + # Determine scope and user_id from path rel_path = file_path.relative_to(workspace_dir) parts = rel_path.parts @@ -312,6 +316,12 @@ class MemoryManager: scope = "shared" await self._sync_file(file_path, "memory", scope, user_id) + + # Scan knowledge directory (structured knowledge wiki) + knowledge_dir = Path(workspace_dir) / "knowledge" + if knowledge_dir.exists(): + for file_path in knowledge_dir.rglob("*.md"): + await self._sync_file(file_path, "knowledge", "shared", None) self._dirty = False diff --git a/agent/memory/summarizer.py b/agent/memory/summarizer.py index b280e1c1..c854ff1a 100644 --- a/agent/memory/summarizer.py +++ b/agent/memory/summarizer.py @@ -1,9 +1,10 @@ """ -Memory flush manager +Memory flush manager (with Light Dream) Handles memory persistence when conversation context is trimmed or overflows: - Uses LLM to summarize discarded messages into concise key-information entries - Writes to daily memory files (lazy creation) +- Light Dream: extracts long-term memories to MEMORY.md in the same LLM call - Deduplicates trim flushes to avoid repeated writes - Runs summarization asynchronously to avoid blocking normal replies - Provides daily summary interface for scheduler @@ -16,26 +17,41 @@ from datetime import datetime from common.log import logger -SUMMARIZE_SYSTEM_PROMPT = """你是一个记忆提取助手。你的任务是从对话记录中提炼出值得长期记住的关键事件和核心信息。 +SUMMARIZE_SYSTEM_PROMPT = """你是一个记忆提取助手。你的任务是从对话记录中提炼出两种记忆： -核心原则： -- 按「事件」维度归纳，而不是按对话轮次逐条记录 -- 多轮对话如果围绕同一件事，合并为一条摘要 -- 只记录有长期价值的信息，忽略闲聊、问候、无意义的短消息 +## 第一部分：日常记录（[DAILY]） -输出要求： -1. 每条一行，用 "- " 开头，格式为：事件/主题 + 关键结论或结果 -2. 值得记录的信息类型：用户提出的需求及最终解决方案、重要的事实信息、用户的偏好或决策、关键技术方案或配置变更 -3. 不值得记录的信息：简单问候、闲聊、无实质内容的短消息、重复的中间过程 -4. 每条摘要应当简明扼要，一句话概括事件的核心内容和结果 -5. 直接输出摘要内容，不要加任何前缀说明 -6. 当对话没有任何记录价值（仅含问候或无意义内容），回复"无" +按「事件」维度归纳当天发生的事，不要按对话轮次逐条记录： +- 每条一行，用 "- " 开头 +- 合并同一件事的多轮对话 +- 只记录有意义的事件，忽略闲聊和问候 -示例（仅供参考格式）： -- 用户配置了 XX 功能，设置参数为 YY，已生效 -- 用户反馈了 XX 问题，原因是 YY，通过 ZZ 方式解决""" +## 第二部分：长期记忆（[MEMORY]） -SUMMARIZE_USER_PROMPT = """请从以下对话记录中，按关键事件维度提炼记忆摘要（合并同一事件的多轮对话，不要逐条列出）： +提取值得**永久记住**的关键信息，这些信息在未来的对话中仍然有价值： +- 用户的偏好、习惯、风格（如"用户偏好中文回复"、"用户喜欢简洁风格"） +- 重要的决策或约定（如"项目决定使用 PostgreSQL"） +- 关键人物信息（如"张总是用户的上级"） +- 用户明确要求记住的内容 +- 重要的教训或经验总结 + +**如果没有值得永久记住的信息，[MEMORY] 部分留空即可。** + +## 输出格式（严格遵守） + +``` +[DAILY] +- 事件1的摘要 +- 事件2的摘要 + +[MEMORY] +- 值得永久记住的信息1 +- 值得永久记住的信息2 +``` + +当对话没有任何记录价值（仅含问候或无意义内容），直接回复"无"。""" + +SUMMARIZE_USER_PROMPT = """请从以下对话记录中提取记忆（按 [DAILY] 和 [MEMORY] 两部分输出）： {conversation}""" @@ -160,40 +176,111 @@ class MemoryFlushManager: reason: str, max_messages: int, ): - """Background worker: summarize with LLM and write to daily file.""" + """Background worker: summarize with LLM, write daily file + MEMORY.md (Light Dream).""" try: - summary = self._summarize_messages(messages, max_messages) - if not summary or not summary.strip() or summary.strip() == "无": + raw_summary = self._summarize_messages(messages, max_messages) + if not raw_summary or not raw_summary.strip() or raw_summary.strip() == "无": logger.info(f"[MemoryFlush] No valuable content to flush (reason={reason})") return - - daily_file = ensure_daily_memory_file(self.workspace_dir, user_id) - - if reason == "overflow": - header = f"## Context Overflow Recovery ({datetime.now().strftime('%H:%M')})" - note = "The following conversation was trimmed due to context overflow:\n" - elif reason == "trim": - header = f"## Trimmed Context ({datetime.now().strftime('%H:%M')})" - note = "" - elif reason == "daily_summary": - header = f"## Daily Summary ({datetime.now().strftime('%H:%M')})" - note = "" - else: - header = f"## Session Notes ({datetime.now().strftime('%H:%M')})" - note = "" - - flush_entry = f"\n{header}\n\n{note}{summary}\n" - - with open(daily_file, "a", encoding="utf-8") as f: - f.write(flush_entry) - + + daily_part, memory_part = self._parse_dual_output(raw_summary) + + # --- Write daily memory --- + if daily_part: + daily_file = ensure_daily_memory_file(self.workspace_dir, user_id) + + if reason == "overflow": + header = f"## Context Overflow Recovery ({datetime.now().strftime('%H:%M')})" + note = "The following conversation was trimmed due to context overflow:\n" + elif reason == "trim": + header = f"## Trimmed Context ({datetime.now().strftime('%H:%M')})" + note = "" + elif reason == "daily_summary": + header = f"## Daily Summary ({datetime.now().strftime('%H:%M')})" + note = "" + else: + header = f"## Session Notes ({datetime.now().strftime('%H:%M')})" + note = "" + + flush_entry = f"\n{header}\n\n{note}{daily_part}\n" + + with open(daily_file, "a", encoding="utf-8") as f: + f.write(flush_entry) + + logger.info(f"[MemoryFlush] Wrote daily memory to {daily_file.name} (reason={reason}, chars={len(daily_part)})") + + # --- Light Dream: write long-term memory to MEMORY.md --- + if memory_part: + self._append_to_main_memory(memory_part, user_id) + self.last_flush_timestamp = datetime.now() - - logger.info(f"[MemoryFlush] Wrote to {daily_file.name} (reason={reason}, chars={len(summary)})") - + except Exception as e: logger.warning(f"[MemoryFlush] Async flush failed (reason={reason}): {e}") - + + @staticmethod + def _parse_dual_output(raw: str) -> tuple: + """ + Parse LLM output into (daily_part, memory_part). + Handles both new [DAILY]/[MEMORY] format and legacy single-section format. + """ + raw = raw.strip() + + if "[DAILY]" in raw or "[MEMORY]" in raw: + daily_part = "" + memory_part = "" + + # Extract [DAILY] section + if "[DAILY]" in raw: + start = raw.index("[DAILY]") + len("[DAILY]") + end = raw.index("[MEMORY]") if "[MEMORY]" in raw else len(raw) + daily_part = raw[start:end].strip() + + # Extract [MEMORY] section + if "[MEMORY]" in raw: + start = raw.index("[MEMORY]") + len("[MEMORY]") + memory_part = raw[start:].strip() + + # Filter out empty markers + if memory_part and all( + not line.strip() or line.strip() == "-" + for line in memory_part.split("\n") + ): + memory_part = "" + + return daily_part, memory_part + + # Legacy format: treat entire output as daily, no memory extraction + return raw, "" + + def _append_to_main_memory(self, memory_entries: str, user_id: Optional[str] = None): + """Append extracted long-term memories to MEMORY.md with date stamp.""" + try: + main_file = self.get_main_memory_file(user_id) + today = datetime.now().strftime("%Y-%m-%d") + + # Add date prefix to each entry line + stamped_lines = [] + for line in memory_entries.strip().split("\n"): + line = line.strip() + if line.startswith("- "): + stamped_lines.append(f"- ({today}) {line[2:]}") + elif line: + stamped_lines.append(f"- ({today}) {line}") + + if not stamped_lines: + return + + stamped_text = "\n".join(stamped_lines) + + with open(main_file, "a", encoding="utf-8") as f: + f.write(f"\n{stamped_text}\n") + + logger.info(f"[LightDream] Appended {len(stamped_lines)} entries to MEMORY.md") + + except Exception as e: + logger.warning(f"[LightDream] Failed to append to MEMORY.md: {e}") + def create_daily_summary( self, messages: List[Dict], diff --git a/agent/prompt/builder.py b/agent/prompt/builder.py index 1b96d2cf..11bd3b51 100644 --- a/agent/prompt/builder.py +++ b/agent/prompt/builder.py @@ -92,10 +92,11 @@ def build_agent_system_prompt( 顺序说明（按重要性和逻辑关系排列）: 1. 工具系统 - 核心能力，最先介绍 2. 技能系统 - 紧跟工具，因为技能需要用 read 工具读取 - 3. 记忆系统 - 独立的记忆能力 + 3. 记忆系统 - 记忆检索与写入引导 + 3.5 知识系统 - 结构化知识库（knowledge/index.md 注入） 4. 工作空间 - 工作环境说明 5. 用户身份 - 用户信息（可选） - 6. 项目上下文 - AGENT.md, USER.md, RULE.md, BOOTSTRAP.md（定义人格、身份、规则、初始化引导） + 6. 项目上下文 - AGENT.md, USER.md, RULE.md, MEMORY.md, BOOTSTRAP.md 7. 运行时信息 - 元信息（时间、模型等） Args: @@ -126,6 +127,9 @@ def build_agent_system_prompt( # 3. 记忆系统（独立的记忆能力） if memory_manager: sections.extend(_build_memory_section(memory_manager, tools, language)) + + # 3.5 知识系统（结构化知识库） + sections.extend(_build_knowledge_section(workspace_dir, language)) # 4. 工作空间（工作环境说明） sections.extend(_build_workspace_section(workspace_dir, language)) @@ -268,55 +272,105 @@ def _build_memory_section(memory_manager: Any, tools: Optional[List[Any]], langu """构建记忆系统section""" if not memory_manager: return [] - - # 检查是否有memory工具 + has_memory_tools = False if tools: tool_names = [tool.name if hasattr(tool, 'name') else str(tool) for tool in tools] has_memory_tools = any(name in ['memory_search', 'memory_get'] for name in tool_names) - + if not has_memory_tools: return [] - + from datetime import datetime today_file = datetime.now().strftime("%Y-%m-%d") + ".md" - + lines = [ "## 🧠 记忆系统", "", - "### 检索记忆", + "### Memory Recall（mandatory）", "", - "在回答关于以前的工作、决定、日期、人物、偏好或待办事项的任何问题之前：", + "在回答任何关于过往工作、决策、日期、人物、偏好或待办事项的问题之前，**必须**先检索记忆。", + "MEMORY.md 已自动加载在项目上下文中（可能被截断），完整内容和每日记忆需要通过工具检索。", "", - "1. 不确定记忆文件位置 → 先用 `memory_search` 通过关键词和语义检索相关内容", - "2. 已知文件位置 → 直接用 `memory_get` 读取相应的行 (例如：MEMORY.md, memory/YYYY-MM-DD.md)", - "3. search 无结果 → 尝试用 `memory_get` 读取MEMORY.md及最近两天记忆文件", + "1. 不确定位置 → `memory_search` 关键词/语义检索", + "2. 已知位置 → `memory_get` 直接读取对应行", + "3. search 无结果 → `memory_get` 读最近两天记忆", "", "**记忆文件结构**:", - f"- `MEMORY.md`: 长期记忆（核心信息、偏好、决策等）", + "- `MEMORY.md`: 长期记忆索引（已自动加载到上下文，核心信息、偏好、决策等）", f"- `memory/YYYY-MM-DD.md`: 每日记忆，今天是 `memory/{today_file}`", + "- `knowledge/`: 结构化知识库（见下方知识系统）", "", "### 写入记忆", "", - "**主动存储**：遇到以下情况时，应主动将信息写入记忆文件（无需告知用户）：", + "遇到以下情况时，**主动**将信息写入记忆文件（无需告知用户）：", "", - "- 用户明确要求你记住某些信息", + "- 用户要求记住某些信息", "- 用户分享了重要的个人偏好、习惯、决策", "- 对话中产生了重要的结论、方案、约定", "- 完成了复杂任务，值得记录关键步骤和结果", - "- 发现了用户经常遇到的问题或解决方案", "", "**存储规则**:", - f"- 长期有效的核心信息 → `MEMORY.md`（文件保持精简，< 2000 tokens）", - f"- 当天的事件、进展、笔记 → `memory/{today_file}`", - "- 追加内容 → `edit` 工具，oldText 留空", - "- 修改内容 → `edit` 工具，oldText 填写要替换的文本", - "- **禁止写入敏感信息**：API密钥、令牌等敏感信息严禁写入记忆文件", + f"- 长期核心信息 → `MEMORY.md`", + f"- 当天事件/进展 → `memory/{today_file}`", + "- 结构化知识 → `knowledge/`（见知识系统）", + "- 追加 → `edit` 工具，oldText 留空", + "- 修改 → `edit` 工具，oldText 填写要替换的文本", + "- **禁止写入敏感信息**（API密钥、令牌等）", "", "**使用原则**: 自然使用记忆，就像你本来就知道；不用刻意提起，除非用户问起。", "", ] - + + return lines + + +def _build_knowledge_section(workspace_dir: str, language: str) -> List[str]: + """Build knowledge wiki section. Injects knowledge/index.md when present.""" + index_path = os.path.join(workspace_dir, "knowledge", "index.md") + if not os.path.exists(index_path): + return [] + + try: + with open(index_path, 'r', encoding='utf-8') as f: + index_content = f.read().strip() + except Exception: + return [] + + lines = [ + "## 📚 知识系统", + "", + "你拥有一个持续积累的个人知识库 `knowledge/`，这是你的长期结构化知识存储。", + "", + "### 自动写入规则（mandatory）", + "", + "以下场景**必须**在回复的同时写入知识库，**直接写入，不要询问用户是否需要**：", + "", + "1. **用户分享了文章/链接/文档** → 阅读理解后，在同一轮回复中将要点写入 `knowledge/sources/.md`", + "2. **深度讨论产生了结论/方案** → 整理为 `knowledge/analysis/.md`", + "3. **对话涉及重要实体**（人物/公司/项目）→ 创建或更新 `knowledge/entities/.md`", + "4. **讨论了技术概念/方法论** → 整理为 `knowledge/concepts/.md`", + "", + "每次写入知识页面后，**必须同步更新** `knowledge/index.md` 添加一行索引。", + "详细的页面格式和操作规范，请读取技能 `knowledge-wiki` 的 SKILL.md。", + "", + "⚠️ 不要问「要不要存到知识库」——符合上述场景就直接写入，这是你的本能行为。", + "", + ] + + if index_content: + lines.extend([ + "### 当前知识索引", + "", + index_content, + "", + ]) + + lines.extend([ + "**查询方式**：用 `read` 读取知识页面，或用 `memory_search` 检索（知识已纳入向量索引）。", + "", + ]) + return lines @@ -375,11 +429,12 @@ def _build_workspace_section(workspace_dir: str, language: str) -> List[str]: "", "**重要说明 - 文件已自动加载**:", "", - "以下文件在会话启动时**已经自动加载**到系统提示词的「项目上下文」section 中，你**无需再用 read 工具读取它们**：", + "以下文件在会话启动时**已经自动加载**到系统提示词中，你**无需再用 read 工具读取**：", "", "- ✅ `AGENT.md`: 已加载 - 你的人格和灵魂设定，请严格遵循。当你的名字、性格或交流风格发生变化时，主动用 `edit` 更新此文件", "- ✅ `USER.md`: 已加载 - 用户的身份信息。当用户修改称呼、姓名等身份信息时，用 `edit` 更新此文件", "- ✅ `RULE.md`: 已加载 - 工作空间使用指南和规则，请严格遵循", + "- ✅ `MEMORY.md`: 已加载 - 长期记忆索引", "", "**💬 交流规范**:", "", diff --git a/agent/prompt/workspace.py b/agent/prompt/workspace.py index 68eec912..9ebf0703 100644 --- a/agent/prompt/workspace.py +++ b/agent/prompt/workspace.py @@ -67,6 +67,12 @@ def ensure_workspace(workspace_dir: str, create_templates: bool = True) -> Works # 创建websites子目录 (for web pages / sites generated by agent) websites_dir = os.path.join(workspace_dir, "websites") os.makedirs(websites_dir, exist_ok=True) + + # 创建knowledge子目录 (structured knowledge wiki) + knowledge_dir = os.path.join(workspace_dir, "knowledge") + os.makedirs(knowledge_dir, exist_ok=True) + for sub in ["entities", "concepts", "sources", "analysis"]: + os.makedirs(os.path.join(knowledge_dir, sub), exist_ok=True) # 如果需要，创建模板文件 if create_templates: @@ -74,6 +80,14 @@ def ensure_workspace(workspace_dir: str, create_templates: bool = True) -> Works _create_template_if_missing(user_path, _get_user_template()) _create_template_if_missing(rule_path, _get_rule_template()) _create_template_if_missing(memory_path, _get_memory_template()) + _create_template_if_missing( + os.path.join(knowledge_dir, "index.md"), + _get_knowledge_index_template() + ) + _create_template_if_missing( + os.path.join(knowledge_dir, "log.md"), + _get_knowledge_log_template() + ) # Only create BOOTSTRAP.md for brand new workspaces; # agent deletes it after completing onboarding @@ -109,6 +123,7 @@ def load_context_files(workspace_dir: str, files_to_load: Optional[List[str]] = DEFAULT_AGENT_FILENAME, DEFAULT_USER_FILENAME, DEFAULT_RULE_FILENAME, + DEFAULT_MEMORY_FILENAME, # Long-term memory (frozen snapshot) DEFAULT_BOOTSTRAP_FILENAME, # Only exists when onboarding is incomplete ] @@ -138,6 +153,10 @@ def load_context_files(workspace_dir: str, files_to_load: Optional[List[str]] = # 跳过空文件或只包含模板占位符的文件 if not content or _is_template_placeholder(content): continue + + # Truncate MEMORY.md to protect context window (frozen snapshot) + if filename == DEFAULT_MEMORY_FILENAME: + content = _truncate_memory_content(content) context_files.append(ContextFile( path=filename, @@ -163,6 +182,36 @@ def _create_template_if_missing(filepath: str, template_content: str): logger.error(f"[Workspace] Failed to create template {filepath}: {e}") +_MEMORY_MAX_LINES = 200 +_MEMORY_MAX_BYTES = 25000 + + +def _truncate_memory_content(content: str) -> str: + """Truncate MEMORY.md to keep system prompt manageable. + + Takes the **last** N lines (newest entries are appended at the bottom), + subject to 200 lines / 25 KB limits (whichever is hit first). + Prepends a hint when truncated so the model knows older content exists. + """ + lines = content.split('\n') + truncated = False + + if len(lines) > _MEMORY_MAX_LINES: + lines = lines[-_MEMORY_MAX_LINES:] + truncated = True + + result = '\n'.join(lines) + if len(result.encode('utf-8')) > _MEMORY_MAX_BYTES: + while len(result.encode('utf-8')) > _MEMORY_MAX_BYTES and lines: + lines.pop(0) + truncated = True + result = '\n'.join(lines) + + if truncated: + result = "...(older entries truncated, use `memory_search` or `memory_get` for full content)\n\n" + result + return result + + def _is_template_placeholder(content: str) -> bool: """检查内容是否为模板占位符""" # 常见的占位符模式 @@ -287,39 +336,82 @@ def _get_rule_template() -> str: 这个文件夹是你的家。好好对待它。 +## 工作空间目录结构 + +``` +~/cow/ +├── AGENT.md # 你的身份和灵魂设定 +├── USER.md # 用户基本信息（静态） +├── RULE.md # 工作空间规则（本文件） +├── MEMORY.md # 长期记忆索引（会话启动时自动加载） +│ +├── memory/ # 每日对话记忆 +│ └── YYYY-MM-DD.md # 当天事件、进展、笔记 +│ +├── knowledge/ # 结构化知识库（持续积累的知识） +│ ├── index.md # 知识目录索引 +│ ├── log.md # 知识操作日志 +│ ├── entities/ # 实体页面（人物、公司、项目） +│ ├── concepts/ # 概念页面（技术、方法论） +│ ├── sources/ # 资料摘要（文章、文件的要点提取） +│ └── analysis/ # 沉淀的分析和洞见 +│ +├── skills/ # 技能 +├── websites/ # 网页产物 +└── tmp/ # 系统临时文件（自动管理，勿手动存放重要文件） +``` + ## 记忆系统 你每次会话都是全新的，记忆文件让你保持连续性： -### 📝 每日记忆：`memory/YYYY-MM-DD.md` -- 原始的对话日志 -- 记录当天发生的事情 -- 如果 `memory/` 目录不存在，创建它 - ### 🧠 长期记忆：`MEMORY.md` -- 你精选的记忆，就像人类的长期记忆 -- **仅在主会话中加载**（与用户的直接聊天） -- **不要在共享上下文中加载**（群聊、与其他人的会话） -- 这是为了**安全** - 包含不应泄露给陌生人的个人上下文 -- 记录重要事件、想法、决定、观点、经验教训 -- 这是你精选的记忆 - 精华，而不是原始日志 -- 用 `edit` 工具追加新的记忆内容 +- 你精选的记忆索引，每次会话启动时**自动加载**到上下文中 +- 记录核心事实、偏好、决策、重要人物、教训 +- 保持精简（< 200 行），是精华索引而非原始日志 +- 用 `edit` 工具追加或修改 + +### 📝 每日记忆：`memory/YYYY-MM-DD.md` +- 当天的事件、进展、笔记 +- 原始对话日志的沉淀 ### 📝 写下来 - 不要"记在心里"！ -- **记忆是有限的** - 如果你想记住某事，写入文件 +- **记忆是有限的** - 想记住的事就写入文件 - "记在心里"不会在会话重启后保留，文件才会 - 当有人说"记住这个" → 更新 `MEMORY.md` 或 `memory/YYYY-MM-DD.md` - 当你学到教训 → 更新 RULE.md 或相关技能 -- 当你犯错 → 记录下来，这样未来的你不会重复，**文字 > 大脑** 📝 +- 当你犯错 → 记录下来，**文字 > 大脑** 📝 ### 存储规则 当用户分享信息时，根据类型选择存储位置： -1. **你的身份设定 → AGENT.md**（你的名字、角色、性格、交流风格——用户修改时必须用 `edit` 更新） -2. **用户静态身份 → USER.md**（姓名、称呼、职业、时区、联系方式、生日——用户修改时必须用 `edit` 更新） -3. **动态记忆 → MEMORY.md**（爱好、偏好、决策、目标、项目、教训、待办事项） +1. **你的身份设定 → AGENT.md**（名字、角色、性格、风格） +2. **用户静态身份 → USER.md**（姓名、称呼、职业、联系方式、生日） +3. **动态记忆 → MEMORY.md**（偏好、决策、目标、教训、待办） 4. **当天对话 → memory/YYYY-MM-DD.md**（今天聊的内容） +5. **结构化知识 → knowledge/**（见下方知识系统） + +## 知识系统 + +知识库 `knowledge/` 是你持续积累的结构化知识。与记忆不同，知识是经过整理和编译的，有明确的主题和交叉引用。 + +### 自动写入（不要询问，直接写入） + +以下场景你**必须**在回复的同时主动写入知识库，**不要问用户"要不要存到知识库"**： + +- 用户分享了一篇文章/链接/文件 → 阅读后提取要点，在同一轮回复中写入 `knowledge/sources/` +- 深度讨论产生了有价值的结论/方案 → 整理写入 `knowledge/analysis/` +- 对话涉及重要的人物/项目/公司 → 创建或更新 `knowledge/entities/` +- 讨论了技术概念或方法论 → 整理写入 `knowledge/concepts/` + +**关键原则**：学完就记是你的本能，不要征求确认。回复中可以顺带告知"已存入知识库"。 + +### 索引维护 + +每次创建或更新知识页面后，**必须同步更新** `knowledge/index.md`。 +索引格式：每行一个 `[标题](路径) — 一句话摘要`，按分类分组，不要用表格。 +详细操作规范见技能 `knowledge-wiki`。 ## 安全 @@ -381,4 +473,12 @@ _你刚刚启动，这是你的第一次对话。_ ✨ """ +def _get_knowledge_index_template() -> str: + """Knowledge wiki index template — empty file, agent fills it.""" + return "" + + +def _get_knowledge_log_template() -> str: + """Knowledge wiki operation log template — empty file, agent fills it.""" + return "" diff --git a/skills/knowledge-wiki/SKILL.md b/skills/knowledge-wiki/SKILL.md new file mode 100644 index 00000000..da3d4c4f --- /dev/null +++ b/skills/knowledge-wiki/SKILL.md @@ -0,0 +1,90 @@ +--- +name: knowledge-wiki +description: Manage the personal knowledge wiki. Use when the user shares articles, documents, or asks to organize knowledge; when a conversation produces insights worth preserving as structured knowledge; or when the user asks about the knowledge base. +metadata: + cowagent: + always: true +--- + +# Knowledge Wiki + +Maintain a persistent, structured knowledge base in the `knowledge/` directory. + +## Core Operations + +### 1. Ingest — User shares an article, document, or resource + +1. Read and understand the source material +2. Extract key facts, entities, concepts, and insights +3. Create or update relevant pages: + - `knowledge/sources/.md` — source summary + - `knowledge/entities/.md` — people, companies, projects mentioned + - `knowledge/concepts/.md` — new concepts or topics discussed +4. Update `knowledge/index.md` — add one-line entry per new/updated page +5. Append to `knowledge/log.md` + +### 2. Synthesize — Conversation produces valuable structured knowledge + +1. Create `knowledge/analysis/.md` with the structured analysis +2. Update related entity/concept pages with cross-references +3. Update `knowledge/index.md` and `knowledge/log.md` + +### 3. Query — User asks about accumulated knowledge + +1. Check `knowledge/index.md` (already in your context) for relevant pages +2. Read specific pages with the `read` tool +3. Supplement with `memory_search` if needed + +## Page Format + +```markdown +# Page Title + +Content here. Reference other pages with markdown links: +[Related Entity](../entities/related-entity.md) + +## Key Points + +- ... + +## Sources + +- [Source Title](../sources/source-slug.md) +``` + +## Index Format (`knowledge/index.md`) + +Flat list, one line per page: `[Title](path) — one-line summary`. No tables, no emoji, no template headers. + +```markdown +# Knowledge Index + +## Concepts +- [Topic Name](concepts/topic-name.md) — one-line description + +## Sources +- [Article Title](sources/article-slug.md) — one-line summary + +## Entities +- [Entity Name](entities/entity-name.md) — one-line description + +## Analysis +- [Analysis Title](analysis/analysis-slug.md) — one-line summary +``` + +## Log Format (`knowledge/log.md`) + +Append-only, newest at bottom: + +```markdown +## [2026-04-09] ingest | DeepSeek-R1 Deploy Guide +## [2026-04-09] synthesize | Memory System Design Analysis +``` + +## Guidelines + +- **File naming**: lowercase kebab-case (e.g. `machine-learning.md`) +- **One topic per page**: link between pages rather than duplicating +- **Update, don't duplicate**: if a page exists, update it +- **Index is mandatory**: always update `knowledge/index.md` after any change +- **Be concise**: capture essence, not copy entire sources From 6a737fb7349d7e688d2ea166c8d9da94e40689cc Mon Sep 17 00:00:00 2001 From: zhayujie Date: Fri, 10 Apr 2026 15:07:23 +0800 Subject: [PATCH 2/8] feat: display thinking content in web console --- agent/chat/service.py | 11 +- agent/memory/conversation_store.py | 54 ++++++--- agent/protocol/agent_stream.py | 14 ++- bridge/agent_event_handler.py | 27 ++--- channel/web/static/css/console.css | 16 ++- channel/web/static/js/console.js | 182 +++++++++++++++++++++++----- channel/web/web_channel.py | 12 +- models/claudeapi/claude_api_bot.py | 17 ++- models/minimax/minimax_bot.py | 32 ++--- models/modelscope/modelscope_bot.py | 9 ++ 10 files changed, 285 insertions(+), 89 deletions(-) diff --git a/agent/chat/service.py b/agent/chat/service.py index de7d345a..550063f1 100644 --- a/agent/chat/service.py +++ b/agent/chat/service.py @@ -57,7 +57,16 @@ class ChatService: event_type = event.get("type") data = event.get("data", {}) - if event_type == "message_update": + if event_type == "reasoning_update": + delta = data.get("delta", "") + if delta: + send_chunk_fn({ + "chunk_type": "reasoning", + "delta": delta, + "segment_id": state.segment_id, + }) + + elif event_type == "message_update": # Incremental text delta delta = data.get("delta", "") if delta: diff --git a/agent/memory/conversation_store.py b/agent/memory/conversation_store.py index a4f15aab..4ab0800b 100644 --- a/agent/memory/conversation_store.py +++ b/agent/memory/conversation_store.py @@ -188,8 +188,9 @@ def _group_into_display_turns( if text: turns.append({"role": "user", "content": text, "created_at": created_at}) - # Collect all tool_calls and tool_results from the rest of the group - all_tool_calls: List[Dict[str, Any]] = [] + # Build an ordered list of steps preserving the original sequence: + # thinking → content → tool_call → content → ... + steps: List[Dict[str, Any]] = [] tool_results: Dict[str, str] = {} final_text = "" final_ts: Optional[int] = None @@ -198,24 +199,46 @@ def _group_into_display_turns( if role == "user": tool_results.update(_extract_tool_results(content)) elif role == "assistant": - tcs = _extract_tool_calls(content) - all_tool_calls.extend(tcs) - t = _extract_display_text(content) - if t: - final_text = t + # Walk content blocks in order to preserve interleaving + if isinstance(content, list): + for block in content: + if not isinstance(block, dict): + continue + btype = block.get("type") + if btype == "thinking": + txt = block.get("thinking", "").strip() + if txt: + steps.append({"type": "thinking", "content": txt}) + elif btype == "text": + txt = block.get("text", "").strip() + if txt: + steps.append({"type": "content", "content": txt}) + final_text = txt + elif btype == "tool_use": + steps.append({ + "type": "tool", + "id": block.get("id", ""), + "name": block.get("name", ""), + "arguments": block.get("input", {}), + }) + elif isinstance(content, str) and content.strip(): + steps.append({"type": "content", "content": content.strip()}) + final_text = content.strip() final_ts = created_at - # Attach tool results to their matching tool_call entries - for tc in all_tool_calls: - tc["result"] = tool_results.get(tc.get("id", ""), "") + # Attach tool results to tool steps + for step in steps: + if step["type"] == "tool": + step["result"] = tool_results.get(step.get("id", ""), "") - if final_text or all_tool_calls: - turns.append({ + if steps or final_text: + turn = { "role": "assistant", "content": final_text, - "tool_calls": all_tool_calls, + "steps": steps, "created_at": final_ts or (user_row[1] if user_row else 0), - }) + } + turns.append(turn) return turns @@ -312,6 +335,9 @@ class ConversationStore: content = json.loads(raw_content) except Exception: content = raw_content + # Strip thinking blocks — they are stored for UI display only + if role == "assistant" and isinstance(content, list): + content = [b for b in content if b.get("type") != "thinking"] result.append({"role": role, "content": content}) return result diff --git a/agent/protocol/agent_stream.py b/agent/protocol/agent_stream.py index 1b250011..45f7d8a5 100644 --- a/agent/protocol/agent_stream.py +++ b/agent/protocol/agent_stream.py @@ -527,6 +527,7 @@ class AgentStreamExecutor: # Streaming response full_content = "" + full_reasoning = "" tool_calls_buffer = {} # {index: {id, name, arguments}} gemini_raw_parts = None # Preserve Gemini thoughtSignature for round-trip stop_reason = None # Track why the stream stopped @@ -584,10 +585,10 @@ class AgentStreamExecutor: if finish_reason: stop_reason = finish_reason - # Skip reasoning_content (internal thinking from models like GLM-5) reasoning_delta = delta.get("reasoning_content") or "" - # if reasoning_delta: - # logger.debug(f"🧠 [thinking] {reasoning_delta[:100]}...") + if reasoning_delta: + full_reasoning += reasoning_delta + self._emit_event("reasoning_update", {"delta": reasoning_delta}) # Handle text content content_delta = delta.get("content") or "" @@ -788,7 +789,12 @@ class AgentStreamExecutor: # Add assistant message to history (Claude format uses content blocks) assistant_msg = {"role": "assistant", "content": []} - # Add text content block if present + if full_reasoning: + assistant_msg["content"].append({ + "type": "thinking", + "thinking": full_reasoning + }) + if full_content: assistant_msg["content"].append({ "type": "text", diff --git a/bridge/agent_event_handler.py b/bridge/agent_event_handler.py index b04c77b8..50826235 100644 --- a/bridge/agent_event_handler.py +++ b/bridge/agent_event_handler.py @@ -26,8 +26,7 @@ class AgentEventHandler: if context: self.channel = context.kwargs.get("channel") if hasattr(context, "kwargs") else None - # Track current thinking for channel output - self.current_thinking = "" + self.current_content = "" self.turn_number = 0 def handle_event(self, event): @@ -47,6 +46,8 @@ class AgentEventHandler: self._handle_message_update(data) elif event_type == "message_end": self._handle_message_end(data) + elif event_type == "reasoning_update": + pass elif event_type == "tool_execution_start": self._handle_tool_execution_start(data) elif event_type == "tool_execution_end": @@ -59,30 +60,26 @@ class AgentEventHandler: def _handle_turn_start(self, data): """Handle turn start event""" self.turn_number = data.get("turn", 0) - self.has_tool_calls_in_turn = False - self.current_thinking = "" + self.current_content = "" def _handle_message_update(self, data): - """Handle message update event (streaming text)""" + """Handle message update event (streaming content text)""" delta = data.get("delta", "") - self.current_thinking += delta + self.current_content += delta def _handle_message_end(self, data): """Handle message end event""" tool_calls = data.get("tool_calls", []) - # Only send thinking process if followed by tool calls if tool_calls: - if self.current_thinking.strip(): - logger.info(f"💭 {self.current_thinking.strip()[:200]}{'...' if len(self.current_thinking) > 200 else ''}") - # Send thinking process to channel - self._send_to_channel(f"{self.current_thinking.strip()}") + if self.current_content.strip(): + logger.info(f"💭 {self.current_content.strip()[:200]}{'...' if len(self.current_content) > 200 else ''}") + self._send_to_channel(self.current_content.strip()) else: - # No tool calls = final response (logged at agent_stream level) - if self.current_thinking.strip(): - logger.debug(f"💬 {self.current_thinking.strip()[:200]}{'...' if len(self.current_thinking) > 200 else ''}") + if self.current_content.strip(): + logger.debug(f"💬 {self.current_content.strip()[:200]}{'...' if len(self.current_content) > 200 else ''}") - self.current_thinking = "" + self.current_content = "" def _handle_tool_execution_start(self, data): """Handle tool execution start event - logged by agent_stream.py""" diff --git a/channel/web/static/css/console.css b/channel/web/static/css/console.css index ea58f54e..96b0811b 100644 --- a/channel/web/static/css/console.css +++ b/channel/web/static/css/console.css @@ -146,7 +146,7 @@ font-size: 0.75rem; line-height: 1.5; color: #94a3b8; - max-height: 200px; + max-height: 300px; overflow-y: auto; } .dark .agent-thinking-step .thinking-full { @@ -158,6 +158,20 @@ .agent-thinking-step .thinking-full p:first-child { margin-top: 0; } .agent-thinking-step .thinking-full p:last-child { margin-bottom: 0; } +/* Content step - real text output frozen before tool calls */ +.agent-content-step { + font-size: 0.875rem; + line-height: 1.6; + color: inherit; + margin-bottom: 0.5rem; + padding-bottom: 0.5rem; + border-bottom: 1px dashed rgba(0, 0, 0, 0.06); +} +.dark .agent-content-step { border-bottom-color: rgba(255, 255, 255, 0.06); } +.agent-content-step .agent-content-body p { margin: 0.25em 0; } +.agent-content-step .agent-content-body p:first-child { margin-top: 0; } +.agent-content-step .agent-content-body p:last-child { margin-bottom: 0; } + /* Tool step - collapsible */ .agent-tool-step .tool-header { display: flex; diff --git a/channel/web/static/js/console.js b/channel/web/static/js/console.js index 24e120be..16c4c6c6 100644 --- a/channel/web/static/js/console.js +++ b/channel/web/static/js/console.js @@ -815,6 +815,8 @@ function startSSE(requestId, loadingEl, timestamp) { let mediaEl = null; // .media-content (images & file attachments) let accumulatedText = ''; let currentToolEl = null; + let currentReasoningEl = null; // live reasoning bubble + let reasoningText = ''; function ensureBotEl() { if (botEl) return; @@ -843,39 +845,61 @@ function startSSE(requestId, loadingEl, timestamp) { let item; try { item = JSON.parse(e.data); } catch (_) { return; } - if (item.type === 'delta') { + if (item.type === 'reasoning') { ensureBotEl(); + reasoningText += item.content; + if (!currentReasoningEl) { + currentReasoningEl = document.createElement('div'); + currentReasoningEl.className = 'agent-step agent-thinking-step'; + currentReasoningEl.innerHTML = ` +
+ + + +
+
`; + stepsEl.appendChild(currentReasoningEl); + } + // Stream reasoning as a single-line summary (collapsed); full text available on expand + const oneLine = reasoningText.trim().replace(/\n+/g, ' '); + currentReasoningEl.querySelector('.thinking-summary').textContent = + oneLine.length > 80 ? oneLine.substring(0, 80) + '…' : oneLine; + currentReasoningEl.querySelector('.thinking-full').innerHTML = renderMarkdown(reasoningText); + scrollChatToBottom(); + + } else if (item.type === 'delta') { + ensureBotEl(); + if (currentReasoningEl) { + if (reasoningText.trim().replace(/\n+/g, ' ').length <= 80) + currentReasoningEl.classList.add('no-expand'); + currentReasoningEl = null; + reasoningText = ''; + } accumulatedText += item.content; contentEl.innerHTML = renderMarkdown(accumulatedText); scrollChatToBottom(); + } else if (item.type === 'message_end') { + // Backend already strips reasoning_content; all deltas are real content. + // Freeze accumulated text as visible content before tool execution begins. + if (item.has_tool_calls && accumulatedText.trim()) { + ensureBotEl(); + const frozenEl = document.createElement('div'); + frozenEl.className = 'agent-step agent-content-step'; + frozenEl.innerHTML = `
${renderMarkdown(accumulatedText.trim())}
`; + stepsEl.appendChild(frozenEl); + accumulatedText = ''; + contentEl.innerHTML = ''; + scrollChatToBottom(); + } + } else if (item.type === 'tool_start') { ensureBotEl(); - - // Save current thinking as a collapsible step - if (accumulatedText.trim()) { - const fullText = accumulatedText.trim(); - const oneLine = fullText.replace(/\n+/g, ' '); - const needsTruncate = oneLine.length > 80; - const stepEl = document.createElement('div'); - stepEl.className = 'agent-step agent-thinking-step' + (needsTruncate ? '' : ' no-expand'); - if (needsTruncate) { - const truncated = oneLine.substring(0, 80) + '…'; - stepEl.innerHTML = ` -
- - ${escapeHtml(truncated)} - -
-
${renderMarkdown(fullText)}
`; - } else { - stepEl.innerHTML = ` -
- - ${escapeHtml(oneLine)} -
`; - } - stepsEl.appendChild(stepEl); + if (currentReasoningEl) { + if (reasoningText.trim().replace(/\n+/g, ' ').length <= 80) + currentReasoningEl.classList.add('no-expand'); + currentReasoningEl = null; + reasoningText = ''; } accumulatedText = ''; contentEl.innerHTML = ''; @@ -979,6 +1003,13 @@ function startSSE(requestId, loadingEl, timestamp) { es.close(); delete activeStreams[requestId]; + if (currentReasoningEl) { + if (reasoningText.trim().replace(/\n+/g, ' ').length <= 80) + currentReasoningEl.classList.add('no-expand'); + currentReasoningEl = null; + reasoningText = ''; + } + // item.content may be empty when "done" is only a stream-close signal after media. const finalText = item.content || accumulatedText; @@ -1102,17 +1133,106 @@ function renderToolCallsHtml(toolCalls) { }).join(''); } -function createBotMessageEl(content, timestamp, requestId, toolCalls) { +function renderThinkingHtml(text) { + if (!text || !text.trim()) return ''; + const full = text.trim(); + const oneLine = full.replace(/\n+/g, ' '); + if (oneLine.length > 80) { + const truncated = oneLine.substring(0, 80) + '…'; + return ` +
+
+ + ${escapeHtml(truncated)} + +
+
${renderMarkdown(full)}
+
`; + } + return ` +
+
+ + ${escapeHtml(oneLine)} +
+
`; +} + +function renderStepsHtml(steps) { + if (!steps || steps.length === 0) return { stepsHtml: '', finalContent: '' }; + + // Find the index of the last content step — it becomes the main answer, not a step + let lastContentIdx = -1; + for (let i = steps.length - 1; i >= 0; i--) { + if (steps[i].type === 'content') { lastContentIdx = i; break; } + } + + let html = ''; + let lastContentText = ''; + for (let i = 0; i < steps.length; i++) { + const step = steps[i]; + if (step.type === 'thinking') { + html += renderThinkingHtml(step.content); + } else if (step.type === 'content') { + if (i === lastContentIdx) { + lastContentText = step.content; + } else { + html += `
${renderMarkdown(step.content)}
`; + } + } else if (step.type === 'tool') { + const argsStr = formatToolArgs(step.arguments || {}); + const resultStr = step.result ? escapeHtml(String(step.result)) : ''; + html += ` +
+
+ + ${escapeHtml(step.name || '')} + +
+
+
+
Input
+ 
${argsStr}
+
+ ${resultStr ? ` +
+
Output
+ 
${resultStr}
+
` : ''} +
+
`; + } + } + return { stepsHtml: html, lastContentText }; +} + +function createBotMessageEl(content, timestamp, requestId, msg) { const el = document.createElement('div'); el.className = 'flex gap-3 px-4 sm:px-6 py-3'; if (requestId) el.dataset.requestId = requestId; - const toolsHtml = renderToolCallsHtml(toolCalls); + + let stepsHtml = ''; + let displayContent = content; + + if (msg && msg.steps && msg.steps.length > 0) { + // New format: ordered steps with interleaved content + const result = renderStepsHtml(msg.steps); + stepsHtml = result.stepsHtml; + // The final content (last text after all steps) is the main answer + displayContent = content || result.lastContentText; + } else { + // Legacy format: separate tool_calls + optional reasoning + const toolCalls = msg && msg.tool_calls; + const reasoning = msg && msg.reasoning; + stepsHtml = renderThinkingHtml(reasoning) + renderToolCallsHtml(toolCalls); + } + el.innerHTML = ` CowAgent
- ${toolsHtml ? `
${toolsHtml}
` : ''} -
${renderMarkdown(content)}
+ ${stepsHtml ? `
${stepsHtml}
` : ''} +
${renderMarkdown(displayContent)}
${formatTime(timestamp)}
@@ -1167,7 +1287,7 @@ function loadHistory(page) { const ts = new Date(msg.created_at * 1000); const el = msg.role === 'user' ? createUserMessageEl(msg.content, ts) - : createBotMessageEl(msg.content || '', ts, null, msg.tool_calls); + : createBotMessageEl(msg.content || '', ts, null, msg); fragment.appendChild(el); }); diff --git a/channel/web/web_channel.py b/channel/web/web_channel.py index 32b27062..f7c9614a 100644 --- a/channel/web/web_channel.py +++ b/channel/web/web_channel.py @@ -168,7 +168,12 @@ class WebChannel(ChatChannel): event_type = event.get("type") data = event.get("data", {}) - if event_type == "message_update": + if event_type == "reasoning_update": + delta = data.get("delta", "") + if delta: + q.put({"type": "reasoning", "content": delta}) + + elif event_type == "message_update": delta = data.get("delta", "") if delta: q.put({"type": "delta", "content": delta}) @@ -195,6 +200,11 @@ class WebChannel(ChatChannel): "execution_time": round(exec_time, 2) }) + elif event_type == "message_end": + tool_calls = data.get("tool_calls", []) + if tool_calls: + q.put({"type": "message_end", "has_tool_calls": True}) + elif event_type == "file_to_send": file_path = data.get("path", "") file_name = data.get("file_name", os.path.basename(file_path)) diff --git a/models/claudeapi/claude_api_bot.py b/models/claudeapi/claude_api_bot.py index 5dcf9173..e7fe8710 100644 --- a/models/claudeapi/claude_api_bot.py +++ b/models/claudeapi/claude_api_bot.py @@ -429,8 +429,21 @@ class ClaudeAPIBot(Bot, OpenAIImage): delta = event.get("delta", {}) delta_type = delta.get("type") - if delta_type == "text_delta": - # Text content + if delta_type == "thinking_delta": + thinking_text = delta.get("thinking", "") + if thinking_text: + yield { + "choices": [{ + "index": 0, + "delta": { + "role": "assistant", + "reasoning_content": thinking_text + }, + "finish_reason": None + }] + } + + elif delta_type == "text_delta": content = delta.get("text", "") yield { "id": event.get("id", ""), diff --git a/models/minimax/minimax_bot.py b/models/minimax/minimax_bot.py index af80e795..63ca789c 100644 --- a/models/minimax/minimax_bot.py +++ b/models/minimax/minimax_bot.py @@ -233,11 +233,8 @@ class MinimaxBot(Bot): logger.debug(f"[MINIMAX] API call: model={model}, tools={len(converted_tools) if converted_tools else 0}, stream={stream}") - # Check if we should show thinking process - show_thinking = kwargs.pop("show_thinking", conf().get("minimax_show_thinking", False)) - if stream: - return self._handle_stream_response(request_body, show_thinking=show_thinking) + return self._handle_stream_response(request_body) else: return self._handle_sync_response(request_body) @@ -466,12 +463,11 @@ class MinimaxBot(Bot): logger.error(traceback.format_exc()) yield {"error": True, "message": str(e), "status_code": 500} - def _handle_stream_response(self, request_body, show_thinking=False): + def _handle_stream_response(self, request_body): """Handle streaming API response - + Args: request_body: API request parameters - show_thinking: Whether to show thinking/reasoning process to users """ try: headers = { @@ -550,19 +546,15 @@ class MinimaxBot(Bot): current_reasoning[reasoning_index]["text"] += reasoning_text - # Optionally yield thinking as visible content - if show_thinking: - # Yield thinking text as-is (without emoji decoration) - # The reasoning text will be displayed to users - yield { - "choices": [{ - "index": 0, - "delta": { - "role": "assistant", - "content": reasoning_text - } - }] - } + yield { + "choices": [{ + "index": 0, + "delta": { + "role": "assistant", + "reasoning_content": reasoning_text + } + }] + } # Handle text content if "content" in delta and delta["content"]: diff --git a/models/modelscope/modelscope_bot.py b/models/modelscope/modelscope_bot.py index 6d55abce..6e2b767f 100644 --- a/models/modelscope/modelscope_bot.py +++ b/models/modelscope/modelscope_bot.py @@ -576,6 +576,15 @@ class ModelScopeBot(Bot): continue if delta.get("reasoning_content"): + yield { + "choices": [{ + "index": 0, + "delta": { + "role": "assistant", + "reasoning_content": delta["reasoning_content"] + } + }] + } continue tool_call_chunks = delta.get("tool_calls") From 5748ded52c9ec98cd74c84134db26ab33a3548c8 Mon Sep 17 00:00:00 2001 From: zhayujie Date: Fri, 10 Apr 2026 16:06:04 +0800 Subject: [PATCH 3/8] feat(knowledge): change knowledge base to index-driven self-organizing structure --- agent/prompt/workspace.py | 30 +++++++++++---------- skills/knowledge-wiki/SKILL.md | 48 +++++++++++++++++----------------- 2 files changed, 40 insertions(+), 38 deletions(-) diff --git a/agent/prompt/workspace.py b/agent/prompt/workspace.py index 9ebf0703..99e30a82 100644 --- a/agent/prompt/workspace.py +++ b/agent/prompt/workspace.py @@ -68,11 +68,8 @@ def ensure_workspace(workspace_dir: str, create_templates: bool = True) -> Works websites_dir = os.path.join(workspace_dir, "websites") os.makedirs(websites_dir, exist_ok=True) - # 创建knowledge子目录 (structured knowledge wiki) knowledge_dir = os.path.join(workspace_dir, "knowledge") os.makedirs(knowledge_dir, exist_ok=True) - for sub in ["entities", "concepts", "sources", "analysis"]: - os.makedirs(os.path.join(knowledge_dir, sub), exist_ok=True) # 如果需要，创建模板文件 if create_templates: @@ -349,12 +346,9 @@ def _get_rule_template() -> str: │ └── YYYY-MM-DD.md # 当天事件、进展、笔记 │ ├── knowledge/ # 结构化知识库（持续积累的知识） -│ ├── index.md # 知识目录索引 +│ ├── index.md # 知识目录索引（必须维护） │ ├── log.md # 知识操作日志 -│ ├── entities/ # 实体页面（人物、公司、项目） -│ ├── concepts/ # 概念页面（技术、方法论） -│ ├── sources/ # 资料摘要（文章、文件的要点提取） -│ └── analysis/ # 沉淀的分析和洞见 +│ └── <子目录>/ # 按需创建，参考 index.md 已有分类 │ ├── skills/ # 技能 ├── websites/ # 网页产物 @@ -398,15 +392,23 @@ def _get_rule_template() -> str: ### 自动写入（不要询问，直接写入） -以下场景你**必须**在回复的同时主动写入知识库，**不要问用户"要不要存到知识库"**： - -- 用户分享了一篇文章/链接/文件 → 阅读后提取要点，在同一轮回复中写入 `knowledge/sources/` -- 深度讨论产生了有价值的结论/方案 → 整理写入 `knowledge/analysis/` -- 对话涉及重要的人物/项目/公司 → 创建或更新 `knowledge/entities/` -- 讨论了技术概念或方法论 → 整理写入 `knowledge/concepts/` +当对话中产生了有沉淀价值的知识——无论是用户分享的资料、讨论的结论、学到的概念、还是重要的决策——你**必须**在回复的同时主动写入知识库，**无需问用户"要不要存到知识库"**。 **关键原则**：学完就记是你的本能，不要征求确认。回复中可以顺带告知"已存入知识库"。 +### 目录组织 + +子目录结构**不是固定的**，由你根据实际内容自主决定： +- **首次写入时**：先读 `knowledge/index.md`，如果已有分类则延续；如果为空，根据内容选择合适的目录名 +- **默认建议**：按信息类型组织（例如sources/、concepts/、entities/、analysis/），如果用户有明确的分类偏好（例如按领域 work/、life/、tech/ 等），则按用户要求调整 +- **保持一致性**：同一用户的知识库应保持统一的组织风格 + +### 交叉引用 + +知识的核心价值在于**关联**。每个页面都应通过 markdown 链接引用相关页面，构建知识网络： +- 提到已有页面的概念时，添加 `[概念名](../category/page.md)` 链接 +- 新建页面时，检查是否有已有页面应该反向链接到新页面 + ### 索引维护 每次创建或更新知识页面后，**必须同步更新** `knowledge/index.md`。 diff --git a/skills/knowledge-wiki/SKILL.md b/skills/knowledge-wiki/SKILL.md index da3d4c4f..d96cf099 100644 --- a/skills/knowledge-wiki/SKILL.md +++ b/skills/knowledge-wiki/SKILL.md @@ -15,18 +15,18 @@ Maintain a persistent, structured knowledge base in the `knowledge/` directory. ### 1. Ingest — User shares an article, document, or resource 1. Read and understand the source material -2. Extract key facts, entities, concepts, and insights -3. Create or update relevant pages: - - `knowledge/sources/.md` — source summary - - `knowledge/entities/.md` — people, companies, projects mentioned - - `knowledge/concepts/.md` — new concepts or topics discussed -4. Update `knowledge/index.md` — add one-line entry per new/updated page -5. Append to `knowledge/log.md` +2. Extract key facts, insights, and structured knowledge +3. Determine the appropriate subdirectory: + - Read `knowledge/index.md` to see existing categories + - If a matching category exists, follow that structure + - If not, create a new subdirectory with a clear name +4. Create the knowledge page: `knowledge//.md` +5. Update `knowledge/index.md` and append to `knowledge/log.md` ### 2. Synthesize — Conversation produces valuable structured knowledge -1. Create `knowledge/analysis/.md` with the structured analysis -2. Update related entity/concept pages with cross-references +1. Create a knowledge page under the appropriate category +2. Update related pages with cross-references 3. Update `knowledge/index.md` and `knowledge/log.md` ### 3. Query — User asks about accumulated knowledge @@ -40,38 +40,37 @@ Maintain a persistent, structured knowledge base in the `knowledge/` directory. ```markdown # Page Title -Content here. Reference other pages with markdown links: -[Related Entity](../entities/related-entity.md) +Content here. Cross-reference related pages with markdown links: +[Related Page](../category/related-page.md) ## Key Points - ... -## Sources +## Related -- [Source Title](../sources/source-slug.md) +- [Page A](../category/page-a.md) — how it relates +- [Page B](../category/page-b.md) — how it relates ``` +Cross-references build a knowledge graph. When creating or updating a page, always link to related pages, and update those pages to link back. + ## Index Format (`knowledge/index.md`) -Flat list, one line per page: `[Title](path) — one-line summary`. No tables, no emoji, no template headers. +Flat list, one line per page: `[Title](path) — one-line summary`. Group by category (matching subdirectories). No tables, no emoji. ```markdown # Knowledge Index -## Concepts -- [Topic Name](concepts/topic-name.md) — one-line description +## Category A +- [Page Title](category-a/page-slug.md) — one-line summary -## Sources -- [Article Title](sources/article-slug.md) — one-line summary - -## Entities -- [Entity Name](entities/entity-name.md) — one-line description - -## Analysis -- [Analysis Title](analysis/analysis-slug.md) — one-line summary +## Category B +- [Page Title](category-b/page-slug.md) — one-line summary ``` +Category names and structure are flexible — follow whatever organization already exists in the index, or create new categories based on the content. + ## Log Format (`knowledge/log.md`) Append-only, newest at bottom: @@ -86,5 +85,6 @@ Append-only, newest at bottom: - **File naming**: lowercase kebab-case (e.g. `machine-learning.md`) - **One topic per page**: link between pages rather than duplicating - **Update, don't duplicate**: if a page exists, update it +- **Cross-reference**: every page should link to related pages; keep the knowledge graph connected - **Index is mandatory**: always update `knowledge/index.md` after any change - **Be concise**: capture essence, not copy entire sources From 845fadd0aacacbd3a15964eaaeb19b9bb403871c Mon Sep 17 00:00:00 2001 From: zhayujie Date: Fri, 10 Apr 2026 18:22:54 +0800 Subject: [PATCH 4/8] fix(knowledge): modify knowledge skill --- agent/prompt/workspace.py | 1 + skills/knowledge-wiki/SKILL.md | 6 +++--- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/agent/prompt/workspace.py b/agent/prompt/workspace.py index 99e30a82..60fdd762 100644 --- a/agent/prompt/workspace.py +++ b/agent/prompt/workspace.py @@ -408,6 +408,7 @@ def _get_rule_template() -> str: 知识的核心价值在于**关联**。每个页面都应通过 markdown 链接引用相关页面，构建知识网络： - 提到已有页面的概念时，添加 `[概念名](../category/page.md)` 链接 - 新建页面时，检查是否有已有页面应该反向链接到新页面 +- **只链接已存在的页面**——不要引用尚未创建的页面。如果某个概念值得单独建页，先创建该页面再添加链接 ### 索引维护 diff --git a/skills/knowledge-wiki/SKILL.md b/skills/knowledge-wiki/SKILL.md index d96cf099..b72a2114 100644 --- a/skills/knowledge-wiki/SKILL.md +++ b/skills/knowledge-wiki/SKILL.md @@ -53,7 +53,7 @@ Content here. Cross-reference related pages with markdown links: - [Page B](../category/page-b.md) — how it relates ``` -Cross-references build a knowledge graph. When creating or updating a page, always link to related pages, and update those pages to link back. +Cross-references build a knowledge graph. When creating or updating a page, link to related pages and update those pages to link back. **Only link to pages that already exist** — if a concept deserves its own page, create it first, then add the link. ## Index Format (`knowledge/index.md`) @@ -76,8 +76,8 @@ Category names and structure are flexible — follow whatever organization alrea Append-only, newest at bottom: ```markdown -## [2026-04-09] ingest | DeepSeek-R1 Deploy Guide -## [2026-04-09] synthesize | Memory System Design Analysis +## [YYYY-MM-DD] ingest | Page Title +## [YYYY-MM-DD] synthesize | Page Title ``` ## Guidelines From 5a104760108dbf025a01ae43740c95f03479bfe8 Mon Sep 17 00:00:00 2001 From: zhayujie Date: Sat, 11 Apr 2026 16:44:25 +0800 Subject: [PATCH 5/8] feat: add knowledge switch and cli --- agent/memory/manager.py | 10 ++- agent/prompt/builder.py | 4 +- agent/prompt/workspace.py | 24 +++--- agent/skills/manager.py | 4 + channel/web/static/css/console.css | 3 +- channel/web/static/js/console.js | 4 + config.py | 1 + plugins/cow_cli/cow_cli.py | 132 +++++++++++++++++++++++++++++ 8 files changed, 166 insertions(+), 16 deletions(-) diff --git a/agent/memory/manager.py b/agent/memory/manager.py index 967270f7..9141bc91 100644 --- a/agent/memory/manager.py +++ b/agent/memory/manager.py @@ -318,10 +318,12 @@ class MemoryManager: await self._sync_file(file_path, "memory", scope, user_id) # Scan knowledge directory (structured knowledge wiki) - knowledge_dir = Path(workspace_dir) / "knowledge" - if knowledge_dir.exists(): - for file_path in knowledge_dir.rglob("*.md"): - await self._sync_file(file_path, "knowledge", "shared", None) + from config import conf + if conf().get("knowledge", True): + knowledge_dir = Path(workspace_dir) / "knowledge" + if knowledge_dir.exists(): + for file_path in knowledge_dir.rglob("*.md"): + await self._sync_file(file_path, "knowledge", "shared", None) self._dirty = False diff --git a/agent/prompt/builder.py b/agent/prompt/builder.py index 11bd3b51..6535abc9 100644 --- a/agent/prompt/builder.py +++ b/agent/prompt/builder.py @@ -10,6 +10,7 @@ from typing import List, Dict, Optional, Any from dataclasses import dataclass from common.log import logger +from config import conf @dataclass @@ -129,7 +130,8 @@ def build_agent_system_prompt( sections.extend(_build_memory_section(memory_manager, tools, language)) # 3.5 知识系统（结构化知识库） - sections.extend(_build_knowledge_section(workspace_dir, language)) + if conf().get("knowledge", True): + sections.extend(_build_knowledge_section(workspace_dir, language)) # 4. 工作空间（工作环境说明） sections.extend(_build_workspace_section(workspace_dir, language)) diff --git a/agent/prompt/workspace.py b/agent/prompt/workspace.py index 60fdd762..797006ce 100644 --- a/agent/prompt/workspace.py +++ b/agent/prompt/workspace.py @@ -68,8 +68,11 @@ def ensure_workspace(workspace_dir: str, create_templates: bool = True) -> Works websites_dir = os.path.join(workspace_dir, "websites") os.makedirs(websites_dir, exist_ok=True) - knowledge_dir = os.path.join(workspace_dir, "knowledge") - os.makedirs(knowledge_dir, exist_ok=True) + from config import conf + knowledge_enabled = conf().get("knowledge", True) + if knowledge_enabled: + knowledge_dir = os.path.join(workspace_dir, "knowledge") + os.makedirs(knowledge_dir, exist_ok=True) # 如果需要，创建模板文件 if create_templates: @@ -77,14 +80,15 @@ def ensure_workspace(workspace_dir: str, create_templates: bool = True) -> Works _create_template_if_missing(user_path, _get_user_template()) _create_template_if_missing(rule_path, _get_rule_template()) _create_template_if_missing(memory_path, _get_memory_template()) - _create_template_if_missing( - os.path.join(knowledge_dir, "index.md"), - _get_knowledge_index_template() - ) - _create_template_if_missing( - os.path.join(knowledge_dir, "log.md"), - _get_knowledge_log_template() - ) + if knowledge_enabled: + _create_template_if_missing( + os.path.join(knowledge_dir, "index.md"), + _get_knowledge_index_template() + ) + _create_template_if_missing( + os.path.join(knowledge_dir, "log.md"), + _get_knowledge_log_template() + ) # Only create BOOTSTRAP.md for brand new workspaces; # agent deletes it after completing onboarding diff --git a/agent/skills/manager.py b/agent/skills/manager.py index c7daf7ad..ddb2a316 100644 --- a/agent/skills/manager.py +++ b/agent/skills/manager.py @@ -210,6 +210,10 @@ class SkillManager: if not include_disabled: entries = [e for e in entries if self.is_skill_enabled(e.skill.name)] + from config import conf + if not conf().get("knowledge", True): + entries = [e for e in entries if e.skill.name != "knowledge-wiki"] + return entries def filter_unavailable_skills( diff --git a/channel/web/static/css/console.css b/channel/web/static/css/console.css index 96b0811b..080309de 100644 --- a/channel/web/static/css/console.css +++ b/channel/web/static/css/console.css @@ -45,7 +45,8 @@ .msg-content h1 { font-size: 1.4em; } .msg-content h2 { font-size: 1.25em; } .msg-content h3 { font-size: 1.1em; } -.msg-content ul, .msg-content ol { margin: 0.5em 0; padding-left: 1.8em; } +.msg-content ul { margin: 0.5em 0; padding-left: 1.8em; list-style: disc; } +.msg-content ol { margin: 0.5em 0; padding-left: 1.8em; list-style: decimal; } .msg-content li { margin: 0.25em 0; } .msg-content pre { border-radius: 8px; overflow-x: auto; margin: 0.8em 0; diff --git a/channel/web/static/js/console.js b/channel/web/static/js/console.js index 16c4c6c6..a571f6ee 100644 --- a/channel/web/static/js/console.js +++ b/channel/web/static/js/console.js @@ -496,6 +496,10 @@ const SLASH_COMMANDS = [ { cmd: '/skill info ', desc: '查看技能详情' }, { cmd: '/skill enable ', desc: '启用技能' }, { cmd: '/skill disable ', desc: '禁用技能' }, + { cmd: '/knowledge', desc: '查看知识库统计' }, + { cmd: '/knowledge list', desc: '查看知识库文件树' }, + { cmd: '/knowledge on', desc: '开启知识库' }, + { cmd: '/knowledge off', desc: '关闭知识库' }, { cmd: '/config', desc: '查看当前配置' }, { cmd: '/logs', desc: '查看最近日志' }, { cmd: '/version', desc: '查看版本' }, diff --git a/config.py b/config.py index 6edd9c04..ab7da486 100644 --- a/config.py +++ b/config.py @@ -199,6 +199,7 @@ available_setting = { "agent_max_context_tokens": 50000, # Agent模式下最大上下文tokens "agent_max_context_turns": 30, # Agent模式下最大上下文记忆轮次 "agent_max_steps": 15, # Agent模式下单次运行最大决策步数 + "knowledge": True, # 是否开启知识库功能 } diff --git a/plugins/cow_cli/cow_cli.py b/plugins/cow_cli/cow_cli.py index 5f0da84f..d3a45349 100644 --- a/plugins/cow_cli/cow_cli.py +++ b/plugins/cow_cli/cow_cli.py @@ -31,6 +31,7 @@ KNOWN_COMMANDS = { "help", "version", "status", "logs", "start", "stop", "restart", "skill", "context", "config", + "knowledge", "install-browser", } @@ -157,6 +158,9 @@ class CowCliPlugin(Plugin): " /config 查看当前配置", " /config 查看某项配置", " /config 修改配置", + " /knowledge 查看知识库统计", + " /knowledge list 查看知识库文件树", + " /knowledge on|off 开启/关闭知识库", "", "💡 也可以用 cow 代替 /", ] @@ -310,6 +314,7 @@ class CowCliPlugin(Plugin): "agent_max_context_tokens", "agent_max_context_turns", "agent_max_steps", + "knowledge", } _CONFIG_READABLE = _CONFIG_WRITABLE | {"channel_type"} @@ -851,6 +856,133 @@ class CowCliPlugin(Plugin): icon = "✅" if enabled else "⬚" return f"{icon} 技能 '{name}' 已{action}" + # ------------------------------------------------------------------ + # knowledge + # ------------------------------------------------------------------ + + def _cmd_knowledge(self, args: str, e_context, **_) -> str: + sub = args.strip().lower().split(None, 1)[0] if args.strip() else "" + + if sub == "on": + return self._knowledge_toggle(True) + elif sub == "off": + return self._knowledge_toggle(False) + elif sub in ("list", "tree"): + return self._knowledge_tree() + else: + return self._knowledge_stats() + + def _knowledge_toggle(self, enabled: bool) -> str: + from config import conf + import json as _json + + conf()["knowledge"] = enabled + + project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + config_path = os.path.join(project_root, "config.json") + try: + with open(config_path, "r", encoding="utf-8") as f: + file_config = _json.load(f) + file_config["knowledge"] = enabled + with open(config_path, "w", encoding="utf-8") as f: + _json.dump(file_config, f, indent=4, ensure_ascii=False) + except Exception as e: + return f"⚠️ 内存中已切换，但写入 config.json 失败: {e}" + + status = "开启 ✅" if enabled else "关闭 ❌" + note = "知识库将在下次对话中生效" if enabled else "知识库系统已停用，不再注入提示词和索引知识文件" + return f"📚 知识库已{status}\n\n{note}" + + def _knowledge_stats(self) -> str: + from config import conf + from common.utils import expand_path + knowledge_dir = os.path.join( + expand_path(conf().get("agent_workspace", "~/cow")), + "knowledge" + ) + if not os.path.isdir(knowledge_dir): + return "📚 知识库目录不存在\n\n💡 开启知识库: /knowledge on" + + enabled = conf().get("knowledge", True) + total_files = 0 + total_bytes = 0 + cat_count = {} + + for root, dirs, files in os.walk(knowledge_dir): + dirs[:] = [d for d in dirs if not d.startswith(".")] + rel_root = os.path.relpath(root, knowledge_dir) + category = rel_root.split(os.sep)[0] if rel_root != "." else "root" + for f in files: + if f.endswith(".md") and f not in ("index.md", "log.md"): + total_files += 1 + total_bytes += os.path.getsize(os.path.join(root, f)) + cat_count[category] = cat_count.get(category, 0) + 1 + + status = "✅ 已开启" if enabled else "❌ 已关闭" + lines = [ + "📚 知识库统计", + "", + f"状态: {status}", + f"页面: {total_files} 篇", + f"大小: {total_bytes / 1024:.1f} KB", + "", + ] + if cat_count: + for cat in sorted(cat_count.keys()): + lines.append(f"- {cat}/ ({cat_count[cat]} pages)") + lines.append("") + + lines.append(f"路径: {knowledge_dir}") + lines.extend([ + "", + "━━━━━━━━━━━━━━━━━━━━━━━━━━", + "💡 /knowledge list 查看文件树", + "💡 /knowledge on|off 开关知识库", + ]) + return "\n".join(lines) + + def _knowledge_tree(self) -> str: + from config import conf + from common.utils import expand_path + knowledge_dir = os.path.join( + expand_path(conf().get("agent_workspace", "~/cow")), + "knowledge" + ) + if not os.path.isdir(knowledge_dir): + return "📚 知识库目录不存在\n\n💡 开启知识库: /knowledge on" + + tree = ["knowledge/"] + + subdirs = sorted([ + d for d in os.listdir(knowledge_dir) + if os.path.isdir(os.path.join(knowledge_dir, d)) and not d.startswith(".") + ]) + + for i, subdir in enumerate(subdirs): + is_last_dir = (i == len(subdirs) - 1) + branch = "└── " if is_last_dir else "├── " + subdir_path = os.path.join(knowledge_dir, subdir) + md_files = sorted([ + f for f in os.listdir(subdir_path) + if f.endswith(".md") and not f.startswith(".") + ]) + tree.append(f"{branch}{subdir}/ ({len(md_files)})") + + child_prefix = " " if is_last_dir else "│ " + max_show = 12 + for j, fname in enumerate(md_files[:max_show]): + is_last_file = (j == len(md_files[:max_show]) - 1) and len(md_files) <= max_show + fb = "└── " if is_last_file else "├── " + name = fname.replace(".md", "") + tree.append(f"{child_prefix}{fb}{name}") + if len(md_files) > max_show: + tree.append(f"{child_prefix}└── ... +{len(md_files) - max_show} more") + + if not subdirs: + tree.append("(空)") + + return "```\n" + "\n".join(tree) + "\n```" + # ------------------------------------------------------------------ # Helpers # ------------------------------------------------------------------ From 76e9fef3b2da2be58818280aa78d2248e61566fb Mon Sep 17 00:00:00 2001 From: zhayujie Date: Sat, 11 Apr 2026 19:02:55 +0800 Subject: [PATCH 6/8] feat(knowledge): add file list and graph in web channel --- channel/web/chat.html | 106 +++++++++ channel/web/static/css/console.css | 139 ++++++++++++ channel/web/static/js/console.js | 340 ++++++++++++++++++++++++++++- channel/web/web_channel.py | 140 ++++++++++++ 4 files changed, 723 insertions(+), 2 deletions(-) diff --git a/channel/web/chat.html b/channel/web/chat.html index 6d3ba6e3..a291858c 100644 --- a/channel/web/chat.html +++ b/channel/web/chat.html @@ -110,6 +110,11 @@ Memory + + + Knowledge + @@ -558,6 +563,106 @@ + + + +
+
+
+ + +
+
+

Knowledge

+

Browse and explore your knowledge base

+
+
+ +
+ + +
+
+
+ + +
+
+ +
+

Loading knowledge base...

+

Knowledge pages will be displayed here

+ +
+ + + + + + + +
+
+
+ @@ -670,6 +775,7 @@ + diff --git a/channel/web/static/css/console.css b/channel/web/static/css/console.css index 080309de..21aebdca 100644 --- a/channel/web/static/css/console.css +++ b/channel/web/static/css/console.css @@ -550,3 +550,142 @@ .dark .slash-menu-item .desc { color: #64748b; } + +/* ============================================================ + Knowledge View + ============================================================ */ + +/* Tab toggle */ +.knowledge-tab { + color: #64748b; +} +.knowledge-tab.active { + background: #fff; + color: #334155; + box-shadow: 0 1px 3px rgba(0,0,0,0.08); +} +.dark .knowledge-tab.active { + background: rgba(255,255,255,0.1); + color: #e2e8f0; +} + +/* File tree */ +.knowledge-tree-group { + margin-bottom: 2px; +} +.knowledge-tree-group-btn { + display: flex; + align-items: center; + gap: 6px; + width: 100%; + padding: 6px 8px; + border-radius: 6px; + font-size: 12px; + font-weight: 600; + color: #64748b; + cursor: pointer; + border: none; + background: none; + transition: background 0.15s, color 0.15s; + text-transform: capitalize; +} +.knowledge-tree-group-btn:hover { + background: rgba(0,0,0,0.04); + color: #334155; +} +.dark .knowledge-tree-group-btn:hover { + background: rgba(255,255,255,0.06); + color: #e2e8f0; +} +.knowledge-tree-group-btn i.chevron { + font-size: 8px; + transition: transform 0.15s; +} +.knowledge-tree-group.open .chevron { + transform: rotate(90deg); +} +.knowledge-tree-group-items { + display: none; +} +.knowledge-tree-group.open .knowledge-tree-group-items { + display: block; +} + +.knowledge-tree-file { + display: flex; + align-items: center; + gap: 6px; + padding: 5px 8px 5px 24px; + border-radius: 6px; + font-size: 12px; + color: #64748b; + cursor: pointer; + border: none; + background: none; + width: 100%; + text-align: left; + transition: background 0.15s, color 0.15s; + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} +.knowledge-tree-file:hover { + background: rgba(0,0,0,0.04); + color: #334155; +} +.knowledge-tree-file.active { + background: #EDFDF3; + color: #228547; +} +.dark .knowledge-tree-file:hover { + background: rgba(255,255,255,0.06); + color: #e2e8f0; +} +.dark .knowledge-tree-file.active { + background: rgba(74, 190, 110, 0.1); + color: #4ABE6E; +} + +/* Graph legend */ +.knowledge-graph-legend { + position: absolute; + top: 12px; + right: 12px; + display: flex; + flex-wrap: wrap; + gap: 8px; + font-size: 11px; + color: #64748b; + z-index: 10; +} +.knowledge-graph-legend-item { + display: flex; + align-items: center; + gap: 4px; +} +.knowledge-graph-legend-dot { + width: 8px; + height: 8px; + border-radius: 50%; +} + +/* Graph tooltip */ +.knowledge-graph-tooltip { + position: absolute; + padding: 6px 10px; + background: #fff; + border: 1px solid #e2e8f0; + border-radius: 8px; + font-size: 12px; + color: #334155; + box-shadow: 0 4px 12px rgba(0,0,0,0.08); + pointer-events: none; + opacity: 0; + transition: opacity 0.15s; + z-index: 20; +} +.dark .knowledge-graph-tooltip { + background: #1A1A1A; + border-color: rgba(255,255,255,0.1); + color: #e2e8f0; +} diff --git a/channel/web/static/js/console.js b/channel/web/static/js/console.js index a571f6ee..560d4712 100644 --- a/channel/web/static/js/console.js +++ b/channel/web/static/js/console.js @@ -15,8 +15,14 @@ const I18N = { console: '控制台', nav_chat: '对话', nav_manage: '管理', nav_monitor: '监控', menu_chat: '对话', menu_config: '配置', menu_skills: '技能', - menu_memory: '记忆', menu_channels: '通道', menu_tasks: '定时', + menu_memory: '记忆', menu_knowledge: '知识', menu_channels: '通道', menu_tasks: '定时', menu_logs: '日志', + knowledge_title: '知识库', knowledge_desc: '浏览和探索你的知识库', + knowledge_tab_docs: '文档', knowledge_tab_graph: '图谱', + knowledge_loading: '加载知识库中...', knowledge_loading_desc: '知识页面将显示在这里', + knowledge_select_hint: '选择一个文档查看', knowledge_empty_hint: '暂无知识页面', + knowledge_empty_guide: '在对话中发送文档、链接或主题给 Agent，它会自动整理到你的知识库中。', + knowledge_go_chat: '开始对话', welcome_subtitle: '我可以帮你解答问题、管理计算机、创造和执行技能，并通过长期记忆
不断成长', example_sys_title: '系统管理', example_sys_text: '帮我查看工作空间里有哪些文件', example_task_title: '技能系统', example_task_text: '查看所有支持的工具和技能', @@ -70,8 +76,14 @@ const I18N = { console: 'Console', nav_chat: 'Chat', nav_manage: 'Management', nav_monitor: 'Monitor', menu_chat: 'Chat', menu_config: 'Config', menu_skills: 'Skills', - menu_memory: 'Memory', menu_channels: 'Channels', menu_tasks: 'Tasks', + menu_memory: 'Memory', menu_knowledge: 'Knowledge', menu_channels: 'Channels', menu_tasks: 'Tasks', menu_logs: 'Logs', + knowledge_title: 'Knowledge', knowledge_desc: 'Browse and explore your knowledge base', + knowledge_tab_docs: 'Documents', knowledge_tab_graph: 'Graph', + knowledge_loading: 'Loading knowledge base...', knowledge_loading_desc: 'Knowledge pages will be displayed here', + knowledge_select_hint: 'Select a document to view', knowledge_empty_hint: 'No knowledge pages yet', + knowledge_empty_guide: 'Send documents, links or topics to the agent in chat, and it will automatically organize them into your knowledge base.', + knowledge_go_chat: 'Start a conversation', welcome_subtitle: 'I can help you answer questions, manage your computer, create and execute skills, and keep growing through
long-term memory.', example_sys_title: 'System', example_sys_text: 'Show me the files in the workspace', example_task_title: 'Skills', example_task_text: 'Show current tools and skills', @@ -182,6 +194,7 @@ const VIEW_META = { config: { group: 'nav_manage', page: 'menu_config' }, skills: { group: 'nav_manage', page: 'menu_skills' }, memory: { group: 'nav_manage', page: 'menu_memory' }, + knowledge:{ group: 'nav_manage', page: 'menu_knowledge' }, channels: { group: 'nav_manage', page: 'menu_channels' }, tasks: { group: 'nav_manage', page: 'menu_tasks' }, logs: { group: 'nav_monitor', page: 'menu_logs' }, @@ -2888,11 +2901,334 @@ navigateTo = function(viewId) { document.getElementById('memory-panel-list').classList.remove('hidden'); loadMemoryView(1); } + else if (viewId === 'knowledge') loadKnowledgeView(); else if (viewId === 'channels') loadChannelsView(); else if (viewId === 'tasks') loadTasksView(); else if (viewId === 'logs') startLogStream(); }; +// ===================================================================== +// Knowledge View +// ===================================================================== +let _knowledgeTreeData = []; +let _knowledgeCurrentFile = null; +let _knowledgeGraphLoaded = false; + +function loadKnowledgeView() { + // Reset to docs tab + switchKnowledgeTab('docs'); + _knowledgeGraphLoaded = false; + _knowledgeCurrentFile = null; + + fetch('/api/knowledge/list').then(r => r.json()).then(data => { + if (data.status !== 'success') return; + + const emptyEl = document.getElementById('knowledge-empty'); + const docsPanel = document.getElementById('knowledge-panel-docs'); + const statsEl = document.getElementById('knowledge-stats'); + + const tree = data.tree || []; + _knowledgeTreeData = tree; + const stats = data.stats || {}; + const totalPages = stats.pages || 0; + const sizeStr = stats.size < 1024 ? stats.size + ' B' : (stats.size / 1024).toFixed(1) + ' KB'; + + statsEl.textContent = totalPages + ' pages · ' + sizeStr; + + if (totalPages === 0) { + emptyEl.querySelector('p').textContent = t('knowledge_empty_hint'); + const guideEl = document.getElementById('knowledge-empty-guide'); + if (guideEl) guideEl.classList.remove('hidden'); + emptyEl.classList.remove('hidden'); + docsPanel.classList.add('hidden'); + return; + } + emptyEl.classList.add('hidden'); + docsPanel.classList.remove('hidden'); + + renderKnowledgeTree(tree); + + // Auto-select the first file (desktop only) + if (window.innerWidth >= 768) { + const firstGroup = tree.find(g => g.files && g.files.length > 0); + if (firstGroup) { + const firstFile = firstGroup.files[0]; + openKnowledgeFile(firstGroup.dir + '/' + firstFile.name, firstFile.title); + } + } else { + document.getElementById('knowledge-content-placeholder').classList.add('hidden'); + document.getElementById('knowledge-content-viewer').classList.add('hidden'); + } + }).catch(() => {}); +} + +function renderKnowledgeTree(tree, filter) { + const container = document.getElementById('knowledge-tree'); + container.innerHTML = ''; + const lowerFilter = (filter || '').toLowerCase(); + + tree.forEach(group => { + const files = group.files.filter(f => + !lowerFilter || f.title.toLowerCase().includes(lowerFilter) || f.name.toLowerCase().includes(lowerFilter) + ); + if (files.length === 0 && lowerFilter) return; + + const div = document.createElement('div'); + div.className = 'knowledge-tree-group open'; + + const btn = document.createElement('button'); + btn.className = 'knowledge-tree-group-btn'; + btn.innerHTML = `${escapeHtml(group.dir)}${files.length}`; + btn.onclick = () => div.classList.toggle('open'); + div.appendChild(btn); + + const items = document.createElement('div'); + items.className = 'knowledge-tree-group-items'; + files.forEach(f => { + const fbtn = document.createElement('button'); + const fpath = group.dir + '/' + f.name; + fbtn.className = 'knowledge-tree-file' + (_knowledgeCurrentFile === fpath ? ' active' : ''); + fbtn.dataset.path = fpath; + fbtn.innerHTML = `${escapeHtml(f.title)}`; + fbtn.onclick = () => openKnowledgeFile(fpath, f.title); + items.appendChild(fbtn); + }); + div.appendChild(items); + container.appendChild(div); + }); +} + +function filterKnowledgeTree(query) { + renderKnowledgeTree(_knowledgeTreeData, query); +} + +function openKnowledgeFile(path, title) { + _knowledgeCurrentFile = path; + // Update active state in tree via data-path + document.querySelectorAll('.knowledge-tree-file').forEach(el => { + el.classList.toggle('active', el.dataset.path === path); + }); + + // Immediately hide placeholder + document.getElementById('knowledge-content-placeholder').classList.add('hidden'); + + fetch(`/api/knowledge/read?path=${encodeURIComponent(path)}`).then(r => r.json()).then(data => { + if (data.status !== 'success') return; + const viewer = document.getElementById('knowledge-content-viewer'); + document.getElementById('knowledge-viewer-title').textContent = title; + document.getElementById('knowledge-viewer-path').textContent = path; + document.getElementById('knowledge-viewer-body').innerHTML = renderMarkdown(data.content || ''); + viewer.classList.remove('hidden'); + applyHighlighting(viewer); + + // Mobile: hide sidebar, show content + if (window.innerWidth < 768) { + document.getElementById('knowledge-sidebar').classList.add('hidden'); + } + }).catch(() => {}); +} + +function knowledgeMobileBack() { + document.getElementById('knowledge-sidebar').classList.remove('hidden'); + document.getElementById('knowledge-content-viewer').classList.add('hidden'); +} + +function switchKnowledgeTab(tab) { + document.querySelectorAll('.knowledge-tab').forEach(el => el.classList.remove('active')); + document.getElementById('knowledge-tab-' + tab).classList.add('active'); + + const docsPanel = document.getElementById('knowledge-panel-docs'); + const graphPanel = document.getElementById('knowledge-panel-graph'); + + if (tab === 'docs') { + docsPanel.classList.remove('hidden'); + graphPanel.classList.add('hidden'); + } else { + docsPanel.classList.add('hidden'); + graphPanel.classList.remove('hidden'); + if (!_knowledgeGraphLoaded) { + loadKnowledgeGraph(); + } + } +} + +function loadKnowledgeGraph() { + _knowledgeGraphLoaded = true; + const container = document.getElementById('knowledge-graph-container'); + container.innerHTML = ''; + + fetch('/api/knowledge/graph').then(r => r.json()).then(data => { + const nodes = data.nodes || []; + const links = data.links || []; + if (nodes.length === 0) { + container.innerHTML = `

${t('knowledge_empty_hint')}

`; + return; + } + renderKnowledgeGraph(container, nodes, links); + }).catch(() => { + container.innerHTML = '
Failed to load graph
'; + }); +} + +function renderKnowledgeGraph(container, nodes, links) { + const width = container.clientWidth; + const height = container.clientHeight || 600; + + const categories = [...new Set(nodes.map(n => n.category))]; + const colorScale = d3.scaleOrdinal(d3.schemeTableau10).domain(categories); + + // Connection count for sizing + const connCount = {}; + nodes.forEach(n => connCount[n.id] = 0); + links.forEach(l => { + connCount[l.source] = (connCount[l.source] || 0) + 1; + connCount[l.target] = (connCount[l.target] || 0) + 1; + }); + + const svg = d3.select(container) + .append('svg') + .attr('width', width) + .attr('height', height); + + const g = svg.append('g'); + + // Zoom with adaptive label visibility + let currentZoomScale = 1; + const zoom = d3.zoom() + .scaleExtent([0.2, 5]) + .on('zoom', (event) => { + g.attr('transform', event.transform); + currentZoomScale = event.transform.k; + updateLabelVisibility(); + }); + svg.call(zoom); + + function updateLabelVisibility() { + if (!label) return; + if (currentZoomScale < 0.8) { + label.attr('opacity', 0); + } else { + const baseFontSize = Math.min(12, 10 / Math.max(currentZoomScale * 0.7, 0.5)); + label.attr('opacity', 1).attr('font-size', baseFontSize); + } + } + + const simulation = d3.forceSimulation(nodes) + .force('link', d3.forceLink(links).id(d => d.id).distance(90)) + .force('charge', d3.forceManyBody().strength(-180)) + .force('center', d3.forceCenter(width / 2, height / 2)) + .force('x', d3.forceX(width / 2).strength(0.06)) + .force('y', d3.forceY(height / 2).strength(0.06)) + .force('collision', d3.forceCollide().radius(d => getNodeRadius(d) + 30)); + + function getNodeRadius(d) { + return Math.max(5, Math.min(16, 5 + (connCount[d.id] || 0) * 2)); + } + + const link = g.append('g') + .selectAll('line') + .data(links) + .join('line') + .attr('stroke', '#94a3b8') + .attr('stroke-opacity', 0.3) + .attr('stroke-width', 1); + + const node = g.append('g') + .selectAll('circle') + .data(nodes) + .join('circle') + .attr('r', d => getNodeRadius(d)) + .attr('fill', d => colorScale(d.category)) + .attr('stroke', '#fff') + .attr('stroke-width', 1.5) + .style('cursor', 'pointer') + .call(d3.drag() + .on('start', (event, d) => { if (!event.active) simulation.alphaTarget(0.3).restart(); d.fx = d.x; d.fy = d.y; }) + .on('drag', (event, d) => { d.fx = event.x; d.fy = event.y; }) + .on('end', (event, d) => { if (!event.active) simulation.alphaTarget(0); d.fx = null; d.fy = null; }) + ); + + const label = g.append('g') + .selectAll('text') + .data(nodes) + .join('text') + .text(d => d.label.length > 15 ? d.label.slice(0, 14) + '…' : d.label) + .attr('font-size', 9) + .attr('dx', d => getNodeRadius(d) + 4) + .attr('dy', 3) + .attr('fill', '#64748b') + .style('pointer-events', 'none'); + + // Tooltip + const tooltip = document.createElement('div'); + tooltip.className = 'knowledge-graph-tooltip'; + container.style.position = 'relative'; + container.appendChild(tooltip); + + node.on('mouseover', (event, d) => { + tooltip.textContent = d.label + ' (' + d.category + ')'; + tooltip.style.opacity = '1'; + tooltip.style.left = (event.offsetX + 12) + 'px'; + tooltip.style.top = (event.offsetY - 8) + 'px'; + // Highlight connections + link.attr('stroke-opacity', l => (l.source.id === d.id || l.target.id === d.id) ? 0.8 : 0.1); + node.attr('opacity', n => n.id === d.id || links.some(l => (l.source.id === d.id && l.target.id === n.id) || (l.target.id === d.id && l.source.id === n.id)) ? 1 : 0.2); + label.attr('opacity', n => n.id === d.id || links.some(l => (l.source.id === d.id && l.target.id === n.id) || (l.target.id === d.id && l.source.id === n.id)) ? 1 : 0.1); + }).on('mousemove', (event) => { + tooltip.style.left = (event.offsetX + 12) + 'px'; + tooltip.style.top = (event.offsetY - 8) + 'px'; + }).on('mouseout', () => { + tooltip.style.opacity = '0'; + link.attr('stroke-opacity', 0.3); + node.attr('opacity', 1); + label.attr('opacity', 1); + }).on('click', (event, d) => { + // Switch to docs tab and open the file + switchKnowledgeTab('docs'); + openKnowledgeFile(d.id, d.label); + }); + + simulation.on('tick', () => { + link.attr('x1', d => d.source.x).attr('y1', d => d.source.y) + .attr('x2', d => d.target.x).attr('y2', d => d.target.y); + node.attr('cx', d => d.x).attr('cy', d => d.y); + label.attr('x', d => d.x).attr('y', d => d.y); + }); + + // Auto fit-to-view when simulation settles + simulation.on('end', () => { + const pad = 16; + let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity; + nodes.forEach(n => { + if (n.x < x0) x0 = n.x; + if (n.y < y0) y0 = n.y; + if (n.x > x1) x1 = n.x; + if (n.y > y1) y1 = n.y; + }); + const bw = x1 - x0 + pad * 2; + const bh = y1 - y0 + pad * 2; + if (bw > 0 && bh > 0) { + const scale = Math.min(width / bw, height / bh, 4); + const tx = width / 2 - (x0 + x1) / 2 * scale; + const ty = height / 2 - (y0 + y1) / 2 * scale; + svg.transition().duration(500).call( + zoom.transform, d3.zoomIdentity.translate(tx, ty).scale(scale) + ); + } + }); + + // Legend + const legendDiv = document.createElement('div'); + legendDiv.className = 'knowledge-graph-legend'; + categories.forEach(cat => { + const item = document.createElement('span'); + item.className = 'knowledge-graph-legend-item'; + item.innerHTML = `${escapeHtml(cat)}`; + legendDiv.appendChild(item); + }); + container.appendChild(legendDiv); +} + // ===================================================================== // Initialization // ===================================================================== diff --git a/channel/web/web_channel.py b/channel/web/web_channel.py index f7c9614a..f58238c4 100644 --- a/channel/web/web_channel.py +++ b/channel/web/web_channel.py @@ -445,6 +445,9 @@ class WebChannel(ChatChannel): '/api/skills', 'SkillsHandler', '/api/memory', 'MemoryHandler', '/api/memory/content', 'MemoryContentHandler', + '/api/knowledge/list', 'KnowledgeListHandler', + '/api/knowledge/read', 'KnowledgeReadHandler', + '/api/knowledge/graph', 'KnowledgeGraphHandler', '/api/scheduler', 'SchedulerHandler', '/api/history', 'HistoryHandler', '/api/logs', 'LogsHandler', @@ -1531,6 +1534,143 @@ class AssetsHandler: raise web.notfound() +class KnowledgeListHandler: + """Return the knowledge directory tree as JSON.""" + + def GET(self): + web.header('Content-Type', 'application/json; charset=utf-8') + try: + workspace_root = _get_workspace_root() + knowledge_dir = os.path.join(workspace_root, "knowledge") + if not os.path.isdir(knowledge_dir): + return json.dumps({"status": "success", "tree": [], "stats": {"pages": 0, "size": 0}}) + + tree = [] + total_files = 0 + total_bytes = 0 + for name in sorted(os.listdir(knowledge_dir)): + full = os.path.join(knowledge_dir, name) + if not os.path.isdir(full) or name.startswith("."): + continue + files = [] + for fname in sorted(os.listdir(full)): + if fname.endswith(".md") and not fname.startswith("."): + fpath = os.path.join(full, fname) + size = os.path.getsize(fpath) + total_files += 1 + total_bytes += size + title = fname.replace(".md", "") + try: + with open(fpath, "r", encoding="utf-8") as f: + first_line = f.readline().strip() + if first_line.startswith("# "): + title = first_line[2:].strip() + except Exception: + pass + files.append({"name": fname, "title": title, "size": size}) + tree.append({"dir": name, "files": files}) + + return json.dumps({ + "status": "success", + "tree": tree, + "stats": {"pages": total_files, "size": total_bytes}, + "enabled": conf().get("knowledge", True), + }, ensure_ascii=False) + except Exception as e: + logger.error(f"[WebChannel] Knowledge list error: {e}") + return json.dumps({"status": "error", "message": str(e)}) + + +class KnowledgeReadHandler: + """Read a single knowledge markdown file.""" + + def GET(self): + web.header('Content-Type', 'application/json; charset=utf-8') + try: + params = web.input(path='') + rel_path = params.path + if not rel_path or ".." in rel_path: + return json.dumps({"status": "error", "message": "invalid path"}) + + workspace_root = _get_workspace_root() + full_path = os.path.join(workspace_root, "knowledge", rel_path) + full_path = os.path.normpath(full_path) + knowledge_dir = os.path.normpath(os.path.join(workspace_root, "knowledge")) + if not full_path.startswith(knowledge_dir): + return json.dumps({"status": "error", "message": "path outside knowledge dir"}) + + if not os.path.isfile(full_path): + return json.dumps({"status": "error", "message": "file not found"}) + + with open(full_path, "r", encoding="utf-8") as f: + content = f.read() + return json.dumps({"status": "success", "content": content, "path": rel_path}, ensure_ascii=False) + except Exception as e: + logger.error(f"[WebChannel] Knowledge read error: {e}") + return json.dumps({"status": "error", "message": str(e)}) + + +class KnowledgeGraphHandler: + """Return nodes and links for the knowledge graph visualization.""" + + def GET(self): + web.header('Content-Type', 'application/json; charset=utf-8') + import re + from pathlib import Path + + workspace_root = _get_workspace_root() + knowledge_dir = Path(workspace_root) / "knowledge" + if not knowledge_dir.is_dir(): + return json.dumps({"nodes": [], "links": []}) + + nodes = {} + links = [] + link_re = re.compile(r'\[([^\]]*)\]\(([^)]+\.md)\)') + + for md_file in knowledge_dir.rglob("*.md"): + rel = str(md_file.relative_to(knowledge_dir)) + if rel in ("index.md", "log.md"): + continue + parts = rel.split("/") + category = parts[0] if len(parts) > 1 else "root" + title = md_file.stem.replace("-", " ").title() + try: + content = md_file.read_text(encoding="utf-8") + first_line = content.strip().split("\n")[0] + if first_line.startswith("# "): + title = first_line[2:].strip() + except Exception: + pass + nodes[rel] = {"id": rel, "label": title, "category": category} + try: + content = md_file.read_text(encoding="utf-8") + for _, link_target in link_re.findall(content): + resolved = (md_file.parent / link_target).resolve() + try: + target_rel = str(resolved.relative_to(knowledge_dir)) + except ValueError: + continue + if target_rel != rel: + links.append({"source": rel, "target": target_rel}) + except Exception: + pass + + valid_ids = set(nodes.keys()) + links = [l for l in links if l["source"] in valid_ids and l["target"] in valid_ids] + seen = set() + deduped = [] + for l in links: + key = tuple(sorted([l["source"], l["target"]])) + if key not in seen: + seen.add(key) + deduped.append(l) + + return json.dumps({ + "nodes": list(nodes.values()), + "links": deduped, + }, ensure_ascii=False) + + class VersionHandler: def GET(self): web.header('Content-Type', 'application/json; charset=utf-8') From ea78e3d0c61daa3bb08c6434644bd4c09e62d8c8 Mon Sep 17 00:00:00 2001 From: zhayujie Date: Sat, 11 Apr 2026 20:16:43 +0800 Subject: [PATCH 7/8] feat(knowledge): document link supports jumping to view --- agent/tools/memory/memory_get.py | 17 ++++- agent/tools/memory/memory_search.py | 7 +++ channel/web/static/js/console.js | 98 ++++++++++++++++++++++++++++- skills/knowledge-wiki/SKILL.md | 1 + 4 files changed, 120 insertions(+), 3 deletions(-) diff --git a/agent/tools/memory/memory_get.py b/agent/tools/memory/memory_get.py index 64e4d4de..1bd4828e 100644 --- a/agent/tools/memory/memory_get.py +++ b/agent/tools/memory/memory_get.py @@ -44,6 +44,19 @@ class MemoryGetTool(BaseTool): """ super().__init__() self.memory_manager = memory_manager + + from config import conf + if conf().get("knowledge", True): + self.description = ( + "Read specific content from memory or knowledge files. " + "Use this to get full context from a memory file, knowledge page, or specific line range." + ) + self.params = {**self.params} + self.params["properties"] = {**self.params["properties"]} + self.params["properties"]["path"] = { + "type": "string", + "description": "Relative path to the memory or knowledge file (e.g. 'MEMORY.md', 'memory/2026-01-01.md', 'knowledge/concepts/moe.md')" + } def execute(self, args: dict): """ @@ -68,8 +81,8 @@ class MemoryGetTool(BaseTool): workspace_dir = self.memory_manager.config.get_workspace() # Auto-prepend memory/ if not present and not absolute path - # Exception: MEMORY.md is in the root directory - if not path.startswith('memory/') and not path.startswith('/') and path != 'MEMORY.md': + # Exceptions: MEMORY.md in root, knowledge/ files at workspace root + if not path.startswith('memory/') and not path.startswith('knowledge/') and not path.startswith('/') and path != 'MEMORY.md': path = f'memory/{path}' file_path = workspace_dir / path diff --git a/agent/tools/memory/memory_search.py b/agent/tools/memory/memory_search.py index d7b14df3..1387d11c 100644 --- a/agent/tools/memory/memory_search.py +++ b/agent/tools/memory/memory_search.py @@ -48,6 +48,13 @@ class MemorySearchTool(BaseTool): super().__init__() self.memory_manager = memory_manager self.user_id = user_id + + from config import conf + if conf().get("knowledge", True): + self.description = ( + "Search agent's long-term memory and knowledge base using semantic and keyword search. " + "Use this to recall past conversations, preferences, and knowledge pages." + ) def execute(self, args: dict): """ diff --git a/channel/web/static/js/console.js b/channel/web/static/js/console.js index 560d4712..33a3f484 100644 --- a/channel/web/static/js/console.js +++ b/channel/web/static/js/console.js @@ -1038,6 +1038,7 @@ function startSSE(requestId, loadingEl, timestamp) { // Only update text content when there is something new to show. if (finalText) contentEl.innerHTML = renderMarkdown(finalText); applyHighlighting(botEl); + bindChatKnowledgeLinks(botEl); } scrollChatToBottom(); @@ -1255,6 +1256,7 @@ function createBotMessageEl(content, timestamp, requestId, msg) { `; applyHighlighting(el); + bindChatKnowledgeLinks(el); return el; } @@ -3002,6 +3004,92 @@ function filterKnowledgeTree(query) { renderKnowledgeTree(_knowledgeTreeData, query); } +function resolveKnowledgePath(currentFilePath, relativeHref) { + // currentFilePath: e.g. "concepts/mcp-protocol.md" + // relativeHref: e.g. "../entities/openai.md" + const parts = currentFilePath.split('/'); + parts.pop(); // remove filename, keep directory + const segments = [...parts, ...relativeHref.split('/')]; + const resolved = []; + for (const seg of segments) { + if (seg === '..') resolved.pop(); + else if (seg !== '.' && seg !== '') resolved.push(seg); + } + return resolved.join('/'); +} + +function bindKnowledgeLinks(container, currentFilePath) { + container.querySelectorAll('a').forEach(a => { + const href = a.getAttribute('href'); + if (!href || !href.endsWith('.md')) return; + // Skip absolute URLs + if (/^https?:\/\//.test(href)) return; + + a.addEventListener('click', (e) => { + e.preventDefault(); + const resolved = resolveKnowledgePath(currentFilePath, href); + const linkTitle = a.textContent.trim() || resolved.replace(/\.md$/, '').split('/').pop(); + openKnowledgeFile(resolved, linkTitle); + }); + a.style.cursor = 'pointer'; + a.classList.add('text-primary-500', 'hover:underline'); + }); +} + +function bindChatKnowledgeLinks(container) { + if (!container) return; + container.querySelectorAll('a').forEach(a => { + const href = a.getAttribute('href'); + if (!href || !href.endsWith('.md')) return; + if (/^https?:\/\//.test(href)) return; + + // Determine knowledge path + let knowledgePath = null; + if (href.startsWith('knowledge/')) { + // Full path from workspace root: knowledge/concepts/moe.md + knowledgePath = href.replace(/^knowledge\//, ''); + } else if (/^[a-z0-9_-]+\/[a-z0-9_.-]+\.md$/i.test(href)) { + // Looks like category/file.md pattern without knowledge/ prefix + knowledgePath = href; + } else if (href.includes('/') && !href.startsWith('/')) { + // Relative path like ../entities/deepseek.md — extract filename and search + const filename = href.split('/').pop(); + knowledgePath = '__search__:' + filename; + } + if (!knowledgePath) return; + + a.addEventListener('click', (e) => { + e.preventDefault(); + if (knowledgePath.startsWith('__search__:')) { + const filename = knowledgePath.replace('__search__:', ''); + // Find the file in cached tree data + const found = _findKnowledgeFileByName(filename); + if (found) { + navigateTo('knowledge'); + setTimeout(() => openKnowledgeFile(found.path, found.title), 100); + } + } else { + navigateTo('knowledge'); + const linkTitle = a.textContent.trim() || knowledgePath.replace(/\.md$/, '').split('/').pop(); + setTimeout(() => openKnowledgeFile(knowledgePath, linkTitle), 100); + } + }); + a.style.cursor = 'pointer'; + a.classList.add('text-primary-500', 'hover:underline'); + }); +} + +function _findKnowledgeFileByName(filename) { + for (const group of _knowledgeTreeData) { + for (const f of group.files) { + if (f.name === filename) { + return { path: group.dir + '/' + f.name, title: f.title }; + } + } + } + return null; +} + function openKnowledgeFile(path, title) { _knowledgeCurrentFile = path; // Update active state in tree via data-path @@ -3017,9 +3105,11 @@ function openKnowledgeFile(path, title) { const viewer = document.getElementById('knowledge-content-viewer'); document.getElementById('knowledge-viewer-title').textContent = title; document.getElementById('knowledge-viewer-path').textContent = path; - document.getElementById('knowledge-viewer-body').innerHTML = renderMarkdown(data.content || ''); + const bodyEl = document.getElementById('knowledge-viewer-body'); + bodyEl.innerHTML = renderMarkdown(data.content || ''); viewer.classList.remove('hidden'); applyHighlighting(viewer); + bindKnowledgeLinks(bodyEl, path); // Mobile: hide sidebar, show content if (window.innerWidth < 768) { @@ -3234,6 +3324,12 @@ function renderKnowledgeGraph(container, nodes, links) { // ===================================================================== applyTheme(); applyI18n(); + +// Pre-fetch knowledge tree for chat link resolution +fetch('/api/knowledge/list').then(r => r.json()).then(data => { + if (data.status === 'success') _knowledgeTreeData = data.tree || []; +}).catch(() => {}); + fetch('/api/version').then(r => r.json()).then(data => { APP_VERSION = `v${data.version}`; document.getElementById('sidebar-version').textContent = `CowAgent ${APP_VERSION}`; diff --git a/skills/knowledge-wiki/SKILL.md b/skills/knowledge-wiki/SKILL.md index b72a2114..508441ac 100644 --- a/skills/knowledge-wiki/SKILL.md +++ b/skills/knowledge-wiki/SKILL.md @@ -88,3 +88,4 @@ Append-only, newest at bottom: - **Cross-reference**: every page should link to related pages; keep the knowledge graph connected - **Index is mandatory**: always update `knowledge/index.md` after any change - **Be concise**: capture essence, not copy entire sources +- **Full paths in replies**: when referencing knowledge files in conversation replies, use the full path from workspace root (e.g. `[Title](knowledge//.md)`), not relative paths. Relative paths are only for cross-references inside knowledge pages themselves. From a1d82f6193c3d50e63c634a19e86f69052925973 Mon Sep 17 00:00:00 2001 From: zhayujie Date: Sun, 12 Apr 2026 16:39:06 +0800 Subject: [PATCH 8/8] feat(knowledge): add cli and update docs --- README.md | 3 +- agent/knowledge/__init__.py | 0 agent/knowledge/service.py | 218 +++++++++++++++++++++++++++++++ agent/tools/memory/memory_get.py | 6 +- channel/web/web_channel.py | 128 +++--------------- cli/VERSION | 2 +- cli/cli.py | 3 + cli/commands/knowledge.py | 121 +++++++++++++++++ common/cloud_client.py | 37 ++++++ config-template.json | 3 +- config.py | 4 +- docs/cli/general.mdx | 39 ++++++ docs/cli/index.mdx | 7 + docs/docs.json | 33 +++++ docs/en/cli/general.mdx | 25 ++++ docs/en/cli/index.mdx | 7 + docs/en/intro/architecture.mdx | 24 ++-- docs/en/intro/features.mdx | 35 +++-- docs/en/intro/index.mdx | 3 + docs/en/knowledge/index.mdx | 77 +++++++++++ docs/en/tools/memory.mdx | 19 ++- docs/intro/architecture.mdx | 38 +++--- docs/intro/features.mdx | 37 ++++-- docs/intro/index.mdx | 8 +- docs/ja/cli/general.mdx | 25 ++++ docs/ja/cli/index.mdx | 7 + docs/ja/intro/architecture.mdx | 24 ++-- docs/ja/intro/features.mdx | 35 +++-- docs/ja/intro/index.mdx | 3 + docs/ja/knowledge/index.mdx | 77 +++++++++++ docs/ja/tools/memory.mdx | 19 ++- docs/knowledge/index.mdx | 77 +++++++++++ docs/tools/memory.mdx | 19 ++- skills/knowledge-wiki/SKILL.md | 1 + 34 files changed, 956 insertions(+), 208 deletions(-) create mode 100644 agent/knowledge/__init__.py create mode 100644 agent/knowledge/service.py create mode 100644 cli/commands/knowledge.py create mode 100644 docs/en/knowledge/index.mdx create mode 100644 docs/ja/knowledge/index.mdx create mode 100644 docs/knowledge/index.mdx diff --git a/README.md b/README.md index 7478b99d..89dee8fe 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,7 @@ [中文] | [English] | [日本語]

-**CowAgent** 是基于大模型的超级 AI 助理，能够主动思考和任务规划、操作计算机和外部资源、创造和执行 Skills、拥有长期记忆并不断成长，比 OpenClaw 更轻量和便捷。CowAgent 支持灵活切换多种模型，能处理文本、语音、图片、文件等多模态消息，可接入微信、飞书、钉钉、企微智能机器人、QQ、企微自建应用、微信公众号、网页中使用，7*24小时运行于你的个人电脑或服务器中。 +**CowAgent** 是基于大模型的超级 AI 助理，能够主动思考和任务规划、操作计算机和外部资源、创造和执行 Skills、拥有长期记忆和知识库并不断成长，比 OpenClaw 更轻量和便捷。CowAgent 支持灵活切换多种模型，能处理文本、语音、图片、文件等多模态消息，可接入微信、飞书、钉钉、企微智能机器人、QQ、企微自建应用、微信公众号、网页中使用，7*24小时运行于你的个人电脑或服务器中。

🌐 官网  ·  @@ -24,6 +24,7 @@ - ✅ **自主任务规划**：能够理解复杂任务并自主规划执行，持续思考和调用工具直到完成目标 - ✅ **长期记忆：** 自动将对话记忆持久化至本地文件和数据库中，包括核心记忆和日级记忆，支持关键词及向量检索 +- ✅ **个人知识库：** 自动整理结构化知识，通过交叉引用构建知识图谱，支持通过对话管理和可视化浏览知识库 - ✅ **技能系统：** Skills 安装和运行的引擎，支持从 [Skill Hub](https://skills.cowagent.ai/)、GitHub 等一键安装技能，或通过对话创造 Skills - ✅ **工具系统：** 内置文件读写、终端执行、浏览器操作、定时任务等工具，Agent 自主调用以完成复杂任务 - ✅ **CLI系统：** 提供终端命令和对话命令，支持进程管理、技能安装、配置修改等操作 diff --git a/agent/knowledge/__init__.py b/agent/knowledge/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/agent/knowledge/service.py b/agent/knowledge/service.py new file mode 100644 index 00000000..a4fc3d6b --- /dev/null +++ b/agent/knowledge/service.py @@ -0,0 +1,218 @@ +""" +Knowledge service for handling knowledge base operations. + +Provides a unified interface for listing, reading, and graphing knowledge files, +callable from the web console, API, or CLI. + +Knowledge file layout (under workspace_root): + knowledge/index.md + knowledge/log.md + knowledge//.md +""" + +import os +import re +from pathlib import Path +from typing import Optional + +from common.log import logger +from config import conf + + +class KnowledgeService: + """ + High-level service for knowledge base queries. + Operates directly on the filesystem. + """ + + def __init__(self, workspace_root: str): + self.workspace_root = workspace_root + self.knowledge_dir = os.path.join(workspace_root, "knowledge") + + # ------------------------------------------------------------------ + # list — directory tree with stats + # ------------------------------------------------------------------ + def list_tree(self) -> dict: + """ + Return the knowledge directory tree grouped by category. + + Returns:: + + { + "tree": [ + { + "dir": "concepts", + "files": [ + {"name": "moe.md", "title": "MoE", "size": 1234}, + ... + ] + }, + ... + ], + "stats": {"pages": 15, "size": 32768}, + "enabled": true + } + """ + if not os.path.isdir(self.knowledge_dir): + return {"tree": [], "stats": {"pages": 0, "size": 0}, "enabled": conf().get("knowledge", True)} + + tree = [] + total_files = 0 + total_bytes = 0 + for name in sorted(os.listdir(self.knowledge_dir)): + full = os.path.join(self.knowledge_dir, name) + if not os.path.isdir(full) or name.startswith("."): + continue + files = [] + for fname in sorted(os.listdir(full)): + if fname.endswith(".md") and not fname.startswith("."): + fpath = os.path.join(full, fname) + size = os.path.getsize(fpath) + total_files += 1 + total_bytes += size + title = fname.replace(".md", "") + try: + with open(fpath, "r", encoding="utf-8") as f: + first_line = f.readline().strip() + if first_line.startswith("# "): + title = first_line[2:].strip() + except Exception: + pass + files.append({"name": fname, "title": title, "size": size}) + tree.append({"dir": name, "files": files}) + + return { + "tree": tree, + "stats": {"pages": total_files, "size": total_bytes}, + "enabled": conf().get("knowledge", True), + } + + # ------------------------------------------------------------------ + # read — single file content + # ------------------------------------------------------------------ + def read_file(self, rel_path: str) -> dict: + """ + Read a single knowledge markdown file. + + :param rel_path: Relative path within knowledge/, e.g. ``concepts/moe.md`` + :return: dict with ``content`` and ``path`` + :raises ValueError: if path is invalid or escapes knowledge dir + :raises FileNotFoundError: if file does not exist + """ + if not rel_path or ".." in rel_path: + raise ValueError("invalid path") + + full_path = os.path.normpath(os.path.join(self.knowledge_dir, rel_path)) + allowed = os.path.normpath(self.knowledge_dir) + if not full_path.startswith(allowed + os.sep) and full_path != allowed: + raise ValueError("path outside knowledge dir") + + if not os.path.isfile(full_path): + raise FileNotFoundError(f"file not found: {rel_path}") + + with open(full_path, "r", encoding="utf-8") as f: + content = f.read() + return {"content": content, "path": rel_path} + + # ------------------------------------------------------------------ + # graph — nodes and links for visualization + # ------------------------------------------------------------------ + def build_graph(self) -> dict: + """ + Parse all knowledge pages and extract cross-reference links. + + Returns:: + + { + "nodes": [ + {"id": "concepts/moe.md", "label": "MoE", "category": "concepts"}, + ... + ], + "links": [ + {"source": "concepts/moe.md", "target": "entities/deepseek.md"}, + ... + ] + } + """ + knowledge_path = Path(self.knowledge_dir) + if not knowledge_path.is_dir(): + return {"nodes": [], "links": []} + + nodes = {} + links = [] + link_re = re.compile(r'\[([^\]]*)\]\(([^)]+\.md)\)') + + for md_file in knowledge_path.rglob("*.md"): + rel = str(md_file.relative_to(knowledge_path)) + if rel in ("index.md", "log.md"): + continue + parts = rel.split("/") + category = parts[0] if len(parts) > 1 else "root" + title = md_file.stem.replace("-", " ").title() + try: + content = md_file.read_text(encoding="utf-8") + first_line = content.strip().split("\n")[0] + if first_line.startswith("# "): + title = first_line[2:].strip() + for _, link_target in link_re.findall(content): + resolved = (md_file.parent / link_target).resolve() + try: + target_rel = str(resolved.relative_to(knowledge_path)) + except ValueError: + continue + if target_rel != rel: + links.append({"source": rel, "target": target_rel}) + except Exception: + pass + nodes[rel] = {"id": rel, "label": title, "category": category} + + valid_ids = set(nodes.keys()) + links = [l for l in links if l["source"] in valid_ids and l["target"] in valid_ids] + seen = set() + deduped = [] + for l in links: + key = tuple(sorted([l["source"], l["target"]])) + if key not in seen: + seen.add(key) + deduped.append(l) + + return {"nodes": list(nodes.values()), "links": deduped} + + # ------------------------------------------------------------------ + # dispatch — single entry point for protocol messages + # ------------------------------------------------------------------ + def dispatch(self, action: str, payload: Optional[dict] = None) -> dict: + """ + Dispatch a knowledge management action. + + :param action: ``list``, ``read``, or ``graph`` + :param payload: action-specific payload + :return: protocol-compatible response dict + """ + payload = payload or {} + try: + if action == "list": + result = self.list_tree() + return {"action": action, "code": 200, "message": "success", "payload": result} + + elif action == "read": + path = payload.get("path") + if not path: + return {"action": action, "code": 400, "message": "path is required", "payload": None} + result = self.read_file(path) + return {"action": action, "code": 200, "message": "success", "payload": result} + + elif action == "graph": + result = self.build_graph() + return {"action": action, "code": 200, "message": "success", "payload": result} + + else: + return {"action": action, "code": 400, "message": f"unknown action: {action}", "payload": None} + + except ValueError as e: + return {"action": action, "code": 403, "message": str(e), "payload": None} + except FileNotFoundError as e: + return {"action": action, "code": 404, "message": str(e), "payload": None} + except Exception as e: + logger.error(f"[KnowledgeService] dispatch error: action={action}, error={e}") + return {"action": action, "code": 500, "message": str(e), "payload": None} diff --git a/agent/tools/memory/memory_get.py b/agent/tools/memory/memory_get.py index 1bd4828e..ec466849 100644 --- a/agent/tools/memory/memory_get.py +++ b/agent/tools/memory/memory_get.py @@ -85,7 +85,11 @@ class MemoryGetTool(BaseTool): if not path.startswith('memory/') and not path.startswith('knowledge/') and not path.startswith('/') and path != 'MEMORY.md': path = f'memory/{path}' - file_path = workspace_dir / path + file_path = (workspace_dir / path).resolve() + workspace_resolved = workspace_dir.resolve() + + if not str(file_path).startswith(str(workspace_resolved) + '/') and file_path != workspace_resolved: + return ToolResult.fail(f"Error: Access denied: path outside workspace") if not file_path.exists(): return ToolResult.fail(f"Error: File not found: {path}") diff --git a/channel/web/web_channel.py b/channel/web/web_channel.py index f58238c4..8a5fbaf0 100644 --- a/channel/web/web_channel.py +++ b/channel/web/web_channel.py @@ -1535,141 +1535,45 @@ class AssetsHandler: class KnowledgeListHandler: - """Return the knowledge directory tree as JSON.""" - def GET(self): web.header('Content-Type', 'application/json; charset=utf-8') try: - workspace_root = _get_workspace_root() - knowledge_dir = os.path.join(workspace_root, "knowledge") - if not os.path.isdir(knowledge_dir): - return json.dumps({"status": "success", "tree": [], "stats": {"pages": 0, "size": 0}}) - - tree = [] - total_files = 0 - total_bytes = 0 - for name in sorted(os.listdir(knowledge_dir)): - full = os.path.join(knowledge_dir, name) - if not os.path.isdir(full) or name.startswith("."): - continue - files = [] - for fname in sorted(os.listdir(full)): - if fname.endswith(".md") and not fname.startswith("."): - fpath = os.path.join(full, fname) - size = os.path.getsize(fpath) - total_files += 1 - total_bytes += size - title = fname.replace(".md", "") - try: - with open(fpath, "r", encoding="utf-8") as f: - first_line = f.readline().strip() - if first_line.startswith("# "): - title = first_line[2:].strip() - except Exception: - pass - files.append({"name": fname, "title": title, "size": size}) - tree.append({"dir": name, "files": files}) - - return json.dumps({ - "status": "success", - "tree": tree, - "stats": {"pages": total_files, "size": total_bytes}, - "enabled": conf().get("knowledge", True), - }, ensure_ascii=False) + from agent.knowledge.service import KnowledgeService + svc = KnowledgeService(_get_workspace_root()) + result = svc.list_tree() + return json.dumps({"status": "success", **result}, ensure_ascii=False) except Exception as e: logger.error(f"[WebChannel] Knowledge list error: {e}") return json.dumps({"status": "error", "message": str(e)}) class KnowledgeReadHandler: - """Read a single knowledge markdown file.""" - def GET(self): web.header('Content-Type', 'application/json; charset=utf-8') try: + from agent.knowledge.service import KnowledgeService params = web.input(path='') - rel_path = params.path - if not rel_path or ".." in rel_path: - return json.dumps({"status": "error", "message": "invalid path"}) - - workspace_root = _get_workspace_root() - full_path = os.path.join(workspace_root, "knowledge", rel_path) - full_path = os.path.normpath(full_path) - knowledge_dir = os.path.normpath(os.path.join(workspace_root, "knowledge")) - if not full_path.startswith(knowledge_dir): - return json.dumps({"status": "error", "message": "path outside knowledge dir"}) - - if not os.path.isfile(full_path): - return json.dumps({"status": "error", "message": "file not found"}) - - with open(full_path, "r", encoding="utf-8") as f: - content = f.read() - return json.dumps({"status": "success", "content": content, "path": rel_path}, ensure_ascii=False) + svc = KnowledgeService(_get_workspace_root()) + result = svc.read_file(params.path) + return json.dumps({"status": "success", **result}, ensure_ascii=False) + except (ValueError, FileNotFoundError) as e: + return json.dumps({"status": "error", "message": str(e)}) except Exception as e: logger.error(f"[WebChannel] Knowledge read error: {e}") return json.dumps({"status": "error", "message": str(e)}) class KnowledgeGraphHandler: - """Return nodes and links for the knowledge graph visualization.""" - def GET(self): web.header('Content-Type', 'application/json; charset=utf-8') - import re - from pathlib import Path - - workspace_root = _get_workspace_root() - knowledge_dir = Path(workspace_root) / "knowledge" - if not knowledge_dir.is_dir(): + try: + from agent.knowledge.service import KnowledgeService + svc = KnowledgeService(_get_workspace_root()) + return json.dumps(svc.build_graph(), ensure_ascii=False) + except Exception as e: + logger.error(f"[WebChannel] Knowledge graph error: {e}") return json.dumps({"nodes": [], "links": []}) - nodes = {} - links = [] - link_re = re.compile(r'\[([^\]]*)\]\(([^)]+\.md)\)') - - for md_file in knowledge_dir.rglob("*.md"): - rel = str(md_file.relative_to(knowledge_dir)) - if rel in ("index.md", "log.md"): - continue - parts = rel.split("/") - category = parts[0] if len(parts) > 1 else "root" - title = md_file.stem.replace("-", " ").title() - try: - content = md_file.read_text(encoding="utf-8") - first_line = content.strip().split("\n")[0] - if first_line.startswith("# "): - title = first_line[2:].strip() - except Exception: - pass - nodes[rel] = {"id": rel, "label": title, "category": category} - try: - content = md_file.read_text(encoding="utf-8") - for _, link_target in link_re.findall(content): - resolved = (md_file.parent / link_target).resolve() - try: - target_rel = str(resolved.relative_to(knowledge_dir)) - except ValueError: - continue - if target_rel != rel: - links.append({"source": rel, "target": target_rel}) - except Exception: - pass - - valid_ids = set(nodes.keys()) - links = [l for l in links if l["source"] in valid_ids and l["target"] in valid_ids] - seen = set() - deduped = [] - for l in links: - key = tuple(sorted([l["source"], l["target"]])) - if key not in seen: - seen.add(key) - deduped.append(l) - - return json.dumps({ - "nodes": list(nodes.values()), - "links": deduped, - }, ensure_ascii=False) - class VersionHandler: def GET(self): diff --git a/cli/VERSION b/cli/VERSION index e0102586..157e54f3 100644 --- a/cli/VERSION +++ b/cli/VERSION @@ -1 +1 @@ -2.0.5 +2.0.6 diff --git a/cli/cli.py b/cli/cli.py index 6740667f..9bc6f48f 100644 --- a/cli/cli.py +++ b/cli/cli.py @@ -6,6 +6,7 @@ from cli.commands.skill import skill from cli.commands.process import start, stop, restart, update, status, logs from cli.commands.context import context from cli.commands.install import install_browser +from cli.commands.knowledge import knowledge HELP_TEXT = """Usage: cow COMMAND [ARGS]... @@ -22,6 +23,7 @@ Commands: status Show CowAgent running status. logs View CowAgent logs. skill Manage CowAgent skills. + knowledge Manage knowledge base. install-browser Install browser tool (Playwright + Chromium). Tip: You can also send /help, /skill list, etc. in agent chat.""" @@ -69,6 +71,7 @@ main.add_command(update) main.add_command(status) main.add_command(logs) main.add_command(context) +main.add_command(knowledge) main.add_command(install_browser) diff --git a/cli/commands/knowledge.py b/cli/commands/knowledge.py new file mode 100644 index 00000000..296ca6c9 --- /dev/null +++ b/cli/commands/knowledge.py @@ -0,0 +1,121 @@ +"""cow knowledge - Knowledge base management commands.""" + +import os + +import click + +from cli.utils import get_project_root + + +def _get_knowledge_dir(): + """Resolve the knowledge directory path from config or default.""" + try: + import sys + sys.path.insert(0, get_project_root()) + from config import conf + from common.utils import expand_path + workspace = expand_path(conf().get("agent_workspace", "~/cow")) + except Exception: + workspace = os.path.expanduser("~/cow") + return os.path.join(workspace, "knowledge") + + +def _get_knowledge_enabled(): + try: + import sys + sys.path.insert(0, get_project_root()) + from config import conf + return conf().get("knowledge", True) + except Exception: + return True + + +@click.group(invoke_without_command=True) +@click.pass_context +def knowledge(ctx): + """Manage CowAgent knowledge base.""" + if ctx.invoked_subcommand is None: + click.echo(_stats()) + + +@knowledge.command("list") +def knowledge_list(): + """Display knowledge base file tree.""" + click.echo(_tree()) + + +def _stats() -> str: + knowledge_dir = _get_knowledge_dir() + if not os.path.isdir(knowledge_dir): + return "Knowledge base directory not found." + + enabled = _get_knowledge_enabled() + total_files = 0 + total_bytes = 0 + cat_count = {} + + for root, dirs, files in os.walk(knowledge_dir): + dirs[:] = [d for d in dirs if not d.startswith(".")] + rel_root = os.path.relpath(root, knowledge_dir) + category = rel_root.split(os.sep)[0] if rel_root != "." else "root" + for f in files: + if f.endswith(".md") and f not in ("index.md", "log.md"): + total_files += 1 + total_bytes += os.path.getsize(os.path.join(root, f)) + cat_count[category] = cat_count.get(category, 0) + 1 + + status_icon = click.style("enabled", fg="green") if enabled else click.style("disabled", fg="red") + lines = [ + f"\n Knowledge Base [{status_icon}]", + "", + f" Pages: {total_files}", + f" Size: {total_bytes / 1024:.1f} KB", + "", + ] + if cat_count: + lines.append(" Categories:") + for cat in sorted(cat_count.keys()): + lines.append(f" {cat}/ ({cat_count[cat]} pages)") + lines.append("") + + lines.append(f" Path: {knowledge_dir}") + lines.append("") + return "\n".join(lines) + + +def _tree() -> str: + knowledge_dir = _get_knowledge_dir() + if not os.path.isdir(knowledge_dir): + return "Knowledge base directory not found." + + tree_lines = [" knowledge/"] + + subdirs = sorted([ + d for d in os.listdir(knowledge_dir) + if os.path.isdir(os.path.join(knowledge_dir, d)) and not d.startswith(".") + ]) + + for i, subdir in enumerate(subdirs): + is_last_dir = (i == len(subdirs) - 1) + branch = "└── " if is_last_dir else "├── " + subdir_path = os.path.join(knowledge_dir, subdir) + md_files = sorted([ + f for f in os.listdir(subdir_path) + if f.endswith(".md") and not f.startswith(".") + ]) + tree_lines.append(f" {branch}{subdir}/ ({len(md_files)})") + + child_prefix = " " if is_last_dir else " │ " + max_show = 15 + for j, fname in enumerate(md_files[:max_show]): + is_last_file = (j == len(md_files[:max_show]) - 1) and len(md_files) <= max_show + fb = "└── " if is_last_file else "├── " + name = fname.replace(".md", "") + tree_lines.append(f"{child_prefix}{fb}{name}") + if len(md_files) > max_show: + tree_lines.append(f"{child_prefix}└── ... +{len(md_files) - max_show} more") + + if not subdirs: + tree_lines.append(" (empty)") + + return "\n" + "\n".join(tree_lines) + "\n" diff --git a/common/cloud_client.py b/common/cloud_client.py index 656c1604..870f5dc4 100644 --- a/common/cloud_client.py +++ b/common/cloud_client.py @@ -54,6 +54,7 @@ class CloudClient(LinkAIClient): self.channel_mgr = None self._skill_service = None self._memory_service = None + self._knowledge_service = None self._chat_service = None @property @@ -88,6 +89,21 @@ class CloudClient(LinkAIClient): logger.error(f"[CloudClient] Failed to init MemoryService: {e}") return self._memory_service + @property + def knowledge_service(self): + """Lazy-init KnowledgeService.""" + if self._knowledge_service is None: + try: + from agent.knowledge.service import KnowledgeService + from config import conf + from common.utils import expand_path + workspace_root = expand_path(conf().get("agent_workspace", "~/cow")) + self._knowledge_service = KnowledgeService(workspace_root) + logger.debug("[CloudClient] KnowledgeService initialised") + except Exception as e: + logger.error(f"[CloudClient] Failed to init KnowledgeService: {e}") + return self._knowledge_service + @property def chat_service(self): """Lazy-init ChatService (requires AgentBridge via Bridge singleton).""" @@ -468,6 +484,27 @@ class CloudClient(LinkAIClient): return svc.dispatch(action, payload) + # ------------------------------------------------------------------ + # knowledge callback + # ------------------------------------------------------------------ + def on_knowledge(self, data: dict) -> dict: + """ + Handle KNOWLEDGE messages from the cloud console. + Delegates to KnowledgeService.dispatch for the actual operations. + + :param data: message data with 'action', 'clientId', 'payload' + :return: response dict + """ + action = data.get("action", "") + payload = data.get("payload") + logger.info(f"[CloudClient] on_knowledge: action={action}") + + svc = self.knowledge_service + if svc is None: + return {"action": action, "code": 500, "message": "KnowledgeService not available", "payload": None} + + return svc.dispatch(action, payload) + # ------------------------------------------------------------------ # chat callback # ------------------------------------------------------------------ diff --git a/config-template.json b/config-template.json index d5a80440..65ecc651 100644 --- a/config-template.json +++ b/config-template.json @@ -29,5 +29,6 @@ "agent": true, "agent_max_context_tokens": 40000, "agent_max_context_turns": 20, - "agent_max_steps": 15 + "agent_max_steps": 15, + "knowledge": true } diff --git a/config.py b/config.py index ab7da486..6b231ed2 100644 --- a/config.py +++ b/config.py @@ -180,14 +180,14 @@ available_setting = { # 豆包(火山方舟) 平台配置 "ark_api_key": "", "ark_base_url": "https://ark.cn-beijing.volces.com/api/v3", - #魔搭社区 平台配置 + # 魔搭社区 平台配置 "modelscope_api_key": "", "modelscope_base_url": "https://api-inference.modelscope.cn/v1/chat/completions", # LinkAI平台配置 "use_linkai": False, "linkai_api_key": "", "linkai_app_code": "", - "linkai_api_base": "https://api.link-ai.tech", # linkAI服务地址 + "linkai_api_base": "https://api.link-ai.tech", "cloud_host": "client.link-ai.tech", "cloud_deployment_id": "", "minimax_api_key": "", diff --git a/docs/cli/general.mdx b/docs/cli/general.mdx index 8ab9fb75..32fb5a1c 100644 --- a/docs/cli/general.mdx +++ b/docs/cli/general.mdx @@ -106,6 +106,45 @@ Session: 12 messages | 8 skills loaded /logs 50 ``` +## knowledge + +查看和管理个人知识库。默认显示知识库统计信息。 + +```text +/knowledge +``` + +输出示例： + +``` +📚 知识库 + +- 状态：已开启 +- 页面数：12 +- 总大小：45.2 KB +- 分类明细： + - concepts/: 5 篇 + - entities/: 4 篇 + - sources/: 3 篇 +``` + +**查看目录结构：** + +```text +/knowledge list +``` + +**开启 / 关闭知识库：** + +```text +/knowledge on +/knowledge off +``` + + + 终端 CLI 中 `cow knowledge` 和 `cow knowledge list` 可用，但 `on|off` 仅支持在对话中使用（需实时生效）。 + + ## version 显示当前 CowAgent 版本号。 diff --git a/docs/cli/index.mdx b/docs/cli/index.mdx index f9282607..469b9d7c 100644 --- a/docs/cli/index.mdx +++ b/docs/cli/index.mdx @@ -40,6 +40,9 @@ Service: Skills: skill Manage skills (list / search / install / uninstall ...) +Knowledge: + knowledge View knowledge base stats and structure + Others: help Show this help message version Show version @@ -55,6 +58,9 @@ Others: | `/status` | 查看服务状态和配置 | | `/config` | 查看或修改运行时配置 | | `/skill` | 管理技能（安装、卸载、启用、禁用等） | +| `/knowledge` | 查看知识库统计信息 | +| `/knowledge list` | 查看知识库目录结构 | +| `/knowledge on\|off` | 开启或关闭知识库 | | `/context` | 查看当前会话上下文信息 | | `/context clear` | 清空当前会话上下文 | | `/logs` | 查看最近日志 | @@ -76,6 +82,7 @@ Others: | logs | ✓ | ✓ | | config | ✗ | ✓ | | context | — | ✓ | +| knowledge (子命令) | ✓ | ✓ | | skill (子命令) | ✓ | ✓ | | start / stop / restart | ✓ | ✗ | | update | ✓ | ✗ | diff --git a/docs/docs.json b/docs/docs.json index df8025a8..a1ca6a00 100644 --- a/docs/docs.json +++ b/docs/docs.json @@ -147,6 +147,17 @@ } ] }, + { + "tab": "知识", + "groups": [ + { + "group": "知识库", + "pages": [ + "knowledge/index" + ] + } + ] + }, { "tab": "通道", "groups": [ @@ -308,6 +319,17 @@ } ] }, + { + "tab": "Knowledge", + "groups": [ + { + "group": "Knowledge Base", + "pages": [ + "en/knowledge/index" + ] + } + ] + }, { "tab": "Channels", "groups": [ @@ -469,6 +491,17 @@ } ] }, + { + "tab": "ナレッジ", + "groups": [ + { + "group": "ナレッジベース", + "pages": [ + "ja/knowledge/index" + ] + } + ] + }, { "tab": "チャネル", "groups": [ diff --git a/docs/en/cli/general.mdx b/docs/en/cli/general.mdx index 186f51a9..67ba435c 100644 --- a/docs/en/cli/general.mdx +++ b/docs/en/cli/general.mdx @@ -92,6 +92,31 @@ View recent service logs. Shows the last 20 lines by default, up to 50. /logs 50 ``` +## knowledge + +View and manage the personal knowledge base. Shows statistics by default. + +```text +/knowledge +``` + +**View directory structure:** + +```text +/knowledge list +``` + +**Enable / disable knowledge base:** + +```text +/knowledge on +/knowledge off +``` + + + In the terminal CLI, `cow knowledge` and `cow knowledge list` are available, but `on|off` is only supported in chat (requires runtime effect). + + ## version Show the current CowAgent version. diff --git a/docs/en/cli/index.mdx b/docs/en/cli/index.mdx index 4d7c91a5..0b1232f1 100644 --- a/docs/en/cli/index.mdx +++ b/docs/en/cli/index.mdx @@ -40,6 +40,9 @@ Service: Skills: skill Manage skills (list / search / install / uninstall ...) +Knowledge: + knowledge View knowledge base stats and structure + Others: help Show this help message version Show version @@ -55,6 +58,9 @@ In the Web console or any connected channel, type `/` to see command suggestions | `/status` | View service status and configuration | | `/config` | View or modify runtime configuration | | `/skill` | Manage skills (install, uninstall, enable, disable, etc.) | +| `/knowledge` | View knowledge base statistics | +| `/knowledge list` | View knowledge base directory structure | +| `/knowledge on\|off` | Enable or disable knowledge base | | `/context` | View current session context info | | `/context clear` | Clear current session context | | `/logs` | View recent logs | @@ -74,6 +80,7 @@ In the Web console or any connected channel, type `/` to see command suggestions | logs | ✓ | ✓ | | config | ✗ | ✓ | | context | — | ✓ | +| knowledge (subcommands) | ✓ | ✓ | | skill (subcommands) | ✓ | ✓ | | start / stop / restart | ✓ | ✗ | | update | ✓ | ✗ | diff --git a/docs/en/intro/architecture.mdx b/docs/en/intro/architecture.mdx index cb1c7d76..3719df04 100644 --- a/docs/en/intro/architecture.mdx +++ b/docs/en/intro/architecture.mdx @@ -11,14 +11,16 @@ CowAgent's architecture consists of the following core modules: CowAgent Architecture -### Core Modules - | Module | Description | | --- | --- | -| **Channels** | Message channel layer for receiving and sending messages. Supports Web, Feishu, DingTalk, WeCom, WeChat Official Account, and more | -| **Agent Core** | Agent engine including task planning, memory system, and skills engine | -| **Tools** | Tool layer for Agent to access OS resources. 10+ built-in tools | -| **Models** | Model layer with unified access to mainstream LLMs | +| **Plan** | Understands user intent, decomposes complex tasks into multi-step plans, and iteratively invokes tools until the goal is achieved | +| **Memory** | Automatically persists important information as core memory and daily memory, with hybrid keyword and vector retrieval for cross-session context continuity | +| **Knowledge** | Organizes structured knowledge by topic. The Agent autonomously distills valuable information into Markdown pages, maintaining indexes and cross-references to build a growing knowledge network | +| **Tools** | Core capability for Agent to access OS resources. 10+ built-in tools including file read/write, terminal, browser, scheduler, memory search, web search, and more | +| **Skills** | Loads and manages Skills. Supports one-click installation from Skill Hub, GitHub, and more, or custom skill creation through conversation | +| **Models** | Model layer with unified access to OpenAI, Claude, Gemini, DeepSeek, MiniMax, GLM, Qwen, and other mainstream LLMs | +| **Channels** | Message channel layer for receiving and sending messages. Supports Web console, WeChat, Feishu, DingTalk, WeCom, WeChat Official Account, and more with a unified protocol | +| **CLI** | Command-line system providing terminal commands (`cow`) and chat commands (`/`) for process management, skill installation, configuration, knowledge base management, and more | ## Agent Mode Workflow @@ -28,7 +30,7 @@ When Agent mode is enabled, CowAgent runs as an autonomous agent with the follow 2. **Understand Intent** — Analyze task requirements and context 3. **Plan Task** — Break complex tasks into multiple steps 4. **Invoke Tools** — Select and execute appropriate tools for each step -5. **Update Memory** — Store important information in long-term memory +5. **Update Memory & Knowledge** — Store important information in long-term memory and organize structured knowledge into the knowledge base 6. **Return Result** — Send execution results back to the user ## Workspace Directory Structure @@ -39,9 +41,12 @@ The Agent workspace is located at `~/cow` by default and stores system prompts, ~/cow/ ├── system.md # Agent system prompt ├── user.md # User profile +├── MEMORY.md # Core memory ├── memory/ # Long-term memory storage -│ ├── core.md # Core memory -│ └── daily/ # Daily memory +│ └── YYYY-MM-DD.md # Daily memory +├── knowledge/ # Personal knowledge base +│ ├── index.md # Knowledge index +│ └── / # Topic-based pages └── skills/ # Custom skills ├── skill-1/ └── skill-2/ @@ -75,3 +80,4 @@ Configure Agent mode parameters in `config.json`: | `agent_max_context_tokens` | Max context tokens | `40000` | | `agent_max_context_turns` | Max context turns | `30` | | `agent_max_steps` | Max decision steps per task | `15` | +| `knowledge` | Enable personal knowledge base | `true` | diff --git a/docs/en/intro/features.mdx b/docs/en/intro/features.mdx index 66c2427d..41fa11a4 100644 --- a/docs/en/intro/features.mdx +++ b/docs/en/intro/features.mdx @@ -15,13 +15,26 @@ In subsequent long-term conversations, the Agent intelligently stores or retriev -## 2. Task Planning and Tool Use +## 2. Personal Knowledge Base + +> The knowledge base system enables the Agent to continuously accumulate and organize structured knowledge. Unlike memory which records along a timeline, the knowledge base is organized by topics, transforming articles, conversation insights, and learning materials into interconnected Markdown pages that form a continuously growing knowledge network. + +The Agent automatically organizes valuable information from conversations into knowledge pages, maintaining cross-references and indexes. The Web console provides document browsing and knowledge graph visualization. Knowledge is stored in `~/cow/knowledge/` within the workspace. + +- **Auto-organization**: The Agent autonomously extracts and organizes structured knowledge during conversations, maintaining indexes and cross-references +- **Knowledge graph**: Automatically builds a knowledge graph from cross-references between pages, with interactive graph visualization in the Web console +- **Chat integration**: Knowledge document links referenced in Agent replies can be clicked directly in the Web console for viewing +- **CLI management**: Use `/knowledge` commands to view stats, browse directory, and toggle the feature with `/knowledge on|off` + +See [Personal Knowledge Base](/en/knowledge) for details. + +## 3. Task Planning and Tool Use Tools are the core of how the Agent accesses operating system resources. The Agent intelligently selects and invokes tools based on task requirements, performing file read/write, command execution, scheduled tasks, and more. Built-in tools are implemented in the project's `agent/tools/` directory. **Key tools:** file read/write/edit, Bash terminal, browser, file send, scheduler, memory search, web search, environment config, and more. -### 2.1 Terminal and File Access +### 3.1 Terminal and File Access Access to the OS terminal and file system is the most fundamental and core capability. Many other tools and skills build on top of this. Users can interact with the Agent from a mobile device to operate resources on their personal computer or server: @@ -29,7 +42,7 @@ Access to the OS terminal and file system is the most fundamental and core capab -### 2.2 Programming Capability +### 3.2 Programming Capability Combining programming and system access, the Agent can execute the complete **Vibecoding workflow** — from information search, asset generation, coding, testing, deployment, Nginx configuration, to publishing — all triggered by a single command from your phone: @@ -37,7 +50,7 @@ Combining programming and system access, the Agent can execute the complete **Vi -### 2.3 Scheduled Tasks +### 3.3 Scheduled Tasks The `scheduler` tool enables dynamic scheduled tasks, supporting **one-time tasks, fixed intervals, and Cron expressions**. Tasks can be triggered as either a **fixed message send** or an **Agent dynamic task** execution: @@ -45,7 +58,7 @@ The `scheduler` tool enables dynamic scheduled tasks, supporting **one-time task -### 2.4 Browser +### 3.4 Browser The built-in `browser` tool allows the Agent to control a Chromium browser to visit web pages, fill forms, click elements, and take screenshots, with support for dynamic JS-rendered pages. Run `cow install-browser` to install with one command, automatically adapting to server (headless) and desktop environments: @@ -53,7 +66,7 @@ The built-in `browser` tool allows the Agent to control a Chromium browser to vi -### 2.5 Environment Variable Management +### 3.5 Environment Variable Management Secrets required by skills are stored in an environment variable file, managed by the `env_config` tool. You can update secrets through conversation, with built-in security protection and desensitization: @@ -61,7 +74,7 @@ Secrets required by skills are stored in an environment variable file, managed b -## 3. Skills System +## 4. Skills System The Skills system provides infinite extensibility for the Agent. Each Skill consists of a description file, execution scripts (optional), and resources (optional), describing how to complete specific types of tasks. Skills allow the Agent to follow instructions for complex workflows, invoke tools, or integrate third-party systems. @@ -71,7 +84,7 @@ The Skills system provides infinite extensibility for the Agent. Each Skill cons Install skills: `/skill install ` or `cow skill install `, supporting Skill Hub, GitHub, ClawHub, URL, and more. -### 3.1 Creating Skills +### 4.1 Creating Skills The `skill-creator` skill enables rapid skill creation through conversation. You can ask the Agent to codify a workflow as a skill, or send any API documentation and examples for the Agent to complete the integration directly: @@ -79,7 +92,7 @@ The `skill-creator` skill enables rapid skill creation through conversation. You -### 3.2 Web Search and Image Recognition +### 4.2 Web Search and Image Recognition - **Web search:** Built-in `web_search` tool, supports multiple search engines. Configure `BOCHA_API_KEY` or `LINKAI_API_KEY` to enable. - **Image recognition:** Built-in `openai-image-vision` skill, supports `gpt-4.1-mini`, `gpt-4.1`, and other models. Requires `OPENAI_API_KEY`. @@ -88,7 +101,7 @@ The `skill-creator` skill enables rapid skill creation through conversation. You -### 3.3 Skill Hub +### 4.3 Skill Hub Visit [skills.cowagent.ai](https://skills.cowagent.ai/) to browse all available skills, or use commands in conversation: @@ -102,7 +115,7 @@ Also supports installing skills from GitHub, ClawHub, LinkAI, and other third-pa -## 4. CLI Command System +## 5. CLI Command System CowAgent provides two command interaction methods, covering service management, skill installation, configuration, and more: diff --git a/docs/en/intro/index.mdx b/docs/en/intro/index.mdx index 109c3097..e4b05352 100644 --- a/docs/en/intro/index.mdx +++ b/docs/en/intro/index.mdx @@ -22,6 +22,9 @@ CowAgent can proactively think and plan tasks, operate computers and external re Automatically persists conversation memory to local files and databases, including core memory and daily memory, with keyword and vector retrieval support. + + Automatically organizes structured knowledge with knowledge graph visualization, building a continuously growing knowledge network through cross-references. + Implements a Skills creation and execution engine with built-in skills, and supports custom Skills development through natural language conversation. diff --git a/docs/en/knowledge/index.mdx b/docs/en/knowledge/index.mdx new file mode 100644 index 00000000..be6d4729 --- /dev/null +++ b/docs/en/knowledge/index.mdx @@ -0,0 +1,77 @@ +--- +title: Personal Knowledge Base +description: CowAgent personal knowledge base — structured knowledge accumulation, automatic organization, and knowledge graph +--- + +The personal knowledge base is the Agent's long-term structured knowledge store, saved in the `knowledge/` directory within the workspace. Unlike memory, which is organized by timeline, the knowledge base organizes content by topic — articles, conversation insights, and learning materials are structured into interlinked Markdown pages, forming a continuously growing knowledge network. + +## Core Concepts + +### Knowledge vs Memory + +| Dimension | Knowledge Base (knowledge/) | Long-term Memory (memory/) | +| --- | --- | --- | +| Organization | By topic, interlinked | By timeline, dated files | +| Writing | Agent actively structures content | Auto-summarized on context trimming | +| Content | Refined, structured knowledge | Raw conversation summaries | +| Use cases | Study notes, tech docs, project knowledge | Conversation history, event records | + +### Directory Structure + +``` +~/cow/knowledge/ +├── index.md # Knowledge index, entry point for all pages +├── log.md # Change log, records each write +├── concepts/ # Conceptual knowledge +│ └── machine-learning.md +├── entities/ # Entity knowledge (people, orgs, tools) +│ └── openai.md +└── sources/ # Source knowledge (articles, papers) + └── llm-wiki.md +``` + +The directory structure is flexible — the Agent automatically creates appropriate category directories based on actual content. Users can also customize the organization. + +## Automatic Organization + +Knowledge writing is an autonomous Agent behavior, triggered in these scenarios: + +- **User shares an article or document** — The Agent automatically extracts key information and creates a structured knowledge page +- **Conversation produces valuable conclusions** — The Agent organizes insights into knowledge pages and links them to existing knowledge +- **User explicitly requests organization** — Users can guide the Agent to organize and update knowledge through conversation + +Each knowledge page includes cross-reference links to related pages, gradually building a knowledge graph. + +## Knowledge Retrieval + +The Agent can retrieve knowledge during conversation through: + +- **Index lookup** — Quickly locate relevant pages via `knowledge/index.md` +- **Semantic search** — Search knowledge content via the `memory_search` tool +- **Direct read** — Read specific knowledge files via the `memory_get` tool + +## Web Console + +The web console provides a dedicated "Knowledge" module with: + +- **Document browsing** — Tree-style directory structure, searchable and collapsible, click to view content +- **Knowledge graph** — D3.js force-directed graph visualizing relationships between knowledge pages +- **Chat integration** — Knowledge document links referenced in Agent replies are clickable for direct navigation + +## CLI Commands + +Manage the knowledge base with the `/knowledge` command: + +| Command | Description | +| --- | --- | +| `/knowledge` | Show knowledge base statistics | +| `/knowledge list` | Display file directory as a tree | +| `/knowledge on` | Enable the knowledge base feature | +| `/knowledge off` | Disable the knowledge base feature | + +## Configuration + +| Parameter | Description | Default | +| --- | --- | --- | +| `knowledge` | Whether to enable the personal knowledge base | `true` | +| `agent_workspace` | Workspace path; knowledge is stored under the `knowledge/` subdirectory | `~/cow` | diff --git a/docs/en/tools/memory.mdx b/docs/en/tools/memory.mdx index a7526336..a1874eef 100644 --- a/docs/en/tools/memory.mdx +++ b/docs/en/tools/memory.mdx @@ -1,9 +1,11 @@ --- -title: memory - Memory -description: Search and read long-term memory +title: memory - Memory & Knowledge +description: Search and read long-term memory and knowledge base files --- -The memory tool contains two sub-tools: `memory_search` (search memory) and `memory_get` (read memory files). +The memory tool contains two sub-tools: `memory_search` (search memory) and `memory_get` (read memory or knowledge files). + +When the [knowledge base](/en/knowledge) feature is enabled, both tools also support accessing files under the `knowledge/` directory. ## Dependencies @@ -11,7 +13,7 @@ No extra dependencies, available by default. Managed by the Agent Core memory sy ## memory_search -Search historical memory with hybrid keyword and vector retrieval. +Search historical memory and knowledge base content with hybrid keyword and vector retrieval. | Parameter | Type | Required | Description | | --- | --- | --- | --- | @@ -19,11 +21,11 @@ Search historical memory with hybrid keyword and vector retrieval. ## memory_get -Read the content of a specific memory file. +Read the content of a specific memory or knowledge file. | Parameter | Type | Required | Description | | --- | --- | --- | --- | -| `path` | string | Yes | Relative path to memory file (e.g. `MEMORY.md`, `memory/2026-01-01.md`) | +| `path` | string | Yes | Relative path to the file (e.g. `MEMORY.md`, `memory/2026-01-01.md`, `knowledge/concepts/rag.md`) | | `start_line` | integer | No | Start line number | | `end_line` | integer | No | End line number | @@ -34,3 +36,8 @@ The Agent automatically invokes memory tools in these scenarios: - When the user shares important information → stores to memory - When historical context is needed → searches relevant memory - When conversation reaches a certain length → extracts summary for storage +- When discussing domain knowledge → retrieves relevant pages from the knowledge base + + + When `knowledge` is set to `false` in config, the tool descriptions and search scope automatically adjust to include only memory files. + diff --git a/docs/intro/architecture.mdx b/docs/intro/architecture.mdx index deae6456..5ec593c4 100644 --- a/docs/intro/architecture.mdx +++ b/docs/intro/architecture.mdx @@ -11,25 +11,27 @@ CowAgent 的整体架构由以下核心模块组成： CowAgent Architecture -### 核心模块说明 - | 模块 | 说明 | | --- | --- | -| **Channels** | 消息通道层，负责接收和发送消息，支持 Web、飞书、钉钉、企微、公众号等 | -| **Agent Core** | 智能体核心引擎，包括任务规划、记忆系统和技能引擎 | -| **Tools** | 工具层，Agent 通过工具访问操作系统资源，内置 10+ 种工具 | -| **Models** | 模型层，支持国内外主流大语言模型的统一接入 | +| **Plan** | 理解用户意图，将复杂任务分解为多步骤计划，循环调用工具直到完成目标 | +| **Memory** | 自动将重要信息持久化为核心记忆和日级记忆，支持关键词和向量混合检索，跨会话保持上下文连续性 | +| **Knowledge** | 以主题维度组织结构化知识，Agent 自主整理有价值信息为 Markdown 页面，维护索引和交叉引用，构建持续增长的知识网络 | +| **Tools** | Agent 访问操作系统资源的核心能力，内置文件读写、终端执行、浏览器操作、定时调度、记忆检索、联网搜索等 10+ 种工具 | +| **Skills** | 加载和管理 Skills，支持从 Skill Hub、GitHub 等一键安装，或通过对话创建自定义技能 | +| **Models** | 模型层，统一接入 OpenAI、Claude、Gemini、DeepSeek、MiniMax、GLM、Qwen 等国内外主流大语言模型 | +| **Channels** | 消息通道层，负责接收和发送消息，支持 Web 控制台、微信、飞书、钉钉、企微、公众号等，统一消息协议 | +| **CLI** | 命令行系统，提供终端命令（`cow`）和对话命令（`/`），支持进程管理、技能安装、配置修改、知识库管理等操作 | ## Agent 模式 启用 Agent 模式后，CowAgent 会以自主智能体的方式运行，核心工作流如下： -1. **接收消息** - 通过通道接收用户输入 -2. **理解意图** - 分析任务需求和上下文 -3. **规划任务** - 将复杂任务分解为多个步骤 -4. **调用工具** - 选择合适的工具执行每个步骤 -5. **记忆更新** - 将重要信息存入长期记忆 -6. **返回结果** - 将执行结果发送回用户 +1. **接收消息** — 通过通道接收用户输入 +2. **理解意图** — 分析任务需求和上下文 +3. **规划任务** — 将复杂任务分解为多个步骤 +4. **调用工具** — 选择合适的工具执行每个步骤 +5. **记忆与知识更新** — 将重要信息存入长期记忆，将结构化知识整理至知识库 +6. **返回结果** — 将执行结果发送回用户 ## 工作空间 @@ -37,11 +39,14 @@ Agent 的工作空间默认位于 `~/cow` 目录，用于存储系统提示词 ``` ~/cow/ -├── system.md # Agent system prompt -├── user.md # User profile +├── SYSTEM.md # Agent system prompt +├── USER.md # User profile +├── MEMORY.md # Core memory ├── memory/ # Long-term memory storage -│ ├── core.md # Core memory -│ └── daily/ # Daily memory +│ └── YYYY-MM-DD.md # Daily memory +├── knowledge/ # Personal knowledge base +│ ├── index.md # Knowledge index +│ └── / # Topic-based pages └── skills/ # Custom skills ├── skill-1/ └── skill-2/ @@ -75,3 +80,4 @@ Agent 的工作空间默认位于 `~/cow` 目录，用于存储系统提示词 | `agent_max_context_tokens` | 最大上下文 token 数 | `40000` | | `agent_max_context_turns` | 最大上下文记忆轮次 | `30` | | `agent_max_steps` | 单次任务最大决策步数 | `15` | +| `knowledge` | 是否启用个人知识库 | `true` | diff --git a/docs/intro/features.mdx b/docs/intro/features.mdx index 5ffca1e2..c3d18731 100644 --- a/docs/intro/features.mdx +++ b/docs/intro/features.mdx @@ -1,6 +1,6 @@ --- title: 功能介绍 -description: CowAgent 长期记忆、任务规划、技能系统、CLI 命令、浏览器工具详细说明 +description: CowAgent 长期记忆、个人知识库、任务规划、技能系统、CLI 命令、浏览器工具详细说明 --- ## 1. 长期记忆 @@ -15,13 +15,26 @@ description: CowAgent 长期记忆、任务规划、技能系统、CLI 命令、 -## 2. 任务规划和工具调用 +## 2. 个人知识库 + +> 知识库系统让 Agent 能够持续积累和组织结构化知识。与按时间线记录的记忆不同，知识库以主题为维度，将文章、对话洞察、学习材料等整理为互相关联的 Markdown 页面，形成持续增长的知识网络。 + +Agent 会在对话中自动将有价值的信息整理为知识页面，维护交叉引用和索引，通过 Web 控制台可浏览文档和查看知识图谱。知识库存储在工作空间的 `~/cow/knowledge/` 目录下。 + +- **自动整理**：Agent 在对话中自主提取和整理结构化知识，维护索引和交叉引用 +- **知识图谱**：基于页面间的交叉引用自动构建知识图谱，Web 控制台提供可视化关系图浏览 +- **对话联动**：Agent 回复中引用的知识文档链接可在 Web 控制台中直接点击跳转查看 +- **CLI 管理**：通过 `/knowledge` 命令查看统计、浏览目录，通过 `/knowledge on|off` 开关功能 + +详细说明请参考 [个人知识库](/knowledge)。 + +## 3. 任务规划和工具调用 工具是 Agent 访问操作系统资源的核心，Agent 会根据任务需求智能选择和调用工具，完成文件读写、命令执行、定时任务等各类操作。内置工具的实现在项目的 `agent/tools/` 目录下。 **主要工具：** 文件读写编辑、Bash 终端、浏览器操作、文件发送、定时调度、记忆搜索、联网搜索、环境配置等。 -### 2.1 终端和文件访问 +### 3.1 终端和文件访问 针对操作系统的终端和文件的访问能力，是最基础和核心的工具，其他很多工具或技能都是基于此进行扩展。用户可通过手机端与 Agent 交互，操作个人电脑或服务器上的资源： @@ -29,7 +42,7 @@ description: CowAgent 长期记忆、任务规划、技能系统、CLI 命令、 -### 2.2 编程能力 +### 3.2 编程能力 基于编程能力和系统访问能力，Agent 可以实现从信息搜索、图片等素材生成、编码、测试、部署、Nginx 配置修改、发布的 **Vibecoding 全流程**，通过手机端简单的一句命令完成应用的快速 demo： @@ -37,7 +50,7 @@ description: CowAgent 长期记忆、任务规划、技能系统、CLI 命令、 -### 2.3 定时任务 +### 3.3 定时任务 基于 `scheduler` 工具实现动态定时任务，支持**一次性任务、固定时间间隔、Cron 表达式**三种形式，任务触发可选择**固定消息发送**或 **Agent 动态任务**执行两种模式： @@ -45,7 +58,7 @@ description: CowAgent 长期记忆、任务规划、技能系统、CLI 命令、 -### 2.4 浏览器操作 +### 3.4 浏览器操作 内置 `browser` 工具，Agent 可控制浏览器访问网页、填写表单、点击元素、截图，支持动态 JS 渲染页面。运行 `cow install-browser` 一键安装，自动适配服务器（无头模式）和桌面环境： @@ -53,7 +66,7 @@ description: CowAgent 长期记忆、任务规划、技能系统、CLI 命令、 -### 2.5 环境变量管理 +### 3.5 环境变量管理 技能所需的秘钥存储在环境变量文件中，由 `env_config` 工具进行管理，你可以通过对话的方式更新秘钥，工具内置安全保护和脱敏策略： @@ -61,7 +74,7 @@ description: CowAgent 长期记忆、任务规划、技能系统、CLI 命令、 -## 3. 技能系统 +## 4. 技能系统 技能系统为 Agent 提供无限的扩展性，每个 Skill 由说明文件、运行脚本（可选）、资源（可选）组成，描述如何完成特定类型的任务。通过 Skill 可以让 Agent 遵循说明完成复杂流程、调用各类工具或对接第三方系统。 @@ -71,7 +84,7 @@ description: CowAgent 长期记忆、任务规划、技能系统、CLI 命令、 安装技能：`/skill install <名称>` 或 `cow skill install <名称>`，支持从 Skill Hub、GitHub、ClawHub、URL 等来源安装。 -### 3.1 创建技能 +### 4.1 创建技能 通过 `skill-creator` 技能可以通过对话的方式快速创建技能。你可以让 Agent 将某个工作流程固化为技能，或者把任意接口文档和示例发送给 Agent，让他直接完成对接： @@ -79,7 +92,7 @@ description: CowAgent 长期记忆、任务规划、技能系统、CLI 命令、 -### 3.2 搜索和图像识别 +### 4.2 搜索和图像识别 - **联网搜索：** 内置 `web_search` 工具，支持多种搜索引擎，配置 `BOCHA_API_KEY` 或 `LINKAI_API_KEY` 后启用。 - **图像识别：** 内置 `openai-image-vision` 技能，可使用 `gpt-4.1-mini`、`gpt-4.1` 等模型，依赖 `OPENAI_API_KEY`。 @@ -88,7 +101,7 @@ description: CowAgent 长期记忆、任务规划、技能系统、CLI 命令、 -### 3.3 技能广场 +### 4.3 技能广场 访问 [skills.cowagent.ai](https://skills.cowagent.ai/) 浏览所有可用技能，或在对话中执行： @@ -103,7 +116,7 @@ description: CowAgent 长期记忆、任务规划、技能系统、CLI 命令、 -## 4. CLI 命令系统 +## 5. CLI 命令系统 CowAgent 提供两种命令交互方式，覆盖服务管理、技能安装、配置调整等日常运维操作： diff --git a/docs/intro/index.mdx b/docs/intro/index.mdx index 6384f3ad..d7fd6abb 100644 --- a/docs/intro/index.mdx +++ b/docs/intro/index.mdx @@ -5,7 +5,7 @@ description: CowAgent - 基于大模型的超级AI助理 CowAgent -**CowAgent** 是基于大模型的超级AI助理，能够主动思考和任务规划、操作计算机和外部资源、创造和执行Skills、拥有长期记忆并不断成长。 +**CowAgent** 是基于大模型的超级AI助理，能够主动思考和任务规划、操作计算机和外部资源、创造和执行Skills、拥有长期记忆和知识库并不断成长。 CowAgent 支持灵活切换多种模型，能处理文本、语音、图片、文件等多模态消息，可接入微信、飞书、钉钉、企业微信应用、微信公众号、网页中使用，7×24小时运行于你的个人电脑或服务器中。 @@ -27,12 +27,12 @@ CowAgent 支持灵活切换多种模型，能处理文本、语音、图片、 自动将对话记忆持久化至本地文件和数据库中，包括全局记忆和天级记忆，支持关键词及向量检索。 + + 自动整理结构化知识，支持知识图谱可视化，通过交叉引用构建持续增长的知识网络。 + 实现了Skills创建和运行的引擎，内置多种技能，并支持通过自然语言对话完成自定义Skills开发。 - - 支持对文本、图片、语音、文件等多类型消息进行解析、处理、生成、发送等操作。 - 内置文件读写、终端执行、浏览器操作、定时任务、消息发送等工具，Agent 可自主调用工具完成复杂任务。 diff --git a/docs/ja/cli/general.mdx b/docs/ja/cli/general.mdx index ede186c5..9a61fee2 100644 --- a/docs/ja/cli/general.mdx +++ b/docs/ja/cli/general.mdx @@ -92,6 +92,31 @@ description: ステータスの確認、設定管理、コンテキスト制御 /logs 50 ``` +## knowledge + +パーソナルナレッジベースの表示と管理を行います。デフォルトでは統計情報を表示します。 + +```text +/knowledge +``` + +**ディレクトリ構造を表示：** + +```text +/knowledge list +``` + +**ナレッジベースの有効化・無効化：** + +```text +/knowledge on +/knowledge off +``` + + + ターミナル CLI では `cow knowledge` と `cow knowledge list` が利用可能ですが、`on|off` はチャットでのみサポートされます（実行時に即座に反映するため）。 + + ## version 現在の CowAgent のバージョンを表示します。 diff --git a/docs/ja/cli/index.mdx b/docs/ja/cli/index.mdx index a9f9d2b1..02eaf063 100644 --- a/docs/ja/cli/index.mdx +++ b/docs/ja/cli/index.mdx @@ -40,6 +40,9 @@ Service: Skills: skill Manage skills (list / search / install / uninstall ...) +Knowledge: + knowledge View knowledge base stats and structure + Others: help Show this help message version Show version @@ -55,6 +58,9 @@ Web コンソールや接続されたチャネルの会話で `/` を入力す | `/status` | サービスの状態と設定を表示 | | `/config` | 実行時設定の表示・変更 | | `/skill` | スキル管理（インストール、アンインストール、有効化、無効化など） | +| `/knowledge` | ナレッジベースの統計情報を表示 | +| `/knowledge list` | ナレッジベースのディレクトリ構造を表示 | +| `/knowledge on\|off` | ナレッジベースの有効化・無効化 | | `/context` | 現在のセッションのコンテキスト情報を表示 | | `/context clear` | 現在のセッションのコンテキストをクリア | | `/logs` | 最近のログを表示 | @@ -74,6 +80,7 @@ Web コンソールや接続されたチャネルの会話で `/` を入力す | logs | ✓ | ✓ | | config | ✗ | ✓ | | context | — | ✓ | +| knowledge（サブコマンド） | ✓ | ✓ | | skill（サブコマンド） | ✓ | ✓ | | start / stop / restart | ✓ | ✗ | | update | ✓ | ✗ | diff --git a/docs/ja/intro/architecture.mdx b/docs/ja/intro/architecture.mdx index 3add3fe9..57ef30af 100644 --- a/docs/ja/intro/architecture.mdx +++ b/docs/ja/intro/architecture.mdx @@ -11,14 +11,16 @@ CowAgent のアーキテクチャは以下のコアモジュールで構成さ CowAgent Architecture -### コアモジュール - | モジュール | 説明 | | --- | --- | -| **Channels** | メッセージの受信と送信を行うメッセージチャネル層。Web、Feishu（飛書）、DingTalk（釘釘）、WeCom（企業微信）、WeChat公式アカウントなどをサポート | -| **Agent Core** | タスク計画、記憶システム、Skill エンジンを含む Agent エンジン | -| **Tools** | Agent が OS リソースにアクセスするためのツール層。10 以上の組み込みツール | -| **Models** | 主要な LLM への統一アクセスを提供するモデル層 | +| **Plan** | ユーザーの意図を理解し、複雑なタスクをマルチステップの計画に分解、目標達成までツールを反復的に呼び出す | +| **Memory** | 重要な情報をコアメモリとデイリーメモリとして自動永続化し、キーワードとベクトルのハイブリッド検索でセッション間の連続性を実現 | +| **Knowledge** | トピック別に構造化された知識を整理。Agent が価値ある情報を Markdown ページとして自律的に整理し、インデックスと相互参照で成長するナレッジネットワークを構築 | +| **Tools** | Agent が OS リソースにアクセスするための中核能力。ファイル読み書き、ターミナル、ブラウザ、スケジューラ、記憶検索、Web 検索など 10 以上の組み込みツール | +| **Skills** | Skill の読み込み・管理。Skill Hub や GitHub からのワンクリックインストール、または会話を通じたカスタム Skill の作成をサポート | +| **Models** | モデル層。OpenAI、Claude、Gemini、DeepSeek、MiniMax、GLM、Qwen など主要 LLM への統一アクセスを提供 | +| **Channels** | メッセージチャネル層。Web コンソール、WeChat、Feishu、DingTalk、WeCom、公式アカウントなど複数チャネルを統一プロトコルでサポート | +| **CLI** | コマンドラインシステム。ターミナルコマンド（`cow`）とチャットコマンド（`/`）で、プロセス管理、Skill インストール、設定変更、ナレッジベース管理などをサポート | ## Agent モードのワークフロー @@ -28,7 +30,7 @@ Agent モードが有効な場合、CowAgent は以下のワークフローで 2. **意図の理解** — タスク要件とコンテキストを分析 3. **タスク計画** — 複雑なタスクを複数のステップに分解 4. **ツール呼び出し** — 各ステップに適切なツールを選択・実行 -5. **記憶の更新** — 重要な情報を長期記憶に保存 +5. **記憶・ナレッジの更新** — 重要な情報を長期記憶に保存し、構造化された知識をナレッジベースに整理 6. **結果の返却** — 実行結果をユーザーに送信 ## ワークスペースのディレクトリ構成 @@ -39,9 +41,12 @@ Agent のワークスペースはデフォルトで `~/cow` にあり、シス ~/cow/ ├── system.md # Agent システムプロンプト ├── user.md # ユーザープロフィール +├── MEMORY.md # コアメモリ ├── memory/ # 長期記憶ストレージ -│ ├── core.md # コアメモリ -│ └── daily/ # デイリーメモリ +│ └── YYYY-MM-DD.md # デイリーメモリ +├── knowledge/ # パーソナルナレッジベース +│ ├── index.md # ナレッジインデックス +│ └── / # トピック別ページ └── skills/ # カスタム Skill ├── skill-1/ └── skill-2/ @@ -75,3 +80,4 @@ Agent のワークスペースはデフォルトで `~/cow` にあり、シス | `agent_max_context_tokens` | 最大コンテキストトークン数 | `40000` | | `agent_max_context_turns` | 最大コンテキストターン数 | `30` | | `agent_max_steps` | タスクあたりの最大判断ステップ数 | `15` | +| `knowledge` | パーソナルナレッジベースの有効化 | `true` | diff --git a/docs/ja/intro/features.mdx b/docs/ja/intro/features.mdx index 0e213f3a..5b82c8c1 100644 --- a/docs/ja/intro/features.mdx +++ b/docs/ja/intro/features.mdx @@ -15,13 +15,26 @@ description: CowAgent の長期記憶、タスク計画、Skill システム、C -## 2. タスク計画とツール活用 +## 2. パーソナルナレッジベース + +> ナレッジベースシステムにより、Agent は構造化された知識を継続的に蓄積・整理できます。時系列で記録されるメモリとは異なり、ナレッジベースはトピック別に整理され、記事、会話からの洞察、学習資料などを相互にリンクされた Markdown ページとして整理し、継続的に成長するナレッジネットワークを形成します。 + +Agent は会話中に価値ある情報を自動的にナレッジページとして整理し、相互参照とインデックスを維持します。Web コンソールではドキュメントの閲覧とナレッジグラフの可視化が可能です。ナレッジはワークスペースの `~/cow/knowledge/` ディレクトリに保存されます。 + +- **自動整理**：Agent が会話中に構造化された知識を自律的に抽出・整理し、インデックスと相互参照を維持 +- **ナレッジグラフ**：ページ間の相互参照から自動的にナレッジグラフを構築し、Web コンソールでインタラクティブな関係図として可視化 +- **チャット連携**：Agent の回答で参照されるナレッジドキュメントのリンクを Web コンソールで直接クリックして閲覧可能 +- **CLI 管理**：`/knowledge` コマンドで統計表示、ディレクトリ閲覧、`/knowledge on|off` で機能の切り替えが可能 + +詳細は [パーソナルナレッジベース](/ja/knowledge) を参照してください。 + +## 3. タスク計画とツール活用 ツールは Agent がオペレーティングシステムのリソースにアクセスするための中核です。Agent はタスク要件に基づいてインテリジェントにツールを選択・呼び出し、ファイルの読み書き、コマンド実行、スケジュールタスクなどを実行します。組み込みツールはプロジェクトの `agent/tools/` ディレクトリに実装されています。 **主なツール：** ファイルの読み書き・編集、Bash ターミナル、ブラウザ操作、ファイル送信、スケジューラ、記憶検索、Web 検索、環境設定など。 -### 2.1 ターミナルとファイルアクセス +### 3.1 ターミナルとファイルアクセス OS のターミナルとファイルシステムへのアクセスは、最も基本的かつ中核的な機能です。多くの他のツールや Skill はこの機能の上に構築されています。ユーザーはモバイルデバイスから Agent とやり取りし、パソコンやサーバーのリソースを操作できます： @@ -29,7 +42,7 @@ OS のターミナルとファイルシステムへのアクセスは、最も -### 2.2 プログラミング能力 +### 3.2 プログラミング能力 プログラミングとシステムアクセスを組み合わせることで、Agent は完全な **Vibecoding ワークフロー** を実行できます。情報検索、アセット生成、コーディング、テスト、デプロイ、Nginx 設定、公開まで、すべてスマートフォンからの一つのコマンドで実行可能です： @@ -37,7 +50,7 @@ OS のターミナルとファイルシステムへのアクセスは、最も -### 2.3 スケジュールタスク +### 3.3 スケジュールタスク `scheduler` ツールにより動的なスケジュールタスクが可能で、**ワンタイムタスク、固定間隔、Cron 式**をサポートしています。タスクは**固定メッセージ送信**または **Agent 動的タスク**実行としてトリガーできます： @@ -45,7 +58,7 @@ OS のターミナルとファイルシステムへのアクセスは、最も -### 2.4 ブラウザ操作 +### 3.4 ブラウザ操作 組み込みの `browser` ツールにより、Agent は Chromium ブラウザを制御して Web ページへのアクセス、フォームの入力、要素のクリック、スクリーンショットの撮影が可能です。動的 JS レンダリングページにも対応しています。`cow install-browser` でワンコマンドインストール、サーバー（ヘッドレス）とデスクトップ環境に自動対応します： @@ -53,7 +66,7 @@ OS のターミナルとファイルシステムへのアクセスは、最も -### 2.5 環境変数管理 +### 3.5 環境変数管理 Skill が必要とするシークレットキーは環境変数ファイルに保存され、`env_config` ツールによって管理されます。会話を通じてシークレットを更新でき、セキュリティ保護とマスキング機能が組み込まれています： @@ -61,7 +74,7 @@ Skill が必要とするシークレットキーは環境変数ファイルに -## 3. Skill システム +## 4. Skill システム Skill システムは Agent に無限の拡張性を提供します。各 Skill は説明ファイル、実行スクリプト（任意）、リソース（任意）で構成され、特定のタイプのタスクを完了する方法を記述します。Skill により Agent は複雑なワークフローの指示に従い、ツールを呼び出し、サードパーティシステムと連携できます。 @@ -71,7 +84,7 @@ Skill システムは Agent に無限の拡張性を提供します。各 Skill Skill のインストール：`/skill install <名前>` または `cow skill install <名前>`。Skill Hub、GitHub、ClawHub、URL などからインストール可能。 -### 3.1 Skill の作成 +### 4.1 Skill の作成 `skill-creator` Skill により、会話を通じて Skill を素早く作成できます。ワークフローを Skill としてコード化するよう Agent に依頼したり、API ドキュメントやサンプルを送信して Agent に直接連携を完成させることができます： @@ -79,7 +92,7 @@ Skill のインストール：`/skill install <名前>` または `cow skill ins -### 3.2 Web 検索と画像認識 +### 4.2 Web 検索と画像認識 - **Web 検索：** 組み込みの `web_search` ツールで、複数の検索エンジンをサポートします。`BOCHA_API_KEY` または `LINKAI_API_KEY` を設定して有効化してください。 - **画像認識：** 組み込みの `openai-image-vision` Skill で、`gpt-4.1-mini`、`gpt-4.1` などのモデルをサポートします。`OPENAI_API_KEY` が必要です。 @@ -88,7 +101,7 @@ Skill のインストール：`/skill install <名前>` または `cow skill ins -### 3.3 Skill Hub +### 4.3 Skill Hub [skills.cowagent.ai](https://skills.cowagent.ai/) で利用可能なすべての Skill を閲覧するか、会話内でコマンドを実行できます： @@ -102,7 +115,7 @@ GitHub、ClawHub、LinkAI などサードパーティプラットフォームの -## 4. CLI コマンドシステム +## 5. CLI コマンドシステム CowAgent はサービス管理、Skill インストール、設定変更などをカバーする2つのコマンドインターフェースを提供します： diff --git a/docs/ja/intro/index.mdx b/docs/ja/intro/index.mdx index e0e51828..760f7d6d 100644 --- a/docs/ja/intro/index.mdx +++ b/docs/ja/intro/index.mdx @@ -22,6 +22,9 @@ CowAgent は自ら思考しタスクを計画し、コンピュータや外部 会話の記憶をローカルファイルやデータベースに自動的に永続化します。コアメモリとデイリーメモリを含み、キーワード検索とベクトル検索に対応しています。 + + 構造化された知識を自動整理し、ナレッジグラフの可視化をサポート。相互参照により継続的に成長するナレッジネットワークを構築します。 + Skill の作成・実行エンジンを実装し、組み込み Skill を搭載。自然言語の会話を通じてカスタム Skill の開発もサポートしています。 diff --git a/docs/ja/knowledge/index.mdx b/docs/ja/knowledge/index.mdx new file mode 100644 index 00000000..0ded408c --- /dev/null +++ b/docs/ja/knowledge/index.mdx @@ -0,0 +1,77 @@ +--- +title: パーソナルナレッジベース +description: CowAgent のパーソナルナレッジベース — 構造化された知識の蓄積、自動整理、ナレッジグラフ +--- + +パーソナルナレッジベースは、Agent の長期的な構造化知識ストレージで、ワークスペースの `knowledge/` ディレクトリに保存されます。タイムラインで整理されるメモリとは異なり、ナレッジベースはトピック別にコンテンツを整理します。記事、会話のインサイト、学習資料が相互リンクされた Markdown ページとして構造化され、継続的に成長するナレッジネットワークを形成します。 + +## コアコンセプト + +### ナレッジ vs メモリ + +| 次元 | ナレッジベース（knowledge/） | 長期記憶（memory/） | +| --- | --- | --- | +| 整理方法 | トピック別、相互リンク | タイムライン順、日付ファイル | +| 書き込み | Agent が能動的に構造化 | コンテキストトリミング時に自動要約 | +| コンテンツ | 精製された構造化知識 | 生の会話要約 | +| 用途 | 学習ノート、技術ドキュメント、プロジェクト知識 | 会話履歴、イベント記録 | + +### ディレクトリ構造 + +``` +~/cow/knowledge/ +├── index.md # ナレッジインデックス、全ページのエントリポイント +├── log.md # 変更ログ、各書き込みの記録 +├── concepts/ # 概念的な知識 +│ └── machine-learning.md +├── entities/ # エンティティ知識（人物、組織、ツール） +│ └── openai.md +└── sources/ # ソース知識（記事、論文） + └── llm-wiki.md +``` + +ディレクトリ構造は柔軟です — Agent は実際のコンテンツに基づいて適切なカテゴリディレクトリを自動作成します。ユーザーが整理方法をカスタマイズすることも可能です。 + +## 自動整理 + +ナレッジの書き込みは Agent の自律的な動作で、以下のシナリオでトリガーされます： + +- **ユーザーが記事やドキュメントを共有** — Agent が自動的にキー情報を抽出し、構造化されたナレッジページを作成 +- **会話から価値ある結論が生まれた場合** — Agent がインサイトをナレッジページに整理し、既存の知識とリンク +- **ユーザーが明示的に整理を要求** — ユーザーは会話を通じて Agent にナレッジの整理・更新を指示可能 + +各ナレッジページには関連ページへの相互参照リンクが含まれ、ナレッジグラフを段階的に構築します。 + +## ナレッジ検索 + +Agent は会話中に以下の方法でナレッジを検索できます： + +- **インデックス参照** — `knowledge/index.md` で関連ページを素早く特定 +- **セマンティック検索** — `memory_search` ツールでナレッジコンテンツをセマンティック検索 +- **直接読み取り** — `memory_get` ツールで特定のナレッジファイルを読み取り + +## Web コンソール + +Web コンソールには専用の「ナレッジ」モジュールがあり、以下をサポートします： + +- **ドキュメント閲覧** — ツリー形式のディレクトリ構造、検索・折りたたみ可能、クリックでコンテンツ表示 +- **ナレッジグラフ** — D3.js フォースダイレクテッドグラフによるナレッジ間の関係を可視化 +- **チャット連携** — Agent の返信で参照されたナレッジドキュメントリンクはクリックで直接ナビゲーション + +## CLI コマンド + +`/knowledge` コマンドでナレッジベースを管理： + +| コマンド | 説明 | +| --- | --- | +| `/knowledge` | ナレッジベースの統計情報を表示 | +| `/knowledge list` | ファイルディレクトリをツリー形式で表示 | +| `/knowledge on` | ナレッジベース機能を有効化 | +| `/knowledge off` | ナレッジベース機能を無効化 | + +## 設定 + +| パラメータ | 説明 | デフォルト | +| --- | --- | --- | +| `knowledge` | パーソナルナレッジベースの有効/無効 | `true` | +| `agent_workspace` | ワークスペースパス、ナレッジは `knowledge/` サブディレクトリに保存されます | `~/cow` | diff --git a/docs/ja/tools/memory.mdx b/docs/ja/tools/memory.mdx index 06097223..d82791cf 100644 --- a/docs/ja/tools/memory.mdx +++ b/docs/ja/tools/memory.mdx @@ -1,9 +1,11 @@ --- -title: memory - メモリ -description: 長期メモリの検索と読み取り +title: memory - メモリ & ナレッジ +description: 長期メモリとナレッジベースファイルの検索・読み取り --- -メモリToolには `memory_search`（メモリ検索）と `memory_get`（メモリファイル読み取り）の2つのサブToolがあります。 +メモリToolには `memory_search`（メモリ検索）と `memory_get`（メモリまたはナレッジファイル読み取り）の2つのサブToolがあります。 + +[ナレッジベース](/ja/knowledge) 機能が有効な場合、両ツールとも `knowledge/` ディレクトリのファイルへのアクセスもサポートします。 ## 依存関係 @@ -11,7 +13,7 @@ description: 長期メモリの検索と読み取り ## memory_search -キーワードとベクトルのハイブリッド検索で過去のメモリを検索します。 +キーワードとベクトルのハイブリッド検索で過去のメモリとナレッジベースの内容を検索します。 | パラメータ | 型 | 必須 | 説明 | | --- | --- | --- | --- | @@ -19,11 +21,11 @@ description: 長期メモリの検索と読み取り ## memory_get -特定のメモリファイルの内容を読み取ります。 +特定のメモリファイルまたはナレッジファイルの内容を読み取ります。 | パラメータ | 型 | 必須 | 説明 | | --- | --- | --- | --- | -| `path` | string | はい | メモリファイルの相対パス（例：`MEMORY.md`、`memory/2026-01-01.md`） | +| `path` | string | はい | ファイルの相対パス（例：`MEMORY.md`、`memory/2026-01-01.md`、`knowledge/concepts/rag.md`） | | `start_line` | integer | いいえ | 開始行番号 | | `end_line` | integer | いいえ | 終了行番号 | @@ -34,3 +36,8 @@ Agentは以下のシナリオでメモリToolを自動的に呼び出します - ユーザーが重要な情報を共有した場合 → メモリに保存 - 過去のコンテキストが必要な場合 → 関連するメモリを検索 - 会話が一定の長さに達した場合 → 要約を抽出して保存 +- 専門知識について議論する場合 → ナレッジベースから関連ページを検索 + + + 設定で `knowledge` が `false` に設定されている場合、ツールの説明と検索範囲は自動的にメモリファイルのみに調整されます。 + diff --git a/docs/knowledge/index.mdx b/docs/knowledge/index.mdx new file mode 100644 index 00000000..b4cf7f9b --- /dev/null +++ b/docs/knowledge/index.mdx @@ -0,0 +1,77 @@ +--- +title: 个人知识库 +description: CowAgent 的个人知识库系统 — 结构化知识沉淀、自动整理与知识图谱 +--- + +个人知识库是 Agent 的长期结构化知识存储，保存在工作空间的 `knowledge/` 目录下。与按时间线组织的记忆不同，知识库以主题为维度，将用户分享的文章、对话中的洞察、学习材料等整理为互相关联的 Markdown 页面，形成可持续增长的知识网络。 + +## 核心概念 + +### 知识 vs 记忆 + +| 维度 | 知识库（knowledge/） | 长期记忆（memory/） | +| --- | --- | --- | +| 组织方式 | 按主题分类、互相关联 | 按时间线、日期文件 | +| 写入方式 | Agent 主动整理结构化内容 | 上下文裁剪时自动摘要 | +| 内容特点 | 提炼后的结构化知识 | 原始对话摘要 | +| 典型用途 | 学习笔记、技术文档、项目知识 | 对话历史、事件记录 | + +### 目录结构 + +``` +~/cow/knowledge/ +├── index.md # 知识索引，所有页面的入口 +├── log.md # 变更日志，记录每次写入 +├── concepts/ # 概念类知识 +│ └── machine-learning.md +├── entities/ # 实体类知识（人物、组织、工具） +│ └── openai.md +└── sources/ # 来源类知识（文章、论文） + └── llm-wiki.md +``` + +目录结构是灵活的 — Agent 会根据实际内容自动创建合适的分类目录。用户也可以通过对话自定义目录组织方式。 + +## 自动整理 + +知识库的写入是 Agent 的自主行为，在以下场景中触发： + +- **用户分享文章或文档** — Agent 自动提取关键信息，创建结构化知识页面 +- **对话产生有价值的结论** — Agent 将洞察整理为知识页面，并与已有知识建立关联 +- **用户主动要求整理** — 用户可以通过对话指导 Agent 组织和更新知识 + +每个知识页面都包含与其他页面的交叉引用链接，逐步构建起一个知识图谱。 + +## 知识检索 + +Agent 在对话中可以通过以下方式检索知识： + +- **索引查阅** — 通过 `knowledge/index.md` 快速定位相关知识页面 +- **语义搜索** — 通过 `memory_search` 工具对知识库内容进行语义检索 +- **直接读取** — 通过 `memory_get` 工具读取特定知识文件 + +## Web 控制台 + +Web 控制台提供了专用的「知识」模块，支持： + +- **文档浏览** — 树状目录结构，可搜索、可折叠，点击查看文档内容 +- **知识图谱** — 基于 D3.js 的力导向图，可视化展示知识之间的关联关系 +- **对话联动** — Agent 回复中引用的知识文档链接可直接点击跳转查看 + +## CLI 命令 + +通过 `/knowledge` 命令管理知识库： + +| 命令 | 说明 | +| --- | --- | +| `/knowledge` | 显示知识库统计信息 | +| `/knowledge list` | 以树状结构显示文件目录 | +| `/knowledge on` | 开启知识库功能 | +| `/knowledge off` | 关闭知识库功能 | + +## 相关配置 + +| 参数 | 说明 | 默认值 | +| --- | --- | --- | +| `knowledge` | 是否启用个人知识库功能 | `true` | +| `agent_workspace` | 工作空间路径，知识库存储在此目录的 `knowledge/` 子目录下 | `~/cow` | diff --git a/docs/tools/memory.mdx b/docs/tools/memory.mdx index 0b60624a..c3cc6fe4 100644 --- a/docs/tools/memory.mdx +++ b/docs/tools/memory.mdx @@ -1,9 +1,11 @@ --- -title: memory - 记忆 -description: 搜索和读取长期记忆 +title: memory - 记忆与知识 +description: 搜索和读取长期记忆及知识库文件 --- -记忆工具包含两个子工具：`memory_search`（搜索记忆）和 `memory_get`（读取记忆文件）。 +记忆工具包含两个子工具：`memory_search`（搜索记忆）和 `memory_get`（读取记忆或知识文件）。 + +当 [知识库](/knowledge) 功能开启时，这两个工具同时支持访问 `memory/` 和 `knowledge/` 目录下的文件。 ## 依赖 @@ -11,7 +13,7 @@ description: 搜索和读取长期记忆 ## memory_search -搜索历史记忆，支持关键词和向量混合检索。 +搜索历史记忆和知识库内容，支持关键词和向量混合检索。 | 参数 | 类型 | 必填 | 说明 | | --- | --- | --- | --- | @@ -19,11 +21,11 @@ description: 搜索和读取长期记忆 ## memory_get -读取特定记忆文件的内容。 +读取特定记忆文件或知识库文件的内容。 | 参数 | 类型 | 必填 | 说明 | | --- | --- | --- | --- | -| `path` | string | 是 | 记忆文件的相对路径（如 `MEMORY.md`、`memory/2026-01-01.md`） | +| `path` | string | 是 | 文件的相对路径（如 `MEMORY.md`、`memory/2026-01-01.md`、`knowledge/concepts/rag.md`） | | `start_line` | integer | 否 | 起始行号 | | `end_line` | integer | 否 | 结束行号 | @@ -34,3 +36,8 @@ Agent 会在以下场景自动调用记忆工具： - 用户分享重要信息时 → 存储到记忆 - 需要参考历史信息时 → 搜索相关记忆 - 对话达到一定长度时 → 提取摘要存储 +- 讨论到专业知识时 → 检索知识库中的相关页面 + + + 当 `knowledge` 配置为 `false` 时，工具的描述和搜索范围会自动调整为仅包含记忆文件。 + diff --git a/skills/knowledge-wiki/SKILL.md b/skills/knowledge-wiki/SKILL.md index 508441ac..1b0123da 100644 --- a/skills/knowledge-wiki/SKILL.md +++ b/skills/knowledge-wiki/SKILL.md @@ -89,3 +89,4 @@ Append-only, newest at bottom: - **Index is mandatory**: always update `knowledge/index.md` after any change - **Be concise**: capture essence, not copy entire sources - **Full paths in replies**: when referencing knowledge files in conversation replies, use the full path from workspace root (e.g. `[Title](knowledge//.md)`), not relative paths. Relative paths are only for cross-references inside knowledge pages themselves. +- **Cite sources**: when answering based on knowledge pages, include links to the relevant pages so the user can explore further.