nonebot-plugin-group-chat-memory 0.1.0__py3-none-any.whl

nonebot_plugin_group_chat_memory/__init__.py

@@ -0,0 +1,26 @@
+from nonebot import get_driver, require
+from nonebot.plugin import PluginMetadata
+
+from .config import Config
+
+__plugin_meta__ = PluginMetadata(
+    name="群聊记忆",
+    description="为群聊提供共享长期记忆、点名对话和按群概率回复",
+    usage=(
+        "在群聊中 @机器人 或回复机器人的消息即可对话。\n"
+        "SUPERUSER：/回复概率 [0~100] 查询或设置当前群随机回复概率；"
+        "/清空群记忆 清除当前群聊天记录与长期记忆。"
+    ),
+    type="application",
+    homepage="https://github.com/TonyLiangP2010405/nonebot-plugin-group-chat-memory",
+    config=Config,
+    supported_adapters={"~onebot.v11"},
+)
+
+try:
+    get_driver()
+except ValueError:
+    pass  # 允许在 NoneBot 初始化前单独导入模块
+else:
+    require("nonebot_plugin_localstore")
+    from . import handlers as handlers

nonebot_plugin_group_chat_memory/api.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import asyncio
+import math
+from typing import Any
+
+import httpx
+
+from .config import Config
+from .context import build_chat_messages
+from .models import ChatContext
+
+CHAT_RETRY_DELAYS: tuple[float, ...] = (0.5, 1.0)
+
+
+class ModelAPIError(RuntimeError):
+    """模型 API 调用失败；异常消息只包含状态或原因，不含密钥与响应正文。"""
+
+
+class EmbeddingAPIError(ModelAPIError):
+    """Embedding 请求失败或响应不可用。"""
+
+
+class ChatAPIError(ModelAPIError):
+    """聊天请求失败或响应不可用。"""
+
+    def __init__(self, message: str, *, retryable: bool = False) -> None:
+        super().__init__(message)
+        self.retryable = retryable
+
+
+def _make_client(timeout: float) -> httpx.AsyncClient:
+    """为单次请求创建客户端，使聊天与 Embedding 各自使用独立超时。"""
+    return httpx.AsyncClient(timeout=timeout)
+
+
+def _endpoint(base_url: str, path: str) -> str:
+    return f"{base_url.rstrip('/')}/{path}"
+
+
+def _auth_headers(api_key: str) -> dict[str, str]:
+    return {"Authorization": f"Bearer {api_key.strip()}"}
+
+
+class EmbeddingClient:
+    """OpenAI 兼容 `/embeddings` 客户端，用于批量向量化。"""
+
+    def __init__(self, config: Config) -> None:
+        self._config = config
+
+    async def embed(self, texts: list[str]) -> list[list[float]]:
+        """批量向量化 texts，返回与输入顺序一致的向量；失败时抛出 EmbeddingAPIError。"""
+        if not texts:
+            return []
+        self._config.require_embedding_config()
+        payload = {"model": self._config.group_chat_memory_embedding_model, "input": list(texts)}
+        response = await self._post(payload)
+        return self._parse(response, len(texts))
+
+    async def _post(self, payload: dict[str, Any]) -> httpx.Response:
+        url = _endpoint(self._config.group_chat_memory_embedding_base_url, "embeddings")
+        headers = _auth_headers(self._config.group_chat_memory_embedding_api_key.get_secret_value())
+        timeout = self._config.group_chat_memory_embedding_timeout
+        try:
+            async with _make_client(timeout) as client:
+                response = await client.post(url, json=payload, headers=headers)
+        except httpx.TimeoutException as exc:
+            raise EmbeddingAPIError("Embedding 请求超时。") from exc
+        except httpx.HTTPError as exc:
+            raise EmbeddingAPIError("Embedding 请求失败，无法连接服务。") from exc
+        if not 200 <= response.status_code < 300:
+            raise EmbeddingAPIError(f"Embedding 服务返回 HTTP {response.status_code}。")
+        return response
+
+    def _parse(self, response: httpx.Response, expected: int) -> list[list[float]]:
+        try:
+            payload = response.json()
+        except ValueError as exc:
+            raise EmbeddingAPIError("Embedding 响应不是合法 JSON。") from exc
+        data = payload.get("data") if isinstance(payload, dict) else None
+        if not isinstance(data, list) or not data:
+            raise EmbeddingAPIError("Embedding 响应缺少向量数据。")
+        if len(data) != expected:
+            raise EmbeddingAPIError(
+                f"Embedding 响应返回 {len(data)} 条向量，与请求的 {expected} 条不一致。"
+            )
+
+        ordered = sorted(
+            enumerate(data),
+            key=lambda item: _index_of(item[1], item[0]),
+        )
+        dimensions = self._config.group_chat_memory_embedding_dimensions
+        return [_parse_vector(item, dimensions) for _, item in ordered]
+
+
+class ChatClient:
+    """OpenAI 兼容 `/chat/completions` 客户端，带有限重试。"""
+
+    def __init__(
+        self,
+        config: Config,
+        *,
+        retry_delays: tuple[float, ...] = CHAT_RETRY_DELAYS,
+    ) -> None:
+        self._config = config
+        self._retry_delays = tuple(retry_delays)
+
+    async def complete(self, context: ChatContext, current_text: str) -> str:
+        """按上下文请求一条回复；瞬时失败按配置次数重试，最终失败抛出 ChatAPIError。"""
+        self._config.require_chat_config()
+        if not current_text.strip():
+            raise ChatAPIError("当前消息为空，无法请求聊天模型。")
+        payload = {
+            "model": self._config.group_chat_memory_chat_model,
+            "messages": build_chat_messages(self._config, context, current_text),
+        }
+
+        attempts = len(self._retry_delays) + 1
+        for attempt in range(attempts):
+            try:
+                response = await self._post(payload)
+            except ChatAPIError as exc:
+                if not exc.retryable or attempt + 1 >= attempts:
+                    raise
+                await asyncio.sleep(self._retry_delays[attempt])
+                continue
+            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())
+        timeout = self._config.group_chat_memory_chat_timeout
+        try:
+            async with _make_client(timeout) as client:
+                response = await client.post(url, json=payload, headers=headers)
+        except httpx.TimeoutException as exc:
+            raise ChatAPIError("聊天请求超时。", retryable=True) from exc
+        except httpx.HTTPError as exc:
+            raise ChatAPIError("聊天请求失败，无法连接服务。", retryable=True) from exc
+        if not 200 <= response.status_code < 300:
+            raise ChatAPIError(
+                f"聊天服务返回 HTTP {response.status_code}。",
+                retryable=response.status_code == 429 or response.status_code >= 500,
+            )
+        return response
+
+    @staticmethod
+    def _parse(response: httpx.Response) -> str:
+        try:
+            payload = response.json()
+        except ValueError as exc:
+            raise ChatAPIError("聊天响应不是合法 JSON。") from exc
+        choices = payload.get("choices") if isinstance(payload, dict) else None
+        if not isinstance(choices, list) or not choices:
+            raise ChatAPIError("聊天响应缺少 choices。")
+        message = choices[0].get("message") if isinstance(choices[0], dict) else None
+        content = message.get("content") if isinstance(message, dict) else None
+        if not isinstance(content, str) or not content.strip():
+            raise ChatAPIError("聊天响应缺少回复内容。")
+        return content.strip()
+
+
+def _index_of(item: Any, fallback: int) -> int:
+    index = item.get("index") if isinstance(item, dict) else None
+    if isinstance(index, int) and not isinstance(index, bool):
+        return index
+    return fallback
+
+
+def _parse_vector(item: Any, dimensions: int) -> list[float]:
+    vector = item.get("embedding") if isinstance(item, dict) else None
+    if not isinstance(vector, list):
+        raise EmbeddingAPIError("Embedding 响应缺少向量。")
+    if len(vector) != dimensions:
+        raise EmbeddingAPIError(f"Embedding 向量维度为 {len(vector)}，配置要求 {dimensions}。")
+    values: list[float] = []
+    for value in vector:
+        if isinstance(value, bool) or not isinstance(value, int | float):
+            raise EmbeddingAPIError("Embedding 向量包含非数值。")
+        number = float(value)
+        if not math.isfinite(number):
+            raise EmbeddingAPIError("Embedding 向量包含非有限数值。")
+        values.append(number)
+    return values

