amrita_plugin_memory 0.1.0__tar.gz → 0.1.1__tar.gz

amrita_plugin_memory-0.1.1/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: amrita_plugin_memory
+Version: 0.1.1
+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 的工具系统中。
+
+## 功能特点
+
+- **长期记忆存储**：将用户偏好、项目信息等持久化存入 ChromaDB 向量数据库
+- **语义检索**：基于嵌入向量的语义相似度检索，支持中英文关键词
+- **智能标签**：支持使用自定义标签对记忆进行分类（如 `preference`、`project`）
+- **重要性分级**：三级重要程度（`low` / `medium` / `high`），支持按级别过滤检索
+- **完整 CRUD**：支持记忆的创建、查询、更新、删除和列表查看
+- **并发安全**：按用户 ID 粒度加锁，确保同一用户的操作串行化
+- **多租户支持**：通过 ChromaDB remote 模式支持远程向量数据库
+
+## 工具函数
+
+### 1. `write_memory` —— 写入记忆
+
+将当前用户（或群组）的重要信息存入长期记忆。
+
+| 参数 | 类型 | 必需 | 描述 |
+|------|------|------|------|
+| `content` | string | ✅ | 记忆内容，简洁明了 |
+| `tags` | string | ✅ | 分类标签，如 `preference`、`project` |
+| `importance` | `"low"` / `"medium"` / `"high"` | ✅ | 重要性等级 |
+
+### 2. `read_memory` —— 检索记忆
+
+从记忆库中按语义相似度检索用户相关信息。
+
+| 参数 | 类型 | 必需 | 默认值 | 描述 |
+|------|------|------|--------|------|
+| `query` | string | ✅ | — | 关键词字符串，空格分隔 |
+| `top_k` | integer | ❌ | `5` | 返回结果数量 |
+| `importance` | `"low"` / `"medium"` / `"high"` | ❌ | — | 按重要性过滤 |
+
+### 3. `update_memory` —— 更新记忆
+
+更新指定 ID 的记忆内容、标签或重要性。
+
+| 参数 | 类型 | 必需 | 描述 |
+|------|------|------|------|
+| `id` | string | ✅ | 要更新的记忆 ID |
+| `content` | string | ❌ | 新的记忆内容 |
+| `tags` | string | ❌ | 新的标签 |
+| `importance` | `"low"` / `"medium"` / `"high"` | ❌ | 新的重要性等级 |
+
+### 4. `delete_memory` —— 删除记忆
+
+删除指定 ID 的记忆。
+
+| 参数 | 类型 | 必需 | 描述 |
+|------|------|------|------|
+| `id` | string | ✅ | 要删除的记忆 ID |
+
+### 5. `list_memory` —— 列出记忆
+
+列出当前用户的所有记忆（返回标签和 ID）。
+
+| 参数 | 类型 | 必需 | 默认值 | 描述 |
+|------|------|------|--------|------|
+| `limit` | integer | ❌ | `5` | 返回数量限制 |
+
+## 配置选项
+
+### 文件配置（`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` | 嵌入模型协议 |
+
+## 安装与使用
+
+### 前置条件
+
+- 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.1/README.md

@@ -0,0 +1,166 @@
+# 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 的工具系统中。
+
+## 功能特点
+
+- **长期记忆存储**：将用户偏好、项目信息等持久化存入 ChromaDB 向量数据库
+- **语义检索**：基于嵌入向量的语义相似度检索，支持中英文关键词
+- **智能标签**：支持使用自定义标签对记忆进行分类（如 `preference`、`project`）
+- **重要性分级**：三级重要程度（`low` / `medium` / `high`），支持按级别过滤检索
+- **完整 CRUD**：支持记忆的创建、查询、更新、删除和列表查看
+- **并发安全**：按用户 ID 粒度加锁，确保同一用户的操作串行化
+- **多租户支持**：通过 ChromaDB remote 模式支持远程向量数据库
+
+## 工具函数
+
+### 1. `write_memory` —— 写入记忆
+
+将当前用户（或群组）的重要信息存入长期记忆。
+
+| 参数 | 类型 | 必需 | 描述 |
+|------|------|------|------|
+| `content` | string | ✅ | 记忆内容，简洁明了 |
+| `tags` | string | ✅ | 分类标签，如 `preference`、`project` |
+| `importance` | `"low"` / `"medium"` / `"high"` | ✅ | 重要性等级 |
+
+### 2. `read_memory` —— 检索记忆
+
+从记忆库中按语义相似度检索用户相关信息。
+
+| 参数 | 类型 | 必需 | 默认值 | 描述 |
+|------|------|------|--------|------|
+| `query` | string | ✅ | — | 关键词字符串，空格分隔 |
+| `top_k` | integer | ❌ | `5` | 返回结果数量 |
+| `importance` | `"low"` / `"medium"` / `"high"` | ❌ | — | 按重要性过滤 |
+
+### 3. `update_memory` —— 更新记忆
+
+更新指定 ID 的记忆内容、标签或重要性。
+
+| 参数 | 类型 | 必需 | 描述 |
+|------|------|------|------|
+| `id` | string | ✅ | 要更新的记忆 ID |
+| `content` | string | ❌ | 新的记忆内容 |
+| `tags` | string | ❌ | 新的标签 |
+| `importance` | `"low"` / `"medium"` / `"high"` | ❌ | 新的重要性等级 |
+
+### 4. `delete_memory` —— 删除记忆
+
+删除指定 ID 的记忆。
+
+| 参数 | 类型 | 必需 | 描述 |
+|------|------|------|------|
+| `id` | string | ✅ | 要删除的记忆 ID |
+
+### 5. `list_memory` —— 列出记忆
+
+列出当前用户的所有记忆（返回标签和 ID）。
+
+| 参数 | 类型 | 必需 | 默认值 | 描述 |
+|------|------|------|--------|------|
+| `limit` | integer | ❌ | `5` | 返回数量限制 |
+
+## 配置选项
+
+### 文件配置（`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` | 嵌入模型协议 |
+
+## 安装与使用
+
+### 前置条件
+
+- 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.0 → amrita_plugin_memory-0.1.1}/amrita_plugin_memory/config.py

