jarvis-ai-assistant 0.1.222__py3-none-any.whl → 0.7.0__py3-none-any.whl

jarvis/jarvis_tools/retrieve_memory.py

@@ -0,0 +1,227 @@
+# -*- coding: utf-8 -*-
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from jarvis.jarvis_utils.config import get_data_dir, get_max_input_token_count
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.globals import get_short_term_memories
+from jarvis.jarvis_utils.embedding import get_context_token_count
+
+
+class RetrieveMemoryTool:
+    """检索记忆工具，用于从长短期记忆系统中检索信息"""
+
+    name = "retrieve_memory"
+    description = """从长短期记忆系统中检索信息。
+    
+    支持的记忆类型：
+    - project_long_term: 项目长期记忆（与当前项目相关的信息）
+    - global_long_term: 全局长期记忆（通用的信息、用户喜好、知识、方法等）
+    - short_term: 短期记忆（当前任务相关的信息）
+    - all: 从所有类型中检索
+    
+    可以通过标签过滤检索结果，支持多个标签（满足任一标签即可）
+    注意：标签数量建议不要超过10个，以保证检索效率
+    """
+
+    parameters = {
+        "type": "object",
+        "properties": {
+            "memory_types": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "enum": [
+                        "project_long_term",
+                        "global_long_term",
+                        "short_term",
+                        "all",
+                    ],
+                },
+                "description": "要检索的记忆类型列表，如果包含'all'则检索所有类型",
+            },
+            "tags": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "用于过滤的标签列表（可选）",
+            },
+            "limit": {
+                "type": "integer",
+                "description": "返回结果的最大数量（可选，默认返回所有）",
+                "minimum": 1,
+            },
+        },
+        "required": ["memory_types"],
+    }
+
+    def __init__(self):
+        """初始化检索记忆工具"""
+        self.project_memory_dir = Path(".jarvis/memory")
+        self.global_memory_dir = Path(get_data_dir()) / "memory"
+
+    def _get_memory_dir(self, memory_type: str) -> Path:
+        """根据记忆类型获取存储目录"""
+        if memory_type == "project_long_term":
+            return self.project_memory_dir
+        elif memory_type in ["global_long_term", "short_term"]:
+            return self.global_memory_dir / memory_type
+        else:
+            raise ValueError(f"未知的记忆类型: {memory_type}")
+
+    def _retrieve_from_type(
+        self, memory_type: str, tags: Optional[List[str]] = None
+    ) -> List[Dict[str, Any]]:
+        """从指定类型中检索记忆"""
+        memories: List[Dict[str, Any]] = []
+
+        if memory_type == "short_term":
+            # 从全局变量获取短期记忆
+            memories = get_short_term_memories(tags)
+        else:
+            # 从文件系统获取长期记忆
+            memory_dir = self._get_memory_dir(memory_type)
+
+            if not memory_dir.exists():
+                return memories
+
+            # 遍历记忆文件
+            for memory_file in memory_dir.glob("*.json"):
+                try:
+                    with open(memory_file, "r", encoding="utf-8") as f:
+                        memory_data = json.load(f)
+
+                    # 如果指定了标签，检查是否匹配
+                    if tags:
+                        memory_tags = memory_data.get("tags", [])
+                        if not any(tag in memory_tags for tag in tags):
+                            continue
+
+                    memories.append(memory_data)
+                except Exception as e:
+                    PrettyOutput.print(
+                        f"读取记忆文件 {memory_file} 失败: {str(e)}", OutputType.WARNING
+                    )
+
+        return memories
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """执行检索记忆操作"""
+        try:
+            memory_types = args.get("memory_types", [])
+            tags = args.get("tags", [])
+            limit = args.get("limit", None)
+
+            # 确定要检索的记忆类型
+            if "all" in memory_types:
+                types_to_search = [
+                    "project_long_term",
+                    "global_long_term",
+                    "short_term",
+                ]
+            else:
+                types_to_search = memory_types
+
+            # 从各个类型中检索记忆
+            all_memories = []
+            for memory_type in types_to_search:
+                memories = self._retrieve_from_type(memory_type, tags)
+                all_memories.extend(memories)
+
+            # 按创建时间排序（最新的在前）
+            all_memories.sort(key=lambda x: x.get("created_at", ""), reverse=True)
+
+            # 获取最大输入token数的2/3作为记忆的token限制
+            max_input_tokens = get_max_input_token_count()
+            memory_token_limit = int(max_input_tokens * 2 / 3)
+
+            # 基于token限制和条数限制筛选记忆
+            filtered_memories: List[Dict[str, Any]] = []
+            total_tokens = 0
+
+            for memory in all_memories:
+                # 计算当前记忆的token数量
+                memory_content = json.dumps(memory, ensure_ascii=False)
+                memory_tokens = get_context_token_count(memory_content)
+
+                # 检查是否超过token限制
+                if total_tokens + memory_tokens > memory_token_limit:
+
+                    break
+
+                # 检查是否超过50条限制
+                if len(filtered_memories) >= 50:
+
+                    break
+
+                filtered_memories.append(memory)
+                total_tokens += memory_tokens
+
+            all_memories = filtered_memories
+
+            # 如果指定了额外的限制，只返回前N个
+            if limit and len(all_memories) > limit:
+                all_memories = all_memories[:limit]
+
+            # 打印结果摘要
+
+            if tags:
+                pass
+
+            # 格式化为Markdown输出
+            markdown_output = "# 记忆检索结果\n\n"
+            markdown_output += f"**检索到 {len(all_memories)} 条记忆**\n\n"
+
+            if tags:
+                markdown_output += f"**使用标签过滤**: {', '.join(tags)}\n\n"
+
+            markdown_output += f"**记忆类型**: {', '.join(types_to_search)}\n\n"
+
+            markdown_output += "---\n\n"
+
+            # 输出所有记忆
+            for i, memory in enumerate(all_memories):
+                markdown_output += f"## {i+1}. {memory.get('id', '未知ID')}\n\n"
+                markdown_output += f"**类型**: {memory.get('type', '未知类型')}\n\n"
+                markdown_output += f"**标签**: {', '.join(memory.get('tags', []))}\n\n"
+                markdown_output += (
+                    f"**创建时间**: {memory.get('created_at', '未知时间')}\n\n"
+                )
+
+                # 内容部分
+                content = memory.get("content", "")
+                if content:
+                    markdown_output += f"**内容**:\n\n{content}\n\n"
+
+                # 如果有额外的元数据
+                metadata = {
+                    k: v
+                    for k, v in memory.items()
+                    if k not in ["id", "type", "tags", "created_at", "content"]
+                }
+                if metadata:
+                    markdown_output += "**其他信息**:\n"
+                    for key, value in metadata.items():
+                        markdown_output += f"- {key}: {value}\n"
+                    markdown_output += "\n"
+
+                markdown_output += "---\n\n"
+
+            # 如果记忆较多，在终端显示摘要
+            if len(all_memories) > 5:
+                # 静默模式下不再打印摘要，完整结果已包含在返回的markdown_output中
+                for i, memory in enumerate(all_memories[:5]):
+                    content_preview = memory.get("content", "")[:100]
+                    if len(memory.get("content", "")) > 100:
+                        content_preview += "..."
+
+            return {
+                "success": True,
+                "stdout": markdown_output,
+                "stderr": "",
+            }
+
+        except Exception as e:
+            error_msg = f"检索记忆失败: {str(e)}"
+            PrettyOutput.print(error_msg, OutputType.ERROR)
+            return {"success": False, "stdout": "", "stderr": error_msg}

