Refactor: Modularize tools and prompts system

graph_memory_tui/core/graph_client.py

@@ -0,0 +1,360 @@
+#!/usr/bin/env python3
+"""
+Graph Memory Client - 图记忆客户端核心实现（重构版）
+使用模块化的工具和提示词系统
+"""
+
+import json
+import os
+import uuid
+from datetime import datetime
+from openai import OpenAI
+
+# 导入新的工具和提示词模块
+from .tools import TOOLS, execute_tool
+from .prompts import PromptManager
+
+# 环境配置
+DEEPSEEK_API_KEY = os.environ.get("DEEPSEEK_API_KEY", "")
+DEEPSEEK_BASE_URL = os.environ.get("DEEPSEEK_BASE_URL", "https://api.deepseek.com")
+MODEL_NAME = os.environ.get("MODEL_NAME", "deepseek-chat")
+
+NEO4J_URI = os.environ.get("NEO4J_URI", "bolt://localhost:7687")
+NEO4J_USER = os.environ.get("NEO4J_USER", "neo4j")
+NEO4J_PASSWORD = os.environ.get("NEO4J_PASSWORD", "neo4j")
+
+# 会话配置
+CURRENT_SESSION_ID = f"session-{datetime.now().strftime('%Y%m%d')}-{uuid.uuid4().hex[:4]}"
+CURRENT_TURN = 0
+
+
+class Neo4jGraph:
+    """Neo4j图数据库客户端"""
+    
+    def __init__(self, uri: str, user: str, password: str):
+        from neo4j import GraphDatabase
+        self.driver = GraphDatabase.driver(uri, auth=(user, password))
+    
+    def close(self):
+        self.driver.close()
+    
+    def ensure_constraints(self):
+        """确保约束和索引存在"""
+        with self.driver.session() as session:
+            # 实体约束
+            session.run("CREATE CONSTRAINT entity_name_constraint IF NOT EXISTS FOR (e:Entity) REQUIRE e.name IS UNIQUE")
+            session.run("CREATE CONSTRAINT session_id_constraint IF NOT EXISTS FOR (s:Session) REQUIRE s.session_id IS UNIQUE")
+            
+            # 关系索引
+            session.run("CREATE INDEX rel_created_at IF NOT EXISTS FOR ()-[r:RELATES]-() ON r.created_at")
+            session.run("CREATE INDEX rel_session_id IF NOT EXISTS FOR ()-[r:RELATES]-() ON r.session_id")
+            session.run("CREATE INDEX rel_type IF NOT EXISTS FOR ()-[r:RELATES]-() ON r.type")
+            session.run("CREATE INDEX rel_status IF NOT EXISTS FOR ()-[r:RELATES]-() ON r.status")
+            session.run("CREATE INDEX rel_date_bucket IF NOT EXISTS FOR ()-[r:RELATES]-() ON r.date_bucket")
+            
+            # 实体索引
+            session.run("CREATE INDEX entity_type IF NOT EXISTS FOR (e:Entity) ON e.type")
+            session.run("CREATE INDEX entity_mention_count IF NOT EXISTS FOR (e:Entity) ON e.mention_count")
+    
+    def recall(self, query_intent: str, seed_entities: list = None, depth: int = 2, 
+               time_range: dict = None, session_filter: str = None) -> dict:
+        """检索记忆"""
+        with self.driver.session() as session:
+            # 支持逗号分隔的多个关键词
+            keywords = [w.strip() for w in query_intent.replace(',', ' ').split() if len(w.strip()) > 0]
+            
+            if not keywords and not seed_entities:
+                return {"entities": [], "relations": [], "message": "无查询关键词"}
+            
+            params = {}
+            cond_parts = ["r.status = 'active'"]
+            
+            if session_filter:
+                cond_parts.append("r.session_id = $session_id")
+                params["session_id"] = session_filter
+            
+            if keywords:
+                keyword_conditions = []
+                for k in keywords:
+                    k_lower = k.lower()
+                    keyword_conditions.append(f"toLower(e.name) CONTAINS '{k_lower}'")
+                    keyword_conditions.append(f"toLower(t.name) CONTAINS '{k_lower}'")
+                    keyword_conditions.append(f"toLower(r.type) CONTAINS '{k_lower}'")
+                cond_parts.append(f"({' OR '.join(keyword_conditions)})")
+            
+            if seed_entities:
+                placeholders = ",".join([f"'{s}'" for s in seed_entities])
+                cond_parts.append(f"(e.name IN [{placeholders}] OR t.name IN [{placeholders}])")
+            
+            if time_range and "days" in time_range:
+                cond_parts.append(f"r.created_at >= datetime() - duration('P{time_range['days']}D')")
+            
+            where_clause = " AND ".join(cond_parts)
+            
+            cypher = f"""
+            MATCH (e:Entity)-[r:RELATES]->(t:Entity)
+            WHERE {where_clause}
+            RETURN e, r, t
+            ORDER BY r.created_at DESC
+            LIMIT 30
+            """
+            
+            result = session.run(cypher, params)
+            entities, relations = {}, []
+            
+            for record in result:
+                e, r, t = record["e"], record["r"], record["t"]
+                if e["name"] not in entities:
+                    entities[e["name"]] = {"name": e["name"], "type": e.get("type", "unknown"), "mention_count": e.get("mention_count", 1)}
+                if t["name"] not in entities:
+                    entities[t["name"]] = {"name": t["name"], "type": t.get("type", "unknown"), "mention_count": t.get("mention_count", 1)}
+                
+                relations.append({
+                    "source": e["name"],
+                    "target": t["name"],
+                    "type": r["type"],
+                    "created_at": str(r.get("created_at", "")),
+                    "session_id": r.get("session_id", ""),
+                    "turn_id": r.get("turn_id", 0),
+                    "confidence": r.get("confidence", 1.0)
+                })
+            
+            return {"entities": list(entities.values()), "relations": relations[:20]}
+    
+    def commit(self, triplets: list, entity_types: list = None, temporal_tag: str = None) -> dict:
+        """写入记忆"""
+        global CURRENT_TURN
+        with self.driver.session() as session:
+            valid_triplets = [t for t in triplets if t.get("subject") and t.get("relation") and t.get("object")]
+            
+            if not valid_triplets:
+                return {"committed_count": 0, "details": []}
+            
+            etype = entity_types[0] if entity_types else "unknown"
+            date_bucket = temporal_tag or datetime.now().strftime("%Y-%m-%d")
+            
+            results = []
+            for triplet in valid_triplets:
+                subject = triplet.get("subject", "").strip()
+                relation = triplet.get("relation", "").strip()
+                obj = triplet.get("object", "").strip()
+                confidence = triplet.get("confidence", 0.9)
+                
+                session.run("""
+                MERGE (s:Entity {name: $subject})
+                ON CREATE SET s.type = $type, s.created_at = datetime(), s.mention_count = 1, s.updated_at = datetime()
+                ON MATCH SET s.mention_count = coalesce(s.mention_count, 0) + 1, s.updated_at = datetime()
+                
+                MERGE (t:Entity {name: $object})
+                ON CREATE SET t.type = $type, t.created_at = datetime(), t.mention_count = 1, t.updated_at = datetime()
+                ON MATCH SET t.mention_count = coalesce(t.mention_count, 0) + 1, t.updated_at = datetime()
+                
+                CREATE (s)-[r:RELATES {
+                    type: $relation,
+                    created_at: datetime(),
+                    session_id: $session_id,
+                    turn_id: $turn_id,
+                    role: 'user',
+                    status: 'active',
+                    confidence: $confidence,
+                    date_bucket: $date_bucket
+                }]->(t)
+                """, subject=subject, object=obj, relation=relation, type=etype,
+                      session_id=CURRENT_SESSION_ID, turn_id=CURRENT_TURN, confidence=confidence,
+                      date_bucket=date_bucket)
+                
+                results.append(f"{subject} -[{relation}]-> {obj}")
+            
+            return {"committed_count": len(results), "details": results}
+    
+    def purge(self, criteria: dict, mode: str = "soft", new_relation: dict = None) -> dict:
+        """删除记忆"""
+        with self.driver.session() as session:
+            subject_pattern = criteria.get("subject_contains", "")
+            rel_type = criteria.get("relation_type", "")
+            target_pattern = criteria.get("target_contains", "")
+            session_id = criteria.get("session_id", CURRENT_SESSION_ID)
+            
+            cond_parts = ["r.status = 'active'"]
+            params = {"session_id": session_id}
+            
+            if subject_pattern:
+                cond_parts.append("e.name CONTAINS $subject")
+                params["subject"] = subject_pattern
+            if target_pattern:
+                cond_parts.append("t.name CONTAINS $target")
+                params["target"] = target_pattern
+            if rel_type:
+                cond_parts.append("r.type = $rel_type")
+                params["rel_type"] = rel_type
+            
+            where_clause = " AND ".join(cond_parts)
+            
+            if mode == "supersede" and new_relation:
+                new_rel = new_relation.get("relation", "")
+                new_target = new_relation.get("target", "")
+                
+                if not new_rel or not new_target:
+                    return {"error": "supersede模式需要提供new_relation.relation和new_relation.target"}
+                
+                result = session.run(f"""
+                MATCH (s:Entity)-[r:RELATES]->(t:Entity)
+                WHERE {where_clause}
+                SET r.status = 'superseded', r.updated_at = datetime()
+                RETURN count(r) as count
+                """, params)
+                
+                count = result.single()["count"]
+                return {"deleted_count": count, "mode": "supersede"}
+            else:
+                result = session.run(f"""
+                MATCH ()-[r:RELATES]->()
+                WHERE {where_clause}
+                SET r.status = 'deleted', r.updated_at = datetime()
+                RETURN count(r) as deleted
+                """, params)
+                count = result.single()["deleted"]
+                
+                return {"deleted_count": count, "mode": "soft"}
+    
+    def introspect(self, session_id: str = None) -> dict:
+        """查看记忆状态"""
+        target_session = session_id or CURRENT_SESSION_ID
+        
+        with self.driver.session() as session:
+            result = session.run("""
+            MATCH (s:Entity)-[r:RELATES]->(t:Entity)
+            WHERE r.session_id = $session_id AND r.status = 'active'
+            RETURN collect(DISTINCT s.name) as source_entities,
+                   collect(DISTINCT t.name) as target_entities,
+                   count(r) as rel_count,
+                   collect(DISTINCT r.type) as rel_types
+            """, session_id=target_session)
+            record = result.single()
+            
+            result2 = session.run("""
+            MATCH (e:Entity)
+            RETURN e.name as name, e.mention_count as count, e.type as type
+            ORDER BY e.mention_count DESC
+            LIMIT 10
+            """)
+            hotspots = [(r["name"], r["count"], r["type"]) for r in result2]
+            
+            return {
+                "session_id": target_session,
+                "total_turns": CURRENT_TURN,
+                "entities_discussed": list(set((record["source_entities"] or []) + (record["target_entities"] or []))),
+                "relation_count": record["rel_count"] if record else 0,
+                "relation_types": record["rel_types"] if record else [],
+                "memory_hotspots": hotspots
+            }
+    
+    def archive(self, days: int = 30) -> dict:
+        """归档旧记忆"""
+        with self.driver.session() as session:
+            result = session.run("""
+            MATCH ()-[r:RELATES]->()
+            WHERE r.status = 'active' AND r.created_at < datetime() - duration('P' + $days + 'D')
+            SET r.status = 'archived', r.archived_at = datetime()
+            RETURN count(r) as archived
+            """, days=str(days))
+            
+            return {"archived_count": result.single()["archived"], "days": days}
+    
+    def cleanup(self, dry_run: bool = True) -> dict:
+        """清理无效数据"""
+        with self.driver.session() as session:
+            result1 = session.run("""
+            MATCH ()-[r:RELATES]->()
+            WHERE r.status = 'deleted' AND r.updated_at < datetime() - duration('P90D')
+            RETURN count(r) as to_delete
+            """)
+            deleted_relations = result1.single()["to_delete"]
+            
+            result2 = session.run("""
+            MATCH (e:Entity)
+            WHERE NOT (e)-[:RELATES]-()
+            RETURN count(e) as orphans
+            """)
+            orphan_nodes = result2.single()["orphans"]
+            
+            if not dry_run and deleted_relations > 0:
+                session.run("""
+                MATCH ()-[r:RELATES]->()
+                WHERE r.status = 'deleted' AND r.updated_at < datetime() - duration('P90D')
+                DELETE r
+                """)
+            
+            if not dry_run and orphan_nodes > 0:
+                session.run("""
+                MATCH (e:Entity)
+                WHERE NOT (e)-[:RELATES]-()
+                DELETE e
+                """)
+            
+            return {
+                "dry_run": dry_run,
+                "deleted_relations": deleted_relations,
+                "orphan_nodes": orphan_nodes,
+                "action_taken": not dry_run
+            }
+
+
+class GraphMemoryClient:
+    """图记忆客户端"""
+    
+    def __init__(self, api_key: str, base_url: str, graph):
+        self.client = OpenAI(api_key=api_key, base_url=base_url)
+        self.graph = graph
+        self.tools = TOOLS
+        
+        # 使用新的提示词管理器
+        prompt_manager = PromptManager()
+        self.system_prompt = prompt_manager.get_system_prompt()
+    
+    def send_message(self, user_input: str, tool_results: list = None, assistant_msg: dict = None) -> dict:
+        """发送消息"""
+        global CURRENT_TURN
+        
+        messages = [{"role": "system", "content": self.system_prompt}]
+        
+        if assistant_msg:
+            messages.append(assistant_msg)
+        
+        if tool_results:
+            messages.extend(tool_results)
+        
+        messages.append({"role": "user", "content": user_input})
+        
+        response = self.client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=messages,
+            tools=self.tools,
+            tool_choice="auto"
+        )
+        
+        return response
+
+    def send_message_stream(self, user_input: str, tool_results: list = None, assistant_msg: dict = None):
+        """流式发送消息"""
+        global CURRENT_TURN
+
+        messages = [{"role": "system", "content": self.system_prompt}]
+
+        if assistant_msg:
+            messages.append(assistant_msg)
+
+        if tool_results:
+            messages.extend(tool_results)
+
+        messages.append({"role": "user", "content": user_input})
+
+        stream = self.client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=messages,
+            tools=self.tools,
+            tool_choice="auto",
+            stream=True
+        )
+
+        return stream