@@ -14,6 +14,8 @@ PLUGIN_IM = "amrita_plugin_memory"
 
 
 class ConfigFile(BaseModel):
+    """配置文件"""
+
     short_term_expiry_days: int = Field(
         default=3, description="短期记忆的过期天数，默认为3天"
     )
@@ -60,12 +62,13 @@ class EnvConfig(BaseModel):
         default="http://127.0.0.1:11434", description="Embedding模型地址"
     )
     embedding_model_name: str = Field(default="auto", description="Embedding模型名称")
-    embedding_proctol: Literal["openai-embed", "ollama-embed"] = Field(
+    embedding_proctol: Literal["openai", "ollama-embed"] = Field(
         default="ollama-embed", description="Embedding模型协议"
     )
 
 
 class DataManager(BaseDataManager[ConfigFile]):
+    _owner_name = PLUGIN_IM
     config: ConfigFile
 
 

{amrita_plugin_memory-0.1.0 → amrita_plugin_memory-0.1.1}/amrita_plugin_memory/embed.py

@@ -1,13 +1,14 @@
-from collections.abc import Iterable, Sequence
+from collections.abc import Iterable, Sequence  # noqa: I001
 from typing import Any, Literal
+from typing_extensions import override
 
 import aiohttp
-from amrita_core.protocol import ModelAdapter
+from amrita_core.base.adapter import ModelAdapter
 from amrita_core.types import EmbeddingChunk
-from openai import AsyncOpenAI
 
 
 class OllamaEmbeddingAdapter(ModelAdapter):
+    @override
     async def call_embed(
         self, texts: Iterable[str], **kwargs
     ) -> Sequence[EmbeddingChunk]:
@@ -43,28 +44,3 @@ class OllamaEmbeddingAdapter(ModelAdapter):
     @staticmethod
     def get_type() -> Literal["embed"]:
         return "embed"
-
-
-class OpenAIEmbeddingAdapter(ModelAdapter):
-    async def call_embed(
-        self, texts: Iterable[str], **kwargs
-    ) -> Sequence[EmbeddingChunk]:
-        ps = self.preset
-        client = AsyncOpenAI(
-            base_url=ps.base_url, api_key=ps.api_key, max_retries=5, timeout=60
-        )
-        if isinstance(texts, str):
-            texts = [texts]
-        texts = list(texts)
-        embedd = await client.embeddings.create(
-            input=texts, model=ps.model, **kwargs, timeout=60
-        )
-        return [EmbeddingChunk.model_validate(data) for data in embedd.data]
-
-    @staticmethod
-    def get_adapter_protocol() -> Literal["openai-embed"]:
-        return "openai-embed"
-
-    @staticmethod
-    def get_type() -> Literal["embed"]:
-        return "embed"

{amrita_plugin_memory-0.1.0 → amrita_plugin_memory-0.1.1}/amrita_plugin_memory/tools.py

@@ -1,7 +1,8 @@
 import json
 from datetime import datetime
+from typing import Any
 
-from amrita.plugins.chat.runtime import AmritaChatObject
+from amrita.plugins.chat.runtime import AmritaBotContext
 from amrita_core import (
     FunctionDefinitionSchema,
     FunctionParametersSchema,
@@ -15,6 +16,30 @@ from nonebot import logger
 from .config import DataManager
 from .vector import AsyncUserMemory, MemoryMetadata, get_db_conn
 
+
+def _get_session_id(ctx: ToolContext) -> str:
+    """从 ToolContext 中提取会话 ID"""
+    amrictx: AmritaBotContext = ctx.ctx.chat_object._hook_kwargs["amrita"]
+    return amrictx["event"].get_session_id()
+
+
+def _make_operator() -> AsyncUserMemory:
+    """创建 AsyncUserMemory 实例"""
+    return AsyncUserMemory(get_db_conn())
+
+
+def _ok(**extra: Any) -> str:
+    """构建成功响应 JSON"""
+    return json.dumps({"status": "success", **extra}, ensure_ascii=False, indent=4)
+
+
+def _err(message: str) -> str:
+    """构建错误响应 JSON"""
+    return json.dumps(
+        {"status": "error", "message": message}, ensure_ascii=False, indent=4
+    )
+
+
 WRITE_MEMORY_FUN = FunctionDefinitionSchema(
     name="write_memory",
     description="将当前用户(或群组)的重要信息存入长期记忆",
@@ -117,34 +142,22 @@ LIST_MEMORY_FUN = FunctionDefinitionSchema(
 
 @on_tools(WRITE_MEMORY_FUN, custom_run=True, strict=True)
 async def w(ctx: ToolContext) -> str:
-    assert isinstance(ctx.ctx.chat_object, AmritaChatObject)
-    nb_event = ctx.ctx.chat_object.event
-    ope = AsyncUserMemory(get_db_conn())
+    session_id = _get_session_id(ctx)
+    ope = _make_operator()
     await ope.init()
     logger.debug("开始写入记忆...")
-    logger.debug(f"会话ID: {nb_event.get_session_id()}")
+    logger.debug(f"会话ID: {session_id}")
     logger.debug(f"记忆Payload {ctx.data['content']}")
     if (
-        await ope.count_user_notes(nb_event.get_session_id())
-        > (await DataManager().safe_get_config()).per_session_memory_limit
+        await ope.count_user_notes(session_id)
+        >= (await DataManager().safe_get_config()).per_session_memory_limit
     ):
-        return json.dumps(
-            {
-                "status": "error",
-                "message": "当前会话的记忆数量已超过限制，请清理后再试",
-            },
-            ensure_ascii=False,
-            indent=4,
-        )
+        return _err("当前会话的记忆数量已超过限制，请清理后再试")
     meta = MemoryMetadata(
         importance=ctx.data["importance"],
         tags=ctx.data["tags"],
     )
-    await ope.add_note(
-        nb_event.get_session_id(),
-        ctx.data["content"],
-        metadata=meta,
-    )
+    await ope.add_note(session_id, ctx.data["content"], metadata=meta)
     dmp = meta.model_dump()
     dmp["status"] = "success"
     return json.dumps(dmp, ensure_ascii=False, indent=4)
@@ -152,80 +165,53 @@ async def w(ctx: ToolContext) -> str:
 
 @on_tools(READ_MEMORY_FUN, custom_run=True, strict=True)
 async def r(ctx: ToolContext) -> str:
-    assert isinstance(ctx.ctx.chat_object, AmritaChatObject)
-    nb_event = ctx.ctx.chat_object.event
-    ope = AsyncUserMemory(get_db_conn())
+    session_id = _get_session_id(ctx)
+    ope = _make_operator()
     await ope.init()
     logger.debug("开始检索记忆...")
-    logger.debug(f"会话ID: {nb_event.get_session_id()}")
-    res: QueryResult = await ope.query_notes(
-        nb_event.get_session_id(),
-        ctx.data["query"],
-        top_k=ctx.data["top_k"],
-        importance=ctx.data.get("importance"),
-    )
-    return json.dumps(res, ensure_ascii=False, indent=4)
+    logger.debug(f"会话ID: {session_id}")
+    try:
+        res: QueryResult = await ope.query_notes(
+            session_id,
+            ctx.data["query"],
+            top_k=ctx.data["top_k"],
+            importance=ctx.data.get("importance"),
+        )
+        return json.dumps(res, ensure_ascii=False, indent=4)
+    except Exception as e:
+        logger.error(f"检索记忆时发生错误: {e}")
+        return _err(f"检索记忆失败: {e!s}")
 
 
 @on_tools(UPDATE_FUN, custom_run=True, strict=True)
 async def update_memory(ctx: ToolContext) -> str:
-    assert isinstance(ctx.ctx.chat_object, AmritaChatObject)
-    nb_event = ctx.ctx.chat_object.event
-    ope = AsyncUserMemory(get_db_conn())
+    session_id = _get_session_id(ctx)
+    ope = _make_operator()
     await ope.init()
     logger.debug("开始更新记忆...")
-    logger.debug(f"会话ID: {nb_event.get_session_id()}")
+    logger.debug(f"会话ID: {session_id}")
     logger.debug(f"更新记忆ID: {ctx.data['id']}")
 
     try:
-        result = await ope.get_all_notes(
-            nb_event.get_session_id(), include=["metadatas", "documents"]
-        )
+        result = await ope.get_all_notes(session_id, include=["metadatas", "documents"])
         if not result or not result.get("ids"):
-            return json.dumps(
-                {
-                    "status": "error",
-                    "message": "未找到指定ID的记忆",
-                },
-                ensure_ascii=False,
-                indent=4,
-            )
+            return _err("未找到指定ID的记忆")
 
         # 查找要更新的记忆
-        target_index = -1
         ids = result["ids"]
-        for i, doc_id in enumerate(ids):
-            if doc_id == ctx.data["id"]:
-                target_index = i
-                break
+        try:
+            target_index = ids.index(ctx.data["id"])
+        except ValueError:
+            return _err("未找到指定ID的记忆")
 
-        if target_index == -1:
-            return json.dumps(
-                {
-                    "status": "error",
-                    "message": "未找到指定ID的记忆",
-                },
-                ensure_ascii=False,
-                indent=4,
-            )
-
-        # 获取现有数据，处理可能为None的情况
+        # 获取现有数据
         documents = result.get("documents") or []
         metadatas = result.get("metadatas") or []
-
         existing_doc = documents[target_index] if target_index < len(documents) else ""
         existing_meta = metadatas[target_index] if target_index < len(metadatas) else {}
 
-        # 确保有必要的元数据
         if not existing_meta:
-            return json.dumps(
-                {
-                    "status": "error",
-                    "message": "记忆元数据损坏",
-                },
-                ensure_ascii=False,
-                indent=4,
-            )
+            return _err("记忆元数据损坏")
 
         # 构建更新后的数据
         new_content = ctx.data.get("content", existing_doc)
@@ -234,113 +220,71 @@ async def update_memory(ctx: ToolContext) -> str:
             "importance", existing_meta.get("importance", "medium")
         )
 
-        # 处理创建时间
+        # 保留原始创建时间
         created_at_str = existing_meta.get("created_at", "")
-        if isinstance(created_at_str, str) and created_at_str:
-            # 处理ISO格式的时间字符串
-            if created_at_str.endswith("Z"):
-                created_at_str = created_at_str.replace("Z", "+00:00")
-            created_at = datetime.fromisoformat(created_at_str)
+        if isinstance(created_at_str, str):
+            try:
+                created_at = datetime.fromisoformat(created_at_str)
+            except ValueError:
+                created_at = datetime.now()
         else:
             created_at = datetime.now()
-        await ope.delete_note(nb_event.get_session_id(), ctx.data["id"])
+
+        # 使用原生 update，原子操作，不会丢失数据
         meta = MemoryMetadata(
             memory_id=ctx.data["id"],
             importance=new_importance,
             tags=new_tags,
             created_at=created_at,
         )
-        await ope.add_note(
-            nb_event.get_session_id(),
-            new_content,
-            metadata=meta,
-        )
+        await ope.update_note(session_id, new_content, metadata=meta)
 
-        return json.dumps(
-            {"status": "success", "message": "记忆更新成功", "id": ctx.data["id"]},
-            ensure_ascii=False,
-            indent=4,
-        )
+        return _ok(message="记忆更新成功", id=ctx.data["id"])
     except Exception as e:
         logger.error(f"更新记忆时发生错误: {e}")
-        return json.dumps(
-            {
-                "status": "error",
-                "message": f"更新记忆失败: {e!s}",
-            },
-            ensure_ascii=False,
-            indent=4,
-        )
+        return _err(f"更新记忆失败: {e!s}")
 
 
 @on_tools(DELETE_FUN, custom_run=True, strict=True)
 async def delete_memory(ctx: ToolContext) -> str:
-    assert isinstance(ctx.ctx.chat_object, AmritaChatObject)
-    nb_event = ctx.ctx.chat_object.event
-    ope = AsyncUserMemory(get_db_conn())
+    session_id = _get_session_id(ctx)
+    ope = _make_operator()
     await ope.init()
     logger.debug("开始删除记忆...")
-    logger.debug(f"会话ID: {nb_event.get_session_id()}")
+    logger.debug(f"会话ID: {session_id}")
     logger.debug(f"删除记忆ID: {ctx.data['id']}")
 
     try:
-        # 检查记忆是否存在
-        result = await ope.get_all_notes(
-            nb_event.get_session_id(), include=["metadatas"]
-        )
+        result = await ope.get_all_notes(session_id, include=["metadatas"])
         if (
             not result
             or not result.get("ids")
             or ctx.data["id"] not in (result.get("ids") or [])
         ):
-            return json.dumps(
-                {
-                    "status": "error",
-                    "message": "未找到指定ID的记忆",
-                },
-                ensure_ascii=False,
-                indent=4,
-            )
+            return _err("未找到指定ID的记忆")
 
-        await ope.delete_note(nb_event.get_session_id(), ctx.data["id"])
-        return json.dumps(
-            {"status": "success", "message": "记忆删除成功", "id": ctx.data["id"]},
-            ensure_ascii=False,
-            indent=4,
-        )
+        await ope.delete_note(session_id, ctx.data["id"])
+        return _ok(message="记忆删除成功", id=ctx.data["id"])
     except Exception as e:
         logger.error(f"删除记忆时发生错误: {e}")
-        return json.dumps(
-            {
-                "status": "error",
-                "message": f"删除记忆失败: {e!s}",
-            },
-            ensure_ascii=False,
-            indent=4,
-        )
+        return _err(f"删除记忆失败: {e!s}")
 
 
 @on_tools(LIST_MEMORY_FUN, custom_run=True, strict=True)
 async def list_memory(ctx: ToolContext) -> str:
-    assert isinstance(ctx.ctx.chat_object, AmritaChatObject)
-    nb_event = ctx.ctx.chat_object.event
-    ope = AsyncUserMemory(get_db_conn())
+    session_id = _get_session_id(ctx)
+    ope = _make_operator()
     await ope.init()
     logger.debug("开始列出记忆...")
-    logger.debug(f"会话ID: {nb_event.get_session_id()}")
+    logger.debug(f"会话ID: {session_id}")
 
     try:
         limit = ctx.data.get("limit", 5)
-        result = await ope.get_all_notes(
-            nb_event.get_session_id(), include=["metadatas", "documents"]
-        )
+        result = await ope.get_all_notes(session_id, include=["metadatas", "documents"])
 
         if not result or not result.get("ids"):
-            return json.dumps(
-                {"status": "success", "memories": [], "total": 0},
-                ensure_ascii=False,
-                indent=4,
-            )
+            return _ok(memories=[], total=0)
+
         memories = []
         ids = result["ids"]
         documents = result.get("documents") or [""] * len(ids)
@@ -361,18 +305,7 @@ async def list_memory(ctx: ToolContext) -> str:
                 }
             )
 
-        return json.dumps(
-            {"status": "success", "memories": memories, "total": len(ids)},
-            ensure_ascii=False,
-            indent=4,
-        )
+        return _ok(memories=memories, total=len(ids))
     except Exception as e:
         logger.error(f"列出记忆时发生错误: {e}")
-        return json.dumps(
-            {
-                "status": "error",
-                "message": f"列出记忆失败: {e!s}",
-            },
-            ensure_ascii=False,
-            indent=4,
-        )
+        return _err(f"列出记忆失败: {e!s}")

{amrita_plugin_memory-0.1.0 → amrita_plugin_memory-0.1.1}/amrita_plugin_memory/vector.py

@@ -7,7 +7,6 @@ from collections.abc import Awaitable, Callable, Sequence
 from datetime import datetime
 from functools import wraps
 from inspect import iscoroutinefunction
-from types import CoroutineType
 from typing import Any, Literal, TypeVar, overload
 from uuid import UUID
 
@@ -15,7 +14,7 @@ import aiologic
 import chromadb
 from amrita_core.libchat import call_embedding
 from amrita_core.types import EmbeddingChunk
-from amrita_core.weakcache import WeakValueLRUCache
+from amrita_sense.weakcache import WeakValueLRUCache
 from chromadb.api import ClientAPI
 from chromadb.api.collection_configuration import (
     CreateCollectionConfiguration,
@@ -53,14 +52,12 @@ def get_lock(collection: str, uid: str) -> aiologic.Lock:
 @overload
 def any_to_thread(
     func: Callable[..., Awaitable[T]], /, *args, **kwargs
-) -> CoroutineType[Any, Any, T]: ...
+) -> Awaitable[T]: ...
 @overload
-def any_to_thread(
-    func: Callable[..., T], /, *args, **kwargs
-) -> CoroutineType[Any, Any, T]: ...
+def any_to_thread(func: Callable[..., T], /, *args, **kwargs) -> Awaitable[T]: ...
 
 
-def any_to_thread(func: Callable[..., Awaitable[T] | T], /, *args, **kwargs):
+def any_to_thread(func: Callable[..., Awaitable[T] | T], /, *args, **kwargs) -> Any:
     if not callable(func):
         raise TypeError("func must be callable")
     if iscoroutinefunction(func):
@@ -371,6 +368,30 @@ class AsyncUserMemory:
                 documents=[note_text],
             )
 
