Swarms

https://docs.swarms.world
Admin
Swarms is an enterprise-grade, production-ready multi-agent orchestration framework designed for...
Tokens:479,100
Snippets:5,104
Trust Score:7.9
Update:4 months ago
Show doc for...
Tokens:
Raw
### Full Working Example Setup

Source: https://docs.swarms.world/api/forest-swarm

Imports necessary classes for setting up a ForestSwarm, including TreeAgent, Tree, and ForestSwarm itself. This is the starting point for creating swarm instances.

```python
from swarms.structs.tree_swarm import TreeAgent, Tree, ForestSwarm

```

--------------------------------

### Complete Tool Setup Example

Source: https://docs.swarms.world/api/tools

Demonstrates the setup for a complete tool, including defining a Pydantic model for input validation and using the `@tool` decorator.

```python
from swarms.tools import BaseTool, tool
from pydantic import BaseModel

# Define a Pydantic model
class MathInput(BaseModel):
    a: int
    b: int
    operation: str
```

--------------------------------

### Initialize HHCS with Legal Practice Example Setup

Source: https://docs.swarms.world/api/hhcs

This example demonstrates the setup for a full legal practice scenario using HHCS. It requires importing necessary classes like Agent and SwarmRouter.

```python
from swarms import Agent
from swarms.structs.hybrid_hiearchical_peer_swarm import (HybridHierarchicalClusterSwarm,)
from swarms.routers.swarm_router import SwarmRouter
```

--------------------------------

### ExpertPanelDiscussion Example Setup

Source: https://docs.swarms.world/api/orchestration-methods

Illustrates the initial setup for an expert panel discussion. This involves importing the necessary classes and creating agent instances for the experts.

```python
from swarms import Agent
from swarms.structs.multi_agent_debates import ExpertPanelDiscussion
```

--------------------------------

### Complete Swarm Example

Source: https://docs.swarms.world/quickstart

A consolidated example demonstrating the import, agent creation, workflow setup, and execution for a research and writing task.

```python
from swarms import Agent, SequentialWorkflow

# Agent 1: The Researcher
researcher = Agent(
    agent_name="Researcher",
    system_prompt="Your job is to research the provided topic and provide a detailed summary.",
    model_name="gpt-5.4",
)

# Agent 2: The Writer
writer = Agent(
    agent_name="Writer",
    system_prompt="Your job is to take the research summary and write a beautiful, engaging blog post about it.",
    model_name="gpt-5.4",
)

# Create a sequential workflow where the researcher's output feeds into the writer's input
workflow = SequentialWorkflow(agents=[researcher, writer])

# Run the workflow on a task
final_post = workflow.run(
    "The history and future of artificial intelligence"
)
print(final_post)
```

--------------------------------

### Install uv and Swarms using uv

Source: https://docs.swarms.world/community/development-setup

Install the uv package manager and then use it to install Swarms. uv is recommended for its speed.

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh

# Install swarms using uv
uv pip install swarms
```

--------------------------------

### Quick Start Gemini Agent

Source: https://docs.swarms.world/examples/model-providers/gemini

Initialize and run a basic Gemini agent. This example demonstrates the minimal setup required to interact with a Gemini model.

```python
from swarms import Agent

agent = Agent(
    agent_name="Gemini-Agent",
    model_name="gemini/gemini-2.5-pro",
    max_loops=1,
)

print(agent.run("Summarize the difference between RAG and fine-tuning in three paragraphs."))
```

--------------------------------

### Install swarms and swarms-tools

Source: https://docs.swarms.world/examples/applications/gold-etf-research

Install the necessary Python packages for using swarms and its tools. This is a prerequisite for running the example.

```bash
pip3 install -U swarms swarms-tools
```

--------------------------------

### Quick Start OpenAI Agent

Source: https://docs.swarms.world/examples/model-providers/openai

Initialize and run a basic OpenAI agent with a specified model and task. This demonstrates the minimal setup for agent execution.

```python
from swarms import Agent

agent = Agent(
    agent_name="OpenAI-Agent",
    model_name="gpt-4.1",
    max_loops=1,
)

print(agent.run("Summarize the architectural shift from monoliths to microservices in three paragraphs."))
```

--------------------------------

### Run Debate with Preset Agents

Source: https://docs.swarms.world/api/debate-with-judge

Quick start example demonstrating how to run the DebateWithJudge system using preset agents and a specific topic.

```python
from swarms import DebateWithJudge

# Create the DebateWithJudge system with preset agents
debate_system = DebateWithJudge(
    preset_agents=True,
    max_loops=3,
    model_name="gpt-5.4",
    output_type="str-all-except-first",
    verbose=True,
)

# Define the debate topic
topic = (
    "Should artificial intelligence be regulated by governments? "
    "Discuss the balance between innovation and safety."
)

# Run the debate
result = debate_system.run(task=topic)
print(result)

# Get the final refined answer
final_answer = debate_system.get_final_answer()
print(final_answer)
```

--------------------------------

### Create Agent Objects Example

Source: https://docs.swarms.world/api/auto-swarm-builder

Shows how to initialize AutoSwarmBuilder with `return-agents-objects` execution type to get ready-to-use Agent objects. Includes an example of using the created agents to perform a task.

```python
builder = AutoSwarmBuilder(
    name="agent-factory",
    execution_type="return-agents-objects",
    model_name="claude-sonnet-4-6"
)

# Get ready-to-use Agent objects
agents = builder.run(
    task="Build a content creation team with research, writing, and editing capabilities"
)

# Use the agents
for agent in agents:
    result = agent.run("Write an article about AI trends")
    print(f"{agent.agent_name}: {result}")

