基于Council框架构建多智能体代码审查系统实战指南

在实际的 AI 应用开发中，我们常常面临一个困境：单一的大型语言模型（LLM）虽然能力强大，但在特定任务上可能表现不稳定，或者其知识、推理风格存在局限性。例如，一个模型可能擅长创意写作，但在逻辑推理上稍逊一筹；另一个模型可能精通代码生成，但对话风格过于生硬。如何整合多个模型的优势，构建一个更稳定、更智能的“集体智慧”系统，是提升应用质量的关键。 council-of-high-intelligence 项目正是为解决这一问题而生，它提供了一个框架，允许开发者像组建一个“高智能委员会”一样，协调多个 LLM 或 AI 代理协同工作，通过投票、辩论、链式调用等机制，得出比单一模型更优的决策或输出。

本文将带你从零开始，深入理解 council-of-high-intelligence 的核心概念，并完成一个完整的实战项目：构建一个“代码审查委员会”。这个委员会将由三个不同特长的 AI 代理组成：一个负责代码风格检查，一个负责安全漏洞扫描，一个负责逻辑合理性评估。最终，我们将整合三个代理的意见，生成一份综合性的代码审查报告。通过这个案例，你将掌握如何利用该框架设计多智能体协作流程，处理不同模型（如 GPT、Claude、本地模型）的集成，以及如何将抽象的“委员会”概念落地为可运行的应用程序。

1. 理解 Council-of-High-Intelligence 的核心机制

在开始编码之前，必须理解框架的几个核心抽象，这决定了你如何设计智能体之间的协作关系。

1.1 核心组件：Agent、Skill、Chain 与 Council

council-of-high-intelligence 框架的架构围绕几个关键组件构建，理解它们的关系是成功使用的第一步。

• Agent（代理） ：这是框架中的基本执行单元。一个 Agent 封装了执行特定任务的能力。它通常由一个 LLM（大语言模型） 和一组 Skill（技能） 组成。你可以将 Agent 视为一个具有特定角色和专长的“委员会成员”，例如“代码安全专家”或“文档撰写员”。
• Skill（技能） ：Skill 定义了 Agent 能够执行的具体操作。它可以是简单的提示词工程（Prompt Engineering），调用一个外部 API，执行一段 Python 函数，或者查询一个数据库。一个 Agent 可以拥有多个 Skill，并根据上下文选择使用哪一个。
• Chain（链） ：Chain 用于描述一个线性的、顺序执行的工作流。它由多个 Controller 组成。Controller 负责在链的每个步骤中，根据当前状态和上下文，选择调用哪个 Agent 来执行任务。Chain 使得构建“先做 A，再做 B，最后做 C”的复杂流程变得简单。
• Council（委员会） ：这是框架的灵魂。一个 Council 由多个 Chain 组成。Council 的核心职责是 整合 所有 Chain 的执行结果。它通过内置的 Evaluator（评估器） 模块，对所有 Chain 的输出进行比较、评估、投票或排序，最终选出一个最优结果，或者综合所有结果生成一个新的输出。这模拟了委员会通过讨论或投票达成决议的过程。

它们之间的关系可以概括为： Council 协调多个 Chain，每个 Chain 通过 Controller 调度多个 Agent，每个 Agent 利用其 Skill 和 LLM 完成具体任务。 这种分层结构提供了极大的灵活性。

1.2 工作流程：从问题输入到集体决策

一个典型的 council-of-high-intelligence 应用工作流程如下：

1. 输入 ：用户提交一个查询或任务（例如，“审查这段 Python 代码”）。
2. Chain 执行 ：查询被发送到 Council 内的所有 Chain。每个 Chain 独立地、按顺序执行其内部的步骤（调用不同的 Agent）。
3. Agent 工作 ：在每个 Chain 的步骤中，Controller 根据上下文选择合适的 Agent。Agent 调用其 LLM 和 Skill 处理任务，并产生一个响应。
4. 结果汇总 ：每个 Chain 最终都会产生一个输出结果。所有这些结果被提交给 Council。
5. 评估与决策 ：Council 的 Evaluator 开始工作。它可能采用多种策略：
   • 投票 ：让一个特定的“裁判”Agent 对所有结果进行投票，选出最佳。
   • 评分 ：为每个结果打分，选择最高分。
   • 合成 ：将多个结果作为输入，让另一个“合成”Agent 生成一个综合性的最终答案。
