Swarms World

https://docs.swarms.world/en/latest
Admin
The provided content is a Cloudflare verification page and does not contain sufficient information...
Tokens:656,237
Snippets:4,786
Trust Score:7.9
Update:8 months ago
Show doc for...
Tokens:
Raw
### Complete Agent Publishing Example (Python)

Source: https://docs.swarms.world/en/latest/examples/marketplace_publishing_quickstart

This comprehensive Python example demonstrates the end-to-end process of creating, configuring, and publishing a specialized agent to the Swarms Marketplace. It includes API key validation, agent setup with detailed prompts and use cases, and the final execution step.

```python
import os
from swarms import Agent

# Ensure API key is set
if not os.getenv("SWARMS_API_KEY"):
    raise ValueError("Please set SWARMS_API_KEY environment variable")

# Step 1: Create a specialized medical analysis agent
medical_agent = Agent(
    agent_name="Blood-Data-Analysis-Agent",
    agent_description="Explains and contextualizes common blood test panels with structured insights",
    model_name="gpt-4o-mini",
    max_loops=1,

    system_prompt="""You are a clinical laboratory data analyst assistant focused on hematology and basic metabolic panels.

Your goals:
1) Interpret common blood test panels (CBC, CMP/BMP, lipid panel, HbA1c, thyroid panels)
2) Provide structured findings: out-of-range markers, degree of deviation, clinical significance
3) Identify potential confounders (e.g., hemolysis, fasting status, medications)
4) Suggest safe, non-diagnostic next steps

Reliability and safety:
- This is not medical advice. Do not diagnose or treat.
- Use cautious language with confidence levels (low/medium/high)
- Highlight red-flag combinations that warrant urgent clinical evaluation""",

    # Step 2: Publishing configuration
    publish_to_marketplace=True,

    tags=["lab", "hematology", "metabolic", "education"],
    capabilities=[
        "panel-interpretation",
        "risk-flagging", 
        "guideline-citation"
    ],

    use_cases=[
        {
            "title": "Blood Analysis",
            "description": "Analyze blood samples and summarize notable findings."
        },
        {
            "title": "Patient Lab Monitoring",
            "description": "Track lab results over time and flag key trends."
        },
        {
            "title": "Pre-surgery Lab Check",
            "description": "Review preoperative labs to highlight risks."
        }
    ],
)

# Step 3: Run the agent (this publishes it to the marketplace)
result = medical_agent.run(
    task="Analyze this blood sample: Hematology and Basic Metabolic Panel"
)

print(result)

```

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

### Manual Swarms Setup with Poetry

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

This manual setup process involves cloning the Swarms repository and then using Poetry to install all project dependencies, including development-specific ones. This method provides more control over the setup.

```bash
git clone https://github.com/kyegomez/swarms.git
cd swarms
poetry install --with dev
```

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

### Run Swarms Setup Check

Source: https://docs.swarms.world/en/latest/examples/cli_multi_agent_quickstart

Verifies that the Swarms environment is correctly configured and ready for use. Running with the --verbose flag provides more detailed output about the setup status.

```bash
swarms setup-check --verbose

```

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

### Install Dependencies with Poetry

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Installs all project dependencies, including development tools, and activates the virtual environment using Poetry.

```bash
# Navigate to project directory
cd swarms

# Install all dependencies including development tools
poetry install --with dev,lint,test

# Activate the virtual environment
poetry shell
```

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

### Build and Serve Documentation Locally

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Provides instructions for building and serving the project's documentation locally using MkDocs. Requires installing documentation dependencies first.

```bash
# Install documentation dependencies
pip install -r docs/requirements.txt

# Navigate to docs directory
cd docs

# Serve documentation locally
mkdocs serve
# Documentation will be available at http://127.0.0.1:8000
```

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

### Complete Debate Example with Output Options

Source: https://docs.swarms.world/en/latest/examples/debate_quickstart

A comprehensive example demonstrating the creation of a DebateWithJudge system, running a debate on a complex topic, and printing the full result. It also shows how to access the 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-4o-mini",
    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 Server Setup Example

Source: https://docs.swarms.world/en/latest/swarms/structs/aop

Demonstrates how to set up a basic agent server with individual agent additions and run it.