```

--------------------------------

### Install HTTP Client and Tools

Source: https://docs.swarms.world/examples/applications/job-finding

Installs HTTP client libraries and Swarms tools.

```bash
pip install httpx swarms_tools
```

--------------------------------

### Full Streaming Voice Agent Example

Source: https://docs.swarms.world/examples/voice-agents/agent-with-streaming-speech

A complete example combining agent initialization, streaming TTS callback setup, task execution, and buffer flushing for a voice-enabled agent.

```python
from swarms import Agent
from voice_agents.main import StreamingTTSCallback

agent = Agent(
    agent_name="Quantitative-Trading-Agent",
    agent_description="Advanced quantitative trading and algorithmic analysis agent",
    model_name="gpt-4.1",
    dynamic_temperature_enabled=True,
    max_loops=1,
    dynamic_context_window=True,
    top_p=None,
)

tts_callback = StreamingTTSCallback(
    voice="alloy", model="openai/tts-1", stream_mode=True
)

out = agent.run(
    task="What are the top five best energy stocks across nuclear, solar, gas, and other energy sources?",
    streaming_callback=tts_callback,
)

tts_callback.flush()
print(out)
```

--------------------------------

### Quick Start Grok Agent

Source: https://docs.swarms.world/examples/model-providers/xai

Initialize and run a basic Grok agent. This example demonstrates a simple summarization task using the Grok 4 model.

```python
from swarms import Agent

agent = Agent(
    agent_name="Grok-Agent",
    model_name="xai/grok-4-0709",
    max_loops=1,
)

print(agent.run("Summarize the case for first-principles thinking in three paragraphs."))
```

--------------------------------

### Quick Question Example

Source: https://docs.swarms.world/examples/cli/chat-command

Demonstrates asking a specific question to the chat agent to get information on Python async programming best practices.

```bash
swarms chat --task "What are the best practices for Python async programming?"
```

--------------------------------

### Install Swarms using uv

Source: https://docs.swarms.world/community/faq

Recommended for faster installation using the uv package manager.

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
uv pip install swarms
```

--------------------------------

### Install Dependencies

Source: https://docs.swarms.world/examples/voice-agents/agent-speech

Install the necessary swarms and voice-agents libraries and set the OpenAI API key.

```bash
pip install -U swarms voice-agents
export OPENAI_API_KEY=sk-...
```

--------------------------------

### Quick Start with DeepSeek Chat

Source: https://docs.swarms.world/examples/model-providers/deepseek

Initialize a DeepSeek agent for general-purpose tasks. This example uses the 'deepseek/deepseek-chat' model.

```python
from swarms import Agent

agent = Agent(
    agent_name="DeepSeek-Agent",
    model_name="deepseek/deepseek-chat",
    max_loops=1,
)

print(agent.run("Summarize the architectural ideas behind mixture-of-experts in three paragraphs."))
```

--------------------------------

### Run Swarms Environment Setup Check

Source: https://docs.swarms.world/cli/commands

The 'swarms onboarding' command performs a comprehensive check of your Swarms installation, verifying Python version, Swarms version, API key configuration, dependencies, and environment setup. Use the --verbose flag for detailed diagnostics.

```bash
swarms onboarding [--verbose]
```

```bash
swarms onboarding --verbose
```

--------------------------------

### Quick Start Azure OpenAI Agent

Source: https://docs.swarms.world/examples/model-providers/azure-openai

Initialize an Agent with Azure OpenAI, specifying the deployment name. This example demonstrates a basic agent run.

```python
from swarms import Agent

agent = Agent(
    agent_name="Azure-Agent",
    model_name="azure/gpt-4.1",         # your Azure deployment name
    max_loops=1,
)

print(agent.run("Summarize the case for private cloud AI in three paragraphs."))
```

--------------------------------

### Customer Support Agent Example

Source: https://docs.swarms.world/quickstart

Example of initializing a single Agent for customer support with a specific system prompt and running a query.

```python
# Customer Support Agent
customer_support = Agent(
    agent_name="Customer-Support",
    system_prompt="You are a helpful customer support agent. Respond professionally and empathetically to customer inquiries.",
    model_name="gpt-5.4",
    max_loops=1,
)

response = customer_support.run(
    "I haven't received my order yet. What should I do?"
)
```

--------------------------------

### Install Dependencies

Source: https://docs.swarms.world/examples/voice-agents/autonomous-agent-with-speech

Install the necessary Swarms and voice-agents libraries. Set API keys for Anthropic and OpenAI.

```bash
pip install -U swarms voice-agents
export ANTHROPIC_API_KEY=sk-ant-...
export OPENAI_API_KEY=sk-...
```

--------------------------------

### Install Open Agent Bazaar

Source: https://docs.swarms.world/examples/research/open_agent_bazaar

Clone the repository, navigate to the directory, and install dependencies using pip.

```bash
git clone https://github.com/The-Swarm-Corporation/agent-bazaar-implementation
cd agent-bazaar-implementation
pip install -r requirements.txt
```

--------------------------------

### Install Swarms and httpx

Source: https://docs.swarms.world/examples/integrations/x402-discovery

Install the necessary Python libraries for Swarms and asynchronous HTTP requests.

```bash
pip install swarms httpx
```

--------------------------------

### Complete .env File Example

Source: https://docs.swarms.world/environment-setup

An example of a comprehensive .env file including configurations for core settings, multiple LLM providers, and optional workspace settings.

```bash
# Core Configuration
WORKSPACE_DIR="agent_workspace"

# OpenAI
OPENAI_API_KEY="sk-proj-..."

# Anthropic
ANTHROPIC_API_KEY="sk-ant-..."

# Groq
GROQ_API_KEY="gsk_..."

# Additional Providers (Optional)
COHERE_API_KEY="your-cohere-key"
DEEPSEEK_API_KEY="your-deepseek-key"
OPENROUTER_API_KEY="your-openrouter-key"
XAI_API_KEY="your-xai-key"

# Workspace Settings (Optional)
LOG_LEVEL="INFO"
MAX_WORKERS="4"
CACHE_ENABLED="true"
```

