amrita_plugin_memory 0.1.2__tar.gz → 0.1.4__tar.gz

amrita_plugin_memory-0.1.4/PKG-INFO

@@ -0,0 +1,187 @@
+Metadata-Version: 2.4
+Name: amrita_plugin_memory
+Version: 0.1.4
+Summary: Amrita长期记忆插件
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.13.3
+Requires-Dist: aiologic>=0.16.0
+Requires-Dist: amrita-core>=0.8.5
+Requires-Dist: amrita>=1.3
+Requires-Dist: chromadb>=1.5.8
+Requires-Dist: nonebot-plugin-localstore>=0.7.4
+Dynamic: license-file
+
+# amrita_plugin_memory
+
+Amrita 长期记忆插件 —— 基于 ChromaDB 向量数据库的智能记忆管理系统，让 AI 助手能够持久化地记住关于用户的重要信息。
+
+## 技术栈
+
+| 组件       | 技术                                                    |
+| ---------- | ------------------------------------------------------- |
+| 后端框架   | Python 3.10+ / NoneBot2 / Amrita Core                   |
+| 向量数据库 | ChromaDB（支持本地 PersistentClient 与远程 HttpClient） |
+| 嵌入模型   | OpenAI Embedding API / Ollama Embedding API             |
+| 配置管理   | Pydantic + TOML                                         |
+| 异步处理   | asyncio + aiologic + aiohttp                            |
+| 代码质量   | Ruff + Pyright                                          |
+
+## 架构概览
+
+```
+amrita_plugin_memory/
+├── __init__.py    # 插件入口，注册依赖
+├── config.py      # 配置模型（ConfigFile / EnvConfig / DataManager）
+├── embed.py       # Ollama 嵌入适配器
+├── vector.py      # ChromaDB 异步封装（WrappedClientAPI / AsyncUserMemory）
+└── tools.py       # 工具函数定义与注册（write/read/update/delete/list）
+```
+
+- **config.py**: 定义配置文件（过期天数、记忆上限）和环境变量（数据库类型、嵌入模型地址等），通过 Pydantic 模型校验。
+- **embed.py**: 实现 Ollama 协议的嵌入适配器，通过 HTTP API 调用 `/api/embed` 端点。
+- **vector.py**: 对 ChromaDB 原生 API 进行 `asyncio.to_thread` 封装，提供异步的集合管理与记忆 CRUD。使用 `aiologic.Lock` 按用户粒度加锁，保证并发安全。
+- **tools.py**: 定义 5 个 Function Calling 工具（`write_memory` / `read_memory` / `update_memory` / `delete_memory` / `list_memory`），注册到 Amrita 的工具系统中。通过 `scope` 参数支持群共享记忆与用户专属记忆的分区隔离。
+
+## 功能特点
+
+- **长期记忆存储**：将用户偏好、项目信息等持久化存入 ChromaDB 向量数据库
+- **群/用户记忆隔离**：LLM 可通过 `scope` 参数选择存入群共享记忆（群内所有人可见）或用户专属记忆（仅自己可见）
+- **语义检索**：基于嵌入向量的语义相似度检索，支持中英文关键词
+- **智能标签**：支持使用自定义标签对记忆进行分类（如 `preference`、`project`）
+- **重要性分级**：三级重要程度（`low` / `medium` / `high`），支持按级别过滤检索
+- **完整 CRUD**：支持记忆的创建、查询、更新、删除和列表查看
+- **并发安全**：按用户 ID 粒度加锁，确保同一用户的操作串行化
+- **多租户支持**：通过 ChromaDB remote 模式支持远程向量数据库
+
+## 工具函数
+
+### 1. `write_memory` —— 写入记忆
+
+将当前用户（或群组）的重要信息存入长期记忆。
+
+| 参数         | 类型                            | 必需 | 描述                                                  |
+| ------------ | ------------------------------- | ---- | ----------------------------------------------------- |
+| `content`    | string                          | ✅   | 记忆内容，简洁明了                                    |
+| `tags`       | string                          | ✅   | 分类标签，如 `preference`、`project`                  |
+| `importance` | `"low"` / `"medium"` / `"high"` | ✅   | 重要性等级                                            |
+| `scope`      | `"group"` / `"user"`            | ✅   | `group`=群共享，`user`=个人专属（私聊不可用 `group`） |
+
+### 2. `read_memory` —— 检索记忆
+
+从记忆库中按语义相似度检索用户相关信息。
+
+| 参数         | 类型                            | 必需 | 默认值 | 描述                       |
+| ------------ | ------------------------------- | ---- | ------ | -------------------------- |
+| `query`      | string                          | ✅   | —      | 关键词字符串，空格分隔     |
+| `top_k`      | integer                         | ❌   | `5`    | 返回结果数量               |
+| `importance` | `"low"` / `"medium"` / `"high"` | ❌   | —      | 按重要性过滤               |
+| `scope`      | `"group"` / `"user"`            | ✅   | —      | 检索范围：群共享或个人专属 |
+
+### 3. `update_memory` —— 更新记忆
+
+更新指定 ID 的记忆内容、标签或重要性。
+
+| 参数         | 类型                            | 必需 | 描述            |
+| ------------ | ------------------------------- | ---- | --------------- |
+| `id`         | string                          | ✅   | 要更新的记忆 ID |
+| `scope`      | `"group"` / `"user"`            | ✅   | 记忆所属范围    |
+| `content`    | string                          | ❌   | 新的记忆内容    |
+| `tags`       | string                          | ❌   | 新的标签        |
+| `importance` | `"low"` / `"medium"` / `"high"` | ❌   | 新的重要性等级  |
+
+### 4. `delete_memory` —— 删除记忆
+
+删除指定 ID 的记忆。
+
+| 参数    | 类型                 | 必需 | 描述            |
+| ------- | -------------------- | ---- | --------------- |
+| `id`    | string               | ✅   | 要删除的记忆 ID |
+| `scope` | `"group"` / `"user"` | ✅   | 记忆所属范围    |
+
+### 5. `list_memory` —— 列出记忆
+
+列出当前用户的所有记忆（返回 scope、标签和 ID）。
+
+| 参数    | 类型                 | 必需 | 默认值 | 描述                       |
+| ------- | -------------------- | ---- | ------ | -------------------------- |
+| `limit` | integer              | ❌   | `5`    | 返回数量限制               |
+| `scope` | `"group"` / `"user"` | ✅   | —      | 列出范围：群共享或个人专属 |
+
+## 配置选项
+
+### 文件配置（`config/amrita_plugin_memory/config.toml`）
+
+| 配置项                     | 类型 | 默认值 | 描述                   |
+| -------------------------- | ---- | ------ | ---------------------- |
+| `short_term_expiry_days`   | int  | `3`    | 短期记忆过期天数       |
+| `long_term_expiry_days`    | int  | `30`   | 长期记忆过期天数       |
+| `permanent_expiry_days`    | int  | `365`  | 永久记忆过期天数       |
+| `per_session_memory_limit` | int  | `50`   | 每个会话的记忆数量上限 |
+
+### 环境变量（`.env` 或系统环境变量）
+
+| 变量                       | 类型                      | 默认值                   | 描述                      |
+| -------------------------- | ------------------------- | ------------------------ | ------------------------- |
+| `VECTOR_DB_TYPE`           | `local` / `remote`        | `local`                  | ChromaDB 数据库类型       |
+| `VECTOR_DB_SERVER`         | string                    | `127.0.0.1`              | 远程 ChromaDB 地址        |
+| `VECTOR_DB_PORT`           | int                       | `8000`                   | 远程 ChromaDB 端口        |
+| `VECTOR_DB_SERVER_SSL`     | bool                      | `false`                  | 是否启用 SSL              |
+| `VECTOR_DB_REMOTE_HEADERS` | dict                      | `{}`                     | 远程请求头                |
+| `VECTOR_DB_TENANT`         | string                    | `default`                | 租户名称                  |
+| `VECTOR_DB_DATABASE`       | string                    | `default`                | 数据库名称                |
+| `EMBEDDING_MODEL_URL`      | string                    | `http://127.0.0.1:11434` | 嵌入模型地址              |
+| `EMBEDDING_MODEL_NAME`     | string                    | `auto`                   | 嵌入模型名称              |
+| `EMBEDDING_PROCTOL`        | `openai` / `ollama-embed` | `ollama-embed`           | 嵌入模型协议              |
+| `EMBEDDING_MODEL_API_KEY`  | string                    | (空)                     | 嵌入模型 API 密钥（可选） |
+
+## 安装与使用
+
+### 前置条件
+
+- Python 3.10 ~ 3.13
+- 已部署的 [AmritaBot](https://github.com/AmritaBot) 实例
+- （本地模式）无需额外组件
+- （远程模式）已运行的 ChromaDB 服务端
+- 已运行的嵌入模型服务（如 Ollama）
+
+### 安装
+
+```bash
+ambot plugin install amrita_plugin_memory
+```
+
+### 配置
+
+插件安装后会自动生成配置文件。你可以通过以下方式配置：
+
+1. **WebUI 配置**：在 Amrita 的 Web 管理界面中直接修改
+2. **手动编辑**：修改 `config/amrita_plugin_memory/config.toml`
+3. **环境变量**：通过 `.env` 文件或系统环境变量设置数据库和嵌入模型参数
+
+### 验证
+
+启动后查看日志，确认向量数据库连接成功：
+
+```
+正在尝试向量数据库连接...
+当前向量数据库类型: local
+创建了向量数据库客户端！
+向量数据库版本：x.x.x
+完成。
+```
+
+## 开发
+
+```bash
+# 安装开发依赖
+uv sync
+
+# 代码格式化与检查
+ruff format .
+ruff check .
+
+# 类型检查
+pyright
+```

amrita_plugin_memory-0.1.4/README.md

@@ -0,0 +1,172 @@
+# amrita_plugin_memory
+
+Amrita 长期记忆插件 —— 基于 ChromaDB 向量数据库的智能记忆管理系统，让 AI 助手能够持久化地记住关于用户的重要信息。
+
+## 技术栈
+
+| 组件       | 技术                                                    |
+| ---------- | ------------------------------------------------------- |
+| 后端框架   | Python 3.10+ / NoneBot2 / Amrita Core                   |
+| 向量数据库 | ChromaDB（支持本地 PersistentClient 与远程 HttpClient） |
+| 嵌入模型   | OpenAI Embedding API / Ollama Embedding API             |
+| 配置管理   | Pydantic + TOML                                         |
+| 异步处理   | asyncio + aiologic + aiohttp                            |
+| 代码质量   | Ruff + Pyright                                          |
+
+## 架构概览
+
+```
+amrita_plugin_memory/
+├── __init__.py    # 插件入口，注册依赖
+├── config.py      # 配置模型（ConfigFile / EnvConfig / DataManager）
+├── embed.py       # Ollama 嵌入适配器
+├── vector.py      # ChromaDB 异步封装（WrappedClientAPI / AsyncUserMemory）
+└── tools.py       # 工具函数定义与注册（write/read/update/delete/list）
+```
+
+- **config.py**: 定义配置文件（过期天数、记忆上限）和环境变量（数据库类型、嵌入模型地址等），通过 Pydantic 模型校验。
+- **embed.py**: 实现 Ollama 协议的嵌入适配器，通过 HTTP API 调用 `/api/embed` 端点。
+- **vector.py**: 对 ChromaDB 原生 API 进行 `asyncio.to_thread` 封装，提供异步的集合管理与记忆 CRUD。使用 `aiologic.Lock` 按用户粒度加锁，保证并发安全。
+- **tools.py**: 定义 5 个 Function Calling 工具（`write_memory` / `read_memory` / `update_memory` / `delete_memory` / `list_memory`），注册到 Amrita 的工具系统中。通过 `scope` 参数支持群共享记忆与用户专属记忆的分区隔离。
+
+## 功能特点
+
+- **长期记忆存储**：将用户偏好、项目信息等持久化存入 ChromaDB 向量数据库
+- **群/用户记忆隔离**：LLM 可通过 `scope` 参数选择存入群共享记忆（群内所有人可见）或用户专属记忆（仅自己可见）
+- **语义检索**：基于嵌入向量的语义相似度检索，支持中英文关键词
+- **智能标签**：支持使用自定义标签对记忆进行分类（如 `preference`、`project`）
+- **重要性分级**：三级重要程度（`low` / `medium` / `high`），支持按级别过滤检索
+- **完整 CRUD**：支持记忆的创建、查询、更新、删除和列表查看
+- **并发安全**：按用户 ID 粒度加锁，确保同一用户的操作串行化
+- **多租户支持**：通过 ChromaDB remote 模式支持远程向量数据库
+
+## 工具函数
+
+### 1. `write_memory` —— 写入记忆
+
+将当前用户（或群组）的重要信息存入长期记忆。
+
+| 参数         | 类型                            | 必需 | 描述                                                  |
+| ------------ | ------------------------------- | ---- | ----------------------------------------------------- |
+| `content`    | string                          | ✅   | 记忆内容，简洁明了                                    |
+| `tags`       | string                          | ✅   | 分类标签，如 `preference`、`project`                  |
+| `importance` | `"low"` / `"medium"` / `"high"` | ✅   | 重要性等级                                            |
+| `scope`      | `"group"` / `"user"`            | ✅   | `group`=群共享，`user`=个人专属（私聊不可用 `group`） |
+
+### 2. `read_memory` —— 检索记忆
+
+从记忆库中按语义相似度检索用户相关信息。
+
+| 参数         | 类型                            | 必需 | 默认值 | 描述                       |
+| ------------ | ------------------------------- | ---- | ------ | -------------------------- |
+| `query`      | string                          | ✅   | —      | 关键词字符串，空格分隔     |
+| `top_k`      | integer                         | ❌   | `5`    | 返回结果数量               |
+| `importance` | `"low"` / `"medium"` / `"high"` | ❌   | —      | 按重要性过滤               |
+| `scope`      | `"group"` / `"user"`            | ✅   | —      | 检索范围：群共享或个人专属 |
+
+### 3. `update_memory` —— 更新记忆
+
+更新指定 ID 的记忆内容、标签或重要性。
+
+| 参数         | 类型                            | 必需 | 描述            |
+| ------------ | ------------------------------- | ---- | --------------- |
+| `id`         | string                          | ✅   | 要更新的记忆 ID |
+| `scope`      | `"group"` / `"user"`            | ✅   | 记忆所属范围    |
+| `content`    | string                          | ❌   | 新的记忆内容    |
+| `tags`       | string                          | ❌   | 新的标签        |
+| `importance` | `"low"` / `"medium"` / `"high"` | ❌   | 新的重要性等级  |
+
+### 4. `delete_memory` —— 删除记忆
+
+删除指定 ID 的记忆。
+
+| 参数    | 类型                 | 必需 | 描述            |
+| ------- | -------------------- | ---- | --------------- |
+| `id`    | string               | ✅   | 要删除的记忆 ID |
+| `scope` | `"group"` / `"user"` | ✅   | 记忆所属范围    |
+
+### 5. `list_memory` —— 列出记忆
+
+列出当前用户的所有记忆（返回 scope、标签和 ID）。
+
+| 参数    | 类型                 | 必需 | 默认值 | 描述                       |
+| ------- | -------------------- | ---- | ------ | -------------------------- |
+| `limit` | integer              | ❌   | `5`    | 返回数量限制               |
+| `scope` | `"group"` / `"user"` | ✅   | —      | 列出范围：群共享或个人专属 |
+
+## 配置选项
+
+### 文件配置（`config/amrita_plugin_memory/config.toml`）
+
+| 配置项                     | 类型 | 默认值 | 描述                   |
+| -------------------------- | ---- | ------ | ---------------------- |
+| `short_term_expiry_days`   | int  | `3`    | 短期记忆过期天数       |
+| `long_term_expiry_days`    | int  | `30`   | 长期记忆过期天数       |
+| `permanent_expiry_days`    | int  | `365`  | 永久记忆过期天数       |
+| `per_session_memory_limit` | int  | `50`   | 每个会话的记忆数量上限 |
+
+### 环境变量（`.env` 或系统环境变量）
+
+| 变量                       | 类型                      | 默认值                   | 描述                      |
+| -------------------------- | ------------------------- | ------------------------ | ------------------------- |
+| `VECTOR_DB_TYPE`           | `local` / `remote`        | `local`                  | ChromaDB 数据库类型       |
+| `VECTOR_DB_SERVER`         | string                    | `127.0.0.1`              | 远程 ChromaDB 地址        |
+| `VECTOR_DB_PORT`           | int                       | `8000`                   | 远程 ChromaDB 端口        |
+| `VECTOR_DB_SERVER_SSL`     | bool                      | `false`                  | 是否启用 SSL              |
+| `VECTOR_DB_REMOTE_HEADERS` | dict                      | `{}`                     | 远程请求头                |
+| `VECTOR_DB_TENANT`         | string                    | `default`                | 租户名称                  |
+| `VECTOR_DB_DATABASE`       | string                    | `default`                | 数据库名称                |
+| `EMBEDDING_MODEL_URL`      | string                    | `http://127.0.0.1:11434` | 嵌入模型地址              |
+| `EMBEDDING_MODEL_NAME`     | string                    | `auto`                   | 嵌入模型名称              |
+| `EMBEDDING_PROCTOL`        | `openai` / `ollama-embed` | `ollama-embed`           | 嵌入模型协议              |
+| `EMBEDDING_MODEL_API_KEY`  | string                    | (空)                     | 嵌入模型 API 密钥（可选） |
+
+## 安装与使用
+
+### 前置条件
+
+- Python 3.10 ~ 3.13
+- 已部署的 [AmritaBot](https://github.com/AmritaBot) 实例
+- （本地模式）无需额外组件
+- （远程模式）已运行的 ChromaDB 服务端
+- 已运行的嵌入模型服务（如 Ollama）
+
+### 安装
+
+```bash
+ambot plugin install amrita_plugin_memory
+```
+
+### 配置
+
+插件安装后会自动生成配置文件。你可以通过以下方式配置：
+
+1. **WebUI 配置**：在 Amrita 的 Web 管理界面中直接修改
+2. **手动编辑**：修改 `config/amrita_plugin_memory/config.toml`
+3. **环境变量**：通过 `.env` 文件或系统环境变量设置数据库和嵌入模型参数
+
+### 验证
+
+启动后查看日志，确认向量数据库连接成功：
+
+```
+正在尝试向量数据库连接...
+当前向量数据库类型: local
+创建了向量数据库客户端！
+向量数据库版本：x.x.x
+完成。
+```
+
+## 开发
+
+```bash
+# 安装开发依赖
+uv sync
+
+# 代码格式化与检查
+ruff format .
+ruff check .
+
+# 类型检查
+pyright
+```

amrita_plugin_memory-0.1.4/amrita_plugin_memory/__init__.py

@@ -0,0 +1,8 @@
+from nonebot import require
+
+require("nonebot_plugin_localstore")
+require("amrita.plugins.chat")
+require("amrita.plugins.menu")
+from . import config, embed, matchers, tools, vector
+
+__all__ = ["config", "embed", "matchers", "tools", "vector"]

{amrita_plugin_memory-0.1.2 → amrita_plugin_memory-0.1.4}/amrita_plugin_memory/config.py

@@ -65,6 +65,9 @@ class EnvConfig(BaseModel):
     embedding_proctol: Literal["openai", "ollama-embed"] = Field(
         default="ollama-embed", description="Embedding模型协议"
     )
+    embedding_model_api_key: str = Field(
+        default="", description="Embedding模型API密钥(可选，默认为空)"
+    )
 
 
 class DataManager(BaseDataManager[ConfigFile]):
@@ -79,7 +82,10 @@ async def setup():
 
 def build_preset() -> ModelPreset:
     return ModelPreset(
-        model=env_config.embedding_model_name, base_url=env_config.embedding_model_url
+        model=env_config.embedding_model_name,
+        base_url=env_config.embedding_model_url,
+        api_key=env_config.embedding_model_api_key,
+        protocol=env_config.embedding_proctol,
     )
 
 

amrita_plugin_memory-0.1.4/amrita_plugin_memory/matchers.py

@@ -0,0 +1,170 @@
+"""NoneBot2 命令：/memory"""
+
+from amrita.plugins.menu.models import MatcherData
+from nonebot import on_command
+from nonebot.adapters.onebot.v11 import GroupMessageEvent, Message, MessageEvent
+from nonebot.matcher import Matcher
+from nonebot.params import CommandArg
+
+from .vector import AsyncUserMemory, get_db_conn
+
+memory_cmd = on_command(
+    "memory",
+    aliases={"记忆"},
+    state=MatcherData(
+        name="记忆管理",
+        description="查看/搜索/删除长期记忆",
+        usage="/memory (list|search|delete) [参数]",
+    ).model_dump(),
+)
+
+
+def _label(scope: str) -> str:
+    return "👥群共享" if scope == "group" else "👤个人"
+
+
+@memory_cmd.handle()
+async def _(
+    matcher: Matcher,
+    event: MessageEvent,
+    args: Message = CommandArg(),
+):
+    args_list = args.extract_plain_text().strip().split(maxsplit=1)
+    sub = args_list[0].lower() if args_list else ""
+    rest = args_list[1] if len(args_list) > 1 else ""
+
+    ope = AsyncUserMemory(get_db_conn())
+    await ope.init()
+
+    if isinstance(event, GroupMessageEvent):
+        partitions = [
+            ("group", f"group_{event.group_id}"),
+            ("user", f"user_{event.user_id}"),
+        ]
+        role = event.sender.role if event.sender else "member"
+    else:
+        partitions = [("user", f"user_{event.user_id}")]
+        role = None
+
+    if sub == "" or sub == "list":
+        await _handle_list(matcher, ope, partitions)
+    elif sub == "search":
+        await _handle_search(matcher, ope, partitions, rest)
+    elif sub == "delete":
+        await _handle_delete(matcher, ope, partitions, role, rest)
+    else:
+        await matcher.finish(
+            "用法:\n"
+            "/memory           — 列出记忆\n"
+            "/memory search <关键词> — 搜索记忆\n"
+            "/memory delete <ID>    — 删除记忆"
+        )
+
+
+async def _handle_list(
+    matcher: Matcher,
+    ope: AsyncUserMemory,
+    partitions: list[tuple[str, str]],
+):
+    try:
+        all_lines = ["📋 记忆列表:"]
+        total = 0
+        for scope, pid in partitions:
+            result = await ope.get_all_notes(pid, include=["metadatas", "documents"])
+            if not result or not result.get("ids"):
+                all_lines.append(f"  {_label(scope)}: (无)")
+                continue
+
+            ids = result["ids"]
+            documents = result.get("documents") or [""] * len(ids)
+            metadatas = result.get("metadatas") or [{}] * len(ids)
+            total += len(ids)
+
+            all_lines.append(f"  {_label(scope)} ({len(ids)} 条):")
+            for i, doc_id in enumerate(ids):
+                meta = metadatas[i] if i < len(metadatas) else {}
+                doc = documents[i] if i < len(documents) else ""
+                preview = doc[:50] + "..." if len(doc) > 50 else doc
+                all_lines.append(
+                    f"    [{meta.get('importance', '-')}] {doc_id[:8]}… "
+                    f"{preview} | tag: {meta.get('tags', '-')}"
+                )
+
+        all_lines[0] = f"📋 记忆列表（共 {total} 条）:"
+        await matcher.finish("\n".join(all_lines))
+    except Exception as e:
+        await matcher.finish(f"列出记忆失败: {e}")
+
+
+async def _handle_search(
+    matcher: Matcher,
+    ope: AsyncUserMemory,
+    partitions: list[tuple[str, str]],
+    query: str,
+):
+    if not query:
+        await matcher.finish("请提供搜索关键词，例如: /memory search 喜欢什么")
+
+    try:
+        all_lines = [f"🔍 搜索「{query}」结果:"]
+        has_result = False
+        for scope, pid in partitions:
+            res = await ope.query_notes(pid, query, top_k=5)
+            if not res or not res.get("ids") or not res["ids"]:
+                continue
+
+            flat_ids = res["ids"][0]
+            if not flat_ids:
+                continue
+            has_result = True
+
+            raw_docs = res.get("documents")
+            flat_docs = raw_docs[0] if raw_docs else []
+            raw_metas = res.get("metadatas")
+            flat_metas = raw_metas[0] if raw_metas else []
+            raw_dist = res.get("distances")
+            distances: list[float] = raw_dist[0] if raw_dist else []  # type: ignore[assignment]
+
+            all_lines.append(f"  {_label(scope)}:")
+            for i, doc_id in enumerate(flat_ids):
+                meta = flat_metas[i] if i < len(flat_metas) else {}
+                doc = flat_docs[i] if i < len(flat_docs) else ""
+                dist = distances[i] if i < len(distances) else 0.0
+                preview = doc[:50] + "..." if len(doc) > 50 else doc
+                all_lines.append(
+                    f"    [{meta.get('importance', '-')}] {doc_id[:8]}… "
+                    f"{preview} | tag: {meta.get('tags', '-')} | score: {dist:.3f}"
+                )
+
+        if not has_result:
+            all_lines.append(f"  未找到与「{query}」相关的记忆")
+
+        await matcher.finish("\n".join(all_lines))
+    except Exception as e:
+        await matcher.finish(f"搜索记忆失败: {e}")
+
+
+async def _handle_delete(
+    matcher: Matcher,
+    ope: AsyncUserMemory,
+    partitions: list[tuple[str, str]],
+    role: str | None,
+    doc_id: str,
+):
+    if not doc_id:
+        await matcher.finish("请提供要删除的记忆 ID")
+
+    # 先找到记忆属于哪个分区
+    for scope, pid in partitions:
+        result = await ope.get_all_notes(pid, include=["metadatas"])
+        if doc_id in (result.get("ids") or []):
+            # 群共享记忆只有 admin/owner 能删
+            if scope == "group" and role == "member":
+                await matcher.finish(
+                    f"❌ 无权删除群共享记忆（{_label(scope)}），仅管理员和群主可删除"
+                )
+            await ope.delete_note(pid, doc_id)
+            await matcher.finish(f"✅ 已删除 {_label(scope)} 记忆: {doc_id[:8]}…")
+            return
+
+    await matcher.finish(f"未找到记忆: {doc_id}")

{amrita_plugin_memory-0.1.2 → amrita_plugin_memory-0.1.4}/amrita_plugin_memory/tools.py

@@ -13,6 +13,7 @@ from amrita_core import (
 from chromadb import QueryResult
 from nonebot import logger
 from nonebot.adapters.onebot.v11 import Event as OB11Event
+from nonebot.adapters.onebot.v11 import GroupMessageEvent
 
 from .config import DataManager
 from .vector import AsyncUserMemory, MemoryMetadata, get_db_conn
@@ -30,16 +31,15 @@ def _resolve_scope_id(ctx: ToolContext, scope: str) -> str:
     """根据 scope 返回对应的分区 key
 
     - scope="group": 群共享记忆，返回 f"group_{group_id}"
-    - scope="user":  用户专属记忆，返回 event.get_session_id()
+    - scope="user":  用户专属记忆，返回 f"user_{user_id}"（群聊私聊互通）
     """
-    event = _get_event(ctx)
+    event: OB11Event = _get_event(ctx)
     if scope == "group":
-        group_id: int | None = getattr(event, "group_id", None)
-        if group_id is None:
+        if not isinstance(event, GroupMessageEvent):
             raise ValueError("当前不在群聊中，无法使用群共享记忆")
-        return f"group_{group_id}"
+        return f"group_{event.group_id}"
     elif scope == "user":
-        return event.get_session_id()
+        return f"user_{event.user_id}"  # type: ignore
     else:
         raise ValueError(f"无效的 scope: {scope}")
 
@@ -61,6 +61,14 @@ def _err(message: str) -> str:
     )
 
 
+def _check_required(ctx: ToolContext, tool_name: str, *params: str) -> str | None:
+    """校验必填参数，缺失时返回错误消息；全部通过返回 None"""
+    for p in params:
+        if p not in ctx.data or ctx.data[p] is None:
+            return _err(f"调用 {tool_name} 工具必须带有 {p} 参数")
+    return None
+
+
 #  公共参数：scope
 _SCOPE_PROP = FunctionPropertySchema(
     type="string",
@@ -183,6 +191,10 @@ LIST_MEMORY_FUN = FunctionDefinitionSchema(
 
 @on_tools(WRITE_MEMORY_FUN, custom_run=True, strict=True)
 async def w(ctx: ToolContext) -> str:
+    if err := _check_required(
+        ctx, "write_memory", "content", "tags", "importance", "scope"
+    ):
+        return err
     scope: str = ctx.data["scope"]
     try:
         partition_id = _resolve_scope_id(ctx, scope)
@@ -205,13 +217,15 @@ async def w(ctx: ToolContext) -> str:
         scope=cast(Scope, scope),
     )
     await ope.add_note(partition_id, ctx.data["content"], metadata=meta)
-    dmp = meta.model_dump()
+    dmp = meta.model_dump(mode="json")
     dmp["status"] = "success"
     return json.dumps(dmp, ensure_ascii=False, indent=4)
 
 
 @on_tools(READ_MEMORY_FUN, custom_run=True, strict=True)
 async def r(ctx: ToolContext) -> str:
+    if err := _check_required(ctx, "read_memory", "query", "scope"):
+        return err
     scope: str = ctx.data["scope"]
     try:
         partition_id = _resolve_scope_id(ctx, scope)
@@ -226,7 +240,7 @@ async def r(ctx: ToolContext) -> str:
         res: QueryResult = await ope.query_notes(
             partition_id,
             ctx.data["query"],
-            top_k=ctx.data["top_k"],
+            top_k=ctx.data.get("top_k", 5),
             importance=ctx.data.get("importance"),
         )
         return json.dumps(res, ensure_ascii=False, indent=4)
@@ -237,6 +251,8 @@ async def r(ctx: ToolContext) -> str:
 
 @on_tools(UPDATE_FUN, custom_run=True, strict=True)
 async def update_memory(ctx: ToolContext) -> str:
+    if err := _check_required(ctx, "update_memory", "id", "scope"):
+        return err
     scope: str = ctx.data["scope"]
     try:
         partition_id = _resolve_scope_id(ctx, scope)
@@ -307,6 +323,8 @@ async def update_memory(ctx: ToolContext) -> str:
 
 @on_tools(DELETE_FUN, custom_run=True, strict=True)
 async def delete_memory(ctx: ToolContext) -> str:
+    if err := _check_required(ctx, "delete_memory", "id", "scope"):
+        return err
     scope: str = ctx.data["scope"]
     try:
         partition_id = _resolve_scope_id(ctx, scope)
@@ -337,6 +355,8 @@ async def delete_memory(ctx: ToolContext) -> str:
 
 @on_tools(LIST_MEMORY_FUN, custom_run=True, strict=True)
 async def list_memory(ctx: ToolContext) -> str:
+    if err := _check_required(ctx, "list_memory", "scope"):
+        return err
     scope: str = ctx.data["scope"]
     try:
         partition_id = _resolve_scope_id(ctx, scope)