```APIDOC
## Basic Server Setup

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

# Create specialized agents
research_agent = Agent(
    agent_name="Research-Agent",
    agent_description="Expert in research, data collection, and information gathering",
    model_name="anthropic/claude-sonnet-4-5",
    max_loops=1,
    top_p=None,
    dynamic_temperature_enabled=True,
    system_prompt="""You are a research specialist. Your role is to:
    1. Gather comprehensive information on any given topic
    2. Analyze data from multiple sources
    3. Provide well-structured research findings
    4. Cite sources and maintain accuracy
    5. Present findings in a clear, organized manner

    Always provide detailed, factual information with proper context.""",
)

analysis_agent = Agent(
    agent_name="Analysis-Agent",
    agent_description="Expert in data analysis, pattern recognition, and generating insights",
    model_name="anthropic/claude-sonnet-4-5",
    max_loops=1,
    top_p=None,
    dynamic_temperature_enabled=True,
    system_prompt="""You are an analysis specialist. Your role is to:
    1. Analyze data and identify patterns
    2. Generate actionable insights
    3. Create visualizations and summaries
    4. Provide statistical analysis
    5. Make data-driven recommendations

    Focus on extracting meaningful insights from information.""",
)

# Create AOP instance
deployer = AOP(
    server_name="MyAgentServer",
    port=8000,
    verbose=True,
    log_level="INFO"
)

# Add agents individually
deployer.add_agent(research_agent)
deployer.add_agent(analysis_agent)

# Start the server
deployer.run()

```
```

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

### Quick Start with Preset Debate Agents

Source: https://docs.swarms.world/en/latest/swarms/structs/debate_with_judge

This example demonstrates how to quickly initialize and run the `DebateWithJudge` system using pre-configured, optimized agents. It requires minimal setup, making it ideal for rapid prototyping.

```python
from swarms import DebateWithJudge

# Create debate system with built-in optimized agents
debate = DebateWithJudge(preset_agents=True, max_loops=3)

# Run a debate on a specific topic
result = debate.run("Should universal basic income be implemented?")
print(result)
```

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

### Markdown Documentation Example with MkDocs Extensions

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Illustrates how to write documentation using Markdown with MkDocs extensions, including admonitions and language-specific code blocks.

```markdown
# Page Title

!!! tip "Pro Tip"
    Use admonitions to highlight important information.

=== "Python"
    ```python
    from swarms import Agent
    agent = Agent()
    ```

=== "CLI"
    ```bash
    swarms create-agent --name myagent
    ```
```

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

### Install Dependencies with pip and venv

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Sets up project dependencies using a traditional pip-based approach with virtual environments. Includes steps for creating, activating, and installing packages.

```bash
# Navigate to project directory
cd swarms

# Create virtual environment
python -m venv venv

# Activate virtual environment
# On macOS/Linux:
source venv/bin/activate
# On Windows:
virtualenv\Scripts\activate

# Upgrade pip
pip install --upgrade pip

# Install core dependencies
pip install -r requirements.txt

# Install documentation dependencies (optional)
pip install -r docs/requirements.txt
```

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

### Set Up Pre-commit Hooks

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Installs and configures pre-commit hooks to automate code quality checks before committing. Includes steps for installation and running hooks.

```bash
# Install pre-commit
poetry add --group dev pre-commit
# or with pip:
pip install pre-commit

# Install git hooks
pre-commit install

# Run on all files
pre-commit run --all-files
```

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

### Example Pytest Test File

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Demonstrates how to write tests using Pytest, including basic agent creation assertions and parametrized tests for different inputs.

```python
# Example test file: tests/test_example.py
import pytest
from swarms import Agent

def test_agent_creation():
    """Test that an agent can be created successfully."""
    agent = Agent(
        agent_name="test_agent",
        system_prompt="You are a helpful assistant"
    )
    assert agent.agent_name == "test_agent"

@pytest.mark.parametrize("input_val,expected", [
    ("hello", "HELLO"),
    ("world", "WORLD"),
])
def test_uppercase(input_val, expected):
    """Example parametrized test."""
    assert input_val.upper() == expected
```

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

### Create or Copy .env File

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Explains how to set up environment variables for local development by creating a `.env` file, either by copying an example or creating a new one.

```bash
# Copy example environment file
cp .env.example .env  # if it exists

# Or create your own .env file
touch .env
```

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

### Run a Simple Agent for Setup Verification

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Tests the basic functionality of the Agent class by initializing an agent and running a simple command. This confirms that the agent can be instantiated and execute tasks, indicating a successful setup.

```python
from swarms import Agent

agent = Agent(
    agent_name="setup_test",
    system_prompt="You are a helpful assistant for testing setup.",
    max_loops=1
)