--------------------------------

### Quick Start: Initialize and Run Framework

Source: https://docs.swarms.world/api/hierarchical-communication-framework

Demonstrates how to initialize the HierarchicalStructuredCommunicationFramework with specialized agents and run a workflow for a given task. Ensure all necessary agent classes are imported.

```python
from swarms.structs.hierarchical_structured_communication_framework import (
    HierarchicalStructuredCommunicationFramework,
    HierarchicalStructuredCommunicationGenerator,
    HierarchicalStructuredCommunicationEvaluator,
    HierarchicalStructuredCommunicationRefiner,
    HierarchicalStructuredCommunicationSupervisor
)

# Create specialized agents
generator = HierarchicalStructuredCommunicationGenerator(
    agent_name="ContentGenerator"
)

evaluator = HierarchicalStructuredCommunicationEvaluator(
    agent_name="QualityEvaluator"
)

refiner = HierarchicalStructuredCommunicationRefiner(
    agent_name="ContentRefiner"
)

supervisor = HierarchicalStructuredCommunicationSupervisor(
    agent_name="WorkflowSupervisor"
)

# Create the framework
framework = HierarchicalStructuredCommunicationFramework(
    name="MyFramework",
    supervisor=supervisor,
    generators=[generator],
    evaluators=[evaluator],
    refiners=[refiner],
    max_loops=3
)

# Run the workflow
result = framework.run("Create a comprehensive analysis of AI trends in 2024")
```

--------------------------------

### Customer Service Team Swarm

Source: https://docs.swarms.world/examples/hierarchical-swarm-example

Illustrates the setup of a hierarchical swarm for a customer service team. This example is a starting point for defining agents that handle customer inquiries and support tasks.

```python
from swarms import Agent, HierarchicalSwarm

```

--------------------------------

### Install and Serve Documentation Locally

Source: https://docs.swarms.world/community/development-setup

Install necessary dependencies and serve the project documentation locally for previewing changes. Essential for documentation contributors.

```bash
# Install documentation dependencies
pip install mkdocs mkdocs-material
```

```bash
# Serve documentation locally
mkdocs serve
```

```bash
# Build documentation
mkdocs build
```

--------------------------------

### Quick Start: Run a Fable 5 Agent

Source: https://docs.swarms.world/examples/model-providers/claude-fable-5

Initialize and run a Swarms agent using the Claude Fable 5 model. This example demonstrates a basic agent setup for a simple query.

```python
from swarms import Agent

agent = Agent(
    agent_name="Fable-5-Agent",
    model_name="anthropic/claude-fable-5",
    max_loops=1,
)

print(agent.run("Explain how transformer attention works in three paragraphs."))
```

--------------------------------

### Full Voice Agent Example

Source: https://docs.swarms.world/examples/voice-agents/agent-speech

A complete example combining agent initialization, task execution, and TTS narration for the final response.

```python
from swarms import Agent
from voice_agents.main import stream_tts_openai

agent = Agent(
    agent_name="Quantitative-Trading-Agent",
    agent_description="Advanced quantitative trading and algorithmic analysis agent",
    model_name="gpt-4.1",
    dynamic_temperature_enabled=True,
    max_loops=1,
    dynamic_context_window=True,
    top_p=None,
)

out = agent.run(
    task="What are the top five best energy stocks across nuclear, solar, gas, and other energy sources?",
)

stream_tts_openai(
    [out],
    stream_mode=True,
)
```

--------------------------------

### Define Address Model with Examples in Descriptions

Source: https://docs.swarms.world/agents/structured-outputs

Include example values within field descriptions to guide users on the expected format and content.

```python
class Address(BaseModel):
    street: str = Field(description="Street address, e.g., '123 Main St'")
    city: str = Field(description="City name, e.g., 'San Francisco'")
    state: str = Field(description="Two-letter state code, e.g., 'CA'")
    zip_code: str = Field(pattern=r"^\d{5}(-\d{4})?$", description="ZIP code, e.g., '94102' or '94102-1234'")
```

--------------------------------

### AgentRearrange Flow Example

Source: https://docs.swarms.world/concepts/swarms

Demonstrates setting up agents and a flow for sequential task execution.

```python
flow = "researcher -> writer, editor; writer -> reviewer; editor -> reviewer"

swarm = AgentRearrange(
    agents=[researcher, writer, editor, reviewer],
    flow=flow,
)

result = swarm.run("Create a technical whitepaper on blockchain")
```

--------------------------------

### Quick Start Agent with Groq

Source: https://docs.swarms.world/examples/model-providers/groq

Initialize an Agent with a Groq model and run a task. This demonstrates basic agent functionality with Groq.

```python
from swarms import Agent

agent = Agent(
    agent_name="Groq-Agent",
    model_name="groq/llama-3.3-70b-versatile",
    max_loops=1,
)

print(agent.run("Summarize the case for serverless inference in three paragraphs."))
```

--------------------------------

### Initialize and Run Mentorship Session

Source: https://docs.swarms.world/api/orchestration-methods

Sets up a mentor and mentee agent, then initializes and runs a mentorship session for a specified topic and duration.

```python
from swarms import Agent
from swarms.structs.multi_agent_debates import MentorshipSession

# Create agents
mentor = Agent(agent_name="Mentor", model_name="openai/gpt-4o")
mentee = Agent(agent_name="Mentee", model_name="openai/gpt-4o")

# Initialize mentorship
mentorship = MentorshipSession(
    mentor=mentor,
    mentee=mentee,
    session_count=3,
    include_feedback=True
)

# Run session
result = mentorship.run("Career development in AI research")
```