6. 输出 ：Council 输出评估后的最终结果。

这种机制的优势在于，即使某个 Chain（或背后的某个模型）产生了有偏差或错误的结果，其他 Chain 的结果可以作为制衡，最终由评估机制选出更可靠或更全面的答案。

2. 环境准备与项目初始化

我们将构建一个名为 code-review-council 的项目。为了清晰管理依赖和项目结构，推荐使用虚拟环境。

2.1 创建项目目录与虚拟环境

首先，创建项目目录并进入。

mkdir code-review-council
cd code-review-council

接下来，创建一个 Python 虚拟环境来隔离项目依赖。这里使用 venv 。

# 在项目根目录下创建虚拟环境
python -m venv venv

# 激活虚拟环境
# 在 Windows 上：
venv\Scripts\activate
# 在 macOS/Linux 上：
source venv/bin/activate

激活后，你的命令行提示符前通常会显示 (venv) ，表示已进入虚拟环境。

2.2 安装核心依赖

council-of-high-intelligence 是核心框架。此外，我们还需要 openai 库来调用 GPT 模型，以及 python-dotenv 来管理环境变量（如 API 密钥）。

pip install council-ai openai python-dotenv

安装完成后，可以通过以下命令验证版本：

pip list | grep council
pip list | grep openai

2.3 项目结构设计

一个清晰的项目结构有助于管理代码、配置和技能模块。

code-review-council/
├── .env                    # 环境变量文件（API密钥等）
├── .gitignore             # Git忽略文件
├── requirements.txt       # 项目依赖清单
├── main.py                # 应用主入口
├── agents/                # 存放自定义Agent定义
│   ├── __init__.py
│   ├── style_agent.py
│   ├── security_agent.py
│   └── logic_agent.py
├── skills/                # 存放自定义Skill定义
│   ├── __init__.py
│   └── code_analysis.py
├── chains/                # 存放Chain定义
│   ├── __init__.py
│   └── review_chain.py
├── councils/              # 存放Council定义
│   ├── __init__.py
│   └── code_review_council.py
└── utils/                 # 工具函数
    ├── __init__.py
    └── prompts.py         # 存放提示词模板

现在，创建这些目录和文件：

mkdir agents skills chains councils utils
touch .env .gitignore requirements.txt main.py
touch agents/__init__.py agents/style_agent.py agents/security_agent.py agents/logic_agent.py
touch skills/__init__.py skills/code_analysis.py
touch chains/__init__.py chains/review_chain.py
touch councils/__init__.py councils/code_review_council.py
touch utils/__init__.py utils/prompts.py

2.4 配置环境变量

在 .env 文件中，添加你的 OpenAI API 密钥。 切记不要将此文件提交到版本控制系统 。

# .env
OPENAI_API_KEY=sk-your-actual-openai-api-key-here

在 .gitignore 文件中，确保包含以下内容：

# .gitignore
venv/
__pycache__/
*.pyc
.env
.DS_Store

将依赖写入 requirements.txt 文件，方便他人复现环境。

# requirements.txt
council-ai>=0.1.0
openai>=1.0.0
python-dotenv>=1.0.0

3. 构建代码审查委员会：从 Skill 到 Council

我们将按照自底向上的顺序构建系统：先定义 Skill，再创建使用这些 Skill 的 Agent，然后用 Chain 组织 Agent，最后用 Council 整合 Chain。

3.1 定义核心 Skill：代码分析

所有 Agent 都需要与 LLM 交互来分析代码。我们将创建一个通用的 CodeAnalysisSkill ，它接收一段代码和一个特定的分析指令（如“检查代码风格”），然后调用 LLM 并返回分析结果。

编辑 skills/code_analysis.py ：

# skills/code_analysis.py
import os
from typing import List
from council.contexts import SkillContext, ChatMessage
from council.skills import SkillBase
from council.llm import LLMBase, LLMMessage
from council.llm.openai_llm import OpenAILLM
from dotenv import load_dotenv

# 加载环境变量
load_dotenv()