response = agent.run("Say hello!")
print(f"✅ Agent response: {response}")
```

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

### Basic BatchedGridWorkflow Setup and Run

Source: https://docs.swarms.world/en/latest/swarms/examples/batched_grid_simple_example

Demonstrates the fundamental setup of BatchedGridWorkflow by creating two agents and running a list of simple tasks. It requires the 'swarms' library and the BatchedGridWorkflow class.

```python
from swarms import Agent
from swarms.structs.batched_grid_workflow import BatchedGridWorkflow

# Create two basic agents
agent1 = Agent(model="gpt-4")
agent2 = Agent(model="gpt-4")

# Create workflow with default settings
workflow = BatchedGridWorkflow(
    agents=[agent1, agent2]
)

# Define simple tasks
tasks = [
    "What is the capital of France?",
    "Explain photosynthesis in simple terms"
]

# Run the workflow
result = workflow.run(tasks)

```

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

### Start Swarms CLI Onboarding Process

Source: https://docs.swarms.world/en/latest/swarms/cli/cli_examples

Initiates the interactive onboarding process for the Swarms CLI. This process guides users through the initial setup and configuration of their environment.

```bash
swarms onboarding
```

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

### Basic Handoff Example: Multi-Agent System Setup (Python)

Source: https://docs.swarms.world/en/latest/swarms/structs/agent

Illustrates setting up a multi-agent system with task delegation using specialized agents (Research, Code, Writing) and a coordinator agent. The coordinator intelligently routes tasks to the appropriate agent(s). This example focuses on the initialization of these agents. Requires the `swarms.structs.agent` module.

```python
from swarms.structs.agent import Agent

# Create specialized agents
research_agent = Agent(
    agent_name="ResearchAgent",
    agent_description="Specializes in researching topics and providing detailed, factual information",
    model_name="gpt-4o-mini",
    max_loops=1,
    system_prompt="You are a research specialist. Provide detailed, well-researched information about any topic, citing sources when possible.",
)

code_agent = Agent(
    agent_name="CodeExpertAgent",
    agent_description="Expert in writing, reviewing, and explaining code across multiple programming languages",
    model_name="gpt-4o-mini",
    max_loops=1,
    system_prompt="You are a coding expert. Write, review, and explain code with a focus on best practices and clean code principles.",
)

writing_agent = Agent(
    agent_name="WritingAgent",
    agent_description="Skilled in creative and technical writing, content creation, and editing",
    model_name="gpt-4o-mini",
    max_loops=1,
    system_prompt="You are a writing specialist. Create, edit, and improve written content while maintaining appropriate tone and style.",
)
```

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

### Automated Swarms Setup Script

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

This script automates the setup of the Swarms development environment. It clones the repository, makes the setup script executable, and runs it to install Poetry, create a virtual environment, install dependencies, and set up pre-commit hooks.

```bash
git clone https://github.com/kyegomez/swarms.git
cd swarms
chmod +x scripts/setup.sh
./scripts/setup.sh
```

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

### Install Swarms Framework

Source: https://docs.swarms.world/en/latest/index

Installs the Swarms Python package using pip. This is the primary command to get started with the framework.

```bash
pip3 install swarms

```

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

### Install swarms-tools Package

Source: https://docs.swarms.world/en/latest/swarms_tools/search

Installs or upgrades the swarms-tools package using pip. This is the primary step to get started with the search tools.

```bash
pip3 install -U swarms-tools

```

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

### Install Swarms Library

Source: https://docs.swarms.world/en/latest/examples/debate_quickstart

Installs the Swarms library, which is a prerequisite for using the DebateWithJudge class. This command should be run in your terminal or command prompt.

```bash
pip install swarms

