Losita/mai-bot
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

全部prompt独立

Browse Source
This commit is contained in:
UnCLAS-Prommer
2026-01-21 22:24:31 +08:00
parent 1a1edde750
commit f44598a331
34 changed files with 690 additions and 1037 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
src/memory_system/chat_history_summarizer.py
View File

@@ -22,73 +22,13 @@ from src.chat.utils.chat_message_builder import build_readable_messages
from src.chat.utils.utils import is_bot_self
from src.person_info.person_info import Person
from src.chat.message_receive.chat_stream import get_chat_manager
from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
from src.prompt.prompt_manager import prompt_manager
logger = get_logger("chat_history_summarizer")
HIPPO_CACHE_DIR = Path(__file__).resolve().parents[2] / "data" / "hippo_memorizer"
def init_prompt():
"""初始化提示词模板"""
topic_analysis_prompt = """【历史话题标题列表】（仅标题，不含具体内容）：
{history_topics_block}
【历史话题标题列表结束】
【本次聊天记录】（每条消息前有编号，用于后续引用）：
{messages_block}
【本次聊天记录结束】
请完成以下任务：
**识别话题**
1. 识别【本次聊天记录】中正在进行的一个或多个话题；
2. 【本次聊天记录】的中的消息可能与历史话题有关，也可能毫无关联。
2. 判断【历史话题标题列表】中的话题是否在【本次聊天记录】中出现，如果出现，则直接使用该历史话题标题字符串；
**选取消息**
1. 对于每个话题（新话题或历史话题），从上述带编号的消息中选出与该话题强相关的消息编号列表；
2. 每个话题用一句话清晰地描述正在发生的事件，必须包含时间（大致即可）、人物、主要事件和主题，保证精准且有区分度；
请先输出一段简短思考，说明有什么话题，哪些是不包含在历史话题中的，哪些是包含在历史话题中的，并说明为什么；
然后严格以 JSON 格式输出【本次聊天记录】中涉及的话题，格式如下：
[
{{
"topic": "话题",
"message_indices": [1, 2, 5]
}},
...
]
"""
Prompt(topic_analysis_prompt, "hippo_topic_analysis_prompt")
topic_summary_prompt = """
请基于以下话题，对聊天记录片段进行概括，提取以下信息：
**话题**：{topic}
**要求**：
1. 关键词：提取与话题相关的关键词，用列表形式返回（3-10个关键词）
2. 概括：对这段话的平文本概括（50-200字），要求：
- 仔细地转述发生的事件和聊天内容；
- 重点突出事件的发展过程和结果；
- 围绕话题这个中心进行概括。
- 提取话题中的关键信息点，关键信息点应该简洁明了。
请以JSON格式返回，格式如下：
{{
"keywords": ["关键词1", "关键词2", ...],
"summary": "概括内容"
}}
聊天记录：
{original_text}
请直接返回JSON，不要包含其他内容。
"""
Prompt(topic_summary_prompt, "hippo_topic_summary_prompt")
@dataclass
class MessageBatch:
"""消息批次（用于触发话题检查的原始消息累积）"""
@@ -380,12 +320,16 @@ class ChatHistorySummarizer:
# 条件1: 消息数量达到阈值，触发一次检查
if message_count >= message_threshold:
should_check = True
logger.info(f"{self.log_prefix} 触发检查条件: 消息数量达到 {message_count} 条（阈值: {message_threshold}条）")
logger.info(
f"{self.log_prefix} 触发检查条件: 消息数量达到 {message_count} 条（阈值: {message_threshold}条）"
)
# 条件2: 距离上一次检查超过时间阈值且消息数量达到最小阈值，触发一次检查
elif time_since_last_check > time_threshold_seconds and message_count >= min_messages:
should_check = True
logger.info(f"{self.log_prefix} 触发检查条件: 距上次检查 {time_str}（阈值: {time_threshold_hours}小时）且消息数量达到 {message_count} 条（阈值: {min_messages}条）")
logger.info(
f"{self.log_prefix} 触发检查条件: 距上次检查 {time_str}（阈值: {time_threshold_hours}小时）且消息数量达到 {message_count} 条（阈值: {min_messages}条）"
)
if should_check:
await self._run_topic_check_and_update_cache(messages)
@@ -539,7 +483,9 @@ class ChatHistorySummarizer:
topics_to_finalize: List[str] = []
for topic, item in self.topic_cache.items():
if item.no_update_checks >= no_update_checks_threshold:
logger.info(f"{self.log_prefix} 话题[{topic}] 连续 {no_update_checks_threshold} 次检查无新增内容，触发打包存储")
logger.info(
f"{self.log_prefix} 话题[{topic}] 连续 {no_update_checks_threshold} 次检查无新增内容，触发打包存储"
)
topics_to_finalize.append(topic)
continue
if len(item.messages) > message_count_threshold:
@@ -712,11 +658,10 @@ class ChatHistorySummarizer:
history_topics_block = "\n".join(f"- {t}" for t in existing_topics) if existing_topics else "（当前无历史话题）"
messages_block = "\n".join(numbered_lines)
prompt = await global_prompt_manager.format_prompt(
"hippo_topic_analysis_prompt",
history_topics_block=history_topics_block,
messages_block=messages_block,
)
prompt_template = prompt_manager.get_prompt("hippo_topic_analysis_prompt")
prompt_template.add_context("history_topics_block", history_topics_block)
prompt_template.add_context("messages_block", messages_block)
prompt = await prompt_manager.render_prompt(prompt_template)
try:
response, _ = await self.summarizer_llm.generate_response_async(
@@ -826,23 +771,17 @@ class ChatHistorySummarizer:
while attempt < max_retries:
attempt += 1
success, keywords, summary = await self._compress_with_llm(original_text, topic)
if success and keywords and summary:
# 成功获取到有效的 keywords 和 summary
if attempt > 1:
logger.info(
f"{self.log_prefix} 话题[{topic}] LLM 概括在第 {attempt} 次重试后成功"
)
logger.info(f"{self.log_prefix} 话题[{topic}] LLM 概括在第 {attempt} 次重试后成功")
break
if attempt < max_retries:
logger.warning(
f"{self.log_prefix} 话题[{topic}] LLM 概括失败（第 {attempt} 次尝试），准备重试"
)
logger.warning(f"{self.log_prefix} 话题[{topic}] LLM 概括失败（第 {attempt} 次尝试），准备重试")
else:
logger.error(
f"{self.log_prefix} 话题[{topic}] LLM 概括连续 {max_retries} 次失败，放弃存储"
)
logger.error(f"{self.log_prefix} 话题[{topic}] LLM 概括连续 {max_retries} 次失败，放弃存储")
if not success or not keywords or not summary:
logger.warning(f"{self.log_prefix} 话题[{topic}] LLM 概括失败，不写入数据库")
@@ -875,11 +814,10 @@ class ChatHistorySummarizer:
Returns:
tuple[bool, List[str], str]: (是否成功, 关键词列表, 概括)
"""
prompt = await global_prompt_manager.format_prompt(
"hippo_topic_summary_prompt",
topic=topic,
original_text=original_text,
)
prompt_template = prompt_manager.get_prompt("hippo_topic_summary_prompt")
prompt_template.add_context("topic", topic)
prompt_template.add_context("original_text", original_text)
prompt = await prompt_manager.render_prompt(prompt_template)
try:
response, _ = await self.summarizer_llm.generate_response_async(prompt=prompt)
@@ -943,7 +881,7 @@ class ChatHistorySummarizer:
keywords = result.get("keywords", [])
summary = result.get("summary", "")
# 检查必需字段是否为空
if not keywords or not summary:
logger.warning(f"{self.log_prefix} LLM返回的JSON中缺少必需字段，原文\n{response}")
@@ -1046,7 +984,7 @@ class ChatHistorySummarizer:
# 1. 话题主题
# if theme:
# content_parts.append(f"话题：{theme}")
# content_parts.append(f"话题：{theme}")
# 2. 概括内容
if summary:
@@ -1134,6 +1072,3 @@ class ChatHistorySummarizer:
traceback.print_exc()
self._running = False
init_prompt()

175
src/memory_system/memory_retrieval.py
View File

@@ -4,7 +4,7 @@ import asyncio
from typing import List, Dict, Any, Optional, Tuple
from src.common.logger import get_logger
from src.config.config import global_config, model_config
from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
from src.prompt.prompt_manager import prompt_manager
from src.plugin_system.apis import llm_api
from src.common.database.database_model import ThinkingBack
from src.memory_system.retrieval_tools import get_tool_registry, init_all_tools
@@ -41,84 +41,11 @@ def _cleanup_stale_not_found_thinking_back() -> None:
logger.error(f"清理未找到答案的thinking_back记录失败: {e}")
def init_memory_retrieval_prompt():
"""初始化记忆检索相关的 prompt 模板和工具"""
# 首先注册所有工具
def init_memory_retrieval_sys():
"""初始化记忆检索相关工具"""
# 注册所有工具
init_all_tools()
# 第二步：ReAct Agent prompt（使用function calling，要求先思考再行动）
Prompt(
"""你的名字是{bot_name}。现在是{time_now}。
你正在参与聊天，你需要搜集信息来帮助你进行回复。
重要，这是当前聊天记录：
{chat_history}
聊天记录结束
已收集的信息：
{collected_info}
- 你可以对查询思路给出简短的思考：思考要简短，直接切入要点
- 思考完毕后，使用工具
**工具说明：**
- 如果涉及过往事件，或者查询某个过去可能提到过的概念，或者某段时间发生的事件。可以使用lpmm知识库查询
- 如果遇到不熟悉的词语、缩写、黑话或网络用语，可以使用query_words工具查询其含义
- 你必须使用tool，如果需要查询你必须给出使用什么工具进行查询
- 当你决定结束查询时，必须调用return_information工具返回总结信息并结束查询
""",
name="memory_retrieval_react_prompt_head_lpmm",
)
# 第二步：ReAct Agent prompt（使用function calling，要求先思考再行动）
Prompt(
"""你的名字是{bot_name}。现在是{time_now}。
你正在参与聊天，你需要搜集信息来帮助你进行回复。
当前聊天记录：
{chat_history}
已收集的信息：
{collected_info}
**工具说明：**
- 如果涉及过往事件，或者查询某个过去可能提到过的概念，或者某段时间发生的事件。可以使用聊天记录查询工具查询过往事件
- 如果涉及人物，可以使用人物信息查询工具查询人物信息
- 如果遇到不熟悉的词语、缩写、黑话或网络用语，可以使用query_words工具查询其含义
- 如果没有可靠信息，且查询时间充足，或者不确定查询类别，也可以使用lpmm知识库查询，作为辅助信息
**思考**
- 你可以对查询思路给出简短的思考：思考要简短，直接切入要点
- 先思考当前信息是否足够回答问题
- 如果信息不足，则需要使用tool查询信息，你必须给出使用什么工具进行查询
- 当你决定结束查询时，必须调用return_information工具返回总结信息并结束查询
""",
name="memory_retrieval_react_prompt_head",
)
# 额外，如果最后一轮迭代：ReAct Agent prompt（使用function calling，要求先思考再行动）
Prompt(
"""你的名字是{bot_name}。现在是{time_now}。
你正在参与聊天，你需要根据搜集到的信息总结信息。
如果搜集到的信息对于参与聊天，回答问题有帮助，请加入总结，如果无关，请不要加入到总结。
当前聊天记录：
{chat_history}
已收集的信息：
{collected_info}
分析：
- 基于已收集的信息，总结出对当前聊天有帮助的相关信息
- **如果收集的信息对当前聊天有帮助**，在思考中直接给出总结信息，格式为：return_information(information="你的总结信息")
- **如果信息无关或没有帮助**，在思考中给出：return_information(information="")
**重要规则：**
- 必须严格使用检索到的信息回答问题，不要编造信息
- 答案必须精简，不要过多解释
""",
name="memory_retrieval_react_final_prompt",
)
def _log_conversation_messages(
conversation_messages: List[Message],
@@ -304,17 +231,20 @@ async def _react_agent_solve_question(
# 第一次构建，使用初始的collected_info（即initial_info）
initial_collected_info = initial_info if initial_info else ""
# 根据配置选择使用哪个 prompt
prompt_name = "memory_retrieval_react_prompt_head_lpmm" if global_config.experimental.lpmm_memory else "memory_retrieval_react_prompt_head"
first_head_prompt = await global_prompt_manager.format_prompt(
prompt_name,
bot_name=bot_name,
time_now=time_now,
chat_history=chat_history,
collected_info=initial_collected_info,
current_iteration=current_iteration,
remaining_iterations=remaining_iterations,
max_iterations=max_iterations,
prompt_name = (
"memory_retrieval_react_prompt_head_lpmm"
if global_config.experimental.lpmm_memory
else "memory_retrieval_react_prompt_head"
)
first_head_prompt_template = prompt_manager.get_prompt(prompt_name)
first_head_prompt_template.add_context("bot_name", bot_name)
first_head_prompt_template.add_context("time_now", time_now)
first_head_prompt_template.add_context("chat_history", chat_history)
first_head_prompt_template.add_context("collected_info", initial_collected_info)
first_head_prompt_template.add_context("current_iteration", str(current_iteration))
first_head_prompt_template.add_context("remaining_iterations", str(remaining_iterations))
first_head_prompt_template.add_context("max_iterations", str(max_iterations))
first_head_prompt = await prompt_manager.render_prompt(first_head_prompt_template)
# 后续迭代都复用第一次构建的head_prompt
head_prompt = first_head_prompt
@@ -394,11 +324,11 @@ async def _react_agent_solve_question(
"""从文本中解析JSON格式的return_information，返回information字符串，如果未找到则返回None"""
if not text:
return None, None
try:
# 尝试提取JSON对象（可能包含在代码块中或直接是JSON）
json_text = text.strip()
# 如果包含代码块标记，提取JSON部分
if "```json" in json_text:
start = json_text.find("```json") + 7
@@ -410,10 +340,10 @@ async def _react_agent_solve_question(
end = json_text.find("```", start)
if end != -1:
json_text = json_text[start:end].strip()
# 尝试解析JSON
data = json.loads(json_text)
# 检查是否包含return_information字段
if isinstance(data, dict) and "return_information" in data:
information = data.get("information", "")
@@ -422,20 +352,20 @@ async def _react_agent_solve_question(
# 如果JSON解析失败，尝试在文本中查找JSON对象
try:
# 查找第一个 { 和最后一个 } 之间的内容（更健壮的JSON提取）
first_brace = text.find('{')
first_brace = text.find("{")
if first_brace != -1:
# 从第一个 { 开始，找到匹配的 }
brace_count = 0
json_end = -1
for i in range(first_brace, len(text)):
if text[i] == '{':
if text[i] == "{":
brace_count += 1
elif text[i] == '}':
elif text[i] == "}":
brace_count -= 1
if brace_count == 0:
json_end = i + 1
break
if json_end != -1:
json_text = text[first_brace:json_end]
data = json.loads(json_text)
@@ -444,9 +374,9 @@ async def _react_agent_solve_question(
return information
except (json.JSONDecodeError, ValueError, TypeError):
pass
return None
# 尝试从文本中解析return_information函数调用
def parse_return_information_from_text(text: str):
"""从文本中解析return_information函数调用，返回information字符串，如果未找到则返回None"""
@@ -462,14 +392,14 @@ async def _react_agent_solve_question(
# 解析information参数（字符串，使用extract_quoted_content）
information = extract_quoted_content(text, "return_information", "information")
# 如果information存在（即使是空字符串），也返回它
return information
# 首先尝试解析JSON格式
parsed_information_json = parse_json_return_information(response)
is_json_format = parsed_information_json is not None
# 如果JSON解析成功，使用JSON结果
if is_json_format:
parsed_information = parsed_information_json
@@ -519,9 +449,7 @@ async def _react_agent_solve_question(
# 如果没有检测到return_information格式，记录思考过程，继续下一轮迭代
step["observations"] = [f"思考完成，但未调用工具。响应: {response}"]
logger.info(
f"{react_log_prefix}第 {iteration + 1} 次迭代 思考完成但未调用工具: {response}"
)
logger.info(f"{react_log_prefix}第 {iteration + 1} 次迭代 思考完成但未调用工具: {response}")
collected_info += f"思考: {response}"
else:
logger.warning(f"{react_log_prefix}第 {iteration + 1} 次迭代 无工具调用且无响应")
@@ -566,9 +494,7 @@ async def _react_agent_solve_question(
# 信息为空，直接退出查询
step["observations"] = ["检测到return_information工具调用，信息为空"]
thinking_steps.append(step)
logger.info(
f"{react_log_prefix}第 {iteration + 1} 次迭代 通过return_information工具判断信息为空"
)
logger.info(f"{react_log_prefix}第 {iteration + 1} 次迭代 通过return_information工具判断信息为空")
_log_conversation_messages(
conversation_messages,
@@ -614,9 +540,7 @@ async def _react_agent_solve_question(
return f"查询{tool_name_str}({param_str})的结果：{observation}"
except Exception as e:
error_msg = f"工具执行失败: {str(e)}"
logger.error(
f"{react_log_prefix}第 {iter_num + 1} 次迭代 工具 {tool_name_str} {error_msg}"
)
logger.error(f"{react_log_prefix}第 {iter_num + 1} 次迭代 工具 {tool_name_str} {error_msg}")
return f"查询{tool_name_str}失败: {error_msg}"
tool_tasks.append(execute_single_tool(tool, tool_params, tool_name, iteration))
@@ -636,9 +560,7 @@ async def _react_agent_solve_question(
for i, (tool_call_item, observation) in enumerate(zip(tool_calls, observations, strict=False)):
if isinstance(observation, Exception):
observation = f"工具执行异常: {str(observation)}"
logger.error(
f"{react_log_prefix}第 {iteration + 1} 次迭代 工具 {i + 1} 执行异常: {observation}"
)
logger.error(f"{react_log_prefix}第 {iteration + 1} 次迭代 工具 {i + 1} 执行异常: {observation}")
observation_text = observation if isinstance(observation, str) else str(observation)
stripped_observation = observation_text.strip()
@@ -740,16 +662,15 @@ async def _react_agent_solve_question(
return None
# 执行最终评估
evaluation_prompt = await global_prompt_manager.format_prompt(
"memory_retrieval_react_final_prompt",
bot_name=bot_name,
time_now=time_now,
chat_history=chat_history,
collected_info=collected_info if collected_info else "暂无信息",
current_iteration=current_iteration,
remaining_iterations=remaining_iterations,
max_iterations=max_iterations,
)
evaluation_prompt_template = prompt_manager.get_prompt("memory_retrieval_react_final_prompt")
evaluation_prompt_template.add_context("bot_name", bot_name)
evaluation_prompt_template.add_context("time_now", time_now)
evaluation_prompt_template.add_context("chat_history", chat_history)
evaluation_prompt_template.add_context("collected_info", collected_info if collected_info else "暂无信息")
evaluation_prompt_template.add_context("current_iteration", str(current_iteration))
evaluation_prompt_template.add_context("remaining_iterations", str(remaining_iterations))
evaluation_prompt_template.add_context("max_iterations", str(max_iterations))
evaluation_prompt = await prompt_manager.render_prompt(evaluation_prompt_template)
(
eval_success,
@@ -788,7 +709,9 @@ async def _react_agent_solve_question(
eval_step = {
"iteration": current_iteration,
"thought": f"[最终评估] {eval_response}",
"actions": [{"action_type": "return_information", "action_params": {"information": return_information_content}}],
"actions": [
{"action_type": "return_information", "action_params": {"information": return_information_content}}
],
"observations": ["最终评估阶段检测到return_information"],
}
thinking_steps.append(eval_step)
@@ -813,9 +736,7 @@ async def _react_agent_solve_question(
eval_step = {
"iteration": current_iteration,
"thought": f"[最终评估] {eval_response}",
"actions": [
{"action_type": "return_information", "action_params": {"information": ""}}
],
"actions": [{"action_type": "return_information", "action_params": {"information": ""}}],
"observations": ["已到达最大迭代次数，信息为空"],
}
thinking_steps.append(eval_step)
@@ -1124,9 +1045,7 @@ async def build_memory_retrieval_prompt(
end_time = time.time()
if result:
logger.info(
f"{log_prefix}记忆检索成功，耗时: {(end_time - start_time):.3f}秒"
)
logger.info(f"{log_prefix}记忆检索成功，耗时: {(end_time - start_time):.3f}秒")
return f"你回忆起了以下信息：\n{result}\n如果与回复内容相关，可以参考这些回忆的信息。\n"
else:
logger.debug(f"{log_prefix}记忆检索未找到相关信息")