企业级、生产就绪的多智能体（Multi-Agent）编排框架

Swarms 官网   •   文档   •   Swarms 市场

功能特性

Swarms 提供了一个全面的企业级多智能体（Multi-Agent）基础设施平台，专为生产环境的大规模部署和与现有系统的无缝集成而设计。在此了解更多关于 Swarms 的功能特性

类别	功能特性	优势
企业级架构	• 生产就绪的基础设施 • 高可用性系统 • 模块化微服务设计 • 全面的可观测性（Observability） • 向后兼容性	• 99.9%+ 的正常运行时间保障 • 降低运维开销 • 无缝集成遗留系统 • 增强的系统监控能力 • 无风险迁移路径
多智能体编排	• 分层智能体集群（Hierarchical Agent Swarms） • 并行处理流水线 • 顺序工作流编排 • 基于图的智能体网络 • 动态智能体组合 • 智能体注册中心管理	• 复杂业务流程自动化 • 可扩展的任务分发 • 灵活的工作流适配 • 优化的资源利用率 • 集中式智能体治理 • 企业级智能体生命周期管理
企业集成能力	• 多模型提供商支持 • 自定义智能体开发框架 • 丰富的企用工具库 • 多种记忆系统（Memory Systems） • 向后兼容 LangChain、AutoGen、CrewAI • 标准化 API 接口	• 与供应商无关的架构 • 支持定制化解决方案开发 • 扩展功能集成 • 增强的知识管理 • 无缝框架迁移 • 降低集成复杂度
企业级可扩展性	• 并发多智能体处理 • 智能资源管理 • 负载均衡与自动扩缩容 • 水平扩展能力 • 性能优化 • 容量规划工具	• 高吞吐量处理 • 成本效益高的资源利用 • 按需弹性伸缩 • 线性性能扩展 • 优化的响应时间 • 可预测的增长规划
开发者体验	• 直观的企业级 API • 全面的文档 • 活跃的企业社区 • CLI 与 SDK 工具 • IDE 集成支持 • 代码生成模板	• 加速开发周期 • 降低学习曲线 • 专家社区支持 • 快速部署能力 • 提升开发者生产力 • 标准化的开发模式

支持的协议与集成

Swarms 无缝集成了行业标准协议和开放规范，为工具集成、支付处理、分布式智能体编排（Agent Orchestration）以及模型互操作性（Model Interoperability）解锁了强大能力。

协议	描述	使用场景	文档
MCP (Model Context Protocol)	一种标准化协议，允许 AI 智能体通过 MCP 服务器与外部工具和服务交互，支持动态工具发现与执行。	• 工具集成 • 多服务器连接 • 外部 API 访问 • 数据库连接	MCP 集成指南
X402	一种面向 API 端点的加密货币支付协议，支持按使用付费（pay-per-use）模式对智能体进行变现。	• 智能体变现 • 支付网关保护 • 加密货币支付 • 按使用付费服务	X402 快速入门
AOP (Agent Orchestration Protocol)	用于将智能体作为分布式服务部署和管理的框架，通过标准化协议实现智能体发现、管理和执行。	• 分布式智能体部署 • 智能体发现 • 服务编排 • 可扩展的多智能体系统	AOP 参考文档
Swarms Marketplace	一个用于发现和共享生产就绪型提示（prompts）、智能体和工具的平台，支持从市场自动加载提示，并可直接从代码中发布自己的提示。	• 提示发现与复用 • 一行代码加载提示 • 社区提示共享 • 提示变现	Marketplace 教程
Open Responses	基于 OpenAI Responses API 的开源规范和生态系统，提供跨提供商、可互操作的大语言模型（LLM）接口。它定义了统一的数据结构和工具，用于调用语言模型、流式输出结果以及构建智能体工作流，且不依赖于特定提供商。	• 统一的 LLM 接口 • 流式输出 • 多提供商编排 • 可互操作的智能体工作流	Open Responses 官网
Agent Skills	由 Anthropic 提出的一种轻量级、基于 Markdown 的格式，用于定义模块化、可复用的智能体能力。通过加载简单的 SKILL.md 文件即可实现智能体专业化，无需修改代码。	• 智能体专业化 • 可复用技能库 • 无代码智能体定制 • 兼容 Claude Code	Agent Skills 文档

安装

使用 pip

$ pip3 install -U swarms

使用 uv（推荐）

uv 是一个用 Rust 编写的快速 Python 包安装器和依赖解析器。

$ uv pip install swarms

使用 poetry

$ poetry add swarms

从源码安装

# 克隆仓库
$ git clone https://github.com/kyegomez/swarms.git
$ cd swarms
$ pip install -r requirements.txt

---

环境配置

在此了解更多关于环境配置的信息