class CodeAnalysisSkill(SkillBase):
    """一个通用的代码分析技能，根据给定的指令分析代码。"""

    def __init__(self, llm: LLMBase, analysis_instruction: str):
        """
        初始化技能。
        Args:
            llm: 用于分析的LLM实例。
            analysis_instruction: 具体的分析指令，例如“请检查代码风格是否符合PEP8”。
        """
        super().__init__(f"CodeAnalysisSkill_{analysis_instruction[:20]}")
        self._llm = llm
        self._instruction = analysis_instruction

    def execute(self, context: SkillContext) -> List[ChatMessage]:
        """
        执行技能：将代码和分析指令组合成提示，调用LLM，返回结果。
        """
        # 从上下文中获取最新的用户消息，其中应包含待分析的代码
        latest_message = context.current.messages[-1]
        code_to_review = latest_message.message

        # 构建系统提示词
        system_prompt = f"""你是一个资深的代码审查专家。你的任务是：{self._instruction}
        请只针对代码本身进行分析，输出清晰、有条理的审查意见。如果发现问题，请指出具体位置和原因，并给出修改建议。如果未发现问题，请说明“未发现相关问题”。
        """

        # 构建用户消息
        user_message = f"""请分析以下代码：
        ```
        {code_to_review}
        ```
        """

        # 调用LLM
        llm_messages = [
            LLMMessage.system_message(system_prompt),
            LLMMessage.user_message(user_message)
        ]
        response = self._llm.completion(llm_messages)

        # 将LLM响应封装成Council的ChatMessage返回
        return [ChatMessage.agent(response.completion)]

关键解释 ：

1. SkillBase 是所有自定义 Skill 的基类，必须实现 execute 方法。
2. context.current.messages[-1] 获取了工作流中上一步传来的消息，我们约定其中包含待审查的代码。
3. 我们通过 analysis_instruction 参数使这个 Skill 变得通用，不同的 Agent 可以传入不同的指令来复用此 Skill。
4. LLMMessage 用于构建符合 OpenAI 格式的消息（系统消息、用户消息）。 OpenAILLM 是框架对 OpenAI API 的封装。

3.2 创建三位专家 Agent

现在，我们创建三位拥有不同专长的 Agent。它们将共用同一个 LLM 实例，但使用不同的 analysis_instruction 。

首先，在 utils/prompts.py 中定义一些常量，用于存放给不同 Agent 的指令。

# utils/prompts.py

STYLE_AGENT_INSTRUCTION = """
请严格检查代码风格，重点包括但不限于：
1. 命名规范（变量、函数、类名是否符合蛇形命名法或驼峰命名法）。
2. 缩进和空格（是否使用4个空格缩进，操作符两侧是否有空格）。
3. 行长度（是否超过79/99字符）。
4. 导入顺序（是否标准库、第三方库、本地库分开）。
5. 文档字符串（函数和类是否有docstring）。
请参照PEP8规范给出具体建议。
"""

SECURITY_AGENT_INSTRUCTION = """
请检查代码中可能存在的安全漏洞，重点包括但不限于：
1. 硬编码的敏感信息（如密码、API密钥）。
2. SQL注入风险（是否使用字符串拼接构造SQL）。
3. 命令注入风险（是否使用`os.system`或`subprocess`执行未经验证的用户输入）。
4. 反序列化风险（是否使用`pickle`加载不可信数据）。
5. 路径遍历风险（用户输入是否未经验证直接用于文件路径）。
请指出具体风险代码行和缓解方案。
"""

