long_term.py 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290
  1. """长期知识记忆:基于 Chroma 向量库存储 Gap / Innovation / 通用知识
  2. - 与 RAG 模块共用 Embedder(从 backend.rag.embedding 导入),但使用独立 collection
  3. - Embedder 与 Chroma 均较重,采用懒加载
  4. - 所有 IO 操作异步化(Chroma 为同步接口,用 asyncio.to_thread 包装)
  5. """
  6. from __future__ import annotations
  7. import asyncio
  8. import uuid
  9. from typing import Any, Optional
  10. # 尝试从 RAG 模块导入 Embedder;若依赖未装或模块尚未实现,则兜底为 None,不影响模块定义
  11. try:
  12. from backend.rag.embedding import Embedder # type: ignore
  13. except Exception: # noqa: BLE001 - 兜底导入,任何失败都降级为 None
  14. Embedder = None # type: ignore
  15. from backend.config import settings
  16. # 长期知识使用的独立 collection 名称
  17. LONG_TERM_COLLECTION = "long_term_knowledge"
  18. def _gap_to_text(gap: Any) -> str:
  19. """将 Gap 模型转为可向量化的文本"""
  20. # 兼容 pydantic 模型与普通对象
  21. gap_type = getattr(getattr(gap, "gap_type", None), "value", getattr(gap, "gap_type", ""))
  22. source_papers = getattr(gap, "source_papers", []) or []
  23. source_str = "; ".join(source_papers) if source_papers else "无"
  24. return (
  25. f"【研究空白 / {gap_type}】\n"
  26. f"描述:{getattr(gap, 'description', '')}\n"
  27. f"来源论文:{source_str}\n"
  28. f"论证:{getattr(gap, 'evidence', '')}\n"
  29. f"置信度:{getattr(gap, 'confidence', '')}"
  30. )
  31. def _innovation_to_text(innovation: Any) -> str:
  32. """将 Innovation 模型转为可向量化的文本"""
  33. source = getattr(getattr(innovation, "source", None), "value", getattr(innovation, "source", ""))
  34. score = getattr(innovation, "score", None)
  35. score_str = ""
  36. if score is not None:
  37. novelty = getattr(score, "novelty", "")
  38. feasibility = getattr(score, "feasibility", "")
  39. significance = getattr(score, "significance", "")
  40. score_str = f"新颖性={novelty} 可行性={feasibility} 显著性={significance}"
  41. return (
  42. f"【创新点 / {source}】\n"
  43. f"标题:{getattr(innovation, 'title', '')}\n"
  44. f"思路:{getattr(innovation, 'idea', '')}\n"
  45. f"Gap 来源:{getattr(innovation, 'gap_origin', '')}\n"
  46. f"评分:{score_str}\n"
  47. f"论据支撑:{getattr(innovation, 'supporting_evidence', '')}"
  48. )
  49. def _flatten_metadata(metadata: dict) -> dict:
  50. """将 metadata 中的复杂类型扁平化为 Chroma 支持的基本类型(str/int/float/bool/None)"""
  51. flat: dict[str, Any] = {}
  52. for k, v in (metadata or {}).items():
  53. if v is None or isinstance(v, (str, int, float, bool)):
  54. flat[k] = v
  55. else:
  56. # 列表/字典等转为字符串
  57. flat[k] = str(v)
  58. return flat
  59. class LongTermMemory:
  60. """长期知识记忆:向量库存储与语义检索
  61. 每条知识条目结构:{type: gap/innovation/knowledge, content, metadata}
  62. """
  63. def __init__(self) -> None:
  64. # 懒加载:仅在首次使用时初始化 Embedder 与 Chroma
  65. self._embedder: Any = None
  66. self._embedder_loaded: bool = False
  67. self._client: Any = None
  68. self._collection: Any = None
  69. # ---------- 懒加载 ----------
  70. def _get_embedder(self) -> Any:
  71. """懒加载 Embedder 实例"""
  72. if not self._embedder_loaded:
  73. self._embedder_loaded = True
  74. if Embedder is None:
  75. raise RuntimeError(
  76. "Embedder 不可用:backend.rag.embedding 导入失败"
  77. "(请安装 sentence-transformers 并实现 Embedder)"
  78. )
  79. # Embedder 可能是类或工厂,统一实例化
  80. self._embedder = Embedder()
  81. return self._embedder
  82. def _get_collection(self) -> Any:
  83. """懒加载 Chroma collection(同步,仅在主线程初始化一次)"""
  84. if self._collection is None:
  85. import chromadb # 局部导入,避免模块加载即依赖
  86. path = str(settings.CHROMA_PATH)
  87. # PersistentClient 将数据持久化到磁盘
  88. self._client = chromadb.PersistentClient(path=path)
  89. self._collection = self._client.get_or_create_collection(
  90. name=LONG_TERM_COLLECTION,
  91. metadata={"description": "Paper Innovation Agent 长期知识记忆"},
  92. )
  93. return self._collection
  94. async def _embed(self, texts: list[str]) -> list[list[float]]:
  95. """异步向量化文本列表,兼容同步/异步 Embedder 接口
  96. 依次尝试:aembed(异步)-> embed(同步,丢入线程池)-> encode(同步,丢入线程池)
  97. """
  98. embedder = self._get_embedder()
  99. # 1. 异步接口优先
  100. aembed = getattr(embedder, "aembed", None)
  101. if callable(aembed):
  102. result = await aembed(texts)
  103. return self._normalize_embeddings(result)
  104. # 2. 同步 embed 接口
  105. embed = getattr(embedder, "embed", None)
  106. if callable(embed):
  107. result = await asyncio.to_thread(embed, texts)
  108. return self._normalize_embeddings(result)
  109. # 3. sentence-transformers 风格 encode
  110. encode = getattr(embedder, "encode", None)
  111. if callable(encode):
  112. result = await asyncio.to_thread(encode, texts)
  113. return self._normalize_embeddings(result)
  114. raise RuntimeError("Embedder 未提供 aembed/embed/encode 方法")
  115. @staticmethod
  116. def _normalize_embeddings(result: Any) -> list[list[float]]:
  117. """将各种返回形态统一为 list[list[float]]"""
  118. # numpy ndarray / tensor 等
  119. if hasattr(result, "tolist"):
  120. result = result.tolist()
  121. # 嵌套列表直接返回
  122. if result and isinstance(result[0], (list, tuple)):
  123. return [list(v) for v in result]
  124. # 单条向量被压平的情况(不太可能,兜底)
  125. return [list(result)]
  126. # ---------- 写入 ----------
  127. async def _add(self, entry_type: str, content: str, metadata: dict) -> str:
  128. """通用写入:向量化 content 并存入 Chroma"""
  129. # 生成唯一 id
  130. entry_id = f"{entry_type}_{uuid.uuid4().hex[:12]}"
  131. flat_meta = _flatten_metadata({"type": entry_type, **metadata})
  132. # 向量化(异步)
  133. embeddings = await self._embed([content])
  134. # Chroma 写入为同步阻塞操作,丢入线程池
  135. collection = self._get_collection()
  136. def _do_add() -> None:
  137. collection.add(
  138. ids=[entry_id],
  139. documents=[content],
  140. metadatas=[flat_meta],
  141. embeddings=embeddings,
  142. )
  143. await asyncio.to_thread(_do_add)
  144. return entry_id
  145. async def save_gap(self, gap: Any) -> str:
  146. """保存 Gap 到长期记忆
  147. Args:
  148. gap: Gap 模型实例(backend.models.schemas.Gap)
  149. Returns:
  150. 存入向量库的条目 id
  151. """
  152. content = _gap_to_text(gap)
  153. gap_type = getattr(getattr(gap, "gap_type", None), "value", getattr(gap, "gap_type", ""))
  154. metadata = {
  155. "gap_type": gap_type,
  156. "source_papers": getattr(gap, "source_papers", []),
  157. "confidence": getattr(gap, "confidence", 1.0),
  158. "description": getattr(gap, "description", ""),
  159. }
  160. return await self._add("gap", content, metadata)
  161. async def save_innovation(self, innovation: Any) -> str:
  162. """保存 Innovation 到长期记忆
  163. Args:
  164. innovation: Innovation 模型实例
  165. Returns:
  166. 存入向量库的条目 id
  167. """
  168. content = _innovation_to_text(innovation)
  169. source = getattr(getattr(innovation, "source", None), "value", getattr(innovation, "source", ""))
  170. score = getattr(innovation, "score", None)
  171. metadata = {
  172. "title": getattr(innovation, "title", ""),
  173. "source": source,
  174. "gap_origin": getattr(innovation, "gap_origin", ""),
  175. "novelty": getattr(score, "novelty", 0.0) if score else 0.0,
  176. "feasibility": getattr(score, "feasibility", 0.0) if score else 0.0,
  177. "significance": getattr(score, "significance", 0.0) if score else 0.0,
  178. }
  179. return await self._add("innovation", content, metadata)
  180. async def save_knowledge(self, content: str, metadata: Optional[dict] = None) -> str:
  181. """保存通用知识条目
  182. Args:
  183. content: 知识文本
  184. metadata: 附加元数据
  185. Returns:
  186. 存入向量库的条目 id
  187. """
  188. return await self._add("knowledge", content, metadata or {})
  189. # ---------- 检索 ----------
  190. async def search(
  191. self,
  192. query: str,
  193. top_k: int = 5,
  194. filter_type: Optional[str] = None,
  195. ) -> list[dict]:
  196. """语义检索相关历史记忆
  197. Args:
  198. query: 查询文本
  199. top_k: 返回条数上限
  200. filter_type: 可选,按类型过滤(gap/innovation/knowledge)
  201. Returns:
  202. 命中条目列表,每条 {id, type, content, metadata, distance}
  203. """
  204. query_embeddings = await self._embed([query])
  205. collection = self._get_collection()
  206. where = {"type": filter_type} if filter_type else None
  207. def _do_query() -> dict:
  208. return collection.query(
  209. query_embeddings=query_embeddings,
  210. n_results=top_k,
  211. where=where,
  212. )
  213. result = await asyncio.to_thread(_do_query)
  214. # 解析 Chroma 返回结构(每项都是 list[list[...]],对应批量查询)
  215. ids_batch = result.get("ids", [[]])
  216. docs_batch = result.get("documents", [[]])
  217. metas_batch = result.get("metadatas", [[]])
  218. dists_batch = result.get("distances", [[]])
  219. ids = ids_batch[0] if ids_batch else []
  220. docs = docs_batch[0] if docs_batch else []
  221. metas = metas_batch[0] if metas_batch else []
  222. dists = dists_batch[0] if dists_batch else []
  223. items: list[dict] = []
  224. for i, doc in enumerate(docs):
  225. meta = metas[i] if i < len(metas) else {}
  226. items.append({
  227. "id": ids[i] if i < len(ids) else "",
  228. "type": meta.get("type", ""),
  229. "content": doc,
  230. "metadata": meta,
  231. "distance": dists[i] if i < len(dists) else None,
  232. })
  233. return items
  234. async def load_relevant(self, query: str, top_k: int = 5) -> list[dict]:
  235. """加载与查询相关的历史 Gap 和 Innovation(用于创新点去重)
  236. 分别按 gap / innovation 类型检索,合并后按距离排序取 top_k
  237. """
  238. # 每类各取 top_k,合并后截断
  239. gaps = await self.search(query, top_k=top_k, filter_type="gap")
  240. innovations = await self.search(query, top_k=top_k, filter_type="innovation")
  241. merged = gaps + innovations
  242. # 距离越小越相关,升序排序
  243. merged.sort(key=lambda x: x.get("distance") if x.get("distance") is not None else float("inf"))
  244. return merged[:top_k]