OPENAI_API_KEY=""
WORKSPACE_DIR="agent_workspace"
ANTHROPIC_API_KEY=""
GROQ_API_KEY=""

你的第一个智能体（Agent）

智能体（Agent） 是 swarm 的基本构建单元——一个由大语言模型（LLM）+ 工具（Tools）+ 记忆（Memory）驱动的自主实体。了解更多

from swarms import Agent

# 初始化一个新智能体
agent = Agent(
    model_name="gpt-5.4", # 指定 LLM
    max_loops="auto",              # 设置交互次数
    interactive=True,         # 启用交互模式以获得实时反馈
)

# 让智能体执行任务
agent.run("使用多智能体系统的主要优势有哪些？")

你的第一个 Swarm：多智能体协作

Swarm 由多个协同工作的智能体组成。以下简单示例创建了一个包含两个智能体的工作流，用于研究并撰写一篇博客文章。了解更多关于 SequentialWorkflow

from swarms import Agent, SequentialWorkflow

# 智能体 1：研究员
researcher = Agent(
    agent_name="Researcher",
    system_prompt="你的任务是研究提供的主题并提供详细摘要。",
    model_name="gpt-5.4",
)

# 智能体 2：撰稿人
writer = Agent(
    agent_name="Writer",
    system_prompt="你的任务是根据研究摘要撰写一篇优美、引人入胜的博客文章。",
    model_name="gpt-5.4",
)

# 创建一个顺序工作流，研究员的输出将作为撰稿人的输入
workflow = SequentialWorkflow(agents=[researcher, writer])

# 在指定任务上运行工作流
final_post = workflow.run("人工智能的历史与未来")
print(final_post)

---

AutoSwarmBuilder：自主智能体生成

AutoSwarmBuilder 能根据你的任务描述自动生成专用智能体及其工作流。只需描述你的需求，它就会创建一个完整的多智能体系统，包含详细的提示词和最优的智能体配置。了解更多关于 AutoSwarmBuilder

from swarms.structs.auto_swarm_builder import AutoSwarmBuilder
import json

# 初始化 AutoSwarmBuilder
swarm = AutoSwarmBuilder(
    name="My Swarm",
    description="A swarm of agents",
    verbose=True,
    max_loops=1,
    return_agents=True,
    model_name="gpt-5.4",
)

让构建器自动创建智能体（agents）和工作流（workflows）

result = swarm.run(
    task="创建一个会计团队来分析加密货币交易，"
         "团队中必须包含 5 个智能体，且每个智能体的提示词（prompts）必须极其详尽。"
         "确保提示词极度详细、具体、冗长且全面。"
         "务必在提示词中包含任务的所有细节。"
)

# result 包含生成的智能体及其配置
print(json.dumps(result, indent=4))

AutoSwarmBuilder 提供以下功能：

• 自动智能体生成（Automatic Agent Generation）：根据任务需求创建专业化的智能体
• 智能提示工程（Intelligent Prompt Engineering）：为每个智能体生成全面、详细的提示词
• 最优工作流设计（Optimal Workflow Design）：确定最佳的智能体交互方式和工作流结构
• 生产就绪配置（Production-Ready Configurations）：返回可直接部署的完整配置智能体
• 灵活架构（Flexible Architecture）：支持多种 swarm 类型和智能体专业化方向

该功能非常适合快速原型开发、复杂任务分解，以及在无需手动配置的情况下创建专业化的智能体团队。

---

可用的多智能体架构（Multi-Agent Architectures）

swarms 提供了多种强大且预构建的多智能体架构，使您能够以不同方式编排智能体。为您的特定问题选择合适的结构，以构建高效可靠的生产系统。

架构（Architecture）	描述（Description）	适用场景（Best For）
SequentialWorkflow	智能体按线性链式顺序执行任务；前一个智能体的输出作为下一个智能体的输入。	分步处理流程，例如数据转换管道和报告生成。
ConcurrentWorkflow	智能体同时运行任务，以实现最高效率。	高吞吐量任务，例如批处理和并行数据分析。
AgentRearrange	动态映射智能体之间的复杂关系（例如 a -> b, c）。	灵活且自适应的工作流、任务分发和动态路由。
GraphWorkflow	将智能体作为有向无环图（DAG）中的节点进行编排。	具有复杂依赖关系的项目，例如软件构建。
MixtureOfAgents (MoA)	并行使用多个专家智能体，并综合其输出结果。	通过协作实现复杂问题求解和达到前沿性能。
GroupChat	智能体通过对话界面协作并做出决策。	实时协作决策、谈判和头脑风暴。
ForestSwarm	动态选择最适合当前任务的单个智能体或智能体树。	任务路由、基于专业能力的优化以及复杂决策树。
HierarchicalSwarm	由一个指挥者（director）智能体制定计划，并将任务分发给专业化的工作者（worker）智能体。	复杂项目管理、团队协调以及带反馈循环的层级化决策。
HeavySwarm	实现五阶段工作流，包含专业化智能体（研究、分析、备选方案、验证），用于全面任务分析。	复杂研究与分析任务、财务分析、战略规划和综合报告。
MAKER	将长期任务分解为多个步骤；每一步使用“first-to-ahead-by-k”投票机制，并对微智能体样本进行红标（red-flagging）检测（源自 Meyerson 等人，2025）。	极长或脆弱的流水线任务，要求在每个原子步骤上获得统计一致性与验证——而非人工设计的多智能体图。
SwarmRouter	通用编排器，提供统一接口以动态选择并运行任意类型的 swarm。	简化复杂工作流、在不同 swarm 策略间切换以及统一的多智能体管理。