```

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

### Dynamic Agent Discovery and Coordination Example (Python)

Source: https://docs.swarms.world/en/latest/swarms/structs/aop

A Python example demonstrating how to set up a coordinator agent that can discover and utilize other specialized agents. It includes creating agents, deploying them using an AOP server, and a function to coordinate a research task by discovering and assigning work to appropriate agents.

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

# Create a coordinator agent that can discover and use other agents
coordinator = Agent(
    agent_name="Coordinator-Agent",
    agent_description="Coordinates tasks between different specialized agents",
    model_name="anthropic/claude-sonnet-4-5",
    max_loops=1,
    tags=["coordination", "orchestration", "management"],
    capabilities=["agent-discovery", "task-distribution", "workflow-management"],
    role="coordinator"
)

# Create specialized agents
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"
)

# Create AOP server
deployer = AOP(
    server_name="DynamicAgentCluster",
    port=8000,
    verbose=True
)

# Add all agents
deployer.add_agent(coordinator)
deployer.add_agent(research_agent)
deployer.add_agent(analysis_agent)

# The coordinator can now discover other agents and use them
# This would be done through MCP tool calls in practice
def coordinate_research_task(task_description):
    """
    Example of how the coordinator might use discovery tools
    """
    # 1. Discover available research agents
    research_agents = discover_agents()
    research_agents = [a for a in research_agents['agents'] if 'research' in a['tags']]

    # 2. Get detailed info about the best research agent
    if research_agents:
        best_agent = research_agents[0]
        agent_details = get_agent_details(agent_name=best_agent['agent_name'])

        # 3. Use the research agent for the task
        research_result = research_agent.run(task=task_description)

        # 4. Find analysis agents for processing the research
        analysis_agents = search_agents(query="analysis", search_fields=["tags"])
        if analysis_agents['matching_agents']:
            analysis_agent_name = analysis_agents['matching_agents'][0]['agent_name']
            analysis_result = analysis_agent.run(task=f"Analyze this research: {research_result}")

            return {
                "research_result": research_result,
                "analysis_result": analysis_result,
                "agents_used": [best_agent['agent_name'], analysis_agent_name]
            }

    return {"error": "No suitable agents found"}

# Start the server
deployer.run()
```

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

### Install Swarms in Development Mode

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Installs the 'swarms' package and its development dependencies using Poetry. This ensures that the project is installed in a way that allows for local development and testing.

```shell
# Install in development mode
poetry install --with dev
# or
pip install -e .
```

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

### Full AgentRegistry Example Setup

Source: https://docs.swarms.world/en/latest/swarms/structs/agent_registry

Imports necessary classes from swarms to set up and use the AgentRegistry and Agent functionalities.

```python
from swarms.structs.agent_registry import AgentRegistry
from swarms import Agent, OpenAIChat, Anthropic
```

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

### Initialize ForestSwarm and Run Tasks

Source: https://docs.swarms.world/en/latest/swarms/structs/forest_swarm

Demonstrates the creation of agents, trees, and a ForestSwarm. It shows how to initialize the swarm with multiple trees and agents, and how to execute tasks using the swarm's capabilities.

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

# Create agents with varying system prompts and dynamically generated distances/keywords
agents_tree1 = [
    TreeAgent(
        name="Financial Advisor",
        system_prompt="I am a financial advisor specializing in investment planning, retirement strategies, and tax optimization for individuals and businesses.",
        agent_name="Financial Advisor",
        verbose=True
    ),
    TreeAgent(
        name="Tax Expert",
        system_prompt="I am a tax expert with deep knowledge of corporate taxation, Delaware incorporation benefits, and free tax filing options for businesses.",
        agent_name="Tax Expert",
        verbose=True
    ),
    TreeAgent(
        name="Retirement Planner",
        system_prompt="I am a retirement planning specialist who helps individuals and businesses create comprehensive retirement strategies and investment plans.",
        agent_name="Retirement Planner",
        verbose=True
    ),
]

agents_tree2 = [
    TreeAgent(
        name="Stock Analyst",
        system_prompt="I am a stock market analyst who provides insights on market trends, stock recommendations, and portfolio optimization strategies.",
        agent_name="Stock Analyst",
        verbose=True
    ),
    TreeAgent(
        name="Investment Strategist",
        system_prompt="I am an investment strategist specializing in portfolio diversification, risk management, and market analysis.",
        agent_name="Investment Strategist",
        verbose=True
    ),
    TreeAgent(
        name="ROTH IRA Specialist",
        system_prompt="I am a ROTH IRA specialist who helps individuals optimize their retirement accounts and tax advantages.",
        agent_name="ROTH IRA Specialist",
        verbose=True
    ),
]

# Create trees
tree1 = Tree(tree_name="Financial Services Tree", agents=agents_tree1, verbose=True)
tree2 = Tree(tree_name="Investment & Trading Tree", agents=agents_tree2, verbose=True)

# Create the ForestSwarm
forest_swarm = ForestSwarm(
    name="Financial Services Forest",
    description="A comprehensive financial services multi-agent system",
    trees=[tree1, tree2],
    verbose=True
)