+    @require_init
+    async def update_note(self, user_id: str, note_text: str, metadata: MemoryMetadata):
+        """更新指定记忆，使用 ChromaDB 原生 update 保证原子性"""
+        async with get_lock(self._collection_name, user_id):
+            vector: Sequence[EmbeddingChunk] = await call_embedding(
+                note_text, build_preset()
+            )
+            if len(vector) == 0:
+                raise RuntimeError("No embedding returned")
+            await any_to_thread(
+                self._collection.update,
+                ids=[metadata.memory_id],
+                metadatas=[
+                    {
+                        "user_id": user_id,
+                        "tags": metadata.tags,
+                        "importance": metadata.importance,
+                        "created_at": metadata.created_at.isoformat(),
+                    }
+                ],
+                embeddings=[vector[0].embedding],
+                documents=[note_text],
+            )
+
     @require_init
     async def query_notes(
         self,

amrita_plugin_memory-0.1.1/amrita_plugin_memory.egg-info/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: amrita_plugin_memory
+Version: 0.1.1
+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 的工具系统中。
+
+## 功能特点
+
+- **长期记忆存储**：将用户偏好、项目信息等持久化存入 ChromaDB 向量数据库
+- **语义检索**：基于嵌入向量的语义相似度检索，支持中英文关键词
+- **智能标签**：支持使用自定义标签对记忆进行分类（如 `preference`、`project`）
+- **重要性分级**：三级重要程度（`low` / `medium` / `high`），支持按级别过滤检索
+- **完整 CRUD**：支持记忆的创建、查询、更新、删除和列表查看
+- **并发安全**：按用户 ID 粒度加锁，确保同一用户的操作串行化
+- **多租户支持**：通过 ChromaDB remote 模式支持远程向量数据库
+
+## 工具函数
+
+### 1. `write_memory` —— 写入记忆
+
+将当前用户（或群组）的重要信息存入长期记忆。
+
+| 参数 | 类型 | 必需 | 描述 |
+|------|------|------|------|
+| `content` | string | ✅ | 记忆内容，简洁明了 |
+| `tags` | string | ✅ | 分类标签，如 `preference`、`project` |
+| `importance` | `"low"` / `"medium"` / `"high"` | ✅ | 重要性等级 |
+
+### 2. `read_memory` —— 检索记忆
+
+从记忆库中按语义相似度检索用户相关信息。
+
+| 参数 | 类型 | 必需 | 默认值 | 描述 |
+|------|------|------|--------|------|
+| `query` | string | ✅ | — | 关键词字符串，空格分隔 |
+| `top_k` | integer | ❌ | `5` | 返回结果数量 |
+| `importance` | `"low"` / `"medium"` / `"high"` | ❌ | — | 按重要性过滤 |
+
+### 3. `update_memory` —— 更新记忆
+
+更新指定 ID 的记忆内容、标签或重要性。
+
+| 参数 | 类型 | 必需 | 描述 |
+|------|------|------|------|
+| `id` | string | ✅ | 要更新的记忆 ID |
+| `content` | string | ❌ | 新的记忆内容 |
+| `tags` | string | ❌ | 新的标签 |
+| `importance` | `"low"` / `"medium"` / `"high"` | ❌ | 新的重要性等级 |
+
+### 4. `delete_memory` —— 删除记忆
+
+删除指定 ID 的记忆。
+
+| 参数 | 类型 | 必需 | 描述 |
+|------|------|------|------|
+| `id` | string | ✅ | 要删除的记忆 ID |
+
+### 5. `list_memory` —— 列出记忆
+
+列出当前用户的所有记忆（返回标签和 ID）。
+
+| 参数 | 类型 | 必需 | 默认值 | 描述 |
+|------|------|------|--------|------|
+| `limit` | integer | ❌ | `5` | 返回数量限制 |
+
+## 配置选项
+
+### 文件配置（`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` | 嵌入模型协议 |
+
+## 安装与使用
+
+### 前置条件
+
+- 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.0 → amrita_plugin_memory-0.1.1}/amrita_plugin_memory.egg-info/requires.txt