nonebot_plugin_group_chat_memory/config.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from nonebot import get_plugin_config
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+DEFAULT_DB_FILENAME = "group_chat_memory.db"
+
+DEFAULT_SYSTEM_PROMPT = (
+    "你是一个群聊助手。回答自然、简洁，像群友一样交流。"
+    "只使用提供的聊天记录和长期记忆，不要假装记得没有出现过的内容。"
+)
+
+RUNTIME_CONFIG_DEFAULTS = {
+    "chat_base_url": "",
+    "chat_api_key": "",
+    "chat_model": "deepseek-v4.1-flash",
+    "embedding_api_key": "",
+}
+
+
+class ConfigError(RuntimeError):
+    """功能所需的配置缺失时抛出。"""
+
+
+def _localstore_data_dir() -> Path:
+    from nonebot_plugin_localstore import get_plugin_data_dir
+
+    return get_plugin_data_dir()
+
+
+class Config(BaseModel):
+    """群聊记忆插件配置；四个模型运行时字段由私聊命令和数据库覆盖。"""
+
+    model_config = ConfigDict(extra="ignore")
+
+    group_chat_memory_chat_base_url: str = ""
+    group_chat_memory_chat_api_key: SecretStr = SecretStr("")
+    group_chat_memory_chat_model: str = "deepseek-v4.1-flash"
+    group_chat_memory_chat_timeout: float = Field(default=60.0, gt=0)
+
+    group_chat_memory_embedding_base_url: str = "https://api.siliconflow.cn/v1"
+    group_chat_memory_embedding_api_key: SecretStr = SecretStr("")
+    group_chat_memory_embedding_model: str = "BAAI/bge-m3"
+    group_chat_memory_embedding_dimensions: int = Field(default=1024, gt=0)
+    group_chat_memory_embedding_timeout: float = Field(default=10.0, gt=0)
+    group_chat_memory_query_timeout: float = Field(default=3.0, gt=0)
+
+    group_chat_memory_db_path_override: str | None = None
+
+    group_chat_memory_recent_messages: int = Field(default=20, ge=1)
+    group_chat_memory_chunk_size: int = Field(default=10, ge=1)
+    group_chat_memory_long_term_memories: int = Field(default=5, ge=0)
+    group_chat_memory_context_max_chars: int = Field(default=6000, ge=1)
+    group_chat_memory_default_probability: float = Field(default=0.0, ge=0.0, le=100.0)
+    group_chat_memory_ignored_qq: set[int] = Field(default_factory=set)
+    group_chat_memory_system_prompt: str = DEFAULT_SYSTEM_PROMPT
+
+    @property
+    def database_path(self) -> Path:
+        """数据库文件路径；未配置时使用 localstore 的插件数据目录。"""
+        configured = (self.group_chat_memory_db_path_override or "").strip()
+        if configured:
+            return Path(configured).expanduser()
+        return _localstore_data_dir() / DEFAULT_DB_FILENAME
+
+    def apply_runtime_config(self, values: dict[str, str]) -> None:
+        """应用数据库中的四项全局配置，未保存的字段恢复内置默认值。"""
+        for key, default in RUNTIME_CONFIG_DEFAULTS.items():
+            value = values.get(key, default)
+            if key == "chat_base_url":
+                self.group_chat_memory_chat_base_url = value
+            elif key == "chat_api_key":
+                self.group_chat_memory_chat_api_key = SecretStr(value)
+            elif key == "chat_model":
+                self.group_chat_memory_chat_model = value
+            elif key == "embedding_api_key":
+                self.group_chat_memory_embedding_api_key = SecretStr(value)
+
+    def require_chat_config(self) -> None:
+        """检查聊天模型配置，仅在真正调用聊天功能时使用。"""
+        missing = self._missing(
+            ("GROUP_CHAT_MEMORY_CHAT_BASE_URL", self.group_chat_memory_chat_base_url),
+            (
+                "GROUP_CHAT_MEMORY_CHAT_API_KEY",
+                self.group_chat_memory_chat_api_key.get_secret_value(),
+            ),
+            ("GROUP_CHAT_MEMORY_CHAT_MODEL", self.group_chat_memory_chat_model),
+        )
+        if missing:
+            raise ConfigError(f"聊天模型未配置，请设置：{'、'.join(missing)}")
+
+    def require_embedding_config(self) -> None:
+        """检查 Embedding 配置，仅在真正调用向量化功能时使用。"""
+        missing = self._missing(
+            (
+                "GROUP_CHAT_MEMORY_EMBEDDING_BASE_URL",
+                self.group_chat_memory_embedding_base_url,
+            ),
+            (
+                "GROUP_CHAT_MEMORY_EMBEDDING_API_KEY",
+                self.group_chat_memory_embedding_api_key.get_secret_value(),
+            ),
+            ("GROUP_CHAT_MEMORY_EMBEDDING_MODEL", self.group_chat_memory_embedding_model),
+        )
+        if missing:
+            raise ConfigError(f"Embedding 未配置，请设置：{'、'.join(missing)}")
+
+    @staticmethod
+    def _missing(*items: tuple[str, str]) -> list[str]:
+        return [name for name, value in items if not value.strip()]
+
+
+def get_settings() -> Config:
+    """从 NoneBot 全局配置读取本插件配置。"""
+    return get_plugin_config(Config)

