Co-STORM：人机协作的知识整理新范式

【免费下载链接】storm An LLM-powered knowledge curation system that researches a topic and generates a full-length report with citations. 项目地址: https://gitcode.com/GitHub_Trending/sto/storm

Co-STORM是一套创新的人机协作知识整理系统，通过精心设计的协作协议实现了人类用户与多个AI专家之间的流畅对话和知识共建。该系统基于真实学术讨论场景的深度模拟，采用智能回合管理策略、动态专家调度机制和共享概念空间构建，创造了一个真正意义上的协作知识探索环境。系统设计了三种核心角色：Co-STORM专家负责基于外部知识源生成回答，主持人引导对话方向并提出启发性问题，人类用户可观察对话或主动参与引导。

Co-STORM协作协议设计理念

Co-STORM作为人机协作的知识整理系统，其核心创新在于设计了一套精心编排的协作协议，实现了人类用户与多个AI专家之间的流畅对话和知识共建。这一协议的设计理念基于对真实学术讨论场景的深度模拟，通过智能的回合管理策略、动态专家调度机制和共享概念空间构建，创造了一个真正意义上的协作知识探索环境。

多智能体角色分工与协作架构

Co-STORM协议设计了三种核心角色，每种角色承担特定的职责并遵循不同的行为模式：

角色类型	主要职责	行为特征	协作方式
Co-STORM专家	基于外部知识源生成回答，提出后续问题	领域专业化，知识驱动	轮流参与讨论，提供深度见解
主持人(Moderator)	引导对话方向，提出启发性问题	全局视角，协调管理	在适当时机介入，防止对话偏离
人类用户	观察对话或主动参与引导	灵活介入，目标导向	可随时注入话语，影响讨论进程

智能回合管理策略

Co-STORM的回合管理策略是其协议设计的核心，通过TurnPolicySpec数据结构来精确控制每个对话回合的行为：

@dataclass
class TurnPolicySpec:
    agent: Agent  # 当前回合的发言角色
    should_reorganize_knowledge_base: bool = False  # 是否重组知识库
    should_update_experts_list: bool = False  # 是否更新专家列表
    should_polish_utterance: bool = True  # 是否润色话语

协议采用基于规则的智能决策机制，根据对话历史和知识库状态动态确定下一回合的策略：

1. 连续性控制：当专家连续回答超过设定阈值（默认3次）时，主持人会自动介入，防止对话陷入单一视角
2. 知识库状态感知：系统监控知识库中信息片段的积累情况，当某个节点包含的信息超过阈值时触发扩展
3. 专家轮换机制：采用轮询方式调度不同领域的专家，确保多角度知识覆盖

动态知识库与概念空间构建

Co-STORM协议的核心创新之一是维护一个动态更新的思维导图（Mind Map），该结构将收集的信息组织成层次化的概念结构：

这种层次化结构的设计理念在于：

• 构建共享概念空间：为人类用户和AI系统提供共同的理解框架
• 支持非线性探索：允许用户在不同概念间自由导航和深入探索
• 动态演化能力：随着对话的进行不断扩展和重组知识结构

话语生成与优化流程

Co-STORM采用多阶段的话语生成流程，确保输出的质量和适宜性：

人类参与与系统响应机制

协议设计充分考虑了人类用户的主动参与需求，提供了灵活的介入机制：

1. 观察模式：用户可被动观察AI专家间的讨论，学习知识探索过程
2. 主动引导：用户可随时注入话语，直接影响讨论方向和重点
3. 意图模拟：系统可模拟用户意图，用于测试和演示目的

def step(self, user_utterance: str = "", 
         simulate_user: bool = False,
         simulate_user_intent: str = "") -> ConversationTurn:
    """
    执行协作对话的一个回合
    :param user_utterance: 用户注入的话语
    :param simulate_user: 是否模拟用户
    :param simulate_user_intent: 模拟用户的意图
    :return: 生成的对话回合
    """

协议的可扩展性与定制性

Co-STORM协议设计具有良好的可扩展性，开发者可以通过以下方式定制协作行为：

• 角色扩展：可添加新的专家类型或修改现有角色行为
• 策略调整：通过修改RunnerArgument参数调整回合管理策略
• 知识库适配：支持不同的知识组织方式和检索机制
• 话语风格：可定制不同场景下的话语生成风格和格式

这种设计理念使得Co-STORM不仅是一个静态的系统，更是一个可适应不同应用场景和用户需求的协作框架，为人机协作的知识整理设立了新的标准。

LLM专家与人类用户协同机制

在Co-STORM框架中，LLM专家与人类用户的协同机制是整个系统的核心创新。这种机制通过精心设计的角色分工、动态对话策略和知识共享空间，实现了人机之间的高效协作。