jarvis/jarvis_tools/save_memory.py

@@ -0,0 +1,194 @@
+# -*- coding: utf-8 -*-
+import json
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict
+
+from jarvis.jarvis_utils.config import get_data_dir
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.globals import add_short_term_memory
+
+
+class SaveMemoryTool:
+    """保存记忆工具，用于将信息保存到长短期记忆系统"""
+
+    name = "save_memory"
+    description = """保存信息到长短期记忆系统。
+    
+    支持批量保存多条记忆，可以同时保存不同类型的记忆。
+    
+    支持的记忆类型：
+    - project_long_term: 项目长期记忆（与当前项目相关的信息）
+    - global_long_term: 全局长期记忆（通用的信息、用户喜好、知识、方法等）
+    - short_term: 短期记忆（当前任务相关的信息）
+    
+    项目长期记忆存储在当前目录的 .jarvis/memory 下
+    全局长期记忆和短期记忆存储在数据目录的 memory 子目录下
+    """
+
+    parameters = {
+        "type": "object",
+        "properties": {
+            "memories": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "memory_type": {
+                            "type": "string",
+                            "enum": [
+                                "project_long_term",
+                                "global_long_term",
+                                "short_term",
+                            ],
+                            "description": "记忆类型",
+                        },
+                        "tags": {
+                            "type": "array",
+                            "items": {"type": "string"},
+                            "description": "用于索引记忆的标签列表",
+                        },
+                        "content": {
+                            "type": "string",
+                            "description": "要保存的记忆内容",
+                        },
+                    },
+                    "required": ["memory_type", "tags", "content"],
+                },
+                "description": "要保存的记忆列表",
+            }
+        },
+        "required": ["memories"],
+    }
+
+    def __init__(self):
+        """初始化保存记忆工具"""
+        self.project_memory_dir = Path(".jarvis/memory")
+        self.global_memory_dir = Path(get_data_dir()) / "memory"
+
+    def _get_memory_dir(self, memory_type: str) -> Path:
+        """根据记忆类型获取存储目录"""
+        if memory_type == "project_long_term":
+            return self.project_memory_dir
+        elif memory_type in ["global_long_term", "short_term"]:
+            return self.global_memory_dir / memory_type
+        else:
+            raise ValueError(f"未知的记忆类型: {memory_type}")
+
+    def _generate_memory_id(self) -> str:
+        """生成唯一的记忆ID"""
+        # 添加微秒级时间戳确保唯一性
+        time.sleep(0.001)  # 确保不同记忆有不同的时间戳
+        return datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+
+    def _save_single_memory(self, memory_data: Dict[str, Any]) -> Dict[str, Any]:
+        """保存单条记忆"""
+        memory_type = memory_data["memory_type"]
+        tags = memory_data.get("tags", [])
+        content = memory_data.get("content", "")
+
+        # 生成记忆ID
+        memory_id = self._generate_memory_id()
+
+        # 创建记忆对象
+        memory_obj = {
+            "id": memory_id,
+            "type": memory_type,
+            "tags": tags,
+            "content": content,
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat(),
+        }
+
+        if memory_type == "short_term":
+            # 短期记忆保存到全局变量
+            add_short_term_memory(memory_obj)
+
+            result = {
+                "memory_id": memory_id,
+                "memory_type": memory_type,
+                "tags": tags,
+                "storage": "memory",
+                "message": f"短期记忆已成功保存到内存，ID: {memory_id}",
+            }
+        else:
+            # 长期记忆保存到文件
+            # 获取存储目录并确保存在
+            memory_dir = self._get_memory_dir(memory_type)
+            memory_dir.mkdir(parents=True, exist_ok=True)
+
+            # 保存记忆文件
+            memory_file = memory_dir / f"{memory_id}.json"
+            with open(memory_file, "w", encoding="utf-8") as f:
+                json.dump(memory_obj, f, ensure_ascii=False, indent=2)
+
+            result = {
+                "memory_id": memory_id,
+                "memory_type": memory_type,
+                "tags": tags,
+                "file_path": str(memory_file),
+                "message": f"记忆已成功保存，ID: {memory_id}",
+            }
+
+        return result
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """执行保存记忆操作"""
+        try:
+            memories = args.get("memories", [])
+
+            if not memories:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "没有提供要保存的记忆",
+                }
+
+            results = []
+            success_count = 0
+            failed_count = 0
+
+            # 保存每条记忆
+            for i, memory_data in enumerate(memories):
+                try:
+                    result = self._save_single_memory(memory_data)
+                    results.append(result)
+                    success_count += 1
+
+                    # 打印单条记忆保存信息
+                    memory_data["memory_type"]
+                    memory_data.get("tags", [])
+
+                except Exception as e:
+                    failed_count += 1
+                    error_msg = f"保存第 {i+1} 条记忆失败: {str(e)}"
+                    PrettyOutput.print(error_msg, OutputType.ERROR)
+                    results.append(
+                        {
+                            "error": error_msg,
+                            "memory_type": memory_data.get("memory_type", "unknown"),
+                            "tags": memory_data.get("tags", []),
+                        }
+                    )
+
+            # 生成总结报告
+
+            # 构建返回结果
+            output = {
+                "total": len(memories),
+                "success": success_count,
+                "failed": failed_count,
+                "results": results,
+            }
+
+            return {
+                "success": True,
+                "stdout": json.dumps(output, ensure_ascii=False, indent=2),
+                "stderr": "",
+            }
+
+        except Exception as e:
+            error_msg = f"保存记忆失败: {str(e)}"
+            PrettyOutput.print(error_msg, OutputType.ERROR)
+            return {"success": False, "stdout": "", "stderr": error_msg}