@@ -1,6 +1,6 @@
 aiohttp>=3.13.3
 aiologic>=0.16.0
 amrita-core>=0.8.5
-amrita[full]>=1.1.9
+amrita>=1.3
 chromadb>=1.5.8
 nonebot-plugin-localstore>=0.7.4

{amrita_plugin_memory-0.1.0 → amrita_plugin_memory-0.1.1}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "amrita_plugin_memory"
 description = "Amrita长期记忆插件"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
     "aiohttp>=3.13.3",
     "aiologic>=0.16.0",
     "amrita-core>=0.8.5",
-    "amrita[full]>=1.1.9",
+    "amrita>=1.3",
     "chromadb>=1.5.8",
     "nonebot-plugin-localstore>=0.7.4",
 ]

amrita_plugin_memory-0.1.0/PKG-INFO

@@ -1,98 +0,0 @@
-Metadata-Version: 2.4
-Name: amrita_plugin_memory
-Version: 0.1.0
-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[full]>=1.1.9
-Requires-Dist: chromadb>=1.5.8
-Requires-Dist: nonebot-plugin-localstore>=0.7.4
-Dynamic: license-file
-
-# amrita_plugin_memory
-
-Amrita 长期记忆插件 - 一个智能记忆管理系统，用于帮助 AI 助手记住关于用户的长期信息。
-
-## 技术栈
-
-- **后端**: Python 3.x 插件架构
-- **向量数据库**: ChromaDB (支持本地和远程模式)
-- **嵌入模型**: 支持 OpenAI Embedding API 和 Ollama Embedding API
-- **框架**: NoneBot2 + Amrita Core + AmritaBot
-- **配置管理**: Pydantic + TOML
-- **异步处理**: asyncio + aiologic + aiohttp
-
-## 功能特点
-
-- **长期记忆存储**：持久化存储关于用户的长期重要信息
-- **智能标签系统**：支持使用标签对记忆进行分类管理
-- **重要性分级**：支持设置记忆的重要程度（low/medium/high）
-- **灵活检索**：支持按关键词检索记忆内容
-- **完整管理**：支持记忆的增删改查和列表查看
-
-## 工具函数
-
-插件提供了五个主要工具函数：
-
-### 1. write_memory
-
-将重要信息存入长期记忆
-
-参数：
-
-- content: 记忆内容，简洁明了（必需）
-- tags: 分类标签，如 `"preference"` 或 `"project"`（必需）
-- importance: 重要性等级（必需，可选值：`"low"`, `"medium"`, `"high"`）
-
-### 2. read_memory
-
-从记忆库检索用户相关信息
-
-参数：
-
-- query: 关键词字符串，用空格分割（必需）
-- top_k: 返回数量，默认5条（可选）
-- importance: 重要性等级过滤（可选，可选值：`"low"`, `"medium"`, `"high"`）
-
-### 3. update_memory
-
-更新指定ID的记忆内容
-
-参数：
-
-- id: 要更新的记忆ID（必需）
-- content: 新的记忆内容（可选）
-- tags: 新的标签（可选）
-- importance: 新的重要性等级（可选，可选值：`"low"`, `"medium"`, `"high"`）
-
-### 4. delete_memory
-
-删除指定ID的记忆
-
-参数：
-
-- id: 要删除的记忆ID（必需）
-
-### 5. list_memory
-
-列出当前用户的所有记忆
-
-参数：
-
-- limit: 返回数量限制，默认5条（可选）
-
-## 配置选项
-
-- `short_term_expiry_days`: 短期记忆的过期天数，默认为3天
-- `long_term_expiry_days`: 长期记忆的过期天数，默认为30天
-- `permanent_expiry_days`: 永久记忆的过期天数，默认为1年
-- `per_session_memory_limit`: 每个会话的记忆数量限制，默认为50条
-
-## 安装和使用
-
-1. 安装插件：`amrita plugin install amrita_plugin_memory`
-2. 配置插件：插件会自动生成配置文件，或者您可以在WebUI中配置。