--------------------------------

### Complete Debate Example

Source: https://docs.swarms.world/examples/multi-agent/debate-quickstart

A full example demonstrating the setup, execution, and retrieval of results from a DebateWithJudge system. It includes defining a complex topic and accessing conversation history.

```python
from swarms import DebateWithJudge

# Step 1: Create the debate system with preset agents
debate_system = DebateWithJudge(
    preset_agents=True,
    max_loops=3,
    model_name="gpt-5.4",
    output_type="str-all-except-first",
    verbose=True,
)

# Step 2: Define a complex topic
topic = (
    "Should artificial intelligence be regulated by governments? "
    "Discuss the balance between innovation and safety."
)

# Step 3: Run the debate and get refined answer
result = debate_system.run(task=topic)

print("=" * 60)
print("DEBATE RESULT:")
print("=" * 60)
print(result)

# Access conversation history for detailed analysis
history = debate_system.get_conversation_history()
print(f"\nTotal exchanges: {len(history)}")
```

--------------------------------

### Basic Sequential Flow Example

Source: https://docs.swarms.world/api/swarm-rearrange

Demonstrates initializing an Agent and setting up a basic sequential flow using SwarmRearrange. This example sets up a 'Managing-Director' agent for investment analysis.

```python
import os
from swarms import Agent, AgentRearrange, SwarmRearrange

company = "TGSC"

# Initialize the Managing Director agent
managing_director = Agent(
    agent_name="Managing-Director",
    system_prompt=f"""
    As the Managing Director at Blackstone, your role is to oversee the entire investment analysis process for potential acquisitions.
    Your responsibilities include:
    1. Setting the overall strategy and direction for the analysis
    2. Coordinating the efforts of the various team members and ensuring a comprehensive evaluation
    3. Reviewing the findings and recommendations from each team member
    4. Making the final decision on whether to proceed with the acquisition

    For the current potential acquisition of {company}, direct the tasks for the team to thoroughly analyze all aspects of the company, including its financials, industry position, technology, market potential, and regulatory compliance. Provide guidance and feedback as needed to ensure a rigorous and unbiased assessment.
    """,
    model_name="gpt-4.1",
    max_loops=1,
)


```

--------------------------------

### Basic Agent Creation Example

Source: https://docs.swarms.world/api/auto-swarm-builder

Demonstrates initializing AutoSwarmBuilder and using its `run` method to generate agent specifications for a given task.

```python
from swarms.structs.auto_swarm_builder import AutoSwarmBuilder

# Create swarm builder
builder = AutoSwarmBuilder(
    name="intelligent-swarm-builder",
    model_name="claude-sonnet-4-6",
    execution_type="return-agents",
    verbose=True
)

# Generate agent specifications
agent_specs = builder.run(
    task="Create a team to analyze financial reports and generate investment recommendations"
)

print(agent_specs)

```

--------------------------------

### Configure Environment Variables

Source: https://docs.swarms.world/examples/research/open_agent_bazaar

Copy the example environment file and fill in API keys for the desired LLM providers.

```bash
cp .env.example .env
```

--------------------------------

### Collaborative Prompt Format Example

Source: https://docs.swarms.world/api/round-robin-swarm

This is an example of the prompt format used to guide agents in a collaborative session. It includes the conversation history, agent roles, and instructions to build upon previous responses.

```text
[Previous conversation history]

As Analyst, you are agent 1 of 3 in this collaborative session. 
The other agents participating are: Strategist, Implementer.

Please review the conversation history above carefully and build upon 
the insights shared by other agents. Acknowledge their contributions 
where relevant and provide your unique perspective and expertise.

Your response:

```

--------------------------------

### Environment Variables Setup

Source: https://docs.swarms.world/examples/integrations/x402-payment

Configure your API keys and wallet address in a .env file for secure access and payment processing.

```bash
# OpenAI API Key
OPENAI_API_KEY=your_openai_api_key_here

# Exa API Key (for web search)
EXA_API_KEY=your_exa_api_key_here

# Your wallet address (where you'll receive payments)
WALLET_ADDRESS=0xYourWalletAddressHere
```

--------------------------------

### Quick Start with Cerebras Agent

Source: https://docs.swarms.world/examples/model-providers/cerebras

Initialize an Agent with a Cerebras model for quick inference. This example uses the 'cerebras/llama-3.3-70b' model.

```python
from swarms import Agent

agent = Agent(
    agent_name="Cerebras-Agent",
    model_name="cerebras/llama-3.3-70b",
    max_loops=1,
)

print(agent.run("Summarize the architectural innovations behind wafer-scale compute in three paragraphs."))
```

--------------------------------

### Basic Concurrent Workflow Setup and Execution

Source: https://docs.swarms.world/api/concurrent-workflow

Demonstrates how to create and run a basic concurrent workflow with multiple specialized agents. Ensure agents are initialized before adding them to the workflow.

```python
from swarms import Agent, ConcurrentWorkflow

# Create specialized agents with different perspectives
technical_analyst = Agent(
    agent_name="Technical-Analyst",
    model_name="claude-sonnet-4-6",
    temperature=0.5,
    max_loops=1,
    system_prompt="You are a technical analyst. Analyze from a technical perspective."
)

business_analyst = Agent(
    agent_name="Business-Analyst",
    model_name="claude-sonnet-4-6",
    temperature=0.5,
    max_loops=1,
    system_prompt="You are a business analyst. Analyze from a business perspective."
)

user_researcher = Agent(
    agent_name="User-Researcher",
    model_name="claude-sonnet-4-6",
    temperature=0.5,
    max_loops=1,
    system_prompt="You are a user researcher. Analyze from a user experience perspective."
)

# Create concurrent workflow
workflow = ConcurrentWorkflow(
    name="Multi-Perspective Analysis",
    description="Analyze from multiple perspectives simultaneously",
    agents=[technical_analyst, business_analyst, user_researcher],
    verbose=True
)

# Run all agents concurrently on the same task
result = workflow.run("Analyze the potential of implementing AI chatbots in customer service")
print(result)
```

