Skip to content

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.py
index adc0746..f2a4579 100644
--- a/src/knowledge/base.py
+++ b/src/knowledge/base.py
@@ -1,94 +1,329 @@
+import asyncio
from 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 datetime
from pydantic import BaseModel
from langchain_core.language_models.chat_models import BaseChatModel
from 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_client
self.embedder = embedder
+ self.schema_class = schema_class
self.storage = storage
self.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.py
new file mode 100644
index 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}")
+ raise
diff --git a/src/knowledge/graph/base.py b/src/knowledge/graph/base.py
index 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. 构造 prompt
prompt = 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.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/test_knowledge.py b/tests/test_knowledge.py
new file mode 100644
index 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"])