```

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

### Basic Server Setup with Swarms Agents

Source: https://docs.swarms.world/en/latest/swarms/structs/aop

Demonstrates how to create and deploy specialized agents (Research-Agent, Analysis-Agent) using the swarms library and the AOP class. It includes setting agent names, descriptions, models, and system prompts, then adding them to an AOP instance and running the server.

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

# Create specialized agents
research_agent = Agent(
    agent_name="Research-Agent",
    agent_description="Expert in research, data collection, and information gathering",
    model_name="anthropic/claude-sonnet-4-5",
    max_loops=1,
    top_p=None,
    dynamic_temperature_enabled=True,
    system_prompt="""You are a research specialist. Your role is to:
    1. Gather comprehensive information on any given topic
    2. Analyze data from multiple sources
    3. Provide well-structured research findings
    4. Cite sources and maintain accuracy
    5. Present findings in a clear, organized manner

    Always provide detailed, factual information with proper context.""",
)

analysis_agent = Agent(
    agent_name="Analysis-Agent",
    agent_description="Expert in data analysis, pattern recognition, and generating insights",
    model_name="anthropic/claude-sonnet-4-5",
    max_loops=1,
    top_p=None,
    dynamic_temperature_enabled=True,
    system_prompt="""You are an analysis specialist. Your role is to:
    1. Analyze data and identify patterns
    2. Generate actionable insights
    3. Create visualizations and summaries
    4. Provide statistical analysis
    5. Make data-driven recommendations

    Focus on extracting meaningful insights from information.""",
)

# Create AOP instance
deployer = AOP(
    server_name="MyAgentServer",
    port=8000,
    verbose=True,
    log_level="INFO"
)

# Add agents individually
deployer.add_agent(research_agent)
deployer.add_agent(analysis_agent)

# Start the server
deployer.run()

```

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

### Install Swarms Prerequisites on Ubuntu/Debian

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Installs necessary tools for Swarms development on Ubuntu or Debian systems. It updates the package list, installs Python 3.10 with pip, Git, and then installs Poetry using a script and adds it to the PATH.

```bash
# Update package list
sudo apt update

# Install Python 3.10 and pip
sudo apt install python3.10 python3.10-venv python3-pip git curl

# Install Poetry
curl -sSL https://install.python-poetry.org | python3 - 

# Add Poetry to PATH
export PATH="$HOME/.local/bin:$PATH"
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
```

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

### Initialize and Run LLM Council (Quick Start)

Source: https://docs.swarms.world/en/latest/swarms/examples/llm_council_examples

Demonstrates how to import the LLMCouncil, create an instance with default settings, and run a query. It shows how to access the final synthesized answer, original responses, and evaluation rankings.

```python
from swarms.structs.llm_council import LLMCouncil

# Create the council with default members
council = LLMCouncil(
    name="Decision Council",
    verbose=True,
    output_type="dict-all-except-first"
)

# Run a query
result = council.run("What are the key factors to consider when choosing a cloud provider for enterprise applications?")

# Access the final synthesized answer
print(result["final_response"])

# View individual member responses
print(result["original_responses"])

# See how members ranked each other
print(result["evaluations"])

```

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

### Install Swarms Prerequisites on Windows (Poetry)

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Installs Poetry on Windows using PowerShell. This command downloads the installation script from the official Poetry website and executes it using Python, setting up Poetry for dependency management.

```powershell
(Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python - 
```

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

### Use Financial Analysis Agent (Python)

Source: https://docs.swarms.world/en/latest/swarms/tools/tools_examples

Demonstrates how to run queries against the initialized 'Financial-Analysis-Agent'. Examples include asking for top cryptocurrencies, getting specific coin prices, and performing searches.

```python
# Example usage with different queries
response = agent.run("What are the top 5 cryptocurrencies by market cap?")
print(response)

# Query with specific parameters
response = agent.run("Get the current price of Bitcoin and Ethereum in EUR")
print(response)

# Search functionality
response = agent.run("Search for cryptocurrencies related to 'cardano'")
print(response)

```

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

### Install Loguru Logging Library (Shell)

Source: https://docs.swarms.world/en/latest/swarms/framework/code_cleanliness

This command installs the Loguru library, a Python package that simplifies logging. It is a prerequisite for using the advanced logging features demonstrated in subsequent examples.

```bash
pip install loguru

```

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

### Install Test Dependencies with Poetry

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Installs the dependencies required for running tests, including Pytest and its plugins, using Poetry. This command is used when tests fail due to missing testing-related packages.