amrita_plugin_memory-0.1.0/README.md

@@ -1,83 +0,0 @@
-# amrita_plugin_memory
-
-Amrita 长期记忆插件 - 一个智能记忆管理系统，用于帮助 AI 助手记住关于用户的长期信息。
-
-## 技术栈
-
-- **后端**: Python 3.x 插件架构
-- **向量数据库**: ChromaDB (支持本地和远程模式)
-- **嵌入模型**: 支持 OpenAI Embedding API 和 Ollama Embedding API
-- **框架**: NoneBot2 + Amrita Core + AmritaBot
-- **配置管理**: Pydantic + TOML
-- **异步处理**: asyncio + aiologic + aiohttp
-
-## 功能特点
-
-- **长期记忆存储**：持久化存储关于用户的长期重要信息
-- **智能标签系统**：支持使用标签对记忆进行分类管理
-- **重要性分级**：支持设置记忆的重要程度（low/medium/high）
-- **灵活检索**：支持按关键词检索记忆内容
-- **完整管理**：支持记忆的增删改查和列表查看
-
-## 工具函数
-
-插件提供了五个主要工具函数：
-
-### 1. write_memory
-
-将重要信息存入长期记忆
-
-参数：
-
-- content: 记忆内容，简洁明了（必需）
-- tags: 分类标签，如 `"preference"` 或 `"project"`（必需）
-- importance: 重要性等级（必需，可选值：`"low"`, `"medium"`, `"high"`）
-
-### 2. read_memory
-
-从记忆库检索用户相关信息
-
-参数：
-
-- query: 关键词字符串，用空格分割（必需）
-- top_k: 返回数量，默认5条（可选）
-- importance: 重要性等级过滤（可选，可选值：`"low"`, `"medium"`, `"high"`）
-
-### 3. update_memory
-
-更新指定ID的记忆内容
-
-参数：
-
-- id: 要更新的记忆ID（必需）
-- content: 新的记忆内容（可选）
-- tags: 新的标签（可选）
-- importance: 新的重要性等级（可选，可选值：`"low"`, `"medium"`, `"high"`）
-
-### 4. delete_memory
-
-删除指定ID的记忆
-
-参数：
-
-- id: 要删除的记忆ID（必需）
-
-### 5. list_memory
-
-列出当前用户的所有记忆
-
-参数：
-
-- limit: 返回数量限制，默认5条（可选）
-
-## 配置选项
-
-- `short_term_expiry_days`: 短期记忆的过期天数，默认为3天
-- `long_term_expiry_days`: 长期记忆的过期天数，默认为30天
-- `permanent_expiry_days`: 永久记忆的过期天数，默认为1年
-- `per_session_memory_limit`: 每个会话的记忆数量限制，默认为50条
-
-## 安装和使用
-
-1. 安装插件：`amrita plugin install amrita_plugin_memory`
-2. 配置插件：插件会自动生成配置文件，或者您可以在WebUI中配置。

