import time import json import re import random 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.plugin_system.apis import llm_api from src.common.database.database_model import ThinkingBack from json_repair import repair_json from src.memory_system.retrieval_tools import get_tool_registry, init_all_tools from src.llm_models.payload_content.message import MessageBuilder, RoleType, Message logger = get_logger("memory_retrieval") def init_memory_retrieval_prompt(): """初始化记忆检索相关的 prompt 模板和工具""" # 首先注册所有工具 init_all_tools() # 第一步：问题生成prompt Prompt( """ 你的名字是{bot_name}。现在是{time_now}。 群里正在进行的聊天内容： {chat_history} {recent_query_history} 现在，{sender}发送了内容:{target_message},你想要回复ta。 请仔细分析聊天内容，考虑以下几点： 1. 对话中是否提到了过去发生的事情、人物、事件或信息 2. 是否有需要回忆的内容（比如"之前说过"、"上次"、"以前"等） 3. 是否有需要查找历史信息的问题 4. 是否有问题可以搜集信息帮助你聊天 5. 对话中是否包含黑话、俚语、缩写等可能需要查询的概念 重要提示： - **每次只能提出一个问题**，选择最需要查询的关键问题 - 如果"最近已查询的问题和结果"中已经包含了类似的问题，请避免重复生成相同或相似的问题 - 如果之前已经查询过某个问题但未找到答案，可以尝试用不同的方式提问或更具体的问题 - 如果之前已经查询过某个问题并找到了答案，可以直接参考已有结果，不需要重复查询 如果你认为需要从记忆中检索信息来回答，请： 1. 先识别对话中可能需要查询的概念（黑话/俚语/缩写/人名/专有名词等关键词） 2. 然后根据上下文提出**一个**最关键的问题来帮助你回复目标消息 问题格式示例： - "xxx在前几天干了什么" - "xxx是什么" - "xxxx和xxx的关系是什么" - "xxx在某个时间点发生了什么" 请输出JSON格式，包含两个字段： - "concepts": 需要检索的概念列表（字符串数组），如果不需要检索概念则输出空数组[] - "questions": 问题数组（字符串数组），如果不需要检索记忆则输出空数组[]，如果需要检索则只输出包含一个问题的数组 输出格式示例（需要检索时）： ```json {{ "concepts": ["AAA", "BBB", "CCC"], "questions": ["张三在前几天干了什么"] }} ``` 输出格式示例（不需要检索时）： ```json {{ "concepts": [], "questions": [] }} ``` 请只输出JSON对象，不要输出其他内容： """, name="memory_retrieval_question_prompt", ) # 第二步：ReAct Agent prompt（使用function calling，要求先思考再行动） Prompt( """ 你的名字是{bot_name}。现在是{time_now}。 你正在参与聊天，你需要搜集信息来回答问题，帮助你参与聊天。 你需要通过思考(Think)、行动(Action)、观察(Observation)的循环来回答问题。 **重要限制：** - 最大查询轮数：5轮（当前第{current_iteration}轮，剩余{remaining_iterations}轮） - 必须尽快得出答案，避免不必要的查询 - 思考要简短，直接切入要点 - 必须严格使用检索到的信息回答问题，不要编造信息 当前问题：{question} 已收集的信息： {collected_info} **执行步骤：** **第一步：思考（Think）** 在思考中分析： - 当前信息是否足够回答问题？ - 如果足够，在思考中直接给出答案，格式为：final_answer(answer="你的答案内容") - 如果不够，说明最需要查询什么，并输出为纯文本说明 **第二步：行动（Action）** 根据思考结果立即行动： - 如果思考中已给出final_answer → 无需调用工具，直接结束 - 如果信息不足 → 调用相应工具查询（可并行调用多个工具） - 如果多次查询仍无结果 → 在思考中给出no_answer(reason="无法找到答案的原因") **重要：答案必须在思考中给出，格式为 final_answer(answer="...") 或 no_answer(reason="...")，不要调用工具。** """, name="memory_retrieval_react_prompt", ) # 第二步：ReAct Agent prompt（使用function calling，要求先思考再行动） Prompt( """ 你的名字是{bot_name}。现在是{time_now}。 你正在参与聊天，你需要搜集信息来回答问题，帮助你参与聊天。 你需要通过思考(Think)、行动(Action)、观察(Observation)的循环来回答问题。 **重要限制：** - 最大查询轮数：5轮（当前第{current_iteration}轮，剩余{remaining_iterations}轮） - 必须尽快得出答案，避免不必要的查询 - 思考要简短，直接切入要点 - 必须严格使用检索到的信息回答问题，不要编造信息 当前问题：{question} **执行步骤：** **第一步：思考（Think）** 在思考中分析： - 当前信息是否足够回答问题？ - 如果足够，在思考中直接给出答案，格式为：final_answer(answer="你的答案内容") - 如果不够，说明最需要查询什么，并输出为纯文本说明 **第二步：行动（Action）** 根据思考结果立即行动： - 如果思考中已给出final_answer → 无需调用工具，直接结束 - 如果信息不足 → 调用相应工具查询（可并行调用多个工具） - 如果多次查询仍无结果 → 在思考中给出no_answer(reason="无法找到答案的原因") **重要：答案必须在思考中给出，格式为 final_answer(answer="...") 或 no_answer(reason="...")，不要调用工具。** """, name="memory_retrieval_react_prompt_head", ) # 额外，如果最后一轮迭代：ReAct Agent prompt（使用function calling，要求先思考再行动） Prompt( """ 你的名字是{bot_name}。现在是{time_now}。 你正在参与聊天，你需要搜集信息来回答问题，帮助你参与聊天。 **重要限制：** - 你已经经过几轮查询，尝试了信息搜集，现在你需要总结信息，选择回答问题或判断问题无法回答 - 思考要简短，直接切入要点 - 必须严格使用检索到的信息回答问题，不要编造信息 当前问题：{question} 已收集的信息： {collected_info} **执行步骤：** 分析： - 当前信息是否足够回答问题？ - 如果足够，在思考中直接给出答案，格式为：final_answer(answer="你的答案内容") - 如果不够，在思考中给出no_answer(reason="无法找到答案的原因") **重要：答案必须给出，格式为 final_answer(answer="...") 或 no_answer(reason="...")。** """, name="memory_retrieval_react_final_prompt", ) def _parse_react_response(response: str) -> Optional[Dict[str, Any]]: """解析ReAct Agent的响应 Args: response: LLM返回的响应 Returns: Dict[str, Any]: 解析后的动作信息，如果解析失败返回None 格式: {"thought": str, "actions": List[Dict[str, Any]]} 每个action格式: {"action_type": str, "action_params": dict} """ try: # 尝试提取JSON（可能包含在```json代码块中） json_pattern = r"```json\s*(.*?)\s*```" matches = re.findall(json_pattern, response, re.DOTALL) if matches: json_str = matches[0] else: # 尝试直接解析整个响应 json_str = response.strip() # 修复可能的JSON错误 repaired_json = repair_json(json_str) # 解析JSON action_info = json.loads(repaired_json) if not isinstance(action_info, dict): logger.warning(f"解析的JSON不是对象格式: {action_info}") return None # 确保actions字段存在且为列表 if "actions" not in action_info: logger.warning(f"响应中缺少actions字段: {action_info}") return None if not isinstance(action_info["actions"], list): logger.warning(f"actions字段不是数组格式: {action_info['actions']}") return None # 确保actions不为空 if len(action_info["actions"]) == 0: logger.warning("actions数组为空") return None return action_info except Exception as e: logger.error(f"解析ReAct响应失败: {e}, 响应内容: {response[:200]}...") return None async def _retrieve_concepts_with_jargon( concepts: List[str], chat_id: str ) -> str: """对概念列表进行jargon检索 Args: concepts: 概念列表 chat_id: 聊天ID Returns: str: 检索结果字符串 """ if not concepts: return "" from src.jargon.jargon_miner import search_jargon results = [] for concept in concepts: concept = concept.strip() if not concept: continue # 先尝试精确匹配 jargon_results = search_jargon( keyword=concept, chat_id=chat_id, limit=10, case_sensitive=False, fuzzy=False ) is_fuzzy_match = False # 如果精确匹配未找到，尝试模糊搜索 if not jargon_results: jargon_results = search_jargon( keyword=concept, chat_id=chat_id, limit=10, case_sensitive=False, fuzzy=True ) is_fuzzy_match = True if jargon_results: # 找到结果 if is_fuzzy_match: # 模糊匹配 output_parts = [f"未精确匹配到'{concept}'"] for result in jargon_results: found_content = result.get("content", "").strip() meaning = result.get("meaning", "").strip() if found_content and meaning: output_parts.append(f"找到 '{found_content}' 的含义为：{meaning}") results.append("，".join(output_parts)) logger.info(f"在jargon库中找到匹配（模糊搜索）: {concept}，找到{len(jargon_results)}条结果") else: # 精确匹配 output_parts = [] for result in jargon_results: meaning = result.get("meaning", "").strip() if meaning: output_parts.append(f"'{concept}' 为黑话或者网络简写，含义为：{meaning}") results.append("；".join(output_parts) if len(output_parts) > 1 else output_parts[0]) logger.info(f"在jargon库中找到匹配（精确匹配）: {concept}，找到{len(jargon_results)}条结果") else: # 未找到 results.append(f"未在jargon库中找到'{concept}'的解释") logger.info(f"在jargon库中未找到匹配: {concept}") if results: return "【概念检索结果】\n" + "\n".join(results) + "\n" return "" async def _react_agent_solve_question( question: str, chat_id: str, max_iterations: int = 5, timeout: float = 30.0, initial_info: str = "" ) -> Tuple[bool, str, List[Dict[str, Any]], bool]: """使用ReAct架构的Agent来解决问题 Args: question: 要回答的问题 chat_id: 聊天ID max_iterations: 最大迭代次数 timeout: 超时时间（秒） initial_info: 初始信息（如概念检索结果），将作为collected_info的初始值 Returns: Tuple[bool, str, List[Dict[str, Any]], bool]: (是否找到答案, 答案内容, 思考步骤列表, 是否超时) """ start_time = time.time() collected_info = initial_info if initial_info else "" thinking_steps = [] is_timeout = False conversation_messages: List[Message] = [] for iteration in range(max_iterations): # 检查超时 if time.time() - start_time > timeout: logger.warning(f"ReAct Agent超时，已迭代{iteration}次") is_timeout = True break # 获取工具注册器 tool_registry = get_tool_registry() # 获取bot_name bot_name = global_config.bot.nickname # 获取当前时间 time_now = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) # 计算剩余迭代次数 current_iteration = iteration + 1 remaining_iterations = max_iterations - current_iteration is_final_iteration = current_iteration >= max_iterations # 构建prompt（不再需要工具文本描述） prompt_type = "memory_retrieval_react_prompt" if is_final_iteration: prompt_type = "memory_retrieval_react_final_prompt" tool_definitions = [] logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代，问题: {question}|可用工具数量: 0（最后一次迭代，不提供工具调用）") else: tool_definitions = tool_registry.get_tool_definitions() logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代，问题: {question}|可用工具数量: {len(tool_definitions)}") prompt = await global_prompt_manager.format_prompt( prompt_type, bot_name=bot_name, time_now=time_now, question=question, collected_info=collected_info if collected_info else "暂无信息", current_iteration=current_iteration, remaining_iterations=remaining_iterations, ) if not is_final_iteration: head_prompt = await global_prompt_manager.format_prompt( "memory_retrieval_react_prompt_head", bot_name=bot_name, time_now=time_now, question=question, current_iteration=current_iteration, remaining_iterations=remaining_iterations, ) def message_factory( _client, *, _head_prompt: str = head_prompt, _prompt: str = prompt, _conversation_messages: List[Message] = conversation_messages, ) -> List[Message]: messages: List[Message] = [] system_builder = MessageBuilder() system_builder.set_role(RoleType.System) system_builder.add_text_content(_head_prompt) if _prompt.strip(): system_builder.add_text_content(f"\n{_prompt}") messages.append(system_builder.build()) messages.extend(_conversation_messages) for msg in messages: print(msg) return messages success, response, reasoning_content, model_name, tool_calls = await llm_api.generate_with_model_with_tools_by_message_factory( message_factory, model_config=model_config.model_task_config.tool_use, tool_options=tool_definitions, request_type="memory.react", ) else: logger.info(f"ReAct Agent 第 {iteration + 1} 次Prompt: {prompt}") success, response, reasoning_content, model_name, tool_calls = await llm_api.generate_with_model_with_tools( prompt, model_config=model_config.model_task_config.tool_use, tool_options=tool_definitions, request_type="memory.react", ) logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 模型: {model_name} ，调用工具数量: {len(tool_calls) if tool_calls else 0} ，调用工具响应: {response}") if not success: logger.error(f"ReAct Agent LLM调用失败: {response}") break assistant_message: Optional[Message] = None if tool_calls: assistant_builder = MessageBuilder() assistant_builder.set_role(RoleType.Assistant) if response and response.strip(): assistant_builder.add_text_content(response) assistant_builder.set_tool_calls(tool_calls) assistant_message = assistant_builder.build() elif response and response.strip(): assistant_builder = MessageBuilder() assistant_builder.set_role(RoleType.Assistant) assistant_builder.add_text_content(response) assistant_message = assistant_builder.build() # 记录思考步骤 step = { "iteration": iteration + 1, "thought": response, "actions": [], "observations": [] } # 优先从思考内容中提取final_answer或no_answer def extract_quoted_content(text, func_name, param_name): """从文本中提取函数调用中参数的值，支持单引号和双引号 Args: text: 要搜索的文本 func_name: 函数名，如 'final_answer' param_name: 参数名，如 'answer' Returns: 提取的参数值，如果未找到则返回None """ if not text: return None # 查找函数调用位置（不区分大小写） func_pattern = func_name.lower() text_lower = text.lower() func_pos = text_lower.find(func_pattern) if func_pos == -1: return None # 查找参数名和等号 param_pattern = f'{param_name}=' param_pos = text_lower.find(param_pattern, func_pos) if param_pos == -1: return None # 跳过参数名、等号和空白 start_pos = param_pos + len(param_pattern) while start_pos < len(text) and text[start_pos] in ' \t\n': start_pos += 1 if start_pos >= len(text): return None # 确定引号类型 quote_char = text[start_pos] if quote_char not in ['"', "'"]: return None # 查找匹配的结束引号（考虑转义） end_pos = start_pos + 1 while end_pos < len(text): if text[end_pos] == quote_char: # 检查是否是转义的引号 if end_pos > start_pos + 1 and text[end_pos - 1] == '\\': end_pos += 1 continue # 找到匹配的引号 content = text[start_pos + 1:end_pos] # 处理转义字符 content = content.replace('\\"', '"').replace("\\'", "'").replace('\\\\', '\\') return content end_pos += 1 return None # 从LLM的直接输出内容中提取final_answer或no_answer final_answer_content = None no_answer_reason = None # 只检查response（LLM的直接输出内容），不检查reasoning_content if response: final_answer_content = extract_quoted_content(response, 'final_answer', 'answer') if not final_answer_content: no_answer_reason = extract_quoted_content(response, 'no_answer', 'reason') # 如果从输出内容中找到了答案，直接返回 if final_answer_content: step["actions"].append({"action_type": "final_answer", "action_params": {"answer": final_answer_content}}) step["observations"] = ["从LLM输出内容中检测到final_answer"] thinking_steps.append(step) logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 从LLM输出内容中检测到final_answer: {final_answer_content[:100]}...") return True, final_answer_content, thinking_steps, False if no_answer_reason: step["actions"].append({"action_type": "no_answer", "action_params": {"reason": no_answer_reason}}) step["observations"] = ["从LLM输出内容中检测到no_answer"] thinking_steps.append(step) logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 从LLM输出内容中检测到no_answer: {no_answer_reason[:100]}...") return False, no_answer_reason, thinking_steps, False if is_final_iteration: step["actions"].append({"action_type": "no_answer", "action_params": {"reason": "已到达最后一次迭代，无法找到答案"}}) step["observations"] = ["已到达最后一次迭代，无法找到答案"] thinking_steps.append(step) logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 已到达最后一次迭代，无法找到答案") return False, "已到达最后一次迭代，无法找到答案", thinking_steps, False if assistant_message: conversation_messages.append(assistant_message) # 记录思考过程到collected_info中 if reasoning_content or response: thought_summary = reasoning_content or (response[:200] if response else "") if thought_summary: collected_info += f"\n[思考] {thought_summary}\n" # 处理工具调用 if not tool_calls: # 没有工具调用，说明LLM在思考中已经给出了答案（已在前面检查），或者需要继续查询 # 如果思考中没有答案，说明需要继续查询或等待下一轮 if response and response.strip(): # 如果响应不为空，记录思考过程，继续下一轮迭代 step["observations"] = [f"思考完成，但未调用工具。响应: {response}"] logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 思考完成但未调用工具: {response[:100]}...") # 继续下一轮迭代，让LLM有机会在思考中给出final_answer或继续查询 collected_info += f"思考: {response}" thinking_steps.append(step) continue else: logger.warning(f"ReAct Agent 第 {iteration + 1} 次迭代 无工具调用且无响应") step["observations"] = ["无响应且无工具调用"] thinking_steps.append(step) break # 处理工具调用 tool_tasks = [] for i, tool_call in enumerate(tool_calls): tool_name = tool_call.func_name tool_args = tool_call.args or {} logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 工具调用 {i+1}/{len(tool_calls)}: {tool_name}({tool_args})") # 普通工具调用 tool = tool_registry.get_tool(tool_name) if tool: # 准备工具参数（需要添加chat_id如果工具需要） tool_params = tool_args.copy() # 如果工具函数签名需要chat_id，添加它 import inspect sig = inspect.signature(tool.execute_func) if "chat_id" in sig.parameters: tool_params["chat_id"] = chat_id # 创建异步任务 async def execute_single_tool(tool_instance, params, tool_name_str, iter_num): try: observation = await tool_instance.execute(**params) param_str = ", ".join([f"{k}={v}" for k, v in params.items() if k != "chat_id"]) return f"查询{tool_name_str}({param_str})的结果：{observation}" except Exception as e: error_msg = f"工具执行失败: {str(e)}" logger.error(f"ReAct Agent 第 {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)) step["actions"].append({"action_type": tool_name, "action_params": tool_args}) else: error_msg = f"未知的工具类型: {tool_name}" logger.warning(f"ReAct Agent 第 {iteration + 1} 次迭代 工具 {i+1}/{len(tool_calls)} {error_msg}") tool_tasks.append(asyncio.create_task(asyncio.sleep(0, result=f"查询{tool_name}失败: {error_msg}"))) # 并行执行所有工具 if tool_tasks: observations = await asyncio.gather(*tool_tasks, return_exceptions=True) # 处理执行结果 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 Agent 第 {iteration + 1} 次迭代 工具 {i+1} 执行异常: {observation}") observation_text = observation if isinstance(observation, str) else str(observation) step["observations"].append(observation_text) collected_info += f"\n{observation_text}\n" if observation_text.strip(): tool_builder = MessageBuilder() tool_builder.set_role(RoleType.Tool) tool_builder.add_text_content(observation_text) tool_builder.add_tool_call(tool_call_item.call_id) conversation_messages.append(tool_builder.build()) # logger.info(f"ReAct Agent 第 {iteration + 1} 次迭代 工具 {i+1} 执行结果: {observation_text}") thinking_steps.append(step) # 达到最大迭代次数或超时，但Agent没有明确返回final_answer # 迭代超时应该直接视为no_answer，而不是使用已有信息 # 只有Agent明确返回final_answer时，才认为找到了答案 if collected_info: logger.warning(f"ReAct Agent达到最大迭代次数或超时，但未明确返回final_answer。已收集信息: {collected_info[:100]}...") if is_timeout: logger.warning("ReAct Agent超时，直接视为no_answer") else: logger.warning("ReAct Agent达到最大迭代次数，直接视为no_answer") return False, "未找到相关信息", thinking_steps, is_timeout def _get_recent_query_history(chat_id: str, time_window_seconds: float = 300.0) -> str: """获取最近一段时间内的查询历史 Args: chat_id: 聊天ID time_window_seconds: 时间窗口（秒），默认10分钟 Returns: str: 格式化的查询历史字符串 """ try: current_time = time.time() start_time = current_time - time_window_seconds # 查询最近时间窗口内的记录，按更新时间倒序 records = ( ThinkingBack.select() .where( (ThinkingBack.chat_id == chat_id) & (ThinkingBack.update_time >= start_time) ) .order_by(ThinkingBack.update_time.desc()) .limit(5) # 最多返回5条最近的记录 ) if not records.exists(): return "" history_lines = [] history_lines.append("最近已查询的问题和结果：") for record in records: status = "✓ 已找到答案" if record.found_answer else "✗ 未找到答案" answer_preview = "" # 只有找到答案时才显示答案内容 if record.found_answer and record.answer: # 截取答案前100字符 answer_preview = record.answer[:100] if len(record.answer) > 100: answer_preview += "..." history_lines.append(f"- 问题：{record.question}") history_lines.append(f" 状态：{status}") if answer_preview: history_lines.append(f" 答案：{answer_preview}") history_lines.append("") # 空行分隔 return "\n".join(history_lines) except Exception as e: logger.error(f"获取查询历史失败: {e}") return "" def _get_cached_memories(chat_id: str, time_window_seconds: float = 300.0) -> List[str]: """获取最近一段时间内缓存的记忆（只返回找到答案的记录） Args: chat_id: 聊天ID time_window_seconds: 时间窗口（秒），默认300秒（5分钟） Returns: List[str]: 格式化的记忆列表，每个元素格式为 "问题：xxx\n答案：xxx" """ try: current_time = time.time() start_time = current_time - time_window_seconds # 查询最近时间窗口内找到答案的记录，按更新时间倒序 records = ( ThinkingBack.select() .where( (ThinkingBack.chat_id == chat_id) & (ThinkingBack.update_time >= start_time) & (ThinkingBack.found_answer == 1) ) .order_by(ThinkingBack.update_time.desc()) .limit(5) # 最多返回5条最近的记录 ) if not records.exists(): return [] cached_memories = [] for record in records: if record.answer: cached_memories.append(f"问题：{record.question}\n答案：{record.answer}") return cached_memories except Exception as e: logger.error(f"获取缓存记忆失败: {e}") return [] def _query_thinking_back(chat_id: str, question: str) -> Optional[Tuple[bool, str]]: """从thinking_back数据库中查询是否有现成的答案 Args: chat_id: 聊天ID question: 问题 Returns: Optional[Tuple[bool, str]]: 如果找到记录，返回(found_answer, answer)，否则返回None found_answer: 是否找到答案（True表示found_answer=1，False表示found_answer=0） answer: 答案内容 """ try: # 查询相同chat_id和问题的所有记录（包括found_answer为0和1的） # 按更新时间倒序，获取最新的记录 records = ( ThinkingBack.select() .where( (ThinkingBack.chat_id == chat_id) & (ThinkingBack.question == question) ) .order_by(ThinkingBack.update_time.desc()) .limit(1) ) if records.exists(): record = records.get() found_answer = bool(record.found_answer) answer = record.answer or "" logger.info(f"在thinking_back中找到记录，问题: {question[:50]}...，found_answer: {found_answer}") return found_answer, answer return None except Exception as e: logger.error(f"查询thinking_back失败: {e}") return None def _store_thinking_back( chat_id: str, question: str, context: str, found_answer: bool, answer: str, thinking_steps: List[Dict[str, Any]] ) -> None: """存储或更新思考过程到数据库（如果已存在则更新，否则创建） Args: chat_id: 聊天ID question: 问题 context: 上下文信息 found_answer: 是否找到答案 answer: 答案内容 thinking_steps: 思考步骤列表 """ try: now = time.time() # 先查询是否已存在相同chat_id和问题的记录 existing = ( ThinkingBack.select() .where( (ThinkingBack.chat_id == chat_id) & (ThinkingBack.question == question) ) .order_by(ThinkingBack.update_time.desc()) .limit(1) ) if existing.exists(): # 更新现有记录 record = existing.get() record.context = context record.found_answer = found_answer record.answer = answer record.thinking_steps = json.dumps(thinking_steps, ensure_ascii=False) record.update_time = now record.save() logger.info(f"已更新思考过程到数据库，问题: {question[:50]}...") else: # 创建新记录 ThinkingBack.create( chat_id=chat_id, question=question, context=context, found_answer=found_answer, answer=answer, thinking_steps=json.dumps(thinking_steps, ensure_ascii=False), create_time=now, update_time=now ) logger.info(f"已创建思考过程到数据库，问题: {question[:50]}...") except Exception as e: logger.error(f"存储思考过程失败: {e}") async def _process_single_question( question: str, chat_id: str, context: str, initial_info: str = "" ) -> Optional[str]: """处理单个问题的查询（包含缓存检查逻辑） Args: question: 要查询的问题 chat_id: 聊天ID context: 上下文信息 initial_info: 初始信息（如概念检索结果），将传递给ReAct Agent Returns: Optional[str]: 如果找到答案，返回格式化的结果字符串，否则返回None """ logger.info(f"开始处理问题: {question}") # 先检查thinking_back数据库中是否有现成答案 cached_result = _query_thinking_back(chat_id, question) should_requery = False if cached_result: cached_found_answer, cached_answer = cached_result # 根据found_answer的值决定是否重新查询 if cached_found_answer: # found_answer == 1 (True) # found_answer == 1：20%概率重新查询 if random.random() < 0.2: should_requery = True logger.info(f"found_answer=1，触发20%概率重新查询，问题: {question[:50]}...") else: # found_answer == 0 (False) # found_answer == 0：40%概率重新查询 if random.random() < 0.4: should_requery = True logger.info(f"found_answer=0，触发40%概率重新查询，问题: {question[:50]}...") # 如果不需要重新查询，使用缓存答案 if not should_requery: if cached_answer: logger.info(f"从thinking_back缓存中获取答案，问题: {question[:50]}...") return f"问题：{question}\n答案：{cached_answer}" else: # 缓存中没有答案，需要查询 should_requery = True # 如果没有缓存答案或需要重新查询，使用ReAct Agent查询 if not cached_result or should_requery: if should_requery: logger.info(f"概率触发重新查询，使用ReAct Agent查询，问题: {question[:50]}...") else: logger.info(f"未找到缓存答案，使用ReAct Agent查询，问题: {question[:50]}...") found_answer, answer, thinking_steps, is_timeout = await _react_agent_solve_question( question=question, chat_id=chat_id, max_iterations=5, timeout=120.0, initial_info=initial_info ) # 存储到数据库（超时时不存储） if not is_timeout: _store_thinking_back( chat_id=chat_id, question=question, context=context, found_answer=found_answer, answer=answer, thinking_steps=thinking_steps ) else: logger.info(f"ReAct Agent超时，不存储到数据库，问题: {question[:50]}...") if found_answer and answer: return f"问题：{question}\n答案：{answer}" return None async def build_memory_retrieval_prompt( message: str, sender: str, target: str, chat_stream, tool_executor, ) -> str: """构建记忆检索提示 使用两段式查询：第一步生成问题，第二步使用ReAct Agent查询答案 Args: message: 聊天历史记录 sender: 发送者名称 target: 目标消息内容 chat_stream: 聊天流对象 tool_executor: 工具执行器（保留参数以兼容接口） Returns: str: 记忆检索结果字符串 """ start_time = time.time() logger.info(f"检测是否需要回忆，元消息：{message[:30]}...，消息长度: {len(message)}") try: time_now = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) bot_name = global_config.bot.nickname chat_id = chat_stream.stream_id # 获取最近查询历史（最近1小时内的查询） recent_query_history = _get_recent_query_history(chat_id, time_window_seconds=300.0) if not recent_query_history: recent_query_history = "最近没有查询记录。" # 第一步：生成问题 question_prompt = await global_prompt_manager.format_prompt( "memory_retrieval_question_prompt", bot_name=bot_name, time_now=time_now, chat_history=message, recent_query_history=recent_query_history, sender=sender, target_message=target, ) success, response, reasoning_content, model_name = await llm_api.generate_with_model( question_prompt, model_config=model_config.model_task_config.tool_use, request_type="memory.question", ) logger.info(f"记忆检索问题生成提示词: {question_prompt}") logger.info(f"记忆检索问题生成响应: {response}") if not success: logger.error(f"LLM生成问题失败: {response}") return "" # 解析概念列表和问题列表 concepts, questions = _parse_questions_json(response) logger.info(f"解析到 {len(concepts)} 个概念: {concepts}") logger.info(f"解析到 {len(questions)} 个问题: {questions}") # 对概念进行jargon检索，作为初始信息 initial_info = "" if concepts: logger.info(f"开始对 {len(concepts)} 个概念进行jargon检索") initial_info = await _retrieve_concepts_with_jargon(concepts, chat_id) if initial_info: logger.info(f"概念检索完成，结果: {initial_info[:200]}...") else: logger.info("概念检索未找到任何结果") # 获取缓存的记忆（与question时使用相同的时间窗口和数量限制） cached_memories = _get_cached_memories(chat_id, time_window_seconds=300.0) if not questions: logger.debug("模型认为不需要检索记忆或解析失败") # 即使没有当次查询，也返回缓存的记忆和概念检索结果 all_results = [] if initial_info: all_results.append(initial_info.strip()) if cached_memories: all_results.extend(cached_memories) if all_results: retrieved_memory = "\n\n".join(all_results) end_time = time.time() logger.info(f"无当次查询，返回缓存记忆和概念检索结果，耗时: {(end_time - start_time):.3f}秒") return f"你回忆起了以下信息：\n{retrieved_memory}\n如果与回复内容相关，可以参考这些回忆的信息。\n" else: return "" logger.info(f"解析到 {len(questions)} 个问题: {questions}") # 第二步：并行处理所有问题（固定使用5次迭代/120秒超时） logger.info(f"问题数量: {len(questions)}，固定设置最大迭代次数: 5，超时时间: 120秒") # 并行处理所有问题，将概念检索结果作为初始信息传递 question_tasks = [ _process_single_question( question=question, chat_id=chat_id, context=message, initial_info=initial_info ) for question in questions ] # 并行执行所有查询任务 results = await asyncio.gather(*question_tasks, return_exceptions=True) # 收集所有有效结果 all_results = [] current_questions = set() # 用于去重，避免缓存和当次查询重复 for i, result in enumerate(results): if isinstance(result, Exception): logger.error(f"处理问题 '{questions[i]}' 时发生异常: {result}") elif result is not None: all_results.append(result) # 提取问题用于去重 if result.startswith("问题："): question = result.split("\n")[0].replace("问题：", "").strip() current_questions.add(question) # 将缓存的记忆添加到结果中（排除当次查询已包含的问题，避免重复） for cached_memory in cached_memories: if cached_memory.startswith("问题："): question = cached_memory.split("\n")[0].replace("问题：", "").strip() # 只有当次查询中没有相同问题时，才添加缓存记忆 if question not in current_questions: all_results.append(cached_memory) logger.debug(f"添加缓存记忆: {question[:50]}...") end_time = time.time() if all_results: retrieved_memory = "\n\n".join(all_results) logger.info(f"记忆检索成功，耗时: {(end_time - start_time):.3f}秒，包含 {len(all_results)} 条记忆（含缓存）") return f"你回忆起了以下信息：\n{retrieved_memory}\n如果与回复内容相关，可以参考这些回忆的信息。\n" else: logger.debug("所有问题均未找到答案，且无缓存记忆") return "" except Exception as e: logger.error(f"记忆检索时发生异常: {str(e)}") return "" def _parse_questions_json(response: str) -> Tuple[List[str], List[str]]: """解析问题JSON，返回概念列表和问题列表 Args: response: LLM返回的响应 Returns: Tuple[List[str], List[str]]: (概念列表, 问题列表) """ try: # 尝试提取JSON（可能包含在```json代码块中） json_pattern = r"```json\s*(.*?)\s*```" matches = re.findall(json_pattern, response, re.DOTALL) if matches: json_str = matches[0] else: # 尝试直接解析整个响应 json_str = response.strip() # 修复可能的JSON错误 repaired_json = repair_json(json_str) # 解析JSON parsed = json.loads(repaired_json) # 只支持新格式：包含concepts和questions的对象 if not isinstance(parsed, dict): logger.warning(f"解析的JSON不是对象格式: {parsed}") return [], [] concepts_raw = parsed.get("concepts", []) questions_raw = parsed.get("questions", []) # 确保是列表 if not isinstance(concepts_raw, list): concepts_raw = [] if not isinstance(questions_raw, list): questions_raw = [] # 确保所有元素都是字符串 concepts = [c for c in concepts_raw if isinstance(c, str) and c.strip()] questions = [q for q in questions_raw if isinstance(q, str) and q.strip()] return concepts, questions except Exception as e: logger.error(f"解析问题JSON失败: {e}, 响应内容: {response[:200]}...") return [], []