--------------------------------

### Basic Usage of SelfConsistencyAgent

Source: https://docs.swarms.world/agents/self-consistency-agent

Instantiate and run the SelfConsistencyAgent for a given task. This example demonstrates basic setup with a specified model and number of samples.

```python
from swarms.agents.consistency_agent import SelfConsistencyAgent

agent = SelfConsistencyAgent(
    name="Math-Reasoning-Agent",
    model_name="claude-sonnet-4-6",
    max_loops=1,
    num_samples=5
)

task = "What is the 40th prime number?"
final_answer = agent.run(task)
print("Final aggregated answer:", final_answer)
```

--------------------------------

### Basic Mixture of Agents Setup

Source: https://docs.swarms.world/architectures/mixture-of-agents

Demonstrates how to initialize and run a basic Mixture of Agents swarm with financial, market, and risk expert agents, and an aggregator agent for investment recommendations.

```python
from swarms import Agent, MixtureOfAgents

# Define expert agents
financial_analyst = Agent(
    agent_name="Financial-Analyst",
    system_prompt="Analyze financial data, ratios, and performance metrics.",
    model_name="gpt-5.4",
    max_loops=1,
)

market_analyst = Agent(
    agent_name="Market-Analyst",
    system_prompt="Analyze market trends, competition, and positioning.",
    model_name="gpt-5.4",
    max_loops=1,
)

risk_analyst = Agent(
    agent_name="Risk-Analyst",
    system_prompt="Analyze risks, threats, and mitigation strategies.",
    model_name="gpt-5.4",
    max_loops=1,
)

# Define aggregator agent
aggregator = Agent(
    agent_name="Investment-Advisor",
    system_prompt="Synthesize financial, market, and risk analyses into a comprehensive investment recommendation.",
    model_name="gpt-5.4",
    max_loops=1,
)

# Create MoA swarm
moa = MixtureOfAgents(
    name="Investment-Analysis-Team",
    agents=[financial_analyst, market_analyst, risk_analyst],
    aggregator_agent=aggregator,
    layers=1,  # Single layer of analysis
)

# Execute
recommendation = moa.run("Should we invest in NVIDIA stock?")
print(recommendation)
```

--------------------------------

### Initialize Agents with Different LLM Providers

Source: https://docs.swarms.world/examples/basic-agent

Demonstrates initializing agents using different LLM providers including OpenAI, Anthropic Claude, Groq, and local Ollama.

```python
# OpenAI
agent_openai = Agent(model_name="claude-sonnet-4-6")

# Anthropic Claude
agent_claude = Agent(model_name="claude-sonnet-4-5")

# Groq
agent_groq = Agent(model_name="groq/llama-3.3-70b-versatile")

# Local with Ollama
agent_ollama = Agent(model_name="ollama/llama3.2")
```

--------------------------------

### Run Local Development Server

Source: https://docs.swarms.world/community/contributing-to-docs

Start the Mintlify development server from the root of the cloned repository. This allows you to preview changes locally.

```bash
mint dev
```

--------------------------------

### Complete Agent Example

Source: https://docs.swarms.world/quickstart

A full example demonstrating agent import, initialization, and task execution. This code block combines all the steps to create and run a basic agent.

```python
from swarms import Agent

# Initialize a new agent
agent = Agent(
    model_name="gpt-5.4",  # Specify the LLM
    max_loops="auto",          # Set the number of interactions
    interactive=True,          # Enable interactive mode for real-time feedback
)

# Run the agent with a task
response = agent.run(
    "What are the key benefits of using a multi-agent system?"
)
print(response)
```

--------------------------------

### Start AOP Medical Server

Source: https://docs.swarms.world/examples/multi-agent/aop-medical

Run the AOP server that exposes medical agents as MCP tools. Ensure Python is installed and the script path is correct.

```bash
python -m examples.aop_examples.medical_aop.server
```

--------------------------------

### Full Autonomous Voice Agent Example

Source: https://docs.swarms.world/examples/voice-agents/autonomous-agent-with-speech

A complete script combining agent initialization, TTS callback setup, and agent execution for an autonomous voice agent.

```python
from swarms import Agent
from voice_agents import StreamingTTSCallback

agent = Agent(
    agent_name="Terminal-Agent",
    agent_description="Agent that can plan tasks and run bash commands on the terminal",
    model_name="anthropic/claude-sonnet-4-5",
    dynamic_temperature_enabled=True,
    max_loops="auto",
    dynamic_context_window=True,
    selected_tools="all",
    top_p=None,
)

tts_callback = StreamingTTSCallback(voice="alloy", model="tts-1")


if __name__ == "__main__":
    result = agent.run(
        task="Use the terminal to list the current directory, and see what files are in it.",
        streaming_callback=tts_callback,
    )

    tts_callback.flush()
    print(result)
```

--------------------------------

### Complete Prompt Management Example

Source: https://docs.swarms.world/api/prompts

Demonstrates creating, editing, adding tools, rolling back, and exporting a prompt using the Prompt class. It also shows how to set the workspace directory and enable autosave.