graph_memory_tui/core/imports.py

@@ -31,14 +31,14 @@ if USE_EMBEDDED_DB:
 else:
     # 使用Neo4j数据库
     try:
-        from graph_memory_demo import Neo4jGraph
+        from .graph_client import Neo4jGraph
         print("[INFO] Using Neo4j database")
     except ImportError:
         from .embedded_db import EmbeddedGraphDB as Neo4jGraph
         print("[INFO] Fallback to embedded SQLite database")
 
 # 导入其他组件
-from graph_memory_demo import (
+from .graph_client import (
     GraphMemoryClient,
     TOOLS,
     execute_tool,

graph_memory_tui/core/prompts/__init__.py

@@ -0,0 +1,6 @@
+"""
+提示词管理模块
+"""
+from .prompt_manager import PromptManager
+
+__all__ = ["PromptManager"]

graph_memory_tui/core/prompts/prompt_manager.py

@@ -0,0 +1,64 @@
+"""
+提示词管理器
+"""
+from pathlib import Path
+
+
+class PromptManager:
+    """提示词管理器"""
+    
+    def __init__(self):
+        self.prompts_dir = Path(__file__).parent / "templates"
+    
+    def get_system_prompt(self) -> str:
+        """获取系统提示词"""
+        prompt_file = self.prompts_dir / "system_prompt.md"
+        if prompt_file.exists():
+            with open(prompt_file, "r", encoding="utf-8") as f:
+                return f.read()
+        else:
+            return self._build_default_prompt()
+    
+    def _build_default_prompt(self) -> str:
+        """构建默认提示词（精简版）"""
+        return """你是TrulyMEM，一个拥有长期记忆能力的AI助手。
+
+## 核心能力
+
+1. **长期记忆** - 基于图数据库存储实体关系
+2. **人设管理** - 支持角色扮演和性格设定
+3. **任务跟踪** - 维护工作记忆链，跟踪连续性任务
+
+## 记忆原则
+
+- **明确内容必须写入** - 用户明确提到的信息必须存储
+- **推理内容必须标注** - AI推理得到的内容标注[猜测]
+- **图数据库是唯一记忆源** - 没有其他记忆方式
+
+## 工具使用
+
+### 记忆工具
+- `memory_recall` - 检索记忆
+- `memory_commit` - 写入记忆
+- `memory_purge` - 删除记忆
+- `memory_introspect` - 查看状态
+
+### 人设工具
+- `persona_update` - 更新人设
+- `persona_clear` - 清除人设
+
+### 任务工具
+- `task_create` - 创建任务
+- `task_set_state` - 设置状态
+- `task_delete` - 删除任务
+- `task_link_info` - 关联信息
+
+## 自主性
+
+你有权根据对话上下文自主决定：
+- 是否需要查询记忆
+- 是否需要写入记忆
+- 是否需要维护任务链
+- 如何使用工具
+
+记住：灵活应对，保持自然对话体验。"""

graph_memory_tui/core/prompts/templates/system_prompt.md

@@ -0,0 +1,232 @@
+# TrulyMEM 系统提示词
+
+你是TrulyMEM，一个拥有长期记忆能力的AI助手。
+
+## ⚠️ 关键约束：无传统上下文系统
+
+**重要**: 你没有传统的对话上下文系统（没有消息历史数组）。
+
+- ❌ **没有** messages数组存储历史对话
+- ❌ **没有** 传统的多轮对话上下文
+- ✅ **只有** 图数据库作为唯一记忆载体
+- ✅ **必须** 通过工作记忆链维持对话连贯性
+
+## 核心身份
+
+- **名称**: TrulyMEM (TrueHumanMEM)
+- **能力**: 基于图数据库的长期记忆
+- **理念**: 让AI的记忆方式更像人类
+
+## 核心能力
+
+### 1. 长期记忆
+- 图数据库存储实体关系
+- 支持时间范围查询
+- 支持会话过滤
+
+### 2. 人设管理（关键）
+- 角色扮演支持
+- 性格、语气设定
+- 动态切换人设
+- **每轮必须查询人设图**
+
+### 3. 任务跟踪（关键）
+- 工作记忆链 - **维持对话连贯性的唯一机制**
+- 任务状态管理
+- 上下文恢复
+
+## 记忆原则
+
+### 必须写入的情况
+- 用户明确表达偏好："我喜欢X"
+- 用户分享信息："我在做X项目"
+- 用户制定计划："我打算X"
+- 用户描述状态："我现在在X"
+
+### 禁止写入的情况
+- AI推断的用户偏好
+- AI猜测的用户意图
+- AI推导的结论
+
+### 标注规则
+- 推理内容必须标注 **[猜测]**
+- 明确内容直接陈述
+
+## 工具系统
+
+### 记忆工具
+| 工具 | 功能 | 使用场景 |
+|------|------|---------|
+| `memory_recall` | 检索记忆 | 查询历史信息 |
+| `memory_commit` | 写入记忆 | 存储重要信息 |
+| `memory_purge` | 删除记忆 | 修正错误信息 |
+| `memory_introspect` | 查看状态 | 监控记忆系统 |
+
+### 人设工具
+| 工具 | 功能 | 使用场景 |
+|------|------|---------|
+| `persona_update` | 更新人设 | 设置角色属性 |
+| `persona_clear` | 清除人设 | 恢复默认身份 |
+
+### 任务工具
+| 工具 | 功能 | 使用场景 |
+|------|------|---------|
+| `task_create` | 创建任务 | 开始连续性任务 |
+| `task_set_state` | 设置状态 | 更新任务状态 |
+| `task_delete` | 删除任务 | 清理完成任务 |
+| `task_link_info` | 关联信息 | 连接任务与记忆 |
+
+## 每轮对话强制要求
+
+### ⚠️ 执行顺序（每轮必须）
+
+由于没有传统上下文系统，必须通过图数据库维持对话连贯性。
+
+#### 步骤1: 查询人设图（最高优先级）
+```
+必须调用: memory_recall
+参数: {
+  "query_intent": "AI,人设,角色,性格,语气,说话风格",
+  "depth": 2
+}
+```
+**目的**: 获取当前人设，确保角色一致性。
+**处理**: 
+- 找到人设 → 严格按照人设回复
+- 未找到 → 使用默认TrulyMEM身份
+
+#### 步骤2: 查询工作记忆链
+```
+必须调用: memory_recall
+参数: {
+  "query_intent": "TaskNode,工作记忆,任务链",
+  "depth": 2
+}
+```
+**目的**: 获取之前的任务上下文，了解对话历史。
+
+#### 步骤3: 处理对话
+- 理解用户意图
+- 根据人设和工作记忆链生成回复
+- 执行其他必要的记忆操作
+
+#### 步骤4: 更新工作记忆链
+```
+必须调用: task_create
+参数: {
+  "task_id": "Task_当前轮次ID",
+  "description": "本轮对话概述",
+  "info_nodes": ["相关记忆节点"]
+}
+```
+**目的**: 记录本轮对话，维持时间链。
+
+---
+
+## 人设图机制
+
+### 强制查询
+每轮对话开始时**必须**查询人设图，确保角色一致性。
+
+### 人设优先级
+- 人设优先级 > 默认身份
+- 每句话都符合人设的语气、风格、特征
+- 绝不主动跳出角色，除非用户明确要求
+
+### 人设更新
+用户要求角色扮演时：
+1. 使用 `persona_update` 更新人设
+2. 立即按照新人设回复
+
+### 人设清除
+用户要求恢复默认身份时：
+1. 使用 `persona_clear` 清除人设
+2. 恢复为TrulyMEM默认身份
+
+---
+
+## 工作记忆链机制
+
+#### 强制查询场景：
+
+以下情况**必须**查询工作记忆链：
+
+1. **用户提到"刚才"、"之前"、"上次"**
+   - 例: "刚才我们聊了什么？"
+   - 例: "继续刚才的话题"
+
+2. **用户询问对话历史**
+   - 例: "我们之前说了什么？"
+   - 例: "我们聊过X吗？"
+
+3. **连续性任务被打断后恢复**
+   - 例: 用户突然回到之前的话题
+   - 例: 用户要求继续之前的任务
+
+4. **涉及上下文的引用**
+   - 例: "那个东西"（需要查询上下文）
+   - 例: "继续"（需要查询当前任务）
+
+### 节点类型
+- **TaskNode** - 任务节点，存储任务概述
+- **StateNode** - 状态节点，存储任务状态
+- **InfoNode** - 信息节点，存储具体信息
+
+### 边类型
+- **NEXT_TASK** - 时间链，连接任务节点
+- **HAS_STATE** - 状态，任务指向状态
+- **CONTAINS_INFO** - 信息，任务指向信息节点
+
+### 任务状态
+- 进行中
+- 已完成
+- 已暂停
+- 已取消
+
+## 自主性原则（在强制要求之外）
+
+除了工作记忆链的强制要求外，你有权自主决定：
+
+1. **是否查询其他记忆**
+   - 用户询问历史 → 查询
+   - 涉及之前内容 → 查询
+   - 不确定时 → 可查询
+
+2. **是否写入其他记忆**
+   - 用户明确提到 → 必须写入
+   - AI推理得到 → 可以写入，但是对应边上必须标注[推测]
+
+3. **如何使用其他工具**
+   - 根据上下文灵活选择
+   - 避免过度使用
+   - 保持自然对话
+
+**注意**: 工作记忆链的强制要求不受自主性影响。
+
+## 对话风格
+
+- 自然、流畅
+- 避免机械式工具调用
+- 优先理解用户意图
+- 适时使用记忆增强体验
+
+---
+
+## ⚠️ 执行检查清单
+
+每轮对话必须检查：
+
+- [ ] 步骤1: 是否查询了人设图？
+- [ ] 步骤2: 是否查询了工作记忆链？
+- [ ] 步骤3: 是否根据人设和工作记忆链生成回复？
+- [ ] 步骤4: 是否更新了工作记忆链？
+- [ ] 涉及上下文引用时是否查询了工作记忆链？
+- [ ] 用户提到"刚才/之前/上次"时是否查询了工作记忆链？
+
+---
+
+**记住**: 
+1. 图数据库是你记忆的唯一载体
+2. 人设图确保角色一致性（最高优先级）
+3. 工作记忆链维持对话连贯性
+4. 每轮必须按顺序执行：查询人设图 → 查询工作记忆链 → 处理对话 → 更新工作记忆链

graph_memory_tui/core/tools/__init__.py

@@ -0,0 +1,7 @@
+"""
+工具定义模块
+"""
+from .memory_tools import TOOLS
+from .tool_executor import execute_tool
+
+__all__ = ["TOOLS", "execute_tool"]

graph_memory_tui/core/tools/memory_tools.py

@@ -0,0 +1,323 @@
+"""
+记忆工具定义 - 优化版
+精简描述，避免过拟合，保留AI自主性
+"""
+
+# 基础记忆工具
+MEMORY_TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "memory_recall",
+            "description": "检索记忆。支持关键词、时间范围、会话过滤。返回相关实体和关系。",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query_intent": {
+                        "type": "string",
+                        "description": "查询意图，支持逗号分隔多个关键词"
+                    },
+                    "seed_entities": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "种子实体（可选）"
+                    },
+                    "depth": {
+                        "type": "integer",
+                        "description": "遍历深度，默认2"
+                    },
+                    "time_range": {
+                        "type": "object",
+                        "description": "时间范围（可选）",
+                        "properties": {
+                            "days": {"type": "integer", "description": "最近N天"}
+                        }
+                    },
+                    "session_filter": {
+                        "type": "string",
+                        "description": "会话ID过滤（可选）"
+                    }
+                },
+                "required": ["query_intent"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "memory_commit",
+            "description": "写入记忆。将三元组写入图数据库，支持批量写入。",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "triplets": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "subject": {"type": "string"},
+                                "relation": {"type": "string"},
+                                "object": {"type": "string"},
+                                "confidence": {"type": "number"}
+                            },
+                            "required": ["subject", "relation", "object"]
+                        },
+                        "description": "三元组列表"
+                    },
+                    "entity_types": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "实体类型（可选）"
+                    },
+                    "temporal_tag": {
+                        "type": "string",
+                        "description": "时间标记（可选）"
+                    }
+                },
+                "required": ["triplets"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "memory_purge",
+            "description": "删除记忆。支持条件删除和纠错替代。",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "criteria": {
+                        "type": "object",
+                        "properties": {
+                            "subject_contains": {"type": "string"},
+                            "relation_type": {"type": "string"},
+                            "target_contains": {"type": "string"},
+                            "time_before": {"type": "string"},
+                            "session_id": {"type": "string"}
+                        },
+                        "description": "删除条件"
+                    },
+                    "mode": {
+                        "type": "string",
+                        "enum": ["soft", "supersede"],
+                        "description": "删除模式：soft=逻辑删除, supersede=纠错替代",
+                        "default": "soft"
+                    },
+                    "new_relation": {
+                        "type": "object",
+                        "description": "新关系（supersede模式）",
+                        "properties": {
+                            "relation": {"type": "string"},
+                            "target": {"type": "string"}
+                        }
+                    }
+                },
+                "required": ["criteria"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "memory_introspect",
+            "description": "查看记忆状态。返回会话统计、实体热点、关系分布。",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "session_id": {
+                        "type": "string",
+                        "description": "会话ID（可选）"
+                    }
+                },
+                "required": []
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "memory_archive",
+            "description": "归档旧记忆。将N天前的非活跃关系标记为归档状态。",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "days": {
+                        "type": "integer",
+                        "description": "归档天数，默认30"
+                    }
+                },
+                "required": []
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "memory_cleanup",
+            "description": "清理无效数据。物理删除已删除状态超过90天的关系和孤立节点。",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "dry_run": {
+                        "type": "boolean",
+                        "description": "仅预览不删除",
+                        "default": True
+                    }
+                },
+                "required": []
+            }
+        }
+    }
+]
+
+# 人设图管理工具
+PERSONA_TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "persona_update",
+            "description": "更新人设。修改AI的角色、性格、语气等属性。",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "attributes": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "attribute": {"type": "string", "description": "属性名（如：扮演角色、说话风格、性格特点）"},
+                                "value": {"type": "string", "description": "属性值"}
+                            },
+                            "required": ["attribute", "value"]
+                        },
+                        "description": "人设属性列表"
+                    },
+                    "mode": {
+                        "type": "string",
+                        "enum": ["replace", "merge"],
+                        "description": "更新模式：replace=替换, merge=合并",
+                        "default": "merge"
+                    }
+                },
+                "required": ["attributes"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "persona_clear",
+            "description": "清除人设。删除AI的角色设定，恢复默认身份。",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "confirm": {
+                        "type": "boolean",
+                        "description": "确认清除",
+                        "default": True
+                    }
+                },
+                "required": []
+            }
+        }
+    }
+]
+
+# 工作记忆链管理工具
+WORKING_MEMORY_TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "task_create",
+            "description": "创建任务节点。用于跟踪连续性任务。",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "task_id": {
+                        "type": "string",
+                        "description": "任务ID（如：Task_001）"
+                    },
+                    "description": {
+                        "type": "string",
+                        "description": "任务概述"
+                    },
+                    "info_nodes": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "关联的信息节点名称（可选）"
+                    }
+                },
+                "required": ["task_id", "description"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "task_set_state",
+            "description": "设置任务状态。支持：进行中、已完成、已暂停、已取消。",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "task_id": {
+                        "type": "string",
+                        "description": "任务ID"
+                    },
+                    "state": {
+                        "type": "string",
+                        "enum": ["进行中", "已完成", "已暂停", "已取消"],
+                        "description": "任务状态"
+                    }
+                },
+                "required": ["task_id", "state"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "task_delete",
+            "description": "删除任务节点。同时删除关联的信息节点。",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "task_id": {
+                        "type": "string",
+                        "description": "任务ID"
+                    },
+                    "delete_info_nodes": {
+                        "type": "boolean",
+                        "description": "是否删除关联的信息节点",
+                        "default": True
+                    }
+                },
+                "required": ["task_id"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "task_link_info",
+            "description": "关联信息节点。将记忆节点关联到任务节点。",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "task_id": {
+                        "type": "string",
+                        "description": "任务ID"
+                    },
+                    "info_node_names": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "信息节点名称列表"
+                    }
+                },
+                "required": ["task_id", "info_node_names"]
+            }
+        }
+    }
+]
+
+# 所有工具
+TOOLS = MEMORY_TOOLS + PERSONA_TOOLS + WORKING_MEMORY_TOOLS

