移除残留的KnowU系统，修复gemini请求的思考签名问题

.gitignore

@@ -6,7 +6,6 @@ data/
 !pytests/A_memorix_test/data/real_dialogues/private_alice_weekend.json
 pytests/A_memorix_test/data/benchmarks/results/
 data1/
-mai_knowledge/knowledge.json
 mongodb/
 NapCat.Framework.Windows.Once/
 NapCat.Framework.Windows.OneKey/

pytests/test_gemini_thought_signatures.py

@@ -0,0 +1,72 @@
+import base64
+import sys
+from types import ModuleType, SimpleNamespace
+
+
+config_module = ModuleType("src.config.config")
+
+
+class _ConfigManagerStub:
+    def get_model_config(self) -> SimpleNamespace:
+        return SimpleNamespace(api_providers=[])
+
+    def register_reload_callback(self, _: object) -> None:
+        return None
+
+
+config_module.config_manager = _ConfigManagerStub()
+sys.modules.setdefault("src.config.config", config_module)
+
+from src.llm_models.model_client import gemini_client
+from src.llm_models.payload_content.message import MessageBuilder, RoleType
+from src.llm_models.payload_content.tool_option import ToolCall
+
+
+def _encode_signature(value: bytes) -> str:
+    return base64.b64encode(value).decode("ascii")
+
+
+def test_convert_messages_preserves_gemini_function_call_signature_and_tool_result_id() -> None:
+    thought_signature = b"gemini-signature"
+    tool_call = ToolCall(
+        call_id="call-1",
+        func_name="reply",
+        args={"msg_id": "42"},
+        extra_content={"google": {"thought_signature": _encode_signature(thought_signature)}},
+    )
+    assistant_message = MessageBuilder().set_role(RoleType.Assistant).set_tool_calls([tool_call]).build()
+    tool_message = (
+        MessageBuilder()
+        .set_role(RoleType.Tool)
+        .set_tool_call_id("call-1")
+        .set_tool_name("reply")
+        .add_text_content('{"ok": true}')
+        .build()
+    )
+
+    contents, _ = gemini_client._convert_messages([assistant_message, tool_message])
+
+    assistant_part = contents[0].parts[0]
+    assert assistant_part.function_call is not None
+    assert assistant_part.function_call.id == "call-1"
+    assert assistant_part.function_call.name == "reply"
+    assert assistant_part.thought_signature == thought_signature
+
+    tool_part = contents[1].parts[0]
+    assert tool_part.function_response is not None
+    assert tool_part.function_response.id == "call-1"
+    assert tool_part.function_response.name == "reply"
+    assert tool_part.function_response.response == {"ok": True}
+
+
+def test_convert_messages_injects_dummy_signature_for_first_historical_tool_call() -> None:
+    tool_calls = [
+        ToolCall(call_id="call-1", func_name="reply", args={"msg_id": "1"}),
+        ToolCall(call_id="call-2", func_name="reply", args={"msg_id": "2"}),
+    ]
+    assistant_message = MessageBuilder().set_role(RoleType.Assistant).set_tool_calls(tool_calls).build()
+
+    contents, _ = gemini_client._convert_messages([assistant_message])
+
+    assert contents[0].parts[0].thought_signature == gemini_client.GEMINI_FALLBACK_THOUGHT_SIGNATURE
+    assert contents[0].parts[1].thought_signature is None

src/common/data_models/llm_service_data_models.py

@@ -135,6 +135,7 @@ class LLMServiceResult(BaseDataModel):
                         "name": tool_call.func_name,
                         "arguments": tool_call.args or {},
                     },
+                    **({"extra_content": tool_call.extra_content} if tool_call.extra_content else {}),
                 }
                 for tool_call in self.completion.tool_calls
             ]

src/common/database/database_model.py

@@ -221,22 +221,6 @@ class Jargon(SQLModel, table=True):
     inference_with_content_only: Optional[str] = Field(
         default=None, sa_column=Column(Text, nullable=True)
     )  # 只基于词条的推断结果，JSON格式
-
-
-class MaiKnowledge(SQLModel, table=True):
-    """存储 Maisaka 的用户画像知识。"""
-
-    __tablename__ = "mai_knowledge"  # type: ignore
-
-    id: Optional[int] = Field(default=None, primary_key=True)
-    knowledge_id: str = Field(index=True, max_length=255)
-    category_id: str = Field(index=True, max_length=32)
-    content: str
-    normalized_content: str = Field(index=True)
-    metadata_json: Optional[str] = Field(default=None, nullable=True)
-    created_at: datetime = Field(default_factory=datetime.now, sa_column=Column(DateTime, index=True))
-
-
 class ChatHistory(SQLModel, table=True):
     """存储聊天历史记录的模型"""
 

src/common/database/migrations/frozen_v2_schema.py

@@ -138,18 +138,6 @@ _V2_TABLE_STATEMENTS = (
     )
     """,
     """