```python
from swarms.prompts import Prompt
from swarms.tools import BaseTool
import os

# Set workspace directory
os.environ["WORKSPACE_DIR"] = "./workspace"

# Create a prompt with autosave
prompt = Prompt(
    name="market_analysis",
    description="Financial market analysis prompt",
    content="""
You are a financial analyst. Analyze the following:
    1. Market trends
    2. Risk factors
    3. Investment opportunities
    """,
    autosave=True,
    autosave_folder="financial_prompts"
)

# Edit the prompt
prompt.edit_prompt("""
You are an expert financial analyst specializing in equity markets.

Analyze the following aspects:
1. Current market trends and momentum
2. Key risk factors and hedging strategies
3. High-conviction investment opportunities
4. Portfolio allocation recommendations

Provide detailed analysis with supporting data.
""")

print(f"Edit count: {prompt.edit_count}")  # 1
print(f"Total versions: {len(prompt.edit_history)}")  # 2

# Add tools to the prompt
def calculate_sharpe_ratio(returns: float, risk_free_rate: float, std_dev: float) -> float:
    """Calculate Sharpe ratio for investment analysis."""
    return (returns - risk_free_rate) / std_dev

prompt.add_tools([calculate_sharpe_ratio])

# Rollback if needed
prompt.rollback(version=0)  # Back to original version

# Get the current prompt
current = prompt.get_prompt()
print(current)

# Export as JSON
json_export = prompt.return_json()
print(json_export)
```

--------------------------------

### Basic Sequential Workflow Setup

Source: https://docs.swarms.world/architectures/sequential-workflow

Create and run a basic sequential workflow with researcher, writer, and editor agents. Ensure agents are initialized with their respective system prompts and model names.

```python
from swarms import Agent, SequentialWorkflow

# Create specialized agents
researcher = Agent(
    agent_name="Researcher",
    system_prompt="Research the given topic and provide detailed information.",
    model_name="gpt-5.4",
    max_loops=1,
)

writer = Agent(
    agent_name="Writer",
    system_prompt="Transform research into an engaging article.",
    model_name="gpt-5.4",
    max_loops=1,
)

editor = Agent(
    agent_name="Editor",
    system_prompt="Edit and polish the article for publication.",
    model_name="gpt-5.4",
    max_loops=1,
)

# Create workflow
workflow = SequentialWorkflow(
    agents=[researcher, writer, editor],
    max_loops=1,
)

# Execute
result = workflow.run("The impact of AI on healthcare")
print(result)
```

--------------------------------

### Interactive Terminal Session Setup

Source: https://docs.swarms.world/architectures/group-chat

Enable and start an interactive REPL session for a GroupChat, allowing users to directly interact with agents via terminal commands.

```python
# Enable interactive mode
chat = GroupChat(
    name="Research-Team",
    agents=[researcher, analyst, writer],
    interactive=True,
)

# Start REPL session
chat.start_interactive_session()

# User can:
# - Type questions and tasks
# - Use @mentions to target specific agents
# - Type 'help' for commands
# - Type 'speaker' to change speaker function
# - Type 'exit' to end session
```

--------------------------------

### Custom System Prompt for Agent Specialization

Source: https://docs.swarms.world/api/auto-swarm-builder

Customize the system prompt to guide the AI in creating specialized agents. This example focuses on financial analysis expertise.

```python
custom_prompt = """
You are an expert swarm architect specializing in financial analysis teams.
Design agents with deep expertise in financial modeling, risk assessment,
and investment strategy.
"""

builder = AutoSwarmBuilder(
    system_prompt=custom_prompt,
    model_name="claude-sonnet-4-6"
)

agents = builder.run("Create a financial analysis team")
```

--------------------------------

### Extended Conversation Example

Source: https://docs.swarms.world/examples/cli/chat-command

Starts an extended chat session with a custom agent name and system prompt, designed for a patient programming tutor role. Follow-up questions can be asked interactively.

```bash
swarms chat --name "TutorBot" --system-prompt "You are a patient programming tutor"
```

--------------------------------

### Quick Start with OpenRouter Agent

Source: https://docs.swarms.world/examples/model-providers/openrouter

Initialize an Agent with an OpenRouter model and run a task.

```python
from swarms import Agent

agent = Agent(
    agent_name="OpenRouter-Agent",
    model_name="openrouter/anthropic/claude-3.5-sonnet",
    max_loops=1,
)

print(agent.run("Summarize the case for API gateways in three paragraphs."))
```

--------------------------------

### Initialize and Run PlannerWorkerSwarm

Source: https://docs.swarms.world/api/planner-worker-swarm

Quick start example demonstrating how to initialize a PlannerWorkerSwarm with worker agents and execute a task. The swarm will then plan, execute, and evaluate the task until completion or max loops are reached.

```python
from swarms import Agent
from swarms.structs.planner_worker_swarm import PlannerWorkerSwarm

swarm = PlannerWorkerSwarm(
    agents=[
        Agent(agent_name="Research", agent_description="Gathers information", model_name="gpt-5.4", max_loops=1),
        Agent(agent_name="Analysis", agent_description="Analyzes data", model_name="gpt-5.4", max_loops=1),
    ],
    max_loops=1,
    max_workers=2,
    worker_timeout=120,
)

result = swarm.run("What are the top 3 benefits of renewable energy?")
print(result)
```

--------------------------------

### Get Cron Job Execution Statistics

Source: https://docs.swarms.world/api/cron-job

Retrieve statistics about a cron job's execution, including its ID, running status, execution count, start time, uptime, and configured interval.

```python
stats = cron.get_execution_stats()
print(stats)
# {
#   "job_id": "financial_analysis_job",
#   "is_running": True,
#   "execution_count": 42,
#   "start_time": 1234567890.123,
#   "uptime": 3600.5,
#   "interval": "10minutes"
# }
```

--------------------------------

### Initialize and Run GKPAgent

Source: https://docs.swarms.world/agents/gkp-agent

