nonebot-plugin-group-chat-memory 0.1.0__tar.gz → 0.1.2__tar.gz

{nonebot_plugin_group_chat_memory-0.1.0 → nonebot_plugin_group_chat_memory-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nonebot-plugin-group-chat-memory
-Version: 0.1.0
+Version: 0.1.2
 Summary: 为 NoneBot2 群聊提供共享长期记忆、点名对话和按群概率回复
 License-Expression: MIT
 License-File: LICENSE
@@ -26,7 +26,7 @@ Description-Content-Type: text/markdown
 
 # nonebot-plugin-group-chat-memory
 
-为 NoneBot2 OneBot v11 群聊提供按群隔离的长期向量记忆、@/回复对话和按群概率随机回复。插件使用 SQLite + sqlite-vec 保存原文、分块、向量和群配置，聊天与 Embedding 均请求可配置的 OpenAI 兼容 HTTP API。
+为 NoneBot2 OneBot v11 群聊提供按群隔离的长期向量记忆、@/回复对话和按群概率随机回复。插件使用 SQLite 保存原文、分块、向量和群配置，聊天与 Embedding 均请求可配置的 OpenAI 兼容 HTTP API。
 
 ## 环境与安装
 
@@ -34,6 +34,8 @@ Description-Content-Type: text/markdown
 - NoneBot2 2.2+
 - OneBot v11 适配器与对应的 OneBot 协议端
 
+优先使用 sqlite-vec 原生向量索引。如果当前 Python 的 `sqlite3` 不支持加载扩展（例如部分 python.org/Homebrew Python 3.13/3.14 构建），插件会自动改用 SQLite BLOB 保存向量并在 Python 中计算余弦相似度；启动日志会给出提示，功能保持可用。旧 sqlite-vec 数据库中缺少 BLOB 向量的已就绪片段会自动重新排队向量化。
+
 选择一种安装方式：
 
 ```bash
@@ -83,6 +85,8 @@ COMMAND_START=["/"]
 
 聊天地址填到 API 根路径（通常包含 `/v1`），插件分别请求其下的 `/chat/completions` 和 `/embeddings`。默认聊天模型标识是 `deepseek-v4.1-flash`，但**模型标识必须以实际服务商支持的值为准**。这四项保存到 SQLite，不再读取同名环境变量，更新后立即生效且重启后保留。使用 `/模型配置` 可查询脱敏状态。
 
+使用 OpenCode Go 直连 API 时，地址是 `https://opencode.ai/inference/go/openai/v1`，模型是 `deepseek-v4.1-flash`。插件会发送自己的 User-Agent，并对 OpenCode 请求附带按群稳定的 `x-opencode-session`，避免被网关当作通用 SDK 流量。
+
 ## 其余环境配置字段
 
 四个模型运行时字段不再通过 env 设置。其余以下字段可写在 NoneBot `.env` 中；集合类值使用 JSON 格式。

{nonebot_plugin_group_chat_memory-0.1.0 → nonebot_plugin_group_chat_memory-0.1.2}/README.md

@@ -1,6 +1,6 @@
 # nonebot-plugin-group-chat-memory
 
-为 NoneBot2 OneBot v11 群聊提供按群隔离的长期向量记忆、@/回复对话和按群概率随机回复。插件使用 SQLite + sqlite-vec 保存原文、分块、向量和群配置，聊天与 Embedding 均请求可配置的 OpenAI 兼容 HTTP API。
+为 NoneBot2 OneBot v11 群聊提供按群隔离的长期向量记忆、@/回复对话和按群概率随机回复。插件使用 SQLite 保存原文、分块、向量和群配置，聊天与 Embedding 均请求可配置的 OpenAI 兼容 HTTP API。
 
 ## 环境与安装
 
@@ -8,6 +8,8 @@
 - NoneBot2 2.2+
 - OneBot v11 适配器与对应的 OneBot 协议端
 
+优先使用 sqlite-vec 原生向量索引。如果当前 Python 的 `sqlite3` 不支持加载扩展（例如部分 python.org/Homebrew Python 3.13/3.14 构建），插件会自动改用 SQLite BLOB 保存向量并在 Python 中计算余弦相似度；启动日志会给出提示，功能保持可用。旧 sqlite-vec 数据库中缺少 BLOB 向量的已就绪片段会自动重新排队向量化。
+
 选择一种安装方式：
 
 ```bash
@@ -57,6 +59,8 @@ COMMAND_START=["/"]
 
 聊天地址填到 API 根路径（通常包含 `/v1`），插件分别请求其下的 `/chat/completions` 和 `/embeddings`。默认聊天模型标识是 `deepseek-v4.1-flash`，但**模型标识必须以实际服务商支持的值为准**。这四项保存到 SQLite，不再读取同名环境变量，更新后立即生效且重启后保留。使用 `/模型配置` 可查询脱敏状态。
 
+使用 OpenCode Go 直连 API 时，地址是 `https://opencode.ai/inference/go/openai/v1`，模型是 `deepseek-v4.1-flash`。插件会发送自己的 User-Agent，并对 OpenCode 请求附带按群稳定的 `x-opencode-session`，避免被网关当作通用 SDK 流量。
+
 ## 其余环境配置字段
 
 四个模型运行时字段不再通过 env 设置。其余以下字段可写在 NoneBot `.env` 中；集合类值使用 JSON 格式。

{nonebot_plugin_group_chat_memory-0.1.0 → nonebot_plugin_group_chat_memory-0.1.2}/nonebot_plugin_group_chat_memory/api.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import math
 from typing import Any
+from urllib.parse import urlparse
 
 import httpx
 
@@ -11,6 +12,7 @@ from .context import build_chat_messages
 from .models import ChatContext
 
 CHAT_RETRY_DELAYS: tuple[float, ...] = (0.5, 1.0)
+CLIENT_USER_AGENT = "nonebot-plugin-group-chat-memory/0.1.2"
 
 
 class ModelAPIError(RuntimeError):
@@ -24,9 +26,16 @@ class EmbeddingAPIError(ModelAPIError):
 class ChatAPIError(ModelAPIError):
     """聊天请求失败或响应不可用。"""
 
-    def __init__(self, message: str, *, retryable: bool = False) -> None:
+    def __init__(
+        self,
+        message: str,
+        *,
+        retryable: bool = False,
+        status_code: int | None = None,
+    ) -> None:
         super().__init__(message)
         self.retryable = retryable
+        self.status_code = status_code
 
 
 def _make_client(timeout: float) -> httpx.AsyncClient:
@@ -39,7 +48,19 @@ def _endpoint(base_url: str, path: str) -> str:
 
 
 def _auth_headers(api_key: str) -> dict[str, str]:
-    return {"Authorization": f"Bearer {api_key.strip()}"}
+    return {
+        "Authorization": f"Bearer {api_key.strip()}",
+        "User-Agent": CLIENT_USER_AGENT,
+    }
+
+
+def _chat_headers(
+    base_url: str, api_key: str, session_id: str | None
+) -> dict[str, str]:
+    headers = _auth_headers(api_key)
+    if session_id and urlparse(base_url).hostname == "opencode.ai":
+        headers["x-opencode-session"] = session_id
+    return headers
 
 
 class EmbeddingClient:
@@ -105,7 +126,9 @@ class ChatClient:
         self._config = config
         self._retry_delays = tuple(retry_delays)
 
-    async def complete(self, context: ChatContext, current_text: str) -> str:
+    async def complete(
+        self, context: ChatContext, current_text: str, *, session_id: str | None = None
+    ) -> str:
         """按上下文请求一条回复；瞬时失败按配置次数重试，最终失败抛出 ChatAPIError。"""
         self._config.require_chat_config()
         if not current_text.strip():
@@ -118,7 +141,7 @@ class ChatClient:
         attempts = len(self._retry_delays) + 1
         for attempt in range(attempts):
             try:
-                response = await self._post(payload)
+                response = await self._post(payload, session_id)
             except ChatAPIError as exc:
                 if not exc.retryable or attempt + 1 >= attempts:
                     raise
@@ -127,9 +150,16 @@ class ChatClient:
             return self._parse(response)
         raise ChatAPIError("聊天请求重试次数已用尽。")
 
-    async def _post(self, payload: dict[str, Any]) -> httpx.Response:
-        url = _endpoint(self._config.group_chat_memory_chat_base_url, "chat/completions")
-        headers = _auth_headers(self._config.group_chat_memory_chat_api_key.get_secret_value())
+    async def _post(
+        self, payload: dict[str, Any], session_id: str | None
+    ) -> httpx.Response:
+        base_url = self._config.group_chat_memory_chat_base_url
+        url = _endpoint(base_url, "chat/completions")
+        headers = _chat_headers(
+            base_url,
+            self._config.group_chat_memory_chat_api_key.get_secret_value(),
+            session_id,
+        )
         timeout = self._config.group_chat_memory_chat_timeout
         try:
             async with _make_client(timeout) as client:
@@ -142,6 +172,7 @@ class ChatClient:
             raise ChatAPIError(
                 f"聊天服务返回 HTTP {response.status_code}。",
                 retryable=response.status_code == 429 or response.status_code >= 500,
+                status_code=response.status_code,
             )
         return response
 

{nonebot_plugin_group_chat_memory-0.1.0 → nonebot_plugin_group_chat_memory-0.1.2}/nonebot_plugin_group_chat_memory/handlers.py

@@ -21,7 +21,7 @@ from nonebot.adapters.onebot.v11 import (
 from nonebot.params import CommandArg
 from nonebot.permission import SUPERUSER
 
-from .api import ChatClient, EmbeddingClient
+from .api import ChatAPIError, ChatClient, EmbeddingClient
 from .config import get_settings
 from .context import ContextBuilder
 from .memory import MemoryWriter
@@ -79,9 +79,12 @@ async def reply(group_id: int, message: MemoryMessage) -> None:
     bot = _bots[group_id]
     try:
         context = await context_builder.build(group_id, message.text)
-        response = await chat_client.complete(context, message.text)
+        response = await chat_client.complete(
+            context, message.text, session_id=f"group:{group_id}"
+        )
     except Exception as exc:
-        logger.error("群 %s 的聊天回复失败：%s", group_id, type(exc).__name__)
+        status = f" HTTP {exc.status_code}" if isinstance(exc, ChatAPIError) else ""
+        logger.error("群 %s 的聊天回复失败：%s%s", group_id, type(exc).__name__, status)
         await bot.send_group_msg(group_id=group_id, message=GENERIC_REPLY_ERROR)
         return
 

{nonebot_plugin_group_chat_memory-0.1.0 → nonebot_plugin_group_chat_memory-0.1.2}/nonebot_plugin_group_chat_memory/store.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 import math
+import sqlite3
+import struct
 from collections.abc import AsyncIterator, Sequence
-from contextlib import asynccontextmanager
+from contextlib import asynccontextmanager, suppress
 from datetime import datetime, timezone
 
 import aiosqlite
@@ -12,8 +15,14 @@ import sqlite_vec
 from .config import RUNTIME_CONFIG_DEFAULTS, Config
 from .models import Chunk, ChunkStatus, Message
 
+logger = logging.getLogger(__name__)
+
 DIMENSIONS_META_KEY = "embedding_dimensions"
 
+
+def _supports_load_extension() -> bool:
+    return hasattr(sqlite3.Connection, "enable_load_extension")
+
 _SCHEMA_STATEMENTS = (
     """
     CREATE TABLE IF NOT EXISTS meta (
@@ -66,6 +75,17 @@ _SCHEMA_STATEMENTS = (
     CREATE INDEX IF NOT EXISTS idx_messages_unchunked
         ON messages(group_id, id) WHERE chunk_id IS NULL
     """,
+    """
+    CREATE TABLE IF NOT EXISTS memory_vector_blobs (
+        chunk_id INTEGER PRIMARY KEY REFERENCES chunks(id) ON DELETE CASCADE,
+        group_id INTEGER NOT NULL,
+        embedding BLOB NOT NULL
+    )
+    """,
+    """
+    CREATE INDEX IF NOT EXISTS idx_vector_blobs_group
+        ON memory_vector_blobs(group_id)
+    """,
 )
 
 _VECTOR_TABLE_STATEMENT = """
@@ -85,10 +105,11 @@ class MemoryStore:
         self._dimensions = config.group_chat_memory_embedding_dimensions
         self._default_probability = config.group_chat_memory_default_probability
         self._db: aiosqlite.Connection | None = None
+        self._use_sqlite_vec = False
         self._lock = asyncio.Lock()
 
     async def open(self) -> None:
-        """打开数据库、加载 sqlite-vec 并创建缺失的表结构。"""
+        """打开数据库；优先加载 sqlite-vec，不支持时使用 BLOB 向量回退。"""
         async with self._lock:
             if self._db is not None:
                 return
@@ -96,23 +117,57 @@ class MemoryStore:
             path = self._config.database_path
             path.parent.mkdir(parents=True, exist_ok=True)
             db = await aiosqlite.connect(path, isolation_level=None)
+            use_sqlite_vec = _supports_load_extension()
             try:
                 db.row_factory = aiosqlite.Row
-                await db.enable_load_extension(True)
-                await db.load_extension(sqlite_vec.loadable_path())
-                await db.enable_load_extension(False)
+                if use_sqlite_vec:
+                    try:
+                        await db.enable_load_extension(True)
+                        await db.load_extension(sqlite_vec.loadable_path())
+                    except Exception as exc:
+                        logger.warning(
+                            "sqlite-vec 加载失败，改用 SQLite BLOB 向量检索：%s",
+                            type(exc).__name__,
+                        )
+                        use_sqlite_vec = False
+                    finally:
+                        if hasattr(db, "enable_load_extension"):
+                            with suppress(Exception):
+                                await db.enable_load_extension(False)
+                else:
+                    logger.warning(
+                        "当前 Python 的 sqlite3 不支持加载扩展，改用 SQLite BLOB 向量检索。"
+                    )
                 await db.execute("PRAGMA journal_mode = WAL")
                 await db.execute("PRAGMA foreign_keys = ON")
                 await db.execute("PRAGMA busy_timeout = 5000")
                 await db.execute("PRAGMA synchronous = NORMAL")
                 self._db = db
+                self._use_sqlite_vec = use_sqlite_vec
                 async with self._transaction_on(db) as tx:
                     for statement in _SCHEMA_STATEMENTS:
                         await tx.execute(statement)
                     await self._ensure_dimensions(tx)
-                    await tx.execute(_VECTOR_TABLE_STATEMENT.format(dimensions=self._dimensions))
+                    if use_sqlite_vec:
+                        await tx.execute(
+                            _VECTOR_TABLE_STATEMENT.format(dimensions=self._dimensions)
+                        )
+                    else:
+                        cursor = await tx.execute(
+                            "UPDATE chunks SET status = ? WHERE status = ? AND NOT EXISTS ("
+                            "SELECT 1 FROM memory_vector_blobs AS b WHERE b.chunk_id = chunks.id"
+                            ")",
+                            (ChunkStatus.PENDING.value, ChunkStatus.READY.value),
+                        )
+                        if cursor.rowcount > 0:
+                            logger.warning(
+                                "%s 个片段缺少 BLOB 向量，已重新排队等待向量化。",
+                                cursor.rowcount,
+                            )
+                        await cursor.close()
             except BaseException:
                 self._db = None
+                self._use_sqlite_vec = False
                 await db.close()
                 raise
 
@@ -282,11 +337,21 @@ class MemoryStore:
             await cursor.close()
             if row is None:
                 return
-            await db.execute("DELETE FROM memory_vectors WHERE chunk_id = ?", (chunk_id,))
-            await db.execute(
-                "INSERT INTO memory_vectors(chunk_id, group_id, embedding) VALUES (?, ?, ?)",
-                (chunk_id, row["group_id"], sqlite_vec.serialize_float32(embedding)),
-            )
+            if self._use_sqlite_vec:
+                await db.execute("DELETE FROM memory_vectors WHERE chunk_id = ?", (chunk_id,))
+                await db.execute(
+                    "INSERT INTO memory_vectors(chunk_id, group_id, embedding) VALUES (?, ?, ?)",
+                    (chunk_id, row["group_id"], sqlite_vec.serialize_float32(embedding)),
+                )
+            else:
+                await db.execute(
+                    "DELETE FROM memory_vector_blobs WHERE chunk_id = ?", (chunk_id,)
+                )
+                await db.execute(
+                    "INSERT INTO memory_vector_blobs(chunk_id, group_id, embedding) "
+                    "VALUES (?, ?, ?)",
+                    (chunk_id, row["group_id"], _pack_vector(embedding)),
+                )
             await db.execute(
                 "UPDATE chunks SET status = ? WHERE id = ?",
                 (ChunkStatus.READY.value, chunk_id),
@@ -299,21 +364,46 @@ class MemoryStore:
             return []
         async with self._lock:
             db = self._require_db()
+            if self._use_sqlite_vec:
+                cursor = await db.execute(
+                    "SELECT c.id, c.group_id, c.text, c.status FROM ("
+                    "SELECT chunk_id, distance FROM memory_vectors "
+                    "WHERE embedding MATCH ? AND k = ? AND group_id = ?"
+                    ") AS v JOIN chunks AS c ON c.id = v.chunk_id ORDER BY v.distance",
+                    (sqlite_vec.serialize_float32(embedding), limit, group_id),
+                )
+                rows = await cursor.fetchall()
+                await cursor.close()
+                return [_row_to_chunk(row) for row in rows]
+
             cursor = await db.execute(
-                "SELECT c.id, c.group_id, c.text, c.status FROM ("
-                "SELECT chunk_id, distance FROM memory_vectors "
-                "WHERE embedding MATCH ? AND k = ? AND group_id = ?"
-                ") AS v JOIN chunks AS c ON c.id = v.chunk_id ORDER BY v.distance",
-                (sqlite_vec.serialize_float32(embedding), limit, group_id),
+                "SELECT c.id, c.group_id, c.text, c.status, b.embedding "
+                "FROM memory_vector_blobs AS b JOIN chunks AS c ON c.id = b.chunk_id "
+                "WHERE b.group_id = ? AND c.status = ?",
+                (group_id, ChunkStatus.READY.value),
             )
             rows = await cursor.fetchall()
             await cursor.close()
-        return [_row_to_chunk(row) for row in rows]
+        scored = [
+            (
+                _cosine_similarity(embedding, _unpack_vector(row["embedding"], self._dimensions)),
+                int(row["id"]),
+                row,
+            )
+            for row in rows
+            if len(row["embedding"]) == self._dimensions * 4
+        ]
+        scored.sort(key=lambda item: (-item[0], item[1]))
+        return [_row_to_chunk(row) for _, _, row in scored[:limit]]
 
     async def clear_group(self, group_id: int) -> None:
         """删除当前群的消息、片段与向量，保留概率配置。"""
         async with self._transaction() as db:
-            await db.execute("DELETE FROM memory_vectors WHERE group_id = ?", (group_id,))
+            await db.execute(
+                "DELETE FROM memory_vector_blobs WHERE group_id = ?", (group_id,)
+            )
+            if self._use_sqlite_vec:
+                await db.execute("DELETE FROM memory_vectors WHERE group_id = ?", (group_id,))
             await db.execute("DELETE FROM messages WHERE group_id = ?", (group_id,))
             await db.execute("DELETE FROM chunks WHERE group_id = ?", (group_id,))
 
@@ -407,6 +497,23 @@ def _validated_vector(vector: list[float], dimensions: int) -> list[float]:
     return values
 
 
+def _pack_vector(vector: list[float]) -> bytes:
+    return struct.pack(f"<{len(vector)}f", *vector)
+
+
+def _unpack_vector(value: bytes, dimensions: int) -> list[float]:
+    return list(struct.unpack(f"<{dimensions}f", value))
+
+
+def _cosine_similarity(left: list[float], right: list[float]) -> float:
+    dot = sum(a * b for a, b in zip(left, right, strict=True))
+    left_norm = math.sqrt(sum(value * value for value in left))
+    right_norm = math.sqrt(sum(value * value for value in right))
+    if left_norm == 0.0 or right_norm == 0.0:
+        return 0.0
+    return dot / (left_norm * right_norm)
+
+
 def _utc_now() -> datetime:
     return datetime.now(timezone.utc)
 

{nonebot_plugin_group_chat_memory-0.1.0 → nonebot_plugin_group_chat_memory-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nonebot-plugin-group-chat-memory"
-version = "0.1.0"
+version = "0.1.2"
 description = "为 NoneBot2 群聊提供共享长期记忆、点名对话和按群概率回复"
 readme = "README.md"
 authors = [{ name = "TonyLiangP2010405" }]