-    CREATE TABLE IF NOT EXISTS mai_knowledge (
-        id INTEGER NOT NULL,
-        knowledge_id VARCHAR(255) NOT NULL,
-        category_id VARCHAR(32) NOT NULL,
-        content VARCHAR NOT NULL,
-        normalized_content VARCHAR NOT NULL,
-        metadata_json VARCHAR,
-        created_at DATETIME,
-        PRIMARY KEY (id)
-    )
-    """,
-    """
     CREATE TABLE IF NOT EXISTS mai_messages (
         id INTEGER NOT NULL,
         message_id VARCHAR(255) NOT NULL,
@@ -260,10 +248,6 @@ _V2_INDEX_STATEMENTS = (
     "CREATE INDEX IF NOT EXISTS ix_llm_usage_model_assign_name ON llm_usage (model_assign_name)",
     "CREATE INDEX IF NOT EXISTS ix_llm_usage_model_name ON llm_usage (model_name)",
     "CREATE INDEX IF NOT EXISTS ix_llm_usage_timestamp ON llm_usage (timestamp)",
-    "CREATE INDEX IF NOT EXISTS ix_mai_knowledge_category_id ON mai_knowledge (category_id)",
-    "CREATE INDEX IF NOT EXISTS ix_mai_knowledge_created_at ON mai_knowledge (created_at)",
-    "CREATE INDEX IF NOT EXISTS ix_mai_knowledge_knowledge_id ON mai_knowledge (knowledge_id)",
-    "CREATE INDEX IF NOT EXISTS ix_mai_knowledge_normalized_content ON mai_knowledge (normalized_content)",
     "CREATE INDEX IF NOT EXISTS ix_mai_messages_group_id ON mai_messages (group_id)",
     "CREATE INDEX IF NOT EXISTS ix_mai_messages_message_id ON mai_messages (message_id)",
     "CREATE INDEX IF NOT EXISTS ix_mai_messages_platform ON mai_messages (platform)",

src/config/config.py

@@ -56,7 +56,7 @@ CONFIG_DIR: Path = PROJECT_ROOT / "config"
 BOT_CONFIG_PATH: Path = (CONFIG_DIR / "bot_config.toml").resolve().absolute()
 MODEL_CONFIG_PATH: Path = (CONFIG_DIR / "model_config.toml").resolve().absolute()
 MMC_VERSION: str = "1.0.0"
-CONFIG_VERSION: str = "8.4.1"
+CONFIG_VERSION: str = "8.5.0"
 MODEL_CONFIG_VERSION: str = "1.13.1"
 
 logger = get_logger("config")

src/config/official_configs.py

@@ -1456,15 +1456,6 @@ class MaiSakaConfig(ConfigBase):
 
     __ui_label__ = "MaiSaka"
     __ui_icon__ = "message-circle"
-
-    enable_knowledge_module: bool = Field(
-        default=True,
-        json_schema_extra={
-            "x-widget": "switch",
-            "x-icon": "book",
-        },
-    )
-    """启用知识库模块"""
     cli_user_name: str = Field(
         default="用户",
         json_schema_extra={

src/core/types.py

@@ -315,6 +315,9 @@ class MaiMessages:
                             call_id=str(tool_call.get("call_id", "")),
                             func_name=str(tool_call.get("func_name", "")),
                             args=tool_call.get("args"),
+                            extra_content=tool_call.get("extra_content")
+                            if isinstance(tool_call.get("extra_content"), dict)
+                            else None,
                         )
                     )
             return deserialized_tool_calls

src/know_u/__init__.py

@@ -1,3 +0,0 @@
-"""
-Knowledge utilities package for Maisaka.
-"""

src/know_u/knowledge.py

@@ -1,363 +0,0 @@
-"""
-Maisaka knowledge retrieval and learning helpers.
-"""
-
-from typing import Any, Dict, List
-
-import asyncio
-import json
-
-from src.chat.message_receive.message import SessionMessage
-from src.chat.utils.utils import is_bot_self
-from src.common.data_models.llm_service_data_models import LLMGenerationOptions
-from src.common.logger import get_logger
-from src.know_u.knowledge_store import KNOWLEDGE_CATEGORIES, get_knowledge_store
-from src.maisaka.context_messages import AssistantMessage, LLMContextMessage, SessionBackedMessage, ToolResultMessage
-from src.maisaka.message_adapter import parse_speaker_content
-from src.person_info.person_info import Person
-from src.services.llm_service import LLMServiceClient
-
-logger = get_logger("maisaka_knowledge")
-
-NO_RESULT_KEYWORDS = [
-    "无",
-    "没有",
-    "不适用",
-    "无需",
-    "无相关",
-]
-
-
-def extract_category_ids_from_result(result: str) -> List[str]:
-    """Extract valid category ids from an LLM result string."""
-    if not result:
-        return []
-
-    normalized = result.strip()
-    if not normalized:
-        return []
-
-    lowered = normalized.lower()
-    if any(keyword in lowered for keyword in ["none", "no relevant", "no_need", "no need"]):
-        return []
-    if any(keyword in normalized for keyword in NO_RESULT_KEYWORDS):
-        return []
-
-    category_ids: List[str] = []
-    for part in normalized.replace(",", " ").replace("，", " ").replace("\n", " ").split():
-        candidate = part.strip()
-        if candidate in KNOWLEDGE_CATEGORIES and candidate not in category_ids:
-            category_ids.append(candidate)
-
-    return category_ids
-
-
-async def retrieve_relevant_knowledge(
-    knowledge_analyzer: Any,
-    chat_history: List[LLMContextMessage],
-) -> str:
-    """Retrieve formatted knowledge snippets relevant to the current chat history."""
-    store = get_knowledge_store()
-    categories_summary = store.get_categories_summary()
-
-    try:
-        category_ids = await knowledge_analyzer.analyze_knowledge_need(chat_history, categories_summary)
-        if not category_ids:
-            return ""
-        return store.get_formatted_knowledge(category_ids)
-    except Exception:
-        logger.exception("检索相关知识失败")
-        return ""
-
-
-class KnowledgeLearner:
-    """
-    从最近对话中提取用户画像类知识并写入知识库。
-    """
-
-    def __init__(self, session_id: str) -> None:
-        self._session_id = session_id
-        self._store = get_knowledge_store()
-        self._llm = LLMServiceClient(task_name="utils", request_type="maisaka.knowledge.learn")
-        self._learning_lock = asyncio.Lock()
-        self._last_processed_index = 0
-        self.min_messages_for_extraction = 10
-
-    def get_pending_count(self, message_cache: List[SessionMessage]) -> int:
-        """??????????????"""
-        return max(0, len(message_cache) - self._last_processed_index)
-
-    async def learn(self, message_cache: List[SessionMessage]) -> int:
-        """?????????????????????"""
-        pending_messages = message_cache[self._last_processed_index :]
-        if not pending_messages:
-            return 0
-        if len(pending_messages) < self.min_messages_for_extraction:
-            return 0
-
-        async with self._learning_lock:
-            chat_excerpt = self._build_chat_excerpt(pending_messages)
-            if not chat_excerpt:
-                return 0
-
-            prompt = self._build_learning_prompt(chat_excerpt)
-            try:
-                result = await self._llm.generate_response(
-                    prompt=prompt,
-                    options=LLMGenerationOptions(
-                        temperature=0.1,
-                        max_tokens=512,
-                    ),
-                )
-            except Exception:
-                logger.exception("??????????")
-                return 0
-
-            knowledge_items = self._parse_learning_result(result.response or "")
-            if not knowledge_items:
-                logger.debug("?????????????????")
-                self._last_processed_index = len(message_cache)
-                return 0
-
-            added_count = 0
-            for item in knowledge_items:
-                category_id = str(item.get("category_id", "")).strip()
-                content = str(item.get("content", "")).strip()
-                if not category_id or not content:
-                    continue
-
-                metadata = {
-                    "session_id": self._session_id,
-                    "source": "maisaka_learning",
-                }
-                for field_name in ("platform", "user_id", "user_nickname", "person_name"):
-                    field_value = str(item.get(field_name, "")).strip()
-                    if field_value:
-                        metadata[field_name] = field_value
-
-                if self._store.add_knowledge(
-                    category_id=category_id,
-                    content=content,
-                    metadata=metadata,
-                ):
-                    added_count += 1
-
-            self._last_processed_index = len(message_cache)
-
-            if added_count > 0:
-                logger.info(
-                    f"Maisaka ???????: ????={self._session_id} ????={added_count}"
-                )
-            else:
-                logger.debug(
-                    f"Maisaka ???????????????: ????={self._session_id}"
-                )
-
-            return added_count
-
-    def _build_chat_excerpt(self, messages: List[SessionMessage]) -> str:
-        """
-        构建适合画像提取的对话片段，只保留用户可见文本。
-        """
-        lines: List[str] = []
-        for message in messages[-30:]:
-            if isinstance(message, (AssistantMessage, ToolResultMessage)):
-                continue
-            if isinstance(message, SessionBackedMessage):
-                if message.original_message and is_bot_self(
-                    message.original_message.platform,
-                    message.original_message.message_info.user_info.user_id,
-                ):
-                    continue
-                raw_text = message.processed_plain_text.strip()
-                fallback_speaker = (
-                    message.original_message.message_info.user_info.user_nickname
-                    if message.original_message is not None
-                    else "用户"
-                )
-            else:
-                if is_bot_self(message.platform, message.message_info.user_info.user_id):
-                    continue
-                raw_text = message.processed_plain_text.strip()
-                fallback_speaker = message.message_info.user_info.user_nickname or "用户"
-
-            if not raw_text:
-                continue
-
-            speaker_name, body = parse_speaker_content(raw_text)
-            visible_text = (body or raw_text).strip()
-            if not visible_text:
-                continue
-
-            speaker = speaker_name or fallback_speaker
-            user_metadata = self._extract_message_user_metadata(message)
-            metadata_parts = [
-                f"platform={user_metadata['platform'] or 'unknown'}",
-                f"user_id={user_metadata['user_id'] or 'unknown'}",
-                f"user_nickname={user_metadata['user_nickname'] or speaker}",
-                f"person_name={user_metadata['person_name'] or ''}",
-            ]
-            lines.append(
-                f"[用户信息] {'; '.join(metadata_parts)}\n"
-                f"[发言] {speaker}: {visible_text}"
-            )
-
-        return "\n".join(lines)
-
-    @staticmethod
-    def _extract_message_user_metadata(message: SessionMessage) -> Dict[str, str]:
-        """提取消息对应的用户元信息。"""
-        source_message = message.original_message if isinstance(message, SessionBackedMessage) else message
-        platform = str(getattr(source_message, "platform", "") or "").strip()
-        user_info = getattr(getattr(source_message, "message_info", None), "user_info", None)
-        user_id = str(getattr(user_info, "user_id", "") or "").strip()
-        user_nickname = str(getattr(user_info, "user_nickname", "") or "").strip()
-
-        person_name = ""
-        if platform and user_id:
-            try:
-                person = Person(platform=platform, user_id=user_id)
-                if person.is_known and person.person_name:
-                    person_name = str(person.person_name).strip()
-            except Exception:
-                person_name = ""
-
-        return {
-            "platform": platform,
-            "user_id": user_id,
-            "user_nickname": user_nickname,
-            "person_name": person_name,
-        }
-
-    def _build_learning_prompt(self, chat_excerpt: str) -> str:
-        """构建知识提取提示词。"""
-        categories_text = "\n".join(
-            f"{category_id}. {category_name}" for category_id, category_name in KNOWLEDGE_CATEGORIES.items()
-        )
-        return (
-            "你是一个用户画像知识提取器，需要从聊天记录里提取稳定、可复用的用户事实。\n"
-            "只提取用户明确表达或高置信度可归纳的信息，不要猜测，不要提取一次性情绪，不要重复表述。\n"
-            "如果没有可提取内容，返回空数组 []。\n"
-            "输出必须是 JSON 数组，每项格式为 "
-            '{"category_id":"分类编号","content":"简洁中文陈述"}。\n'
-            "分类如下：\n"
-            f"{categories_text}\n\n"
-            "聊天记录：\n"
-            f"{chat_excerpt}"
-        )
-
-    def _parse_learning_result(self, result: str) -> List[Dict[str, str]]:
-        """解析模型返回的知识条目。"""
-        normalized = result.strip()
-        if not normalized:
-            return []
-
-        if "```" in normalized:
-            normalized = normalized.replace("```json", "").replace("```JSON", "").replace("```", "").strip()
-
-        try:
-            parsed = json.loads(normalized)
-        except json.JSONDecodeError:
-            logger.warning("知识学习结果不是有效的 JSON")
-            return []
-
-        if not isinstance(parsed, list):
-            return []
-
-        normalized_items: List[Dict[str, str]] = []
-        seen_pairs: set[tuple[str, str]] = set()
-        for item in parsed:
-            if not isinstance(item, dict):
-                continue
-
-            category_id = str(item.get("category_id", "")).strip()
-            content = " ".join(str(item.get("content", "")).strip().split())
-            if category_id not in KNOWLEDGE_CATEGORIES:
-                continue
-            if not content:
-                continue
-
-            pair = (category_id, content)
-            if pair in seen_pairs:
-                continue
-            seen_pairs.add(pair)
-            normalized_items.append(
-                {
-                    "category_id": category_id,
-                    "content": content,
-                }
-            )
-
-        return normalized_items
-
-    def _build_learning_prompt(self, chat_excerpt: str) -> str:
-        """构建知识提取提示词。"""
-        categories_text = "\n".join(
-            f"{category_id}. {category_name}" for category_id, category_name in KNOWLEDGE_CATEGORIES.items()
-        )
-        return (
-            "你是一个用户画像知识提取器，需要从聊天记录里提取稳定、可复用的用户事实。\n"
-            "聊天记录每条发言前都带有用户元信息，你必须明确判断这些特征属于哪个用户。\n"
-            "只提取用户明确表达或高置信度可归纳的信息，不要猜测，不要提取一次性情绪，不要重复表达。\n"
-            "如果没有可提取内容，返回空数组[]。\n"
-            "输出必须是 JSON 数组，每项格式为 "
-            '{"category_id":"分类编号","content":"简洁中文陈述","platform":"平台","user_id":"用户ID","user_nickname":"用户昵称","person_name":"人物名或空字符串"}。\n'
-            "其中 platform 和 user_id 必填；user_nickname 尽量填写；person_name 仅在用户信息中明确给出时填写，否则填空字符串。\n"
-            "同一条知识只能归属到一个用户，不要混合不同人的信息。\n"
-            "分类如下：\n"
-            f"{categories_text}\n\n"
-            "聊天记录：\n"
-            f"{chat_excerpt}"
-        )
-
-    def _parse_learning_result(self, result: str) -> List[Dict[str, str]]:
-        """解析模型返回的知识条目。"""
-        normalized = result.strip()
-        if not normalized:
-            return []
-
-        if "```" in normalized:
-            normalized = normalized.replace("```json", "").replace("```JSON", "").replace("```", "").strip()
-
-        try:
-            parsed = json.loads(normalized)
-        except json.JSONDecodeError:
-            logger.warning("知识学习结果不是有效的 JSON")
-            return []
-
-        if not isinstance(parsed, list):
-            return []
-
-        normalized_items: List[Dict[str, str]] = []
-        seen_pairs: set[tuple[str, str, str, str]] = set()
-        for item in parsed:
-            if not isinstance(item, dict):
-                continue
-
-            category_id = str(item.get("category_id", "")).strip()
-            content = " ".join(str(item.get("content", "")).strip().split())
-            platform = str(item.get("platform", "")).strip()
-            user_id = str(item.get("user_id", "")).strip()
-            user_nickname = str(item.get("user_nickname", "")).strip()
-            person_name = str(item.get("person_name", "")).strip()
-            if category_id not in KNOWLEDGE_CATEGORIES:
-                continue
-            if not content or not platform or not user_id:
-                continue
-
-            pair = (category_id, content, platform, user_id)
-            if pair in seen_pairs:
-                continue
-            seen_pairs.add(pair)
-            normalized_items.append(
-                {
-                    "category_id": category_id,
-                    "content": content,
-                    "platform": platform,
-                    "user_id": user_id,
-                    "user_nickname": user_nickname,
-                    "person_name": person_name,
-                }
-            )
-
-        return normalized_items

src/know_u/knowledge_store.py

@@ -1,370 +0,0 @@
-"""
-MaiSaka knowledge store.
-"""
-
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-import json
-
-from sqlmodel import col, select
-
-from src.common.database.database import DATABASE_URL, get_db_session
-from src.common.database.database_model import MaiKnowledge
-
-PROJECT_ROOT = Path(__file__).resolve().parents[2]
-KNOWLEDGE_DATA_DIR = PROJECT_ROOT / "mai_knowledge"
-KNOWLEDGE_FILE = KNOWLEDGE_DATA_DIR / "knowledge.json"
-
-
-KNOWLEDGE_CATEGORIES = {
-    "1": "性别",
-    "2": "性格",
-    "3": "饮食口味",
-    "4": "交友偏好",
-    "5": "情绪/理性倾向",
-    "6": "兴趣爱好",
-    "7": "职业/专业",
-    "8": "生活习惯",
-    "9": "价值观",
-    "10": "沟通风格",
-    "11": "学习方式",
-    "12": "压力应对方式",
-}
-
-
-class KnowledgeStore:
-    """存储 Maisaka 的用户画像知识。"""
-
-    def __init__(self) -> None:
-        """初始化知识存储，并在需要时迁移旧版 JSON 数据。"""
-        self._ensure_legacy_data_dir()
-        self._migrate_legacy_file_if_needed()
-
-    def _ensure_legacy_data_dir(self) -> None:
-        """确保旧版知识目录存在，便于兼容历史数据。"""
-        KNOWLEDGE_DATA_DIR.mkdir(parents=True, exist_ok=True)
-
-    @staticmethod
-    def _normalize_content(content: str) -> str:
-        """标准化知识内容，便于去重。"""
-        return " ".join(str(content).strip().split())
-
-    @staticmethod
-    def _serialize_metadata(metadata: Optional[Dict[str, Any]]) -> Optional[str]:
-        """将元数据序列化为 JSON 文本。"""
-        if not metadata:
-            return None
-        return json.dumps(metadata, ensure_ascii=False, sort_keys=True)
-
-    @staticmethod
-    def _deserialize_metadata(raw_text: Optional[str]) -> Dict[str, Any]:
-        """将 JSON 文本反序列化为元数据字典。"""
-        if not raw_text:
-            return {}
-        try:
-            parsed = json.loads(raw_text)
-        except json.JSONDecodeError:
-            return {}
-        return parsed if isinstance(parsed, dict) else {}
-
-    @staticmethod
-    def _parse_created_at(raw_value: Any) -> datetime:
-        """解析旧版数据中的创建时间。"""
-        if isinstance(raw_value, datetime):
-            return raw_value
-        if isinstance(raw_value, str):
-            raw_text = raw_value.strip()
-            if raw_text:
-                try:
-                    return datetime.fromisoformat(raw_text)
-                except ValueError:
-                    pass
-        return datetime.now()
-
-    @classmethod
-    def _build_item_dict(cls, record: MaiKnowledge) -> Dict[str, Any]:
-        """将数据库记录转换为兼容旧接口的字典。"""
-        return {
-            "id": record.knowledge_id,
-            "content": record.content,
-            "metadata": cls._deserialize_metadata(record.metadata_json),
-            "created_at": record.created_at.isoformat(),
-        }
-
-    def _load_legacy_knowledge_file(self) -> Dict[str, List[Dict[str, Any]]]:
-        """读取旧版 JSON 知识文件。"""
-        if not KNOWLEDGE_FILE.exists():
-            return {}
-
-        try:
-            with open(KNOWLEDGE_FILE, "r", encoding="utf-8") as file:
-                loaded = json.load(file)
-        except Exception:
-            return {}
-
-        if not isinstance(loaded, dict):
-            return {}
-
-        normalized_knowledge: Dict[str, List[Dict[str, Any]]] = {}
-        for category_id in KNOWLEDGE_CATEGORIES:
-            category_items = loaded.get(category_id, [])
-            if isinstance(category_items, list):
-                normalized_knowledge[category_id] = [
-                    item for item in category_items if isinstance(item, dict)
-                ]
-        return normalized_knowledge
-
-    def _migrate_legacy_file_if_needed(self) -> None:
-        """在数据库为空时，将旧版 JSON 中的知识导入数据库。"""
-        legacy_knowledge = self._load_legacy_knowledge_file()
-        if not legacy_knowledge:
-            return
-
-        with get_db_session(auto_commit=False) as session:
-            existing_record = session.exec(select(MaiKnowledge.id).limit(1)).first()
-            if existing_record is not None:
-                return
-
-            for category_id, items in legacy_knowledge.items():
-                if category_id not in KNOWLEDGE_CATEGORIES:
-                    continue
-
-                for item in items:
-                    content = self._normalize_content(str(item.get("content", "")))
-                    if not content:
-                        continue
-
-                    metadata = item.get("metadata")
-                    session.add(
-                        MaiKnowledge(
-                            knowledge_id=str(item.get("id") or f"know_{category_id}_{datetime.now().timestamp()}"),
-                            category_id=category_id,
-                            content=content,
-                            normalized_content=content,
-                            metadata_json=self._serialize_metadata(metadata if isinstance(metadata, dict) else None),
-                            created_at=self._parse_created_at(item.get("created_at")),
-                        )
-                    )
-
-            session.commit()
-
-    def add_knowledge(
-        self,
-        category_id: str,
-        content: str,
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> bool:
-        """添加一条知识信息。"""
-        if category_id not in KNOWLEDGE_CATEGORIES:
-            return False
-
-        normalized_content = self._normalize_content(content)
-        if not normalized_content:
-            return False
-
-        user_platform = str((metadata or {}).get("platform", "")).strip()
-        user_id = str((metadata or {}).get("user_id", "")).strip()
-        with get_db_session(auto_commit=False) as session:
-            existing_records = session.exec(
-                select(MaiKnowledge).where(
-                    MaiKnowledge.category_id == category_id,
-                    MaiKnowledge.normalized_content == normalized_content,
-                )
-            ).all()
-            for existing_record in existing_records:
-                existing_metadata = self._deserialize_metadata(existing_record.metadata_json)
-                existing_platform = str(existing_metadata.get("platform", "")).strip()
-                existing_user_id = str(existing_metadata.get("user_id", "")).strip()
-                if user_platform and user_id:
-                    if existing_platform == user_platform and existing_user_id == user_id:
-                        return False
-                    continue
-                if not existing_platform and not existing_user_id:
-                    return False
-
-            session.add(
-                MaiKnowledge(
-                    knowledge_id=f"know_{category_id}_{datetime.now().timestamp()}",
-                    category_id=category_id,
-                    content=normalized_content,
-                    normalized_content=normalized_content,
-                    metadata_json=self._serialize_metadata(metadata),
-                    created_at=datetime.now(),
-                )
-            )
-            session.commit()
-        return True
-
-    def search_knowledge(
-        self,
-        keyword: str,
-        limit: int = 10,
-    ) -> List[Dict[str, Any]]:
-        """按关键词搜索知识内容。"""
-        normalized_keyword = self._normalize_content(keyword)
-        if not normalized_keyword:
-            return []
-
-        limit_value = max(1, int(limit))
-        with get_db_session() as session:
-            records = session.exec(
-                select(MaiKnowledge)
-                .where(
-                    col(MaiKnowledge.content).contains(normalized_keyword)
-                    | col(MaiKnowledge.normalized_content).contains(normalized_keyword)
-                )
-                .order_by(MaiKnowledge.created_at.desc(), MaiKnowledge.id.desc())
-                .limit(limit_value)
-            ).all()
-
-        results: List[Dict[str, Any]] = []
-        for record in records:
-            item = self._build_item_dict(record)
-            item["category_id"] = record.category_id
-            item["category_name"] = self.get_category_name(record.category_id)
-            results.append(item)
-        return results
-
-    def get_knowledge_by_user(
-        self,
-        *,
-        platform: str = "",
-        user_id: str = "",
-        user_nickname: str = "",
-        person_name: str = "",
-        limit: int = 10,
-    ) -> List[Dict[str, Any]]:
-        """按用户元信息筛选知识条目。"""
-        platform = str(platform).strip()
-        user_id = str(user_id).strip()
-        user_nickname = str(user_nickname).strip()
-        person_name = str(person_name).strip()
-        if not any((platform, user_id, user_nickname, person_name)):
-            return []
-
-        limit_value = max(1, int(limit))
-        with get_db_session() as session:
-            records = session.exec(
-                select(MaiKnowledge).order_by(MaiKnowledge.created_at.desc(), MaiKnowledge.id.desc())
-            ).all()
-
-        results: List[Dict[str, Any]] = []
-        for record in records:
-            metadata = self._deserialize_metadata(record.metadata_json)
-            if user_id and str(metadata.get("user_id", "")).strip() != user_id:
-                continue
-            if platform and str(metadata.get("platform", "")).strip() != platform:
-                continue
-            if user_nickname and str(metadata.get("user_nickname", "")).strip() != user_nickname:
-                continue
-            if person_name and str(metadata.get("person_name", "")).strip() != person_name:
-                continue
-
-            item = self._build_item_dict(record)
-            item["category_id"] = record.category_id
-            item["category_name"] = self.get_category_name(record.category_id)
-            results.append(item)
-            if len(results) >= limit_value:
-                break
-
-        return results
-
-    def get_category_knowledge(self, category_id: str) -> List[Dict[str, Any]]:
-        """获取某个分类下的所有知识。"""
-        if category_id not in KNOWLEDGE_CATEGORIES:
-            return []
-
-        with get_db_session() as session:
-            records = session.exec(
-                select(MaiKnowledge)
-                .where(MaiKnowledge.category_id == category_id)
-                .order_by(MaiKnowledge.created_at.asc(), MaiKnowledge.id.asc())
-            ).all()
-        return [self._build_item_dict(record) for record in records]
-
-    def get_all_knowledge(self) -> Dict[str, List[Dict[str, Any]]]:
-        """获取全部知识。"""
-        all_knowledge: Dict[str, List[Dict[str, Any]]] = {
-            category_id: [] for category_id in KNOWLEDGE_CATEGORIES
-        }
-        with get_db_session() as session:
-            records = session.exec(
-                select(MaiKnowledge).order_by(
-                    MaiKnowledge.category_id.asc(),
-                    MaiKnowledge.created_at.asc(),
-                    MaiKnowledge.id.asc(),
-                )
-            ).all()
-
-        for record in records:
-            all_knowledge.setdefault(record.category_id, []).append(self._build_item_dict(record))
-        return all_knowledge
-
-    def get_category_name(self, category_id: str) -> str:
-        """获取分类名称。"""
-        return KNOWLEDGE_CATEGORIES.get(category_id, "未知分类")
-
-    def get_categories_summary(self) -> str:
-        """获取分类摘要，供模型判断是否需要检索。"""
-        counts: Dict[str, int] = {category_id: 0 for category_id in KNOWLEDGE_CATEGORIES}
-        with get_db_session() as session:
-            records = session.exec(select(MaiKnowledge.category_id)).all()
-
-        for category_id in records:
-            if category_id in counts:
-                counts[category_id] += 1
-
-        lines: List[str] = []
-        for category_id, category_name in KNOWLEDGE_CATEGORIES.items():
-            count = counts.get(category_id, 0)
-            count_text = f"{count}条" if count > 0 else "无数据"
-            lines.append(f"{category_id}. {category_name} ({count_text})")
-        return "\n".join(lines)
-
-    def get_formatted_knowledge(self, category_ids: List[str], limit_per_category: int = 5) -> str:
-        """获取指定分类的格式化知识内容。"""
-        parts: List[str] = []
-        for category_id in category_ids:
-            items = self.get_category_knowledge(category_id)
-            if not items:
-                continue
-
-            category_name = self.get_category_name(category_id)
-            parts.append(f"【{category_name}】")
-
-            recent_items = items[-limit_per_category:]
-            for item in recent_items:
-                content = str(item.get("content", "")).strip()
-                if content:
-                    parts.append(f"- {content}")
-
-        return "\n".join(parts)
-
-    def get_stats(self) -> Dict[str, Any]:
-        """获取知识数据统计。"""
-        with get_db_session() as session:
-            total_items = len(session.exec(select(MaiKnowledge.id)).all())
-
-        return {
-            "total_categories": len(KNOWLEDGE_CATEGORIES),
-            "total_items": total_items,
-            "data_file": DATABASE_URL,
-            "data_exists": True,
-            "data_size_kb": 0,
-            "legacy_data_file": str(KNOWLEDGE_FILE),
-            "legacy_data_exists": KNOWLEDGE_FILE.exists(),
-            "storage_type": "database",
-        }
-
-
-_knowledge_store_instance: Optional[KnowledgeStore] = None
-
-
-def get_knowledge_store() -> KnowledgeStore:
-    """获取知识存储单例。"""
-    global _knowledge_store_instance
-    if _knowledge_store_instance is None:
-        _knowledge_store_instance = KnowledgeStore()
-    return _knowledge_store_instance

src/llm_models/payload_content/tool_option.py

@@ -524,6 +524,7 @@ class ToolCall:
     call_id: str
     func_name: str
     args: Dict[str, Any] | None = None
+    extra_content: Dict[str, Any] | None = None
 
     def __post_init__(self) -> None:
         """执行工具调用的基础校验。

src/maisaka/builtin_tool/query_person_info.py

@@ -9,7 +9,6 @@ from sqlmodel import col, select
 from src.common.database.database import get_db_session
 from src.common.database.database_model import PersonInfo
 from src.core.tooling import ToolExecutionContext, ToolExecutionResult, ToolInvocation, ToolSpec
-from src.know_u.knowledge_store import get_knowledge_store
 
 from .context import BuiltinToolRuntimeContext
 
@@ -79,7 +78,6 @@ async def handle_tool(
     result: Dict[str, Any] = {
         "query": person_name,
         "persons": persons,
-        "related_knowledge": _query_related_knowledge(person_name, persons, limit),
     }
     return tool_ctx.build_success_result(
         invocation.tool_name,
@@ -129,55 +127,3 @@ def _query_person_records(person_name: str, limit: int) -> List[Dict[str, Any]]:
             )
 
         return persons
-
-
-def _query_related_knowledge(
-    person_name: str,
-    persons: List[Dict[str, Any]],
-    limit: int,
-) -> List[Dict[str, Any]]:
-    """从 Maisaka knowledge 中补充检索与该人物相关的条目。"""
-
-    store = get_knowledge_store()
-    knowledge_items: List[Dict[str, Any]] = []
-    seen_ids: set[str] = set()
-
-    for person in persons:
-        matched_items = store.get_knowledge_by_user(
-            platform=str(person.get("platform", "")).strip(),
-            user_id=str(person.get("user_id", "")).strip(),
-            user_nickname=str(person.get("user_nickname", "")).strip(),
-            person_name=str(person.get("person_name", "")).strip(),
-            limit=max(limit, 5),
-        )
-        for item in matched_items:
-            item_id = str(item.get("id", "")).strip()
-            if item_id and item_id in seen_ids:
-                continue
-            if item_id:
-                seen_ids.add(item_id)
-            knowledge_items.append(item)
-
-    if not knowledge_items:
-        fallback_items = store.search_knowledge(person_name, limit=max(limit, 5))
-        for item in fallback_items:
-            item_id = str(item.get("id", "")).strip()
-            if item_id and item_id in seen_ids:
-                continue
-            if item_id:
-                seen_ids.add(item_id)
-            knowledge_items.append(item)
-
-    results: List[Dict[str, Any]] = []
-    for item in knowledge_items:
-        results.append(
-            {
-                "id": str(item.get("id", "")).strip(),
-                "category_id": str(item.get("category_id", "")).strip(),
-                "category_name": str(item.get("category_name", "")).strip(),
-                "content": str(item.get("content", "")).strip(),
-                "metadata": item.get("metadata", {}),
-                "created_at": item.get("created_at"),
-            }
-        )
-    return results

src/maisaka/chat_loop_service.py

@@ -18,7 +18,6 @@ from src.common.prompt_i18n import load_prompt
 from src.common.utils.utils_session import SessionUtils
 from src.config.config import global_config
 from src.core.tooling import ToolRegistry, ToolSpec
-from src.know_u.knowledge import extract_category_ids_from_result
 from src.llm_models.model_client.base_client import BaseClient
 from src.llm_models.payload_content.message import Message, MessageBuilder, RoleType
 from src.llm_models.payload_content.resp_format import RespFormat, RespFormatType
@@ -665,41 +664,6 @@ class MaisakaChatLoopService:
         )
         return filtered_tool_specs
 
-    async def analyze_knowledge_need(
-        self,
-        chat_history: List[LLMContextMessage],
-        categories_summary: str,
-    ) -> List[str]:
-        """分析当前对话是否需要检索知识库分类。"""
-        visible_history: List[str] = []
-        for message in chat_history[-8:]:
-            if not message.processed_plain_text:
-                continue
-            visible_history.append(f"{message.role}: {message.processed_plain_text}")
-
-        if not visible_history or not categories_summary.strip():
-            return []
-
-        prompt = (
-            "你需要判断当前对话是否需要查询知识库。\n"
-            "请只返回最相关的分类编号，多个编号用空格分隔；如果完全不需要，返回 none。\n\n"
-            f"【可用分类】\n{categories_summary}\n\n"
-            f"【最近对话】\n{chr(10).join(visible_history)}"
-        )
-
-        try:
-            generation_result = await self._llm_chat.generate_response(
-                prompt=prompt,
-                options=LLMGenerationOptions(
-                    temperature=0.1,
-                    max_tokens=64,
-                ),
-            )
-        except Exception:
-            return []
-
-        return extract_category_ids_from_result(generation_result.response or "")
-
     async def chat_loop_step(
         self,
         chat_history: List[LLMContextMessage],

src/maisaka/context_messages.py

@@ -263,7 +263,6 @@ class ReferenceMessageType(str, Enum):
 
     CUSTOM = "custom"
     JARGON = "jargon"
-    KNOWLEDGE = "knowledge"
     MEMORY = "memory"
     TOOL_HINT = "tool_hint"
 

src/maisaka/runtime.py

@@ -19,7 +19,6 @@ from src.common.logger import get_logger
 from src.common.utils.utils_config import ExpressionConfigUtils
 from src.config.config import global_config
 from src.core.tooling import ToolRegistry
-from src.know_u.knowledge import KnowledgeLearner
 from src.learners.expression_learner import ExpressionLearner
 from src.learners.jargon_miner import JargonMiner
 from src.llm_models.payload_content.resp_format import RespFormat
@@ -102,10 +101,8 @@ class MaisakaHeartFlowChatting:
         self._enable_jargon_learning = jargon_learn
         self._min_extraction_interval = 30
         self._last_expression_extraction_time = 0.0
-        self._last_knowledge_extraction_time = 0.0
         self._expression_learner = ExpressionLearner(session_id)
         self._jargon_miner = JargonMiner(session_id, session_name=session_name)
-        self._knowledge_learner = KnowledgeLearner(session_id)
 
         self._reasoning_engine = MaisakaReasoningEngine(self)
         self._tool_registry = ToolRegistry()
@@ -449,16 +446,11 @@ class MaisakaHeartFlowChatting:
                 self._wait_timeout_task = None
 
     async def _trigger_batch_learning(self, messages: list[SessionMessage]) -> None:
-        """按同一批消息触发表达方式、黑话和 knowledge 学习。"""
+        """按同一批消息触发表达方式和黑话学习。"""
-        expression_result, knowledge_result = await asyncio.gather(
+        try:
-            self._trigger_expression_learning(messages),
+            await self._trigger_expression_learning(messages)
-            self._trigger_knowledge_learning(messages),
+        except Exception as exc:
-            return_exceptions=True,
+            logger.error(f"{self.log_prefix} 表达学习任务异常退出: {exc}")
-        )
-        if isinstance(expression_result, Exception):
-            logger.error(f"{self.log_prefix} 表达学习任务异常退出: {expression_result}")
-        if isinstance(knowledge_result, Exception):
-            logger.error(f"{self.log_prefix} 知识学习任务异常退出: {knowledge_result}")
 
     def _should_trigger_learning(
         self,
@@ -523,34 +515,6 @@ class MaisakaHeartFlowChatting:
         except Exception:
             logger.exception(f"{self.log_prefix} ??????")
 
-    async def _trigger_knowledge_learning(self, messages: list[SessionMessage]) -> None:
-        """?????????????????"""
-        pending_count = self._knowledge_learner.get_pending_count(self.message_cache)
-        if not self._should_trigger_learning(
-            enabled=global_config.maisaka.enable_knowledge_module,
-            feature_name="知识学习",
-            last_extraction_time=self._last_knowledge_extraction_time,
-            pending_count=pending_count,
-            min_messages_for_extraction=self._knowledge_learner.min_messages_for_extraction,
-        ):
-            return
-
-        self._last_knowledge_extraction_time = time.time()
-        logger.info(
-            f"{self.log_prefix} ??????: "
-            f"??????={len(messages)} ??????={pending_count} "
-            f"?????={len(self.message_cache)}"
-        )
-
-        try:
-            added_count = await self._knowledge_learner.learn(self.message_cache)
-            if added_count > 0:
-                logger.info(f"{self.log_prefix} ???????: ?????={added_count}")
-            else:
-                logger.debug(f"{self.log_prefix} ???????????????")
-        except Exception:
-            logger.exception(f"{self.log_prefix} ??????")
-
     async def _init_mcp(self) -> None:
         """初始化 MCP 工具并注册到统一工具层。"""
         self._mcp_host_bridge = MCPHostLLMBridge(

src/plugin_runtime/hook_payloads.py

@@ -62,6 +62,7 @@ def serialize_tool_calls(tool_calls: Sequence[ToolCall] | None) -> List[Dict[str
                 "name": tool_call.func_name,
                 "arguments": dict(tool_call.args or {}),
             },
+            **({"extra_content": tool_call.extra_content} if tool_call.extra_content else {}),
         }
         for tool_call in tool_calls
     ]
@@ -102,11 +103,13 @@ def deserialize_tool_calls(raw_tool_calls: Any) -> List[ToolCall]:
         if not isinstance(call_id, str) or not isinstance(function_name, str):
             raise ValueError("Hook 返回的工具调用缺少 `id` 或函数名称")
 
+        extra_content = raw_tool_call.get("extra_content")
         normalized_tool_calls.append(
             ToolCall(
                 call_id=call_id,
                 func_name=function_name,
                 args=function_arguments if isinstance(function_arguments, dict) else {},
+                extra_content=extra_content if isinstance(extra_content, dict) else None,
             )
         )
     return normalized_tool_calls

src/services/llm_service.py

@@ -384,11 +384,13 @@ def _build_tool_calls(raw_tool_calls: Any) -> List[ToolCall] | None:
         if not isinstance(call_id, str) or not isinstance(func_name, str):
             raise ValueError("工具调用缺少 `id` 或函数名称")
 
+        extra_content = raw_tool_call.get("extra_content")
         tool_calls.append(
             ToolCall(
                 call_id=call_id,
                 func_name=func_name,
                 args=_normalize_tool_arguments(arguments),
+                extra_content=extra_content if isinstance(extra_content, dict) else None,
             )
         )