```shell
# Install test dependencies
poetry install --with test
# or
pip install pytest pytest-cov pytest-mock
```

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

### Agent.run Method Examples (Python)

Source: https://docs.swarms.world/en/latest/swarms/structs/agent

Demonstrates various ways to use the `Agent.run` method, including basic task execution, image processing, answer validation with retries, and real-time streaming. It showcases how to combine different parameters for complex tasks.

```python
# Basic Usage
# Simple task execution
response = agent.run("Generate a report on financial performance.")

# Single Image Processing
# Process a single image
response = agent.run(
    task="Analyze this image and describe what you see",
    img="path/to/image.jpg"
)

# Multiple Image Processing
# Process multiple images concurrently
response = agent.run(
    task="Analyze these images and identify common patterns",
    imgs=["image1.jpg", "image2.png", "image3.jpeg"]
)

# Answer Validation with Retries
# Run until correct answer is found
response = agent.run(
    task="What is the capital of France?",
    correct_answer="Paris"
)

# Real-time Streaming
def streaming_callback(token: str):
    print(token, end="", flush=True)

response = agent.run(
    task="Tell me a long story about space exploration",
    streaming_callback=streaming_callback
)

# Combined Parameters
# Complex task with multiple features
response = agent.run(
    task="Analyze these financial charts and provide insights",
    imgs=["chart1.png", "chart2.png", "chart3.png"],
    correct_answer="market volatility",
    streaming_callback=my_callback
)
```

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

### Comprehensive X402 Agent with Discovery, Purchase, and Wallet Tools

Source: https://docs.swarms.world/en/latest/swarms/examples/x402_tools_agent

Sets up a comprehensive X402 agent capable of discovering services, managing wallet information, checking balances, and purchasing services. It utilizes asynchronous operations for network requests and integrates with `eth_account` for wallet functionalities. Dependencies include `os`, `asyncio`, `json`, `typing`, `eth_account`, `x402.clients.httpx`, `swarms`, `httpx`, and `dotenv`.

```python
import os
import asyncio
import json
from typing import Optional, Dict, Any, List
from eth_account import Account
from x402.clients.httpx import x402HttpxClient
from swarms import Agent
import httpx
from dotenv import load_dotenv

load_dotenv()


# Tool 1: Discover services
async def discover_services(
    limit: Optional[int] = None,
    max_price: Optional[int] = None,
) -> Dict[str, Any]:
    """Discover x402 services from the bazaar."""
    url = "https://api.cdp.coinbase.com/platform/v2/x402/discovery/resources"
    params = {}
    if limit:
        params["limit"] = limit * 5 if max_price else limit

    async with httpx.AsyncClient(timeout=30.0) as client:
        response = await client.get(url, params=params)
        response.raise_for_status()
        data = response.json()

    if max_price and "items" in data:
        filtered = [
            item for item in data.get("items", [])
            if any(
                int(accept.get("maxAmountRequired", "999999999"))
                <= max_price
                for accept in item.get("accepts", [])
            )
        ]
        data["items"] = filtered[:limit] if limit else filtered

    return data


def discover_services_sync(
    limit: Optional[int] = None,
    max_price: Optional[int] = None,
) -> str:
    """Synchronous wrapper for discovering services."""
    result = asyncio.run(discover_services(limit=limit, max_price=max_price))
    return json.dumps(result, indent=2)


# Tool 2: Get wallet info
def get_wallet_info() -> str:
    """Get wallet information from private key."""
    private_key = os.getenv("X402_PRIVATE_KEY")
    if not private_key:
        return json.dumps({"error": "Private key not found"})

    account = Account.from_key(private_key)
    info = {
        "wallet_address": account.address,
        "has_private_key": True,
        "network": "base-sepolia"
    }
    return json.dumps(info, indent=2)


# Tool 3: Check balance
def check_balance() -> str:
    """Check wallet balance."""
    private_key = os.getenv("X402_PRIVATE_KEY")
    if not private_key:
        return json.dumps({"error": "Private key not found"})

    account = Account.from_key(private_key)
    # In production, query blockchain
    balance = {
        "wallet_address": account.address,
        "usdc_balance": "100.00",
        "eth_balance": "0.5"
    }
    return json.dumps(balance, indent=2)


# Tool 4: Purchase service
async def purchase_service(
    base_url: str,
    endpoint: str,
) -> str:
    """Purchase a service from x402 bazaar."""
    private_key = os.getenv("X402_PRIVATE_KEY")
    if not private_key:
        return json.dumps({"error": "Private key not found"})

    account = Account.from_key(private_key)

    try:
        async with x402HttpxClient(account=account, base_url=base_url) as client:
            response = await client.get(endpoint)
            data = await response.aread()
            return json.dumps({
                "status": "success",
                "wallet": account.address,
                "response": data.decode()
            }, indent=2)
    except Exception as e:
        return json.dumps({"error": str(e)}, indent=2)


def purchase_service_sync(base_url: str, endpoint: str) -> str:
    """Synchronous wrapper for purchasing services."""
    return asyncio.run(purchase_service(base_url, endpoint))
```

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