专家角色体系与职责分工

Co-STORM构建了一个多专家协同的知识整理体系，不同类型的专家承担着特定的职责：

专家类型	主要职责	协作方式
Co-STORM专家	基于外部知识源生成回答，提出后续问题	参与圆桌讨论，提供专业见解
主持人	注入新视角，避免对话停滞	基于未使用的信息片段生成启发性问题
模拟用户	模拟真实用户交互行为	用于自动化实验和系统测试

class CoStormExpert(Agent):
    """Co-STORM专家类，负责参与圆桌讨论并生成专业见解"""
    
    def generate_utterance(self, knowledge_base, conversation_history):
        # 获取知识库摘要
        conversation_summary = knowledge_base.get_knowledge_base_summary()
        
        # 生成专家回应
        conv_turn = self.costorm_agent_utterance_generator(
            topic=self.topic,
            current_expert=self.get_role_description(),
            conversation_summary=conversation_summary,
            last_conv_turn=last_conv_turn
        ).conversation_turn
        
        # 优化回应内容
        self.costorm_agent_utterance_generator.polish_utterance(
            conversation_turn=conv_turn, 
            last_conv_turn=last_conv_turn
        )
        return conv_turn

动态对话策略管理

Co-STORM采用智能的轮次策略管理机制，确保对话的流畅性和深度：

这种策略管理基于以下关键判断逻辑：

def _should_generate_question(self, conversation_history):
    """判断是否需要生成新问题"""
    if not conversation_history:
        return True
    
    # 检查最近几轮是否都是回答而非提问
    last_n_turns = conversation_history[-3:] if len(conversation_history) >= 3 else conversation_history
    questioning_turns = [turn for turn in last_n_turns 
                        if turn.utterance_type == "Questioning"]
    return len(questioning_turns) == 0

知识共享空间构建

Co-STORM通过动态更新的思维导图（Mind Map）构建人机共享的概念空间：

这种共享空间通过以下机制维护：

1. 信息插入模块：将收集到的信息智能地插入到合适的知识节点
2. 节点扩展机制：当节点包含的信息超过阈值时自动扩展子节点
3. 语义相似度计算：基于嵌入向量确保信息的合理归类

人机交互模式

人类用户可以通过两种主要方式参与协作：

观察模式：用户作为观察者，监控对话过程并从中获得对主题的深入理解：

# 观察对话过程
conv_turn = costorm_runner.step()
print(f"专家发言: {conv_turn.raw_utterance}")

主动参与模式：用户注入自己的话语来主动引导对话方向：

# 主动引导对话
user_input = "我想了解更多关于量子计算在药物发现中的应用"
costorm_runner.step(user_utterance=user_input)

专家行动规划与执行

每个Co-STORM专家在生成回应时都遵循精细的行动规划流程：

这种机制确保了每个专家回应都是基于最新知识状态和对话上下文的深思熟虑结果。

协同效率优化策略

为了提升人机协作效率，Co-STORM实现了多种优化策略：

信息重用机制：系统会识别和重用之前轮次中未使用的信息片段，避免重复检索：

def _get_sorted_unused_snippets(self, knowledge_base, conversation_history):
    """获取排序后的未使用信息片段"""
    unused_snippets = []
    for conv_turn in reversed(conversation_history[-2:]):
        turn_unused = self._get_conv_turn_unused_information(
            conv_turn=conv_turn, 
            knowledge_base=knowledge_base
        )
        unused_snippets.extend(turn_unused)
    return unused_snippets

语义相似度计算：基于嵌入向量计算信息片段的相关性，确保最相关的信息优先使用：

# 计算查询与信息片段的相似度
query_embedding = self.encoder.encode(conv_turn.queries)
snippet_embeddings = self.encoder.encode(unused_snippets)
similarities = cosine_similarity(snippet_embeddings, query_embedding)

动态专家列表更新：根据对话焦点和背景信息动态调整参与的专家：

def _update_expert_list_from_utterance(self, focus, background_info):
    """根据用户输入更新专家列表"""
    new_experts = self.generate_expert_module(
        topic=self.topic,
        num_experts=2,
        background_info=background_info,
        focus=focus
    )
    self.experts.extend(new_experts)

这种精细的协同机制使得Co-STORM能够实现真正意义上的人机协作知识整理，既充分发挥了LLM的信息处理能力，又保留了人类用户的主动性和创造性。

动态思维导图构建共享概念空间

在Co-STORM人机协作知识整理系统中，动态思维导图（KnowledgeBase）作为核心架构，承担着构建人机共享概念空间的重要使命。这一创新设计不仅实现了信息的结构化组织，更通过智能化的知识导航机制，为人类用户与AI系统之间建立了高效的知识交流桥梁。

