Agno开发教程系列（五）：多Agent协作系统（下）—— Workflow工作流机制
作者：Agno技术社区 难度：中高级 阅读时间：约30分钟 前置要求：熟悉Python基础、了解Agno Agent和Team机制
📚 教程导航
- 上一篇：多Agent协作系统（上）—— Team机制
- 当前篇：多Agent协作系统（下）—— Workflow工作流机制
- 下一篇：待更新
一、引言
1.1 回顾与承接
在上一篇教程中，我们深入探讨了Agno的Team机制（Level 4） ，了解了如何通过路由（Route）、协作（Collaborate）和协调（Coordinate）三种模式，让多个Agent实现灵活的团队协作。Team机制的核心优势在于其动态性和灵活性——Agent可以根据任务需求自主决策、动态分配工作。
然而，在实际的生产环境中，我们常常需要处理更加结构化、确定性的复杂流程，例如：
- 内容创作流水线：研究 → 大纲 → 写作 → 编辑 → 发布
- 金融分析系统：数据采集 → 预处理 → 基本面分析 → 技术分析 → 风险评估 → 投资建议
- 医疗诊断支持：症状分析 → 文献检索 → 临床指南匹配 → 诊断建议
这些场景有几个共同特点：
- 明确的执行顺序：每个步骤都有严格的先后依赖关系
- 状态持久化：需要在步骤间传递和维护上下文信息
- 可预测的结果：相同输入应该产生一致的输出
- 复杂的流程控制：包含条件分支、并行处理、循环迭代等
这正是Agno Workflow工作流机制（Level 5） 的用武之地。
1.2 什么是Workflow？
Workflow（工作流） 是Agno框架中最高级别（Level 5）的智能体系统架构，它通过有状态的、确定性的编排，将Agent、Team和Python函数组合成可预测、可重复的自动化流程。
Workflow的核心特性包括：
- ✅ 确定性执行：明确的步骤序列和数据流
- ✅ 状态管理：在整个执行过程中持久化上下文
- ✅ 复杂编排：支持顺序、并行、条件、循环等控制流
- ✅ 生产就绪：清晰的审计日志和错误处理
- ✅ 混合执行：可以无缝集成Agent、Team和普通函数
1.3 本教程学习目标
通过本教程，你将学会：
- 理解Workflow的核心概念和架构设计
- 掌握Workflow的配置方法和API使用
- 学会构建从基础到进阶的Workflow应用
- 了解Team和Workflow的区别与适用场景
- 实践完整的生产级Workflow案例
- 掌握Workflow开发的最佳实践
让我们开始探索Agno Workflow的强大功能！
二、核心概念与架构
2.1 Workflow的设计哲学
Agno Workflow的设计遵循几个核心原则：
2.1.1 确定性优先（Determinism First）
与Team的动态协作不同，Workflow强调可预测性：
# Team：动态协作，结果可能因Agent决策而异
team_result = agent_team.run("分析这家公司") # 每次可能路由到不同的Agent
# Workflow：确定性执行，相同输入产生相同的流程
workflow_result = analysis_workflow.run("分析这家公司") # 固定的执行路径
2.1.2 显式流程控制（Explicit Flow Control）
Workflow要求开发者显式定义每个步骤的执行顺序和条件：
# 显式定义的执行流程
workflow = Workflow(
name="Content Creation Pipeline",
steps=[
research_step, # 步骤1：研究
outline_step, # 步骤2：大纲（依赖步骤1）
writing_step, # 步骤3：写作（依赖步骤2）
editing_step, # 步骤4：编辑（依赖步骤3）
]
)
2.1.3 状态即一等公民（State as First-Class Citizen）
Workflow将状态管理作为核心特性，提供多种持久化方案：
workflow = Workflow(
name="Long Running Analysis",
session_id="user_123_analysis",
db=SqliteDb(db_file="./workflow_state.db"), # SQLite持久化
session_state={}, # 初始状态
)
2.2 核心架构组件
Workflow系统由以下关键组件构成：
2.2.1 Workflow类（顶层编排器）
Workflow是整个系统的核心，负责编排和管理所有步骤的执行：
from agno.workflow import Workflow
class MyWorkflow(Workflow):
"""自定义工作流类"""
description: str = "我的第一个工作流"
def __init__(self, **kwargs):
super().__init__(**kwargs)
# 初始化Agent和其他资源
async def run(self, input_data: str):
"""工作流执行逻辑"""
# 定义步骤执行流程
pass
关键特性：
- 维护自己的会话状态（
session_state） - 支持同步/异步执行
- 提供事件流和指标收集
- 支持多种数据库后端
2.2.2 Step（执行单元）
Step是工作流的基本执行单元，每个Step封装唯一的执行器：
from agno.workflow import Step
from agno.agent import Agent
# Step可以封装Agent
research_step = Step(
name="research",
agent=researcher_agent,
description="研究给定的主题，收集相关信息"
)
# Step也可以封装Team
analysis_step = Step(
name="analysis",
team=analysis_team,
description="团队协作分析研究结果"
)
# Step还可以封装Python函数
def preprocess_data(step_input):
"""数据预处理函数"""
return StepOutput(content=f"Processed: {step_input.input}")
preprocess_step = Step(
name="preprocess",
executor=preprocess_data,
description="预处理输入数据"
)
设计原则：
- ✅ 一个Step = 一个执行器（Agent/Team/Function）
- ✅ 清晰的输入/输出接口
- ✅ 可重用和组合
2.2.3 控制流构造
Workflow提供丰富的控制流构造来实现复杂逻辑：
1. Condition（条件分支）
from agno.workflow.condition import Condition
from agno.workflow.step import Step
from agno.workflow.types import StepInput
from agno.workflow.workflow import Workflow
def should_deep_analysis(step_input: StepInput) -> bool:
"""判断是否需要深度分析"""
return "复杂" in step_output.content
basic_workflow = Workflow(
name="Basic Linear Workflow",
description="Research -> Summarize -> Condition(Fact Check) -> Write Article",
steps=[
research_step,
summarize_step,
Condition(
name="fact_check_condition",
description="Check if fact-checking is needed",
evaluator=should_deep_analysis,
steps=[deep_analyst],
),
write_article,
],
)
2. Parallel（并行执行）
from agno.workflow import Parallel
# 并行执行多个分析任务
parallel_analysis = Parallel(
[
fundamental_analysis_step, # 基本面分析
technical_analysis_step, # 技术分析
sentiment_analysis_step, # 情绪分析
],
name="parallel_analysis"
)
3. Loop（循环迭代）
from agno.workflow import Loop
def should_continue_iteration(outputs: List[StepOutput]) -> bool:
"""判断是否继续迭代"""
total_content_length = sum(len(output.content or "") for output in outputs)
return total_content_length > 0
loop_refinement = Loop(
[writing_step, review_step],
max_iterations=5, # 最大5次迭代
name="iterative_refinement",
end_condition=should_continue_iteration # 结束迭代的条件
)
4. Router（路由选择）
from agno.workflow import Router, Step, StepInput
def route_logic(step_input: StepInput)->list[Step]:
"""根据输出决定下一步"""
if "技术文章" in step_input.content:
return [technical_writing_step]
elif "商业报告" in step_input.content:
return [business_writing_step]
else:
return [general_writing_step]
router_step = Router(
selector=route_logic,
choices=[technical_writing_step,business_writing_step,general_writing_step]
)
2.2.4 数据流接口
StepInput和StepOutput提供标准化的数据流接口：
from agno.workflow import StepInput, StepOutput
from typing import Dict, Any
def custom_processor(step_input: StepInput) -> StepOutput:
"""
自定义处理函数
Args:
step_input: 包含input、context等信息
Returns:
StepOutput: 包含处理结果
"""
# 访问输入数据
user_input = step_input.input
# 执行处理逻辑
result = f"处理结果：{user_input}"
# 返回标准化输出
return StepOutput(
content=result
)
2.3 会话状态管理
Workflow的状态管理系统是其核心优势之一，提供了完整的持久化解决方案。
2.3.1 状态存储后端
Agno支持多种存储后端：
SQLite（默认，适合开发和中小规模应用）
from agno.db.sqlite import SqliteDb
workflow = Workflow(
name="My Workflow",
db=SqliteStorage(
session_table="workflow_sessions",
db_file="./data/workflows.db"
)
)
PostgreSQL（适合生产环境）
from agno.db.postgres import PostgresDb
workflow = Workflow(
name="Production Workflow",
db=PostgresDb(
table_name="workflow_sessions",
db_url="postgresql://user:pass@localhost/dbname"
)
)
MongoDB（适合文档型数据）
from agno.db.mongo import MongoDb
workflow = Workflow(
name="Document Workflow",
db=MongoDb(
collection_name="workflow_sessions",
db_name="agno_db"
)
)
2.3.2 会话状态使用
在Workflow执行过程中，可以读写session_state：
class ContentWorkflow(Workflow):
def run(self, topic: str):
# 检查缓存
cached = self.session_state.get("articles", {}).get(topic)
if cached:
yield RunResponse(content=cached)
return
# 执行研究
research_result = self.researcher.run(topic)
# 保存中间结果到状态
self.session_state.setdefault("research_cache", {})[topic] = research_result
# 生成文章
article = self.writer.run(research_result)
# 缓存最终结果
self.session_state.setdefault("articles", {})[topic] = article
yield RunResponse(content=article)
2.4 架构层次对比
让我们回顾一下Agno的完整架构层次：
Level 1: Agent（单个智能体）
↓
Level 2: Agent + Tools（工具增强的智能体）
↓
Level 3: Agent + Knowledge（知识增强的智能体）
↓
Level 4: Team（多智能体协作）
↓
Level 5: Workflow（有状态工作流编排） ← 本教程重点
各层次对比表：
| 层次 | 核心特性 | 适用场景 | 确定性 | 复杂度 |
|---|---|---|---|---|
| Level 1 | 单一Agent | 简单对话 | 低 | ⭐ |
| Level 2 | Agent+工具 | 工具调用任务 | 低-中 | ⭐⭐ |
| Level 3 | Agent+知识库 | RAG应用 | 中 | ⭐⭐⭐ |
| Level 4 | Team协作 | 动态多任务 | 低-中 | ⭐⭐⭐⭐ |
| Level 5 | Workflow编排 | 结构化流程 | 高 | ⭐⭐⭐⭐⭐ |
三、基础用法
3.1 第一个Workflow：Hello Workflow
让我们从最简单的例子开始，创建一个包含两个步骤的工作流：
"""
示例1：基础Workflow - 两步文章生成
功能：研究主题 → 撰写文章
"""
import os
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.models.openai import OpenAIChat
from agno.workflow import Workflow, Step
from agno.tools.baidusearch import BaiduSearchTools
from dotenv import load_dotenv
# 加载DeepSeek API密钥
load_dotenv()
api_key = os.getenv("DEEPSEEK_API_KEY")
deep_seek = DeepSeek(api_key=api_key)
# 步骤1：定义Agent
researcher = Agent(
name="Researcher",
model=deep_seek,
tools=[BaiduSearchTools()],
description="负责研究主题，收集相关信息",
instructions=[
"使用搜索工具查找最新信息",
"总结3-5个关键要点",
"提供信息来源"
],
markdown=True
)
writer = Agent(
name="Writer",
model=deep_seek,
description="负责撰写文章",
instructions=[
"基于研究结果撰写500字文章",
"使用清晰的结构（引言、正文、结论）",
"使用Markdown格式"
],
markdown=True
)
# 步骤2：创建Workflow
simple_workflow = Workflow(
name="Simple Article Generator",
description="简单的文章生成工作流",
steps=[
Step(agent=researcher), # 第一步：研究
Step(agent=writer), # 第二步：写作（自动接收上一步的输出作为输入）
]
)
# 步骤3：运行Workflow
if __name__ == "__main__":
topic = "人工智能在医疗领域的应用"
# 同步执行
result = simple_workflow.run(topic)
print(result.content)
# 或者流式输出
simple_workflow.print_response(topic, markdown=True, stream=True)
运行结果：
┏━ Workflow Information ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ ┃
┃ Workflow: Simple Article Generator ┃
┃ ┃
┃ Description: 简单的文章生成工作流 ┃
┃ ┃
┃ Steps: 2 steps ┃
┃ ┃
┃ Message: 人工智能在医疗领域的应用 ┃
┃ ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
┏━ Step 1: unnamed_step (Completed) ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ ┃
┃ 我来为您搜索人工智能在医疗领域应用的最新信息。让我再搜索一些更具体的应用案例 ┃
┃ 。基于搜索结果，我来为您总结人工智能在医疗领域应用的关键要点： ┃
┃ ┃
┃ ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓ ┃
┃ ┃ 人工智能在医疗领域的应用 ┃ ┃
┃ ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛ ┃
┃ ┃
┃ ┃
┃ 🔑 关键要点 ┃
┃ ┃
┃ 1. 医学影像诊断 ┃
┃ ┃
┃ • 应用场景：CT、MRI、X光片和病理切片分析 ┃
┃ • 技术优势：通过卷积神经网络(CNN)等技术，在识别肿瘤、病变等方面超越人类专家 ┃
┃ 的精度和效率 ┃
┃ • 典型案例：FDA批准的IDx-DR系统用于自动检测糖尿病性视网膜病变，准确率超过87 ┃
┃ % ┃
......
关键要点：
- ✅ Workflow自动将第一步（researcher）的输出作为第二步（writer）的输入
- ✅ 每个步骤都可以是Agent、Team或函数
- ✅
print_response()方法提供友好的输出格式
3.2 使用Steps组织步骤
对于复杂的工作流，可以使用Steps对象将多个步骤组织成逻辑序列：
"""
示例2：使用Steps组织工作流
功能：研究 → 大纲 → 写作 → 编辑
"""
from agno.agent import Agent
from agno.workflow.step import Step
from agno.workflow.steps import Steps
from agno.workflow.workflow import Workflow
# 定义各个Agent（代码略，参考示例1）
researcher = Agent(...)
outliner = Agent(...)
writer = Agent(...)
editor = Agent(...)
# 使用Step封装每个Agent
research_step = Step(
name="research",
agent=researcher,
description="研究主题，收集背景信息和关键数据"
)
outline_step = Step(
name="outline",
agent=outliner,
description="基于研究结果创建文章大纲"
)
writing_step = Step(
name="writing",
agent=writer,
description="根据大纲撰写完整文章"
)
editing_step = Step(
name="editing",
agent=editor,
description="编辑和润色文章，确保质量"
)
# 将步骤组织成可重用的序列
article_creation_sequence = Steps(
name="article_creation",
description="完整的文章创作流程",
steps=[research_step, outline_step, writing_step, editing_step]
)
# 创建Workflow
article_workflow = Workflow(
name="Professional Article Workflow",
description="专业的文章创作工作流",
steps=[article_creation_sequence], # 使用Steps序列
debug_mode=True, # 启用调试模式
)
# 运行
if __name__ == "__main__":
article_workflow.print_response(
input="撰写一篇关于可再生能源的文章",
markdown=True
)
Steps的优势：
- ✅ 将相关步骤组织成逻辑单元
- ✅ 提高可重用性（可以在多个Workflow中使用同一个Steps）
- ✅ 更好的代码组织和可读性
3.3 混合执行：Agent + Team + Function
Workflow的强大之处在于可以混合不同类型的执行器：
"""
示例3：混合执行 - Agent、Team和函数的组合
功能：市场分析 → 数据预处理 → 团队分析 → 报告生成
"""
import os
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.tools.yfinance import YFinanceTools
from agno.workflow import Workflow, StepOutput
from agno.team import Team
from dotenv import load_dotenv
from agno.tools.baidusearch import BaiduSearchTools
load_dotenv()
model = DeepSeek(api_key=os.getenv("DEEPSEEK_API_KEY"))
# 1. 定义数据预处理函数
def data_preprocessor(step_input):
"""
预处理函数：清洗和标准化数据
Args:
step_input: StepInput对象，包含上一步的输出
Returns:
StepOutput: 预处理后的数据
"""
raw_data = step_input.input
# 模拟数据清洗
cleaned_data = raw_data.strip().upper()
# 返回标准化输出
return StepOutput(
content=f"已清洗数据：{cleaned_data}",
)
# 2. 定义市场研究Agent
market_researcher = Agent(
name="Market Researcher",
model=model,
tools=[BaiduSearchTools()],
description="市场研究专家",
instructions=["收集市场数据", "分析竞争对手"]
)
# 3. 定义分析Team
web_analyst = Agent(
name="Web Analyst",
tools=[BaiduSearchTools()],
description="网络信息分析师"
)
financial_analyst = Agent(
name="Financial Analyst",
tools=[YFinanceTools()],
description="金融数据分析师"
)
analysis_team = Team(
delegate_task_to_all_members=True, # 协作模式
members=[web_analyst, financial_analyst],
model=model,
description="多领域分析团队",
instructions=["综合分析多个维度", "提供全面的见解"]
)
# 4. 定义报告生成Agent
report_generator = Agent(
name="Report Generator",
model=model,
description="报告撰写专家",
instructions=[
"生成结构化的分析报告",
"包含执行摘要、详细分析和建议",
"使用专业的商业语言"
]
)
# 5. 组合成Workflow
mixed_workflow = Workflow(
name="Market Analysis Pipeline",
description="混合执行的市场分析流水线",
steps=[
market_researcher, # Step 1: Agent
data_preprocessor, # Step 2: Function
analysis_team, # Step 3: Team
report_generator, # Step 4: Agent
]
)
# 6. 运行Workflow
if __name__ == "__main__":
query = "分析电动汽车市场的竞争格局"
mixed_workflow.print_response(query, markdown=True)
执行流程：
输入：分析电动汽车市场的竞争格局
↓
[Agent] market_researcher → 收集市场数据和竞争对手信息
↓
[Function] data_preprocessor → 清洗和标准化数据
↓
[Team] analysis_team → 多维度协作分析
├─ web_analyst：网络信息分析
└─ financial_analyst：金融数据分析
↓
[Agent] report_generator → 生成最终报告
↓
输出：专业的市场分析报告
3.4 输入验证：使用Pydantic模型
为了确保数据类型安全和一致性，强烈建议使用Pydantic模型定义Workflow的输入和输出：
"""
示例4：使用Pydantic模型进行输入验证
功能：类型安全的研究工作流
"""
import os
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.tools.crawl4ai import Crawl4aiTools
from agno.workflow import Workflow, Step
from dotenv import load_dotenv
from pydantic import BaseModel, Field
from typing import List, Optional
from agno.tools.baidusearch import BaiduSearchTools
load_dotenv()
model = DeepSeek(api_key=os.getenv("DEEPSEEK_API_KEY"))
# 1. 定义输入模型
class ResearchRequest(BaseModel):
"""研究请求输入模型"""
topic: str = Field(..., description="研究主题", min_length=5)
depth: int = Field(default=3, description="研究深度(1-5)", ge=1, le=5)
sources: Optional[List[str]] = Field(
default=None,
description="指定的信息源"
)
# 2. 定义输出模型
class ResearchFinding(BaseModel):
"""单个研究发现"""
url: str = Field(..., description="信息源URL")
summary: str = Field(..., description="关键信息摘要")
class ResearchReport(BaseModel):
"""完整的研究报告"""
topic: str = Field(..., description="研究主题")
key_findings: List[ResearchFinding] = Field(
...,
description="关键发现列表"
)
overall_summary: str = Field(..., description="总体概述")
confidence_score: float = Field(..., description="置信度(0-1)", ge=0, le=1)
# 3. 定义支持结构化输出的Agent
structured_researcher = Agent(
name="Structured Researcher",
model=model,
tools=[BaiduSearchTools(), Crawl4aiTools()],
description="结构化研究专家",
output_schema=ResearchReport, # 指定输出模型
markdown=True
)
# 4. 创建带输入验证的Workflow
validated_workflow = Workflow(
name="Validated Research Workflow",
input_schema=ResearchRequest, # 指定输入验证模型
steps=[Step(agent=structured_researcher)],
debug_mode=True
)
# 5. 使用结构化输入运行
if __name__ == "__main__":
# 方式1：使用Pydantic模型
request = ResearchRequest(
topic="量子计算的商业应用",
depth=4,
sources=["arxiv.org", "nature.com"]
)
result = validated_workflow.run(request)
# 访问结构化输出
if result.content:
report: ResearchReport = result.content
print(f"研究主题：{report.topic}")
print(f"发现数量：{len(report.key_findings)}")
print(f"置信度：{report.confidence_score}")
Pydantic验证的优势：
- ✅ 类型安全：编译时类型检查
- ✅ 自动验证：字段约束自动验证
- ✅ 清晰的API：输入/输出结构一目了然
- ✅ 防止错误：避免运行时的数据格式问题
四、进阶技巧
4.1 条件分支：动态路由
在实际应用中，我们经常需要根据中间结果动态选择不同的执行路径：
"""
示例5：条件分支工作流
功能：根据内容类型选择不同的处理流程
"""
import os
from typing import List
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.workflow import Workflow, Condition, Router, Step, StepInput
from dotenv import load_dotenv
load_dotenv()
model = DeepSeek(api_key=os.getenv("DEEPSEEK_API_KEY"))
# 1. 定义内容分类Agent
content_classifier = Agent(
name="Content Classifier",
model=model,
description="内容分类专家",
instructions=[
"分析输入内容的类型",
"分类为：technical（技术）、business（商业）、creative（创意）",
"返回分类结果和置信度"
]
)
# 2. 定义不同类型的处理Agent
technical_processor = Agent(
name="Technical Processor",
model=model,
description="技术内容处理专家",
instructions=[
"使用专业技术术语",
"包含代码示例和技术细节",
"添加技术参考链接"
]
)
business_processor = Agent(
name="Business Processor",
model=model,
description="商业内容处理专家",
instructions=[
"使用商业语言",
"强调ROI和商业价值",
"包含市场分析"
]
)
creative_processor = Agent(
name="Creative Processor",
model=model,
description="创意内容处理专家",
instructions=[
"使用富有创意的表达",
"讲述引人入胜的故事",
"激发读者情感共鸣"
]
)
technical_processor = Step(
name="technical",
agent=technical_processor,
description="技术内容处理"
)
business_processor = Step(
name="business",
agent=business_processor,
description="商业内容处理"
)
creative_processor = Step(
name="creative",
agent=creative_processor,
description="创意内容处理"
)
# 3. 定义路由逻辑
def content_router(step_input: StepInput) -> List[Step]:
"""
根据分类结果路由到不同的处理器
Args:
step_input: 分类Agent的输入
Returns:
str: 路由目标的步骤名称
"""
content = step_input.input.lower()
if "technical" in content or "技术" in content:
return [technical_processor]
elif "business" in content or "商业" in content:
return [business_processor]
else:
return [creative_processor]
# 4. 创建条件分支Workflow
conditional_workflow = Workflow(
name="Content Processing with Routing",
description="基于内容类型的条件分支处理",
steps=[
# Step 1: 分类
Step(
name="classify",
agent=content_classifier,
description="分类内容类型"
),
# Step 2: 路由（根据分类结果选择处理路径）
Router(
selector=content_router,
choices=[technical_processor, business_processor, creative_processor]
)
]
)
# 5. 测试不同类型的输入
if __name__ == "__main__":
test_inputs = [
"写一篇关于Kubernetes容器编排的技术博客",
"分析电商平台的商业模式和盈利策略",
"创作一个关于AI与人类共存的科幻故事"
]
for input_text in test_inputs:
print(f"\n{'=' * 60}")
print(f"输入: {input_text}")
print('=' * 60)
conditional_workflow.print_response(input_text, markdown=True)
执行示意：
输入: 写一篇关于Kubernetes容器编排的技术博客
↓
[Classifier] → 分类: Technical
↓
[Router] → 路由到: technical_path
↓
[Technical Processor] → 生成技术博客
↓
输出: Kubernetes容器编排深度解析（包含代码示例）
4.2 并行处理：提升效率
对于相互独立的任务，可以使用并行处理显著提升执行效率：
"""
示例6：并行处理工作流
功能：并行执行多维度分析，然后汇总结果
"""
import os
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.tools.yfinance import YFinanceTools
from agno.workflow import Parallel, Workflow, Step
import asyncio
from datetime import datetime
from dotenv import load_dotenv
from agno.tools.baidusearch import BaiduSearchTools
load_dotenv()
model = DeepSeek(api_key=os.getenv("DEEPSEEK_API_KEY"))
# 1. 定义多个独立的分析Agent
fundamental_analyst = Agent(
name="Fundamental Analyst",
model=model,
tools=[YFinanceTools(company_info=True, analyst_recommendation=True)],
description="基本面分析专家",
instructions=[
"分析公司财务状况",
"评估估值水平",
"提供基本面评级"
]
)
technical_analyst = Agent(
name="Technical Analyst",
model=model,
tools=[YFinanceTools(stock_price=True, technical_indicators=True)],
description="技术分析专家",
instructions=[
"分析价格走势",
"识别技术形态",
"提供技术指标信号"
]
)
sentiment_analyst = Agent(
name="Sentiment Analyst",
model=model,
tools=[BaiduSearchTools()],
description="情绪分析专家",
instructions=[
"收集最新新闻",
"分析市场情绪",
"评估舆论倾向"
]
)
risk_analyst = Agent(
name="Risk Analyst",
model=model,
description="风险评估专家",
instructions=[
"识别潜在风险因素",
"评估风险等级",
"提供风险控制建议"
]
)
# 2. 定义汇总Agent
synthesis_agent = Agent(
name="Synthesis Agent",
model=model,
description="综合分析专家",
instructions=[
"整合所有分析结果",
"提供综合投资建议",
"给出明确的操作建议（买入/持有/卖出）",
"标注关键风险点"
]
)
# 3. 创建并行处理Workflow
parallel_workflow = Workflow(
name="Parallel Stock Analysis",
description="并行多维度股票分析",
steps=[
# Step 1: 并行执行4个独立分析
Parallel(
[
Step(name="fundamental", agent=fundamental_analyst),
Step(name="technical", agent=technical_analyst),
Step(name="sentiment", agent=sentiment_analyst),
Step(name="risk", agent=risk_analyst),
],
name="parallel_analysis",
),
# Step 2: 汇总并行结果
Step(
name="synthesis",
agent=synthesis_agent,
description="综合所有分析，提供最终建议"
)
],
stream_intermediate_steps=True, # 流式输出中间步骤
)
# 4. 运行并行分析
if __name__ == "__main__":
stock_symbol = "AAPL"
start_time = datetime.now()
# 异步执行（并行处理）
result = asyncio.run(parallel_workflow.arun(f"分析 {stock_symbol} 股票"))
end_time = datetime.now()
duration = (end_time - start_time).total_seconds()
print(f"\n执行时间: {duration:.2f}秒")
print(f"(并行处理节省了约 {duration * 3:.2f}秒)")
并行执行示意图：
输入: 分析AAPL股票
↓
┌─────────────────────────────────────┐
│ Parallel Execution │
├─────────┬─────────┬─────────┬───────┤
│ 基本面 │ 技术面 │ 情绪面 │ 风险 │
│ 分析 │ 分析 │ 分析 │ 评估 │
│ (10s) │ (12s) │ (8s) │ (9s) │
└─────────┴─────────┴─────────┴───────┘
↓ (总耗时: ~12秒，而不是 39秒)
[Synthesis] → 综合分析
↓
输出: 综合投资建议
性能优势：
- ⚡ 时间节省：并行执行时间 = max(各步骤时间)，而非总和
- 🔄 资源利用：充分利用I/O等待时间
- 📊 实时反馈：
stream_intermediate_steps=True可实时查看各步骤进度
4.3 循环迭代：质量改进
对于需要多次优化的任务，可以使用Loop实现迭代改进：
"""
示例7：循环迭代工作流
功能：写作 → 评审 → 改进，循环直到满足质量标准
"""
from typing import List
from agno.workflow import Loop, StepOutput
import os
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.tools.yfinance import YFinanceTools
from agno.workflow import Parallel, Workflow, Step
import asyncio
from datetime import datetime
from dotenv import load_dotenv
from agno.tools.baidusearch import BaiduSearchTools
from pydantic import BaseModel, Field
load_dotenv()
model = DeepSeek(api_key=os.getenv("DEEPSEEK_API_KEY"))
# 1. 定义写作Agent
writer_agent = Agent(
name="Writer",
model=model,
description="内容写作专家",
instructions=[
"根据给定主题撰写文章",
"使用清晰的结构",
"确保内容准确性"
]
)
# 2. 定义评审Agent（带结构化输出）
class ReviewResult(BaseModel):
"""评审结果模型"""
quality_score: float = Field(..., description="质量评分(0-100)", ge=0, le=100)
needs_improvement: bool = Field(..., description="是否需要改进")
feedback: str = Field(..., description="具体反馈意见")
suggestions: List[str] = Field(..., description="改进建议列表")
reviewer_agent = Agent(
name="Reviewer",
model=model,
description="内容评审专家",
output_schema=ReviewResult,
instructions=[
"评估文章质量（准确性、可读性、结构、深度）",
"如果质量分数低于80分，标记needs_improvement=True",
"提供具体的改进建议"
]
)
# 3. 定义改进Agent
improver_agent = Agent(
name="Improver",
model=model,
description="内容改进专家",
instructions=[
"根据评审反馈改进文章",
"保持原文的核心思想",
"针对性解决指出的问题"
]
)
# 4. 定义循环条件
def should_continue_iteration(step_output: List[StepOutput]) -> bool:
"""
判断是否继续迭代
Args:
step_output: 评审步骤的输出
Returns:
bool: True表示继续迭代，False表示停止
"""
# 检查评审结果
try:
for so in step_output:
if isinstance(so.content, ReviewResult):
review: ReviewResult = so.content
# 如果质量分数低于80且需要改进，则继续迭代
return review.needs_improvement and review.quality_score < 80
else:
# 如果文本中包含"需要改进"，则继续
return "需要改进" in str(so.content)
except:
pass
return False
# 5. 创建循环迭代Workflow
iterative_workflow = Workflow(
name="Iterative Writing Workflow",
description="迭代式写作改进工作流",
steps=[
# Step 1: 初始写作
Step(
name="initial_writing",
agent=writer_agent,
description="撰写初稿"
),
# Step 2-4: 循环（评审 → 改进）
Loop(
name="quality_improvement_loop",
steps=[
Step(
name="review",
agent=reviewer_agent,
description="评审文章质量"
),
Step(
name="improve",
agent=improver_agent,
description="根据反馈改进文章"
),
],
end_condition=should_continue_iteration,
max_iterations=5,
)
],
debug_mode=True,
stream_intermediate_steps=True,
)
# 6. 运行迭代工作流
if __name__ == "__main__":
topic = "深度学习在自然语言处理中的应用"
print(f"开始迭代写作流程：{topic}\n")
result = iterative_workflow.run(topic)
print("\n" + "=" * 60)
print("最终输出:")
print("=" * 60)
print(result.content)
迭代过程示意：
输入: 深度学习在自然语言处理中的应用
↓
[Writer] → 生成初稿
↓
┌─────────────── Loop ───────────────┐
│ 第1轮迭代: │
│ [Reviewer] → 评分: 65 (需改进) │
│ [Improver] → 改进内容深度 │
│ │
│ 第2轮迭代: │
│ [Reviewer] → 评分: 75 (需改进) │
│ [Improver] → 优化案例和数据 │
│ │
│ 第3轮迭代: │
│ [Reviewer] → 评分: 82 (通过) │
│ → 停止迭代 │
└────────────────────────────────────┘
↓
输出: 高质量最终文章 (评分: 82)
4.4 混合内存架构：上下文感知
对于需要长期记忆和上下文感知的复杂应用，可以结合Redis（短时记忆）和Qdrant（长时记忆）：
"""
示例8：混合内存架构工作流
功能：结合短时记忆(Redis)和长时记忆(Qdrant)的智能客服
"""
import os
from agno.agent import Agent
from agno.db.redis import RedisDb
from agno.db.sqlite import SqliteDb
from agno.knowledge import Knowledge
from agno.models.deepseek import DeepSeek
from agno.vectordb.qdrant import Qdrant
from agno.workflow import Workflow, Step
from dotenv import load_dotenv
load_dotenv()
model = DeepSeek(api_key=os.getenv("DEEPSEEK_API_KEY"))
# 1. 配置短时记忆（Redis）
short_term_memory = RedisDb(
db_url='redis://localhost:6379/0',
)
# 2. 配置长时记忆（Qdrant向量数据库）
knowledge_base = Knowledge(
vector_db=Qdrant(
collection="customer_support_kb",
url="http://localhost:6333",
),
max_results=5, # 每次检索5个相关文档
)
# 加载知识库（产品文档、FAQ等）
knowledge_base.add_content(
path="./knowledge_base/product_docs",
upsert=True
)
# 3. 定义上下文感知的客服Agent
context_aware_agent = Agent(
name="Context-Aware Support Agent",
model=model,
db=short_term_memory, # 短时记忆：会话上下文
knowledge=knowledge_base, # 长时记忆：知识库
description="智能客服Agent，具备上下文记忆和知识检索能力",
instructions=[
"记住用户的历史对话（通过短时记忆）",
"从知识库中检索相关信息（通过长时记忆）",
"提供个性化、准确的回答",
"在回答中引用知识来源"
],
read_tool_call_history=True,
markdown=True
)
# 4. 定义问题分类Agent
classifier_agent = Agent(
name="Issue Classifier",
model=model,
description="问题分类专家",
instructions=[
"分类用户问题：技术支持、账单咨询、功能咨询、投诉建议",
"评估紧急程度：低、中、高",
"提取关键信息"
]
)
# 5. 定义解决方案生成Agent
solution_agent = Agent(
name="Solution Generator",
model=model,
knowledge=knowledge_base,
description="解决方案专家",
instructions=[
"基于问题分类和知识库，生成解决方案",
"提供步骤化的操作指南",
"包含相关的文档链接"
]
)
# 6. 创建智能客服Workflow
support_workflow = Workflow(
name="Intelligent Customer Support",
description="基于混合内存的智能客服系统",
session_id="user_12345", # 用户会话ID
db=SqliteDb(db_file="./support_sessions.db"),
steps=[
Step(
name="classify",
agent=classifier_agent,
description="分类用户问题"
),
Step(
name="retrieve_context",
agent=context_aware_agent,
description="检索上下文和知识"
),
Step(
name="generate_solution",
agent=solution_agent,
description="生成解决方案"
),
],
stream=True,
)
# 7. 模拟多轮对话
if __name__ == "__main__":
# 第一轮对话
print("=== 第一轮对话 ===")
support_workflow.print_response(
"我的账户无法登录，显示密码错误",
markdown=True
)
# 第二轮对话（利用短时记忆的上下文）
print("\n=== 第二轮对话 ===")
support_workflow.print_response(
"我已经重置了密码，但还是不行", # Agent会记住之前的问题
markdown=True
)
# 第三轮对话
print("\n=== 第三轮对话 ===")
support_workflow.print_response(
"谢谢，现在可以登录了。另外，我想了解一下VIP会员的权益",
markdown=True
)
混合内存优势：
┌──────────────────────────────────────────┐
│ Mixed Memory Architecture │
├──────────────────┬───────────────────────┤
│ Short-Term │ Long-Term │
│ (Redis) │ (Qdrant) │
├──────────────────┼───────────────────────┤
│ • 会话上下文 │ • 产品知识库 │
│ • 用户偏好 │ • FAQ文档 │
│ • 对话历史 │ • 操作指南 │
│ • TTL=1小时 │ • 永久存储 │
│ • 快速访问 │ • 语义检索 │
└──────────────────┴───────────────────────┘
↓
Context-Aware Response
五、实战案例
5.1 案例一：智能内容创作平台
这个案例展示如何构建一个完整的内容创作平台，包含缓存、重试、质量控制等生产级特性。
"""
实战案例1：专业技术文章生成系统
功能：
- 缓存检查（避免重复生成）
- 主题研究（Web搜索 + 网页抓取）
- 大纲生成
- 分段写作（可重试）
- 编辑润色
- 质量评估
"""
from agno.agent import Agent
from agno.models.deepseek import DeepSeek
from agno.models.openrouter import OpenRouter # 使用OpenRouter支持多模型
from agno.db.sqlite import SqliteDb
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.workflow import Workflow
from agno.workflow.step import StepOutput
from dotenv import load_dotenv
from pydantic import BaseModel, Field
from typing import List, Optional
from textwrap import dedent
import logging
import os
# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
load_dotenv()
# === 数据模型定义 ===
class ResearchFinding(BaseModel):
"""研究发现"""
url: str = Field(..., description="信息源URL")
summary: str = Field(..., description="关键信息摘要")
class ResearchSummary(BaseModel):
"""研究总结"""
key_findings: List[ResearchFinding] = Field(..., description="关键发现列表")
overall_summary: str = Field(..., description="总体概述")
class ArticleOutline(BaseModel):
"""文章大纲"""
title: str = Field(..., description="文章标题（吸引初学者）")
sections: List[str] = Field(..., description="章节标题列表")
seo_keywords: List[str] = Field(default_factory=list, description="SEO关键词")
class SectionDraft(BaseModel):
"""章节草稿"""
section_title: str = Field(..., description="章节标题")
content: str = Field(..., description="Markdown格式的章节内容")
class QualityScore(BaseModel):
"""质量评分"""
score: int = Field(..., description="质量分数(0-100)", ge=0, le=100)
strengths: List[str] = Field(..., description="优点列表")
improvements: List[str] = Field(..., description="改进建议")
# === Workflow定义 ===
class TechnicalArticleWorkflow(Workflow):
"""
技术文章生成工作流
"""
description: str = "专业技术文章自动生成系统"
# 定义工作流中的Agent
researcher: Agent
outliner: Agent
writer: Agent
editor: Agent
quality_checker: Agent
def __init__(
self,
api_key: str,
base_url: str = "https://api.deepseek.com",
model_id: str = "deepseek-chat",
session_id: Optional[str] = None,
storage: Optional[SqliteDb] = None,
debug_mode: bool = False,
max_writer_retries: int = 2,
):
"""
初始化工作流
Args:
api_key: OpenRouter API密钥
model_id: 使用的模型ID
session_id: 会话ID（用于缓存）
storage: 存储后端
debug_mode: 调试模式
max_writer_retries: 写作步骤最大重试次数
"""
if not api_key:
raise ValueError("API Key is required")
# 初始化父类
super().__init__(
session_id=session_id,
db=storage or SqliteDb(
session_table="article_workflows",
db_file="./data/workflows.db"
),
debug_mode=debug_mode
)
self.max_writer_retries = max_writer_retries
# 通用模型配置
common_model_args = {
"id": model_id,
"api_key": api_key,
"base_url": base_url,
"max_tokens": 3000
}
# === 初始化各个Agent ===
# 1. 研究员Agent
self.researcher = Agent(
name="TechResearcher",
model=OpenRouter(**common_model_args),
tools=[
DuckDuckGoTools(enable_search=True, enable_news=True),
],
description="技术研究专家，擅长收集和综合信息",
instructions=dedent("""
你的任务是深入研究给定的技术主题：
1. 使用搜索工具查找最新、最权威的信息源
2. 访问并抓取关键网页内容
3. 提取核心技术概念、应用场景、最佳实践
4. 总结3-5个关键发现，每个都附上信息源URL
5. 提供一个全面的概述
注意：优先选择官方文档、技术博客、GitHub仓库等可信来源
"""),
output_schema=ResearchSummary,
use_json_mode=True,
add_history_to_context=False, # 不添加历史消息（每次独立研究）
exponential_backoff=True, # 启用指数退避重试
)
# 2. 大纲生成Agent
self.outliner = Agent(
name="OutlineGenerator",
model=OpenRouter(**common_model_args),
description="文章结构设计专家",
instructions=dedent("""
基于研究摘要，创建一个结构清晰的技术文章大纲：
1. 设计一个吸引读者的标题（面向初学者和中级开发者）
2. 规划5-7个逻辑递进的章节
3. 确保涵盖：引言、核心概念、实践应用、最佳实践、总结
4. 提取5-10个SEO关键词
大纲应该层次分明，易于理解
"""),
output_schema=ArticleOutline,
use_json_mode=True,
exponential_backoff=True,
)
# 3. 写作Agent
self.writer = Agent(
name="TechnicalWriter",
model=OpenRouter(**common_model_args),
description="技术写作专家",
instructions=dedent("""
撰写高质量的技术文章章节：
1. 使用清晰、专业但易懂的语言
2. 包含代码示例（如果相关）
3. 添加实际应用场景和案例
4. 使用Markdown格式（代码块、标题、列表等）
5. 每个章节300-500字
6. 确保内容准确、逻辑清晰
目标读者：有一定编程基础的开发者
"""),
markdown=True,
exponential_backoff=True,
)
# 4. 编辑Agent
self.editor = Agent(
name="Editor",
model=OpenRouter(**common_model_args),
description="专业编辑，负责润色和优化",
instructions=dedent("""
审查并优化整篇技术文章：
1. 检查语法、拼写、标点
2. 确保全文逻辑连贯、过渡自然
3. 统一术语和风格
4. 优化代码示例的可读性
5. 增强可读性（添加小标题、重点标记等）
6. 保持技术准确性
输出完整的、可发布的Markdown文章
"""),
markdown=True,
exponential_backoff=True,
)
# 5. 质量检查Agent
self.quality_checker = Agent(
name="QualityChecker",
model=OpenRouter(**common_model_args),
description="文章质量评估专家",
instructions=dedent("""
评估技术文章的质量：
1. 技术准确性 (0-25分)
2. 可读性和清晰度 (0-25分)
3. 实用性和深度 (0-25分)
4. 结构和完整性 (0-25分)
总分0-100，列出优点和改进建议
"""),
output_schema=QualityScore,
use_json_mode=True,
)
def run(self, topic: str):
"""
执行文章生成工作流
Args:
topic: 文章主题
Yields:
StepOutput: 工作流执行的响应流
"""
logger.info(f"启动技术文章生成工作流: {topic}")
# === 步骤1: 缓存检查 ===
cached_article = self.session_state.get("articles", {}).get(topic) if self.session_state else None
if cached_article:
logger.info(f"命中缓存: {topic}")
yield StepOutput(content=f"# [缓存] {topic}\n\n{cached_article}")
return
# === 步骤2: 主题研究 ===
logger.info("步骤1/5: 主题研究")
yield StepOutput(content="🔍 正在研究主题...")
research_response = self.researcher.run(topic)
research_summary: ResearchSummary = research_response.content
logger.info(f"研究完成，发现 {len(research_summary.key_findings)} 个关键点")
yield StepOutput(content=f"✅ 研究完成 ({len(research_summary.key_findings)}个关键发现)")
# === 步骤3: 生成大纲 ===
logger.info("步骤2/5: 生成大纲")
yield StepOutput(content="📝 正在生成文章大纲...")
outline_prompt = f"主题: {topic}\n\n研究概述:\n{research_summary.overall_summary}"
outline_response = self.outliner.run(outline_prompt)
article_outline: ArticleOutline = outline_response.content
logger.info(f"大纲生成完成: {article_outline.title}")
yield StepOutput(
content=f"✅ 大纲完成: {article_outline.title}\n章节数: {len(article_outline.sections)}"
)
# === 步骤4: 撰写各章节 ===
logger.info("步骤3/5: 撰写文章")
yield StepOutput(content=f"✍️ 正在撰写 {len(article_outline.sections)} 个章节...")
full_article = f"# {article_outline.title}\n\n"
full_article += f"> **关键词**: {', '.join(article_outline.seo_keywords)}\n\n"
for idx, section_title in enumerate(article_outline.sections, 1):
logger.info(f" 撰写章节 {idx}/{len(article_outline.sections)}: {section_title}")
writer_prompt = dedent(f"""
文章主题: {topic}
文章标题: {article_outline.title}
当前章节: {section_title}
研究背景:
{research_summary.overall_summary}
请撰写这个章节的内容。
""")
# 支持重试机制
retry_count = 0
section_draft = None
while retry_count <= self.max_writer_retries:
try:
section_response = self.writer.run(writer_prompt)
section_draft = section_response.content
break
except Exception as e:
retry_count += 1
if retry_count > self.max_writer_retries:
logger.error(f"章节撰写失败: {section_title}, 错误: {e}")
section_draft = SectionDraft(
section_title=section_title,
content="*（该章节生成失败，请稍后重试）*"
)
else:
logger.warning(f"章节撰写重试 {retry_count}/{self.max_writer_retries}")
full_article = section_draft if isinstance(section_title,
str) else f"## {section_draft.section_title} \n {section_draft.content}"
yield StepOutput(content=f" ✅ 完成章节: {section_title}")
# === 步骤5: 编辑润色 ===
logger.info("步骤4/5: 编辑润色")
yield StepOutput(content="🎨 正在编辑和润色文章...")
edited_response = self.editor.run(full_article)
edited_article = edited_response.content
yield StepOutput(content="✅ 编辑完成")
# === 步骤6: 质量检查 ===
logger.info("步骤5/5: 质量检查")
yield StepOutput(content="🔍 正在进行质量检查...")
quality_response = self.quality_checker.run(edited_article)
quality_score: QualityScore = quality_response.content
logger.info(f"质量评分: {quality_score.score}/100")
# === 缓存结果 ===
if self.session_state:
self.session_state.setdefault("articles", {})[topic] = edited_article
# === 返回最终结果 ===
final_output = f"{edited_article}\n\n---\n\n"
final_output += f"**质量评分**: {quality_score.score}/100\n\n"
final_output += f"**优点**: {', '.join(quality_score.strengths)}\n\n"
if quality_score.improvements:
final_output += f"**改进建议**: {', '.join(quality_score.improvements)}\n"
yield StepOutput(content=final_output)
# === 使用示例 ===
if __name__ == "__main__":
# 从环境变量获取API密钥
OPENROUTER_API_KEY = os.getenv("QWEN_API_KEY")
OPENROUTER_MODEL_ID = "qwen3-max"
OPENROUTER_BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1"
if not OPENROUTER_API_KEY:
print("请设置模型API-KEY环境变量")
exit(1)
# 创建工作流实例
article_workflow = TechnicalArticleWorkflow(
api_key=OPENROUTER_API_KEY,
base_url=OPENROUTER_BASE_URL,
model_id=OPENROUTER_MODEL_ID,
session_id="demo_session", # 使用固定会话ID以启用缓存
debug_mode=True,
)
# 生成文章
topics = [
"Kubernetes容器编排入门指南",
"Python异步编程完全指南",
]
for topic in topics:
print(f"\n{'=' * 70}")
print(f"生成文章: {topic}")
print('=' * 70)
# 流式输出结果
for response in article_workflow.run(topic):
if response.content:
print(response.content)
print("\n")
案例亮点：
-
✅ 生产级特性
- 缓存机制（避免重复生成）
- 重试机制（处理临时失败）
- 结构化数据（Pydantic模型）
- 持久化存储（SQLite）
-
✅ 完整的工作流程
- 研究 → 大纲 → 写作 → 编辑 → 质量检查
-
✅ 质量控制
- 质量评分系统
- 优点和改进建议
-
✅ 用户体验
- 流式进度反馈
- 清晰的日志输出
5.2 案例二：金融分析决策系统
这个案例展示如何构建一个复杂的金融分析系统，结合并行处理和条件分支。
"""
实战案例2：智能金融分析决策系统
功能：
- 市场数据采集
- 并行多维度分析（基本面、技术面、情绪、风险）
- 条件路由（根据风险等级选择策略）
- 综合决策报告
"""
from agno.agent import Agent
from agno.models.openrouter import OpenRouter
from agno.tools.yfinance import YFinanceTools
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.workflow import Workflow, Parallel, Router, Step, StepInput
from dotenv import load_dotenv
from pydantic import BaseModel, Field
from typing import List, Literal
from enum import Enum
import os
# 加载环境变量
load_dotenv()
# === 数据模型 ===
class RiskLevel(str, Enum):
"""风险等级"""
LOW = "低风险"
MEDIUM = "中风险"
HIGH = "高风险"
class AnalysisResult(BaseModel):
"""分析结果基类"""
analysis_type: str = Field(..., description="分析类型")
summary: str = Field(..., description="分析摘要")
score: float = Field(..., description="评分(0-100)", ge=0, le=100)
key_points: List[str] = Field(..., description="关键要点")
class FundamentalAnalysis(AnalysisResult):
"""基本面分析"""
pe_ratio: float = Field(..., description="市盈率")
revenue_growth: float = Field(..., description="营收增长率(%)")
class TechnicalAnalysis(AnalysisResult):
"""技术分析"""
trend: Literal["上升", "下降", "震荡"] = Field(..., description="趋势")
support_level: float = Field(..., description="支撑位")
resistance_level: float = Field(..., description="阻力位")
class SentimentAnalysis(AnalysisResult):
"""情绪分析"""
overall_sentiment: Literal["积极", "中性", "消极"] = Field(..., description="整体情绪")
news_count: int = Field(..., description="新闻数量")
class RiskAssessment(AnalysisResult):
"""风险评估"""
risk_level: RiskLevel = Field(..., description="风险等级")
risk_factors: List[str] = Field(..., description="风险因素")
class InvestmentRecommendation(BaseModel):
"""投资建议"""
action: Literal["强烈买入", "买入", "持有", "卖出", "强烈卖出"] = Field(..., description="操作建议")
confidence: float = Field(..., description="置信度(0-100)", ge=0, le=100)
target_price: float = Field(..., description="目标价格")
reasoning: str = Field(..., description="推理依据")
risk_warning: str = Field(..., description="风险提示")
# === 获取模型配置 ===
API_KEY = os.getenv("QWEN_API_KEY")
BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1"
MODEL_ID = "qwen-turbo"
if not API_KEY:
raise ValueError("请设置 QWEN_API_KEY 环境变量")
# 通用模型配置
common_model = OpenRouter(
id=MODEL_ID,
api_key=API_KEY,
base_url=BASE_URL,
max_tokens=2000
)
# === Agent定义 ===
# 1. 基本面分析Agent
fundamental_analyst = Agent(
name="Fundamental Analyst",
model=common_model,
tools=[YFinanceTools(
company_info=True,
analyst_recommendation=True,
company_news=True
)],
description="基本面分析专家",
instructions=[
"分析公司的财务状况和业务模式",
"评估估值水平（PE、PB等）",
"分析营收和利润增长趋势",
"提供基本面评分(0-100)"
],
output_schema=FundamentalAnalysis,
use_json_mode=True,
read_tool_call_history=True,
)
# 2. 技术分析Agent
technical_analyst = Agent(
name="Technical Analyst",
model=common_model,
tools=[YFinanceTools(
stock_price=True,
technical_indicators=True
)],
description="技术分析专家",
instructions=[
"分析价格走势和技术形态",
"识别关键支撑位和阻力位",
"评估技术指标信号（MA、RSI、MACD等）",
"判断当前趋势",
"提供技术面评分(0-100)"
],
output_schema=TechnicalAnalysis,
use_json_mode=True,
read_tool_call_history=True,
)
# 3. 情绪分析Agent
sentiment_analyst = Agent(
name="Sentiment Analyst",
model=common_model,
tools=[DuckDuckGoTools(enable_news=True)],
description="市场情绪分析专家",
instructions=[
"收集最新的相关新闻",
"分析新闻的情绪倾向",
"评估市场整体情绪",
"识别重大事件影响",
"提供情绪评分(0-100)"
],
output_schema=SentimentAnalysis,
use_json_mode=True,
read_tool_call_history=True,
)
# 4. 风险评估Agent
risk_analyst = Agent(
name="Risk Analyst",
model=common_model,
description="风险评估专家",
instructions=[
"识别潜在风险因素（市场风险、行业风险、公司风险）",
"评估风险等级（低/中/高）",
"提供风险控制建议",
"量化风险评分(0-100，越高越风险)"
],
output_schema=RiskAssessment,
use_json_mode=True,
)
# 5. 保守策略Agent
conservative_advisor = Agent(
name="Conservative Advisor",
model=common_model,
description="保守投资顾问",
instructions=[
"基于分析结果，提供保守的投资建议",
"优先考虑资本保值",
"设置较低的目标收益",
"强调风险控制"
],
output_schema=InvestmentRecommendation,
use_json_mode=True,
)
# 6. 积极策略Agent
aggressive_advisor = Agent(
name="Aggressive Advisor",
model=common_model,
description="积极投资顾问",
instructions=[
"基于分析结果，提供积极的投资建议",
"追求更高的收益机会",
"可承受中等风险",
"识别成长潜力"
],
output_schema=InvestmentRecommendation,
use_json_mode=True,
)
# 7. 平衡策略Agent
balanced_advisor = Agent(
name="Balanced Advisor",
model=common_model,
description="平衡投资顾问",
instructions=[
"基于分析结果，提供平衡的投资建议",
"平衡风险和收益",
"综合考虑多个维度",
"提供中性建议"
],
output_schema=InvestmentRecommendation,
use_json_mode=True,
)
# === 路由逻辑 ===
conservative = Step(
name="conservative_advice",
agent=conservative_advisor,
description="保守投资策略"
)
aggressive = Step(
name="aggressive_advice",
agent=aggressive_advisor,
description="积极投资策略"
)
balanced = Step(
name="balanced_advice",
agent=balanced_advisor,
description="平衡投资策略"
)
def risk_based_router(step_input: StepInput) -> List[Step]:
"""
根据风险评估结果路由到不同的投资顾问
Args:
step_input: 并行分析步骤的输出
Returns:
str: 路由目标
"""
# 提取风险评估结果
content = step_input.input.lower()
if "高风险" in content or "high" in content:
return [conservative] # 高风险 → 保守策略
elif "低风险" in content or "low" in content:
return [aggressive] # 低风险 → 积极策略
else:
return [balanced] # 中等风险 → 平衡策略
# === Workflow定义 ===
financial_analysis_workflow = Workflow(
name="Intelligent Financial Analysis System",
description="智能金融分析决策系统",
steps=[
# 步骤1: 并行多维度分析
Parallel(
[
Step(
name="fundamental",
agent=fundamental_analyst,
description="基本面分析"
),
Step(
name="technical",
agent=technical_analyst,
description="技术分析"
),
Step(
name="sentiment",
agent=sentiment_analyst,
description="情绪分析"
),
Step(
name="risk",
agent=risk_analyst,
description="风险评估"
),
],
name="multi_dimensional_analysis",
),
# 步骤2: 基于风险等级的条件路由
Router(
name="strategy_router",
selector=risk_based_router,
choices=[conservative, aggressive, balanced]
),
],
stream_intermediate_steps=True,
debug_mode=True,
)
# === 使用示例 ===
if __name__ == "__main__":
import asyncio
from datetime import datetime
# 测试股票列表
stocks = ["AAPL", "TSLA", "NVDA"]
async def analyze_stock(symbol: str):
"""异步分析单个股票"""
print(f"\n{'=' * 70}")
print(f"📊 分析股票: {symbol}")
print(f"⏰ 时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
print('=' * 70)
query = f"分析 {symbol} 股票，提供投资建议"
# 异步执行工作流
result = await financial_analysis_workflow.arun(query)
print(f"\n✅ {symbol} 分析完成")
print(result.content)
return result
# 并行分析多个股票
async def analyze_multiple_stocks():
tasks = [analyze_stock(symbol) for symbol in stocks]
results = await asyncio.gather(*tasks)
return results
# 运行分析
print("🚀 启动智能金融分析系统")
asyncio.run(analyze_multiple_stocks())
执行流程图：
输入: 分析AAPL股票
↓
┌─────────────────────────────────────────────┐
│ Parallel Multi-Dimensional Analysis │
├──────────┬──────────┬──────────┬────────────┤
│ 基本面 │ 技术面 │ 情绪面 │ 风险评估 │
│ Analyst │ Analyst │ Analyst │ Analyst │
│ │ │ │ │
│ PE: 28 │ 趋势:上升 │ 积极情绪 │ 风险:中等 │
│ 营收↑15% │ MA支撑 │ 10条新闻 │ 评分:45 │
│ 评分:75 │ 评分:68 │ 评分:72 │ │
└──────────┴──────────┴──────────┴────────────┘
↓
[Router] 风险等级: 中等 → 路由到 balanced_advisor
↓
[Balanced Advisor] → 生成投资建议
↓
输出:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
💡 投资建议: 买入
📈 目标价格: $185.00
✨ 置信度: 75%
📋 推理依据:
- 基本面评分75，财务状况良好
- 技术面呈上升趋势，有支撑
- 市场情绪积极
- 风险可控（中等）
⚠️ 风险提示: 注意市场波动，建议分批建仓
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
案例亮点：
- ✅ 并行处理：4个维度同时分析，大幅提升效率
- ✅ 智能路由：根据风险等级自动选择合适的策略
- ✅ 结构化输出：所有结果都是强类型的Pydantic模型
- ✅ 真实工具集成：使用YFinance获取真实金融数据
六、Team vs Workflow：如何选择？
6.1 核心差异对比
| 维度 | Team (Level 4) | Workflow (Level 5) |
|---|---|---|
| 架构特点 | 动态协作 | 确定性编排 |
| 执行模式 | Agent自主决策 | 显式定义流程 |
| 状态管理 | 无状态/轻量状态 | 有状态/持久化 |
| 可预测性 | 低-中 | 高 |
| 灵活性 | 高 | 中 |
| 适用场景 | 探索性任务、动态问题 | 结构化流程、生产系统 |
| 控制粒度 | 粗粒度（团队级） | 细粒度（步骤级） |
| 审计能力 | 弱 | 强 |
| 学习曲线 | 平缓 | 陡峭 |
6.2 适用场景分析
6.2.1 使用Team的场景
✅ 适合Team：
-
探索性研究任务
# 例：多领域研究团队 research_team = Team( members=[web_researcher, academic_researcher, industry_expert], instructions=["从不同角度研究这个新兴技术"] ) -
动态问题解决
# 例：客服团队（问题类型未知） support_team = Team( respond_directly=True, members=[billing_agent, technical_agent, account_agent], instructions=["根据问题类型自动路由"] ) -
需要Agent间自主协商
# 例：头脑风暴团队 brainstorm_team = Team( delegate_task_to_all_members=True, members=[creative_agent, critic_agent, optimizer_agent], instructions=["共同优化创意方案"] )
❌ 不适合Team：
- 需要严格的执行顺序
- 需要持久化中间状态
- 需要复杂的流程控制（循环、条件分支）
- 生产环境中需要可预测的结果
6.2.2 使用Workflow的场景
✅ 适合Workflow：
-
内容生产流水线
# 明确的执行顺序：研究 → 大纲 → 写作 → 编辑 → 发布 content_workflow = Workflow( steps=[research, outline, write, edit, publish] ) -
数据处理管道
# ETL流程：提取 → 转换 → 加载 etl_workflow = Workflow( steps=[extract, transform, load] ) -
审批流程
# 多级审批：提交 → 初审 → 复审 → 最终审批 approval_workflow = Workflow( steps=[ submit, Condition(steps=[initial_review], evaluator=needs_review), Condition(steps=[secondary_review], evaluator=needs_escalation), final_approval ] ) -
复杂业务逻辑
# 包含并行、条件、循环的复杂流程 complex_workflow = Workflow( steps=[ data_collection, Parallel([analysis_a, analysis_b, analysis_c]), Router(decision_router, routes={...}), Loop([optimize, evaluate], condition=not_satisfied) ] )
❌ 不适合Workflow：
- 任务路径高度不确定
- 需要Agent高度灵活决策
- 简单的问答式交互
6.3 混合使用：最佳实践
在实际应用中，Team和Workflow可以互相嵌套，发挥各自优势：
6.3.1 Workflow包含Team
"""
示例：Workflow中嵌入Team
场景：产品发布流程，其中"市场分析"步骤由Team协作完成
"""
# 定义分析Team
market_analysis_team = Team(
mode="collaborate",
members=[competitor_analyst, customer_analyst, trend_analyst],
description="市场分析团队"
)
# 嵌入到Workflow中
product_launch_workflow = Workflow(
name="Product Launch Pipeline",
steps=[
concept_design_agent, # Step 1: 概念设计
market_analysis_team, # Step 2: 团队协作的市场分析 ← Team
feature_refinement_agent, # Step 3: 功能优化
launch_plan_agent, # Step 4: 发布计划
]
)
优势：
- ✅ 大流程确定性（Workflow保证）
- ✅ 局部灵活性（Team提供）
- ✅ 最佳平衡
6.3.2 决策树指南
开始
↓
是否需要严格的执行顺序？
├─ 是 → Workflow
└─ 否
↓
是否需要持久化状态？
├─ 是 → Workflow
└─ 否
↓
是否需要复杂控制流（并行/条件/循环）？
├─ 是 → Workflow
└─ 否
↓
是否需要Agent自主决策？
├─ 是 → Team
└─ 否 → 单Agent可能足够
6.4 实际案例对比
案例1：新闻摘要生成
Team方式：
# 动态协作，Agent自主分工
news_summary_team = Team(
mode="collaborate",
members=[fetcher_agent, analyzer_agent, writer_agent],
instructions="协作生成新闻摘要"
)
# 优点：灵活、简单
# 缺点：每次执行流程可能不同
Workflow方式：
# 固定流程
news_summary_workflow = Workflow(
steps=[
fetcher_agent, # 1. 抓取新闻
analyzer_agent, # 2. 分析内容
writer_agent, # 3. 生成摘要
]
)
# 优点：可预测、可审计
# 缺点：相对不灵活
建议：如果是生产系统，选Workflow；如果是实验性功能，选Team。
案例2：客户支持系统
Team方式（推荐）：
# 客服团队：问题类型未知，需要动态路由
support_team = Team(
mode="route",
members=[billing_agent, tech_agent, account_agent],
)
# 优点：自动识别问题类型并路由
# 缺点：无状态，难以追踪多轮对话
Workflow方式：
# 如果需要严格的升级流程
support_workflow = Workflow(
steps=[
intake_agent, # 1. 问题登记
Router(...), # 2. 路由到专员
Condition(escalate, ...), # 3. 必要时升级
resolution_agent, # 4. 问题解决
satisfaction_survey, # 5. 满意度调查
]
)
# 优点：完整的流程控制和状态跟踪
# 缺点：设计复杂
建议：简单客服用Team；复杂工单系统用Workflow。
七、最佳实践
7.1 设计原则
7.1.1 单一职责原则
每个Agent和Step都应该有明确的单一职责：
# ❌ 错误：一个Agent做太多事情
jack_of_all_trades = Agent(
name="All-in-One",
tools=[WebSearch, Database, Email, FileSystem, ...], # 太多工具
instructions=[
"搜索信息",
"查询数据库",
"发送邮件",
"处理文件",
# ... 太多职责
]
)
# ✅ 正确：职责分离
searcher = Agent(
name="Searcher",
tools=[WebSearch],
instructions=["专注于网络信息搜索"]
)
db_agent = Agent(
name="DB Agent",
tools=[Database],
instructions=["专注于数据库查询"]
)
# 通过Workflow组合
workflow = Workflow(steps=[searcher, db_agent, ...])
7.1.2 明确的数据契约
使用Pydantic模型定义清晰的输入输出契约：
# ✅ 最佳实践：明确的数据模型
class ResearchInput(BaseModel):
topic: str = Field(..., min_length=5)
depth: int = Field(default=3, ge=1, le=5)
class ResearchOutput(BaseModel):
findings: List[Finding]
confidence: float = Field(..., ge=0, le=1)
researcher = Agent(
input_schema=ResearchInput,
response_model=ResearchOutput,
)
# 这样可以：
# 1. 编译时类型检查
# 2. 运行时自动验证
# 3. 生成API文档
7.1.3 幂等性设计
确保Workflow可以安全地重新执行：
class IdempotentWorkflow(Workflow):
def run(self, request_id: str, data: dict):
# ✅ 检查是否已处理
if self.session_state.get("processed_requests", set()).contains(request_id):
logger.info(f"请求 {request_id} 已处理，返回缓存结果")
return self.session_state[f"result_{request_id}"]
# 执行处理
result = self.process(data)
# ✅ 记录已处理
self.session_state.setdefault("processed_requests", set()).add(request_id)
self.session_state[f"result_{request_id}"] = result
return result
7.2 性能优化
7.2.1 合理使用缓存
class OptimizedWorkflow(Workflow):
def run(self, query: str):
# 1. 缓存昂贵的操作
cache_key = f"research_{hash(query)}"
if cached := self.session_state.get(cache_key):
return cached
# 2. 缓存中间结果
research_result = self.researcher.run(query)
self.session_state[cache_key] = research_result
# 3. 设置过期时间（如果使用Redis）
if isinstance(self.db, RedisDb):
self.db.set_ttl(cache_key, ttl=3600)
return research_result
7.2.2 并行化独立任务
# ❌ 低效：串行执行独立任务
workflow_slow = Workflow(
steps=[
data_source_a, # 10秒
data_source_b, # 10秒
data_source_c, # 10秒
]
)
# 总耗时：30秒
# ✅ 高效：并行执行
workflow_fast = Workflow(
steps=[
Parallel([
data_source_a,
data_source_b,
data_source_c,
]), # 总耗时：~10秒
aggregator,
]
)
7.2.3 选择合适的模型
# ✅ 根据任务复杂度选择模型
simple_classifier = Agent(
model=OpenAIChat(id="gpt-3.5-turbo"), # 便宜、快速
description="简单分类任务"
)
complex_reasoner = Agent(
model=OpenAIChat(id="gpt-4"), # 强大但昂贵
description="复杂推理任务"
)
workflow = Workflow(
steps=[
simple_classifier, # 用3.5处理简单任务
complex_reasoner, # 只在必要时使用4
]
)
7.3 错误处理
7.3.1 优雅降级
class ResilientWorkflow(Workflow):
def run(self, topic: str):
# 尝试主要数据源
try:
primary_result = self.primary_source.run(topic)
return primary_result
except Exception as e:
logger.warning(f"主数据源失败: {e}，切换到备用源")
# 降级到备用数据源
try:
backup_result = self.backup_source.run(topic)
return backup_result
except Exception as e2:
logger.error(f"备用源也失败: {e2}，使用缓存")
# 最后的降级：返回缓存或默认值
return self.session_state.get(
f"last_result_{topic}",
"暂时无法获取数据，请稍后重试"
)
7.3.2 重试机制
from tenacity import retry, stop_after_attempt, wait_exponential
class RetryWorkflow(Workflow):
@retry(
stop=stop_after_attempt(3),
wait=wait_exponential(multiplier=1, min=2, max=10)
)
def call_external_api(self, params):
"""自动重试的外部API调用"""
response = external_api.call(params)
return response
def run(self, query):
# 自动重试3次，指数退避
result = self.call_external_api(query)
return result
7.3.3 超时控制
import asyncio
class TimeoutWorkflow(Workflow):
async def run_with_timeout(self, query: str, timeout: int = 30):
"""带超时控制的执行"""
try:
result = await asyncio.wait_for(
self.arun(query),
timeout=timeout
)
return result
except asyncio.TimeoutError:
logger.error(f"工作流执行超时 ({timeout}秒)")
return "执行超时，请尝试简化查询或稍后重试"
7.4 监控与调试
7.4.1 启用详细日志
workflow = Workflow(
name="My Workflow",
debug_mode=True, # 启用调试模式
stream_intermediate_steps=True, # 流式输出中间步骤
store_events=True, # 存储事件
)
# 查看执行事件
for event in workflow.run_events:
print(f"{event.timestamp}: {event.event_type} - {event.content}")
7.4.2 性能指标收集
from datetime import datetime
class MonitoredWorkflow(Workflow):
def run(self, query: str):
start_time = datetime.now()
# 执行工作流
result = super().run(query)
# 记录指标
duration = (datetime.now() - start_time).total_seconds()
self.session_state.setdefault("metrics", []).append({
"query": query,
"duration": duration,
"timestamp": start_time.isoformat(),
"steps_count": len(self.steps),
})
logger.info(f"工作流执行完成，耗时: {duration:.2f}秒")
return result
7.4.3 集成可观测性平台
# 集成Atla等可观测性平台
from agno.integrations.atla import AtlaIntegration
workflow = Workflow(
name="Monitored Workflow",
telemetry=True, # 启用遥测
)
# Atla会自动跟踪：
# - 执行时间
# - 成功/失败率
# - 错误模式
# - 成本统计
7.5 安全最佳实践
7.5.1 API密钥管理
# ❌ 错误：硬编码密钥
model = OpenAIChat(id="gpt-4", api_key="sk-xxx...")
# ✅ 正确：使用环境变量
import os
from dotenv import load_dotenv
load_dotenv()
model = OpenAIChat(
id="gpt-4",
api_key=os.getenv("OPENAI_API_KEY")
)
# ✅ 更好：使用密钥管理服务
from agno.integrations.secrets import get_secret
model = OpenAIChat(
id="gpt-4",
api_key=get_secret("OPENAI_API_KEY")
)
7.5.2 输入验证和清洗
from pydantic import BaseModel, validator
class SafeInput(BaseModel):
query: str
@validator('query')
def validate_query(cls, v):
# 长度限制
if len(v) > 1000:
raise ValueError("查询长度不能超过1000字符")
# 内容过滤（防止注入攻击）
dangerous_patterns = ['<script>', 'DROP TABLE', 'eval(']
for pattern in dangerous_patterns:
if pattern.lower() in v.lower():
raise ValueError(f"查询包含不安全内容: {pattern}")
return v
workflow = Workflow(
input_schema=SafeInput, # 强制验证
...
)
7.5.3 访问控制
class SecureWorkflow(Workflow):
def run(self, query: str, user_id: str):
# 验证用户权限
if not self.has_permission(user_id, "execute_workflow"):
raise PermissionError(f"用户 {user_id} 无权限执行此工作流")
# 记录审计日志
self.audit_log(user_id, "workflow_executed", {"query": query})
# 执行工作流
return super().run(query)
八、总结与展望
8.1 核心要点回顾
通过本教程，我们系统学习了Agno Workflow工作流机制：
8.1.1 架构理解
- ✅ Workflow = Level 5：Agno最高级别的智能体架构
- ✅ 确定性编排：明确的步骤序列和数据流
- ✅ 有状态管理：持久化上下文，支持长运行流程
- ✅ 混合执行：无缝集成Agent、Team和Python函数
8.1.2 核心组件
| 组件 | 作用 | 关键特性 |
|---|---|---|
Workflow | 顶层编排器 | 会话管理、事件流、指标收集 |
Step | 执行单元 | 封装Agent/Team/Function |
Parallel | 并行处理 | 提升效率、资源利用 |
Condition | 条件分支 | 动态路由、灵活控制 |
Loop | 循环迭代 | 质量改进、优化流程 |
Router | 智能路由 | 基于规则的路径选择 |
8.1.3 最佳实践总结
-
设计原则
- 单一职责
- 明确的数据契约
- 幂等性设计
-
性能优化
- 合理缓存
- 并行化
- 模型选择
-
错误处理
- 优雅降级
- 重试机制
- 超时控制
-
安全实践
- 密钥管理
- 输入验证
- 访问控制
8.2 Team vs Workflow 选择指南
| 场景类型 | 推荐方案 | 理由 |
|---|---|---|
| 探索性研究 | Team | 需要灵活协作 |
| 生产流水线 | Workflow | 需要确定性和审计 |
| 简单客服 | Team | 动态路由足够 |
| 复杂审批流程 | Workflow | 需要严格控制流 |
| 数据处理管道 | Workflow | 明确的ETL步骤 |
| 头脑风暴 | Team | 需要自主协商 |
| 混合场景 | Workflow + Team | 结合两者优势 |
8.3 未来展望
Agno Workflow作为Level 5架构，代表了当前多Agent系统的最高形态，但技术仍在快速演进：
8.3.1 技术趋势
-
更智能的编排
- AI辅助的工作流设计
- 自动优化执行路径
- 自适应资源分配
-
更强大的状态管理
- 分布式状态同步
- 时间旅行调试
- 状态版本控制
-
更好的可观测性
- 实时性能分析
- 智能告警
- 自动故障排查
-
更广泛的集成
- 云原生部署
- 企业系统对接
- 多模态能力
8.3.2 应用前景
当前：结构化业务流程自动化
↓
近期：复杂决策系统
↓
中期：自主业务运营系统
↓
长期：通用人工智能助理
8.4 结语
Agno Workflow为我们提供了一个强大而灵活的框架，让我们能够构建生产级的多Agent智能系统。从简单的两步工作流到包含并行处理、条件分支、循环迭代的复杂编排，Workflow都能优雅地应对。
关键启示：
- 🎯 选择正确的工具：Team适合动态协作，Workflow适合确定性流程
- 🏗️ 从小处着手：先从简单的Workflow开始，逐步增加复杂性
- 📊 注重数据契约：使用Pydantic模型确保类型安全
- 🔄 持续优化：通过缓存、并行、重试等手段优化性能
- 🛡️ 安全第一：密钥管理、输入验证、访问控制不可少
- 📈 监控可观测：生产环境必须有完善的监控和日志
希望这份教程能够帮助你掌握Agno Workflow的核心概念和实践技巧，构建出真正有价值的AI应用！