### ReasoningAgentRouter: Basic Initialization and Task Execution (Python)

Source: https://docs.swarms.world/en/latest/swarms/agents/reasoning_agent_router

Demonstrates the basic initialization of the ReasoningAgentRouter with specific agent configurations and how to run a single task. It also shows how to execute a task that includes an image input.

```python
from swarms.agents.reasoning_agents import ReasoningAgentRouter

# Initialize the router
router = ReasoningAgentRouter(
    agent_name="reasoning-agent",
    description="A reasoning agent that can answer questions and help with tasks.",
    model_name="gpt-4o-mini",
    system_prompt="You are a helpful assistant that can answer questions and help with tasks.",
    max_loops=1,
    swarm_type="self-consistency",
    num_samples=3,
    eval=False,
    random_models_on=False,
    majority_voting_prompt=None
)

# Run a single task
result = router.run("What is the best approach to solve this problem?")

# Run with image input
result_with_image = router.run(
    "Analyze this image and provide insights",
    img="path/to/image.jpg"
)

```

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

### Clear Poetry Cache and Reinstall Dependencies

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Clears all cached packages for PyPI from Poetry and then performs a fresh installation of project dependencies, including development dependencies. This is a common solution for Poetry installation failures.

```shell
# Solution: Clear cache and reinstall
poetry cache clear --all pypi
poetry install --with dev
```

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

### Install Swarms Prerequisites on macOS

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Installs essential development tools for Swarms on macOS using Homebrew. This includes Python 3.10, Git, Poetry, and Node.js, ensuring the system meets the project's requirements.

```bash
# Install Homebrew if not already installed
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install prerequisites
brew install python@3.10 git poetry node
```

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

### Install and Verify Swarms CLI

Source: https://docs.swarms.world/en/latest/examples/cli_multi_agent_quickstart

Installs the Swarms library using pip and verifies that the CLI is accessible by running the help command. This is the first step to ensure the CLI tools are ready for use.

```bash
# Install swarms
pip install swarms

# Verify CLI is available
swarms --help

```

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

### Install X402 and Dependencies

Source: https://docs.swarms.world/en/latest/swarms/examples/x402_tools_agent

Installs the swarms, x402, eth-account, httpx, and python-dotenv libraries using pip. These are essential for building X402-enabled agents.

```bash
pip install swarms x402 eth-account httpx python-dotenv

```

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

### Environment Setup for Autonomous Agents

Source: https://docs.swarms.world/en/latest/swarms/examples/autonomous_agent_tutorial

Sets up environment variables for API keys and workspace directory. Requires a .env file with OPENAI_API_KEY, EXA_API_KEY, and WORKSPACE_DIR.

```plaintext
# .env file
OPENAI_API_KEY=your_openai_api_key_here
EXA_API_KEY=your_exa_api_key_here
WORKSPACE_DIR="agent_workspace"

```

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

### Install All Swarms Dependencies and Hooks

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Installs all dependency groups for Swarms development, including 'dev', 'lint', and 'test'. It also sets up pre-commit hooks for commit messages and runs all pre-commit hooks on existing files to ensure code quality.

```bash
# All dependency groups
poetry install --with dev,lint,test

# Pre-commit hooks
pre-commit install
pre-commit install --hook-type commit-msg

# Initial verification run
pre-commit run --all-files
```

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

### Initiate Interactive Onboarding with Swarms CLI

Source: https://docs.swarms.world/en/latest/swarms/cli/cli_reference

Starts a guided onboarding process for setting up Swarms, including API key configuration, environment setup, and basic agent creation.

```bash
swarms onboarding

```

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

### Build Documentation with MkDocs

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Navigates to the documentation directory and builds the project's documentation using MkDocs. This verifies that the documentation can be generated successfully.

```shell
cd docs
mkdocs build
echo "✅ Documentation built successfully"
```

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