知识节点的层级化架构

Co-STORM的知识库采用树状结构组织，每个KnowledgeNode代表一个概念节点，形成层次化的知识体系：

class KnowledgeNode:
    def __init__(self, name: str, content: Optional[str] = None, 
                 parent: Optional["KnowledgeNode"] = None,
                 children: Optional[List["KnowledgeNode"]] = None):
        self.name = name  # 节点名称
        self.content: Set[int] = set(content) if content else set()  # 关联信息索引
        self.children = [] if children is None else children  # 子节点列表
        self.parent = parent  # 父节点引用

这种设计支持无限层级的嵌套结构，允许系统根据话题的复杂度动态调整知识组织方式。每个节点可以包含多个信息片段，并通过父子关系构建完整的知识图谱。

动态信息插入与语义导航

信息插入模块（InformationInsertionModule）采用智能导航算法，确保新信息被放置在语义最相关的节点下：

信息插入过程基于嵌入向量相似度计算，系统会：

1. 计算语义相似度：使用编码器将信息内容转换为向量表示
2. 分层导航：从根节点开始逐层比较，找到最相关的父节点
3. 智能放置：根据语义匹配度决定插入位置或创建新节点
4. 动态扩展：当节点信息量达到阈值时自动触发扩展机制

共享概念空间的构建机制

知识库作为共享概念空间的核心，通过以下机制实现人机协作：

实时同步更新机制

def insert_information(self, information_index: int):
    if information_index not in self.content:
        self.need_regenerate_synthesize_output = True
        self.content.add(information_index)

每次信息插入都会标记需要重新生成合成输出，确保人机双方看到的始终是最新的知识状态。

多维度知识检索 系统支持多种检索方式，方便用户从不同角度探索知识：

检索类型	功能描述	适用场景
层级检索	按树状结构逐层浏览	系统性学习
语义检索	基于内容相似度查找	关联概念发现
关键词检索	精确匹配节点名称	快速定位

思维导图的动态演化过程

Co-STORM的思维导图不是静态结构，而是随着对话进程不断演化的动态实体：

这个演化过程包含四个关键阶段：

1. 初始化阶段：系统通过warm_start()方法建立基础知识框架
2. 积累阶段：对话中收集的信息被智能分类和组织
3. 重组阶段：定期对知识结构进行优化和重组
4. 输出阶段：生成最终的报告或总结

智能节点扩展与内容合成

当某个节点的信息量达到预设阈值时，系统会自动触发扩展机制：

def _expand_node(self, node: KnowledgeNode, knowledge_base: KnowledgeBase):
    """扩展节点内容并生成合成输出"""
    # 收集节点所有内容
    all_content = node.collect_all_content()
    # 使用语言模型生成合成摘要
    synthesized_output = self._generate_synthesis(all_content)
    node.synthesize_output = synthesized_output
    node.need_regenerate_synthesize_output = False

扩展过程不仅增加新的子节点，还会生成高质量的合成内容，为用户提供更深层次的知识洞察。

人机协作的认知对齐

动态思维导图的核心价值在于实现人机认知对齐：

可视化知识结构 系统通过清晰的层级展示，让用户直观理解知识组织方式，降低认知负荷。

实时反馈机制 每次对话回合后，知识库的更新都会立即反映给用户，确保双方保持同步。

个性化导航支持 用户可以根据自己的认知习惯选择不同的浏览方式，系统会自适应调整展示策略。

这种设计使得Co-STORM不仅仅是一个信息处理工具，更是一个真正意义上的认知协作伙伴，通过共享概念空间的建设，实现了人机在知识探索过程中的深度协同。

实时对话与知识注入功能

Co-STORM 的人机协作机制中，实时对话与知识注入功能是整个系统的核心交互环节，它实现了人类用户与AI专家之间的无缝协作。这一功能通过精心设计的对话协议和知识管理机制，让用户能够主动参与知识整理过程，将个人见解和外部信息实时注入到协作对话中。

对话协议与轮次管理

Co-STORM 采用基于回合的对话协议，每个对话轮次都遵循特定的流程：

系统维护一个动态更新的对话历史记录，每个对话轮次都包含角色标识、话语内容和时间戳信息。这种结构化的对话管理确保了上下文的一致性和连贯性。

知识注入机制

用户可以通过 step() 方法注入任意话语到对话流程中：

# 用户主动注入知识到对话中
user_utterance = "根据最新研究，量子计算在药物发现领域的应用正在加速发展"
conv_turn = costorm_runner.step(user_utterance=user_utterance)

# 或者观察AI专家之间的对话
conv_turn = costorm_runner.step()