Demonstrates how to initialize the GKPAgent with specific parameters and run it with a list of queries. The results are then iterated and printed.

```python
from swarms.agents.gkp_agent import GKPAgent

agent = GKPAgent(
    agent_name="gkp-agent",
    model_name="claude-sonnet-4-6",
    num_knowledge_items=6,
)

queries = [
    "What are the implications of quantum entanglement on information theory?",
]

results = agent.run(queries)

for i, result in enumerate(results):
    print(f"\nQuery {i+1}: {queries[i]}")
    print(f"Answer: {result}")
```

--------------------------------

### Configure a Production-Ready Agent

Source: https://docs.swarms.world/concepts/agents

This example demonstrates advanced agent configuration for production use, including identity, LLM settings, execution control, system prompts, memory management, and tools. Ensure necessary tools like 'search_tool' and 'calculator_tool' are defined and imported.

```python
from swarms import Agent

# Create a production-ready agent
agent = Agent(
    # Identity
    agent_name="Financial-Analyst",
    agent_description="Expert in financial analysis and market research",
    
    # LLM Configuration
    model_name="gpt-5.4",
    max_tokens=4096,
    temperature=0.5,
    
    # Execution Control
    max_loops=5,
    dynamic_loops=True,
    stopping_token="<DONE>",
    
    # System Behavior
    system_prompt="""You are a financial analyst with expertise in market research.
    Your role is to analyze financial data and provide actionable insights.
    Always cite your sources and provide confidence levels for predictions.""",
    
    # Memory & Context
    context_length=16000,
    dynamic_context_window=True,
    return_history=True,
    
    # Tools (if applicable)
    tools=[search_tool, calculator_tool],
    
    # Output Control
    streaming_on=True,
    verbose=True,
)

# Execute a complex task
result = agent.run(
    "Analyze the current state of the renewable energy market and provide investment recommendations"
)
```

--------------------------------

### Install Swarms from Source

Source: https://docs.swarms.world/community/development-setup

Clone the Swarms repository and install it in editable mode using pip, or install dependencies separately. This method is for contributors.

```bash
# Clone the repository
git clone https://github.com/kyegomez/swarms.git
cd swarms

# Install with pip in editable mode
pip install -e . 

# Or install dependencies directly
pip install -r requirements.txt
```

--------------------------------

### Initialize and Run Trial Simulation

Source: https://docs.swarms.world/api/orchestration-methods

Sets up agents and a trial simulation for a legal case, then runs the simulation.

```python
judge = Agent(agent_name="Judge", model_name="openai/gpt-4o")
prosecutor = Agent(agent_name="Prosecutor", model_name="openai/gpt-4o")
defense = Agent(agent_name="Defense", model_name="openai/gpt-4o")
witness1 = Agent(agent_name="Witness1", model_name="openai/gpt-4o")
witness2 = Agent(agent_name="Witness2", model_name="openai/gpt-4o")

trial = TrialSimulation(
    prosecution=prosecutor,
    defense=defense,
    judge=judge,
    witnesses=[witness1, witness2],
    phases=["opening", "testimony", "cross", "closing"]
)

result = trial.run("Patent infringement case")
```

--------------------------------

### Install swarms and optional dependencies

Source: https://docs.swarms.world/api/graph-workflow

Install the swarms library for workflow capabilities. Optionally install graphviz for visualization or rustworkx for a faster backend.

```bash
pip install -U swarms

# For visualization support
pip install graphviz

# For Rustworkx backend (optional, faster for large graphs)
pip install rustworkx
```

--------------------------------

### Install and Initialize Swarms CLI

Source: https://docs.swarms.world/examples/cli/quickstart-tutorial

Installs the Swarms CLI and initializes a new project. The wizard will prompt for project details and API keys.

```bash
pip install -U swarms
swarms init
```

--------------------------------

### Initialize Legal Agent

Source: https://docs.swarms.world/api/prompts

Set up a legal advisor agent by using the LEGAL_AGENT_PROMPT as the system prompt for the Agent class.

```python
from swarms.prompts import LEGAL_AGENT_PROMPT

agent = Agent(
    agent_name="Legal-Advisor",
    system_prompt=LEGAL_AGENT_PROMPT,
    # ... other config
)
```

--------------------------------

### Install MCP, FastMCP, Swarms, and Loguru

Source: https://docs.swarms.world/examples/integrations/mcp-datastax

Install the necessary Python packages for MCP, FastMCP, Swarms, and logging. Ensure you have Python 3.8+ and pip installed.

```bash
# Install MCP SDK and FastMCP
pip install mcp fastmcp

# Install Swarms framework
pip install swarms

# Install additional dependencies
pip install loguru
```

--------------------------------

### ReflexionAgent Example Usage

Source: https://docs.swarms.world/agents/reflexion-agent

Example of how to initialize and use the ReflexionAgent.

```APIDOC
## Example

```python theme={null}
from swarms.agents import ReflexionAgent

agent = ReflexionAgent(
    agent_name="reflexion-agent",
    model_name="openai/o1",
    max_loops=3
)

tasks = [
    "Explain quantum computing to a beginner.",
    "Write a Python function to sort a list of dictionaries by a specific key."
]

results = agent.run(tasks)

for i, result in enumerate(results):
    print(f"\nTask {i+1}: {tasks[i]}")
    print(f"Response: {result}")
```
```

--------------------------------

### Content Creation Pipeline Example

Source: https://docs.swarms.world/architectures/sequential-workflow

Demonstrates a content creation pipeline using Sequential Workflow, involving agents for research, writing, editing, and publishing.

