<think>我们之前已经将知识管理系统模块化，现在这个`knowledge_manager.py`是核心模块，它已经去除了可视化功能，只负责数据管理和提供接口。
但是，我们注意到这个重构后的版本仍然包含了`export_knowledge`方法，该方法包含了导出为Markdown和
HTML的功能。
根据模块化原则，导出功能也可以考虑拆分到单独的模块中，以保持核心模块的简洁性。
然而，考虑到导出功能是知识管理的一部分，并且不涉及复杂的可视化，保留在核心模块中也是合理的。
因此，我们可以有两种选择：
1. 保留`export_knowledge`在`KnowledgeManager`中，因为它直接操作知识库数据，并且不依赖外部库（除了标准库）。
2. 将其拆分到另一个模块，比如`knowledge_exporter.py`。
由于导出功能相对独立，且格式可能会扩展（比如PDF、Word等），拆分出去可能更有利于扩展和维护。
但是，根据当前代码，我建议先保留，因为：
- 它不依赖于外部库（除了标准库）
- 代码量不大
- 是知识管理的一个基本功能
另外，我们还可以考虑以下改进点：
1. **性能优化**：当知识库很大时，每次添加知识都重新拟合TF
-IDF向量器可能会很慢。我们可以考虑增量更新或者只在需要时更新。
2. **异常处理**：在文件操作、JSON序列化等地方增加更详细的异常处理。
3. **数据校验**：在添加知识条目时，对输入数据进行校验（比如非空等）。
4. **关系创建的优化**：自动创建关系时，可以设置一个最大关系数，避免每个新知识都与所有知识创建关系。
5. **去重**：在添加知识时，检查是否有重复的知识（基于标题和内容）。
6. **内存管理**：当知识库非常大时，将所有内容加载到内存中可能不是最佳选择，可以考虑使用数据库。
不过，根据问题，我们目前只关注模块化设计，因此主要考虑是否将导出功能拆分。
考虑到模块化设计的清晰性，我建议将导出功能拆分到单独的模块中，这样：
- `knowledge_manager.py`只负责核心的数据管理（增删改查、搜索、关系维护等）
- `knowledge_exporter.py`负责将知识库导出为各种格式
拆分后，`KnowledgeManager`将不再包含`export_knowledge`方法，而是提供获取数据的接口，由`KnowledgeExporter`来执行导出。
下面我们进行拆分：
步骤：
1. 从`KnowledgeManager`中移除`export_knowledge`方法。
2. 创建一个新的模块`knowledge_exporter.py`，其中包含`KnowledgeExporter`类，该类接收一个`KnowledgeManager`实例，并提供导出方法。
但是，由于导出需要访问`KnowledgeManager`的内部数据结构，我们可以在`KnowledgeManager`中增加一个方法，返回整个知识库的字典（或者只读视图），或者由`KnowledgeExporter`直接使用`KnowledgeManager`的公共接口来获取数据。
考虑到封装性，我们可以在`KnowledgeManager`中提供一个`get_all_knowledge`方法（返回知识库的深拷贝，避免直接操作内部数据）和`get_relationships`方法等。但是这样需要提供多个接口。
另一种方式是，`KnowledgeExporter`接受`KnowledgeManager`实例，然后通过公共方法（如`get_knowledge`、`get_knowledge_graph_data`等）来获取所需数据，但这样效率可能较低。
考虑到导出功能需要整个知识库的数据，我们可以让`KnowledgeManager`提供一个`export_data`方法，返回一个包含知识库当前状态的字典（用于导出）。这样，`KnowledgeExporter`就不需要知道内部结构。
例如：
```python
# 在KnowledgeManager中
def export_data(self):
# 返回一个深拷贝，避免外部修改内部数据
import copy
return copy.deepcopy(self.knowledge_base)
```
然后，在`knowledge_exporter.py`中：
```python
class KnowledgeExporter:
@staticmethod
def export_to_markdown(data, output_file):
# 使用data（即knowledge_base字典）来生成Markdown
pass
@staticmethod
def export_to_
html(data, output_file):
pass
# 其他格式...
```
这样，导出模块就不需要依赖`KnowledgeManager`的内部结构，只需要按照约定的字典结构操作。
但是，这样仍然将内部数据结构暴露给了外部模块。为了减少耦合，我们可以定义一个标准的数据交换格式（比如一个包含节点和边的结构，或者一个自定义的DTO），但这可能会增加复杂度。
鉴于当前项目规模，我们可以暂时使用深拷贝的方式，因为知识库的数据结构相对稳定。
因此，我们做如下调整：
1. 在`knowledge_manager.py`中移除`export_knowledge`方法，并添加一个`export_data`方法。
2. 创建`knowledge_exporter.py`模块，实现各种导出格式。
但是，请注意，原`export_knowledge`方法中使用了`self.get_knowledge`来获取关系中的知识条目，如果拆出去，就需要在导出模块中实现同样的逻辑。
考虑到时间，我们也可以选择不拆分，但为了模块化，我建议拆分。
由于这是一个较大的改动，而且问题只要求我们看这个文件是否需要改，我们可以根据需求来决定。
如果决定拆分，下面是修改后的代码：
修改`knowledge_manager.py`：
- 移除`export_knowledge`方法
- 添加`export_data`方法
新增`knowledge_exporter.py`：
- 实现`export_knowledge`函数，接收导出的数据和格式，然后导出到文件。
由于代码较长，我在这里只给出修改的示例：
在`knowledge_manager.py`末尾添加：
```python
def export_data(self):
"""导出知识库数据（深拷贝）"""
import copy
return copy.deepcopy(self.knowledge_base)
```
然后创建`knowledge_exporter.py`：
```python
# knowledge_exporter.py
import os
from datetime import datetime
class KnowledgeExporter:
@staticmethod
def export_knowledge(data, format="json", output_file=None):
"""
导出知识库
参数:
data
-- 知识库数据（字典）
format
-- 导出格式 (json, md,
html)
output_file
-- 输出文件路径
"""
if not output_file:
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
output_file = f"knowledge_export_{timestamp}.{format}"
if format == "json":
with open(output_file, &#
39;w&#
39;, encoding=&#
39;utf
-8&#
39;) as f:
json.dump(data, f, ensure_ascii=False, indent=2)
print(f"知识已导出到 JSON 文件: {output_file}")
elif format == "md":
KnowledgeExporter._export_to_markdown(data, output_file)
elif format == "
html":
KnowledgeExporter._export_to_
html(data, output_file)
else:
print(f"不支持的导出格式: {format}")
return False
return True
@staticmethod
def _export_to_markdown(data, output_file):
"""导出为Markdown格式"""
with open(output_file, &#
39;w&#
39;, encoding=&#
39;utf
-8&#
39;) as f:
f.write("# 知识库导出\n\n")
f.write(f"> 导出时间: {datetime.now().isoformat()}\n")
f.write(f"> 知识条目数: {data[&#
39;metadata&#
39;][&#
39;knowledge_count&#
39;]}\n\n")
for kid, entry in data["knowledge"].items():
f.write(f"## {entry[&#
39;title&#
39;]}\n")
f.write(f"**ID**: `{kid}` \n")
f.write(f"**创建时间**: {entry[&#
39;created_at&#
39;]} \n")
f.write(f"**最后更新**: {entry[&#
39;updated_at&#
39;]} \n")
if entry.get(&#
39;tags&#
39;):
f.write(f"**标签**: {&#
39;, &#
39;.join(entry[&#
39;tags&#
39;])} \n")
if entry.get(&#
39;category&#
39;):
f.write(f"**分类**: {entry[&#
39;category&#
39;]} \n")
f.write("\n### 内容\n")
f.write(entry["
content"] + "\n\n")
# 添加相关关系
relations = [rel for rel in data["relationships"]
if rel["source"] == kid or rel["target"] == kid]
if relations:
f.write("### 相关关系\n")
for rel in relations:
if rel["source"] == kid:
target = data["knowledge"].get(rel["target"], {})
title = target.get("title", "Unknown")
f.write(
f"
- → [{title}]({rel[&#
39;target&#
39;]}) ({rel[&#
39;type&#
39;]}, {rel[&#
39;strength&#
39;]:.2f})\n")
else:
source = data["knowledge"].get(rel["source"], {})
title = source.get("title", "Unknown")
f.write(
f"
- ← [{title}]({rel[&#
39;source&#
39;]}) ({rel[&#
39;type&#
39;]}, {rel[&#
39;strength&#
39;]:.2f})\n")
f.write("\n")
print(f"知识已导出到 Markdown 文件: {output_file}")
@staticmethod
def _export_to_
html(data, output_file):
"""导出为
HTML格式"""
with open(output_file, &#
39;w&#
39;, encoding=&#
39;utf
-8&#
39;) as f:
f.write("<!DOCTYPE
html>\n<
html>\n<head>\n")
f.write("<title>知识库导出</title>\n")
f.write("<style>body {font
-family: Arial, sans
-serif; margin: 20px;}</style>\n")
f.write("</head>\n<body>\n")
f.write(f"<h
1>知识库导出</h
1>\n")
f.write(f"<p>导出时间: {datetime.now().isoformat()}</p>\n")
f.write(f"<p>知识条目数: {data[&#
39;metadata&#
39;][&#
39;knowledge_count&#
39;]}</p>\n")
for kid, entry in data["knowledge"].items():
f.write(
f"<div style=&#
39;margin
-bottom:
30px; border:
1px solid #ddd; padding:
15px; border
-radius: 5px;&#
39;>\n")
f.write(f"<h2>{entry[&#
39;title&#
39;]}</h2>\n")
f.write(f"<p><strong>ID</strong>: <code>{kid}</code></p>\n")
f.write(f"<p><strong>创建时间</strong>: {entry[&#
39;created_at&#
39;]}</p>\n")
f.write(f"<p><strong>最后更新</strong>: {entry[&#
39;updated_at&#
39;]}</p>\n")
if entry.get(&#
39;tags&#
39;):
f.write(f"<p><strong>标签</strong>: {&#
39;, &#
39;.join(entry[&#
39;tags&#
39;])}</p>\n")
if entry.get(&#
39;category&#
39;):
f.write(f"<p><strong>分类</strong>: {entry[&#
39;category&#
39;]}</p>\n")
f.write(f"<h
3>内容</h
3>\n")
f.write(f"<div style=&#
39;white
-space: pre
-wrap;&#
39;>{entry[&#
39;
content&#
39;]}</div>\n")
# 添加相关关系
relations = [rel for rel in data["relationships"]
if rel["source"] == kid or rel["target"] == kid]
if relations:
f.write("<h
3>相关关系</h
3>\n<ul>\n")
for rel in relations:
if rel["source"] == kid:
target = data["knowledge"].get(rel["target"], {})
title = target.get("title", "Unknown")
f.write(
f"<li>→ <a href=&#
39;#{rel[&#
39;target&#
39;]}&#
39;>{title}</a> ({rel[&#
39;type&#
39;]}, {rel[&#
39;strength&#
39;]:.2f})</li>\n")
else:
source = data["knowledge"].get(rel["source"], {})
title = source.get("title", "Unknown")
f.write(
f"<li>← <a href=&#
39;#{rel[&#
39;source&#
39;]}&#
39;>{title}</a> ({rel[&#
39;type&#
39;]}, {rel[&#
39;strength&#
39;]:.2f})</li>\n")
f.write("</ul>\n")
f.write("</div>\n")
f.write("</body>\n</
html>")
print(f"知识已导出到
HTML 文件: {output_file}")
```
这样，我们就将导出功能拆分到了单独的模块。
但是，请注意，由于原`KnowledgeManager`中的导出方法被移除，使用示例也需要修改：
原使用示例：
```python
km.export_knowledge(format="md")
```
改为：
```python
from knowledge_exporter import KnowledgeExporter
data = km.export_data()
KnowledgeExporter.export_knowledge(data, format="md")
```
另外，考虑到`export_data`返回的是当前状态的深拷贝，对大型知识库可能会有性能影响，但导出操作不频繁，可以接受。
其他改进点（如性能优化）可以在后续迭代中进行。
因此，总结修改：
1. 从`KnowledgeManager`中移除`export_knowledge`方法，添加`export_data`方法。
2. 创建`knowledge_exporter.py`模块，实现导出功能。
由于代码较长，这里只展示修改后的`knowledge_manager.py`（移除了`export_knowledge`，添加了`export_data`）和新增的`knowledge_exporter.py`。
如果不需要拆分，则可以保持原样。
请根据项目需求决定是否进行拆分。</think>根据模块化设计原则和代码分析，我认为这个重构后的 `knowledge_manager.py` 已经相当完善，但还可以进行一些优化和增强。以下是建议的改进点及实现代码：
### 主要改进建议
1. **性能优化**：TF
-IDF 向量化在大型知识库上可能较慢
2. **增强关系管理**：添加关系类型管理和权重调整
3. **数据持久化增强**：添加自动保存机制和备份功能
4. **错误处理**：添加更健壮的异常处理
5. **接口一致性**：统一数据获取接口
### 改进后的代码
```python
# knowledge_manager.py (优化版)
import json
import os
import uuid
import time
from datetime import datetime
from collections import defaultdict
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
import logging
# 配置日志
logging.basicConfig(
level=logging.INFO,
format=&#
39;%(asctime)s
- %(name)s
- %(levelname)s
- %(message)s&#
39;
)
logger = logging.getLogger(&#
39;KnowledgeManager&#
39;)
class KnowledgeManager:
def __init__(self, storage_file="knowledge_base.json", auto_save=True, save_interval=
300):
"""
优化后的知识管理核心模块
参数:
storage_file
-- 知识库存储文件路径
auto_save
-- 是否启用自动保存
save_interval
-- 自动保存间隔(秒)
"""
self.storage_file = storage_file
self.auto_save = auto_save
self.save_interval = save_interval
self.last_save_time = time.time()
self.knowledge_base = self._initialize_knowledge_base()
self.vectorizer = TfidfVectorizer(stop_words=&#
39;english&#
39;)
self.vectorizer_lock = False # 向量器更新锁
self.relationship_types = ["similar", "dependency", "contrast", "
part_of", "derived_from"]
# 加载现有知识库
self.load_knowledge()
# 启动自动保存线程
if self.auto_save:
self._start_auto_save()
def _initialize_knowledge_base(self):
"""初始化知识库结构"""
return {
"knowledge": {},
"relationships": [],
"categories": defaultdict(list),
"metadata": {
"version": "
1.0",
"last_updated": datetime.now().isoformat(),
"knowledge_count": 0,
"
learning_metrics": {
"total_
learning_time": 0.0,
"last_learned": None,
"mastery_levels": {}
},
"integration_history": [],
"backup_history": []
}
}
def _start_auto_save(self):
"""启动自动保存线程"""
import threading
def auto_save_loop():
while True:
time.sleep(self.save_interval)
try:
if self.knowledge_base["metadata"]["knowledge_count"] > 0:
self.save_knowledge()
logger.info("自动保存知识库")
except Exception as e:
logger.error(f"自动保存失败: {e}")
save_thread = threading.Thread(target=auto_save_loop, daemon=True)
save_thread.start()
def create_backup(self):
"""创建知识库备份"""
backup_file = f"{self.storage_file}.backup.{datetime.now().strftime(&#
39;%Y%m%d_%H%M%S&#
39;)}"
try:
with open(backup_file, &#
39;w&#
39;, encoding=&#
39;utf
-8&#
39;) as f:
json.dump(self.knowledge_base, f, ensure_ascii=False, indent=2)
# 记录备份历史
self.knowledge_base["metadata"]["backup_history"].append({
"backup_file": backup_file,
"created_at": datetime.now().isoformat(),
"knowledge_count": self.knowledge_base["metadata"]["knowledge_count"]
})
logger.info(f"知识库备份已创建: {backup_file}")
return True
except Exception as e:
logger.error(f"创建备份失败: {e}")
return False
def load_knowledge(self):
"""从文件加载知识库"""
if os.path.exists(self.storage_file):
try:
with open(self.storage_file, &#
39;r&#
39;, encoding=&#
39;utf
-8&#
39;) as f:
self.knowledge_base = json.load(f)
logger.info(f"知识库已加载，包含 {self.knowledge_base[&#
39;metadata&#
39;][&#
39;knowledge_count&#
39;]} 条知识")
# 确保分类是defaultdict
if not isinstance(self.knowledge_base["categories"], defaultdict):
categories = defaultdict(list)
for cat, items in self.knowledge_base["categories"].items():
categories[cat] = items
self.knowledge_base["categories"] = categories
# 更新向量器
self._update_vectorizer()
return True
except Exception as e:
logger.error(f"加载知识库失败: {e}")
# 创建新知识库
self.knowledge_base = self._initialize_knowledge_base()
return False
return False
def save_knowledge(self):
"""保存知识库到文件"""
try:
# 创建备份
self.create_backup()
with open(self.storage_file, &#
39;w&#
39;, encoding=&#
39;utf
-8&#
39;) as f:
json.dump(self.knowledge_base, f, ensure_ascii=False, indent=2)
self.knowledge_base["metadata"]["last_updated"] = datetime.now().isoformat()
self.last_save_time = time.time()
logger.info("知识库已保存")
return True
except Exception as e:
logger.error(f"保存知识库失败: {e}")
return False
def add_knowledge(self, title,
content, tags=None, category=None):
"""
添加新知识条目
参数:
title
-- 知识标题
content -- 知识内容
tags
-- 标签列表 (可选)
category
-- 分类 (可选)
"""
# 输入验证
if not title or not
content:
logger.warning("添加知识失败: 标题和内容不能为空")
return None
# 检查重复知识
existing = self.search_knowledge(title, top_n=
1)
if existing
and existing[0]["similarity"] > 0.9:
logger.info(f"相似知识已存在: {existing[0][&#
39;title&#
39;]} (ID: {existing[0][&#
39;id&#
39;]})")
return existing[0]["id"]
# 生成唯一ID
knowledge_id = str(uuid.uuid4())
# 创建时间戳
now = datetime.now().isoformat()
# 创建知识条目
new_entry = {
"id": knowledge_id,
"title": title,
"
content":
content,
"tags": tags or [],
"category": category,
"created_at": now,
"updated_at": now
}
# 添加到知识库
self.knowledge_base["knowledge"][knowledge_id] = new_entry
# 更新元数据
self.knowledge_base["metadata"]["knowledge_count"] +=
1
self.knowledge_base["metadata"]["last_updated"] = now
# 添加到分类
if category:
self.knowledge_base["categories"][category].append(knowledge_id)
# 自动创建关系
self._auto_create_relationships(knowledge_id)
# 更新向量器
self._update_vectorizer()
logger.info(f"知识添加成功! ID: {knowledge_id}")
return knowledge_id
def _auto_create_relationships(self, new_id):
"""自动为新知识创建关系"""
try:
new_entry = self.knowledge_base["knowledge"][new_id]
#
1. 基于内容相似度
similarities = self.find_similar_knowledge(new_id, threshold=0.
3)
for knowledge_id, similarity in similarities:
self.add_relationship(new_id, knowledge_id, "similar", similarity)
# 2. 基于标签匹配
for knowledge_id, entry in self.knowledge_base["knowledge"].items():
if knowledge_id == new_id:
continue
# 计算标签匹配度
common_tags = set(new_entry["tags"]) & set(entry["tags"])
if common_tags:
strength = len(common_tags) / (len(new_entry["tags"]) + len(entry["tags"])
- len(common_tags))
self.add_relationship(new_id, knowledge_id, "tag_match", strength)
except Exception as e:
logger.error(f"自动创建关系失败: {e}")
def _update_vectorizer(self):
"""更新TF
-IDF向量器"""
if not self.knowledge_base["knowledge"] or self.vectorizer_lock:
return
try:
# 设置锁防止并发更新
self.vectorizer_lock = True
# 收集所有知识内容
all_
content = [entry["
content"] for entry in self.knowledge_base["knowledge"].values()]
# 更新向量器
self.vectorizer.fit(all_
content)
except Exception as e:
logger.error(f"更新向量器失败: {e}")
finally:
self.vectorizer_lock = False
def add_relationship(self, source_id, target_id, rel_type, strength=0.5):
"""
添加知识关系
参数:
source_id
-- 源知识ID
target_id
-- 目标知识ID
rel_type
-- 关系类型 (e.g., "similar", "dependency", "contrast")
strength
-- 关系强度 (0.0
-1.0)
"""
# 验证关系类型
if rel_type not in self.relationship_types:
logger.warning(f"无效的关系类型: {rel_type}。可用类型: {&#
39;, &#
39;.join(self.relationship_types)}")
return False
# 验证知识ID存在
if source_id not in self.knowledge_base["knowledge"] or target_id not in self.knowledge_base["knowledge"]:
logger.warning("添加关系失败: 源或目标知识不存在")
return False
# 检查关系是否已存在
for rel in self.knowledge_base["relationships"]:
if rel["source"] == source_id
and rel["target"] == target_id
and rel["type"] == rel_type:
# 更新现有关系
rel["strength"] = max(rel["strength"], strength)
rel["updated_at"] = datetime.now().isoformat()
logger.info(f"关系已更新: {source_id[:8]} → {target_id[:8]} ({rel_type}, {rel[&#
39;strength&#
39;]:.2f})")
return True
# 创建新关系
new_rel = {
"source": source_id,
"target": target_id,
"type": rel_type,
"strength": strength,
"created_at": datetime.now().isoformat(),
"updated_at": datetime.now().isoformat()
}
self.knowledge_base["relationships"].append(new_rel)
logger.info(f"关系添加: {source_id[:8]} → {target_id[:8]} ({rel_type}, {strength:.2f})")
return True
def get_knowledge(self, knowledge_id):
"""根据ID获取知识条目"""
return self.knowledge_base["knowledge"].get(knowledge_id)
def update_knowledge(self, knowledge_id, title=None,
content=None, tags=None, category=None):
"""更新知识条目"""
if knowledge_id not in self.knowledge_base["knowledge"]:
logger.warning("知识条目不存在")
return False
entry = self.knowledge_base["knowledge"][knowledge_id]
# 更新字段
updated = False
if title is not None
and title != entry["title"]:
entry["title"] = title
updated = True
if
content is not None
and content != entry["
content"]:
entry["
content"] =
content
updated = True
if tags is not None
and set(tags) != set(entry["tags"]):
entry["tags"] = tags
updated = True
if category is not None
and category != entry.get("category"):
# 移除旧分类
old_category = entry.get("category")
if old_category
and old_category in self.knowledge_base["categories"]:
if knowledge_id in self.knowledge_base["categories"][old_category]:
self.knowledge_base["categories"][old_category].remove(knowledge_id)
# 添加新分类
entry["category"] = category
self.knowledge_base["categories"][category].append(knowledge_id)
updated = True
if updated:
entry["updated_at"] = datetime.now().isoformat()
# 重新计算关系
self._auto_create_relationships(knowledge_id)
# 更新向量器
self._update_vectorizer()
logger.info("知识更新成功")
return True
else:
logger.info("知识未更新")
return False
def delete_knowledge(self, knowledge_id):
"""删除知识条目"""
if knowledge_id not in self.knowledge_base["knowledge"]:
logger.warning("知识条目不存在")
return False
# 删除知识条目
del self.knowledge_base["knowledge"][knowledge_id]
# 更新元数据
self.knowledge_base["metadata"]["knowledge_count"]
-=
1
self.knowledge_base["metadata"]["last_updated"] = datetime.now().isoformat()
# 从分类中移除
for category, items in self.knowledge_base["categories"].items():
if knowledge_id in items:
items.remove(knowledge_id)
# 删除相关关系
self.knowledge_base["relationships"] = [
rel for rel in self.knowledge_base["relationships"]
if rel["source"] != knowledge_id
and rel["target"] != knowledge_id
]
# 更新向量器
self._update_vectorizer()
logger.info("知识删除成功")
return True
def search_knowledge(self, query, top_n=5, similarity_threshold=0.
1):
"""
搜索知识库
参数:
query
-- 搜索查询
top_n
-- 返回最相关的前n个结果
similarity_threshold
-- 相似度阈值
"""
if not self.knowledge_base["knowledge"]:
return []
# 获取所有知识内容
all_ids = list(self.knowledge_base["knowledge"].keys())
all_
content = [self.knowledge_base["knowledge"][kid]["
content"] for kid in all_ids]
# 添加查询到内容列表
all_
content.append(query)
# 计算TF
-IDF向量
try:
tfidf_matrix = self.vectorizer.transform(all_
content)
# 计算相似度（查询与所有知识条目）
query_vector = tfidf_matrix[
-1]
knowledge_vectors = tfidf_matrix[:
-1]
similarities = cosine_similarity(query_vector, knowledge_vectors).flatten()
# 获取最相关的结果
results = []
for i, sim in enumerate(similarities):
if sim > similarity_threshold:
knowledge_id = all_ids[i]
entry = self.knowledge_base["knowledge"][knowledge_id]
results.append({
"id": knowledge_id,
"title": entry["title"],
"
content": entry["
content"][:
150] + "..." if len(entry["
content"]) >
150 else entry["
content"],
"similarity": sim
})
# 按相似度排序
results.sort(key=lambda x: x["similarity"], reverse=True)
return results[:top_n]
except Exception as e:
logger.error(f"搜索失败: {e}")
return []
def find_similar_knowledge(self, knowledge_id, threshold=0.2):
"""
查找相似知识条目
参数:
knowledge_id
-- 参考知识ID
threshold
-- 相似度阈值
"""
if knowledge_id not in self.knowledge_base["knowledge"]:
return []
# 获取所有知识内容
all_ids = list(self.knowledge_base["knowledge"].keys())
all_
content = [self.knowledge_base["knowledge"][kid]["
content"] for kid in all_ids]
# 计算TF
-IDF向量
try:
tfidf_matrix = self.vectorizer.transform(all_
content)
# 找到参考知识的索引
ref_idx = all_ids.index(knowledge_id)
# 计算相似度
similarities = cosine_similarity(tfidf_matrix[ref_idx:ref_idx+
1], tfidf_matrix).flatten()
# 收集相似结果
results = []
for i, sim in enumerate(similarities):
if i != ref_idx
and sim > threshold:
results.append((all_ids[i], sim))
# 按相似度排序
results.sort(key=lambda x: x[
1], reverse=True)
return results
except Exception as e:
logger.error(f"查找相似知识失败: {e}")
return []
def get_knowledge_graph_data(self, min_strength=0.
1):
"""获取知识图谱数据（供可视化模块使用）"""
nodes = []
edges = []
# 添加节点
for kid, entry in self.knowledge_base["knowledge"].items():
nodes.append({
"id": kid,
"title": entry["title"],
"category": entry.get("category", "未分类"),
"tags": entry.get("tags", [])
})
# 添加边
for rel in self.knowledge_base["relationships"]:
if rel["strength"] >= min_strength:
edges.append({
"source": rel["source"],
"target": rel["target"],
"type": rel["type"],
"strength": rel["strength"]
})
return {"nodes": nodes, "links": edges}
def get_timeline_data(self):
"""获取时间线数据（供可视化模块使用）"""
timeline = defaultdict(int)
for entry in self.knowledge_base["knowledge"].values():
try:
date = datetime.fromisoformat(entry["created_at"])
month_key = date.strftime("%Y
-%m")
timeline[month_key] +=
1
except:
continue
# 转换为排序列表
sorted_timeline = sorted(timeline.items(), key=lambda x: x[0])
return [{"month": k, "count": v} for k, v in sorted_timeline]
def get_integration_history(self):
"""获取整合历史记录"""
return self.knowledge_base["metadata"]["integration_history"]
def get_report_data(self):
"""生成知识库报告数据（供可视化模块使用）"""
report = {
"knowledge_count": self.knowledge_base["metadata"]["knowledge_count"],
"last_updated": self.knowledge_base["metadata"]["last_updated"],
"categories": {},
"tag_cloud": defaultdict(int),
"relationship_stats": defaultdict(int),
"timeline_data": [],
"backup_history": self.knowledge_base["metadata"]["backup_history"]
}
# 分类统计
for category, items in self.knowledge_base["categories"].items():
report["categories"][category] = len(items)
# 标签统计
for entry in self.knowledge_base["knowledge"].values():
for tag in entry.get("tags", []):
report["tag_cloud"][tag] +=
1
# 关系统计
for rel in self.knowledge_base["relationships"]:
report["relationship_stats"][rel["type"]] +=
1
# 时间线数据
if self.knowledge_base["knowledge"]:
dates = []
for entry in self.knowledge_base["knowledge"].values():
try:
dates.append(datetime.fromisoformat(entry["created_at"]))
except:
continue
# 按月统计
months = defaultdict(int)
for date in dates:
month_key = date.strftime("%Y
-%m")
months[month_key] +=
1
# 按时间排序
sorted_months = sorted(months.items(), key=lambda x: x[0])
report["timeline_data"] = [{"month": k, "count": v} for k, v in sorted_months]
return report
def export_data(self, format="dict"):
"""
导出知识库数据
参数:
format
-- 导出格式 (dict, json)
"""
if format == "json":
return json.dumps(self.knowledge_base, ensure_ascii=False, indent=2)
else:
return self.knowledge_base
# 使用示例
if __name__ == "__main__":
# 创建知识管理器
km = KnowledgeManager(auto_save=True)
# 添加知识条目
km.add_knowledge(
title="Python列表推导式",
content="列表推导式提供了一种简洁的方法来创建列表。语法: [expression for item in iterable if condition]",
tags=["Python", "编程技巧"],
category="编程"
)
km.add_knowledge(
title="神经网络基础",
content="神经网络由输入层、隐藏层和输出层组成。使用反向传播算法训练权重。",
tags=["机器学习", "神经网络"],
category="AI"
)
km.add_knowledge(
title="Git基本命令",
content="常用Git命令: git init, git add, git commit, git push, git pull",
tags=["Git", "版本控制"],
category="开发工具"
)
# 添加关系
py_id = list(km.knowledge_base["knowledge"].keys())[0]
ai_id = list(km.knowledge_base["knowledge"].keys())[
1]
km.add_relationship(py_id, ai_id, "related", 0.6)
# 搜索知识
print("\n搜索 &#
39;Python&#
39;:")
results = km.search_knowledge("Python")
for res in results:
print(f"{res[&#
39;title&#
39;]} (相似度: {res[&#
39;similarity&#
39;]:.2f})")
# 获取图谱数据
graph_data = km.get_knowledge_graph_data()
print(f"\n知识图谱数据: {len(graph_data[&#
39;nodes&#
39;])} 节点, {len(graph_data[&#
39;links&#
39;])} 边")
# 获取时间线数据
timeline_data = km.get_timeline_data()
print(f"\n时间线数据: {len(timeline_data)} 个月份记录")
# 获取报告数据
report_data = km.get_report_data()
print(f"\n报告数据: {report_data[&#
39;knowledge_count&#
39;]} 条知识")
# 保存知识库
km.save_knowledge()
```
### 主要改进说明
1. **日志系统增强**：
- 使用 Python 的 `logging` 模块替代简单的 print 语句
- 添加详细的日志级别（INFO, WARNING, ERROR）
- 记录关键操作和错误信息
2. **自动保存与备份**：
```python
def _start_auto_save(self):
"""启动自动保存线程"""
import threading
def auto_save_loop():
while True:
time.sleep(self.save_interval)
try:
if self.knowledge_base["metadata"]["knowledge_count"] > 0:
self.save_knowledge()
logger.info("自动保存知识库")
except Exception as e:
logger.error(f"自动保存失败: {e}")
```
- 添加定时自动保存功能
- 每次保存时自动创建备份
- 记录备份历史
3. **输入验证与错误处理**：
```python
# 添加知识时的输入验证
if not title or not
content:
logger.warning("添加知识失败: 标题和内容不能为空")
return None
# 关系类型验证
if rel_type not in self.relationship_types:
logger.warning(f"无效的关系类型: {rel_type}。可用类型: {&#
39;, &#
39;.join(self.relationship_types)}")
return False
```
- 添加关键操作的输入验证
- 使用 try
-except 块增强健壮性
- 详细记录错误信息
4. **性能优化**：
```python
self.vectorizer_lock = False # 向量器更新锁
def _update_vectorizer(self):
if not self.knowledge_base["knowledge"] or self.vectorizer_lock:
return
try:
# 设置锁防止并发更新
self.vectorizer_lock = True
# ... 更新向量器 ...
finally:
self.vectorizer_lock = False
```
- 添加向量器更新锁防止并发问题
- 优化搜索算法，添加相似度阈值参数
5. **关系管理增强**：
```python
self.relationship_types = ["similar", "dependency", "contrast", "
part_of", "derived_from"]
```
- 定义标准关系类型
- 添加关系类型验证
6. **数据导出优化**：
```python
def export_data(self, format="dict"):
"""统一数据导出接口"""
if format == "json":
return json.dumps(self.knowledge_base, ensure_ascii=False, indent=2)
else:
return self.knowledge_base
```
- 提供统一的数据导出接口
- 支持字典和JSON格式导出
7. **数据完整性增强**：
```python
# 确保分类是defaultdict
if not isinstance(self.knowledge_base["categories"], defaultdict):
categories = defaultdict(list)
for cat, items in self.knowledge_base["categories"].items():
categories[cat] = items
self.knowledge_base["categories"] = categories
```
- 加载时验证数据结构
- 添加时间戳解析的异常处理
### 使用建议
1. **配置日志**：
在项目初始化时配置全局日志系统：
```python
import logging
logging.basicConfig(
level=logging.INFO,
format=&#
39;%(asctime)s
- %(name)s
- %(levelname)s
- %(message)s&#
39;,
filename=&#
39;knowledge_system.log&#
39;
)
```
2. **异常处理**：
在调用知识管理器方法时添加异常处理：
```python
try:
km.add_knowledge("新知识", "内容")
except Exception as e:
logger.error(f"添加知识失败: {e}")
# 执行恢复操作
```
3. **定期维护**：
添加定期维护功能：
```python
def perform_maintenance(self):
"""执行知识库维护"""
#
1. 清理无效关系
# 2. 优化数据结构
#
3. 压缩存储
pass
```
这些改进使知识管理系统更加健壮、可靠且易于维护，同时保持了模块化的设计原则。
扫一扫
6516
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