nonebot_plugin_group_chat_memory/context.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING
+
+from .config import Config
+from .models import ChatContext, Chunk, Message
+from .store import MemoryStore
+
+if TYPE_CHECKING:
+    from .api import EmbeddingClient
+
+logger = logging.getLogger(__name__)
+
+MEMORY_SECTION_TITLE = "## 长期记忆（较早的相关片段）"
+RECENT_SECTION_TITLE = "## 最近群聊（从旧到新）"
+CURRENT_SECTION_TITLE = "## 当前消息"
+MEMBER_LABEL = "群友"
+BOT_LABEL = "Bot"
+SPEAKER_GUIDE = (
+    "聊天记录中的「群友」是群里的其他人，「Bot」或「(bot)」标记的都是你自己之前说过的话。"
+    "只回复「当前消息」，不要替其他群友发言，也不要编造记录中没有出现过的内容。"
+)
+TRUNCATION_MARK = "…"
+
+
+class ContextBuilder:
+    """并行读取当前群的最近消息与长期记忆；长期记忆失败时降级为最近消息。"""
+
+    def __init__(self, config: Config, store: MemoryStore, embedding: EmbeddingClient) -> None:
+        self._config = config
+        self._store = store
+        self._embedding = embedding
+
+    async def build(self, group_id: int, query: str) -> ChatContext:
+        """构建一次回复所需的上下文；Embedding 或检索失败不影响最近消息。"""
+        recent, chunks = await asyncio.gather(
+            self._store.recent_messages(group_id, self._config.group_chat_memory_recent_messages),
+            self._long_term_chunks(group_id, query),
+        )
+        return ChatContext(recent_messages=recent, long_term_chunks=chunks)
+
+    async def _long_term_chunks(self, group_id: int, query: str) -> list[Chunk]:
+        """在独立短超时内完成查询向量与检索，超时或失败都降级为空列表。"""
+        limit = self._config.group_chat_memory_long_term_memories
+        if limit < 1 or not query.strip():
+            return []
+        try:
+            return await asyncio.wait_for(
+                self._lookup_long_term(group_id, query, limit),
+                timeout=self._config.group_chat_memory_query_timeout,
+            )
+        except Exception as exc:
+            logger.warning("长期记忆检索失败，仅使用最近消息：%s: %s", type(exc).__name__, exc)
+            return []
+
+    async def _lookup_long_term(self, group_id: int, query: str, limit: int) -> list[Chunk]:
+        vectors = await self._embedding.embed([query])
+        if not vectors:
+            return []
+        return await self._store.search(group_id, vectors[0], limit)
+
+
+def build_chat_messages(
+    config: Config, context: ChatContext, current_text: str
+) -> list[dict[str, str]]:
+    """组装 OpenAI 兼容 messages：系统提示 + 长期记忆 + 最近消息 + 当前输入。
+
+    字符预算优先保证当前输入完整，其次保留最近消息，最后才放长期记忆。
+    """
+    budget = config.group_chat_memory_context_max_chars
+    current_block = f"{CURRENT_SECTION_TITLE}\n{MEMBER_LABEL}: {current_text.strip()}"
+    remaining = max(budget - len(current_block), 0)
+
+    recent_lines = _take_recent_lines(context.recent_messages, remaining)
+    remaining -= sum(len(line) for line in recent_lines) + max(len(recent_lines) - 1, 0)
+
+    memory_blocks = _take_chunk_blocks(
+        context.long_term_chunks,
+        config.group_chat_memory_long_term_memories,
+        max(remaining, 0),
+    )
+
+    sections: list[str] = []
+    if memory_blocks:
+        sections.append(f"{MEMORY_SECTION_TITLE}\n" + "\n\n".join(memory_blocks))
+    if recent_lines:
+        sections.append(f"{RECENT_SECTION_TITLE}\n" + "\n".join(recent_lines))
+    sections.append(current_block)
+
+    system_prompt = "\n\n".join(
+        part for part in (config.group_chat_memory_system_prompt.strip(), SPEAKER_GUIDE) if part
+    )
+    return [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": "\n\n".join(sections)},
+    ]
+
+
+def _take_recent_lines(messages: list[Message], budget: int) -> list[str]:
+    """从最新消息往前取，放不下时截断最后一条，返回从旧到新的行。"""
+    lines: list[str] = []
+    used = 0
+    for message in reversed(messages):
+        line = _format_message(message)
+        separator = 1 if lines else 0
+        available = budget - used - separator
+        if available <= 0:
+            break
+        if len(line) > available:
+            line = line[: available - 1] + TRUNCATION_MARK if available >= 2 else line[:available]
+        lines.append(line)
+        used += len(line) + separator
+        if used >= budget:
+            break
+    lines.reverse()
+    return lines
+
+
+def _take_chunk_blocks(chunks: list[Chunk], limit: int, budget: int) -> list[str]:
+    """按相关度顺序取最多 limit 个片段，放不下时停止，保留更高优先级的最近消息。"""
+    blocks: list[str] = []
+    used = 0
+    for chunk in chunks[: max(limit, 0)]:
+        text = chunk.text.strip()
+        if not text:
+            continue
+        separator = 2 if blocks else 0
+        if used + len(text) + separator > budget:
+            break
+        blocks.append(text)
+        used += len(text) + separator
+    return blocks
+
+
+def _format_message(message: Message) -> str:
+    created_at = _as_utc(message.created_at)
+    label = BOT_LABEL if message.is_bot else MEMBER_LABEL
+    name = message.display_name.strip() or str(message.user_id)
+    return f"[{created_at:%Y-%m-%d %H:%M}] {label} {name}: {message.text.strip()}"
+
+
+def _as_utc(value: datetime) -> datetime:
+    if value.tzinfo is None:
+        return value.replace(tzinfo=timezone.utc)
+    return value.astimezone(timezone.utc)