LOGIC_AGENT_INSTRUCTION = """
请检查代码的逻辑合理性和潜在缺陷，重点包括但不限于：
1. 边界条件处理（循环、数组访问的边界是否安全）。
2. 错误处理（是否有必要的try-except，异常是否被妥善处理）。
3. 资源管理（文件、网络连接是否被正确关闭）。
4. 算法效率（是否存在明显的性能瓶颈，如嵌套循环）。
5. 代码清晰度（逻辑是否清晰，是否有过于复杂的表达式）。
请从健壮性和可维护性角度给出建议。

接下来，创建第一个 Agent：代码风格专家。编辑 agents/style_agent.py 。

# agents/style_agent.py
from council.agents import Agent
from council.skills import SkillBase
from council.llm import OpenAILLM
import os
from skills.code_analysis import CodeAnalysisSkill
from utils.prompts import STYLE_AGENT_INSTRUCTION

def build_style_agent() -> Agent:
    """构建并返回代码风格审查Agent。"""
    # 初始化LLM。这里使用gpt-3.5-turbo，你也可以根据需求更换模型。
    llm = OpenAILLM(api_key=os.getenv("OPENAI_API_KEY"), model="gpt-3.5-turbo")

    # 创建专用于风格审查的Skill
    style_skill: SkillBase = CodeAnalysisSkill(llm, STYLE_AGENT_INSTRUCTION)

    # 创建一个Agent，它只拥有这一个Skill，并赋予其名称和描述。
    agent = Agent(
        name="StyleReviewer",
        description="专注于检查代码风格和PEP8合规性的专家。",
        skills=[style_skill]
    )
    return agent

同理，创建安全专家 Agent ( agents/security_agent.py ) 和逻辑专家 Agent ( agents/logic_agent.py )。代码结构类似，只需导入不同的指令常量并修改 Agent 的名称和描述。

# agents/security_agent.py
from council.agents import Agent
from council.llm import OpenAILLM
import os
from skills.code_analysis import CodeAnalysisSkill
from utils.prompts import SECURITY_AGENT_INSTRUCTION

def build_security_agent() -> Agent:
    llm = OpenAILLM(api_key=os.getenv("OPENAI_API_KEY"), model="gpt-3.5-turbo")
    security_skill = CodeAnalysisSkill(llm, SECURITY_AGENT_INSTRUCTION)
    agent = Agent(
        name="SecurityReviewer",
        description="专注于识别代码安全漏洞的专家。",
        skills=[security_skill]
    )
    return agent

# agents/logic_agent.py
from council.agents import Agent
from council.llm import OpenAILLM
import os
from skills.code_analysis import CodeAnalysisSkill
from utils.prompts import LOGIC_AGENT_INSTRUCTION

def build_logic_agent() -> Agent:
    llm = OpenAILLM(api_key=os.getenv("OPENAI_API_KEY"), model="gpt-3.5-turbo")
    logic_skill = CodeAnalysisSkill(llm, LOGIC_AGENT_INSTRUCTION)
    agent = Agent(
        name="LogicReviewer",
        description="专注于分析代码逻辑合理性和健壮性的专家。",
        skills=[logic_skill]
    )
    return agent

3.3 构建审查 Chain：串联还是并联？

在我们的场景中，三位专家的工作是并行的，他们可以同时审查同一份代码。因此，我们不需要复杂的顺序 Chain，而是需要一种方式让三个 Agent 同时工作。在 council-of-high-intelligence 中，这可以通过创建一个包含多个 Agent 的简单 Chain 来实现，并使用一个 Controller 来（在理论上）选择调用哪个 Agent。但对于纯粹的并行执行，更常见的做法是直接在 Council 中配置多个 Chain，每个 Chain 只包含一个 Agent，然后让 Council 的评估器来汇总结果。

我们将采用后一种更清晰的方式。首先，创建一个“包装”Chain，它内部只包含一个 Agent。编辑 chains/review_chain.py 。

# chains/review_chain.py
from council.chains import Chain
from council.controllers import BasicController
from council.agents import Agent

def build_single_agent_chain(agent: Agent, chain_name: str) -> Chain:
    """
    将一个Agent包装成一个独立的Chain。
    Args:
        agent: 要包装的Agent。
        chain_name: Chain的名称。
    Returns:
        一个只包含该Agent的Chain。
    """
    # BasicController 是一个简单的控制器，它总是选择执行给定的Agent。
    # 这里我们将Agent列表传入，但实际上这个Chain只会有这一个Agent。
    controller = BasicController(agents=[agent])
    # 创建Chain，需要控制器和Agent列表（虽然控制器里已经有了，这里再传一次是框架设计）
    chain = Chain(
        name=chain_name,
        description=f"Chain for {agent.name}",
        controller=controller,
        agents=[agent]
    )
    return chain

这个函数的作用是将一个独立的 Agent “提升”为一个 Chain，这样它就可以被加入到 Council 中，与其他 Chain（即其他 Agent）并行执行。

3.4 组建高智能委员会并定义评估策略

现在是核心环节：创建 Council，并定义它如何整合三位专家的意见。我们将使用 BasicEvaluator ，它需要一个“裁判”Agent 来对各个 Chain 的结果进行评估和选择。我们将创建一个“首席审查员”Agent 来担任裁判。

首先，创建裁判 Agent。我们可以在 councils/code_review_council.py 中内联定义它。

# councils/code_review_council.py
from council.councils import Council
from council.chains import Chain
from council.evaluators import BasicEvaluator
from council.agents import Agent
from council.llm import OpenAILLM, LLMMessage
import os
from dotenv import load_dotenv

load_dotenv()

def build_code_review_council(style_chain: Chain, security_chain: Chain, logic_chain: Chain) -> Council:
    """构建并返回代码审查委员会。"""

    # 1. 创建“首席审查员”Agent，用于评估和综合各专家的意见
    llm = OpenAILLM(api_key=os.getenv("OPENAI_API_KEY"), model="gpt-4") # 可以使用更强的模型作为裁判
    chief_evaluator = Agent(
        name="ChiefReviewer",
        description="综合各位专家意见，生成最终审查报告的首席审查员。",
        skills=[], # 这个Agent的技能将由Evaluator在内部调用LLM实现
        llm=llm
    )

    # 2. 创建评估器，并指定使用 chief_evaluator 作为裁判
    # BasicEvaluator 会要求裁判Agent根据一个指令来评估所有Chain的输出。
    evaluator = BasicEvaluator(agent=chief_evaluator)

    # 3. 定义给裁判Agent的评估指令
    evaluation_instruction = """
    你是一位首席技术官，需要综合三位代码审查专家的意见，生成一份最终的统一审查报告。
    以下是三位专家的独立审查意见：
    {responses}

    你的任务：
    1. 梳理并总结所有意见，去除重复项。
    2. 如果不同专家对同一问题有不同看法，请基于最佳实践进行裁决。
    3. 将问题按严重性排序（例如：安全漏洞 > 逻辑错误 > 风格问题）。
    4. 输出一份结构清晰、可直接交付给开发者的最终审查报告。报告格式应包括：概述、详细问题列表（含代码行引用和建议）、总结。
    请直接输出最终报告，不要添加“作为首席审查员”之类的开场白。
    """
    # 将指令设置给评估器
    evaluator.set_evaluation_instruction(evaluation_instruction)

    # 4. 创建Council，传入所有Chain和评估器
    council = Council(
        name="CodeReviewCouncil",
        description="一个由风格、安全、逻辑专家组成的代码审查委员会。",
        chains=[style_chain, security_chain, logic_chain],
        evaluator=evaluator
    )
    return council

关键解释 ：

1. BasicEvaluator 是框架提供的简单评估器。它的工作流程是：收集所有 Chain 的输出，将这些输出和 evaluation_instruction 一起构造成提示词，发送给 chief_evaluator 这个裁判 Agent。
2. 裁判 Agent ( chief_evaluator ) 本身没有定义 Skill，它的能力来自于其绑定的 LLM（这里用了 GPT-4）。评估器会直接使用这个 LLM 来完成评估任务。
3. {responses} 是一个占位符，在运行时会被替换为所有 Chain 的实际输出。
4. 最终，Council 的 execute 方法会返回裁判 Agent 生成的综合报告。

4. 组装与运行：完成端到端流程

现在，我们将所有部件组装起来，并编写主程序 main.py 。

# main.py
import os
from dotenv import load_dotenv
from council.contexts import ChatMessage, AgentContext, ScoredChatMessage
from council.runners import ParallelRunner

# 导入我们定义的构建函数
from agents.style_agent import build_style_agent
from agents.security_agent import build_security_agent
from agents.logic_agent import build_logic_agent
from chains.review_chain import build_single_agent_chain
from councils.code_review_council import build_code_review_council

def main():
    # 加载环境变量
    load_dotenv()
    if not os.getenv("OPENAI_API_KEY"):
        print("错误：请在 .env 文件中设置 OPENAI_API_KEY")
        return

    # 1. 构建三位专家Agent
    print("正在初始化专家Agent...")
    style_agent = build_style_agent()
    security_agent = build_security_agent()
    logic_agent = build_logic_agent()

    # 2. 将每个Agent包装成独立的Chain
    style_chain = build_single_agent_chain(style_agent, "StyleReviewChain")
    security_chain = build_single_agent_chain(security_agent, "SecurityReviewChain")
    logic_chain = build_single_agent_chain(logic_agent, "LogicReviewChain")

    # 3. 使用三个Chain构建委员会
    print("正在组建代码审查委员会...")
    council = build_code_review_council(style_chain, security_chain, logic_chain)

    # 4. 准备待审查的代码
    code_to_review = """