### Code Generation Agent Example with CLI

Source: https://docs.swarms.world/en/latest/swarms/cli/cli_agent_guide

Illustrates the creation of a code generation agent. This example highlights parameters suitable for developing and writing code, focusing on Python.

```bash
swarms agent \
    --name "Code-Generator" \
    --description "Expert Python developer and code generator" \
    --system-prompt "You are an expert Python developer. Write clean, efficient, well-documented code following PEP 8 guidelines. Include type hints and docstrings." \
    --task "Create a Python class for managing a task queue with priority scheduling" \
    --model-name "gpt-4" \
    --temperature 0.1 \
    --streaming-on
```

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

### Setup and Environment Commands for Swarm World

Source: https://docs.swarms.world/en/latest/swarms/cli/cli_reference

Commands to set up the Swarm World environment, check for necessary dependencies, and view available features. These are essential for getting started with Swarm World.

```bash
swarms setup-check --verbose
swarms onboarding
swarms features
swarms help
```

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

### Quick Start: Initialize and Run Hierarchical Communication Framework

Source: https://docs.swarms.world/en/latest/swarms/structs/hierarchical_structured_communication_framework

Demonstrates how to initialize specialized agents (Generator, Evaluator, Refiner, Supervisor) and the main HierarchicalStructuredCommunicationFramework. It then shows how to run a task using the framework.

```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")

```

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

### Python Agent Setup and Task Execution with MCP

Source: https://docs.swarms.world/en/latest/swarms/structs/agent_mcp

Demonstrates how to set up a Swarms agent, connect it to an MCP service, and execute tasks. This includes initializing the agent with specific parameters like name, MCP URL, output type, and maximum loops, followed by running a query.

```python
# Basic setup
from swarms import Agent

agent = Agent(
    agent_name="Your-Agent",
    mcp_url="http://localhost:8000/mcp",
    output_type="json",
    max_loops=2
)

# Execute task
result = agent.run("Your query here")

# Common patterns
crypto_query = "Get Bitcoin price"
analysis_query = "Analyze Tesla stock performance"
research_query = "Research recent AI developments"

```

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

### Financial Analyst Agent Example with CLI

Source: https://docs.swarms.world/en/latest/swarms/cli/cli_agent_guide

Demonstrates the creation of a specialized financial analyst agent. This example showcases the use of specific parameters for market analysis tasks.

```bash
swarms agent \
    --name "Financial-Analyst" \
    --description "Expert financial analysis and market insights" \
    --system-prompt "You are a CFA-certified financial analyst. Provide detailed market analysis with data-driven insights. Include risk assessments and recommendations." \
    --task "Analyze Apple (AAPL) stock performance and provide investment outlook for Q4 2024" \
    --model-name "gpt-4" \
    --temperature 0.2 \
    --max-loops 5 \
    --verbose
```

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

### Manage Python Versions with Pyenv

Source: https://docs.swarms.world/en/latest/contributors/environment_setup

Installs a specific Python version (3.10.12) using pyenv and sets it as the local version for the current directory. Pyenv is a tool for managing multiple Python versions.

```shell
# Use pyenv to manage Python versions
curl https://pyenv.run | bash
pyenv install 3.10.12
pyenv local 3.10.12
```

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

### LLM Council Quick Start - Python

Source: https://docs.swarms.world/en/latest/swarms/structs/llm_council

Demonstrates how to initialize and run the LLMCouncil for multi-perspective analysis. This example shows creating a council, defining a query, running the council, and accessing the results in various formats (list of messages, final response, full conversation string, JSON export).

```python
from swarms.structs.llm_council import LLMCouncil

# Create the council with default output format
council = LLMCouncil(verbose=True)

# Example query
query = "What are the top five best energy stocks across nuclear, solar, gas, and other energy sources?"

# Run the council - returns formatted conversation
result = council.run(query)

# With default "dict" output_type, result is a list of message dictionaries
# Print all messages
for message in result:
    role = message['role']
    content = message['content']
    print(f"\n{role}:")
    print(content[:500] + "..." if len(content) > 500 else content)

# Access conversation object directly for more options
conversation = council.conversation

# Get only the final response
print("\n" + "="*80)
print("FINAL RESPONSE")
print("="*80)
print(conversation.get_final_message_content())

# Get conversation as formatted string
print("\n" + "="*80)
print("FULL CONVERSATION")
print("="*80)
print(conversation.get_str())

# Export conversation to JSON
conversation.export()
```
Tokens:
Raw