本教程将带你从零开始，一步步构建一个完整的多 Agent 协作系统。每一步都有详细的代码示例和解释，让你真正理解 Agno 框架的工作原理。

第一步：创建你的第一个 Agent

让我们从最简单的开始 - 创建一个能回答问题的 Agent。

1.1 创建基础文件

首先创建一个新文件 step1_simple_agent.py：

from agno import Agent
from agno.models import Qwen

# 第一步：配置模型
qwen = Qwen(
    model="qwen2.5-72b-instruct",
    api_key="your-api-key-here",  # 替换为你的API密钥
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

# 第二步：创建一个简单的Agent
simple_agent = Agent(
    name="简单助手",
    model=qwen,
    instructions="你是一个友好的助手，能回答各种问题。"
)

# 第三步：测试Agent
if __name__ == "__main__":
    response = simple_agent.run("你好，请介绍一下自己")
    print(f"Agent回复: {response.content}")

1.2 运行第一个Agent

运行这个文件：

python step1_simple_agent.py

预期输出：

Agent回复: 你好！我是一个友好的AI助手，很高兴认识你！我可以帮助你回答各种问题...

1.3 代码解释

• Qwen模型配置：这是我们使用的大语言模型，需要配置API密钥和服务地址
• Agent创建：Agent是最基本的智能体，有名字、模型和指令
• run方法：这是与Agent交互的主要方式

---

第二步：给 Agent 添加工具

现在让我们给 Agent 添加一些实用的工具，比如搜索功能。

2.1 安装工具依赖

pip install duckduckgo-search

2.2 创建带工具的Agent

创建文件 step2_agent_with_tools.py：

from agno import Agent
from agno.models import Qwen
from agno.tools.duckduckgo import DuckDuckGoTools

# 配置模型（和第一步相同）
qwen = Qwen(
    model="qwen2.5-72b-instruct",
    api_key="your-api-key-here",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

# 创建带搜索工具的Agent
search_agent = Agent(
    name="搜索助手",
    model=qwen,
    tools=[DuckDuckGoTools()],  # 添加搜索工具
    instructions="""
    你是一个专业的搜索助手。
    当用户询问最新信息时，请使用搜索工具获取准确的信息。
    搜索后，请整理并总结搜索结果。
    """
)

# 测试搜索功能
if __name__ == "__main__":
    # 测试1：普通问答（不需要搜索）
    print("=== 测试1：普通问答 ===")
    response1 = search_agent.run("什么是人工智能？")
    print(f"回复: {response1.content}\n")
    
    # 测试2：需要搜索的问题
    print("=== 测试2：搜索最新信息 ===")
    response2 = search_agent.run("2024年最新的AI技术发展趋势是什么？")
    print(f"回复: {response2.content}")

2.3 运行带工具的Agent

python step2_agent_with_tools.py

预期输出：

=== 测试1：普通问答 ===
回复: 人工智能（AI）是计算机科学的一个分支...

=== 测试2：搜索最新信息 ===
回复: 根据我搜索到的最新信息，2024年AI技术发展的主要趋势包括：
1. 大语言模型的持续优化...
2. 多模态AI的突破...

2.4 工具的工作原理

当Agent遇到需要最新信息的问题时，它会：

1. 识别需要搜索
2. 调用DuckDuckGo搜索工具
3. 获取搜索结果
4. 整理并回复用户

---

第三步：创建多个专业Agent

现在我们创建多个各有专长的Agent。

3.1 创建专业Agent团队

创建文件 step3_multiple_agents.py：

from agno import Agent
from agno.models import Qwen
from agno.tools.duckduckgo import DuckDuckGoTools

# 共享的模型配置
qwen = Qwen(
    model="qwen2.5-72b-instruct",
    api_key="your-api-key-here",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

# Agent 1: 网络搜索专家
web_search_agent = Agent(
    name="网络搜索专家",
    model=qwen,
    tools=[DuckDuckGoTools()],
    instructions="""
    你是一个专业的网络搜索专家。
    你的任务是：
    1. 根据用户需求进行精准搜索
    2. 筛选和整理搜索结果
    3. 提供准确、及时的信息
    请始终使用搜索工具获取最新信息。
    """
)

# Agent 2: 新闻分析师
news_agent = Agent(
    name="新闻分析师",
    model=qwen,
    tools=[DuckDuckGoTools()],
    instructions="""
    你是一个专业的新闻分析师。
    你的任务是：
    1. 搜索和收集相关新闻
    2. 分析新闻的重要性和影响
    3. 提供深入的新闻解读
    4. 识别新闻趋势和模式
    请用专业的新闻分析视角来回答问题。
    """
)

# Agent 3: 技术顾问
tech_advisor = Agent(
    name="技术顾问",
    model=qwen,
    instructions="""
    你是一个资深的技术顾问。
    你的专长包括：
    1. 软件开发和架构设计
    2. 技术选型和最佳实践
    3. 问题诊断和解决方案
    4. 技术趋势分析
    请提供专业、实用的技术建议。
    """
)

# 测试不同的Agent
def test_agents():
    print("=== 测试网络搜索专家 ===")
    search_result = web_search_agent.run("搜索2024年Python最新版本的特性")
    print(f"搜索专家: {search_result.content}\n")
    
    print("=== 测试新闻分析师 ===")
    news_result = news_agent.run("分析最近AI领域的重要新闻")
    print(f"新闻分析师: {news_result.content}\n")
    
    print("=== 测试技术顾问 ===")
    tech_result = tech_advisor.run("我想开发一个Web应用，应该选择什么技术栈？")
    print(f"技术顾问: {tech_result.content}")

if __name__ == "__main__":
    test_agents()

3.2 运行多Agent测试

python step3_multiple_agents.py

你会看到每个Agent都有自己的专业特色和回答风格。

---

第四步：组建Team进行协作

现在是最关键的部分 - 让多个Agent协作完成复杂任务！

4.1 创建Agent团队

创建文件 step4_team_collaboration.py：

from agno import Agent, Team
from agno.models import Qwen
from agno.tools.duckduckgo import DuckDuckGoTools

# 模型配置
qwen = Qwen(
    model="qwen2.5-72b-instruct",
    api_key="your-api-key-here",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

# 创建专业Agent（复用第三步的Agent）
web_search_agent = Agent(
    name="Web Search Agent",
    model=qwen,
    tools=[DuckDuckGoTools()],
    instructions="你是网络搜索专家，负责搜索和收集信息。"
)

news_agent = Agent(
    name="News Agent",
    model=qwen,
    tools=[DuckDuckGoTools()],
    instructions="你是新闻分析师，负责分析和解读新闻内容。"
)

# 关键步骤：创建Team
research_team = Team(
    name="Research Team",
    agents=[web_search_agent, news_agent],  # 团队成员
    instructions="""
    你们是一个专业的研究团队。
    
    工作流程：
    1. Web Search Agent 负责搜索相关信息
    2. News Agent 负责分析和整理信息
    3. 团队协作完成深入的研究报告
    
    请确保：
    - 信息准确和及时
    - 分析深入和专业
    - 报告结构清晰
    """,
    show_chain_of_thought=True  # 显示思考过程
)

# 测试团队协作
def test_team_collaboration():
    print("=== 团队协作测试 ===")
    
    # 复杂任务：需要搜索+分析
    task = "研究2024年人工智能在医疗领域的最新应用和发展趋势"
    
    print(f"任务: {task}\n")
    print("团队开始协作...\n")
    
    # 使用Team处理复杂任务
    result = research_team.run(task)
    
    print("=== 团队协作结果 ===")
    print(result.content)

if __name__ == "__main__":
    test_team_collaboration()

4.2 Team协作的工作原理

当你运行这个代码时，你会看到：

1. 任务分配：Team自动将任务分配给合适的Agent
2. 协作过程：Agent之间会交换信息和结果
3. 结果整合：Team将各Agent的工作整合成最终结果

预期输出示例：

=== 团队协作测试 ===
任务: 研究2024年人工智能在医疗领域的最新应用和发展趋势

团队开始协作...

=== 团队协作结果 ===
# 2024年人工智能在医疗领域研究报告

## 最新应用
1. AI辅助诊断系统...
2. 智能药物发现...
3. 个性化治疗方案...

## 发展趋势
1. 多模态AI在医疗影像的应用...
2. 大语言模型在医疗问答的突破...

---

第五步：完整的实战项目

现在让我们基于 ago_multi_agent.py 创建一个完整的项目。

5.1 完整项目代码

创建文件 step5_complete_project.py（基于 ago_multi_agent.py）：

from agno import Agent, Team
from agno.models import Qwen
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.tools.reasoning import ReasoningTools

# 配置Qwen模型
qwen = Qwen(
    model="qwen2.5-72b-instruct",
    api_key="your-api-key-here",  # 请替换为你的API密钥
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

# 创建Web搜索Agent
web_search_agent = Agent(
    name="Web Search Agent",
    model=qwen,
    tools=[DuckDuckGoTools()],
    instructions="""
    你是一个专业的网络搜索专家。
    你的职责是：
    1. 根据研究需求进行精准的网络搜索
    2. 收集相关的、可靠的信息源
    3. 整理和筛选搜索结果
    4. 为团队提供准确的基础信息
    
    请确保搜索的信息是最新的、权威的。
    """
)

# 创建新闻分析Agent
news_agent = Agent(
    name="News Agent",
    model=qwen,
    tools=[DuckDuckGoTools()],
    instructions="""
    你是一个资深的新闻分析师和研究员。
    你的职责是：
    1. 深入分析收集到的信息
    2. 识别重要趋势和模式
    3. 提供专业的见解和解读
    4. 撰写结构化的研究报告
    
    请用批判性思维分析信息，提供有价值的洞察。
    """
)

# 创建推理研究团队
reasoning_research_team = Team(
    name="Reasoning Research Team",
    agents=[web_search_agent, news_agent],
    tools=[ReasoningTools()],  # 添加推理工具
    instructions="""
    你们是一个专业的推理研究团队，专门处理复杂的研究任务。
    
    ## 团队协作流程：
    1. **信息收集阶段**：Web Search Agent 负责搜索和收集相关信息
    2. **深度分析阶段**：News Agent 负责分析信息，识别关键点
    3. **推理整合阶段**：使用推理工具进行逻辑分析和结论推导
    4. **报告生成阶段**：生成结构化的研究报告
    
    ## 质量标准：
    - 信息必须准确和最新
    - 分析必须深入和专业
    - 推理必须逻辑清晰
    - 报告必须结构完整
    
    ## 输出格式：
    请按以下格式输出研究报告：
    # 研究报告：[主题]
    ## 执行摘要
    ## 关键发现
    ## 详细分析
    ## 趋势预测
    ## 结论和建议
    """,
    show_chain_of_thought=True
)

# 主函数：演示完整的研究流程
def main():
    print("🚀 Agno 多Agent协作系统启动")
    print("=" * 50)
    
    # 研究任务列表
    research_tasks = [
        "分析2024年生成式AI技术的最新发展和商业应用",
        "研究量子计算在未来5年的发展前景和挑战",
        "调查可持续能源技术的最新突破和投资趋势"
    ]
    
    for i, task in enumerate(research_tasks, 1):
        print(f"\n📋 任务 {i}: {task}")
        print("-" * 40)
        
        try:
            # 使用团队协作完成研究任务
            result = reasoning_research_team.run(task)
            
            print("✅ 研究完成！")
            print("📊 研究报告：")
            print(result.content)
            
        except Exception as e:
            print(f"❌ 任务执行失败: {str(e)}")
        
        print("\n" + "=" * 50)

# 单独测试各个Agent
def test_individual_agents():
    print("🧪 测试单个Agent功能")
    print("=" * 30)
    
    # 测试搜索Agent
    print("\n🔍 测试Web搜索Agent:")
    search_result = web_search_agent.run("搜索2024年AI芯片的最新发展")
    print(f"搜索结果: {search_result.content[:200]}...")
    
    # 测试新闻Agent
    print("\n📰 测试新闻分析Agent:")
    news_result = news_agent.run("分析人工智能对就业市场的影响")
    print(f"分析结果: {news_result.content[:200]}...")

# 交互式研究模式
def interactive_research():
    print("\n🎯 进入交互式研究模式")
    print("输入 'quit' 退出")
    
    while True:
        user_query = input("\n请输入你想研究的问题: ")
        
        if user_query.lower() == 'quit':
            print("👋 再见！")
            break
            
        if user_query.strip():
            print("\n🔄 团队开始研究...")
            try:
                result = reasoning_research_team.run(user_query)
                print("\n📋 研究结果:")
                print(result.content)
            except Exception as e:
                print(f"❌ 研究失败: {str(e)}")

if __name__ == "__main__":
    # 选择运行模式
    print("请选择运行模式:")
    print("1. 预设任务演示")
    print("2. 单个Agent测试")
    print("3. 交互式研究")
    
    choice = input("请输入选择 (1/2/3): ")
    
    if choice == "1":
        main()
    elif choice == "2":
        test_individual_agents()
    elif choice == "3":
        interactive_research()
    else:
        print("无效选择，运行默认演示")
        main()

5.2 运行完整项目

python step5_complete_project.py

运行效果：

🚀 Agno 多Agent协作系统启动
==================================================

📋 任务 1: 分析2024年生成式AI技术的最新发展和商业应用
----------------------------------------
✅ 研究完成！
📊 研究报告：
# 研究报告：2024年生成式AI技术发展分析

## 执行摘要
2024年生成式AI技术呈现爆发式增长...

## 关键发现
1. 大语言模型能力显著提升
2. 多模态AI成为新趋势
3. 企业级应用快速普及
...

---

常见问题和解决方案

Q1: API密钥配置问题

问题：运行时提示API密钥错误

解决方案：

# 方法1：直接在代码中配置
qwen = Qwen(
    model="qwen2.5-72b-instruct",
    api_key="sk-your-actual-api-key",  # 替换为真实密钥
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

# 方法2：使用环境变量（推荐）
import os
qwen = Qwen(
    model="qwen2.5-72b-instruct",
    api_key=os.getenv("QWEN_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

Q2: 工具导入失败

问题：ImportError: No module named 'agno.tools.duckduckgo'

解决方案：

# 安装必要的依赖
pip install agno
pip install duckduckgo-search

Q3: Team协作没有效果

问题：Team运行时只有一个Agent在工作

解决方案：

# 确保Team的instructions明确指定协作流程
team = Team(
    name="Research Team",
    agents=[agent1, agent2],
    instructions="""
    明确的协作指令：
    1. Agent1负责搜索信息
    2. Agent2负责分析信息
    3. 两个Agent必须协作完成任务
    """,
    show_chain_of_thought=True  # 显示协作过程
)

Q4: 响应速度慢

问题：Agent响应时间过长

解决方案：

# 优化模型配置
qwen = Qwen(
    model="qwen2.5-72b-instruct",
    api_key="your-api-key",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    timeout=30,  # 设置超时时间
    max_tokens=1000  # 限制输出长度
)

---

进阶技巧和最佳实践

1. Agent角色设计

# ✅ 好的Agent设计
expert_agent = Agent(
    name="数据分析专家",
    model=qwen,
    instructions="""
    你是一个资深的数据分析专家，具有10年以上的行业经验。
    
    你的专长：
    - 统计分析和数据挖掘
    - 商业智能和报表分析
    - 预测建模和趋势分析
    
    工作风格：
    - 严谨、客观、基于数据
    - 提供可操作的建议
    - 用图表和数字说话
    """
)

# ❌ 不好的Agent设计
bad_agent = Agent(
    name="助手",
    model=qwen,
    instructions="你是一个助手"  # 太模糊
)

2. Team协作优化

# 高效的Team设计
optimized_team = Team(
    name="产品研发团队",
    agents=[market_researcher, tech_analyst, product_manager],
    instructions="""
    ## 协作流程（严格按顺序执行）：
    
    ### 第一阶段：市场调研
    - Market Researcher: 调研市场需求和竞品
    - 输出：市场调研报告
    
    ### 第二阶段：技术分析
    - Tech Analyst: 基于市场报告分析技术可行性
    - 输出：技术方案建议
    
    ### 第三阶段：产品规划
    - Product Manager: 整合前两阶段结果，制定产品规划
    - 输出：完整的产品规划文档
    
    ## 质量要求：
    - 每个阶段必须有明确的输出
    - 后续阶段必须基于前面的结果
    - 最终输出必须包含所有阶段的关键信息
    """
)

3. 错误处理和重试机制

def robust_agent_call(agent, query, max_retries=3):
    """带重试机制的Agent调用"""
    for attempt in range(max_retries):
        try:
            result = agent.run(query)
            if result and result.content:
                return result
        except Exception as e:
            print(f"尝试 {attempt + 1} 失败: {e}")
            if attempt == max_retries - 1:
                raise
    return None

# 使用示例
try:
    result = robust_agent_call(my_agent, "复杂的查询")
    print(result.content)
except Exception as e:
    print(f"所有尝试都失败了: {e}")

---

总结

通过这个手把手的教程，你已经学会了：

✅ 你现在掌握的技能：

1. 基础Agent创建 - 从零开始创建智能Agent
2. 工具集成 - 给Agent添加搜索等实用工具
3. 多Agent设计 - 创建专业化的Agent团队
4. Team协作 - 实现真正的多Agent协作
5. 完整项目 - 构建生产级的多Agent系统

🚀 下一步建议：

1. 实践项目：

   • 创建自己的专业Agent（如代码审查、文档生成等）
   • 构建特定领域的研究团队
   • 开发自动化工作流程

2. 深入学习：

   • 探索更多工具集成
   • 学习自定义工具开发
   • 研究高级协作模式

3. 生产部署：

   • 添加日志和监控
   • 实现API接口
   • 优化性能和成本

💡 关键要点回顾：

• Agent = 模型 + 指令 + 工具
• Team = 多个Agent + 协作指令
• 成功的关键在于清晰的角色定义和协作流程
• 从简单开始，逐步增加复杂性

现在你已经具备了使用Agno框架构建强大多Agent系统的能力！开始创建你自己的AI助手团队吧！ 🎉

多 Agent 协作的优势

• 任务分工明确：每个 Agent 专注于特定领域，提高专业性
• 并行处理能力：多个 Agent 可以同时处理不同任务
• 容错性强：单个 Agent 失败不会影响整个系统
• 可扩展性好：可以轻松添加新的 Agent 来扩展功能
• 协作智能：通过 Team 机制实现智能体间的信息共享和协调

适用场景

• 复杂研究任务（如市场分析、技术调研）
• 多源信息整合（如新闻聚合、数据分析）
• 内容生成与处理（如文档生成、翻译）
• 决策支持系统
• 自动化工作流程

环境配置

安装依赖

# 安装 Agno 框架
pip install agno

# 安装相关依赖
pip install duckduckgo-search

API 密钥配置

import os

# 配置通义千问 API 密钥
os.environ["DASHSCOPE_API_KEY"] = "your-api-key-here"

# 其他可能需要的 API 密钥
# os.environ["OPENAI_API_KEY"] = "your-openai-key"
# os.environ["ANTHROPIC_API_KEY"] = "your-anthropic-key"

基础设置

确保你的环境支持：

• Python 3.8+
• 稳定的网络连接（用于 API 调用）
• 足够的内存和计算资源

核心概念

Agent（智能体）

Agent 是 Agno 框架中的基本执行单元，每个 Agent 都有：

• 名称和角色：定义 Agent 的身份和职责
• 模型：使用的 AI 模型（如 Qwen、GPT 等）
• 工具：Agent 可以使用的外部工具
• 指令：指导 Agent 行为的规则和要求

from agno.agent import Agent
from agno.models.qwen import Qwen
from agno.tools.duckduckgo import DuckDuckGoTools

agent = Agent(
    name="示例 Agent",
    role="处理特定任务",
    model=qwen_model,
    tools=[DuckDuckGoTools()],
    instructions="具体的行为指令"
)

Team（团队）

Team 是多个 Agent 的协作容器，负责：

• 协调 Agent 工作：分配任务和管理执行流程
• 信息共享：在 Agent 之间传递信息
• 结果整合：汇总各 Agent 的输出
• 质量控制：确保最终结果符合要求

from agno.team.team import Team

team = Team(
    name="协作团队",
    mode="coordinate",  # 协作模式
    members=[agent1, agent2],
    instructions=["团队协作指令"]
)

Tools（工具）

工具为 Agent 提供外部能力：

• DuckDuckGoTools：网络搜索功能
• ReasoningTools：推理和分析工具
• 自定义工具：根据需求开发的专用工具

Model（模型）

模型是 Agent 的"大脑"，支持多种 AI 模型：

• Qwen：通义千问模型
• OpenAI GPT：OpenAI 的 GPT 系列
• Claude：Anthropic 的 Claude 模型

代码详解

基于 ago_multi_agent.py 的完整代码分析：

1. 导入必要模块

import os
from agno.agent import Agent
from agno.models.qwen import Qwen
from agno.team.team import Team
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.tools.reasoning import ReasoningTools

2. 配置模型

# 配置 API 密钥
os.environ["DASHSCOPE_API_KEY"] = "your-api-key"

# 创建 Qwen 模型实例
qwen = Qwen(
    id="qwen-flash",  # 模型标识符
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    top_p=0.7,        # 控制生成多样性
    temperature=0.95,  # 控制随机性
)

参数说明：

• id：模型标识符，选择具体的模型版本
• base_url：API 服务地址
• top_p：核采样参数，值越小生成越确定
• temperature：温度参数，值越高生成越随机

3. 创建专门化 Agent

Web 搜索 Agent

web_agent = Agent(
    name="Web Search Agent",
    role="处理网络搜索请求和一般研究",
    model=qwen,
    tools=[DuckDuckGoTools()],
    instructions="始终包含来源",
    add_datetime_to_instructions=True,
    debug_mode=True,
)

新闻 Agent

news_agent = Agent(
    name="News Agent",
    role="处理新闻请求和时事分析",
    model=qwen,
    tools=[DuckDuckGoTools(search=True, news=True)],
    instructions=[
        "使用表格显示新闻信息和发现。",
        "明确说明来源和发布日期。",
        "关注提供当前和相关的新闻见解。",
    ],
    add_datetime_to_instructions=True,
    debug_mode=True,
)

配置参数详解：

• name：Agent 的名称标识
• role：Agent 的角色描述
• model：使用的 AI 模型
• tools：可用工具列表
• instructions：行为指令（可以是字符串或列表）
• add_datetime_to_instructions：是否添加时间信息
• debug_mode：是否启用调试模式

4. 创建协作团队

reasoning_research_team = Team(
    name="Reasoning Research Team",
    mode="coordinate",  # 协作模式
    model=qwen,
    members=[web_agent, news_agent],
    tools=[ReasoningTools(add_instructions=True)],
    instructions=[
        "协作提供全面的研究和新闻见解",
        "考虑当前事件和热门话题",
        "使用表格和图表清晰专业地展示数据",
        "以结构化、易于遵循的格式呈现发现",
        "仅输出最终的综合分析，而不是单个代理响应",
    ],
    markdown=True,
    show_members_responses=True,
    enable_agentic_context=True,
    add_datetime_to_instructions=True,
    success_criteria="团队已提供完整的研究分析，包括数据、可视化、趋势评估和基于当前信息和可靠来源的可操作见解。",
    debug_mode=True,
)

Team 参数详解：

• mode：协作模式（coordinate、sequential、parallel 等）
• members：团队成员 Agent 列表
• tools：团队级别的工具
• markdown：是否使用 Markdown 格式输出
• show_members_responses：是否显示各成员的响应
• enable_agentic_context：是否启用智能体上下文
• success_criteria：成功标准定义

5. 执行任务

if __name__ == "__main__":
    reasoning_research_team.print_response(
        """使用中文输出，研究并比较可再生能源的最新发展:
        1. 获取可再生能源创新的最新消息
        2. 分析可再生能源领域的最新发展
        3. 比较不同的可再生能源技术
        4. 推荐值得关注的未来趋势""",
        stream=True,
        show_full_reasoning=True,
        stream_intermediate_steps=True,
    )

执行参数说明：

• stream：是否流式输出结果
• show_full_reasoning：是否显示完整推理过程
• stream_intermediate_steps：是否流式显示中间步骤

实战示例

示例 1：创建单个 Agent

from agno.agent import Agent
from agno.models.qwen import Qwen
from agno.tools.duckduckgo import DuckDuckGoTools

# 创建模型
model = Qwen(id="qwen-flash")

# 创建专门的研究 Agent
research_agent = Agent(
    name="Research Assistant",
    role="专业研究助手",
    model=model,
    tools=[DuckDuckGoTools()],
    instructions=[
        "提供准确、详细的研究信息",
        "引用可靠来源",
        "以结构化方式组织信息"
    ]
)

# 使用 Agent
response = research_agent.run("研究人工智能在医疗领域的应用")
print(response.content)

示例 2：组建 Agent 团队

# 创建多个专门化 Agent
data_agent = Agent(
    name="Data Analyst",
    role="数据分析专家",
    model=model,
    tools=[DuckDuckGoTools()],
    instructions="专注于数据收集和统计分析"
)

report_agent = Agent(
    name="Report Writer",
    role="报告撰写专家",
    model=model,
    instructions="将分析结果整理成专业报告"
)

# 创建协作团队
analysis_team = Team(
    name="Analysis Team",
    mode="sequential",  # 顺序执行模式
    members=[data_agent, report_agent],
    instructions=[
        "首先收集和分析数据",
        "然后生成综合报告",
        "确保报告专业且易懂"
    ]
)

# 执行团队任务
result = analysis_team.run("分析2024年电商市场趋势")

示例 3：配置不同协作模式

# 并行模式：多个 Agent 同时工作
parallel_team = Team(
    name="Parallel Research Team",
    mode="parallel",
    members=[web_agent, news_agent],
    instructions="同时进行网络搜索和新闻分析"
)

# 协调模式：智能分配任务
coordinate_team = Team(
    name="Coordinate Team",
    mode="coordinate",
    members=[web_agent, news_agent],
    instructions="根据任务需求智能分配工作"
)

最佳实践

Agent 设计原则

1. 单一职责原则

   # 好的设计：专门化 Agent
   translation_agent = Agent(
       name="Translator",
       role="专业翻译",
       instructions="只负责文本翻译任务"
   )
   
   # 避免：功能过于复杂的 Agent
   # complex_agent = Agent(
   #     name="Everything Agent",
   #     role="处理所有任务"  # 不推荐
   # )
   

2. 清晰的角色定义

   agent = Agent(
       name="Market Analyst",
       role="专注于市场趋势分析和预测",
       instructions=[
           "分析市场数据和趋势",
           "提供基于数据的预测",
           "使用图表和可视化展示结果"
       ]
   )
   

3. 合适的工具配置

   # 根据 Agent 职责配置相应工具
   search_agent = Agent(
       name="Search Specialist",
       tools=[DuckDuckGoTools(search=True, news=True)],
       instructions="专门负责信息搜索和收集"
   )
   

Team 协作模式选择

1. Sequential（顺序模式）

   • 适用于：有明确先后顺序的任务
   • 示例：数据收集 → 分析 → 报告生成

2. Parallel（并行模式）

   • 适用于：可以同时进行的独立任务
   • 示例：多源信息收集、多角度分析

3. Coordinate（协调模式）

   • 适用于：需要智能任务分配的复杂场景
   • 示例：综合研究、多维度分析

错误处理

try:
    result = team.run(task)
    if result.success:
        print(f"任务完成：{result.content}")
    else:
        print(f"任务失败：{result.error}")
except Exception as e:
    print(f"执行错误：{e}")
    # 实施备用方案

性能优化

1. 合理设置模型参数

   # 平衡性能和质量
   model = Qwen(
       temperature=0.7,  # 适中的随机性
       top_p=0.9,       # 适中的多样性
   )
   

2. 启用调试模式进行开发

   agent = Agent(
       debug_mode=True,  # 开发时启用
       # debug_mode=False,  # 生产时关闭
   )
   

3. 合理使用流式输出

   # 对于长时间任务，使用流式输出提升用户体验
   team.print_response(
       task,
       stream=True,
       stream_intermediate_steps=True
   )
   

扩展应用

自定义工具

from agno.tools.base import Tool

class CustomAnalysisTool(Tool):
    def __init__(self):
        super().__init__(name="Custom Analysis")
    
    def analyze_data(self, data):
        # 自定义分析逻辑
        return f"分析结果：{data}"

# 在 Agent 中使用自定义工具
custom_agent = Agent(
    name="Custom Agent",
    tools=[CustomAnalysisTool()],
    instructions="使用自定义工具进行分析"
)

复杂任务分解

# 将复杂任务分解为多个子任务
def complex_research_workflow(topic):
    # 第一阶段：信息收集
    collection_team = Team(
        name="Information Collection",
        members=[web_agent, news_agent],
        mode="parallel"
    )
    
    raw_data = collection_team.run(f"收集关于{topic}的信息")
    
    # 第二阶段：数据分析
    analysis_agent = Agent(
        name="Data Analyzer",
        instructions="分析收集到的数据"
    )
    
    analysis_result = analysis_agent.run(f"分析数据：{raw_data}")
    
    # 第三阶段：报告生成
    report_agent = Agent(
        name="Report Generator",
        instructions="生成最终报告"
    )
    
    final_report = report_agent.run(f"生成报告：{analysis_result}")
    
    return final_report

实际项目应用

新闻聚合系统

news_system = Team(
    name="News Aggregation System",
    members=[
        Agent(name="News Collector", tools=[DuckDuckGoTools(news=True)]),
        Agent(name="Content Analyzer", instructions="分析新闻内容"),
        Agent(name="Summary Generator", instructions="生成新闻摘要")
    ],
    mode="sequential",
    instructions="收集、分析并总结最新新闻"
)

市场研究系统

market_research_system = Team(
    name="Market Research System",
    members=[
        Agent(name="Data Collector", tools=[DuckDuckGoTools()]),
        Agent(name="Trend Analyzer", instructions="分析市场趋势"),
        Agent(name="Report Writer", instructions="撰写研究报告")
    ],
    mode="coordinate",
    instructions="进行全面的市场研究分析"
)

总结

Agno 多 Agent 协作框架提供了一个强大而灵活的平台，用于构建智能化的多智能体系统。通过合理的 Agent 设计、Team 协作和工具配置，可以实现复杂任务的自动化处理。

关键要点：

• 遵循单一职责原则设计 Agent
• 根据任务特点选择合适的协作模式
• 合理配置模型参数和工具
• 实施适当的错误处理和性能优化
• 根据实际需求扩展和定制功能

通过本教程的学习和实践，你应该能够熟练使用 Agno 框架构建自己的多 Agent 协作系统。