Hypergraph is more powerful. Transform unstructured text into structured knowledge with LLMs. Graphs, hypergraphs, and spatio-temporal extractions — with one command.
重构知识提取和集合类,添加通用实现,优化异步解析和存储功能
yifanfeng974331aa0a9660
diff --git a/src/knowledge/base.py b/src/knowledge/base.pyindex adc0746..f2a4579 100644--- a/src/knowledge/base.py+++ b/src/knowledge/base.py@@ -1,94 +1,329 @@+import asynciofrom abc import ABC, abstractmethod-from typing import TypeVar, Generic, Any, Dict+from typing import TypeVar, Generic, Any, Dict, Optional, Type, List, Callable+from datetime import datetimefrom pydantic import BaseModelfrom langchain_core.language_models.chat_models import BaseChatModelfrom langchain_core.embeddings import Embeddings+try:+ from src.config import logger+except ImportError:+ import logging+ logger = logging.getLogger(__name__)+T = TypeVar("T", bound=BaseModel)-class BaseKnowledge(ABC, Generic[T]):+# ===================== 提取器 (Extractor) =====================+++class BaseExtractor(ABC, Generic[T]):"""- 智能知识容器基类。+ 矿工 - 无状态提取器基类。++ 职责:从文本中提取结构化知识,不负责存储或融合。+ """++ def __init__(self, llm_client: BaseChatModel, schema_class: Type[T]):+ """+ :param llm_client: LangChain 的 ChatModel 实例+ :param schema_class: 期望的返回 Schema 类(必须继承 BaseModel)+ """+ self.llm_client = llm_client+ self.schema_class = schema_class+ @abstractmethod+ async def aparse(self, text: str, **kwargs) -> T:+ """+ 异步解析文本,返回单个知识对象。++ :param text: 输入文本+ :return: 解析后的知识对象+ """+ pass++ def parse(self, text: str, **kwargs) -> T:+ """+ 同步解析(子类可覆盖为真正的同步实现)。++ 默认行为:需要在异步上下文中调用 aparse。+ """+ try:+ loop = asyncio.get_event_loop()+ if loop.is_running():+ raise RuntimeError("Cannot use parse() in async context. Use aparse() instead.")+ return loop.run_until_complete(self.aparse(text, **kwargs))+ except RuntimeError:+ raise++ async def batch_parse(self, texts: List[str], **kwargs) -> List[T]:+ """+ 批量解析多个文本。++ :param texts: 文本列表+ :return: 解析结果列表+ """+ tasks = [self.aparse(text, **kwargs) for text in texts]+ return await asyncio.gather(*tasks)++ async def batch_parse_concurrent(+ self,+ texts: List[str],+ max_concurrent: int = 5,+ **kwargs+ ) -> List[T]:+ """+ 带并发限制的批量解析。++ :param texts: 文本列表+ :param max_concurrent: 最大并发数+ :return: 解析结果列表+ """+ from asyncio import Semaphore- 核心特性:- 1. 持有 LLM 实例:它是"活"的,知道如何利用 LLM 处理数据。- 2. 极简生命周期:Extract -> Evolve -> Search -> Dump。+ semaphore = Semaphore(max_concurrent)++ async def limited_parse(text: str) -> T:+ async with semaphore:+ return await self.aparse(text, **kwargs)++ tasks = [limited_parse(text) for text in texts]+ return await asyncio.gather(*tasks)++++++# ===================== 集合/容器 (Collection) =====================+++class BaseCollection(ABC, Generic[T]):+ """+ 仓库 - 有状态集合基类。++ 职责:存储知识点、融合去重、演化优化、序列化。"""def __init__(self,llm_client: BaseChatModel,embedder: Embeddings,+ schema_class: Type[T],storage: str = "memory",**kwargs,):"""- :param llm_client: LangChain 的 ChatModel 实例或兼容的 LLM 客户端。- :param embedder: LangChain 的 Embeddings 实例或兼容的向量化客户端。- :param storage: 后端存储类型。默认为 "memory",也可以是数据库类型如 "postgres"、"mongodb" 等。+ :param llm_client: LLM 实例(用于演化等操作)+ :param embedder: 向量化器实例(用于语义搜索等)+ :param schema_class: 容器持有的知识 Schema 类+ :param storage: 存储后端类型("memory"、"postgres" 等)"""self.llm_client = llm_clientself.embedder = embedder+ self.schema_class = schema_classself.storage = storageself.metadata: Dict[str, Any] = {}- # ================= 1. 提取 (Extract) [核心方法] =================+ # ================= 存储层 =================@abstractmethod- async def extract(self, text: str, **kwargs) -> T:+ async def add(self, item_id: str, item: T, **kwargs):+ """+ 添加知识点。++ :param item_id: 唯一标识符+ :param item: 知识对象"""- 核心提取逻辑。从原始数据中提取对应类型的知识。+ pass- 职责:- 1. 构造 Prompt。- 2. 调用 self.llm 对 text 进行分析。- 3. 解析返回结果。- 4. 【重要】返回提取出的知识对象。+ @abstractmethod+ async def remove(self, item_id: str, **kwargs) -> bool:+ """+ 删除知识点。++ :return: 是否成功删除+ """+ pass- 注意:这里的实现可以很复杂,可以包含 '提取' -> '清洗' -> '去重合并' 的全过程。+ @abstractmethod+ async def update(self, item_id: str, item: T, **kwargs):+ """+ 更新知识点。++ :param item_id: 知识点 ID+ :param item: 新的知识对象"""pass- # ================= 2. 演化 (Evolve) [可选实现] =================+ @abstractmethod+ def get(self, item_id: str) -> Optional[T]:+ """获取单个知识点"""+ pass- async def evolve(self, **kwargs):+ @abstractmethod+ def list_all(self) -> List[T]:+ """列出所有知识点"""+ pass++ @abstractmethod+ def search(self, filter_fn: Callable[[T], bool]) -> List[T]:"""- 知识演化/内省逻辑。+ 按条件查询知识点。++ :param filter_fn: 过滤函数+ """+ pass- 默认行为:什么都不做(并非所有知识都需要演化)。+ @abstractmethod+ def size(self) -> int:+ """返回容器中知识点的数量"""+ pass++ # ================= 融合层 =================- 子类用途:- - 图卷积 (Convolution):传播节点属性。- - 聚类 (Clustering):发现社区。- - 剪枝 (Pruning):删除置信度低的边。- - 推理 (Reasoning):基于现有知识生成新知识。+ @abstractmethod+ async def aggregate(self, items: List[T], **kwargs) -> Dict[str, Any]:+ """+ 融合多个知识点。++ 职责:清洗、去重、合并。++ :param items: 新提取的知识点列表+ :return: 融合统计信息(去重数、合并数等)"""pass- # ================= 3. 查询与搜索 (Search) =================+ async def fuse_batch(self, new_items: List[T], iteration: int = 0) -> Dict[str, Any]:+ """+ 融合一批新知识点到容器中。++ :param new_items: 新提取的知识点+ :param iteration: 迭代号+ :return: 融合统计信息+ """+ start_time = datetime.now()++ try:+ # 应用融合策略+ stats = await self.aggregate(new_items, iteration=iteration)++ stats["timestamp"] = start_time.isoformat()+ stats["duration_ms"] = (datetime.now() - start_time).total_seconds() * 1000+ stats["iteration"] = iteration++ logger.info(f"Fused batch: {stats}")+ return stats++ except Exception as e:+ logger.error(f"Error during fuse_batch: {e}")+ raise++ # ================= 演化层 =================@abstractmethod- async def search(self, query: str, **kwargs) -> Any:+ async def evolve(self, **kwargs) -> Dict[str, Any]:"""- 在当前已有的知识中进行查询。- 可以是语义搜索、关系查询或简单条件过滤。+ 演化内部知识。++ 职责:推理新关系、剪枝低置信度、聚类等高级操作。++ :return: 演化统计信息"""pass- # ================= 4. 读写操作 (Load & Dump) =================+ # ================= 高级流程 =================++ async def iterative_fuse_and_parse(+ self,+ extractor: "BaseExtractor[T]",+ texts: List[str],+ max_iterations: int = 3,+ convergence_threshold: float = 0.95,+ ) -> Dict[str, Any]:+ """+ 迭代提取与融合流程。++ 流程:+ 1. 第一次提取:从文本中提取所有知识点+ 2. 融合去重+ 3. 演化优化+ 4. 重复直到收敛或达到最大迭代数++ :param extractor: 知识提取器+ :param texts: 输入文本列表+ :param max_iterations: 最大迭代数+ :param convergence_threshold: 收敛阈值+ :return: 迭代结果摘要+ """+ iteration = 0+ previous_size = 0+ fusion_stats = []++ while iteration < max_iterations:+ logger.info(f"Iteration {iteration}: extracting...")++ # 1. 提取新知识+ extracted = await extractor.batch_parse(texts)++ # 2. 融合+ logger.info(f"Iteration {iteration}: fusing...")+ fuse_result = await self.fuse_batch(extracted, iteration)+ fusion_stats.append(fuse_result)++ # 3. 演化+ logger.info(f"Iteration {iteration}: evolving...")+ evolve_result = await self.evolve(iteration=iteration)++ # 4. 检查收敛+ current_size = self.size()+ logger.info(f"Iteration {iteration}: size={current_size}")++ if previous_size > 0:+ growth_rate = (current_size - previous_size) / previous_size+ if growth_rate < (1 - convergence_threshold):+ logger.info(+ f"Converged at iteration {iteration} (growth_rate={growth_rate})"+ )+ break++ previous_size = current_size+ iteration += 1++ await asyncio.sleep(0.1)++ return {+ "final_iteration": iteration,+ "total_items": self.size(),+ "fusion_history": fusion_stats,+ }++ # ================= 序列化 =================@abstractmethod- def load(self, data: Any, **kwargs):+ def dump(self, format: str = "json") -> Any:"""- 从外部恢复知识。数据可以是 dict, json string 或文件路径。+ 导出容器内的知识。++ :param format: 格式 ("json", "dict" 等)"""pass@abstractmethod- def dump(self, format: str = "json") -> Any:+ def load(self, data: Any, **kwargs):"""- 将内部知识导出为标准格式。+ 从外部数据恢复知识。++ :param data: 外部数据 (dict, json string 或文件路径)"""pass++ def clear(self):+ """清空所有知识点(可选实现)"""+ pass+++# ===================== 通用实现 =====================+++diff --git a/src/knowledge/generic.py b/src/knowledge/generic.pynew file mode 100644index 0000000..75af59b--- /dev/null+++ b/src/knowledge/generic.py@@ -0,0 +1,204 @@+"""+通用 Generic 实现。++包含基于 BaseExtractor 和 BaseCollection 的具体实现。+"""++import os+import json+from typing import List, Dict, Any, Callable, Optional, Type+from datetime import datetime+from pydantic import BaseModel, ValidationError+from langchain_core.language_models.chat_models import BaseChatModel+from langchain_core.embeddings import Embeddings++from .base import BaseExtractor, BaseCollection, T++try:+ from src.config import logger+except ImportError:+ import logging+ logger = logging.getLogger(__name__)+++class GenericExtractor(BaseExtractor[T]):+ """+ 通用提取器。使用 LLM 的 with_structured_output 实现提取。+ """++ async def aparse(self, text: str, **kwargs) -> T:+ """+ 使用 with_structured_output 异步解析。+ """+ try:+ # 创建支持结构化输出的 LLM+ structured_llm = self.llm_client.with_structured_output(self.schema_class)++ # 调用 LLM+ result: T = await structured_llm.ainvoke(text)++ logger.info(f"Successfully parsed: {type(result).__name__}")+ return result++ except ValidationError as e:+ logger.error(f"Schema validation failed: {e}")+ raise+ except Exception as e:+ logger.error(f"Error during parsing: {e}")+ raise+++class GenericCollection(BaseCollection[T]):+ """+ 通用集合实现。支持任何 Pydantic BaseModel Schema。+ """++ def __init__(+ self,+ llm_client: BaseChatModel,+ embedder: Embeddings,+ schema_class: Type[T],+ storage: str = "memory",+ **kwargs,+ ):+ """+ :param llm_client: LLM 实例+ :param embedder: 向量化器实例+ :param schema_class: Schema 类+ :param storage: 存储类型+ """+ super().__init__(llm_client, embedder, schema_class, storage, **kwargs)+ self._items: Dict[str, T] = {}+ self._updated_at: Dict[str, datetime] = {}++ # ================= 存储层实现 =================++ async def add(self, item_id: str, item: T, **kwargs):+ """添加知识点"""+ self._items[item_id] = item+ self._updated_at[item_id] = datetime.now()+ logger.info(f"Added item: {item_id}")++ async def remove(self, item_id: str, **kwargs) -> bool:+ """删除知识点"""+ if item_id in self._items:+ del self._items[item_id]+ del self._updated_at[item_id]+ logger.info(f"Removed item: {item_id}")+ return True+ return False++ async def update(self, item_id: str, item: T, **kwargs):+ """更新知识点"""+ if item_id in self._items:+ self._items[item_id] = item+ self._updated_at[item_id] = datetime.now()+ logger.info(f"Updated item: {item_id}")+ else:+ await self.add(item_id, item, **kwargs)++ def get(self, item_id: str) -> Optional[T]:+ """获取单个知识点"""+ return self._items.get(item_id)++ def list_all(self) -> List[T]:+ """列出所有知识点"""+ return list(self._items.values())++ def search(self, filter_fn: Callable[[T], bool]) -> List[T]:+ """按条件查询"""+ return [item for item in self._items.values() if filter_fn(item)]++ def size(self) -> int:+ """返回知识点数量"""+ return len(self._items)++ def clear(self):+ """清空所有知识点"""+ self._items.clear()+ self._updated_at.clear()+ logger.info("Cleared all items")++ # ================= 融合层实现 =================++ async def aggregate(self, items: List[T], **kwargs) -> Dict[str, Any]:+ """+ 默认融合实现:简单去重合并。++ 子类可覆盖此方法实现更复杂的融合逻辑。+ """+ logger.info(f"Aggregating {len(items)} items...")++ # 简单的聚合:直接添加到容器+ for idx, item in enumerate(items):+ item_id = f"item_{len(self._items)}_{idx}"+ await self.add(item_id, item)++ return {+ "input_count": len(items),+ "output_count": len(items),+ "deduplicated": 0,+ }++ # ================= 演化层实现 =================++ async def evolve(self, **kwargs) -> Dict[str, Any]:+ """+ 默认演化实现:空操作。++ 子类可覆盖此方法实现知识演化、推理、剪枝等逻辑。+ """+ logger.debug("Default evolve: no operation")+ return {"evolved": False, "message": "Default implementation"}++ # ================= 序列化实现 =================++ def dump(self, format: str = "json") -> Any:+ """导出容器内的知识"""+ if not self._items:+ logger.warning("No items to dump")+ return None++ try:+ if format.lower() == "json":+ data = {+ k: v.model_dump() for k, v in self._items.items()+ }+ return json.dumps(data, indent=2, ensure_ascii=False)++ elif format.lower() == "dict":+ return {k: v.model_dump() for k, v in self._items.items()}++ else:+ raise ValueError(f"Unsupported format: {format}")++ except Exception as e:+ logger.error(f"Error dumping: {e}")+ raise++ def load(self, data: Any, **kwargs):+ """从外部数据恢复知识"""+ try:+ if isinstance(data, str):+ # 检查是否是文件路径+ if os.path.isfile(data):+ with open(data, "r", encoding="utf-8") as f:+ data = json.load(f)+ logger.info(f"Loaded from file: {data}")+ else:+ # 尝试解析为 JSON 字符串+ data = json.loads(data)+ logger.info("Loaded from JSON string")++ # 恢复为 Schema 对象+ if isinstance(data, dict):+ for item_id, item_data in data.items():+ item = self.schema_class.model_validate(item_data)+ self._items[item_id] = item+ self._updated_at[item_id] = datetime.now()++ logger.info(f"Loaded {len(self._items)} items")++ except Exception as e:+ logger.error(f"Error loading: {e}")+ raisediff --git a/src/knowledge/graph/base.py b/src/knowledge/graph/base.pyindex 5999216..260296b 100644--- a/src/knowledge/graph/base.py+++ b/src/knowledge/graph/base.py@@ -17,11 +17,6 @@ class Entity(BaseModel):description: Optional[str] = Field(None, description="A brief summary of the entity found in the text.")- # Using a dict allows storing extra attributes without changing the schema structure- properties: Dict[str, Any] = Field(- default_factory=dict,- description="Additional attributes (e.g., {'age': 50, 'status': 'active'}).",- )class Relationship(BaseModel):@@ -35,10 +30,6 @@ class Relationship(BaseModel):description: Optional[str] = Field(None, description="Contextual details about this relationship.")- weight: float = Field(- 1.0,- description="The confidence score or strength of the connection (0.0 to 1.0).",- )class GraphSchema(BaseModel):@@ -56,12 +47,12 @@ class SimpleGraph(BaseKnowledge[GraphSchema]):def _get_schema_class(self):return GraphSchema- async def extract(self, text: str, **kwargs):+ async def aextract(self, text: str, **kwargs):# 1. 构造 promptprompt = f"Extract nodes and edges from: {text}"# 2. 调用自带的 LLM- response = await self.llm.ainvoke(prompt)+ response = await self.llm_client.ainvoke(prompt)# 3. 解析结果 (假设 parsed_data 是解析后的 GraphSchema 对象)parsed_data = self._parse(response)diff --git a/src/storage/base.py b/src/storage/base.pynew file mode 100644index 0000000..e69de29diff --git a/tests/test_knowledge.py b/tests/test_knowledge.pynew file mode 100644index 0000000..bb87eaf--- /dev/null+++ b/tests/test_knowledge.py@@ -0,0 +1,343 @@+"""+测试 Knowledge 类的功能。+"""+import pytest+from typing import List, Optional+from pydantic import BaseModel, Field+from unittest.mock import MagicMock, AsyncMock+import json++from src.knowledge.base import Knowledge+++# 定义测试用的 Schema+class Article(BaseModel):+ """文章 Schema"""+ title: str = Field(..., description="文章标题")+ authors: List[str] = Field(default_factory=list, description="作者列表")+ keywords: List[str] = Field(default_factory=list, description="关键词")+ summary: str = Field(default="", description="摘要")+++class Person(BaseModel):+ """人物 Schema"""+ name: str = Field(..., description="人物名字")+ age: int = Field(..., description="年龄")+ occupation: str = Field(default="", description="职业")+++def mock_llm():+ """创建 mock LLM 客户端"""+ llm = AsyncMock()+ return llm+++def mock_embedder():+ """创建 mock Embeddings 客户端"""+ embedder = MagicMock()+ return embedder+++def article_knowledge(mock_llm, mock_embedder):+ """创建一个 Article 类型的 Knowledge 实例"""+ return Knowledge(+ llm_client=mock_llm,+ embedder=mock_embedder,+ schema_class=Article,+ storage="memory",+ )+++def person_knowledge(mock_llm, mock_embedder):+ """创建一个 Person 类型的 Knowledge 实例"""+ return Knowledge(+ llm_client=mock_llm,+ embedder=mock_embedder,+ schema_class=Person,+ storage="memory",+ )+++class TestKnowledgeInitialization:+ """测试 Knowledge 类的初始化"""++ def test_knowledge_init_with_article_schema(self, article_knowledge):+ """测试使用 Article schema 初始化"""+ assert article_knowledge.schema_class == Article+ assert article_knowledge.storage == "memory"+ assert article_knowledge.data is not None++ def test_knowledge_init_with_initial_data(self, mock_llm, mock_embedder):+ """测试带初始数据的初始化"""+ initial_article = Article(+ title="Test Article",+ authors=["Author 1"],+ keywords=["test"],+ summary="A test article"+ )+ knowledge = Knowledge(+ llm_client=mock_llm,+ embedder=mock_embedder,+ schema_class=Article,+ initial_data=initial_article,+ )+ assert knowledge.data == initial_article+ assert knowledge.data.title == "Test Article"++ def test_knowledge_with_different_schemas(self, mock_llm, mock_embedder):+ """测试使用不同 Schema 的 Knowledge"""+ article_k = Knowledge(+ llm_client=mock_llm,+ embedder=mock_embedder,+ schema_class=Article,+ )+ person_k = Knowledge(+ llm_client=mock_llm,+ embedder=mock_embedder,+ schema_class=Person,+ )+ assert article_k.schema_class == Article+ assert person_k.schema_class == Person+++class TestKnowledgeExtract:+ """测试 Knowledge 的 extract 方法"""++ @pytest.mark.asyncio+ async def test_extract_article(self, article_knowledge, mock_llm):+ """测试提取文章信息"""+ # 模拟 LLM 返回的响应(with_structured_output 直接返回对象)+ expected_article = Article(+ title="AI in 2024",+ authors=["John Doe", "Jane Smith"],+ keywords=["AI", "Machine Learning"],+ summary="An overview of AI trends in 2024"+ )++ # 模拟 with_structured_output 返回的 structured_llm+ mock_structured_llm = AsyncMock()+ mock_structured_llm.ainvoke.return_value = expected_article+ mock_llm.with_structured_output.return_value = mock_structured_llm++ text = "Artificial Intelligence continues to advance in 2024..."+ result = await article_knowledge.extract(text)++ assert result.title == "AI in 2024"+ assert len(result.authors) == 2+ assert "AI" in result.keywords+ assert article_knowledge.data == result++ @pytest.mark.asyncio+ async def test_extract_with_markdown_response(self, article_knowledge, mock_llm):+ """测试 with_structured_output 自动处理响应格式"""+ # 使用 with_structured_output 无需处理 markdown 格式+ expected_article = Article(+ title="Test Article",+ authors=["Author"],+ keywords=["test"],+ summary="Summary"+ )++ mock_structured_llm = AsyncMock()+ mock_structured_llm.ainvoke.return_value = expected_article+ mock_llm.with_structured_output.return_value = mock_structured_llm++ result = await article_knowledge.extract("test text")+ assert result.title == "Test Article"+ assert result.authors[0] == "Author"++ @pytest.mark.asyncio+ async def test_aextract_calls_extract(self, article_knowledge, mock_llm):+ """测试 aextract 方法调用 extract"""+ expected_article = Article(+ title="Test",+ authors=[],+ keywords=[],+ summary=""+ )++ mock_structured_llm = AsyncMock()+ mock_structured_llm.ainvoke.return_value = expected_article+ mock_llm.with_structured_output.return_value = mock_structured_llm++ result = await article_knowledge.aextract("test")+ assert result.title == "Test"+++class TestKnowledgeDump:+ """测试 Knowledge 的 dump 方法"""++ def test_dump_to_json(self, mock_llm, mock_embedder):+ """测试导出为 JSON 格式"""+ article = Article(+ title="Test",+ authors=["Alice"],+ keywords=["test"],+ summary="A test"+ )+ knowledge = Knowledge(+ llm_client=mock_llm,+ embedder=mock_embedder,+ schema_class=Article,+ initial_data=article,+ )++ json_str = knowledge.dump(format="json")+ assert isinstance(json_str, str)+ parsed = json.loads(json_str)+ assert parsed["title"] == "Test"+ assert parsed["authors"] == ["Alice"]++ def test_dump_to_dict(self, mock_llm, mock_embedder):+ """测试导出为字典格式"""+ article = Article(+ title="Test",+ authors=["Alice"],+ keywords=["test"],+ summary="A test"+ )+ knowledge = Knowledge(+ llm_client=mock_llm,+ embedder=mock_embedder,+ schema_class=Article,+ initial_data=article,+ )++ data_dict = knowledge.dump(format="dict")+ assert isinstance(data_dict, dict)+ assert data_dict["title"] == "Test"+++class TestKnowledgeLoad:+ """测试 Knowledge 的 load 方法"""++ def test_load_from_dict(self, mock_llm, mock_embedder):+ """测试从字典加载"""+ knowledge = Knowledge(+ llm_client=mock_llm,+ embedder=mock_embedder,+ schema_class=Article,+ )++ data = {+ "title": "Loaded Article",+ "authors": ["Author1"],+ "keywords": ["loaded"],+ "summary": "Loaded from dict"+ }+ knowledge.load(data)++ assert knowledge.data.title == "Loaded Article"+ assert knowledge.data.authors == ["Author1"]++ def test_load_from_json_string(self, mock_llm, mock_embedder):+ """测试从 JSON 字符串加载"""+ knowledge = Knowledge(+ llm_client=mock_llm,+ embedder=mock_embedder,+ schema_class=Article,+ )++ json_str = json.dumps({+ "title": "JSON Article",+ "authors": ["JSON Author"],+ "keywords": [],+ "summary": ""+ })+ knowledge.load(json_str)++ assert knowledge.data.title == "JSON Article"++ def test_load_invalid_data_raises_error(self, mock_llm, mock_embedder):+ """测试加载无效数据时抛出错误"""+ knowledge = Knowledge(+ llm_client=mock_llm,+ embedder=mock_embedder,+ schema_class=Article,+ )++ # 缺少必需字段+ invalid_data = {"authors": ["Author"]}+ with pytest.raises(Exception):+ knowledge.load(invalid_data)+++class TestKnowledgeSearch:+ """测试 Knowledge 的 search 方法"""++ @pytest.mark.asyncio+ async def test_search_returns_dict(self, mock_llm, mock_embedder):+ """测试 search 返回字典格式的数据"""+ article = Article(+ title="Search Test",+ authors=["Searcher"],+ keywords=["search"],+ summary="Testing search"+ )+ knowledge = Knowledge(+ llm_client=mock_llm,+ embedder=mock_embedder,+ schema_class=Article,+ initial_data=article,+ )++ result = await knowledge.search("search")+ assert isinstance(result, dict)+ assert result["title"] == "Search Test"+++class TestKnowledgeEvolve:+ """测试 Knowledge 的 evolve 和 aevolve 方法"""++ @pytest.mark.asyncio+ async def test_aevolve_default_implementation(self, article_knowledge):+ """测试 aevolve 的默认实现(不做任何操作)"""+ await article_knowledge.aevolve()+ # 如果没有抛出异常,则测试通过+++class TestKnowledgeMultipleSchemas:+ """测试使用多个不同 Schema 的场景"""++ def test_different_schemas_independent(self, mock_llm, mock_embedder):+ """测试不同 Schema 的 Knowledge 相互独立"""+ article_k = Knowledge(+ llm_client=mock_llm,+ embedder=mock_embedder,+ schema_class=Article,+ )+ person_k = Knowledge(+ llm_client=mock_llm,+ embedder=mock_embedder,+ schema_class=Person,+ )++ # 分别为两个 knowledge 加载数据+ article_data = {+ "title": "Article",+ "authors": [],+ "keywords": [],+ "summary": ""+ }+ person_data = {+ "name": "John",+ "age": 30,+ "occupation": "Engineer"+ }++ article_k.load(article_data)+ person_k.load(person_data)++ # 验证数据相互独立+ assert article_k.data.title == "Article"+ assert person_k.data.name == "John"+ assert isinstance(article_k.data, Article)+ assert isinstance(person_k.data, Person)+++if __name__ == "__main__":+ pytest.main([__file__, "-v"])