amrita_plugin_memory-0.1.0/amrita_plugin_memory.egg-info/PKG-INFO

@@ -1,98 +0,0 @@
-Metadata-Version: 2.4
-Name: amrita_plugin_memory
-Version: 0.1.0
-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[full]>=1.1.9
-Requires-Dist: chromadb>=1.5.8
-Requires-Dist: nonebot-plugin-localstore>=0.7.4
-Dynamic: license-file
-
-# amrita_plugin_memory
-
-Amrita 长期记忆插件 - 一个智能记忆管理系统，用于帮助 AI 助手记住关于用户的长期信息。
-
-## 技术栈
-
-- **后端**: Python 3.x 插件架构
-- **向量数据库**: ChromaDB (支持本地和远程模式)
-- **嵌入模型**: 支持 OpenAI Embedding API 和 Ollama Embedding API
-- **框架**: NoneBot2 + Amrita Core + AmritaBot
-- **配置管理**: Pydantic + TOML
-- **异步处理**: asyncio + aiologic + aiohttp
-
-## 功能特点
-
-- **长期记忆存储**：持久化存储关于用户的长期重要信息
-- **智能标签系统**：支持使用标签对记忆进行分类管理
-- **重要性分级**：支持设置记忆的重要程度（low/medium/high）
-- **灵活检索**：支持按关键词检索记忆内容
-- **完整管理**：支持记忆的增删改查和列表查看
-
-## 工具函数
-
-插件提供了五个主要工具函数：
-
-### 1. write_memory
-
-将重要信息存入长期记忆
-
-参数：
-
-- content: 记忆内容，简洁明了（必需）
-- tags: 分类标签，如 `"preference"` 或 `"project"`（必需）
-- importance: 重要性等级（必需，可选值：`"low"`, `"medium"`, `"high"`）
-
-### 2. read_memory
-
-从记忆库检索用户相关信息
-
-参数：
-
-- query: 关键词字符串，用空格分割（必需）
-- top_k: 返回数量，默认5条（可选）
-- importance: 重要性等级过滤（可选，可选值：`"low"`, `"medium"`, `"high"`）
-
-### 3. update_memory
-
-更新指定ID的记忆内容
-
-参数：
-
-- id: 要更新的记忆ID（必需）
-- content: 新的记忆内容（可选）
-- tags: 新的标签（可选）
-- importance: 新的重要性等级（可选，可选值：`"low"`, `"medium"`, `"high"`）
-
-### 4. delete_memory
-
-删除指定ID的记忆
-
-参数：
-
-- id: 要删除的记忆ID（必需）
-
-### 5. list_memory
-
-列出当前用户的所有记忆
-
-参数：
-
-- limit: 返回数量限制，默认5条（可选）
-
-## 配置选项
-
-- `short_term_expiry_days`: 短期记忆的过期天数，默认为3天
-- `long_term_expiry_days`: 长期记忆的过期天数，默认为30天
-- `permanent_expiry_days`: 永久记忆的过期天数，默认为1年
-- `per_session_memory_limit`: 每个会话的记忆数量限制，默认为50条
-
-## 安装和使用
-
-1. 安装插件：`amrita plugin install amrita_plugin_memory`
-2. 配置插件：插件会自动生成配置文件，或者您可以在WebUI中配置。