---

SequentialWorkflow

SequentialWorkflow 以严格顺序执行任务，形成一个流水线，其中每个智能体都在前一个智能体工作的基础上继续处理。SequentialWorkflow 非常适合具有清晰、有序步骤的流程，确保依赖任务被正确处理。

from swarms import Agent, SequentialWorkflow

# 智能体 1：研究员（Researcher）
researcher = Agent(
    agent_name="Researcher",
    system_prompt="你的工作是研究提供的主题，并提供详细的摘要。",
    model_name="gpt-5.4",
)

# 智能体 2：写手（Writer）
writer = Agent(
    agent_name="Writer",
    system_prompt="你的工作是根据研究摘要撰写一篇优美、引人入胜的博客文章。",
    model_name="gpt-5.4",
)

# 创建一个顺序工作流，研究员的输出作为写手的输入
workflow = SequentialWorkflow(agents=[researcher, writer])

# 在任务上运行工作流
final_post = workflow.run("人工智能的历史与未来")
print(final_post)

---

ConcurrentWorkflow

ConcurrentWorkflow 同时运行多个智能体，允许任务并行执行。该架构大幅缩短了可并行任务的执行时间，非常适合高吞吐量场景，其中多个智能体同时处理相似任务。

from swarms import Agent, ConcurrentWorkflow

# 为不同分析任务创建智能体
market_analyst = Agent(
    agent_name="Market-Analyst",
    system_prompt="分析市场趋势，并就给定主题提供洞察。",
    model_name="gpt-5.4",
    max_loops=1,
)

financial_analyst = Agent(
    agent_name="Financial-Analyst", 
    system_prompt="就给定主题提供财务分析和建议。",
    model_name="gpt-5.4",
    max_loops=1,
)

risk_analyst = Agent(
    agent_name="Risk-Analyst",
    system_prompt="评估风险，并就给定主题提供风险管理策略。",
    model_name="gpt-5.4", 
    max_loops=1,
)

# 创建并发工作流
concurrent_workflow = ConcurrentWorkflow(
    agents=[market_analyst, financial_analyst, risk_analyst],
    max_loops=1,
)

# 同时在相同任务上运行所有智能体
results = concurrent_workflow.run(
    "分析人工智能技术对医疗行业潜在影响"
)

print(results)

AgentRearrange

受 einsum 启发，AgentRearrange 允许你使用简单的基于字符串的语法定义智能体（agent）之间复杂的非线性关系。了解更多。该架构非常适合编排动态工作流，其中智能体可以并行、顺序运行，或按你选择的任意组合方式协同工作。

from swarms import Agent, AgentRearrange

# 定义智能体
researcher = Agent(agent_name="researcher", model_name="gpt-5.4")
writer = Agent(agent_name="writer", model_name="gpt-5.4")
editor = Agent(agent_name="editor", model_name="gpt-5.4")

# 定义流程：researcher 同时将任务发送给 writer 和 editor
# 这是一个一对多的关系
flow = "researcher -> writer, editor"

# 创建重排系统
rearrange_system = AgentRearrange(
    agents=[researcher, writer, editor],
    flow=flow,
)

# 运行群组
outputs = rearrange_system.run("Analyze the impact of AI on modern cinema.")
print(outputs)

---

SwarmRouter：通用群组编排器

SwarmRouter 通过提供一个统一接口来运行任意类型的群组（swarm），从而简化复杂工作流的构建。你无需导入和管理不同的群组类，只需更改 swarm_type 参数即可动态选择所需类型。阅读完整文档

这使你的代码更简洁、更灵活，能够轻松在不同的多智能体协作策略之间切换。以下是一个完整示例，展示了如何定义智能体，然后使用 SwarmRouter 以不同的协作策略执行相同的任务。

from swarms import Agent
from swarms.structs.swarm_router import SwarmRouter, SwarmType

