多 Agent 协作模式：Supervisor、Hierarchical、Debate 与 Voting

from langgraph.graph import StateGraph, END

# 定义 worker
def researcher(state):
    """研究子任务"""
    result = llm.invoke(f"研究: {state['current_task']}")
    return {"research": result}

def writer(state):
    """写作子任务"""
    result = llm.invoke(f"基于研究写作: {state['research']}")
    return {"draft": result}

def reviewer(state):
    """审稿子任务"""
    result = llm.invoke(f"审稿并提出修改: {state['draft']}")
    return {"feedback": result}

# 定义 supervisor 决策
def supervisor_decision(state):
    """决定下一步调用哪个 worker"""
    decision = llm.invoke(f"""
    当前状态: {state}
    下一步应该调用哪个 agent？可选: researcher / writer / reviewer / FINISH
    只回复 agent 名称，不要解释。
    """)
    return decision.strip()

# 构建 graph
workflow = StateGraph(State)

workflow.add_node("supervisor", supervisor_node)
workflow.add_node("researcher", researcher)
workflow.add_node("writer", writer)
workflow.add_node("reviewer", reviewer)

# supervisor 决定下一步
workflow.add_conditional_edges(
    "supervisor",
    supervisor_decision,
    {
        "researcher": "researcher",
        "writer": "writer",
        "reviewer": "reviewer",
        "FINISH": END
    }
)

# workers 完成后回到 supervisor
workflow.add_edge("researcher", "supervisor")
workflow.add_edge("writer", "supervisor")
workflow.add_edge("reviewer", "supervisor")

workflow.set_entry_point("supervisor")
app = workflow.compile()

class ResearchSystem:
    def __init__(self):
        self.root_supervisor = SupervisorAgent(
            name="root",
            tools=[
                "delegate_to_research_team",
                "delegate_to_writing_team",
                "search_web"
            ]
        )
        
        # 每个 sub-team 有自己的 supervisor
        self.research_team = SupervisorAgent(
            name="research_lead",
            workers=[
                "paper_reader",
                "web_researcher",
                "data_analyst"
            ]
        )
        
        self.writing_team = SupervisorAgent(
            name="writing_lead",
            workers=[
                "outline_writer",
                "section_writer",
                "editor"
            ]
        )

class DebateSystem:
    def __init__(self, n_agents=3, n_rounds=2):
        self.n_agents = n_agents
        self.n_rounds = n_rounds
        self.agents = [
            DebateAgent(role=role, perspective=perspective)
            for role, perspective in [
                ("bull", "支持这个方案"),
                ("bear", "反对这个方案"),
                ("neutral", "分析利弊")
            ]
        ]
        self.judge = JudgeAgent()
    
    def run(self, question: str) -> str:
        # Round 1: 各方表态
        positions = {}
        for agent in self.agents:
            positions[agent.name] = agent.initial_position(question)
        
        # Round 2+: 互相反驳
        for round_num in range(1, self.n_rounds):
            new_positions = {}
            for agent in self.agents:
                # 每个 agent 看到其他人的观点
                other_positions = {
                    name: pos for name, pos in positions.items()
                    if name != agent.name
                }
                new_positions[agent.name] = agent.rebut(
                    question=question,
                    my_position=positions[agent.name],
                    other_positions=other_positions,
                    round_num=round_num
                )
            positions = new_positions
        
        # Judge 综合
        return self.judge.synthesize(question, positions)

class VotingSystem:
    def __init__(self, n_agents=5):
        self.n_agents = n_agents
    
    def run(self, problem: str) -> dict:
        # 1. 多个 agent 独立求解（并行！）
        solutions = []
        for i in range(self.n_agents):
            sol = self.independent_solve(problem, agent_id=i)
            solutions.append(sol)
        
        # 2. 投票（多数决 / 加权 / 置信度）
        final = self.vote(solutions)
        
        return {
            "answer": final["answer"],
            "confidence": final["confidence"],
            "votes": [s["answer"] for s in solutions]
        }
    
    def vote(self, solutions):
        # 简单多数
        from collections import Counter
        answers = [s["answer"] for s in solutions]
        counts = Counter(answers)
        winner, count = counts.most_common(1)[0]
        confidence = count / len(solutions)
        
        # 如果多数票信心不足，调用更贵但更强的模型仲裁
        if confidence < 0.6:
            arbiter = self.arbitrate(solutions)
            return arbiter
        
        return {"answer": winner, "confidence": confidence}

def self_consistency(problem, n=5):
    """Self-Consistency: 同一 prompt 多采样"""
    answers = []
    for _ in range(n):
        response = llm.invoke(problem, temperature=0.7)  # 高温保证多样性
        answer = extract_final_answer(response)
        answers.append(answer)
    
    # 多数决
    from collections import Counter
    final, count = Counter(answers).most_common(1)[0]
    confidence = count / n
    
    return final, confidence

class InvestmentAnalystSystem:
    """混合架构：supervisor + debate + voting"""
    
    def __init__(self):
        self.supervisor = SupervisorAgent(tools=["delegate_research", "delegate_debate"])
        
        # 研究阶段：supervisor 调度多个 worker
        self.research_workers = [
            FinancialWorker(),
            TechnicalWorker(),
            SentimentWorker()
        ]
        
        # 辩论阶段：bull vs bear
        self.debate_agents = [
            BullAgent(),
            BearAgent(),
            NeutralAgent()
        ]
        
        # 投票阶段：多个 Judge agent 投票
        self.judges = [JudgeAgent(seed=i) for i in range(3)]
    
    def analyze(self, stock: str) -> dict:
        # Stage 1: Supervisor 调度研究
            research_results = self.run_research(stock)
            
            # Stage 2: Debate 阶段
            debate_outcome = self.run_debate(stock, research_results)
            
            # Stage 3: Voting 决定评级
            final_rating = self.run_voting(stock, debate_outcome)
            
            return final_rating

frameworks = {
    "LangGraph": {
        "核心模型": "图（Graph）",
        "擅长": "复杂 control flow、人在回路、状态管理",
        "代表项目": "LangChain 生态",
        "学习曲线": "中等"
    },
    "CrewAI": {
        "核心模型": "角色 (Role) + 任务 (Task)",
        "擅长": "角色扮演类协作、易上手",
        "代表项目": "团队式 workflow",
        "学习曲线": "低"
    },
    "AutoGen": {
        "核心模型": "对话 (Conversation)",
        "擅长": "对话驱动协作、研究类任务",
        "代表项目": "Microsoft 学术研究",
        "学习曲线": "中等"
    },
    "OpenAI Swarm": {
        "核心模型": "Handoff（移交）",
        "擅长": "轻量级 agent 切换",
        "代表项目": "客服、路由类任务",
        "学习曲线": "极低"
    },
    "Anthropic SDK": {
        "核心模型": "Sub-agents",
        "擅长": "Claude 生态、parallel tool use",
        "代表项目": "Claude 深度用户",
        "学习曲线": "中等"
    }
}