graph_memory_tui/core/tools/tool_executor.py

@@ -0,0 +1,307 @@
+"""
+工具执行器
+"""
+import json
+from typing import Any, Dict
+
+
+def execute_tool(graph: Any, tool_name: str, arguments: dict) -> str:
+    """执行工具调用"""
+    print(f"\n[工具调用] {tool_name}")
+    print(f"[参数] {json.dumps(arguments, ensure_ascii=False, indent=2)}")
+    
+    try:
+        # 基础记忆工具
+        if tool_name == "memory_recall":
+            result = graph.recall(
+                query_intent=arguments.get("query_intent", ""),
+                seed_entities=arguments.get("seed_entities"),
+                depth=arguments.get("depth", 2),
+                time_range=arguments.get("time_range"),
+                session_filter=arguments.get("session_filter")
+            )
+            return format_recall_result(result)
+        
+        elif tool_name == "memory_commit":
+            result = graph.commit(
+                triplets=arguments.get("triplets", []),
+                entity_types=arguments.get("entity_types"),
+                temporal_tag=arguments.get("temporal_tag")
+            )
+            return json.dumps(result, ensure_ascii=False, default=str)
+        
+        elif tool_name == "memory_purge":
+            result = graph.purge(
+                criteria=arguments.get("criteria", {}),
+                mode=arguments.get("mode", "soft"),
+                new_relation=arguments.get("new_relation")
+            )
+            return json.dumps(result, ensure_ascii=False, default=str)
+        
+        elif tool_name == "memory_introspect":
+            result = graph.introspect(session_id=arguments.get("session_id"))
+            return json.dumps(result, ensure_ascii=False, default=str)
+        
+        elif tool_name == "memory_archive":
+            result = graph.archive(days=arguments.get("days", 30))
+            return json.dumps(result, ensure_ascii=False, default=str)
+        
+        elif tool_name == "memory_cleanup":
+            result = graph.cleanup(dry_run=arguments.get("dry_run", True))
+            return json.dumps(result, ensure_ascii=False, default=str)
+        
+        # 人设图管理工具
+        elif tool_name == "persona_update":
+            result = execute_persona_update(graph, arguments)
+            return json.dumps(result, ensure_ascii=False, default=str)
+        
+        elif tool_name == "persona_clear":
+            result = execute_persona_clear(graph, arguments)
+            return json.dumps(result, ensure_ascii=False, default=str)
+        
+        # 工作记忆链管理工具
+        elif tool_name == "task_create":
+            result = execute_task_create(graph, arguments)
+            return json.dumps(result, ensure_ascii=False, default=str)
+        
+        elif tool_name == "task_set_state":
+            result = execute_task_set_state(graph, arguments)
+            return json.dumps(result, ensure_ascii=False, default=str)
+        
+        elif tool_name == "task_delete":
+            result = execute_task_delete(graph, arguments)
+            return json.dumps(result, ensure_ascii=False, default=str)
+        
+        elif tool_name == "task_link_info":
+            result = execute_task_link_info(graph, arguments)
+            return json.dumps(result, ensure_ascii=False, default=str)
+        
+        return f"未知工具: {tool_name}"
+    
+    except Exception as e:
+        return f"工具执行错误: {str(e)}"
+
+
+def format_recall_result(result: dict) -> str:
+    """格式化检索结果"""
+    lines = ["===== 记忆检索结果 ====="]
+    
+    if result.get("entities"):
+        lines.append(f"\n实体 ({len(result['entities'])} 个):")
+        for e in result["entities"]:
+            if e and isinstance(e, dict):
+                lines.append(f"  - {e.get('name', 'N/A')} (类型: {e.get('type', 'unknown')}, 提及: {e.get('mention_count', 1)}次)")
+    
+    if result.get("relations"):
+        lines.append(f"\n关系 ({len(result['relations'])} 条):")
+        for r in result["relations"]:
+            if r and isinstance(r, dict):
+                lines.append(f"  - {r.get('source', 'N/A')} --[{r.get('type', 'N/A')}]--> {r.get('target', 'N/A')}")
+                created = r.get("created_at", "N/A")
+                if created and created != "N/A":
+                    created = created[:19] if "T" in str(created) else str(created)
+                session_id = r.get('session_id', 'N/A')
+                session_display = session_id[:20] if session_id and session_id != 'N/A' else 'N/A'
+                lines.append(f"    时间: {created}, 会话: {session_display}, 轮次: {r.get('turn_id', 0)}, 置信度: {r.get('confidence', 1.0)}")
+    
+    if not result.get("entities") and not result.get("relations"):
+        lines.append("\n(未找到相关记忆)")
+    
+    lines.append("=" * 30)
+    return "\n".join(lines)
+
+
+# 人设图管理工具实现
+def execute_persona_update(graph: Any, arguments: dict) -> dict:
+    """更新人设"""
+    attributes = arguments.get("attributes", [])
+    mode = arguments.get("mode", "merge")
+    
+    if mode == "replace":
+        # 先清除旧人设
+        graph.purge(
+            criteria={"subject_contains": "AI", "relation_type": "扮演角色"},
+            mode="soft"
+        )
+        graph.purge(
+            criteria={"subject_contains": "AI", "relation_type": "说话风格"},
+            mode="soft"
+        )
+        graph.purge(
+            criteria={"subject_contains": "AI", "relation_type": "性格特点"},
+            mode="soft"
+        )
+    
+    # 写入新人设
+    triplets = []
+    for attr in attributes:
+        triplets.append({
+            "subject": "AI",
+            "relation": attr["attribute"],
+            "object": attr["value"],
+            "confidence": 1.0
+        })
+    
+    result = graph.commit(triplets=triplets)
+    return {
+        "status": "success",
+        "mode": mode,
+        "updated_attributes": len(attributes),
+        "details": result
+    }
+
+
+def execute_persona_clear(graph: Any, arguments: dict) -> dict:
+    """清除人设"""
+    if not arguments.get("confirm", True):
+        return {"status": "cancelled", "message": "需要确认才能清除人设"}
+    
+    # 删除所有人设相关关系
+    result1 = graph.purge(
+        criteria={"subject_contains": "AI", "relation_type": "扮演角色"},
+        mode="soft"
+    )
+    result2 = graph.purge(
+        criteria={"subject_contains": "AI", "relation_type": "说话风格"},
+        mode="soft"
+    )
+    result3 = graph.purge(
+        criteria={"subject_contains": "AI", "relation_type": "性格特点"},
+        mode="soft"
+    )
+    result4 = graph.purge(
+        criteria={"subject_contains": "AI", "relation_type": "语气特征"},
+        mode="soft"
+    )
+    
+    total_deleted = (
+        result1.get("deleted_count", 0) +
+        result2.get("deleted_count", 0) +
+        result3.get("deleted_count", 0) +
+        result4.get("deleted_count", 0)
+    )
+    
+    return {
+        "status": "success",
+        "deleted_count": total_deleted,
+        "message": "人设已清除，恢复默认身份"
+    }
+
+
+# 工作记忆链管理工具实现
+def execute_task_create(graph: Any, arguments: dict) -> dict:
+    """创建任务节点"""
+    task_id = arguments.get("task_id")
+    description = arguments.get("description")
+    info_nodes = arguments.get("info_nodes", [])
+    
+    # 创建任务节点
+    triplets = [
+        {"subject": task_id, "relation": "is_type", "object": "TaskNode"},
+        {"subject": task_id, "relation": "has_description", "object": description},
+        {"subject": task_id, "relation": "HAS_STATE", "object": "State_进行中"}
+    ]
+    
+    result = graph.commit(triplets=triplets)
+    
+    # 关联信息节点
+    if info_nodes:
+        link_triplets = []
+        for node_name in info_nodes:
+            link_triplets.append({
+                "subject": task_id,
+                "relation": "CONTAINS_INFO",
+                "object": node_name
+            })
+        graph.commit(triplets=link_triplets)
+    
+    return {
+        "status": "success",
+        "task_id": task_id,
+        "description": description,
+        "info_nodes": info_nodes,
+        "details": result
+    }
+
+
+def execute_task_set_state(graph: Any, arguments: dict) -> dict:
+    """设置任务状态"""
+    task_id = arguments.get("task_id")
+    state = arguments.get("state")
+    
+    # 删除旧状态
+    graph.purge(
+        criteria={"subject_contains": task_id, "relation_type": "HAS_STATE"},
+        mode="soft"
+    )
+    
+    # 设置新状态
+    state_node = f"State_{state}"
+    result = graph.commit(
+        triplets=[{"subject": task_id, "relation": "HAS_STATE", "object": state_node}]
+    )
+    
+    return {
+        "status": "success",
+        "task_id": task_id,
+        "new_state": state,
+        "details": result
+    }
+
+
+def execute_task_delete(graph: Any, arguments: dict) -> dict:
+    """删除任务节点"""
+    task_id = arguments.get("task_id")
+    delete_info_nodes = arguments.get("delete_info_nodes", True)
+    
+    # 查询关联的信息节点
+    if delete_info_nodes:
+        recall_result = graph.recall(
+            query_intent=f"{task_id},CONTAINS_INFO",
+            depth=1
+        )
+        
+        # 删除信息节点
+        for relation in recall_result.get("relations", []):
+            if relation.get("type") == "CONTAINS_INFO" and relation.get("source") == task_id:
+                info_node = relation.get("target")
+                graph.purge(
+                    criteria={"subject_contains": info_node},
+                    mode="soft"
+                )
+    
+    # 删除任务节点
+    result = graph.purge(
+        criteria={"subject_contains": task_id},
+        mode="soft"
+    )
+    
+    return {
+        "status": "success",
+        "task_id": task_id,
+        "deleted_info_nodes": delete_info_nodes,
+        "details": result
+    }
+
+
+def execute_task_link_info(graph: Any, arguments: dict) -> dict:
+    """关联信息节点"""
+    task_id = arguments.get("task_id")
+    info_node_names = arguments.get("info_node_names", [])
+    
+    triplets = []
+    for node_name in info_node_names:
+        triplets.append({
+            "subject": task_id,
+            "relation": "CONTAINS_INFO",
+            "object": node_name
+        })
+    
+    result = graph.commit(triplets=triplets)
+    
+    return {
+        "status": "success",
+        "task_id": task_id,
+        "linked_nodes": info_node_names,
+        "details": result
+    }