# 定义几个通用智能体
writer = Agent(agent_name="Writer", system_prompt="You are a creative writer.", model_name="gpt-5.4")
editor = Agent(agent_name="Editor", system_prompt="You are an expert editor for stories.", model_name="gpt-5.4")
reviewer = Agent(agent_name="Reviewer", system_prompt="You are a final reviewer who gives a score.", model_name="gpt-5.4")

# 所有示例使用相同的智能体和任务
agents = [writer, editor, reviewer]
task = "Write a short story about a robot who discovers music."

# --- 示例 1：SequentialWorkflow ---
# 智能体按链式顺序依次运行：Writer -> Editor -> Reviewer。
print("Running a Sequential Workflow...")
sequential_router = SwarmRouter(swarm_type=SwarmType.SequentialWorkflow, agents=agents)
sequential_output = sequential_router.run(task)
print(f"Final Sequential Output:\n{sequential_output}\n")

# --- 示例 2：ConcurrentWorkflow ---
# 所有智能体同时接收相同的初始任务并并行运行。
print("Running a Concurrent Workflow...")
concurrent_router = SwarmRouter(swarm_type=SwarmType.ConcurrentWorkflow, agents=agents)
concurrent_outputs = concurrent_router.run(task)
# 返回每个智能体输出的字典
for agent_name, output in concurrent_outputs.items():
    print(f"Output from {agent_name}:\n{output}\n")

# --- 示例 3：MixtureOfAgents ---
# 所有智能体并行运行，一个特殊的“聚合器”（aggregator）智能体综合它们的输出。
print("Running a Mixture of Agents Workflow...")
aggregator = Agent(
    agent_name="Aggregator",
    system_prompt="Combine the story, edits, and review into a final document.",
    model_name="gpt-5.4"
)
moa_router = SwarmRouter(
    swarm_type=SwarmType.MixtureOfAgents,
    agents=agents,
    aggregator_agent=aggregator, # MoA 需要一个聚合器
)
aggregated_output = moa_router.run(task)
print(f"Final Aggregated Output:\n{aggregated_output}\n")

SwarmRouter 是简化多智能体编排的强大工具。它提供了一种一致且灵活的方式来部署不同的协作策略，让你用更少的代码构建更复杂的应用程序。

---

MixtureOfAgents (MoA)

MixtureOfAgents 架构通过将任务并行分发给多个“专家”智能体来处理任务。这些智能体产生的多样化输出随后由一个聚合器（aggregator）智能体进行综合，生成最终的高质量结果。在此了解更多

from swarms import Agent, MixtureOfAgents

# 定义专家智能体
financial_analyst = Agent(agent_name="FinancialAnalyst", system_prompt="Analyze financial data.", model_name="gpt-5.4")
market_analyst = Agent(agent_name="MarketAnalyst", system_prompt="Analyze market trends.", model_name="gpt-5.4")
risk_analyst = Agent(agent_name="RiskAnalyst", system_prompt="Analyze investment risks.", model_name="gpt-5.4")

# 定义聚合器智能体
aggregator = Agent(
    agent_name="InvestmentAdvisor",
    system_prompt="Synthesize the financial, market, and risk analyses to provide a final investment recommendation.",
    model_name="gpt-5.4"
)

# 创建 MoA 群组
moa_swarm = MixtureOfAgents(
    agents=[financial_analyst, market_analyst, risk_analyst],
    aggregator_agent=aggregator,
)

# 运行群组
recommendation = moa_swarm.run("Should we invest in NVIDIA stock right now?")
print(recommendation)

---

GroupChat

GroupChat 创建一个多智能体对话环境，让多个智能体可以互动、讨论并协作解决问题。你可以定义发言顺序，也可以让顺序动态决定。该架构非常适合那些能从辩论和多视角推理中受益的任务，例如合同谈判、头脑风暴或复杂决策。

from swarms import Agent, GroupChat

定义用于辩论的智能体（Agent）

tech_optimist = Agent(agent_name="TechOptimist", system_prompt="论证人工智能对社会的益处。", model_name="gpt-5.4") tech_critic = Agent(agent_name="TechCritic", system_prompt="反对人工智能的无节制发展。", model_name="gpt-5.4")

创建群组聊天