```python
# Research → Write → Edit → Publish
researcher = Agent(agent_name="Researcher", ...)
writer = Agent(agent_name="Writer", ...)
editor = Agent(agent_name="Editor", ...)
publisher = Agent(agent_name="Publisher", ...)

pipeline = SequentialWorkflow(
    agents=[researcher, writer, editor, publisher]
)

article = pipeline.run("Latest developments in renewable energy")
```

--------------------------------

### Verify Development Installation

Source: https://docs.swarms.world/installation

Confirm that the development installation of Swarms is successful.

```bash
python -c "import swarms; print('Development installation successful!')"
```

--------------------------------

### Initialize and Run a Basic Agent

Source: https://docs.swarms.world/examples/basic-agent

This snippet shows the simplest way to create an agent, specifying the LLM, iteration count, and interactive mode, then running it with a task.

```python
from swarms import Agent

# Initialize a new agent
agent = Agent(
    model_name="gpt-5.4",  # Specify the LLM
    max_loops="auto",           # Set the number of interactions
    interactive=True,           # Enable interactive mode for real-time feedback
)

# Run the agent with a task
response = agent.run("What are the key benefits of using a multi-agent system?")
print(response)
```

--------------------------------

### Verify Swarms Installation with One-liner

Source: https://docs.swarms.world/installation

A concise command-line verification of the Swarms installation.

```bash
python -c "import swarms; print('Swarms is ready!')"
```

--------------------------------

### Basic Concurrent Workflow Setup

Source: https://docs.swarms.world/architectures/concurrent-workflow

Sets up a concurrent workflow with specialized agents for market, financial, and risk analysis. Agents run simultaneously on a given task.

```python
from swarms import Agent, ConcurrentWorkflow

# Create specialized analysts
market_analyst = Agent(
    agent_name="Market-Analyst",
    system_prompt="Analyze market trends and opportunities.",
    model_name="gpt-5.4",
)

financial_analyst = Agent(
    agent_name="Financial-Analyst",
    system_prompt="Provide financial analysis and projections.",
    model_name="gpt-5.4",
)

risk_analyst = Agent(
    agent_name="Risk-Analyst",
    system_prompt="Assess and quantify potential risks.",
    model_name="gpt-5.4",
)

# Create concurrent workflow
workflow = ConcurrentWorkflow(
    agents=[market_analyst, financial_analyst, risk_analyst],
    max_loops=1,
)

# All agents run simultaneously
results = workflow.run(
    "Analyze the potential impact of AI on the healthcare industry"
)
print(results)
```

--------------------------------

### Install Simulation Requirements

Source: https://docs.swarms.world/examples/research/open_agent_bazaar

Installs the necessary Python packages for the simulation visualizer.

```bash
pip install -r sim/requirements.txt
```

--------------------------------

### Multi-Tool Agent Example

Source: https://docs.swarms.world/concepts/tools

Demonstrates creating an agent that can utilize multiple tools like web search, calculation, and file saving. The agent can chain these tools together to perform complex tasks.

```python
from swarms import Agent

def search_web(query: str) -> str:
    """Search the web for information."""
    return f"Search results for: {query}"

def calculate(expression: str) -> float:
    """Perform mathematical calculations."""
    return eval(expression)

def save_to_file(filename: str, content: str) -> str:
    """Save content to a file."""
    with open(filename, 'w') as f:
        f.write(content)
    return f"Saved to {filename}"

# Agent with multiple tools
agent = Agent(
    model_name="gpt-5.4",
    tools=[search_web, calculate, save_to_file],
    max_loops=5,  # Allow multiple tool uses
)

# Agent can chain tools together
response = agent.run(
    "Search for the current Bitcoin price, calculate what 10 Bitcoins would cost, "
    "and save the result to bitcoin_value.txt"
)
```

--------------------------------

### Install Swarms and Ollama

Source: https://docs.swarms.world/examples/model-providers/ollama

Install the Swarms library and Ollama using pip.

```bash
pip install -U swarms ollama
```

--------------------------------

### Install Dependencies

Source: https://docs.swarms.world/examples/finance/prediction-markets-kalshi

Install the necessary Python packages for Swarms, requests, and cryptography.

```bash
pip install swarms requests cryptography
```

--------------------------------

### Verify Environment Variables Setup

Source: https://docs.swarms.world/environment-setup

Loads environment variables from the .env file and prints them to verify that the setup was successful. It shows a truncated version of the API key for security.

```python
import os
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Verify API keys are loaded
print(f"OpenAI API Key: {os.getenv('OPENAI_API_KEY')[:10]}...")
print(f"Workspace: {os.getenv('WORKSPACE_DIR')}")
```

--------------------------------

### Install Dependencies

Source: https://docs.swarms.world/examples/fastapi-agent-api

Install the necessary Python packages for FastAPI, Uvicorn, and Swarms.

```bash
pip install fastapi uvicorn swarms
```

--------------------------------

### Install macOS command-line tools

Source: https://docs.swarms.world/installation

On macOS, install necessary command-line tools for development.

```bash
xcode-select --install
```

--------------------------------

### Agent Initialization with Skills Directory

Source: https://docs.swarms.world/agents/agent-skills

Shows how to initialize an Agent, specifying the directory where skills are located. Skills metadata is loaded from SKILL.md frontmatter and their content is added to the system prompt.

```python
# Skills are loaded during agent initialization
agent = Agent(
    skills_dir="./skills",  # Path to skills directory
    model_name="claude-sonnet-4-6",
)

# Skills metadata is loaded from SKILL.md frontmatter
# Skills content is added to system prompt
# Agent can now use all skills
```

--------------------------------

### Install Dependencies

Source: https://docs.swarms.world/examples/integrations/x402-payment

Install the necessary Python packages for X402 integration and Swarms agents.

```bash
pip install swarms x402 fastapi uvicorn python-dotenv swarms-tools
```
Tokens:
Raw