EmberTrace AI | NoteBook Mode：笔记本多模式分析技术
·
背景
在数字化信息爆炸的时代，个人与企业面临的核心挑战已从“获取数据”转向对海量、碎片化文档的有效整合与深层价值抽取。传统的搜索或单一文档阅读模式，已难以满足跨文档知识关联与多维分析的需求。
受 Google NotebookLM “基于源文件接地（Grounding）”范式的启发，EmberTrace AI 推出了 NoteBook Mode（笔记本模式）。该模式旨在复刻并超越 NotebookLM 的体验，构建一个完全基于用户私有数据的智能研判环境。本项目并未止步于简单的 RAG（检索增强生成）问答，而是引入了先进的 多智能体协作（Multi-Agent Collaboration） 架构。
通过调度专精于不同任务的智能体——从非结构化文本清洗、代码编写与执行，到多模态内容生成——系统能够将静态的 PDF、CSV 或 TXT 文档集合，动态转化为音频播客、交互式图表、深度研报及思维导图。这种“多模态输出”能力，重新定义了人与本地知识库的交互方式，让 AI 真正成为辅助思考的第二大脑。
产品思路及架构
EmberTrace AI 的 NoteBook Mode 超越了传统文档管理工具或 RAG（检索增强生成）问答系统的范畴，其核心愿景是实现**“从被动检索走向主动生成”的知识交互范式跃迁。传统的知识库往往是静态的孤岛，而本架构旨在通过多智能体协作（Multi-Agent Collaboration）**，将用户私有的静态文件集合，动态重构为具备深度关联和多维表现力的智能知识网络。
1. 场景感知的信息抽取与知识结构化
一切分析的基石在于对源文件的深度语义理解。本架构摒弃了通用的粗暴切片（Chunking）策略，转而构建了**自适应图式提取（Adaptive Schema Extraction）**机制。
- 非结构化数据的结构化重塑：系统利用非结构化数据处理智能体，具备敏锐的“文档嗅觉”。它能自动识别输入是学术论文、财务报表还是叙事文学，并根据不同体裁动态调整提取策略——对财报聚焦“关键指标与趋势”，对论文则侧重“假设与验证”。
- 跨文档语义网络构建：通过关系提取智能体，系统模拟人类专家的阅读习惯，横向扫描所有文档，挖掘文件间的显性引用与隐性逻辑（如补充、矛盾或衍生关系）。这一过程将孤立的文件节点编织成了一张动态的知识图谱，为后续的复杂推理提供了全局视野。
2. 专家级多智能体协作编排
系统的“中枢大脑”采用**专家团队（Team of Experts）**架构，拒绝“一个 Prompt 解决所有问题”的平庸方案，而是通过主控模块根据用户意图调度专精的智能体：
- 代码即行动（Code-as-Action）范式：为了交付高可用性的结果，系统集成了代码编写与执行智能体。在生成信息图、思维导图或数据看板时，智能体不再停留在生成文本描述，而是化身为全栈工程师，直接编写 HTML/CSS/JS 代码（集成 D3.js 或 ECharts 等库），并进行自我修正与运行。这种“思考即编码”的能力，使得输出结果不再是死板的图片，而是可交互、可缩放的动态应用。
- 元认知规划与反思：针对深度报告或 PPT 大纲等复杂任务，深度分析智能体被设计为遵循“先规划、后填充”的思维链，确保逻辑严密且论据详实。
3. 多模式融合与沉浸式交付
架构的最终交付层致力于打破单一文本交互的认知局限，通过**多模态融合（Multi-Modal Fusion）**技术，根据不同的认知场景提供最佳的知识载体：
- 听觉模态（Audio Mode）：音频概览智能体将复杂的文档摘要转化为自然的播客脚本，通过多角色对话的形式，让用户在通勤或碎片时间通过“听”来吸收知识。
- 视觉交互模态（Visual Mode）：知识图谱智能体与思维导图智能体利用前端渲染技术，将隐性的逻辑关系显性化为可视化的网络结构，支持用户通过拖拽、缩放来探索知识边界。
- 认知增强模态（Learning Mode）：记忆卡片智能体结合认知心理学中的“间隔重复”理论，自动提炼核心考点并生成 3D 翻转卡片，辅助用户将外部知识内化为长期记忆。
架构总结：
整体架构遵循 “数据层（多源异构解析） -> 语义层（关系图谱构建） -> 智能体层（角色编排与代码执行） -> 交付层（多模态渲染）” 的流式处理管线。这种分层解耦的设计，不仅确保了 AI 回答的准确性与可追溯性（Grounding），更赋予了静态数据前所未有的生命力与表现力。
关键代码
一、多文本文件处理及抽取
该模块是系统的基石，旨在解决“多源异构数据”的标准化难题。核心思想采用了**自适应图式（Adaptive Schema）**提取策略。系统首先通过文件指纹识别文件类型（如结构化的 CSV/Excel 或非结构化的 PDF/MD），针对结构化数据，它自动计算统计特征与数据预览；针对非结构化文本，则调用大模型进行深层语义解析，而非简单的 OCR 或文本提取。它会根据文件体裁（如财报、小说、论文）动态调整提取关注点，将非结构化内容转化为包含“核心概念、关键数据点、时间线”的标准化 JSON 中间态。这为后续所有智能体的协作提供了统一且高质量的“燃料”。
class UnstructuredDataProcessor:
"""非结构化数据处理器"""
def __init__(self, model_config: Dict):
self.model_config = model_config
self.llm = ChatOpenAI(
model=model_config.get('model_name', 'gpt-4'),
temperature=0.1
)
def extract_key_knowledge(self, file_path: str, file_type: str, filename: str) -> Dict[str, Any]:
"""从非结构化文件中提取关键知识"""
try:
# 从文件中提取文本
text_content = ""
if file_type == 'pdf':
with open(file_path, 'rb') as f:
reader = PyPDF2.PdfReader(f)
text = ""
for page in reader.pages:
text += page.extract_text() + "\n"
text_content = text
elif file_type == 'docx':
doc = docx.Document(file_path)
text_content = "\n".join([para.text for para in doc.paragraphs])
elif file_type in ['txt', 'md']:
with open(file_path, 'r', encoding='utf-8') as f:
text_content = f.read()
elif file_type == 'html':
with open(file_path, 'r', encoding='utf-8') as f:
soup = BeautifulSoup(f.read(), 'html.parser')
text_content = soup.get_text(separator='\n', strip=True)
else:
# 其他文本文件
try:
with open(file_path, 'r', encoding='utf-8') as f:
text_content = f.read()
except:
text_content = ""
# 限制文本长度，避免token过长
text_content = text_content[:100000]
if not text_content.strip():
return {
"file_name": filename,
"file_type": file_type,
"key_concepts": [],
"key_data_points": [],
"key_findings": [],
"recommendations": [],
"timeline": [],
"summary": "文件内容为空或无法提取文本"
}
# 使用大模型提取关键知识
prompt = f"""
从以下文件中提取关键知识和信息点，用于生成信息图或数据看板：
文件名：{filename}
文件类型：{file_type}
文件内容：
{text_content[:100000]} # 进一步限制长度
请提取以下类型的信息：
1. 核心主题和关键概念
2. 重要数据点和统计信息
3. 关键发现和结论
4. 建议和行动计划
5. 时间线或流程信息
6. 比较和对比信息
7. 问题和解决方案
摘要信息提取提示：请阅读提供的文件内容，首先自动识别文件类型，然后遵循下述“分类型摘要策略”生成摘要。
严格禁令：
拒绝废话： 禁止使用“本文主要讲述了”、“作者介绍了”等泛泛而谈的开场白，直接陈述核心事实或结论。
拒绝模糊： 凡涉及数据、结论、核心观点，必须具体（例如：不要说“业绩有所增长”，要说“业绩同比增长23%”）。
保持客观： 除非文件本身是评论，否则不要加入你的主观判断。
【分类型摘要策略】
1. 学术论文/深度研报 (Academic & Research Papers)
关注点： 解决什么问题（Hypothesis）、使用什么方法（Method）、得出了什么具体结论（Result）。
输出要求：
背景痛点： 一句话概括研究背景。
核心创新： 该研究与过往研究最大的不同点/创新点。
关键结论： 列出3-5条具体的实验数据或论证结果。
局限与展望： 作者提到的不足或未来方向。
2. 小说/文学著作 (Fiction & Literature)
关注点： 叙事弧光、人物关系、核心冲突、深层隐喻。
输出要求：
故事梗概： 用精炼的语言概括起因、经过、高潮和结局（包含关键转折点）。
人物图谱： 核心角色及其性格/关系简述。
核心主旨： 作品想要探讨的人性、社会或哲学议题。
风格基调： （如：赛博朋克、魔幻现实主义、压抑、幽默等）。
3. 结构化数据/报表 (Structured Data: CSV/Excel/JSON)
关注点： 数据的维度、极值、趋势、异常点。
输出要求：
数据概览： 包含哪些字段（列），总数据量级。
统计特征： 核心指标的最高值、最低值、平均值或总量（如适用）。
关键趋势： 数据随时间或其他变量的变化规律。
异常发现： 是否存在明显偏离正常范围的数据点。
4. 行业知识库/说明书 (Knowledge Base & Manuals)
关注点： “How-to”、定义、操作流程、故障解决。
输出要求：
核心功能/定义： 该知识点解决什么具体问题。
操作/逻辑流程： 关键步骤的简要概括（Step 1, Step 2...）。
关键参数/限制： 必须遵守的硬性条件或参数指标。
适用场景： 在什么情况下使用此知识。
5. 新闻/时事资讯 (News & Journalism)
关注点： 5W1H (Who, What, When, Where, Why, How)、事件影响。
输出要求：
新闻事实： 一句话直击核心事件（倒金字塔结构）。
关键细节： 时间、地点、涉及人物、核心数据。
各方表态： 涉事方或专家的核心观点（如有）。
潜在影响： 该事件对行业或社会的后续影响预测。
6. 商业计划书/投研报告 (Business Plans & Investment Reports)
关注点： 商业模式、市场规模、竞争优势、财务预测。
输出要求：
价值主张： 产品/服务解决了什么痛点。
市场机会： 目标市场规模（TAM/SAM/SOM）及增长率。
护城河： 技术壁垒、牌照或渠道优势。
财务亮点： 预计营收、利润率、盈亏平衡点。
7. 法律合同/政策文件 (Legal Contracts & Policies)
关注点： 权利义务、关键时间点、违约责任、排他性条款。
输出要求：
主体对象： 甲方乙方及关系定义。
核心义务： 谁必须在什么时间做什么事。
风险条款： 违约金数额、免责条款、管辖地。
生效/终止条件： 具体的时间节点或触发条件。
8. 会议纪要/访谈实录 (Meeting Minutes & Transcripts)
关注点： 决议、待办事项(TODO)、未决问题、不同观点。
输出要求：
会议结论： 最终达成了哪些一致意见。
行动项 (Action Items)： 谁（Who）需要在何时（When）完成什么（What）。
争议焦点： 讨论中出现的分歧点及各方理由。
9. 代码/技术脚本 (Code & Scripts)
关注点： 逻辑功能、依赖库、输入输出、架构模式。
输出要求：
功能描述： 这段代码主要实现了什么功能。
技术栈： 使用了什么语言、框架或关键库。
核心逻辑： 关键算法或处理流程的简述。
使用方法： 输入参数是什么，预期输出是什么。
10.其他类型文件 (Other Types)
关注点： 文件内容、格式、适用场景。
以JSON格式输出：
{{
"file_name": "{filename}",
"file_type": "{file_type}",
"key_concepts": ["概念1", "概念2", ...],
"key_data_points": [
{{"name": "数据点名称", "value": "数据值", "description": "描述"}},
...
],
"key_findings": ["发现1", "发现2", ...],
"recommendations": ["建议1", "建议2", ...],
"timeline": [
{{"time": "时间点", "event": "事件描述"}},
...
],
"summary": "1000-2000字的文件摘要,根据文类型、主题、核心内容及文件风格，确定文件摘要的内容，不要泛泛而谈。"
}}
确保所有信息准确、简洁，适合用于可视化展示。
"""
response = self.llm.invoke(prompt)
content = response.content
# 提取JSON
try:
json_match = re.search(r'\{.*\}', content, re.DOTALL)
if json_match:
knowledge_data = json.loads(json_match.group())
else:
# 如果找不到JSON，创建基本结构
knowledge_data = {
"file_name": filename,
"file_type": file_type,
"key_concepts": [],
"key_data_points": [],
"key_findings": [],
"recommendations": [],
"timeline": [],
"summary": content[:50000] if content else "未提取到关键信息"
}
except json.JSONDecodeError as e:
knowledge_data = {
"file_name": filename,
"file_type": file_type,
"key_concepts": [],
"key_data_points": [],
"key_findings": [],
"recommendations": [],
"timeline": [],
"summary": f"提取失败: {str(e)}",
"raw_content": content[:80000]
}
return knowledge_data
except Exception as e:
logger.error(f"提取关键知识失败 {filename}: {str(e)}")
return {
"file_name": filename,
"file_type": file_type,
"key_concepts": [],
"key_data_points": [],
"key_findings": [],
"recommendations": [],
"timeline": [],
"summary": f"处理失败: {str(e)}",
"error": str(e)
}
def process_multiple_files(self, unstructured_files: List[Dict]) -> Dict[str, Any]:
"""处理多个非结构化文件"""
all_knowledge = []
for file_info in unstructured_files:
knowledge = self.extract_key_knowledge(
file_info['path'],
file_info['type'],
file_info['name']
)
all_knowledge.append(knowledge)
# 生成综合摘要
combined_summary = ""
if len(all_knowledge) > 0:
combined_summary = self.generate_combined_summary(all_knowledge)
return {
"knowledge_per_file": all_knowledge,
"combined_summary": combined_summary,
"total_files": len(all_knowledge)
}
def generate_combined_summary(self, all_knowledge: List[Dict]) -> str:
"""生成多个文件的综合摘要"""
try:
# 提取所有摘要
summaries = [k.get('summary', '') for k in all_knowledge]
valid_summaries = [s for s in summaries if s and len(s) > 20]
if not valid_summaries:
return "未能从文件中提取有效摘要"
# 如果只有一个文件，直接返回其摘要
if len(valid_summaries) == 1:
return valid_summaries[0]
# 多个文件，生成综合摘要
summaries_text = "\n\n".join([f"文件摘要 {i+1}: {s}" for i, s in enumerate(valid_summaries)])
prompt = f"""
基于以下多个文件的关键知识摘要，生成一个综合摘要：
{summaries_text}
请总结这些文件的共同主题、关键发现和关联信息。
输出一个500-1000字的综合摘要，用于信息图或数据看板的整体描述。
"""
response = self.llm.invoke(prompt)
return response.content.strip()
except Exception as e:
logger.error(f"生成综合摘要失败: {str(e)}")
return "多个文件的综合摘要生成失败"
二、文本摘要及对话模式
此模块重构了传统的 RAG（检索增强生成）流程，引入了双层上下文管理机制。第一层是“单文件粒度”，为每个文件生成独立的精细摘要与元数据；第二层是“笔记本粒度”，通过关系提取算法扫描所有文件，建立文件间的引用、补充或矛盾关系网络。在对话交互时，系统不仅检索向量数据库中的切片，还结合文件关系图谱进行推理。这种“检索+关系推理”的混合模式，使得 AI 能够回答跨文档的复杂问题（如“对比文件 A 与文件 B 的结论差异”），并确保回答具有精确的来源溯源（Grounding）。
def file_summary_agent(self, file_path: str, file_type: str, filename: str) -> Dict[str, Any]:
"""文件摘要智能体 - 提取文件元信息和内容摘要"""
try:
# 提取文本内容
text_content = extract_text_from_file(file_path, file_type)
# 获取文件大小
file_size = os.path.getsize(file_path)
# 使用大模型生成摘要
llm = self.get_llm(temperature=0.2)
prompt = f"""
你是一个文件内容分析专家。请分析以下文件内容并生成详细的摘要。
文件信息:
- 文件名: {filename}
- 文件类型: {file_type}
- 文件大小: {file_size} 字节
文件内容:
```
{text_content[:100000]} # 限制内容长度
```
请生成以下信息:
1. 内容摘要: 总结文件的核心内容、主要观点或数据结构
2. 关键信息: 提取文件中最重要的数据、发现或结论
3. 文件特点: 描述文件的格式、结构和特殊之处
4. 潜在用途: 说明这个文件可能用于什么分析或任务
输出格式必须是JSON:
{{
"summary": "详细的内容摘要，不少于200字",
"key_points": ["关键点1", "关键点2", "关键点3"],
"file_characteristics": "文件特点和结构描述",
"potential_uses": "可能的分析用途",
"metadata": {{
"estimated_word_count": 估算字数,
"main_topics": ["主题1", "主题2"],
"has_structured_data": true/false,
"has_tables": true/false,
"has_code": true/false
}}
}}
"""
response = llm.invoke(prompt)
content = response.content
# 提取JSON
try:
json_match = re.search(r'\{.*\}', content, re.DOTALL)
if json_match:
summary_data = json.loads(json_match.group())
else:
summary_data = {
"summary": content,
"key_points": [],
"file_characteristics": "",
"potential_uses": "",
"metadata": {}
}
except:
summary_data = {
"summary": content,
"key_points": [],
"file_characteristics": "",
"potential_uses": "",
"metadata": {}
}
# 构建文件元数据
file_metadata = {
"name": filename,
"type": file_type,
"size": file_size,
"path": file_path,
"summary": summary_data.get("summary", ""),
"metadata": summary_data
}
return file_metadata
except Exception as e:
logger.error(f"文件摘要智能体失败: {str(e)}")
return {
"name": filename,
"type": file_type,
"size": os.path.getsize(file_path),
"path": file_path,
"summary": f"文件内容摘要生成失败: {str(e)}",
"metadata": {}
}
def relations_extraction_agent(self, notebook_metadata: NotebookMetadata) -> List[FileRelation]:
"""关系提取智能体 - 分析文件之间的关系"""
try:
llm = self.get_llm(temperature=0.1)
# 准备文件信息
files_info = []
for file in notebook_metadata.files:
files_info.append({
"id": file.id,
"name": file.name,
"type": file.type,
"summary": file.summary[:500] # 截断摘要
})
prompt = f"""
你是一个文件关系分析专家。请分析以下文件之间的关联关系。
文件列表:
{json.dumps(files_info, ensure_ascii=False, indent=2)}
请分析这些文件之间的潜在关系，包括但不限于:
1. 引用关系: 一个文件引用或提到了另一个文件的内容
2. 补充关系: 一个文件补充或扩展了另一个文件的信息
3. 相似关系: 文件内容相似或讨论相同主题
4. 数据关系: 一个文件包含另一个文件使用的数据
5. 流程关系: 文件之间存在工作流程或处理顺序
对于每对可能有关联的文件，请评估:
- 关系类型
- 关系强度 (0.1-1.0)
- 关系描述
输出格式必须是JSON数组:
[
{{
"source_file_id": "文件ID",
"target_file_id": "文件ID",
"relation_type": "关系类型",
"strength": 0.8,
"description": "关系描述"
}},
...
]
只返回最可能的5-20个关系，确保关系质量高于数量。
"""
response = llm.invoke(prompt)
content = response.content
try:
json_match = re.search(r'\[.*\]', content, re.DOTALL)
if json_match:
relations_data = json.loads(json_match.group())
else:
relations_data = []
except:
relations_data = []
# 转换为FileRelation对象
relations = []
for rel in relations_data:
if 'source_file_id' in rel and 'target_file_id' in rel:
relation = FileRelation(
source_file_id=rel['source_file_id'],
target_file_id=rel['target_file_id'],
relation_type=rel.get('relation_type', '关联'),
strength=rel.get('strength', 0.5),
description=rel.get('description', '')
)
relations.append(relation)
return relations
except Exception as e:
logger.error(f"关系提取智能体失败: {str(e)}")
return []
def notebook_analysis_agent(self, notebook_id: str, user_question: str,
notebook_metadata: NotebookMetadata,
notebook_relations: NotebookRelations) -> str:
"""笔记本分析智能体 - 回答用户问题"""
try:
llm = self.get_llm(temperature=0.2)
# 准备文件内容用于检索
file_contents = []
for file in notebook_metadata.files:
# 只加载文本类文件内容
if file.type in ['txt', 'md', 'pdf', 'docx', 'html', 'json']:
try:
content = extract_text_from_file(file.path, file.type)
file_contents.append({
"name": file.name,
"summary": file.summary,
"content": content[:100000] # 限制长度
})
except:
pass
# 准备关系信息
relations_text = ""
for rel in notebook_relations.relations:
source_name = next((f.name for f in notebook_metadata.files if f.id == rel.source_file_id), rel.source_file_id)
target_name = next((f.name for f in notebook_metadata.files if f.id == rel.target_file_id), rel.target_file_id)
relations_text += f"- {source_name} → {target_name}: {rel.relation_type} ({rel.strength}): {rel.description}\n"
prompt = f"""
你是一个专业的笔记本分析助手，帮助用户分析他们的文件集合。
笔记本信息:
- 笔记本ID: {notebook_id}
- 文件数量: {len(notebook_metadata.files)}
- 笔记本标题: {notebook_metadata.summary.title}
文件列表及摘要:
{json.dumps([{"name": f.name, "summary": f.summary[:2000]} for f in notebook_metadata.files], ensure_ascii=False, indent=2)}
文件关系网络:
{relations_text}
相关文件内容（用于详细检索）:
{json.dumps(file_contents, ensure_ascii=False, indent=2)}
用户问题:
{user_question}
请基于以上信息，生成详细、专业的回答。要求:
1. 充分引用相关文件的内容和摘要
2. 利用文件关系网络说明文件之间的关联
3. 如果问题涉及数据分析，提供具体的分析思路
4. 如果文件内容不足，可以基于常识补充，但要说明
5. 回答要结构化，使用适当的标题、列表和强调
6. 字数不少于1500字，确保深度和专业性
请用Markdown格式输出回答。
"""
response = llm.invoke(prompt)
return response.content
except Exception as e:
logger.error(f"笔记本分析智能体失败: {str(e)}")
return f"分析失败: {str(e)}"
def all_files_summary_agent(self, notebook_metadata: NotebookMetadata) -> str:
"""所有文件摘要智能体 - 生成整体摘要"""
try:
llm = self.get_llm(temperature=0.1)
files_info = []
for file in notebook_metadata.files:
files_info.append({
"name": file.name,
"type": file.type,
"summary": file.summary[:30000]
})
prompt = f"""
你是一个文档集合分析专家。请基于以下文件集合，生成一个综合性的笔记本摘要。
笔记本信息:
- 标题: {notebook_metadata.summary.title}
- 描述: {notebook_metadata.summary.description}
- 标签: {', '.join(notebook_metadata.summary.tags)}
文件集合 ({len(notebook_metadata.files)} 个文件):
{json.dumps(files_info, ensure_ascii=False, indent=2)}
请生成一个综合性的笔记本摘要，包括:
1. 整体主题和内容概览（100字左右）
2. 文件类型分布和特点（200字左右）
3. 核心数据或信息的总结（500字左右）
4. 文件之间的协同关系（300字左右）
5. 潜在的分析方向和价值（4-5个方面的）
要求:
- 摘要要全面、准确
- 突出笔记本的核心价值
- 字数在1000-2500字之间
- 使用专业但易于理解的语言
输出格式: Markdown形式（格式平衡，不要过多空行）
"""
response = llm.invoke(prompt)
return response.content
except Exception as e:
logger.error(f"所有文件摘要智能体失败: {str(e)}")
return "生成摘要失败"
三、音频模式
该模式通过音频概览智能体实现了从“视觉阅读”到“听觉认知”的跨越。其核心逻辑在于拟人化脚本重构。智能体并不只是朗读文本，而是扮演一位专业的播客主持人或解说员。它首先综合整个笔记本的核心摘要，设计开场白、过渡语和结束语，将枯燥的书面语转化为口语化的对话脚本。同时，系统支持配置不同的语言风格（如专业严肃或轻松活泼），并输出标准的 HTML/SSML 格式，为接入高质量的 TTS（文本转语音）引擎做好了语义层的完美铺垫，让知识获取更具陪伴感。
def audio_overview_agent(self, notebook_metadata: NotebookMetadata, config: StudioConfig) -> str:
"""音频概览智能体 - 生成音频脚本HTML页面"""
try:
llm = self.get_llm(temperature=0.3)
# 准备笔记本摘要
notebook_summary = self.all_files_summary_agent(notebook_metadata)
prompt = f"""
你是一个专业的音频内容制作人。请基于以下笔记本内容，生成一个音频脚本HTML页面。
笔记本信息:
- 标题: {notebook_metadata.summary.title}
- 描述: {notebook_metadata.summary.description}
笔记本综合摘要:
{notebook_summary}
音频配置:
- 语言: {config.language}
- 风格: {config.style}
- 自定义提示: {config.custom_prompt}
请生成一个完整的HTML页面，包含:
1. 美观的页面设计
2. 音频脚本的完整展示
3. 脚本分段和格式
4. 预估时长和语速建议
输出完整的HTML代码，包含CSS样式。
"""
response = llm.invoke(prompt)
audio_result = response.content.replace('```html', '').replace('```', '').strip()
return audio_result
except Exception as e:
logger.error(f"音频概览智能体失败: {str(e)}")
return self._generate_error_html("音频概览", str(e))
四、信息图模式
这是**“代码即行动（Code-as-Action）”思想的典型应用。系统并未直接利用扩散模型生成图片（容易导致文字乱码），而是由信息图生成智能体**编写前端代码。智能体分析文档中的关键数据与定性结论，基于设计美学原则（如 Bento Grid 布局、玻璃拟态风格），自动编写包含 HTML、CSS 和 SVG 的单页应用。它能智能地将结构化数据映射为图表，将非结构化概念转化为视觉卡片。最终交付的是一个可交互、响应式的网页文件，保证了信息图中的每一个文字和数据都清晰、准确且可被浏览器渲染。
## 新模式：生成信息概览图模式
def infographic_report_agent(self, notebook_metadata: NotebookMetadata, config: StudioConfig) -> str:
"""信息概览图生成智能体"""
try:
llm = self.get_llm(temperature=0.5)
# 获取文件详细信息
files_details = []
for file in notebook_metadata.files:
files_details.append({
"name": file.name,
"type": file.type,
"summary": file.summary[:10000],
"metadata": file.metadata
})
json_data_info = """
{
"meta": {
"title": "< 提炼一个吸引人的主标题，限制在 10-20 字 >",
"subtitle": "< 一句话副标题，概括报告的核心范围或价值 >",
"generated_at": "< 当前生成的日期，格式 YYYY-MM-DD >"
},
"sidebar": {
"info_list": [
{
"label": "< 维度1名称，如：来源文件 >",
"value": "< 维度1的值 >",
"highlight": < true 或 false，如果是重要信息则为 true >
},
{
"label": "< 维度2名称，如：预估阅读时间 >",
"value": "< 维度2的值 >",
"is_mono": < true 或 false，如果是数字推荐为 true >
},
{
"label": "< 维度3名称，如：涉及领域 >",
"value": "< 维度3的值 >"
},
{
"label": "< 维度4名称，如：分析对象 >",
"value": "< 维度4的值 >"
}
],
"tags": [
"< 标签1 >",
"< 标签2 >",
"< 标签3 >",
"< 标签4 >"
],
"radar_data": {
"indicators": [
{ "name": "< 评估维度1，如：创新性 >", "max": 100 },
{ "name": "< 评估维度2，如：实用性 >", "max": 100 },
{ "name": "< 评估维度3，如：数据深度 >", "max": 100 },
{ "name": "< 评估维度4，如：逻辑性 >", "max": 100 },
{ "name": "< 评估维度5，如：可读性 >", "max": 100 }
],
"values": [
< 维度1评分 0-100 >,
< 维度2评分 0-100 >,
< 维度3评分 0-100 >,
< 维度4评分 0-100 >,
< 维度5评分 0-100 >
]
}
},
"overview": [
{
"id": "metric_1",
"icon": "< FontAwesome图标类名，如 fa-chart-line, fa-users, fa-money-bill >",
"label": "< 关键指标名称，如：市场增长率 >",
"value": "< 核心数值，如：35% >",
"unit": "< 单位，如：YoY >",
"sub_text": "< 简短的辅助说明，如：对比去年 >",
"color_theme": "< 颜色主题，从以下选择一个: blue, green, purple, orange, red >",
"trend": [
< 提供7个数字组成的数组，模拟趋势线，最后一个数字应接近 value 字段的值 >
],
"details": {
"title": "< 弹窗标题 >",
"description": "< 详细的解释文本，约50-80字 >",
"list": [
{"k": "< 细分项1 >", "v": "< 数值1 >"},
{"k": "< 细分项2 >", "v": "< 数值2 >"}
]
}
},
{
"id": "metric_2",
"icon": "< FontAwesome图标类名 >",
"label": "< 关键指标2名称 >",
"value": "< 核心数值2 >",
"unit": "< 单位2 >",
"sub_text": "< 辅助说明2 >",
"color_theme": "< 颜色主题2 >",
"trend": [ < 7个数字的趋势数组 > ],
"details": {
"title": "< 弹窗标题2 >",
"description": "< 解释文本2 >",
"list": [
{"k": "< 细分项 >", "v": "< 数值 >"}
]
}
},
{
"id": "metric_3",
"icon": "< FontAwesome图标类名 >",
"label": "< 关键指标3名称 >",
"value": "< 核心数值3 >",
"unit": "< 单位3 >",
"sub_text": "< 辅助说明3 >",
"color_theme": "< 颜色主题3 >",
"trend": [ < 7个数字的趋势数组 > ],
"details": {
"title": "< 弹窗标题3 >",
"description": "< 解释文本3 >",
"list": [
{"k": "< 细分项 >", "v": "< 数值 >"}
]
}
}
],
"key_findings": [
{
"index": "01",
"title": "< 关键发现1标题 >",
"content": "< 关键发现1的详细内容，约30-50字 >",
"color": "< 颜色，如 blue >",
"tag": "< 分类标签，如 技术 >"
},
{
"index": "02",
"title": "< 关键发现2标题 >",
"content": "< 关键发现2的详细内容 >",
"color": "< 颜色，如 purple >",
"tag": "< 分类标签，如 市场 >"
},
{
"index": "03",
"title": "< 关键发现3标题 >",
"content": "< 关键发现3的详细内容 >",
"color": "< 颜色，如 green >",
"tag": "< 分类标签 >"
},
{
"index": "04",
"title": "< 关键发现4标题 >",
"content": "< 关键发现4的详细内容 >",
"color": "< 颜色，如 orange >",
"tag": "< 分类标签 >"
}
],
"insights": [
{
"type": "focus",
"icon": "fa-lightbulb",
"content": "< 需要重点关注的信息，可以使用HTML标签如 <span class='text-yellow-300 font-bold'>重点词</span> 进行高亮 >"
},
{
"type": "quote",
"icon": "fa-quote-left",
"content": "< 文档中值得引用的金句或总结性话语 >"
}
],
"word_cloud": [
{ "name": "< 关键词1 >", "value": < 权重 80-100 > },
{ "name": "< 关键词2 >", "value": < 权重 60-80 > },
{ "name": "< 关键词3 >", "value": < 权重 50-70 > },
{ "name": "< 关键词4 >", "value": < 权重 40-60 > },
{ "name": "< 关键词5 >", "value": < 权重 30-50 > },
{ "name": "< 关键词6 >", "value": < 权重 20-40 > }
]
}
"""
prompt = f"""
你是一位资深的数据分析师和信息图表设计师。你的任务是阅读用户提供的文档（PDF/文本），并提取核心信息，将其转化为用于渲染 HTML 信息图的 JSON 数据格式。
笔记本信息:
- 标题: {notebook_metadata.summary.title}
- 描述: {notebook_metadata.summary.description}
- 标签: {', '.join(notebook_metadata.summary.tags)}
- 文件数量: {len(notebook_metadata.files)}
文件详细内容:
{json.dumps(files_details, ensure_ascii=False, indent=2)}
报告配置:
- 语言: {config.language}
- 风格: {config.style}
- 自定义要求: {config.custom_prompt}
Constraints (约束):
必须输出标准的、合法的 JSON 格式。
不要包含 Markdown 代码块标记（如 ```json），只输出纯 JSON 文本。
确保所有数值和结论都基于提供的文档内容。
如果文档中缺少某些特定数据（如趋势），请根据上下文进行合理的估算或模拟，以保持图表完整性。
JSON Output Structure & Extraction Rules (输出结构与提取规则):
请严格按照以下 JSON 模板进行填充，将 < ... > 替换为实际提取的内容：
{json_data_info}
"""
response = llm.invoke(prompt)
raw_json_str = response.content.replace('```json', '').replace('```', '').strip()
try:
# 2. 【关键步骤】将字符串解析为 Python 字典
# 这一步起到了“验证 JSON 格式合法性”的作用
data_dict = json.loads(raw_json_str)
# 3. 读取 HTML 模板
with open("template.html", "r", encoding="utf-8") as f:
html_template = f.read()
# 4. 将 Python 字典转换回 JSON 字符串用于注入
# 这样生成的才是标准的 JSON 对象格式：{"meta": ...}
valid_json_str = json.dumps(data_dict, ensure_ascii=False)
# 5. 注入 HTML
final_html = html_template.replace(
"let REPORT_JSON_DATA = null;",
f"let REPORT_JSON_DATA = {valid_json_str};"
)
# 保存
with open("output.html", "w", encoding="utf-8") as f:
f.write(final_html)
except json.JSONDecodeError as e:
print(f"JSON 解析失败，LLM 输出格式有误: {e}")
print("LLM 原始内容:", raw_json_str)
except Exception as e:
print(f"发生其他错误: {e}")
五、记忆卡片模式
该模块基于认知心理学中的“间隔重复”理论与**主动回忆（Active Recall）**机制设计。记忆卡片智能体扮演了“严苛的面试官”角色，深入分析文档内容的金字塔结构，从宏观主题到微观细节提取高价值考点。它将知识点转化为成对的“问题-答案”结构，并生成包含 3D 翻转动效的 H5 应用代码。通过前端逻辑控制，用户可以模拟真实的卡片学习体验，标记“已掌握”或“需复习”，从而帮助用户将外部文档知识高效转化为大脑的长期记忆。
def flashcards_agent(self, notebook_metadata: NotebookMetadata, config: StudioConfig) -> str:
"""闪记卡片生成智能体"""
try:
llm = self.get_llm(temperature=0.1)
prompt = f"""
你是一位认知心理学家和全栈开发工程师。你的任务是基于笔记本内容(重要！！！深度分析笔记本信息)，构建一个高效的、基于“间隔重复”理念的闪记卡片 (Flashcards) H5 应用。
核心任务 1：内容重构（从宏观到微观）
请不要简单地复制粘贴文件内容。你需要深入理解 {notebook_metadata.summary.title} 和所有文件的关键点，将其转化为 15-30 张高价值的闪记卡片。
卡片内容需遵循以下金字塔结构：
宏观层 (Global): 笔记本的核心主题是什么？解决了什么大问题？（约占 10%）
概念层 (Concepts): 核心术语、定义、关键理论。（约占 40%）
微观层 (Details): 具体的数据、案例、代码片段或特定文件的结论。（约占 50%）
核心任务 2：卡片结构化数据生成
请在生成的 HTML 代码的 <script> 区域，构建一个名为 cardsData 的 JSON 数组。
每个对象应包含：
id: 唯一标识。
category: 标签（如“核心概念”、“数据细节”、“全局概览”）。
front: 正面（问题/线索）。问题要简练，引发思考。
back: 背面（答案/解释）。答案要精准，支持 Markdown 简单格式（如列表）。
核心任务 3：UI 与交互设计 (使用 Tailwind CSS)
创建一个现代化的、沉浸式的学习界面：
卡片设计：
使用 CSS3 transform: rotateY 和 perspective 实现真实的 3D 翻转效果。
卡片应类似实体卡片，有圆角、阴影和纸质质感。
根据 {config.style} 调整配色（如：深色模式用深灰背景，亮色模式用米白背景）。
功能布局：
顶部：进度条（已掌握/总数）和当前类别标签。
中部：卡片显示区。点击卡片任意位置进行翻转。
底部：控制栏。
⬅️ "上一个" (Previous)
🔄 "翻转" (Flip)
✅ "已掌握" (Mark as Mastered) - 点击后更新进度条并自动切换下一张。
➡️ "下一个" (Next)
笔记本内容信息及输入数据：
笔记本标题: {notebook_metadata.summary.title}
文件关键点集合:
{json.dumps([{"name": f.name, "key_points": f.metadata.get('key_points', [])} for f in notebook_metadata.files], ensure_ascii=False, indent=2)}
配置: 语言={config.language}, 风格={config.style}
输出规范：
输出一个完整的 HTML 文件。
引入 CDN: Tailwind CSS (https://cdn.tailwindcss.com) 和 FontAwesome (https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css)。
不使用复杂的第三方 JS 框架（如 React/Vue），使用原生 JavaScript 操作 DOM，确保代码极其轻量且无依赖报错。
输出参考模板（请基于此编写代码，只需要输出HTML代码，请勿输出其他内容）：
```html
<!DOCTYPE html>
<html lang="{config.language}">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Flashcards Memory Deck</title>
<script src="https://cdn.tailwindcss.com"></script>
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
<style>
body {{ background-color: #f3f4f6; font-family: 'Segoe UI', sans-serif; }}
/* 3D 翻转核心样式 */
.scene {{ perspective: 1000px; }}
.card-inner {{
position: relative;
width: 100%;
height: 100%;
text-align: center;
transition: transform 0.6s;
transform-style: preserve-3d;
cursor: pointer;
}}
.card-inner.is-flipped {{ transform: rotateY(180deg); }}
.card-face {{
position: absolute;
width: 100%;
height: 100%;
backface-visibility: hidden;
border-radius: 1.5rem;
display: flex;
flex-direction: column;
justify-content: center;
align-items: center;
padding: 2rem;
box-shadow: 0 10px 30px rgba(0,0,0,0.1);
}}
.card-front {{ background-color: white; color: #1f2937; }}
.card-back {{ background-color: #4f46e5; color: white; transform: rotateY(180deg); }}
/* 如果是深色风格，这里会有对应的覆盖样式 */
</style>
</head>
<body class="h-screen flex flex-col items-center justify-center p-4">
<!-- 顶部状态栏 -->
<div class="w-full max-w-lg mb-6 flex justify-between items-center text-gray-600">
<span id="progress-text" class="font-bold text-sm">Card 1 / 10</span>
<div class="h-2 w-32 bg-gray-200 rounded-full overflow-hidden">
<div id="progress-bar" class="h-full bg-green-500 w-0 transition-all duration-300"></div>
</div>
</div>
<!-- 卡片容器 -->
<div class="scene w-full max-w-lg h-80 sm:h-96">
<div class="card-inner" id="flashcard" onclick="toggleFlip()">
<!-- 正面 -->
<div class="card-face card-front">
<span id="card-tag" class="absolute top-6 right-6 text-xs font-bold uppercase tracking-wider text-indigo-500 bg-indigo-50 px-2 py-1 rounded">概念</span>
<h2 id="card-question" class="text-2xl font-bold mb-4">Loading...</h2>
<p class="text-sm text-gray-400 mt-4">(点击翻转)</p>
</div>
<!-- 背面 -->
<div class="card-face card-back">
<div id="card-answer" class="text-lg leading-relaxed">Loading...</div>
</div>
</div>
</div>
<!-- 控制按钮 -->
<div class="flex gap-4 mt-8">
<button onclick="prevCard()" class="w-12 h-12 rounded-full bg-white shadow-lg text-gray-600 hover:bg-gray-50 hover:text-indigo-600 transition"><i class="fa-solid fa-arrow-left"></i></button>
<button onclick="markAsMastered()" class="px-6 py-3 rounded-xl bg-green-100 text-green-700 font-bold hover:bg-green-200 transition flex items-center gap-2">
<i class="fa-solid fa-check"></i> 已掌握
</button>
<button onclick="nextCard()" class="w-12 h-12 rounded-full bg-white shadow-lg text-gray-600 hover:bg-gray-50 hover:text-indigo-600 transition"><i class="fa-solid fa-arrow-right"></i></button>
</div>
<script>
// 1. 智能体生成的数据
const cardsData = [
{{
id: 1,
category: "全局概览",
front: "{notebook_metadata.summary.title} 的核心目标是什么？",
back: "{notebook_metadata.summary.description}"
}},
// ... 更多由智能体生成的卡片 ...
];
// 2. 逻辑控制
let currentIndex = 0;
let masteredCount = 0;
const cardElement = document.getElementById('flashcard');
function renderCard() {{
const card = cardsData[currentIndex];
document.getElementById('card-question').innerText = card.front;
document.getElementById('card-answer').innerText = card.back;
document.getElementById('card-tag').innerText = card.category;
// 重置翻转状态
cardElement.classList.remove('is-flipped');
// 更新进度UI
document.getElementById('progress-text').innerText = `Card ${{currentIndex + 1}} / ${{cardsData.length}}`;
const percentage = ((masteredCount) / cardsData.length) * 100;
document.getElementById('progress-bar').style.width = percentage + '%';
}}
function toggleFlip() {{
cardElement.classList.toggle('is-flipped');
}}
function nextCard() {{
if (currentIndex < cardsData.length - 1) {{
currentIndex++;
renderCard();
}} else {{
alert("已是最后一张卡片！");
}}
}}
function prevCard() {{
if (currentIndex > 0) {{
currentIndex--;
renderCard();
}}
}}
function markAsMastered() {{
// 简单逻辑：增加掌握计数并跳下一张
if(masteredCount < cardsData.length) masteredCount++;
nextCard();
}}
// 初始化
renderCard();
</script>
</body>
</html>
"""
response = llm.invoke(prompt)
#正则式处理去除```html和多余的内容，保留纯html内容
html_content = response.content.replace("```html", "").replace("'''", "").strip()
return html_content
except Exception as e:
logger.error(f"闪记卡片智能体失败: {str(e)}")
return self._generate_error_html("闪记卡片", str(e))
六、深度报告模式
此模块模拟了高级行业分析师的工作流。深度报告智能体不满足于简单的碎片拼接，而是具备全局的**综合（Synthesis）**能力。它首先扫描所有文档构建大纲，识别出共性主题与特异性证据；接着，按照学术或商业标准，撰写包含执行摘要、方法论、详细分析、关键发现及结论的完整长文。系统特别强化了逻辑的严密性与引用的准确性，支持 Markdown 格式输出，确保生成的报告结构清晰、层级分明，可直接作为正式的决策参考文档。
def deep_report_agent(self, notebook_metadata: NotebookMetadata, config: StudioConfig) -> str:
"""深度报告生成智能体"""
try:
llm = self.get_llm(temperature=0.1)
# 获取文件详细信息
files_details = []
for file in notebook_metadata.files:
files_details.append({
"name": file.name,
"type": file.type,
"summary": file.summary[:10000],
"metadata": file.metadata
})
prompt = f"""
你是一个专业的报告撰写专家。请基于以下笔记本内容，生成一份详细的深度分析报告。
笔记本信息:
- 标题: {notebook_metadata.summary.title}
- 描述: {notebook_metadata.summary.description}
- 标签: {', '.join(notebook_metadata.summary.tags)}
- 文件数量: {len(notebook_metadata.files)}
文件详细内容:
{json.dumps(files_details, ensure_ascii=False, indent=2)}
报告配置:
- 语言: {config.language}
- 风格: {config.style}
- 自定义要求: {config.custom_prompt}
报告要求:
1. 使用Markdown格式
2. 包含目录
3. 至少包含以下章节:
- 执行摘要
- 方法论说明
- 详细分析
- 关键发现
- 结论与建议
- 附录
4. 字数不少于2000字
5. 使用适当的标题层级
6. 包含表格、列表等格式化元素
7. 引用具体的文件内容
8. 提供数据支持和分析依据
9. 结尾提示报告时间、撰写人（EmberTrace AI Notebook）、AI内容检测声明
报告要专业、全面、有深度。
"""
response = llm.invoke(prompt)
return response.content
except Exception as e:
logger.error(f"深度报告智能体失败: {str(e)}")
return f"# 报告生成失败\n\n错误信息: {str(e)}"
七、PPT大纲模式
该模式专注于演示逻辑与视觉语言的转换。演示文稿智能体通过“结构化降维”，将长篇累牍的文档转化为精炼的幻灯片流（Slide Flow）。它为每一页 PPT 定义了明确的“核心结论（Key Takeaway）”和“演讲备注（Speaker Notes）”，确保汇报重点突出。更具创新性的是，它会为每一页生成可视化提示词（Visualization Prompt），指导用户或下游的文生图模型生成匹配的配图。这种“内容逻辑+视觉指令”的双重输出，极大地缩短了从文档到演讲稿的制作周期。
def deep_ppt_agent(self, notebook_metadata: NotebookMetadata, config: StudioConfig) -> str:
"""PPT Prompt生成智能体"""
try:
llm = self.get_llm(temperature=0.1)
# 获取文件详细信息
files_details = []
for file in notebook_metadata.files:
files_details.append({
"name": file.name,
"type": file.type,
"summary": file.summary[:30000],
"metadata": file.metadata
})
prompt = f"""
你是一个资深的商业分析与PPT架构专家，擅长将复杂笔记本内容转化为
【逻辑清晰、适合汇报展示、可直接用于生成PPT的结构化内容】。
请基于以下 Notebook 内容，生成一份【PPT 构建专用内容】，而不是长篇报告。
====================
一、Notebook 背景信息
====================
- 标题: {notebook_metadata.summary.title}
- 描述: {notebook_metadata.summary.description}
- 标签: {', '.join(notebook_metadata.summary.tags)}
- 文件数量: {len(notebook_metadata.files)}
====================
二、文件内容（已整理）
====================
{json.dumps(files_details, ensure_ascii=False, indent=2)}
====================
三、PPT 生成配置
====================
- 语言: {config.language}
- 整体风格: {config.style}
- 额外要求: {config.custom_prompt}
====================
四、输出目标（非常重要）
====================
请生成一份【可直接用于 PPT 自动生成的内容结构】，满足以下要求：
### 1️⃣ 输出格式
- 使用 **Markdown**
- 严格按“Slide”为单位组织内容
- 每一页 PPT 必须包含以下固定结构：
Slide X：页面标题
Key Points（展示要点）
要点1（不超过20字，结论性表达）
要点2
要点3（3–6条）
Speaker Notes（演讲说明）
对本页要点的详细解释（80–150字，可口语化）
Data / Evidence（数据或依据）
引用的文件名 + 关键数据 / 结论
Visualization Prompt（可视化提示词）
用于多模态模型生成图表 / 信息图的英文 Prompt（40–120 words）
---
### 2️⃣ PPT 结构要求（必须包含）
请至少生成 **12–18 页 PPT**，并覆盖以下逻辑模块（可合并或拆分）：
1. 封面（Title Slide）
2. 研究背景 / 问题定义
3. 数据来源与文件说明
4. 方法论与分析框架
5. 核心分析结果（≥4页）
6. 关键发现总结
7. 业务 / 技术 /决策启示
8. 风险、限制与假设
9. 结论页
10. 行动建议 / 下一步
11. 附录（方法、补充数据）
---
### 3️⃣ 内容风格约束
- 表达偏 **汇报型 / 决策型**
- 每一页必须有“明确想传达的一句话结论”
- 避免学术论文式长段落
- 优先使用结构化、对比、分点、归纳
---
### 4️⃣ 可视化提示词要求（重点）
- 每一页都给出 Visualization Prompt
- 明确说明图表类型（如：flowchart / bar chart / timeline / architecture diagram）
- 强调信息层级、配色、风格（适合PPT展示）
- 禁止泛泛描述，必须可直接用于生成图片
---
### 5️⃣ 结尾页要求
最后一页请注明：
- 报告生成时间
- Author: EmberTrace AI Notebook
- AI Generated Content Disclosure
====================
五、最终目标
====================
你的输出将被程序直接解析并转换为 PPT 页面。
请确保结构稳定、层级清晰、内容专业、适合展示。
"""
response = llm.invoke(prompt)
return response.content
except Exception as e:
logger.error(f"深度报告智能体失败: {str(e)}")
return f"# 报告生成失败\n\n错误信息: {str(e)}"
八、知识图谱模式
该模块将笔记本视为一个复杂的语义网络数据库。图谱生成智能体执行高精度的命名实体识别（NER），从海量文本中提取人物、组织、概念等实体，并计算它们之间的关联强度。随后，智能体编写基于 D3.js 等可视化库的 JavaScript 代码，渲染出一个力导向图（Force-Directed Graph）。用户可以通过拖拽节点、缩放画布来探索知识的边界，点击节点即可展开详细的侧边栏描述。这种可视化的交互方式，让隐蔽在大量文本中的关联关系瞬间显性化。
def graph_agent(self, notebook_metadata: NotebookMetadata, config: StudioConfig) -> str:
"""知识图谱生成智能体"""
try:
llm = self.get_llm(temperature=0.2)
# 提取实体和关系
prompt = f"""
你是一位精通网络科学、数据可视化和前端开发的专家。你的任务是将输入的信息转化为一个深度、多维、交互式的知识图谱 HTML 页面。
核心任务：
请基于提供的内容，分析并构建一个高质量的知识图谱。不要仅仅列出简单的点和线，而是要深入挖掘信息背后的层级、权重和簇群关系。
文件列表:
{json.dumps([{"name": f.name, "summary": f.summary[:30000]} for f in notebook_metadata.files], ensure_ascii=False, indent=2)}
步骤 1：深度信息抽取与结构化
请识别并构建以下数据结构（JSON格式嵌入代码中）：
节点 (Nodes)：
核心实体：提取人物、组织、概念、技术、事件等。
属性提取：
id: 唯一标识。
group: 实体类别（用于颜色分类）。
value: 权重/重要性（基于文本提及频率或中心度，决定节点大小）。
description: 详细的实体描述（不少于50字，用于点击展示）。
tags: 相关标签列表。
关系 (Links)：
语义连接：提取实体间的具体关系（如“创始人”、“隶属于”、“衍生出”、“导致”）。
关系强度：评估关系的紧密程度（1-10），决定连线的粗细。
方向性：明确关系的指向（Source -> Target）。
步骤 2：可视化与交互设计要求 (D3.js)
生成一个包含完整 CSS/JS 的单文件 HTML，需满足以下标准：
视觉美学 (Aesthetics)：
采用现代极简风格或科技深色模式（根据 {config.style} 自动调整）。
节点设计：根据 value 动态调整大小；使用高辨识度的配色方案区分 group；添加微弱的阴影或发光效果增加质感。
连线设计：使用带有箭头的曲线或直线；根据关系强度调整透明度和粗细。
文字标签：智能显示（高权重节点常驻显示，低权重节点鼠标悬停显示，避免遮挡）。
高级交互 (Interactions)：
物理模拟：使用 D3 Force Simulation，配置合理的引力、斥力和碰撞检测，使图谱布局自然、舒展，互不重叠。
缩放与平移：支持鼠标滚轮缩放和拖拽画布。
高亮模式：鼠标悬停在节点上时，高亮该节点及其直接相连的节点/连线，并将其他节点淡化（Opacity降低）。
详情侧边栏/卡片：点击节点时，不要使用简单的 alert。在页面右侧或浮层滑出一个设计精美的信息面板 (Info Panel)，展示实体的名称、类别、详细描述、标签及相关关系列表。
功能组件 (Components)：
图例 (Legend)：显示不同颜色代表的实体类别。
搜索框：允许用户搜索节点名称，定位并高亮。
控制栏：提供“重置视图”或“暂停/开始力导向”的按钮。
配置参数注入：
目标语言: {config.language} (确保界面和提取的内容均为该语言)
设计风格: {config.style} (如：Cyberpunk, Minimalist, Academic)
用户额外指令: {config.custom_prompt} (请根据此指令微调数据提取的侧重点)
代码输出规范：
输出一个完整的、可直接运行的 HTML 代码块。
使用 CDN 引入 D3.js v7。
CSS 样式应内嵌，使用 Flexbox/Grid 布局，确保响应式。
JavaScript 代码需包含完整的数据集（const graph = {...}）和渲染逻辑。
确保处理了节点文字过长的情况（截断或换行）。
不要输出任何其他无且与html代码无关的内容
参考示例结构：
```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>知识图谱</title>
<style>
/* 样式表 */
</style>
</head>
.....
</html>
"""
response = llm.invoke(prompt)
##正则式提取html代码块
#html_match = re.search(r'```html(.*?)```', response.content, re.DOTALL)
graph_html = response.content.replace('```html', '').replace('```', '').strip()
return graph_html
except Exception as e:
logger.error(f"知识图谱智能体失败: {str(e)}")
return self._generate_error_html("知识图谱", str(e))
九、数据看板模式
此模块实现了非结构化数据与结构化数据的融合可视化。看板设计智能体不仅能处理 CSV/Excel 中的表格数据，还能从 PDF/Word 中提取关键指标（KPIs）。它生成一个包含 ECharts 或 Chart.js 图表的交互式 HTML 页面。智能体具备 UI/UX 设计能力，能够自动布局顶部指标卡、中部趋势图和底部详细数据表。这种模式将静态的文档包瞬间转化为动态的 BI（商业智能）仪表盘，支持用户通过筛选时间或维度来实时探索数据背后的趋势。
def dashboard_agent(self, notebook_metadata: NotebookMetadata, config: StudioConfig) -> str:
"""数据看板生成智能体 - 整合结构化数据和非结构化知识"""
try:
# 1. 分离结构化数据文件和非结构化数据文件
structured_files = [f for f in notebook_metadata.files if f.type in ['csv', 'xlsx', 'xls']]
unstructured_files = [f for f in notebook_metadata.files if f.type in ['pdf', 'docx', 'txt', 'md', 'html']]
logger.info(f"数据看板生成: 结构化文件 {len(structured_files)} 个，非结构化文件 {len(unstructured_files)} 个")
# 2. 处理非结构化数据，提取关键知识
unstructured_knowledge = {"knowledge_per_file": [], "combined_summary": "", "total_files": 0}
if unstructured_files:
unstructured_processor = UnstructuredDataProcessor(self.model_config)
unstructured_data = []
for file in unstructured_files[:50]: # 限制处理文件数量
unstructured_data.append({
'path': file.path,
'type': file.type,
'name': file.name
})
if unstructured_data:
unstructured_knowledge = unstructured_processor.process_multiple_files(unstructured_data)
# 3. 获取结构化数据信息
structured_info = self.get_structured_data_info(structured_files)
# 4. 创建工作目录
workdir = os.path.join(NOTEBOOK_ANALYSIS_DIR, notebook_metadata.notebook_id, "dashboard", str(uuid.uuid4())[:8])
os.makedirs(workdir, exist_ok=True)
# 5. 构建数据信息
data_info = {
"notebook_title": notebook_metadata.summary.title,
"notebook_description": notebook_metadata.summary.description,
"config": {
"language": config.language,
"style": config.style,
"custom_prompt": config.custom_prompt,
"dashboard_type": "interactive" # 交互式看板
},
"unstructured_knowledge": unstructured_knowledge,
"structured_data_info": structured_info
}
# 6. 构建详细的agents_info提示词
agents_info = f"""
你是一个高级数据看板设计专家，需要创建一个交互式数据看板HTML页面。
## 任务要求
1. 创建一个完整的数据看板HTML页面
2. 页面必须是响应式设计
3. 包含丰富的交互功能
4. 整合数据可视化和关键知识展示
## 笔记本信息
- 标题: {notebook_metadata.summary.title}
- 描述: {notebook_metadata.summary.description}
## 配置参数
- 语言: {config.language}
- 风格: {config.style}
- 自定义提示: {config.custom_prompt}
## 非结构化知识（从文本文件中提取）
以下是从非结构化文件中提取的关键知识：
```
{json.dumps(unstructured_knowledge, ensure_ascii=False, indent=2)[:8000]}
```
## 结构化数据文件
以下是可用的结构化数据文件：
```
{json.dumps(structured_info, ensure_ascii=False, indent=2)[:8000]}
```
## 看板设计指南
设计一个包含以下组件的交互式数据看板：
1. **顶部导航栏**
- 看板标题
- 时间范围选择器
- 数据筛选器
2. **KPI指标区**
- 显示关键指标的卡片（使用非结构化知识中的关键数据点）
- 每个卡片包含：指标名称、当前值、变化趋势、图标
3. **主图表区**
- 左侧：主要数据可视化图表（折线图、柱状图等）
- 右侧：辅助图表或数据表格
4. **知识摘要区**
- 展示从非结构化文件中提取的关键发现
- 使用卡片式布局展示关键概念
5. **详细数据区**
- 可交互的数据表格
- 支持排序、筛选、搜索
6. **控制面板**
- 图表类型切换
- 数据维度选择
- 导出功能
## 技术要求
1. 使用ECharts或Plotly.js进行高级数据可视化
2. 实现真正的交互功能（点击筛选、悬停提示、动态更新）
3. 使用现代前端框架思路（组件化设计）
4. 添加数据加载状态指示
5. 实现响应式布局，支持移动端
## 输出要求
生成一个完整的HTML文件，包含：
- 完整的HTML结构
- 内联或链接的CSS/JavaScript
- 数据可视化代码
- 交互功能实现
注意：HTML文件应该可以直接在浏览器中打开运行，所有数据应该嵌入在文件中。
请生成Python代码来创建这个HTML文件，并将HTML内容保存到工作目录中。
"""
# 7. 调用NL_code_write_execute_agents
result = NL_code_write_execute_agents(
user_message="基于提供的结构化数据和非结构化知识，创建一个交互式数据看板HTML页面",
agents_info=agents_info,
workdir_=workdir,
data_info=data_info,
max_turns=3
)
# 8. 查找生成的HTML文件
for file_path in result.get("file_excute_path", []):
if file_path.endswith('.html'):
with open(file_path, 'r', encoding='utf-8') as f:
html_content = f.read()
# 确保HTML是完整的
if '<html' in html_content.lower() and '</html>' in html_content.lower():
return html_content
# 如果没找到HTML文件，尝试生成基本的看板
logger.warning("NL_code_write_execute_agents未生成HTML文件，尝试生成基本看板")
return self._generate_basic_dashboard(notebook_metadata, config, unstructured_knowledge, structured_info)
except Exception as e:
logger.error(f"数据看板智能体失败: {str(e)}")
return self._generate_error_html("数据看板", str(e))
def _generate_basic_dashboard(self, notebook_metadata: NotebookMetadata, config: StudioConfig,
unstructured_knowledge: Dict, structured_info: Dict) -> str:
"""生成基础看板"""
try:
llm = self.get_llm(temperature=0.5)
prompt = f"""
你是一位世界级的 UI/UX 设计师和数据可视化专家。你的任务是将提供的笔记本信息和知识摘要，转化为一个交互式、响应式、视觉震撼的单页 HTML 数据看板。
核心任务：
不要只堆砌数据。你需要理解 {unstructured_knowledge} 中的核心业务逻辑，提取出关键指标（KPIs），并将其转化为直观的图表和洞察。
设计风格与布局策略（根据 {config.style} 动态调整）：
布局架构：采用 Bento Grid（便当盒式网格布局） 或 Admin Dashboard（侧边栏+主控台） 布局。使用 CSS Grid 确保在桌面端和移动端的完美响应。
视觉语言：
如果风格是 Modern：使用玻璃拟态 (Glassmorphism)，柔和的渐变背景，大圆角 (rounded-2xl)，轻微的阴影。
如果风格是 Professional：使用极简主义，高对比度黑白灰，精细的边框，衬线字体标题。
如果风格是 Creative：使用大胆配色，卡片悬停放大效果，不对称布局。
配色方案：请根据 {config.language} 和内容情感自动选择主色调（如：金融类用深蓝/金，科技类用靛蓝/紫，生态类用翠绿）。
看板组件具体要求：
全局头部 (Header)：
展示笔记本标题 {notebook_metadata.summary.title}。
右侧显示当前日期和“数据已更新”的状态标记。
核心指标区 (KPI Cards) - 位于顶部：
从知识摘要中提取 4 个关键数据点（如果文中没有具体数字，请根据上下文提炼定性指标，如“核心主题数”、“涉及实体数”等）。
UI要求：每个卡片包含图标（使用 FontAwesome）、主数值（大字体）、辅助标签（小字体）和趋势指示器（如：↑ 12% vs 上月）。
主要可视化区 (Charts Section) - 位于中部：
分布图 (Doughnut/Pie)：展示 {structured_info} 中的文件类型分布，或从摘要中提取的“主题占比”。
趋势/分析图 (Bar/Line)：基于知识摘要中的时间线或对比信息，构建一个分析图表。注意：如果缺乏具体数值，请根据文本逻辑生成合理的模拟数据以展示可视化效果，并在图表下方注明“基于文本内容的估算趋势”。
交互：使用 Chart.js，配置 hover 效果和 tooltip。
智能洞察区 (Insights & Summary) - 位于下部或侧边：
不要直接丢出大段文本。将 {unstructured_knowledge} 拆解为“关键发现”、“风险提示”和“行动建议”三个模块。
使用列表、高亮标签或进度条来呈现文本信息。
文件资产概览：
一个小型的表格或列表，展示文件数量 {len(notebook_metadata.files)} 及主要文件名称。
技术实现规范：
必须输出：完整的单一 HTML 文件代码。
库引用：
Tailwind CSS: <script src="https://cdn.tailwindcss.com"></script>
Chart.js: <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
FontAwesome: <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
Google Fonts (Inter): 引用 Inter 字体以提升质感。
脚本逻辑：将 Chart.js 的配置数据直接嵌入在 <script> 标签中。
笔记本摘要及输入数据：
标题: {notebook_metadata.summary.title}
摘要内容: {unstructured_knowledge.get('combined_summary', '无')[:80000]}
结构化文件数: {structured_info.get('total_files', 0)}
输出格式参考（严格遵守）：
只输出 HTML 代码，不要包含 Markdown 标记（如 ```html），不要包含任何解释性文字。
输出格式参考：
```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>AI Analytics Dashboard</title>
<script src="https://cdn.tailwindcss.com"></script>
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
<link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet">
<script>
......................
</html>
"""
response = llm.invoke(prompt)
#正则式处理去除```html和多余的内容，保留纯html内容
html_content = re.sub(r'```html.*?```', '', response.content, flags=re.DOTALL).strip()
return html_content
except Exception as e:
logger.error(f"生成基础看板失败: {str(e)}")
return self._generate_error_html("数据看板", str(e))
十、思维导图模式
该模块致力于知识的层级化梳理与分类。思维导图智能体采用“自顶向下”的归纳逻辑，从笔记本标题出发，识别一级主题、二级概念直至三级证据细节，构建出一棵严谨的知识树。系统最终输出兼容 Markmap 等渲染库的 Markdown 格式数据或 HTML 文件。这种呈现方式能够将几万字的长文档压缩进一张可缩放的全景图中，帮助用户在极短时间内把握复杂文档的脉络结构与核心逻辑框架。
def mindmap_agent(self, notebook_metadata: NotebookMetadata, config: StudioConfig) -> str:
"""思维导图生成智能体"""
try:
llm = self.get_llm(temperature=0.2)
prompt = f"""
你是一位知识管理专家和前端可视化工程师。你的任务是将杂乱的笔记本文件内容，梳理成清晰、有逻辑深度的思维导图。
核心任务：
请分析笔记本的标题、描述以及所有文件的摘要，提取核心知识点，并将其组织成层级化的结构。不要仅仅列出文件名，要按主题 (Topic) 或 概念 (Concept) 进行归类。
技术选型 (关键)：
请使用 Markmap (markmap-view) 库。这是一种基于 D3.js 的轻量级、标准化的思维导图渲染库。
数据源格式：Markdown 字符串。
优势：支持交互（点击折叠/展开）、缩放、自动布局。
思维导图结构要求：
请构建一个 Markdown 字符串，逻辑如下：
根节点 (#): 笔记本标题 {notebook_metadata.summary.title}。
二级节点 (##): 根据文件内容归纳出的 3-6 个核心主题或类别（例如：如果文件包含财务报表和会议记录，主题可能是“财务状况”和“管理决策”，而不是直接显示文件名）。
三级节点 (###): 具体的文件名或该主题下的关键概念。
四级节点 (-): 从文件摘要中提取的 2-3 个关键洞察或数据点。
其他节点：如果某个文件特别重要，可以添加更多层级的子节点，确保信息完整。
UI 与配置要求：
全屏布局：思维导图应占据整个屏幕 (100vw, 100vh)。
配色：根据 {config.style} 调整 SVG 的线条颜色或背景色（如果是深色模式，背景设为深色，文字设为浅色）。
交互：启用缩放 (Zoom) 和平移 (Pan)。
笔记本摘要及其他输入数据：
标题: {notebook_metadata.summary.title}
描述: {notebook_metadata.summary.description}
用户额外提示: {config.custom_prompt}
文件列表及摘要:
{json.dumps([{"name": f.name, "summary": f.summary[:3000]} for f in notebook_metadata.files], ensure_ascii=False, indent=2)}
输出规范：
输出一个完整的 HTML 文件。
引入 CDN: https://cdn.jsdelivr.net/npm/d3@7, https://cdn.jsdelivr.net/npm/markmap-view, https://cdn.jsdelivr.net/npm/markmap-lib (用于转换 markdown)。
关键步骤：在 <script> 标签中，将生成的 Markdown 内容赋值给变量。
代码健壮性：请确保 Markdown 字符串中的换行符被正确转义（使用 \n），避免 JavaScript 语法错误。
输出参考模板（请基于此填充内容）：
```html
<!DOCTYPE html>
<html lang="{config.language}">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Mind Map</title>
<style>
* {{ margin: 0; padding: 0; }}
#mindmap {{ display: block; width: 100vw; height: 100vh; background: #f8fafc; }}
/* 如果 config.style 是深色，这里自动调整为深色背景 */
</style>
</head>
<body>
<svg id="mindmap"></svg>
<script src="https://cdn.jsdelivr.net/npm/d3@7.8.5/dist/d3.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/markmap-view@0.15.4/dist/index.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/markmap-lib@0.15.4/dist/browser/index.min.js"></script>
<script>
// 1. 这里是智能体生成的 Markdown 内容
const markdown = `
# {notebook_metadata.summary.title}
## 核心主题A
### 关键概念 1
- 详细洞察...
- 详细洞察...
### 文件: report.pdf
- 包含数据 X
- 结论 Y
## 核心主题B
...
`;
// 2. 渲染逻辑
const {{ Transformer }} = window.markmap;
const {{ Markmap, loadCSS, loadJS }} = window.markmap;
const transformer = new Transformer();
// 转换 markdown 为数据结构
const {{ root, features }} = transformer.transform(markdown);
// 加载必要的样式和脚本
if (features.styles) loadCSS(features.styles);
if (features.scripts) loadJS(features.scripts);
// 渲染
Markmap.create('#mindmap', {{
autoFit: true, // 自动缩放以适应屏幕
fitRatio: 0.9,
duration: 500, // 动画时长
}}, root);
</script>
</body>
</html>
"""
response = llm.invoke(prompt)
#正则式处理去除```html和多余的内容，保留纯html内容
html_content = re.sub(r'```html.*?```', '', response.content, flags=re.DOTALL).strip()
return html_content
except Exception as e:
logger.error(f"思维导图智能体失败: {str(e)}")
return self._generate_error_html("思维导图", str(e))
实践方式
01 文本对话及摘要自动提取
02 模式一：音频内容生成
- 用户可以根据自己需要提供音频模式的风格及提示信息
- 生成的音频内容
03 模式二：信息图生成模式：用户可以通过定制不同的信息图模板html进行扩展
04 模式三：记忆卡片模式
05 模式四：深度报告模式
- 该模式还生成了用于生成信息图的提示词（借助nanobanana可生成如下图片）
- prompt：Infographic Generation Prompt
Create a detailed infographic titled “Evolution of the Transformer Architecture.” Center the graphic with a core icon labeled “Base Transformer (Self-Attention).” From the center, draw four distinct branches representing key improvements identified in the report:
Hybrid Vision: Show a U-Net icon merging with a Transformer icon, labeled “TransUNet: CNN + Transformer for Medical Segmentation.”
3D Spectral: Depict a cube being split into 3D tokens, labeled “SpectralGPT: 3D Attention for Remote Sensing.”
Multi-Scale & Boundary: Illustrate a pyramid structure with sharp edges, labeled “HBGMT: T2T & Hierarchical Boundary Guidance.”
Token-Level Alignment: Show a sequence of tokens being individually optimized, labeled “TDPO: Fine-Grained LLM Alignment.” Use a clean, academic color palette (blues, teals, and grays). Include small icons for application domains: a stethoscope (Medical), a satellite (Remote Sensing), a car (Autonomous Driving), and a chat bubble (NLP).
- nanobanana生成的信息图
06 模式五：PPT大纲模式
- 基于生成的ppt大纲提示词，输入到google NotebookLM中，生成的ppt
07 模式六：知识图谱模式
08 模式七：数据看板模式
09 模式八：思维导图模式
结论与讨论
1、未来工作
EmberTrace AI 的 NoteBook Mode 目前已验证了“多智能体协作”在知识重构中的巨大潜力，但要实现真正的“全能第二大脑”，仍需在以下维度深化迭代：
- 原生多模态大模型的深度集成：当前的音频与视觉模式主要依赖“脚本+代码”的中间态生成。未来将直接引入端到端的原生音频模型与文生图模型。这意味着系统不再仅生成播客文稿或 SVG 代码，而是能直接输出情感饱满的 MP3 音频文件和高精度的艺术配图，实现从“逻辑可视化”到“感官沉浸”的跨越。
- 结构化数据解析智能体的进化：为了处理更复杂的商业分析需求，将引入数据分析级别的智能体。该智能体将具备高级数据科学家的能力，能够对百万行级的 Excel/CSV 数据进行清洗、回归分析、预测建模，并自动生成 Python/Pandas 代码进行验证，而非仅停留在描述性统计层面。
- 记忆模式的实时化与持久化：当前的分析多基于会话。未来将构建增量式向量数据库与长期记忆网络。系统将具备“热更新”能力，仅对新上传的文件进行索引，同时记住用户的偏好与历史分析上下文，实现毫秒级的知识检索与响应，让笔记本越用越懂用户。
2、瓶颈与展望
尽管架构设计先进，但落地的过程仍面临技术天花板的制约，同时也孕育着重构人机交互范式的机遇。
- 当前瓶颈：
- 模型能力的边界：尽管多智能体能拆解任务，但在极度复杂的长链条推理（如生成万字研报）中，模型仍可能出现逻辑断层或指令遵循漂移。
- 上下文窗口与成本的博弈：虽然百万级 Token 窗口已出现，但在处理海量本地知识库（如 GB 级文档）时，RAG（检索增强生成）的精度（"Lost in the Middle"现象）与 API 调用成本依然是核心制约因素。如何在精度、速度与成本之间找到最优的压缩与检索算法，是持续攻坚的难题。
- 行业展望：
- 笔记本产品的彻底重构：NoteBook Mode 预示着“笔记”定义的消亡。未来的笔记本不再是静态文字的容器，而是动态的思维计算平台。用户不再是“记录者”，而是“导演”，指挥 AI 将素材编排成各种形态的知识产品。
- 本地文档管理的新范式：文件系统中的“文件夹”概念将被语义网络取代。用户无需关心文件存在哪里，只需关心知识之间的关联。这种基于私有数据的、多模态的、主动式的智能分析系统，将成为个人与企业构建本地化主权大模型应用的标准范式。
有“AI”的1024 = 2048，欢迎大家加入2048 AI社区
更多推荐
16
0- 0
已为社区贡献1条内容
所有评论(0)