知识注入模块 (InformationInsertionModule) 负责处理用户提供的信息，并将其智能地整合到知识库的适当位置。该模块使用分层导航算法来确定信息的最佳放置位置：

class InsertInformationModule(dspy.Module):
    def __init__(self, engine, encoder):
        self.engine = engine
        self.encoder = encoder
        self.insert_info = dspy.ChainOfThought(InsertInformation)
        
    def layer_by_layer_navigation_placement(self, knowledge_base, question, query):
        # 从根节点开始逐层导航
        current_node = knowledge_base.root
        while True:
            # 获取导航决策
            action_type, node_name = self._get_navigation_choice(
                current_node, question, query
            )
            
            if action_type == "insert":
                return current_node.get_path_from_root()
            elif action_type == "step":
                current_node = current_node.get_child(node_name)
            elif action_type == "create":
                new_node = current_node.create_child(node_name)
                return new_node.get_path_from_root()

智能知识放置策略

系统采用多种策略来确定用户注入知识的最佳位置：

1. 基于嵌入相似度的排名：使用余弦相似度计算查询与知识节点之间的语义相似度
2. 分层导航决策：通过LLM引导的决策过程在知识树中导航
3. 候选选择机制：从多个候选位置中选择最合适的放置点

def choose_candidate_from_embedding_ranking(self, question, query, encoded_outlines, outlines):
    # 编码查询意图
    encoded_query = self.encoder.encode(f"{question}, {query}")
    
    # 计算相似度并排序
    similarities = cosine_similarity([encoded_query], encoded_outlines)[0]
    sorted_indices = np.argsort(similarities)[::-1]
    
    # 选择top N候选
    top_candidates = [outlines[i] for i in sorted_indices[:5]]
    return self._select_best_candidate(question, query, top_candidates)

实时对话上下文管理

Co-STORM 维护一个丰富的对话上下文，包括：

上下文要素	描述	作用
对话历史	完整的对话轮次记录	保持对话连贯性
知识库状态	当前知识树的结构和内容	指导知识放置
用户意图	用户查询的问题和背景	理解用户需求
未使用信息	之前检索但未引用的信息片段	避免重复工作

多线程知识处理

为了高效处理大量信息注入，系统采用多线程处理机制：

def forward(self, knowledge_base, information, max_thread=5):
    # 创建意图到放置位置的映射
    intent_to_placement_dict = self._info_list_to_intent_mapping(information)
    
    # 使用线程池并行处理
    with ThreadPoolExecutor(max_workers=max_thread) as executor:
        futures = {
            executor.submit(self.process_intent, question, query): (question, query)
            for question, query in intent_to_placement_dict
        }
        
        # 收集处理结果
        for future in as_completed(futures):
            intent, placement = future.result()
            intent_to_placement_dict[intent] = placement

错误处理与恢复机制

系统包含完善的错误处理机制，确保对话流程的稳定性：

def process_intent(self, question, query):
    try:
        # 尝试基于嵌入的候选选择
        candidate_placement = self.choose_candidate_from_embedding_ranking(
            question, query, encoded_outlines, outlines
        )
        
        if candidate_placement is None:
            # 回退到分层导航
            candidate_placement = self.layer_by_layer_navigation_placement(
                knowledge_base, question, query
            )
            
        return candidate_placement
        
    except Exception as e:
        # 记录错误并返回默认位置
        print(f"Error processing intent: {e}")
        return knowledge_base.root.get_path_from_root()

对话状态可视化

系统提供对话状态的实时可视化，帮助用户理解当前的协作进度：

这种实时对话与知识注入功能使得 Co-STORM 不仅仅是一个被动的信息整理工具，而是一个真正的人机协作平台。用户可以通过注入专业知识、提出深入问题或提供新的信息源来主动引导对话方向，而系统则负责将这些输入智能地整合到不断演进的知识结构中。

通过这种协作模式，Co-STORM 能够产生更加全面、准确且符合用户特定需求的知识报告，同时保持了对话的自然流畅性和上下文连贯性。

总结

Co-STORM通过其实时对话与知识注入功能，建立了一个高效的人机协作知识整理平台。该系统不仅能够智能处理用户注入的信息，还能通过多线程知识处理和错误恢复机制确保对话流程的稳定性。通过对话状态可视化和丰富的上下文管理，Co-STORM实现了真正意义上的人机协同知识探索，能够产生更加全面、准确且符合用户特定需求的知识报告，为人机协作的知识整理设立了新的标准。

【免费下载链接】storm An LLM-powered knowledge curation system that researches a topic and generates a full-length report with citations. 项目地址: https://gitcode.com/GitHub_Trending/sto/storm