jarvis/jarvis_tools/search_web.py

@@ -1,19 +1,27 @@
 # -*- coding: utf-8 -*-
-"""A tool for searching the web."""
+"""网络搜索工具。"""
 from typing import Any, Dict
 
-import httpx
-from bs4 import BeautifulSoup
-from ddgs import DDGS
+import requests  # type: ignore[import-untyped]
+from markdownify import markdownify as md  # type: ignore
+
+# pylint: disable=import-error,missing-module-docstring
+# fmt: off
+from ddgs import DDGS  # type: ignore[import-not-found]
+# fmt: on
 
 from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_platform.registry import PlatformRegistry
+from jarvis.jarvis_utils.config import (
+    get_web_search_platform_name,
+    get_web_search_model_name,
+)
 from jarvis.jarvis_utils.http import get as http_get
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class SearchWebTool:
-    """A class to handle web searches."""
+    """处理网络搜索的类。"""
 
     name = "search_web"
     description = "搜索互联网上的信息"
@@ -24,10 +32,10 @@ class SearchWebTool:
 
     def _search_with_ddgs(self, query: str, agent: Agent) -> Dict[str, Any]:
         # pylint: disable=too-many-locals, broad-except
-        """Performs a web search, scrapes content, and summarizes the results."""
+        """执行网络搜索、抓取内容并总结结果。"""
         try:
-            PrettyOutput.print("▶️ 使用 DuckDuckGo 开始网页搜索...", OutputType.INFO)
-            results = list(DDGS().text(query, max_results=5))
+
+            results = list(DDGS().text(query, max_results=50, page=3))
 
             if not results:
                 return {
@@ -36,25 +44,32 @@ class SearchWebTool:
                     "success": False,
                 }
 
-            urls = [r["href"] for r in results]
             full_content = ""
             visited_urls = []
+            visited_count = 0
+
+            for r in results:
+                if visited_count >= 10:
+
+                    break
+
+                url = r["href"]
+                r.get("title", url)
 
-            for url in urls:
                 try:
-                    PrettyOutput.print(f"📄 正在抓取内容: {url}", OutputType.INFO)
-                    response = http_get(url, timeout=10.0, follow_redirects=True)
-                    soup = BeautifulSoup(response.text, "lxml")
-                    body = soup.find("body")
-                    if body:
-                        full_content += body.get_text(" ", strip=True) + "\n\n"
+
+                    response = http_get(url, timeout=10.0, allow_redirects=True)
+                    content = md(response.text, strip=["script", "style"])
+                    if content:
+                        full_content += content + "\n\n"
                         visited_urls.append(url)
-                except httpx.HTTPStatusError as e:
+                        visited_count += 1
+                except requests.exceptions.HTTPError as e:
                     PrettyOutput.print(
                         f"⚠️ HTTP错误 {e.response.status_code} 访问 {url}",
                         OutputType.WARNING,
                     )
-                except httpx.RequestError as e:
+                except requests.exceptions.RequestException as e:
                     PrettyOutput.print(f"⚠️ 请求错误: {e}", OutputType.WARNING)
 
             if not full_content.strip():
@@ -64,12 +79,8 @@ class SearchWebTool:
                     "success": False,
                 }
 
-            url_list_str = "\n".join(f"  - {u}" for u in visited_urls)
-            PrettyOutput.print(
-                f"🔍 已成功访问并处理以下URL:\n{url_list_str}", OutputType.INFO
-            )
+            "\n".join(f"  - {u}" for u in visited_urls)
 
-            PrettyOutput.print("🧠 正在总结内容...", OutputType.INFO)
             summary_prompt = f"请为查询“{query}”总结以下内容：\n\n{full_content}"
 
             if not agent.model:
@@ -124,6 +135,27 @@ class SearchWebTool:
                 "success": False,
             }
 
+        # 检查是否配置了专门的 Web 搜索平台和模型
+        web_search_platform = get_web_search_platform_name()
+        web_search_model = get_web_search_model_name()
+
+        # 如果配置了专门的 Web 搜索平台和模型，优先使用
+        if web_search_platform and web_search_model:
+            model = PlatformRegistry().create_platform(web_search_platform)
+            if model:
+                model.set_model_name(web_search_model)
+                if model.support_web():
+                    model.set_web(True)
+                    model.set_suppress_output(False)
+                    response = model.chat_until_success(query)
+                    if response and response.strip():
+                        return {
+                            "stdout": response,
+                            "stderr": "",
+                            "success": True,
+                        }
+
+        # 否则使用现有的模型选择流程
         if agent.model.support_web():
             model = PlatformRegistry().create_platform(agent.model.platform_name())
             if not model:
@@ -131,11 +163,13 @@ class SearchWebTool:
             model.set_model_name(agent.model.name())
             model.set_web(True)
             model.set_suppress_output(False)
-            return {
-                "stdout": model.chat_until_success(query),
-                "stderr": "",
-                "success": True,
-            }
+            response = model.chat_until_success(query)
+            if response and response.strip():
+                return {
+                    "stdout": response,
+                    "stderr": "",
+                    "success": True,
+                }
 
         return self._search_with_ddgs(query, agent)