def process_user_input(user_id, input_data):
    import sqlite3
    conn = sqlite3.connect('my_database.db')
    cursor = conn.cursor()
    # 潜在的安全风险：直接拼接用户输入
    query = f"SELECT * FROM users WHERE id = {user_id} AND data = '{input_data}'"
    cursor.execute(query)
    result = cursor.fetchall()
    conn.close()
    return result

def calculate_price(quantity, price):
    total = quantity * price
    # 逻辑问题：未处理除零错误
    discount = 10 / (quantity - 5)
    return total - discount
    """
    print("待审查的代码：")
    print(code_to_review)
    print("\n" + "="*50 + "\n")

    # 5. 执行委员会审查
    print("委员会开始审议...")
    # 创建初始消息上下文
    initial_message = ChatMessage.user(code_to_review)
    context = AgentContext(initial_message)

    # 使用ParallelRunner并行执行Council中的所有Chain
    result = ParallelRunner(council).run(context)

    # 6. 输出结果
    print("="*50)
    print("【最终审查报告】")
    print("="*50)
    # result.messages 包含了所有消息，最后一条是评估器（首席审查员）的综合输出
    if result.messages:
        final_message = result.messages[-1]
        # 检查消息类型并打印
        if isinstance(final_message, ScoredChatMessage):
            print(f"评分: {final_message.score}\n")
            print(final_message.message)
        else:
            print(final_message.message)
    else:
        print("未生成报告。")

    print("\n" + "="*50)
    print("审查完成。")

if __name__ == "__main__":
    main()

5. 运行验证与结果分析

在项目根目录下，确保虚拟环境已激活且 .env 文件配置正确，然后运行主程序。

python main.py

5.1 预期输出结构

程序运行后，你会在控制台看到类似以下的输出（具体内容因模型生成而异）：

正在初始化专家Agent...
正在组建代码审查委员会...
待审查的代码：
[此处显示你提供的代码]

==================================================

委员会开始审议...
==================================================
【最终审查报告】
==================================================
# 代码审查最终报告

## 概述
综合风格、安全、逻辑三位专家的意见，本次审查共发现**2个高危安全问题**，**1个逻辑缺陷**，以及**若干风格问题**。

## 详细问题列表

### 1. 高危安全漏洞 - SQL注入
- **位置**: `process_user_input` 函数，第6行
- **代码**: `query = f\"SELECT * FROM users WHERE id = {user_id} AND data = '{input_data}'\"`
- **问题**: 直接使用字符串格式化（f-string）将用户输入（`user_id`, `input_data`）拼接进SQL语句，攻击者可通过构造恶意输入执行任意SQL命令。
- **建议**: 使用参数化查询。修改为 `cursor.execute(\"SELECT * FROM users WHERE id = ? AND data = ?\", (user_id, input_data))`。

### 2. 高危安全漏洞 - 硬编码数据库路径
- **位置**: `process_user_input` 函数，第3行
- **代码**: `conn = sqlite3.connect('my_database.db')`
- **问题**: 数据库路径硬编码在代码中，不利于部署和配置管理。
- **建议**: 将数据库路径作为配置项（如环境变量）传入。

### 3. 逻辑缺陷 - 潜在的除零错误
- **位置**: `calculate_price` 函数，第5行
- **代码**: `discount = 10 / (quantity - 5)`
- **问题**: 当 `quantity` 等于5时，分母为零，将引发 `ZeroDivisionError`。
- **建议**: 在计算前检查 `quantity` 的值，或使用 `try-except` 捕获异常。

### 4. 代码风格问题
- **导入位置不当**: `import sqlite3` 应放在文件顶部，而非函数内部。
- **函数命名**: `process_user_input` 和 `calculate_price` 符合蛇形命名法，良好。
- **变量命名**: `conn`, `cursor`, `query` 等命名清晰。

## 总结
请优先修复SQL注入和除零错误这两个可能导致系统崩溃或数据泄露的关键问题。建议将数据库连接信息配置化，并将模块导入语句移至文件开头。

==================================================
审查完成。

5.2 结果分析

1. 并行执行 ：虽然控制台输出是线性的，但框架内部通过 ParallelRunner 实现了三个专家 Chain 的并行执行，提高了审查效率。
2. 综合决策 ：报告并非简单拼接三个专家的输出。首席审查员（GPT-4）理解了各专家的关注点，对问题进行了去重、排序和综合表述。
3. 问题分级 ：报告按照“安全漏洞 > 逻辑错误 > 风格问题”的优先级进行了排序，这得益于我们给评估器的清晰指令。
4. 可操作性 ：报告指出了具体的代码行，并给出了修改建议，具备直接指导开发的价值。

6. 常见问题排查

在实际运行中，你可能会遇到以下问题。

6.1 API 密钥与网络问题

6.2 框架执行与输出问题

6.3 提示词与模型响应问题

7. 最佳实践与扩展方向

7.1 生产环境部署建议

1. 配置管理 ：将 API 密钥、模型名称、超时时间等配置项全部外置到配置文件（如 config.yaml ）或环境变量中，避免硬编码。
2. 错误处理与重试 ：在 main.py 的 try-except 块中包裹 council.run() ，对网络超时、API 限流等错误进行捕获、日志记录和指数退避重试。
3. 日志记录 ：集成 logging 模块，记录每个 Agent 的调用开始/结束时间、输入 Token 数、输出 Token 数以及关键输出片段，便于监控和计费分析。
4. 性能优化 ：
   • 缓存 ：对于相同的代码片段，可以考虑将审查结果缓存一段时间，避免重复调用昂贵的 LLM API。
   • 模型选型 ：根据任务难度选择合适的模型。例如，专家 Agent 可以使用 gpt-3.5-turbo 以降低成本，而首席审查员使用 gpt-4 以保证综合质量。
5. 异步处理 ：对于大量代码审查任务，应使用异步框架（如 asyncio ）来并发执行多个 Council 任务，充分利用并行能力。

7.2 扩展项目功能

1. 支持更多模型 ：框架不仅支持 OpenAI。你可以集成 Anthropic Claude、Google Gemini 或本地部署的 Llama、Qwen 等模型。需要实现对应的 LLMBase 子类或使用社区插件。
2. 引入更多专家 ：轻松添加新的审查维度，如“性能分析专家”、“API 设计专家”、“测试覆盖率专家”。只需创建新的 Agent 和 Skill，并将其 Chain 加入 Council。
3. 自定义评估策略 ： BasicEvaluator 只是投票/评分的一种方式。你可以实现自己的 EvaluatorBase 子类，例如：
   • 加权投票 ：为不同专家的意见赋予不同权重（如安全专家权重更高）。
   • 多数决 ：选择被最多专家提及的问题。
   • LLM 辩论 ：让专家们就分歧点进行多轮对话，再得出结论。
4. 持久化与用户界面 ：将审查请求和结果保存到数据库，并构建一个简单的 Web 界面（使用 Flask/FastAPI），允许用户提交代码并查看历史审查报告。
5. 集成到 CI/CD ：将本委员会封装成一个命令行工具或 Docker 镜像，集成到 GitLab CI、GitHub Actions 等流程中，作为代码合并前的自动审查关卡。

通过 council-of-high-intelligence 框架，你将复杂的多模型协作流程抽象成了清晰的组件（Agent, Skill, Chain, Council），使得构建一个稳定、智能的集体决策系统变得模块化和可维护。这个代码审查委员会的案例只是一个起点，其设计模式可以广泛应用于智能客服路由、多角度内容生成、风险评估等需要汇聚多方“智慧”的场景。