chat = GroupChat( agents=[tech_optimist, tech_critic], max_loops=4, # 限制对话轮次 )

使用初始话题运行聊天

conversation_history = chat.run( "让我们讨论人工智能对社会的影响。" )

打印完整对话

for message in conversation_history: print(f"[{message['agent_name']}]: {message['content']}")

----

### HierarchicalSwarm（分层智能体群）

`HierarchicalSwarm` 实现了“主管-员工”（director-worker）模式：一个中央主管智能体（director agent）制定全面计划，并将具体任务分配给专业化的员工智能体（worker agents）。主管会评估结果，并可在反馈循环中发布新指令，非常适合复杂项目管理和团队协作场景。

```python
from swarms import Agent, HierarchicalSwarm

# 定义专业化员工智能体
content_strategist = Agent(
    agent_name="Content-Strategist",
    system_prompt="你是一位资深内容策略师。制定全面的内容策略、编辑日历和内容路线图。",
    model_name="gpt-5.4"
)

creative_director = Agent(
    agent_name="Creative-Director", 
    system_prompt="你是一位创意总监。制定引人注目的广告概念、视觉方向和营销活动创意。",
    model_name="gpt-5.4"
)

seo_specialist = Agent(
    agent_name="SEO-Specialist",
    system_prompt="你是一位 SEO 专家。进行关键词研究、内容优化，并制定自然增长策略。",
    model_name="gpt-5.4"
)

brand_strategist = Agent(
    agent_name="Brand-Strategist",
    system_prompt="你是一位品牌策略师。制定品牌定位、识别系统和市场差异化策略。",
    model_name="gpt-5.4"
)

# 创建带主管的分层智能体群
marketing_swarm = HierarchicalSwarm(
    name="Marketing-Team-Swarm",
    description="由主管协调的专业化营销团队",
    agents=[content_strategist, creative_director, seo_specialist, brand_strategist],
    max_loops=2,  # 允许反馈与优化
    verbose=True
)

# 在复杂的营销挑战上运行智能体群
result = marketing_swarm.run(
    "为一款新的 SaaS 产品发布制定全面的营销策略。"
    "该产品是一款面向中小企业的项目管理工具。"
    "协调团队共同制定内容策略、创意活动、SEO 优化和品牌定位，确保各部分协同一致。"
)

print(result)

HierarchicalSwarm 擅长以下方面：

• 复杂项目管理：将大型任务分解为专业化的子任务
• 团队协作：确保所有智能体朝着统一目标工作
• 质量控制：主管提供反馈和优化循环
• 可扩展的工作流：可根据需要轻松添加新的专业化智能体

---

HeavySwarm（重型智能体群）

HeavySwarm 实现了一个受 X.AI 的 Grok heavy 启发的五阶段工作流。它使用专业化智能体（研究、分析、替代方案、验证）通过智能问题生成、并行执行和综合分析，提供全面的任务分析。该架构在需要深入调研和多角度视角的复杂研究与分析任务中表现卓越。

from swarms import HeavySwarm

# Pip install swarms-tools
from swarms_tools import exa_search

swarm = HeavySwarm(
    name="Gold ETF Research Team",
    description="一支研究最佳黄金 ETF 的智能体团队",
    worker_model_name="claude-sonnet-4-20250514",
    show_dashboard=True,
    question_agent_model_name="gpt-4.1",
    loops_per_agent=1,
    agent_prints_on=False,
    worker_tools=[exa_search],
    random_loops_per_agent=True,
)

prompt = (
    "找出最佳的 3 只黄金 ETF。对于每只 ETF，请提供其股票代码、"
    "全称、当前价格、费用比率、资产管理规模，以及"
    "简要说明其为何被视为最佳之一。请以清晰、结构化的格式呈现信息，适合投资者阅读。从网络抓取数据。"
)

out = swarm.run(prompt)
print(out)

HeavySwarm 提供以下能力：

• 五阶段分析：问题生成、研究、分析、替代方案和验证

• 专业化智能体：每个阶段使用专门构建的智能体以获得最佳结果

• 全面覆盖：多角度视角与深入调研

• 实时仪表盘：可选的分析过程可视化

• 结构化输出：组织良好且可操作的结果

该架构非常适合财务分析、战略规划、研究报告，以及任何需要深入、多维度分析的任务。了解更多关于 HeavySwarm 的信息

---

MAKER

MAKER 实现了最大化智能体分解（maximal agentic decomposition），结合领先 k 票胜出机制（first-to-ahead-by-k voting）和红旗标记（red-flagging）：你提供 format_prompt、parse_response，以及可选的 validate_response / update_state，然后运行固定步数（或直到满足停止条件）。每一步都会启动一个专注的单次执行智能体（one-shot Agent）（或循环使用你提供的智能体池），直到某个解析后的答案领先其他答案达到 k 票。这与论文《Solving a Million-Step LLM Task with Zero Errors》中的错误纠正机制一致。完整文档

from swarms.structs.maker import MAKER

maker = MAKER(
    model_name="gpt-4.1-mini",
    system_prompt="你以每步一行清晰语句的方式完成任务。",
    k=3,
)

# 可选：为你的领域重写 format_prompt / parse_response / validate_response。
results = maker.run(
    task="列出类型化 API 的三个简洁优势，每步一条。",
    max_steps=3,
)
print(results)

当 k 值较大时，为降低延迟，可使用 run_parallel_voting，传入相同的 task 和 max_steps。

---

社交算法（Social Algorithms）

社交算法（Social Algorithms）提供了一个灵活的框架，用于定义智能体之间的自定义通信模式。你可以上传任意社交算法作为可调用对象（callable），定义通信顺序，使智能体能够以复杂的方式相互交流。了解更多关于社交算法的信息

from swarms import Agent, SocialAlgorithms

定义一个自定义的社交算法（social algorithm）

def research_analysis_synthesis_algorithm(agents, task, **kwargs): # Agent 1 对主题进行研究 research_result = agents[0].run(f"Research: {task}")

# Agent 2 分析研究结果
analysis = agents[1].run(f"Analyze this research: {research_result}")

# Agent 3 综合（synthesize）研究发现
synthesis = agents[2].run(f"Synthesize: {research_result} + {analysis}")

return {
    "research": research_result,
    "analysis": analysis,
    "synthesis": synthesis
}

创建智能体（Agent）

researcher = Agent( agent_name="Researcher", agent_description="Expert in comprehensive research and information gathering.", model_name="gpt-4.1" ) analyst = Agent( agent_name="Analyst", agent_description="Specialist in analyzing and interpreting data.", model_name="gpt-4.1" ) synthesizer = Agent( agent_name="Synthesizer", agent_description="Focused on synthesizing and integrating research insights.", model_name="gpt-4.1" )

创建社交算法

social_alg = SocialAlgorithms( name="Research-Analysis-Synthesis", agents=[researcher, analyst, synthesizer], social_algorithm=research_analysis_synthesis_algorithm, verbose=True )

运行算法

result = social_alg.run("The impact of AI on healthcare") print(result.final_outputs)

非常适合用于实现复杂的多智能体工作流、协作式问题求解以及自定义通信协议。

---

### 智能体编排协议（Agent Orchestration Protocol, AOP）

**智能体编排协议（AOP）** 是一个强大的框架，用于将智能体部署和管理为分布式服务。AOP 使智能体能够通过标准化协议被发现、管理和执行，非常适合构建可扩展的多智能体系统。[了解更多关于 AOP 的信息](https://docs.swarms.world/en/latest/swarms/structs/aop/)

```python
from swarms import Agent
from swarms.structs.aop import AOP

# 创建专用智能体
research_agent = Agent(
    agent_name="Research-Agent",
    agent_description="Expert in research and data collection",
    model_name="anthropic/claude-sonnet-4-5",
    max_loops=1,
    tags=["research", "data-collection", "analysis"],
    capabilities=["web-search", "data-gathering", "report-generation"],
    role="researcher"
)

analysis_agent = Agent(
    agent_name="Analysis-Agent", 
    agent_description="Expert in data analysis and insights",
    model_name="anthropic/claude-sonnet-4-5",
    max_loops=1,
    tags=["analysis", "data-processing", "insights"],
    capabilities=["statistical-analysis", "pattern-recognition", "visualization"],
    role="analyst"
)

# 创建 AOP 服务器
deployer = AOP(
    server_name="ResearchCluster",
    port=8000,
    verbose=True
)

# 将智能体添加到服务器
deployer.add_agent(
    agent=research_agent,
    tool_name="research_tool",
    tool_description="Research and data collection tool",
    timeout=30,
    max_retries=3
)

deployer.add_agent(
    agent=analysis_agent,
    tool_name="analysis_tool", 
    tool_description="Data analysis and insights tool",
    timeout=30,
    max_retries=3
)

# 列出所有已注册的智能体
print("Registered agents:", deployer.list_agents())

# 启动 AOP 服务器
deployer.run()

非常适合部署大规模多智能体系统。阅读完整的 AOP 文档

---

文档

文档位于：docs.swarms.world

---

示例

探索全面的示例和教程，学习如何高效使用 Swarms。

类别	示例	描述	链接
基础示例	Basic Agent（基础代理）	简单的代理设置与使用	Basic Agent
基础示例	Agent with Tools（带工具的代理）	使用各种工具的代理	Agent with Tools
基础示例	Agent with Structured Outputs（带结构化输出的代理）	处理结构化数据输出	Structured Outputs
基础示例	Agent with MCP Integration（带 MCP 集成的代理）	Model Context Protocol（模型上下文协议）集成	MCP Integration
基础示例	Vision Processing（视觉处理）	具备图像处理能力的代理	Vision Processing
基础示例	Multiple Images（多图像处理）	处理多张图像	Multiple Images
基础示例	Vision and Tools（视觉与工具结合）	将视觉能力与工具使用相结合	Vision and Tools
基础示例	Agent Streaming（代理流式输出）	实时代理输出流	Agent Streaming
基础示例	Agent Output Types（代理输出类型）	不同的输出格式与类型	Output Types
基础示例	Gradio Chat Interface（Gradio 聊天界面）	构建交互式聊天界面	Gradio UI
模型提供商	Model Providers Overview（模型提供商概览）	支持模型的完整指南	Model Providers
模型提供商	OpenAI	OpenAI 模型集成	OpenAI Examples
模型提供商	Anthropic	Claude 模型集成	Anthropic Examples
模型提供商	Groq	Groq 模型集成	Groq Examples
模型提供商	Cohere	Cohere 模型集成	Cohere Examples
模型提供商	DeepSeek	DeepSeek 模型集成	DeepSeek Examples
模型提供商	Ollama	本地 Ollama 模型集成	Ollama Examples
模型提供商	OpenRouter	OpenRouter 模型集成	OpenRouter Examples
模型提供商	XAI	XAI 模型集成	XAI Examples
模型提供商	Llama4	Llama4 模型集成	Llama4 Examples
多代理架构	HierarchicalSwarm（分层 Swarm）	分层代理编排	HierarchicalSwarm Examples
多代理架构	Hybrid Hierarchical-Cluster Swarm（混合分层-集群 Swarm）	高级分层模式	HHCS Examples
多代理架构	GroupChat（群聊）	多代理对话	GroupChat Examples
多代理架构	Sequential Workflow（顺序工作流）	逐步执行的代理工作流	Sequential Examples
多代理架构	SwarmRouter（Swarm 路由器）	通用 Swarm 编排	SwarmRouter Examples
多代理架构	MultiAgentRouter（多代理路由器）	最简路由器示例	MultiAgentRouter Examples
多代理架构	ConcurrentWorkflow（并发工作流）	并行代理执行	Concurrent Examples
多代理架构	Mixture of Agents（代理混合体，MoA）	专家代理协作	MoA Examples
多代理架构	Unique Swarms（独特 Swarm）	专用 Swarm 模式	Unique Swarms
多代理架构	Agents as Tools（将代理作为工具）	在工作流中将代理用作工具	Agents as Tools
多代理架构	Aggregate Responses（聚合响应）	合并多个代理的输出	Aggregate Examples
多代理架构	Interactive GroupChat（交互式群聊）	实时代理交互	Interactive GroupChat
部署方案	Agent Orchestration Protocol (AOP)（代理编排协议）	将代理作为分布式服务部署，支持发现与管理	AOP Reference
应用案例	Advanced Research System（高级研究系统）	受 Anthropic 研究方法启发的多代理研究系统	AdvancedResearch
应用案例	Hospital Simulation（医院模拟）	基于多代理架构的医疗模拟系统	HospitalSim
应用案例	Browser Agents（浏览器代理）	使用代理进行网页自动化	Browser Agents
应用案例	Medical Analysis（医疗分析）	医疗健康领域的应用	Medical Examples
应用案例	Finance Analysis（金融分析）	金融领域的应用	Finance Examples
实战手册与模板	Examples Overview（示例概览）	完整的示例目录	Examples Index
实战手册与模板	Cookbook Index（实战手册索引）	精选示例合集	Cookbook
实战手册与模板	Paper Implementations（论文实现）	研究论文的实现	Paper Implementations
实战手册与模板	Templates & Applications（模板与应用）	可复用的模板	Templates

为 Swarms 做出贡献

我们的使命是通过提供企业级、生产就绪（production-ready）的基础设施，加速向完全自主化的世界经济转型，从而实现数百万个自主智能体（autonomous agents）的无缝部署与编排。我们正在构建智能体经济的操作系统，而实现这一目标离不开您的帮助。

Swarms 由社区共建，也为社区服务。我们相信，协作开发是推动多智能体 AI（multi-agent AI）能力边界的关键。您的贡献不仅受到欢迎——更是我们使命中不可或缺的一部分。了解更多关于为何应为 Swarms 做贡献的原因

为什么要贡献？

加入我们，您将有机会：

• 站在智能体技术的前沿：塑造自主智能体技术的未来，帮助构建一个生产级、开源的框架。

• 加入充满活力的社区：与一群热情且不断壮大的智能体开发者、研究人员和爱好者协作。

• 产生切实影响：无论您是在修复 bug、添加新功能，还是改进文档，您的工作都将被用于真实世界的应用中。

• 学习与成长：获得先进 AI 概念的实践经验，并提升您的软件工程技能。

在我们的官方 贡献者指南 中，了解更多关于我们的使命以及成为贡献者的好处。

如何开始贡献

我们已尽可能简化贡献流程。以下是您可以参与的方式：

1. 寻找可处理的问题：最好的入门方式是访问我们的 贡献项目看板。寻找带有 good first issue 标签的问题——这些问题是专门为新贡献者挑选的。

2. 报告 Bug 或提出功能请求：有新想法或发现某些功能异常？我们非常期待您的反馈。请在 GitHub Issues 页面上 提交 Bug 报告或功能请求。

3. 了解我们的工作流程和标准：在提交您的工作前，请务必阅读完整的 贡献指南。为帮助维持代码质量，我们也鼓励您阅读 代码整洁性指南。

4. 加入讨论：如需参与路线图讨论或与其他开发者交流，请加入我们的 Discord 社区。

感谢我们的贡献者

感谢您为 Swarms 做出的贡献。您的工作备受赞赏并得到认可。

感谢我们的社区

我们对每一位支持 Swarms 的朋友都心怀感激！您的 Star、Fork 和贡献让这个项目每天变得更好。

---

加入 Swarms 社区

加入我们的智能体工程师与研究人员社区，获取技术支持、前沿动态，以及独家的世界级智能体工程洞见！

平台	描述	链接
文档	官方文档与指南	docs.swarms.world
博客	最新动态与技术文章	Medium
Discord	实时聊天与社区支持	加入 Discord
Twitter	最新新闻与公告	@swarms_corp
LinkedIn	职业网络与更新	The Swarm Corporation
YouTube	教程与演示	Swarms 频道
活动	参加我们的社区活动	立即报名
入门会议	与 Swarms 创始人兼首席维护者 Kye Gomez 一起完成入门	预约会议

---

引用

如果您在研究中使用了 swarms，请通过引用 CITATION.cff 中的元数据来引用本项目。

@misc{SWARMS_2022,
  author  = {Kye Gomez and Pliny and Zack Bradshaw and Ilumn and Harshal and the Swarms Community},
  title   = {{Swarms: Production-Grade Multi-Agent Infrastructure Platform}},
  year    = {2022},
  howpublished = {\url{https://github.com/kyegomez/swarms}},
  note    = {Documentation available at \url{https://docs.swarms.world}},
  version = {latest}

---

许可证

Swarms 采用 Apache License 2.0 许可证。在此了解更多

Swarms 快速上手指南

环境准备

• Python 版本：3.9 或更高版本
• 操作系统：Linux / macOS / Windows 均支持
• API 密钥（可选但推荐）：
  • OPENAI_API_KEY（使用 OpenAI 模型时必需）
  • ANTHROPIC_API_KEY（使用 Claude 模型时必需）
  • GROQ_API_KEY（使用 Groq 推理加速时可选）

建议设置以下环境变量（可通过 .env 文件或系统环境变量配置）：

OPENAI_API_KEY="your-api-key"
WORKSPACE_DIR="agent_workspace"
ANTHROPIC_API_KEY="your-anthropic-key"
GROQ_API_KEY="your-groq-key"

💡 国内用户建议使用 uv 安装工具以获得更快的依赖解析速度，并可配合清华源等镜像加速安装。

安装步骤

推荐方式（使用 uv）

$ uv pip install swarms

使用 pip（国内可加 -i https://pypi.tuna.tsinghua.edu.cn/simple 加速）

$ pip3 install -U swarms

使用 Poetry

$ poetry add swarms

从源码安装（适用于开发贡献）

$ git clone https://github.com/kyegomez/swarms.git
$ cd swarms
$ pip install -r requirements.txt

基本使用

创建单个智能体（Agent）

from swarms import Agent

# 初始化一个智能体
agent = Agent(
    model_name="gpt-4",        # 指定使用的 LLM（需有对应 API 密钥）
    max_loops="auto",          # 自动决定循环次数
    interactive=True,          # 启用交互模式
)

# 执行任务
result = agent.run("多智能体系统的主要优势是什么？")
print(result)

构建多智能体协作流程（Swarm）

from swarms import Agent, SequentialWorkflow

# 研究员智能体
researcher = Agent(
    agent_name="Researcher",
    system_prompt="你的任务是深入研究指定主题并提供详细摘要。",
    model_name="gpt-4",
)

# 写作智能体
writer = Agent(
    agent_name="Writer",
    system_prompt="你的任务是根据研究员提供的摘要，撰写一篇生动、专业的博客文章。",
    model_name="gpt-4",
)

# 创建顺序工作流
workflow = SequentialWorkflow(agents=[researcher, writer])

# 执行端到端任务
final_output = workflow.run("人工智能的历史与未来发展趋势")
print(final_output)

✅ 提示：首次运行时请确保已正确配置对应模型的 API 密钥。更多高级功能（如自动构建 Swarm、集成 MCP/X402 协议等）请参考 官方文档。