diff --git a/docs/llm.txt b/docs/llm.txt
index 692944af..bfe3be1e 100644
--- a/docs/llm.txt
+++ b/docs/llm.txt
@@ -1,22 +1,4 @@
-# File: agent_deployment_solutions.md
-
-1. make agent api - fastapi
-2. make agent cron job
-3. agents that listen that could listen to events
-4. run on startup, every time the machine starts
-4. docker
-5. kubernetes
-6. aws or google cloud etc
-
-
-
-user -> build agent -> user now need deploy agent
-
-FAST
-
---------------------------------------------------
-
-# File: concepts\limitations.md
+# File: concepts/limitations.md
# Limitations of Individual Agents
@@ -181,7 +163,7 @@ The next section explores how [Multi-Agent Architecture](architecture.md) addres
--------------------------------------------------
-# File: contributors\docs.md
+# File: contributors/docs.md
# Contributing to Swarms Documentation
@@ -553,7 +535,7 @@ We look forward to your pull requests, feedback, and ideas.
--------------------------------------------------
-# File: contributors\environment_setup.md
+# File: contributors/environment_setup.md
# Environment Setup Guide for Swarms Contributors
@@ -1250,233 +1232,52 @@ Happy coding! 🚀
--------------------------------------------------
-# File: contributors\main.md
-
-# Contributing to Swarms: Building the Infrastructure for The Agentic Economy
-
-Multi-agent collaboration is the most important technology in human history. It will reshape civilization by enabling billions of autonomous agents to coordinate and solve problems at unprecedented scale.
-
-!!! success "The Foundation of Tomorrow"
- **Swarms** is the foundational infrastructure powering this autonomous economy. By contributing, you're building the systems that will enable the next generation of intelligent automation.
-
-### What You're Building
-
-=== "Autonomous Systems"
- **Autonomous Resource Allocation**
-
- Global supply chains and energy distribution optimized in real-time
-
-=== "Intelligence Networks"
- **Distributed Decision Making**
-
- Collaborative intelligence networks across industries and governments
-
-=== "Smart Markets"
- **Self-Organizing Markets**
-
- Agent-driven marketplaces that automatically balance supply and demand
-
-=== "Problem Solving"
- **Collaborative Problem Solving**
-
- Massive agent swarms tackling climate change, disease, and scientific discovery
-
-=== "Infrastructure"
- **Adaptive Infrastructure**
-
- Self-healing systems that evolve without human intervention
-
----
-
-## Why Contribute to Swarms?
-
-### :material-rocket-launch: Shape the Future of Civilization
+# File: contributors/main.md
-!!! abstract "Your Impact"
- - Define standards for multi-agent communication protocols
- - Build architectural patterns for distributed intelligence systems
- - Create frameworks for deploying agent swarms in production
- - Establish ethical guidelines for autonomous agent collaboration
+# Contribute to Swarms
-### :material-trophy: Recognition and Professional Development
+Our mission is to accelerate the transition to a fully autonomous world economy by providing enterprise-grade, production-ready infrastructure that enables seamless deployment and orchestration of millions of autonomous agents. We are creating the operating system for the agent economy, and we need your help to achieve this goal.
-!!! tip "Immediate Recognition"
- - **Social Media Features** - All merged PRs showcased publicly
- - **Bounty Programs** - Financial rewards for high-impact contributions
- - **Fast-Track Hiring** - Priority consideration for core team positions
- - **Community Spotlights** - Regular recognition and acknowledgments
+Swarms is built by the community, for the community. We believe that collaborative development is the key to pushing the boundaries of what's possible with multi-agent AI. Your contributions are not only welcome—they are essential to our mission. [Learn more about why you should contribute to Swarms](https://docs.swarms.world/en/latest/contributors/main/)
-!!! info "Career Benefits"
- - Multi-agent expertise highly valued by AI industry
- - Portfolio demonstrates cutting-edge technical skills
- - Direct networking with leading researchers and companies
- - Thought leadership opportunities in emerging field
+### Why Contribute?
-### :material-brain: Technical Expertise Development
+By joining us, you have the opportunity to:
-Master cutting-edge technologies:
+* **Work on the Frontier of Agents:** Shape the future of autonomous agent technology and help build a production-grade, open-source framework.
-| Technology Area | Skills You'll Develop |
-|----------------|----------------------|
-| **Swarm Intelligence** | Design sophisticated agent coordination mechanisms |
-| **Distributed Computing** | Build scalable architectures for thousands of agents |
-| **Communication Protocols** | Create novel interaction patterns |
-| **Production AI** | Deploy and orchestrate enterprise-scale systems |
-| **Research Implementation** | Turn cutting-edge papers into working code |
+* **Join a Vibrant Community:** Collaborate with a passionate and growing group of agent developers, researchers, and agent enthusasits.
-### :material-account-group: Research Community Access
+* **Make a Tangible Impact:** Whether you're fixing a bug, adding a new feature, or improving documentation, your work will be used in real-world applications.
-!!! note "Collaborative Environment"
- - Work with experts from academic institutions and industry
- - Regular technical seminars and research discussions
- - Structured mentorship from experienced contributors
- - Applied research opportunities with real-world impact
+* **Learn and Grow:** Gain hands-on experience with advanced AI concepts and strengthen your software engineering skills.
----
+Discover more about our mission and the benefits of becoming a contributor in our official [**Contributor's Guide**](https://docs.swarms.world/en/latest/contributors/main/).
-## Contribution Opportunities
+### How to Get Started
-=== "New Contributors"
- ### :material-school: Perfect for Getting Started
-
- - **Documentation** - Improve guides, tutorials, and API references
- - **Bug Reports** - Identify and document issues
- - **Code Quality** - Participate in testing and review processes
- - **Community Support** - Help users in forums and discussions
+We've made it easy to start contributing. Here's how you can help:
-=== "Experienced Developers"
- ### :material-code-braces: Advanced Technical Work
-
- - **Core Architecture** - Design fundamental system components
- - **Performance Optimization** - Enhance coordination and communication efficiency
- - **Research Implementation** - Turn cutting-edge papers into working code
- - **Integration Development** - Build connections with AI tools and platforms
+1. **Find an Issue to Tackle:** The best way to begin is by visiting our [**contributing project board**](https://github.com/users/kyegomez/projects/1). Look for issues tagged with `good first issue`—these are specifically selected for new contributors.
-=== "Researchers"
- ### :material-flask: Research and Innovation
-
- - **Algorithm Development** - Implement novel multi-agent algorithms
- - **Experimental Frameworks** - Create evaluation and benchmarking tools
- - **Theoretical Contributions** - Develop research documentation and frameworks
- - **Academic Collaboration** - Partner on funded research projects
+2. **Report a Bug or Request a Feature:** Have a new idea or found something that isn't working right? We'd love to hear from you. Please [**file a Bug Report or Feature Request**](https://github.com/kyegomez/swarms/issues) on our GitHub Issues page.
----
+3. **Understand Our Workflow and Standards:** Before submitting your work, please review our complete [**Contribution Guidelines**](https://github.com/kyegomez/swarms/blob/master/CONTRIBUTING.md). To help maintain code quality, we also encourage you to read our guide on [**Code Cleanliness**](https://docs.swarms.world/en/latest/swarms/framework/code_cleanliness/).
-## How to Contribute
+4. **Join the Discussion:** To participate in roadmap discussions and connect with other developers, join our community on [**Discord**](https://discord.gg/EamjgSaEQf).
-### Step 1: Get Started
-!!! info "Essential Resources"
- [:material-book-open-page-variant: **Documentation**](https://docs.swarms.world/en/latest/){ .md-button .md-button--primary }
- [:material-github: **GitHub Repository**](https://github.com/kyegomez/swarms){ .md-button }
- [:material-chat: **Community Channels**](#){ .md-button }
+### ✨ Our Valued Contributors
-### Step 2: Find Your Path
+Thank you for contributing to swarms. Your work is extremely appreciated and recognized.
-```mermaid
-graph TD
- A[Choose Your Path] --> B[Browse Issues]
- A --> C[Review Roadmap]
- A --> D[Propose Ideas]
- B --> E[good first issue]
- B --> F[help wanted]
- C --> G[Core Features]
- C --> H[Research Areas]
- D --> I[Discussion Forums]
-```
-
-### Step 3: Make Impact
-
-1. **Fork & Setup** - Configure your development environment
-2. **Develop** - Create your contribution
-3. **Submit** - Open a pull request
-4. **Collaborate** - Work with maintainers
-5. **Celebrate** - See your work recognized
-
----
-
-## Recognition Framework
-
-### :material-flash: Immediate Benefits
-
-!!! success "Instant Recognition"
- | Benefit | Description |
- |---------|-------------|
- | **Social Media Features** | Every merged PR showcased publicly |
- | **Community Recognition** | Contributor badges and documentation credits |
- | **Professional References** | Formal acknowledgment for portfolios |
- | **Direct Mentorship** | Access to core team guidance |
-
-### :material-trending-up: Long-term Opportunities
-
-!!! tip "Career Growth"
- - **Team Positions** - Fast-track consideration for core team roles
- - **Conference Speaking** - Present work at AI conferences and events
- - **Industry Connections** - Network with leading AI organizations
- - **Research Collaboration** - Partner with academic institutions
-
----
-
-## Societal Impact
-
-!!! abstract "Building Solutions for Humanity"
- Swarms enables technology that addresses critical challenges:
-
- === "Research"
- **Scientific Research**
-
- Accelerate collaborative research and discovery across disciplines
-
- === "Healthcare"
- **Healthcare Innovation**
-
- Support drug discovery and personalized medicine development
-
- === "Environment"
- **Environmental Solutions**
-
- Monitor climate and optimize sustainability initiatives
-
- === "Education"
- **Educational Technology**
-
- Create adaptive learning systems for personalized education
-
- === "Economy"
- **Economic Innovation**
-
- Generate new opportunities and efficiency improvements
-
----
-
-## Get Involved
-
-### :material-link: Connect With Us
-
-!!! info "Join the Community"
- [:material-github: **GitHub Repository**](https://github.com/kyegomez/swarms){ .md-button .md-button--primary }
- [:material-book: **Documentation**](https://docs.swarms.world/en/latest/){ .md-button }
- [:material-forum: **Community Forums**](#){ .md-button }
-
----
-
-!!! warning "The Future is Now"
- Multi-agent collaboration will define the next century of human progress. The autonomous economy depends on the infrastructure we build today.
-
-!!! success "Your Mission"
- Your contribution to Swarms helps create the foundation for billions of autonomous agents working together to solve humanity's greatest challenges.
-
- **Join us in building the most important technology of our time.**
-
----
-
-
-*Built with :material-heart: by the global Swarms community*
-
+
+ 
+
--------------------------------------------------
-# File: contributors\tools.md
+# File: contributors/tools.md
# Contributing Tools and Plugins to the Swarms Ecosystem
@@ -1716,6 +1517,620 @@ To begin, fork the [Swarms Tools repository](https://github.com/The-Swarm-Corpor
+--------------------------------------------------
+
+# File: deployment_solutions/fastapi_agent_api.md
+
+# FastAPI Agent API
+
+This guide shows you how to deploy your Swarms agents as REST APIs using FastAPI and Uvicorn. This is the fastest way to expose your agents via HTTP endpoints.
+
+## Overview
+
+FastAPI is a modern, fast web framework for building APIs with Python. Combined with Uvicorn (ASGI server), it provides excellent performance and automatic API documentation.
+
+**Benefits:**
+
+| Feature | Description |
+|----------------|--------------------------------------------------|
+| **Fast** | Built on Starlette and Pydantic |
+| **Auto-docs** | Automatic OpenAPI/Swagger documentation |
+| **Type-safe** | Full type hints and validation |
+| **Easy** | Minimal boilerplate code |
+| **Monitoring** | Built-in logging and metrics |
+
+## Quick Start
+
+### 1. Install Dependencies
+
+```bash
+pip install fastapi uvicorn swarms
+```
+
+### 2. Create Your Agent API
+
+Create a file called `agent_api.py`:
+
+```python
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from swarms import Agent
+import uvicorn
+from typing import Optional, Dict, Any
+
+# Initialize FastAPI app
+app = FastAPI(
+ title="Swarms Agent API",
+ description="REST API for Swarms agents",
+ version="1.0.0"
+)
+
+# Pydantic models for request/response
+class AgentRequest(BaseModel):
+ """Request model for agent tasks"""
+ task: str
+ agent_name: Optional[str] = "default"
+ max_loops: Optional[int] = 1
+ temperature: Optional[float] = None
+
+class AgentResponse(BaseModel):
+ """Response model for agent tasks"""
+ success: bool
+ result: str
+ agent_name: str
+ task: str
+ execution_time: Optional[float] = None
+
+# Initialize your agent (you can customize this)
+def create_agent(agent_name: str = "default") -> Agent:
+ """Create and return a configured agent"""
+ return Agent(
+ agent_name=agent_name,
+ agent_description="Versatile AI agent for various tasks",
+ system_prompt="""You are a helpful AI assistant that can handle a wide variety of tasks.
+ You provide clear, accurate, and helpful responses while maintaining a professional tone.
+ Always strive to be thorough and accurate in your responses.""",
+ model_name="claude-sonnet-4-20250514",
+ dynamic_temperature_enabled=True,
+ max_loops=1,
+ dynamic_context_window=True,
+ )
+
+# API endpoints
+@app.get("/")
+async def root():
+ """Health check endpoint"""
+ return {"message": "Swarms Agent API is running!", "status": "healthy"}
+
+@app.get("/health")
+async def health_check():
+ """Detailed health check"""
+ return {
+ "status": "healthy",
+ "service": "Swarms Agent API",
+ "version": "1.0.0"
+ }
+
+@app.post("/agent/run", response_model=AgentResponse)
+async def run_agent(request: AgentRequest):
+ """Run an agent with the specified task"""
+ try:
+ import time
+ start_time = time.time()
+
+ # Create agent instance
+ agent = create_agent(request.agent_name)
+
+ # Run the agent
+ result = agent.run(
+ task=request.task,
+ max_loops=request.max_loops
+ )
+
+ execution_time = time.time() - start_time
+
+ return AgentResponse(
+ success=True,
+ result=str(result),
+ agent_name=request.agent_name,
+ task=request.task,
+ execution_time=execution_time
+ )
+
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Agent execution failed: {str(e)}")
+
+@app.post("/agent/chat")
+async def chat_with_agent(request: AgentRequest):
+ """Chat with an agent (conversational mode)"""
+ try:
+ agent = create_agent(request.agent_name)
+
+ # For chat, you might want to maintain conversation history
+ # This is a simple implementation
+ result = agent.run(
+ task=request.task,
+ max_loops=request.max_loops
+ )
+
+ return {
+ "success": True,
+ "response": str(result),
+ "agent_name": request.agent_name
+ }
+
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Chat failed: {str(e)}")
+
+@app.get("/agents/available")
+async def list_available_agents():
+ """List available agent configurations"""
+ return {
+ "agents": [
+ {
+ "name": "default",
+ "description": "Versatile AI agent for various tasks",
+ "model": "claude-sonnet-4-20250514"
+ },
+ {
+ "name": "quantitative-trading",
+ "description": "Advanced quantitative trading and algorithmic analysis agent",
+ "model": "claude-sonnet-4-20250514"
+ }
+ ]
+ }
+
+# Custom agent endpoint example
+@app.post("/agent/quantitative-trading")
+async def run_quantitative_trading_agent(request: AgentRequest):
+ """Run the quantitative trading agent specifically"""
+ try:
+ # Create specialized quantitative trading agent
+ agent = Agent(
+ agent_name="Quantitative-Trading-Agent",
+ agent_description="Advanced quantitative trading and algorithmic analysis agent",
+ system_prompt="""You are an expert quantitative trading agent with deep expertise in:
+ - Algorithmic trading strategies and implementation
+ - Statistical arbitrage and market making
+ - Risk management and portfolio optimization
+ - High-frequency trading systems
+ - Market microstructure analysis
+ - Quantitative research methodologies
+ - Financial mathematics and stochastic processes
+ - Machine learning applications in trading""",
+ model_name="claude-sonnet-4-20250514",
+ dynamic_temperature_enabled=True,
+ max_loops=request.max_loops,
+ dynamic_context_window=True,
+ )
+
+ result = agent.run(task=request.task)
+
+ return {
+ "success": True,
+ "result": str(result),
+ "agent_name": "Quantitative-Trading-Agent",
+ "task": request.task
+ }
+
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Quantitative trading agent failed: {str(e)}")
+
+if __name__ == "__main__":
+ uvicorn.run(app, host="0.0.0.0", port=8000)
+```
+
+### 3. Run Your API
+
+```bash
+python agent_api.py
+```
+
+Or with uvicorn directly:
+
+```bash
+uvicorn agent_api:app --host 0.0.0.0 --port 8000 --reload
+```
+
+### 4. Test Your API
+
+Your API will be available at:
+
+- **API**: http://localhost:8000
+
+- **Documentation**: http://localhost:8000/docs
+
+- **Alternative docs**: http://localhost:8000/redoc
+
+## Usage Examples
+
+### Using curl
+
+```bash
+# Basic agent task
+curl -X POST "http://localhost:8000/agent/run" \
+ -H "Content-Type: application/json" \
+ -d '{"task": "What are the best top 3 ETFs for gold coverage?"}'
+
+# Quantitative trading agent
+curl -X POST "http://localhost:8000/agent/quantitative-trading" \
+ -H "Content-Type: application/json" \
+ -d '{"task": "Analyze the current market conditions for gold ETFs"}'
+```
+
+### Using Python requests
+
+```python
+import requests
+
+# Run basic agent
+response = requests.post(
+ "http://localhost:8000/agent/run",
+ json={"task": "Explain quantum computing in simple terms"}
+)
+print(response.json())
+
+# Run quantitative trading agent
+response = requests.post(
+ "http://localhost:8000/agent/quantitative-trading",
+ json={"task": "What are the key factors affecting gold prices today?"}
+)
+print(response.json())
+```
+
+## Advanced Configuration
+
+### Environment Variables
+
+Create a `.env` file for configuration:
+
+```bash
+# .env
+AGENT_MODEL_NAME=claude-sonnet-4-20250514
+AGENT_MAX_LOOPS=3
+API_HOST=0.0.0.0
+API_PORT=8000
+LOG_LEVEL=info
+```
+
+### Enhanced Agent Factory
+
+```python
+import os
+from typing import Dict, Type
+from swarms import Agent
+
+class AgentFactory:
+ """Factory for creating different types of agents"""
+
+ AGENT_CONFIGS = {
+ "default": {
+ "agent_name": "Default-Agent",
+ "agent_description": "Versatile AI agent for various tasks",
+ "system_prompt": "You are a helpful AI assistant...",
+ "model_name": "claude-sonnet-4-20250514"
+ },
+ "quantitative-trading": {
+ "agent_name": "Quantitative-Trading-Agent",
+ "agent_description": "Advanced quantitative trading agent",
+ "system_prompt": "You are an expert quantitative trading agent...",
+ "model_name": "claude-sonnet-4-20250514"
+ },
+ "research": {
+ "agent_name": "Research-Agent",
+ "agent_description": "Academic research and analysis agent",
+ "system_prompt": "You are an expert research agent...",
+ "model_name": "claude-sonnet-4-20250514"
+ }
+ }
+
+ @classmethod
+ def create_agent(cls, agent_type: str = "default", **kwargs) -> Agent:
+ """Create an agent of the specified type"""
+ if agent_type not in cls.AGENT_CONFIGS:
+ raise ValueError(f"Unknown agent type: {agent_type}")
+
+ config = cls.AGENT_CONFIGS[agent_type].copy()
+ config.update(kwargs)
+
+ return Agent(**config)
+```
+
+### Authentication & Rate Limiting
+
+```python
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
+import time
+
+# Rate limiting
+limiter = Limiter(key_func=get_remote_address)
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
+# Security
+security = HTTPBearer()
+
+def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
+ """Verify API token"""
+ # Implement your token verification logic here
+ if credentials.credentials != "your-secret-token":
+ raise HTTPException(
+ status_code=status.HTTP_401_UNAUTHORIZED,
+ detail="Invalid token"
+ )
+ return credentials.credentials
+
+@app.post("/agent/run", response_model=AgentResponse)
+@limiter.limit("10/minute")
+async def run_agent(
+ request: AgentRequest,
+ token: str = Depends(verify_token)
+):
+ """Run an agent with authentication and rate limiting"""
+ # ... existing code ...
+```
+
+## Production Deployment
+
+### Using Gunicorn
+
+```bash
+pip install gunicorn
+gunicorn agent_api:app -w 4 -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000
+```
+
+### Using Docker
+
+```dockerfile
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 8000
+
+CMD ["uvicorn", "agent_api:app", "--host", "0.0.0.0", "--port", "8000"]
+```
+
+### Using Docker Compose
+
+```yaml
+version: '3.8'
+services:
+ agent-api:
+ build: .
+ ports:
+ - "8000:8000"
+ environment:
+ - AGENT_MODEL_NAME=claude-sonnet-4-20250514
+ volumes:
+ - ./logs:/app/logs
+```
+
+## Monitoring & Logging
+
+### Structured Logging
+
+```python
+import logging
+import json
+from datetime import datetime
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+@app.middleware("http")
+async def log_requests(request, call_next):
+ """Log all requests and responses"""
+ start_time = time.time()
+
+ # Log request
+ logger.info(f"Request: {request.method} {request.url}")
+
+ response = await call_next(request)
+
+ # Log response
+ process_time = time.time() - start_time
+ logger.info(f"Response: {response.status_code} - {process_time:.2f}s")
+
+ return response
+```
+
+### Health Checks
+
+```python
+@app.get("/health/detailed")
+async def detailed_health_check():
+ """Detailed health check with agent status"""
+ try:
+ # Test agent creation
+ agent = create_agent()
+
+ return {
+ "status": "healthy",
+ "timestamp": datetime.utcnow().isoformat(),
+ "agent_status": "available",
+ "model_status": "connected"
+ }
+ except Exception as e:
+ return {
+ "status": "unhealthy",
+ "timestamp": datetime.utcnow().isoformat(),
+ "error": str(e)
+ }
+```
+
+## Best Practices
+
+| Best Practice | Description |
+|----------------------|-----------------------------------------------------------|
+| **Error Handling** | Always wrap agent execution in try-catch blocks |
+| **Validation** | Use Pydantic models for request validation |
+| **Rate Limiting** | Implement rate limiting for production APIs |
+| **Authentication** | Add proper authentication for sensitive endpoints |
+| **Logging** | Log all requests and responses for debugging |
+| **Monitoring** | Add health checks and metrics |
+| **Testing** | Write tests for your API endpoints |
+| **Documentation** | Keep your API documentation up to date |
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Port already in use**: Change the port in the uvicorn command
+2. **Agent initialization fails**: Check your API keys and model configuration
+3. **Memory issues**: Reduce `max_loops` or implement streaming responses
+4. **Timeout errors**: Increase timeout settings for long-running tasks
+
+### Performance Tips
+
+| Performance Tip | Description |
+|--------------------------|-----------------------------------------------------|
+| **Connection pooling** | Reuse agent instances when possible |
+| **Async operations** | Use async/await for I/O operations |
+| **Caching** | Cache frequently requested responses |
+| **Load balancing** | Use multiple worker processes for high traffic |
+
+
+Your FastAPI agent API is now ready to handle requests and scale with your needs!
+
+
+--------------------------------------------------
+
+# File: deployment_solutions/overview.md
+
+# Deployment Solutions Overview
+
+This section covers various deployment strategies for Swarms agents and multi-agent systems, from simple local deployments to enterprise-grade cloud solutions.
+
+## Deployment Types Comparison & Documentation
+
+| Deployment Type | Use Case | Complexity | Scalability | Cost | Best For | Documentation Link | Status |
+|------------------------|---------------------|------------|-------------|-----------|----------------------------------|-----------------------------------------------------------------------------|------------|
+| **FastAPI + Uvicorn** | REST API endpoints | Low | Medium | Low | Quick prototypes, internal tools | [FastAPI Agent API Guide](fastapi_agent_api.md) | Available |
+| **Cron Jobs** | Scheduled tasks | Low | Low | Very Low | Batch processing, periodic tasks | [Cron Job Examples](../../examples/deployment_solutions/cron_job_examples/) | Available |
+
+
+## Quick Start Guide
+
+### 1. FastAPI + Uvicorn (Recommended for APIs)
+
+- **Best for**: Creating REST APIs for your agents
+
+- **Setup time**: 5-10 minutes
+
+- **Documentation**: [FastAPI Agent API](fastapi_agent_api.md)
+
+- **Example Code**: [FastAPI Example](../../examples/deployment_solutions/fastapi_agent_api_example.py)
+
+
+### 2. Cron Jobs (Recommended for scheduled tasks)
+
+- **Best for**: Running agents on a schedule
+
+- **Setup time**: 2-5 minutes
+
+- **Examples**: [Cron Job Examples](../../examples/deployment_solutions/cron_job_examples/)
+
+
+
+## Deployment Considerations
+
+### Performance
+
+- **FastAPI**: Excellent for high-throughput APIs
+
+- **Cron Jobs**: Good for batch processing
+
+- **Docker**: Consistent performance across environments
+
+- **Kubernetes**: Best for complex, scalable systems
+
+
+### Security
+
+- **FastAPI**: Built-in security features, easy to add authentication
+
+- **Cron Jobs**: Runs with system permissions
+
+- **Docker**: Isolated environment, security best practices
+
+- **Kubernetes**: Advanced security policies and RBAC
+
+
+### Monitoring & Observability
+
+- **FastAPI**: Built-in logging, easy to integrate with monitoring tools
+
+- **Cron Jobs**: Basic logging, requires custom monitoring setup
+
+- **Docker**: Container-level monitoring, easy to integrate
+
+- **Kubernetes**: Comprehensive monitoring and alerting
+
+
+### Cost Optimization
+
+- **FastAPI**: Pay for compute resources
+
+- **Cron Jobs**: Minimal cost, runs on existing infrastructure
+
+- **Docker**: Efficient resource utilization
+
+- **Kubernetes**: Advanced resource management and auto-scaling
+
+
+## Choosing the Right Deployment
+
+### For Development & Testing
+
+- **FastAPI + Uvicorn**: Quick setup, easy debugging
+
+- **Cron Jobs**: Simple scheduled tasks
+
+
+### For Production APIs
+
+- **FastAPI + Docker**: Reliable, scalable
+
+- **Cloud Run**: Auto-scaling, managed infrastructure
+
+
+### For Enterprise Systems
+
+- **Kubernetes**: Full control, advanced features
+
+- **Hybrid approach**: Mix of deployment types based on use case
+
+
+### For Cost-Sensitive Projects
+
+- **Cron Jobs**: Minimal infrastructure cost
+
+- **Cloud Functions**: Pay-per-use model
+
+- **FastAPI**: Efficient resource utilization
+
+
+## Next Steps
+
+1. **Start with FastAPI** if you need an API endpoint
+2. **Use Cron Jobs** for scheduled tasks
+3. **Move to Docker** when you need consistency
+4. **Consider Kubernetes** for complex, scalable systems
+
+Each deployment solution includes detailed examples and step-by-step guides to help you get started quickly.
+
+
--------------------------------------------------
# File: docs_structure.md
@@ -1746,7 +2161,7 @@ Benefits of class/structure, and more
--------------------------------------------------
-# File: examples\agent_stream.md
+# File: examples/agent_stream.md
# Agent with Streaming
@@ -1814,7 +2229,54 @@ If you'd like technical support, join our Discord below and stay updated on our
--------------------------------------------------
-# File: examples\cookbook_index.md
+# File: examples/community_resources.md
+
+# Community Resources
+
+Welcome to the Community Resources page! Here you'll find a curated collection of articles, tutorials, and guides created by the Swarms community and core contributors.
+
+These resources cover a wide range of topics, including building your first agent, advanced multi-agent architectures, API integrations, and using Swarms with both Python and Rust. Whether you're a beginner or an experienced developer, these links will help you deepen your understanding and accelerate your development with the Swarms framework.
+
+
+## Swarms Python
+
+| Title | Description | Link |
+|-------|-------------|------|
+| **Build Your First Swarms Agent in Under 10 Minutes** | Step-by-step beginner guide to creating your first Swarms agent quickly. | [Read Article](https://medium.com/@devangvashistha/build-your-first-swarms-agent-in-under-10-minutes-ddff23b6c703) |
+| **Building Multi-Agent Systems with GPT-5 and The Swarms Framework** | Learn how to leverage GPT-5 with Swarms for advanced multi-agent system design. | [Read Article](https://medium.com/@kyeg/building-multi-agent-systems-with-gpt-5-and-the-swarms-framework-e52ffaf0fa4f) |
+| **Learn How to Build Production-Grade Agents with OpenAI’s Latest Model: GPT-OSS Locally and in the Cloud** | Guide to building robust agents using OpenAI’s GPT-OSS, both locally and in cloud environments. | [Read Article](https://medium.com/@kyeg/learn-how-to-build-production-grade-agents-with-openais-latest-model-gpt-oss-locally-and-in-the-c5826c7cca7c) |
+| **Building Gemini 2.5 Agents with Swarms Framework** | Tutorial on integrating Gemini 2.5 models into Swarms agents for enhanced capabilities. | [Read Article](https://medium.com/@kyeg/building-gemini-2-5-agents-with-swarms-framework-20abdcf82cac) |
+| **Enterprise Developer Guide: Leveraging OpenAI’s o3 and o4-mini Models with The Swarms Framework** | Enterprise-focused guide to using OpenAI’s o3 and o4-mini models within Swarms. | [Read Article](https://medium.com/@kyeg/enterprise-developer-guide-leveraging-openais-o3-and-o4-mini-models-with-the-swarms-framework-89490c57820a) |
+| **Enneagram of Thoughts Using the Swarms Framework: A Multi-Agent Approach to Holistic Problem Solving** | Explores using Swarms for holistic, multi-perspective problem solving via the Enneagram model. | [Read Article](https://medium.com/@kyeg/enneagram-of-thoughts-using-the-swarms-framework-a-multi-agent-approach-to-holistic-problem-c26c7df5e7eb) |
+| **Building Production-Grade Financial Agents with tickr-agent: An Enterprise Solution for Comprehensive Stock Analysis** | How to build advanced financial analysis agents using tickr-agent and Swarms. | [Read Article](https://medium.com/@kyeg/building-production-grade-financial-agents-with-tickr-agent-an-enterprise-solution-for-db867ec93193) |
+| **Automating Your Startup’s Financial Analysis Using AI Agents: A Comprehensive Guide** | Comprehensive guide to automating your startup’s financial analysis with AI agents using Swarms. | [Read Article](https://medium.com/@kyeg/automating-your-startups-financial-analysis-using-ai-agents-a-comprehensive-guide-b2fa0e2c09d5) |
+| **Managing Thousands of Agent Outputs at Scale with The Spreadsheet Swarm: All-New Multi-Agent Architecture** | Learn how to manage and scale thousands of agent outputs efficiently using the Spreadsheet Swarm architecture. | [Read Article](https://medium.com/@kyeg/managing-thousands-of-agent-outputs-at-scale-with-the-spreadsheet-swarm-all-new-multi-agent-f16f5f40fd5a) |
+| **Introducing GPT-4o Mini: The Future of Cost-Efficient AI Intelligence** | Discover the capabilities and advantages of GPT-4o Mini for building cost-effective, intelligent agents. | [Read Article](https://medium.com/@kyeg/introducing-gpt-4o-mini-the-future-of-cost-efficient-ai-intelligence-a3e3fe78d939) |
+| **Introducing Swarm's GraphWorkflow: A Faster, Simpler, and Superior Alternative to LangGraph** | Learn about Swarms' GraphWorkflow, a powerful alternative to LangGraph that offers improved performance and simplicity for building complex agent workflows. | [Read Article](https://medium.com/@kyeg/introducing-swarms-graphworkflow-a-faster-simpler-and-superior-alternative-to-langgraph-5c040225a4f1) |
+
+
+### Swarms API
+
+| Title | Description | Link |
+|-------|-------------|------|
+| **Specialized Healthcare Agents with Swarms Agent Completions API** | Guide to building healthcare-focused agents using the Swarms API. | [Read Article](https://medium.com/@kyeg/specialized-healthcare-agents-with-swarms-agent-completions-api-b56d067e3b11) |
+| **Building Multi-Agent Systems for Finance & Accounting with the Swarms API: A Technical Guide** | Technical walkthrough for creating finance and accounting multi-agent systems with the Swarms API. | [Read Article](https://medium.com/@kyeg/building-multi-agent-systems-for-finance-accounting-with-the-swarms-api-a-technical-guide-bf6f7005b708) |
+
+### Swarms Rust
+
+| Title | Description | Link |
+|-------|-------------|------|
+| **Building Medical Multi-Agent Systems with Swarms Rust: A Comprehensive Tutorial** | Comprehensive tutorial for developing medical multi-agent systems using Swarms Rust. | [Read Article](https://medium.com/@kyeg/building-medical-multi-agent-systems-with-swarms-rust-a-comprehensive-tutorial-1e8e060601f9) |
+| **Building Production-Grade Agentic Applications with Swarms Rust: A Comprehensive Tutorial** | Learn to build robust, production-ready agentic applications with Swarms Rust. | [Read Article](https://medium.com/@kyeg/building-production-grade-agentic-applications-with-swarms-rust-a-comprehensive-tutorial-bb567c02340f) |
+
+
+### Youtube Videos
+
+- [Swarms Playlist by Swarms Founder Kye Gomez](https://www.youtube.com/watch?v=FzbBRbaqsG8&list=PLphplB7PcU1atnmrUl7lJ5bmGXR7R4lhA)
+
+--------------------------------------------------
+
+# File: examples/cookbook_index.md
# Swarms Cookbook Examples Index
@@ -1877,7 +2339,7 @@ This project is licensed under the MIT License - see the [LICENSE](https://githu
--------------------------------------------------
-# File: examples\index.md
+# File: examples/index.md
# Swarms Examples Index
@@ -2052,6 +2514,7 @@ This index organizes **100+ production-ready examples** from our [Swarms Example
### Research and Deep Analysis
| Category | Example | Description |
|----------|---------|-------------|
+| Advanced Research | [Advanced Research System](https://github.com/The-Swarm-Corporation/AdvancedResearch) | Multi-agent research system inspired by Anthropic's research methodology with orchestrator-worker architecture |
| Deep Research | [Deep Research Example](https://github.com/kyegomez/swarms/blob/master/examples/multi_agent/deep_research_examples/deep_research_example.py) | Comprehensive research system with multiple specialized agents |
| Deep Research Swarm | [Deep Research Swarm](https://github.com/kyegomez/swarms/blob/master/examples/multi_agent/deep_research_examples/deep_research_swarm_example.py) | Swarm-based deep research with collaborative analysis |
| Scientific Agents | [Deep Research Swarm Example](https://github.com/kyegomez/swarms/blob/master/examples/demos/scient_agents/deep_research_swarm_example.py) | Scientific research swarm for academic and research applications |
@@ -2134,11 +2597,13 @@ This index organizes **100+ production-ready examples** from our [Swarms Example
--------------------------------------------------
-# File: examples\paper_implementations.md
+# File: examples/paper_implementations.md
# Multi-Agent Paper Implementations
-At Swarms, we are passionate about democratizing access to cutting-edge multi-agent research and making advanced AI collaboration accessible to everyone. Our mission is to bridge the gap between academic research and practical implementation by providing production-ready, open-source implementations of the most impactful multi-agent research papers.
+At Swarms, we are passionate about democratizing access to cutting-edge multi-agent research and making advanced agent collaboration accessible to everyone.
+
+Our mission is to bridge the gap between academic research and practical implementation by providing production-ready, open-source implementations of the most impactful multi-agent research papers.
### Why Multi-Agent Research Matters
@@ -2176,10 +2641,6 @@ This documentation showcases our comprehensive collection of multi-agent researc
Whether you're a researcher looking to validate findings, a developer building production systems, or a student learning about multi-agent AI, you'll find valuable resources here to advance your work.
-### Join the Multi-Agent Revolution
-
-We invite you to explore these implementations, contribute to our research efforts, and help shape the future of collaborative AI. Together, we can unlock the full potential of multi-agent systems and create AI that truly works as a team.
-
## Implemented Research Papers
| Paper Name | Description | Original Paper | Implementation | Status | Key Features |
@@ -2190,124 +2651,1123 @@ We invite you to explore these implementations, contribute to our research effor
| **[Mixture of Agents (MoA)](https://arxiv.org/abs/2406.04692)** | A sophisticated multi-agent architecture that implements parallel processing with iterative refinement, combining diverse expert agents for comprehensive analysis. | Multi-agent collaboration concepts | [`swarms.structs.moa`](https://docs.swarms.world/en/latest/swarms/structs/moa/) | ✅ Complete | Parallel processing, expert agent combination, iterative refinement, state-of-the-art performance |
| **Deep Research Swarm** | A production-grade research system that conducts comprehensive analysis across multiple domains using parallel processing and advanced AI agents. | Research methodology | [`swarms.structs.deep_research_swarm`](https://docs.swarms.world/en/latest/swarms/structs/deep_research_swarm/) | ✅ Complete | Parallel search processing, multi-agent coordination, information synthesis, concurrent execution |
| **Agent-as-a-Judge** | An evaluation framework that uses agents to evaluate other agents, implementing the "Agent-as-a-Judge: Evaluate Agents with Agents" methodology. | [arXiv:2410.10934](https://arxiv.org/abs/2410.10934) | [`swarms.agents.agent_judge`](https://docs.swarms.world/en/latest/swarms/agents/agent_judge/) | ✅ Complete | Agent evaluation, quality assessment, automated judging, performance metrics |
-
-## Additional Research Resources
+| **Advanced Research System** | An enhanced implementation of the orchestrator-worker pattern from Anthropic's paper "How we built our multi-agent research system", featuring parallel execution, LLM-as-judge evaluation, and professional report generation. | [Anthropic Paper](https://www.anthropic.com/engineering/built-multi-agent-research-system) | [GitHub Repository](https://github.com/The-Swarm-Corporation/AdvancedResearch) | ✅ Complete | Orchestrator-worker architecture, parallel execution, Exa API integration, export capabilities |
### Multi-Agent Papers Compilation
We maintain a comprehensive list of multi-agent research papers at: [awesome-multi-agent-papers](https://github.com/kyegomez/awesome-multi-agent-papers)
-### Research Lists
-Our research compilation includes:
-- **Projects**: ModelScope-Agent, Gorilla, BMTools, LMQL, Langchain, MetaGPT, AutoGPT, and more
+## Contributing
-- **Research Papers**: BOLAA, ToolLLM, Communicative Agents, Mind2Web, Voyager, Tree of Thoughts, and many others
+We welcome contributions to implement additional research papers! If you'd like to contribute:
-- **Blog Articles**: Latest insights and developments in autonomous agents
+1. **Identify a paper**: Choose a relevant multi-agent research paper
+2. **Propose implementation**: Submit an issue with your proposal
+3. **Implement**: Create the implementation following our guidelines
+4. **Document**: Add comprehensive documentation and examples
+5. **Test**: Ensure robust testing and validation
-- **Talks**: Presentations from leading researchers like Geoffrey Hinton and Andrej Karpathy
+## Citation
+If you use any of these implementations in your research, please cite the original papers and the Swarms framework:
-## Implementation Details
+```bibtex
+@misc{SWARMS_2022,
+ author = {Gomez, Kye and Pliny and More, Harshal and Swarms Community},
+ title = {{Swarms: Production-Grade Multi-Agent Infrastructure Platform}},
+ year = {2022},
+ howpublished = {\url{https://github.com/kyegomez/swarms}},
+ note = {Documentation available at \url{https://docs.swarms.world}},
+ version = {latest}
+}
+```
-### MALT Framework
+## Community
-The MALT implementation provides:
+Join our community to stay updated on the latest multi-agent research implementations:
-- **Three-Agent Architecture**: Creator, Verifier, and Refiner agents
+- **Discord**: [Join our community](https://discord.gg/EamjgSaEQf)
-- **Structured Workflow**: Coordinated task execution with conversation history
+- **Documentation**: [docs.swarms.world](https://docs.swarms.world)
-- **Reliability Features**: Error handling, validation, and quality assurance
+- **GitHub**: [kyegomez/swarms](https://github.com/kyegomez/swarms)
-- **Extensibility**: Custom agent integration and configuration options
+- **Research Papers**: [awesome-multi-agent-papers](https://github.com/kyegomez/awesome-multi-agent-papers)
-### MAI-DxO System
-The MAI Diagnostic Orchestrator features:
-- **Virtual Physician Panel**: Multiple specialized medical agents
+--------------------------------------------------
-- **Cost Optimization**: Efficient diagnostic workflows
+# File: examples/smart_database.md
-- **Iterative Refinement**: Continuous improvement of diagnoses
+# Smart Database Powered by Hierarchical Multi-Agent Workflow
-- **Medical Expertise**: Domain-specific knowledge and reasoning
+This module implements a fully autonomous database management system using a hierarchical multi-agent architecture. The system includes specialized agents for different database operations coordinated by a Database Director agent.
+## Features
-### AI-CoScientist Framework
+| Feature | Description |
+|---------------------------------------|-----------------------------------------------------------------------------------------------|
+| Autonomous Database Management | Complete database lifecycle management, including setup and ongoing management of databases. |
+| Intelligent Task Distribution | Automatic assignment of tasks to appropriate specialist agents. |
+| Table Creation with Schema Validation | Ensures tables are created with correct structure, schema enforcement, and data integrity. |
+| Data Insertion and Updates | Handles adding new data and updating existing records efficiently, supporting JSON input. |
+| Complex Query Execution | Executes advanced and optimized queries for data retrieval and analysis. |
+| Schema Modifications | Supports altering table structures and database schemas as needed. |
+| Hierarchical Agent Coordination | Utilizes a multi-agent system for orchestrated, intelligent task execution. |
+| Security | Built-in SQL injection prevention and query validation for data protection. |
+| Performance Optimization | Query optimization and efficient data operations for high performance. |
+| Comprehensive Error Handling | Robust error management and reporting throughout all operations. |
+| Multi-format Data Support | Flexible query parameters and support for JSON-based data insertion. |
-The AI-CoScientist implementation includes:
+## Architecture
-- **Tournament-Based Selection**: Elo rating system for hypothesis ranking
+### Multi-Agent Architecture
-- **Peer Review System**: Comprehensive evaluation of scientific proposals
+```
+Database Director (Coordinator)
+├── Database Creator (Creates databases)
+├── Table Manager (Manages table schemas)
+├── Data Operations (Handles data insertion/updates)
+└── Query Specialist (Executes queries and retrieval)
+```
-- **Hypothesis Evolution**: Iterative refinement based on feedback
+### Agent Specializations
-- **Diversity Control**: Proximity analysis to maintain hypothesis variety
+| Agent | Description |
+|------------------------|-----------------------------------------------------------------------------------------------|
+| **Database Director** | Orchestrates all database operations and coordinates specialist agents |
+| **Database Creator** | Specializes in creating and initializing databases |
+| **Table Manager** | Expert in table creation, schema design, and structure management |
+| **Data Operations** | Handles data insertion, updates, and manipulation |
+| **Query Specialist** | Manages database queries, data retrieval, and optimization |
-### Mixture of Agents (MoA)
+## Agent Tools
-The MoA architecture provides:
+| Function | Description |
+|----------|-------------|
+| **`create_database(database_name, database_path)`** | Creates new SQLite databases |
+| **`create_table(database_path, table_name, schema)`** | Creates tables with specified schemas |
+| **`insert_data(database_path, table_name, data)`** | Inserts data into tables |
+| **`query_database(database_path, query, params)`** | Executes SELECT queries |
+| **`update_table_data(database_path, table_name, update_data, where_clause)`** | Updates existing data |
+| **`get_database_schema(database_path)`** | Retrieves comprehensive schema information |
-- **Parallel Processing**: Multiple agents working simultaneously
+## Install
-- **Expert Specialization**: Domain-specific agent capabilities
+```bash
+pip install -U swarms sqlite3 loguru
+```
-- **Iterative Refinement**: Continuous improvement through collaboration
+## ENV
-- **State-of-the-Art Performance**: Achieving superior results through collective intelligence
+```
+WORKSPACE_DIR="agent_workspace"
+ANTHROPIC_API_KEY=""
+OPENAI_API_KEY=""
+```
+## Code
+- Make a file called `smart_database_swarm.py`
-## Contributing
+```python
+import sqlite3
+import json
+from pathlib import Path
+from loguru import logger
-We welcome contributions to implement additional research papers! If you'd like to contribute:
+from swarms import Agent, HierarchicalSwarm
-1. **Identify a paper**: Choose a relevant multi-agent research paper
-2. **Propose implementation**: Submit an issue with your proposal
-3. **Implement**: Create the implementation following our guidelines
-4. **Document**: Add comprehensive documentation and examples
-5. **Test**: Ensure robust testing and validation
-## Citation
+# =============================================================================
+# DATABASE TOOLS - Core Functions for Database Operations
+# =============================================================================
-If you use any of these implementations in your research, please cite the original papers and the Swarms framework:
-```bibtex
-@misc{SWARMS_2022,
- author = {Gomez, Kye and Pliny and More, Harshal and Swarms Community},
- title = {{Swarms: Production-Grade Multi-Agent Infrastructure Platform}},
- year = {2022},
- howpublished = {\url{https://github.com/kyegomez/swarms}},
- note = {Documentation available at \url{https://docs.swarms.world}},
- version = {latest}
-}
-```
+def create_database(
+ database_name: str, database_path: str = "./databases"
+) -> str:
+ """
+ Create a new SQLite database file.
-## Community
+ Args:
+ database_name (str): Name of the database to create (without .db extension)
+ database_path (str, optional): Directory path where database will be created.
+ Defaults to "./databases".
-Join our community to stay updated on the latest multi-agent research implementations:
+ Returns:
+ str: JSON string containing operation result and database information
-- **Discord**: [Join our community](https://discord.gg/EamjgSaEQf)
+ Raises:
+ OSError: If unable to create database directory or file
+ sqlite3.Error: If database connection fails
-- **Documentation**: [docs.swarms.world](https://docs.swarms.world)
+ Example:
+ >>> result = create_database("company_db", "/data/databases")
+ >>> print(result)
+ {"status": "success", "database": "company_db.db", "path": "/data/databases/company_db.db"}
+ """
+ try:
+ # Validate input parameters
+ if not database_name or not database_name.strip():
+ raise ValueError("Database name cannot be empty")
-- **GitHub**: [kyegomez/swarms](https://github.com/kyegomez/swarms)
+ # Clean database name
+ db_name = database_name.strip().replace(" ", "_")
+ if not db_name.endswith(".db"):
+ db_name += ".db"
-- **Research Papers**: [awesome-multi-agent-papers](https://github.com/kyegomez/awesome-multi-agent-papers)
+ # Create database directory if it doesn't exist
+ db_path = Path(database_path)
+ db_path.mkdir(parents=True, exist_ok=True)
+
+ # Full database file path
+ full_db_path = db_path / db_name
+
+ # Create database connection (creates file if doesn't exist)
+ conn = sqlite3.connect(str(full_db_path))
+
+ # Create a metadata table to track database info
+ conn.execute(
+ """
+ CREATE TABLE IF NOT EXISTS _database_metadata (
+ key TEXT PRIMARY KEY,
+ value TEXT,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+ )
+ """
+ )
+
+ # Insert database metadata
+ conn.execute(
+ "INSERT OR REPLACE INTO _database_metadata (key, value) VALUES (?, ?)",
+ ("database_name", database_name),
+ )
+
+ conn.commit()
+ conn.close()
+ result = {
+ "status": "success",
+ "message": f"Database '{database_name}' created successfully",
+ "database": db_name,
+ "path": str(full_db_path),
+ "size_bytes": full_db_path.stat().st_size,
+ }
+
+ logger.info(f"Database created: {db_name}")
+ return json.dumps(result, indent=2)
+
+ except ValueError as e:
+ return json.dumps({"status": "error", "error": str(e)})
+ except sqlite3.Error as e:
+ return json.dumps(
+ {"status": "error", "error": f"Database error: {str(e)}"}
+ )
+ except Exception as e:
+ return json.dumps(
+ {
+ "status": "error",
+ "error": f"Unexpected error: {str(e)}",
+ }
+ )
+
+
+def create_table(
+ database_path: str, table_name: str, schema: str
+) -> str:
+ """
+ Create a new table in the specified database with the given schema.
+
+ Args:
+ database_path (str): Full path to the database file
+ table_name (str): Name of the table to create
+ schema (str): SQL schema definition for the table columns
+ Format: "column1 TYPE constraints, column2 TYPE constraints, ..."
+ Example: "id INTEGER PRIMARY KEY, name TEXT NOT NULL, age INTEGER"
+
+ Returns:
+ str: JSON string containing operation result and table information
+
+ Raises:
+ sqlite3.Error: If table creation fails
+ FileNotFoundError: If database file doesn't exist
+
+ Example:
+ >>> schema = "id INTEGER PRIMARY KEY, name TEXT NOT NULL, email TEXT UNIQUE"
+ >>> result = create_table("/data/company.db", "employees", schema)
+ >>> print(result)
+ {"status": "success", "table": "employees", "columns": 3}
+ """
+ try:
+ # Validate inputs
+ if not all([database_path, table_name, schema]):
+ raise ValueError(
+ "Database path, table name, and schema are required"
+ )
+
+ # Check if database exists
+ if not Path(database_path).exists():
+ raise FileNotFoundError(
+ f"Database file not found: {database_path}"
+ )
+
+ # Clean table name
+ clean_table_name = table_name.strip().replace(" ", "_")
+
+ # Connect to database
+ conn = sqlite3.connect(database_path)
+ cursor = conn.cursor()
+
+ # Check if table already exists
+ cursor.execute(
+ "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+ (clean_table_name,),
+ )
+
+ if cursor.fetchone():
+ conn.close()
+ return json.dumps(
+ {
+ "status": "warning",
+ "message": f"Table '{clean_table_name}' already exists",
+ "table": clean_table_name,
+ }
+ )
+
+ # Create table with provided schema
+ create_sql = f"CREATE TABLE {clean_table_name} ({schema})"
+ cursor.execute(create_sql)
+
+ # Get table info
+ cursor.execute(f"PRAGMA table_info({clean_table_name})")
+ columns = cursor.fetchall()
+
+ # Update metadata
+ cursor.execute(
+ """
+ INSERT OR REPLACE INTO _database_metadata (key, value)
+ VALUES (?, ?)
+ """,
+ (f"table_{clean_table_name}_created", "true"),
+ )
+
+ conn.commit()
+ conn.close()
+
+ result = {
+ "status": "success",
+ "message": f"Table '{clean_table_name}' created successfully",
+ "table": clean_table_name,
+ "columns": len(columns),
+ "schema": [
+ {
+ "name": col[1],
+ "type": col[2],
+ "nullable": not col[3],
+ }
+ for col in columns
+ ],
+ }
+
+ return json.dumps(result, indent=2)
+
+ except ValueError as e:
+ return json.dumps({"status": "error", "error": str(e)})
+ except FileNotFoundError as e:
+ return json.dumps({"status": "error", "error": str(e)})
+ except sqlite3.Error as e:
+ return json.dumps(
+ {"status": "error", "error": f"SQL error: {str(e)}"}
+ )
+ except Exception as e:
+ return json.dumps(
+ {
+ "status": "error",
+ "error": f"Unexpected error: {str(e)}",
+ }
+ )
+
+
+def insert_data(
+ database_path: str, table_name: str, data: str
+) -> str:
+ """
+ Insert data into a specified table.
+
+ Args:
+ database_path (str): Full path to the database file
+ table_name (str): Name of the target table
+ data (str): JSON string containing data to insert
+ Format: {"columns": ["col1", "col2"], "values": [[val1, val2], ...]}
+ Or: [{"col1": val1, "col2": val2}, ...]
+
+ Returns:
+ str: JSON string containing operation result and insertion statistics
+
+ Example:
+ >>> data = '{"columns": ["name", "age"], "values": [["John", 30], ["Jane", 25]]}'
+ >>> result = insert_data("/data/company.db", "employees", data)
+ >>> print(result)
+ {"status": "success", "table": "employees", "rows_inserted": 2}
+ """
+ try:
+ # Validate inputs
+ if not all([database_path, table_name, data]):
+ raise ValueError(
+ "Database path, table name, and data are required"
+ )
+
+ # Check if database exists
+ if not Path(database_path).exists():
+ raise FileNotFoundError(
+ f"Database file not found: {database_path}"
+ )
+
+ # Parse data
+ try:
+ parsed_data = json.loads(data)
+ except json.JSONDecodeError:
+ raise ValueError("Invalid JSON format for data")
+
+ conn = sqlite3.connect(database_path)
+ cursor = conn.cursor()
+
+ # Check if table exists
+ cursor.execute(
+ "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+ (table_name,),
+ )
+
+ if not cursor.fetchone():
+ conn.close()
+ raise ValueError(f"Table '{table_name}' does not exist")
+
+ rows_inserted = 0
+
+ # Handle different data formats
+ if isinstance(parsed_data, list) and all(
+ isinstance(item, dict) for item in parsed_data
+ ):
+ # Format: [{"col1": val1, "col2": val2}, ...]
+ for row in parsed_data:
+ columns = list(row.keys())
+ values = list(row.values())
+ placeholders = ", ".join(["?" for _ in values])
+ columns_str = ", ".join(columns)
+
+ insert_sql = f"INSERT INTO {table_name} ({columns_str}) VALUES ({placeholders})"
+ cursor.execute(insert_sql, values)
+ rows_inserted += 1
+
+ elif (
+ isinstance(parsed_data, dict)
+ and "columns" in parsed_data
+ and "values" in parsed_data
+ ):
+ # Format: {"columns": ["col1", "col2"], "values": [[val1, val2], ...]}
+ columns = parsed_data["columns"]
+ values_list = parsed_data["values"]
+
+ placeholders = ", ".join(["?" for _ in columns])
+ columns_str = ", ".join(columns)
+
+ insert_sql = f"INSERT INTO {table_name} ({columns_str}) VALUES ({placeholders})"
+
+ for values in values_list:
+ cursor.execute(insert_sql, values)
+ rows_inserted += 1
+ else:
+ raise ValueError(
+ "Invalid data format. Expected list of dicts or dict with columns/values"
+ )
+
+ conn.commit()
+ conn.close()
+
+ result = {
+ "status": "success",
+ "message": f"Data inserted successfully into '{table_name}'",
+ "table": table_name,
+ "rows_inserted": rows_inserted,
+ }
+
+ return json.dumps(result, indent=2)
+
+ except (ValueError, FileNotFoundError) as e:
+ return json.dumps({"status": "error", "error": str(e)})
+ except sqlite3.Error as e:
+ return json.dumps(
+ {"status": "error", "error": f"SQL error: {str(e)}"}
+ )
+ except Exception as e:
+ return json.dumps(
+ {
+ "status": "error",
+ "error": f"Unexpected error: {str(e)}",
+ }
+ )
+
+
+def query_database(
+ database_path: str, query: str, params: str = "[]"
+) -> str:
+ """
+ Execute a SELECT query on the database and return results.
+
+ Args:
+ database_path (str): Full path to the database file
+ query (str): SQL SELECT query to execute
+ params (str, optional): JSON string of query parameters for prepared statements.
+ Defaults to "[]".
+
+ Returns:
+ str: JSON string containing query results and metadata
+
+ Example:
+ >>> query = "SELECT * FROM employees WHERE age > ?"
+ >>> params = "[25]"
+ >>> result = query_database("/data/company.db", query, params)
+ >>> print(result)
+ {"status": "success", "results": [...], "row_count": 5}
+ """
+ try:
+ # Validate inputs
+ if not all([database_path, query]):
+ raise ValueError("Database path and query are required")
+
+ # Check if database exists
+ if not Path(database_path).exists():
+ raise FileNotFoundError(
+ f"Database file not found: {database_path}"
+ )
+
+ # Validate query is SELECT only (security)
+ if not query.strip().upper().startswith("SELECT"):
+ raise ValueError("Only SELECT queries are allowed")
+
+ # Parse parameters
+ try:
+ query_params = json.loads(params)
+ except json.JSONDecodeError:
+ raise ValueError("Invalid JSON format for parameters")
+
+ conn = sqlite3.connect(database_path)
+ conn.row_factory = sqlite3.Row # Enable column access by name
+ cursor = conn.cursor()
+
+ # Execute query
+ if query_params:
+ cursor.execute(query, query_params)
+ else:
+ cursor.execute(query)
+
+ # Fetch results
+ rows = cursor.fetchall()
+
+ # Convert to list of dictionaries
+ results = [dict(row) for row in rows]
+
+ # Get column names
+ column_names = (
+ [description[0] for description in cursor.description]
+ if cursor.description
+ else []
+ )
+
+ conn.close()
+
+ result = {
+ "status": "success",
+ "message": "Query executed successfully",
+ "results": results,
+ "row_count": len(results),
+ "columns": column_names,
+ }
+
+ return json.dumps(result, indent=2)
+
+ except (ValueError, FileNotFoundError) as e:
+ return json.dumps({"status": "error", "error": str(e)})
+ except sqlite3.Error as e:
+ return json.dumps(
+ {"status": "error", "error": f"SQL error: {str(e)}"}
+ )
+ except Exception as e:
+ return json.dumps(
+ {
+ "status": "error",
+ "error": f"Unexpected error: {str(e)}",
+ }
+ )
+
+
+def update_table_data(
+ database_path: str,
+ table_name: str,
+ update_data: str,
+ where_clause: str = "",
+) -> str:
+ """
+ Update existing data in a table.
+
+ Args:
+ database_path (str): Full path to the database file
+ table_name (str): Name of the table to update
+ update_data (str): JSON string with column-value pairs to update
+ Format: {"column1": "new_value1", "column2": "new_value2"}
+ where_clause (str, optional): WHERE condition for the update (without WHERE keyword).
+ Example: "id = 1 AND status = 'active'"
+
+ Returns:
+ str: JSON string containing operation result and update statistics
+
+ Example:
+ >>> update_data = '{"salary": 50000, "department": "Engineering"}'
+ >>> where_clause = "id = 1"
+ >>> result = update_table_data("/data/company.db", "employees", update_data, where_clause)
+ >>> print(result)
+ {"status": "success", "table": "employees", "rows_updated": 1}
+ """
+ try:
+ # Validate inputs
+ if not all([database_path, table_name, update_data]):
+ raise ValueError(
+ "Database path, table name, and update data are required"
+ )
+
+ # Check if database exists
+ if not Path(database_path).exists():
+ raise FileNotFoundError(
+ f"Database file not found: {database_path}"
+ )
+
+ # Parse update data
+ try:
+ parsed_updates = json.loads(update_data)
+ except json.JSONDecodeError:
+ raise ValueError("Invalid JSON format for update data")
+
+ if not isinstance(parsed_updates, dict):
+ raise ValueError("Update data must be a dictionary")
+
+ conn = sqlite3.connect(database_path)
+ cursor = conn.cursor()
+
+ # Check if table exists
+ cursor.execute(
+ "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+ (table_name,),
+ )
+
+ if not cursor.fetchone():
+ conn.close()
+ raise ValueError(f"Table '{table_name}' does not exist")
+
+ # Build UPDATE query
+ set_clauses = []
+ values = []
+
+ for column, value in parsed_updates.items():
+ set_clauses.append(f"{column} = ?")
+ values.append(value)
+
+ set_clause = ", ".join(set_clauses)
+
+ if where_clause:
+ update_sql = f"UPDATE {table_name} SET {set_clause} WHERE {where_clause}"
+ else:
+ update_sql = f"UPDATE {table_name} SET {set_clause}"
+
+ # Execute update
+ cursor.execute(update_sql, values)
+ rows_updated = cursor.rowcount
+
+ conn.commit()
+ conn.close()
+
+ result = {
+ "status": "success",
+ "message": f"Table '{table_name}' updated successfully",
+ "table": table_name,
+ "rows_updated": rows_updated,
+ "updated_columns": list(parsed_updates.keys()),
+ }
+
+ return json.dumps(result, indent=2)
+
+ except (ValueError, FileNotFoundError) as e:
+ return json.dumps({"status": "error", "error": str(e)})
+ except sqlite3.Error as e:
+ return json.dumps(
+ {"status": "error", "error": f"SQL error: {str(e)}"}
+ )
+ except Exception as e:
+ return json.dumps(
+ {
+ "status": "error",
+ "error": f"Unexpected error: {str(e)}",
+ }
+ )
+
+
+def get_database_schema(database_path: str) -> str:
+ """
+ Get comprehensive schema information for all tables in the database.
+
+ Args:
+ database_path (str): Full path to the database file
+
+ Returns:
+ str: JSON string containing complete database schema information
+
+ Example:
+ >>> result = get_database_schema("/data/company.db")
+ >>> print(result)
+ {"status": "success", "database": "company.db", "tables": {...}}
+ """
+ try:
+ if not database_path:
+ raise ValueError("Database path is required")
+
+ if not Path(database_path).exists():
+ raise FileNotFoundError(
+ f"Database file not found: {database_path}"
+ )
+
+ conn = sqlite3.connect(database_path)
+ cursor = conn.cursor()
+
+ # Get all tables
+ cursor.execute(
+ "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE '_%'"
+ )
+ tables = cursor.fetchall()
+
+ schema_info = {
+ "database": Path(database_path).name,
+ "table_count": len(tables),
+ "tables": {},
+ }
+
+ for table in tables:
+ table_name = table[0]
+
+ # Get table schema
+ cursor.execute(f"PRAGMA table_info({table_name})")
+ columns = cursor.fetchall()
+
+ # Get row count
+ cursor.execute(f"SELECT COUNT(*) FROM {table_name}")
+ row_count = cursor.fetchone()[0]
+
+ schema_info["tables"][table_name] = {
+ "columns": [
+ {
+ "name": col[1],
+ "type": col[2],
+ "nullable": not col[3],
+ "default": col[4],
+ "primary_key": bool(col[5]),
+ }
+ for col in columns
+ ],
+ "column_count": len(columns),
+ "row_count": row_count,
+ }
+
+ conn.close()
+
+ result = {
+ "status": "success",
+ "message": "Database schema retrieved successfully",
+ "schema": schema_info,
+ }
+
+ return json.dumps(result, indent=2)
+
+ except (ValueError, FileNotFoundError) as e:
+ return json.dumps({"status": "error", "error": str(e)})
+ except sqlite3.Error as e:
+ return json.dumps(
+ {"status": "error", "error": f"SQL error: {str(e)}"}
+ )
+ except Exception as e:
+ return json.dumps(
+ {
+ "status": "error",
+ "error": f"Unexpected error: {str(e)}",
+ }
+ )
+
+
+# =============================================================================
+# DATABASE CREATION SPECIALIST AGENT
+# =============================================================================
+database_creator_agent = Agent(
+ agent_name="Database-Creator",
+ agent_description="Specialist agent responsible for creating and initializing databases with proper structure and metadata",
+ system_prompt="""You are the Database Creator, a specialist agent responsible for database creation and initialization. Your expertise includes:
+
+ DATABASE CREATION & SETUP:
+ - Creating new SQLite databases with proper structure
+ - Setting up database metadata and tracking systems
+ - Initializing database directories and file organization
+ - Ensuring database accessibility and permissions
+ - Creating database backup and recovery procedures
+
+ DATABASE ARCHITECTURE:
+ - Designing optimal database structures for different use cases
+ - Planning database organization and naming conventions
+ - Setting up database configuration and optimization settings
+ - Implementing database security and access controls
+ - Creating database documentation and specifications
+
+ Your responsibilities:
+ - Create new databases when requested
+ - Set up proper database structure and metadata
+ - Ensure database is properly initialized and accessible
+ - Provide database creation status and information
+ - Handle database creation errors and provide solutions
+
+ You work with precise technical specifications and always ensure databases are created correctly and efficiently.""",
+ model_name="claude-sonnet-4-20250514",
+ max_loops=1,
+ temperature=0.3,
+ dynamic_temperature_enabled=True,
+ tools=[create_database, get_database_schema],
+)
+
+# =============================================================================
+# TABLE MANAGEMENT SPECIALIST AGENT
+# =============================================================================
+table_manager_agent = Agent(
+ agent_name="Table-Manager",
+ agent_description="Specialist agent for table creation, schema design, and table structure management",
+ system_prompt="""You are the Table Manager, a specialist agent responsible for table creation, schema design, and table structure management. Your expertise includes:
+
+ TABLE CREATION & DESIGN:
+ - Creating tables with optimal schema design
+ - Defining appropriate data types and constraints
+ - Setting up primary keys, foreign keys, and indexes
+ - Designing normalized table structures
+ - Creating tables that support efficient queries and operations
+
+ SCHEMA MANAGEMENT:
+ - Analyzing schema requirements and designing optimal structures
+ - Validating schema definitions and data types
+ - Ensuring schema consistency and integrity
+ - Managing schema modifications and updates
+ - Optimizing table structures for performance
+
+ DATA INTEGRITY:
+ - Implementing proper constraints and validation rules
+ - Setting up referential integrity between tables
+ - Ensuring data consistency across table operations
+ - Managing table relationships and dependencies
+ - Creating tables that support data quality requirements
+
+ Your responsibilities:
+ - Create tables with proper schema definitions
+ - Validate table structures and constraints
+ - Ensure optimal table design for performance
+ - Handle table creation errors and provide solutions
+ - Provide detailed table information and metadata
+
+ You work with precision and always ensure tables are created with optimal structure and performance characteristics.""",
+ model_name="claude-sonnet-4-20250514",
+ max_loops=1,
+ temperature=0.3,
+ dynamic_temperature_enabled=True,
+ tools=[create_table, get_database_schema],
+)
+
+# =============================================================================
+# DATA OPERATIONS SPECIALIST AGENT
+# =============================================================================
+data_operations_agent = Agent(
+ agent_name="Data-Operations",
+ agent_description="Specialist agent for data insertion, updates, and data manipulation operations",
+ system_prompt="""You are the Data Operations specialist, responsible for all data manipulation operations including insertion, updates, and data management. Your expertise includes:
+
+ DATA INSERTION:
+ - Inserting data with proper validation and formatting
+ - Handling bulk data insertions efficiently
+ - Managing data type conversions and formatting
+ - Ensuring data integrity during insertion operations
+ - Validating data before insertion to prevent errors
+
+ DATA UPDATES:
+ - Updating existing data with precision and safety
+ - Creating targeted update operations with proper WHERE clauses
+ - Managing bulk updates and data modifications
+ - Ensuring data consistency during update operations
+ - Validating update operations to prevent data corruption
+
+ DATA VALIDATION:
+ - Validating data formats and types before operations
+ - Ensuring data meets schema requirements and constraints
+ - Checking for data consistency and integrity
+ - Managing data transformation and cleaning operations
+ - Providing detailed feedback on data operation results
+
+ ERROR HANDLING:
+ - Managing data operation errors gracefully
+ - Providing clear error messages and solutions
+ - Ensuring data operations are atomic and safe
+ - Rolling back operations when necessary
+ - Maintaining data integrity throughout all operations
+
+ Your responsibilities:
+ - Execute data insertion operations safely and efficiently
+ - Perform data updates with proper validation
+ - Ensure data integrity throughout all operations
+ - Handle data operation errors and provide solutions
+ - Provide detailed operation results and statistics
+
+ You work with extreme precision and always prioritize data integrity and safety in all operations.""",
+ model_name="claude-sonnet-4-20250514",
+ max_loops=1,
+ temperature=0.3,
+ dynamic_temperature_enabled=True,
+ tools=[insert_data, update_table_data],
+)
+
+# =============================================================================
+# QUERY SPECIALIST AGENT
+# =============================================================================
+query_specialist_agent = Agent(
+ agent_name="Query-Specialist",
+ agent_description="Expert agent for database querying, data retrieval, and query optimization",
+ system_prompt="""You are the Query Specialist, an expert agent responsible for database querying, data retrieval, and query optimization. Your expertise includes:
+
+ QUERY EXECUTION:
+ - Executing complex SELECT queries efficiently
+ - Handling parameterized queries for security
+ - Managing query results and data formatting
+ - Ensuring query performance and optimization
+ - Providing comprehensive query results with metadata
+
+ QUERY OPTIMIZATION:
+ - Analyzing query performance and optimization opportunities
+ - Creating efficient queries that minimize resource usage
+ - Understanding database indexes and query planning
+ - Optimizing JOIN operations and complex queries
+ - Managing query timeouts and performance monitoring
+
+ DATA RETRIEVAL:
+ - Retrieving data with proper formatting and structure
+ - Handling large result sets efficiently
+ - Managing data aggregation and summarization
+ - Creating reports and data analysis queries
+ - Ensuring data accuracy and completeness in results
+
+ SECURITY & VALIDATION:
+ - Ensuring queries are safe and secure
+ - Validating query syntax and parameters
+ - Preventing SQL injection and security vulnerabilities
+ - Managing query permissions and access controls
+ - Ensuring queries follow security best practices
+
+ Your responsibilities:
+ - Execute database queries safely and efficiently
+ - Optimize query performance for best results
+ - Provide comprehensive query results and analysis
+ - Handle query errors and provide solutions
+ - Ensure query security and data protection
+
+ You work with expertise in SQL optimization and always ensure queries are secure, efficient, and provide accurate results.""",
+ model_name="claude-sonnet-4-20250514",
+ max_loops=1,
+ temperature=0.3,
+ dynamic_temperature_enabled=True,
+ tools=[query_database, get_database_schema],
+)
+
+# =============================================================================
+# DATABASE DIRECTOR AGENT (COORDINATOR)
+# =============================================================================
+database_director_agent = Agent(
+ agent_name="Database-Director",
+ agent_description="Senior database director who orchestrates comprehensive database operations across all specialized teams",
+ system_prompt="""You are the Database Director, the senior executive responsible for orchestrating comprehensive database operations and coordinating a team of specialized database experts. Your role is to:
+
+ STRATEGIC COORDINATION:
+ - Analyze complex database tasks and break them down into specialized operations
+ - Assign tasks to the most appropriate specialist based on their unique expertise
+ - Ensure comprehensive coverage of all database operations (creation, schema, data, queries)
+ - Coordinate between specialists to avoid conflicts and ensure data integrity
+ - Synthesize results from multiple specialists into coherent database solutions
+ - Ensure all database operations align with user requirements and best practices
+
+ TEAM LEADERSHIP:
+ - Lead the Database Creator in setting up new databases and infrastructure
+ - Guide the Table Manager in creating optimal table structures and schemas
+ - Direct the Data Operations specialist in data insertion and update operations
+ - Oversee the Query Specialist in data retrieval and analysis operations
+ - Ensure all team members work collaboratively toward unified database goals
+ - Provide strategic direction and feedback to optimize team performance
+
+ DATABASE ARCHITECTURE:
+ - Design comprehensive database solutions that meet user requirements
+ - Ensure database operations follow best practices and standards
+ - Plan database workflows that optimize performance and reliability
+ - Balance immediate operational needs with long-term database health
+ - Ensure database operations are secure, efficient, and maintainable
+ - Optimize database operations for scalability and performance
+
+ OPERATION ORCHESTRATION:
+ - Monitor database operations across all specialists and activities
+ - Analyze results to identify optimization opportunities and improvements
+ - Ensure database operations deliver reliable and accurate results
+ - Provide strategic recommendations based on operation outcomes
+ - Coordinate complex multi-step database operations across specialists
+ - Ensure continuous improvement and optimization in database management
+
+ Your expertise includes:
+ - Database architecture and design strategy
+ - Team leadership and cross-functional coordination
+ - Database performance analysis and optimization
+ - Strategic planning and requirement analysis
+ - Operation workflow management and optimization
+ - Database security and best practices implementation
+
+ You deliver comprehensive database solutions that leverage the full expertise of your specialized team, ensuring all database operations work together to provide reliable, efficient, and secure data management.""",
+ model_name="claude-sonnet-4-20250514",
+ max_loops=1,
+ temperature=0.5,
+ dynamic_temperature_enabled=True,
+)
+
+# =============================================================================
+# HIERARCHICAL DATABASE SWARM
+# =============================================================================
+# Create list of specialized database agents
+database_specialists = [
+ database_creator_agent,
+ table_manager_agent,
+ data_operations_agent,
+ query_specialist_agent,
+]
+
+# Initialize the hierarchical database swarm
+smart_database_swarm = HierarchicalSwarm(
+ name="Smart-Database-Swarm",
+ description="A comprehensive database management system with specialized agents for creation, schema management, data operations, and querying, coordinated by a database director",
+ director_model_name="gpt-4.1",
+ agents=database_specialists,
+ max_loops=1,
+ verbose=True,
+)
+
+# =============================================================================
+# EXAMPLE USAGE AND DEMONSTRATIONS
+# =============================================================================
+if __name__ == "__main__":
+ # Configure logging
+ logger.info("Starting Smart Database Swarm demonstration")
+
+ # Example 1: Create a complete e-commerce database system
+ print("=" * 80)
+ print("SMART DATABASE SWARM - E-COMMERCE SYSTEM EXAMPLE")
+ print("=" * 80)
+
+ task1 = """Create a comprehensive e-commerce database system with the following requirements:
+
+ 1. Create a database called 'ecommerce_db'
+ 2. Create tables for:
+ - customers (id, name, email, phone, address, created_at)
+ - products (id, name, description, price, category, stock_quantity, created_at)
+ - orders (id, customer_id, order_date, total_amount, status)
+ - order_items (id, order_id, product_id, quantity, unit_price)
+
+ 3. Insert sample data:
+ - Add 3 customers
+ - Add 5 products in different categories
+ - Create 2 orders with multiple items
+
+ 4. Query the database to:
+ - Show all customers with their order history
+ - Display products by category with stock levels
+ - Calculate total sales by product
+
+ Ensure all operations are executed properly and provide comprehensive results."""
+
+ result1 = smart_database_swarm.run(task=task1)
+ print("\nE-COMMERCE DATABASE RESULT:")
+ print(result1)
+
+ # print("\n" + "=" * 80)
+ # print("SMART DATABASE SWARM - EMPLOYEE MANAGEMENT SYSTEM")
+ # print("=" * 80)
+
+ # # Example 2: Employee management system
+ # task2 = """Create an employee management database system:
+
+ # 1. Create database 'company_hr'
+ # 2. Create tables for:
+ # - departments (id, name, budget, manager_id)
+ # - employees (id, name, email, department_id, position, salary, hire_date)
+ # - projects (id, name, description, start_date, end_date, budget)
+ # - employee_projects (employee_id, project_id, role, hours_allocated)
+
+ # 3. Add sample data for departments, employees, and projects
+ # 4. Query for:
+ # - Employee count by department
+ # - Average salary by position
+ # - Projects with their assigned employees
+ # - Department budgets vs project allocations
+
+ # Coordinate the team to build this system efficiently."""
+
+ # result2 = smart_database_swarm.run(task=task2)
+ # print("\nEMPLOYEE MANAGEMENT RESULT:")
+ # print(result2)
+
+ # print("\n" + "=" * 80)
+ # print("SMART DATABASE SWARM - DATABASE ANALYSIS")
+ # print("=" * 80)
+
+ # # Example 3: Database analysis and optimization
+ # task3 = """Analyze and optimize the existing databases:
+
+ # 1. Get schema information for all created databases
+ # 2. Analyze table structures and relationships
+ # 3. Suggest optimizations for:
+ # - Index creation for better query performance
+ # - Data normalization improvements
+ # - Constraint additions for data integrity
+
+ # 4. Update data in existing tables:
+ # - Increase product prices by 10% for electronics category
+ # - Update employee salaries based on performance criteria
+ # - Modify order statuses for completed orders
+
+ # 5. Create comprehensive reports showing:
+ # - Database statistics and health metrics
+ # - Data distribution and patterns
+ # - Performance optimization recommendations
+
+ # Coordinate all specialists to provide a complete database analysis."""
+
+ # result3 = smart_database_swarm.run(task=task3)
+ # print("\nDATABASE ANALYSIS RESULT:")
+ # print(result3)
+
+ # logger.info("Smart Database Swarm demonstration completed successfully")
+```
+- Run the file with `smart_database_swarm.py`
--------------------------------------------------
-# File: examples\templates.md
+# File: examples/templates.md
# Templates & Applications Documentation
@@ -2528,7 +3988,7 @@ Join our community of agent engineers and researchers for technical support, cut
--------------------------------------------------
-# File: governance\bounty_program.md
+# File: governance/bounty_program.md
# Swarms Bounty Program
@@ -2608,7 +4068,7 @@ Join us in building the future of multi-agent collaboration and AI automation. W
--------------------------------------------------
-# File: governance\main.md
+# File: governance/main.md
# 🔗 Links & Resources
@@ -2691,7 +4151,7 @@ Welcome to the Swarms ecosystem. Click any tile below to explore our products, c
--------------------------------------------------
-# File: guides\agent_evals.md
+# File: guides/agent_evals.md
### Understanding Agent Evaluation Mechanisms
@@ -2950,7 +4410,7 @@ Agent evaluation mechanisms are vital for ensuring the reliability, efficiency,
--------------------------------------------------
-# File: guides\financial_analysis_swarm_mm.md
+# File: guides/financial_analysis_swarm_mm.md
# Building a Multi-Agent System for Real-Time Financial Analysis: A Comprehensive Tutorial
@@ -3436,7 +4896,7 @@ By leveraging the power of multi-agent AI systems, you're well-equipped to navig
--------------------------------------------------
-# File: guides\financial_data_api.md
+# File: guides/financial_data_api.md
# Analyzing Financial Data with AI Agents using Swarms Framework
@@ -4192,7 +5652,7 @@ As the field of AI in finance continues to evolve, we can expect even more sophi
--------------------------------------------------
-# File: guides\healthcare_blog.md
+# File: guides/healthcare_blog.md
# Unlocking Efficiency and Cost Savings in Healthcare: How Swarms of LLM Agents Can Revolutionize Medical Operations and Save Millions
@@ -4472,7 +5932,7 @@ By adopting swarms of LLM agents, healthcare organizations can streamline operat
--------------------------------------------------
-# File: guides\pricing.md
+# File: guides/pricing.md
# Comparing LLM Provider Pricing: A Guide for Enterprises
@@ -5442,7 +6902,7 @@ Want to get in touch with the Swarms team? Open an issue on [GitHub](https://git
--------------------------------------------------
-# File: protocol\overview.md
+# File: protocol/overview.md
# Swarms Protocol Overview & Architecture
@@ -5852,32 +7312,21 @@ For more on the philosophy and architecture, see [Development Philosophy & Princ
## Further Reading & References
-- [Swarms Docs Home](https://docs.swarms.world/en/latest/)
-
-- [Quickstart for Agents](https://docs.swarms.world/en/latest/swarms/agents/)
-
-- [Agent API Reference](https://docs.swarms.world/en/latest/swarms/structs/agent/)
-
-- [Tools Overview](https://docs.swarms.world/en/latest/swarms_tools/overview/)
-
-- [BaseTool Reference](https://docs.swarms.world/en/latest/swarms/tools/base_tool/)
-
-- [Reasoning Agents Overview](https://docs.swarms.world/en/latest/swarms/agents/reasoning_agents_overview/)
-
-- [Multi-Agent Architectures Overview](https://docs.swarms.world/en/latest/swarms/concept/swarm_architectures/)
-
-- [Examples Overview](https://docs.swarms.world/en/latest/examples/index/)
-
-- [CLI Documentation](https://docs.swarms.world/en/latest/swarms/cli/main/)
-
-- [Prompts Management](https://docs.swarms.world/en/latest/swarms/prompts/main/)
-
-- [Development Philosophy & Principles](https://docs.swarms.world/en/latest/swarms/concept/philosophy/)
-
-- [Understanding Swarms Architecture](https://docs.swarms.world/en/latest/swarms/concept/framework_architecture/)
-
-- [SIP Guidelines and Template](https://docs.swarms.world/en/latest/protocol/sip/)
-
+| Resource Name | Link | Description |
+|-------------------------------------- |----------------------------------------------------------------------------------------|--------------------------------------------------|
+| Swarms Docs Home | [Swarms Docs Home](https://docs.swarms.world/en/latest/) | Main documentation homepage |
+| Quickstart for Agents | [Quickstart for Agents](https://docs.swarms.world/en/latest/swarms/agents/) | Getting started with Swarms agents |
+| Agent API Reference | [Agent API Reference](https://docs.swarms.world/en/latest/swarms/structs/agent/) | API reference for Agent class |
+| Tools Overview | [Tools Overview](https://docs.swarms.world/en/latest/swarms_tools/overview/) | Overview of available tools |
+| BaseTool Reference | [BaseTool Reference](https://docs.swarms.world/en/latest/swarms/tools/base_tool/) | Reference for the BaseTool class |
+| Reasoning Agents Overview | [Reasoning Agents Overview](https://docs.swarms.world/en/latest/swarms/agents/reasoning_agents_overview/) | Overview of reasoning agents |
+| Multi-Agent Architectures Overview | [Multi-Agent Architectures Overview](https://docs.swarms.world/en/latest/swarms/concept/swarm_architectures/) | Multi-agent system architectures |
+| Examples Overview | [Examples Overview](https://docs.swarms.world/en/latest/examples/index/) | Example projects and use cases |
+| CLI Documentation | [CLI Documentation](https://docs.swarms.world/en/latest/swarms/cli/main/) | Command-line interface documentation |
+| Prompts Management | [Prompts Management](https://docs.swarms.world/en/latest/swarms/prompts/main/) | Managing and customizing prompts |
+| Development Philosophy & Principles | [Development Philosophy & Principles](https://docs.swarms.world/en/latest/swarms/concept/philosophy/) | Framework philosophy and guiding principles |
+| Understanding Swarms Architecture | [Understanding Swarms Architecture](https://docs.swarms.world/en/latest/swarms/concept/framework_architecture/) | In-depth look at Swarms architecture |
+| SIP Guidelines and Template | [SIP Guidelines and Template](https://docs.swarms.world/en/latest/protocol/sip/) | Swarms Improvement Proposal process and template |
# Conclusion
@@ -5887,7 +7336,7 @@ The Swarms protocol provides a robust foundation for building intelligent, colla
--------------------------------------------------
-# File: protocol\sip.md
+# File: protocol/sip.md
# Swarms Improvement Proposal (SIP) Guidelines
@@ -6444,7 +7893,7 @@ for message in conversation_history:
--------------------------------------------------
-# File: swarms\agents\abstractagent.md
+# File: swarms/agents/abstractagent.md
# swarms.agents
@@ -6573,7 +8022,7 @@ For further exploration and understanding of AI agents and agent communication,
--------------------------------------------------
-# File: swarms\agents\agent_judge.md
+# File: swarms/agents/agent_judge.md
# AgentJudge
@@ -6829,7 +8278,7 @@ for i, task_evals in enumerate(evaluations):
--------------------------------------------------
-# File: swarms\agents\consistency_agent.md
+# File: swarms/agents/consistency_agent.md
# Consistency Agent Documentation
@@ -7065,7 +8514,7 @@ The agent supports various output types:
--------------------------------------------------
-# File: swarms\agents\create_agents_yaml.md
+# File: swarms/agents/create_agents_yaml.md
# Building Agents from a YAML File
@@ -7191,24 +8640,13 @@ load_dotenv()
yaml_file = "agents_multi_agent.yaml"
-# Get the OpenAI API key from the environment variable
-api_key = os.getenv("GROQ_API_KEY")
-
-# Model
-model = OpenAIChat(
- openai_api_base="https://api.groq.com/openai/v1",
- openai_api_key=api_key,
- model_name="llama-3.1-70b-versatile",
- temperature=0.1,
-)
-
try:
- # Create agents and run tasks (using 'both' to return agents and task results)
- task_results = create_agents_from_yaml(
- model=model, yaml_file=yaml_file, return_type="run_swarm"
- )
+ # Create agents and run tasks (using 'both' to return agents and task results)
+ task_results = create_agents_from_yaml(
+ model=model, yaml_file=yaml_file, return_type="run_swarm"
+ )
- logger.info(f"Results from agents: {task_results}")
+ logger.info(f"Results from agents: {task_results}")
except Exception as e:
logger.error(f"An error occurred: {e}")
@@ -7390,7 +8828,7 @@ The `create_agents_from_yaml` function provides a flexible and powerful way to d
--------------------------------------------------
-# File: swarms\agents\external_party_agents.md
+# File: swarms/agents/external_party_agents.md
@@ -7773,7 +9211,7 @@ For more examples and use cases, please refer to the official Swarms documentati
--------------------------------------------------
-# File: swarms\agents\gkp_agent.md
+# File: swarms/agents/gkp_agent.md
# Generated Knowledge Prompting (GKP) Agent
@@ -7952,22 +9390,17 @@ The agent includes robust error handling for:
--------------------------------------------------
-# File: swarms\agents\index.md
+# File: swarms/agents/index.md
# Agents Introduction
-The Agent class is the core component of the Swarms framework, designed to create intelligent, autonomous AI agents capable of handling complex tasks through multi-modal processing, tool integration, and structured outputs. This comprehensive guide covers all aspects of the Agent class, from basic setup to advanced features.
-## Table of Contents
+An agent in swarms is basically 4 elements added together:
+
+`agent = LLM + Tools + RAG + Loop`
+
+The Agent class is the core component of the Swarms framework, designed to create intelligent, autonomous AI agents capable of handling complex tasks through multi-modal processing, tool integration, and structured outputs. This comprehensive guide covers all aspects of the Agent class, from basic setup to advanced features.
-1. [Prerequisites & Installation](#prerequisites--installation)
-2. [Basic Agent Configuration](#basic-agent-configuration)
-3. [Multi-Modal Capabilities](#multi-modal-capabilities)
-4. [Tool Integration](#tool-integration)
-5. [Structured Outputs](#structured-outputs)
-6. [Advanced Features](#advanced-features)
-7. [Best Practices](#best-practices)
-8. [Complete Examples](#complete-examples)
## Prerequisites & Installation
@@ -8448,57 +9881,6 @@ final_only_agent = Agent(
)
```
-### Safety and Content Filtering
-
-```python
-from swarms import Agent
-
-# Agent with enhanced safety features
-safe_agent = Agent(
- agent_name="Safe-Agent",
- agent_description="Agent with comprehensive safety measures",
- system_prompt="You are a helpful, harmless, and honest AI assistant.",
- model_name="gpt-4o-mini",
- safety_prompt_on=True, # Enable safety prompts
- max_loops=1,
- temperature=0.3 # Lower temperature for more consistent, safe responses
-)
-```
-
-## Best Practices
-
-### Error Handling and Robustness
-
-```python
-import logging
-from swarms import Agent
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-def robust_agent_execution(agent, task, max_retries=3):
- """Execute agent with retry logic and error handling."""
- for attempt in range(max_retries):
- try:
- response = agent.run(task)
- logger.info(f"Agent execution successful on attempt {attempt + 1}")
- return response
- except Exception as e:
- logger.error(f"Attempt {attempt + 1} failed: {str(e)}")
- if attempt == max_retries - 1:
- raise
- time.sleep(2 ** attempt) # Exponential backoff
-
- return None
-
-# Example usage
-try:
- result = robust_agent_execution(agent, "Analyze market trends")
- print(result)
-except Exception as e:
- print(f"Agent execution failed: {e}")
-```
### Performance Optimization
@@ -8825,15 +10207,13 @@ If you encounter issues or need assistance:
We welcome contributions! Here's how to get involved:
-- **Report Bugs**: Help us improve by reporting issues
-
-- **Suggest Features**: Share your ideas for new capabilities
-
-- **Submit Code**: Contribute improvements and new features
-
-- **Improve Documentation**: Help make our docs better
-
-- **Share Examples**: Show how you're using Swarms in your projects
+| Contribution Type | Description |
+|-------------------------|--------------------------------------------------|
+| **Report Bugs** | Help us improve by reporting issues |
+| **Suggest Features** | Share your ideas for new capabilities |
+| **Submit Code** | Contribute improvements and new features |
+| **Improve Documentation** | Help make our docs better |
+| **Share Examples** | Show how you're using Swarms in your projects |
---
@@ -8841,7 +10221,7 @@ We welcome contributions! Here's how to get involved:
--------------------------------------------------
-# File: swarms\agents\iterative_agent.md
+# File: swarms/agents/iterative_agent.md
# Iterative Reflective Expansion (IRE) Algorithm Documentation
@@ -8929,7 +10309,7 @@ The Iterative Reflective Expansion (IRE) Algorithm is a powerful tool for solvin
--------------------------------------------------
-# File: swarms\agents\message.md
+# File: swarms/agents/message.md
# The Module/Class Name: Message
@@ -9047,7 +10427,7 @@ For further information on the `Message` class and its usage, refer to the offic
--------------------------------------------------
-# File: swarms\agents\new_agent.md
+# File: swarms/agents/new_agent.md
# How to Create Good Agents
@@ -9265,7 +10645,7 @@ By following these guidelines, you can create powerful and flexible agents tailo
--------------------------------------------------
-# File: swarms\agents\openai_assistant.md
+# File: swarms/agents/openai_assistant.md
# OpenAI Assistant
@@ -9406,7 +10786,7 @@ The assistant implements robust error handling:
--------------------------------------------------
-# File: swarms\agents\reasoning_agent_router.md
+# File: swarms/agents/reasoning_agent_router.md
# ReasoningAgentRouter
@@ -9841,7 +11221,7 @@ graph TD
--------------------------------------------------
-# File: swarms\agents\reasoning_agents_overview.md
+# File: swarms/agents/reasoning_agents_overview.md
# Reasoning Agents Overview
@@ -10272,7 +11652,7 @@ Reasoning agents represent a significant advancement in enterprise agent capabil
--------------------------------------------------
-# File: swarms\agents\reasoning_duo.md
+# File: swarms/agents/reasoning_duo.md
# ReasoningDuo
@@ -10440,7 +11820,7 @@ For a runnable demonstration, see the [reasoning_duo_batched.py](https://github.
--------------------------------------------------
-# File: swarms\agents\reflexion_agent.md
+# File: swarms/agents/reflexion_agent.md
# ReflexionAgent
@@ -10638,7 +12018,7 @@ The ReflexionAgent includes a sophisticated memory system (`ReflexionMemory`) th
--------------------------------------------------
-# File: swarms\agents\structured_outputs.md
+# File: swarms/agents/structured_outputs.md
# :material-code-json: Agentic Structured Outputs
@@ -10977,7 +12357,7 @@ parsed_output = str_to_dict(response)
--------------------------------------------------
-# File: swarms\agents\third_party.md
+# File: swarms/agents/third_party.md
# Swarms Framework: Integrating and Customizing Agent Libraries
@@ -11607,7 +12987,7 @@ By embracing the power of the swarms framework and the ecosystem of agent librar
--------------------------------------------------
-# File: swarms\agents\tool_agent.md
+# File: swarms/agents/tool_agent.md
# ToolAgent Documentation
@@ -11916,7 +13296,7 @@ This documentation provides a comprehensive guide to the `ToolAgent` class, incl
--------------------------------------------------
-# File: swarms\artifacts\artifact.md
+# File: swarms/artifacts/artifact.md
# `Artifact`
@@ -12165,7 +13545,689 @@ print(new_artifact.get_metrics())
--------------------------------------------------
-# File: swarms\cli\cli_guide.md
+# File: swarms/cli/cli_examples.md
+
+# Swarms CLI Examples
+
+This document provides comprehensive examples of how to use the Swarms CLI for various scenarios. Each example includes the complete command, expected output, and explanation.
+
+## Table of Contents
+
+- [Basic Usage Examples](#basic-usage-examples)
+- [Agent Management Examples](#agent-management-examples)
+- [Multi-Agent Workflow Examples](#multi-agent-workflow-examples)
+- [Configuration Examples](#configuration-examples)
+- [Advanced Usage Examples](#advanced-usage-examples)
+- [Troubleshooting Examples](#troubleshooting-examples)
+
+## Basic Usage Examples
+
+### 1. Getting Started
+
+#### Check CLI Installation
+
+```bash
+swarms help
+```
+
+**Expected Output:**
+```
+ _________
+ / _____/_ _ _______ _______ _____ ______
+ \_____ \\ \/ \/ /\__ \\_ __ \/ \ / ___/
+ / \\ / / __ \| | \/ Y Y \\___ \
+/_______ / \/\_/ (____ /__| |__|_| /____ >
+ \/ \/ \/ \/
+
+Available Commands
+┌─────────────────┬─────────────────────────────────────────────────────────────┐
+│ Command │ Description │
+├─────────────────┼─────────────────────────────────────────────────────────────┤
+│ onboarding │ Start the interactive onboarding process │
+│ help │ Display this help message │
+│ get-api-key │ Retrieve your API key from the platform │
+│ check-login │ Verify login status and initialize cache │
+│ run-agents │ Execute agents from your YAML configuration │
+│ load-markdown │ Load agents from markdown files with YAML frontmatter │
+│ agent │ Create and run a custom agent with specified parameters │
+│ auto-upgrade │ Update Swarms to the latest version │
+│ book-call │ Schedule a strategy session with our team │
+│ autoswarm │ Generate and execute an autonomous swarm │
+└─────────────────┴─────────────────────────────────────────────────────────────┘
+```
+
+#### Start Onboarding Process
+```bash
+swarms onboarding
+```
+
+This will start an interactive setup process to configure your environment.
+
+#### Get API Key
+
+```bash
+swarms get-api-key
+```
+
+**Expected Output:**
+```
+✓ API key page opened in your browser
+```
+
+#### Check Login Status
+
+```bash
+swarms check-login
+```
+
+**Expected Output:**
+```
+✓ Authentication verified
+```
+
+#### Run Environment Setup Check
+
+```bash
+swarms setup-check
+```
+
+**Expected Output:**
+```
+🔍 Running Swarms Environment Setup Check
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ Environment Check Results │
+├─────────┬─────────────────────────┬─────────────────────────────────────────┤
+│ Status │ Check │ Details │
+├─────────┼─────────────────────────┼─────────────────────────────────────────┤
+│ ✓ │ Python Version │ Python 3.11.5 │
+│ ✓ │ Swarms Version │ Current version: 8.1.1 │
+│ ✓ │ API Keys │ API keys found: OPENAI_API_KEY │
+│ ✓ │ Dependencies │ All required dependencies available │
+│ ✓ │ Environment File │ .env file exists with 1 API key(s) │
+│ ⚠ │ Workspace Directory │ WORKSPACE_DIR environment variable is not set │
+└─────────┴─────────────────────────┴─────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ Setup Check Complete │
+├─────────────────────────────────────────────────────────────────────────────┤
+│ ⚠️ Some checks failed. Please review the issues above. │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+💡 Recommendations:
+ 1. Set WORKSPACE_DIR environment variable: export WORKSPACE_DIR=/path/to/your/workspace
+
+Run 'swarms setup-check' again after making changes to verify.
+```
+
+## Agent Management Examples
+
+### 2. Creating Custom Agents
+
+#### Basic Research Agent
+
+```bash
+swarms agent \
+ --name "Research Assistant" \
+ --description "AI research specialist for academic papers" \
+ --system-prompt "You are an expert research assistant specializing in academic research. You help users find, analyze, and synthesize information from various sources. Always provide well-structured, evidence-based responses." \
+ --task "Research the latest developments in quantum computing and provide a summary of key breakthroughs in the last 2 years" \
+ --model-name "gpt-4" \
+ --temperature 0.1 \
+ --max-loops 3
+```
+
+**Expected Output:**
+```
+Creating custom agent: Research Assistant
+[✓] Agent 'Research Assistant' completed the task successfully!
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ Agent Execution Results │
+├─────────────────────────────────────────────────────────────────────────────┤
+│ Agent Name: Research Assistant │
+│ Model: gpt-4 │
+│ Task: Research the latest developments in quantum computing... │
+│ Result: │
+│ Recent breakthroughs in quantum computing include: │
+│ 1. Google's 53-qubit Sycamore processor achieving quantum supremacy │
+│ 2. IBM's 433-qubit Osprey processor... │
+│ ... │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+#### Code Review Agent
+
+```bash
+swarms agent \
+ --name "Code Reviewer" \
+ --description "Expert code review assistant with security focus" \
+ --system-prompt "You are a senior software engineer specializing in code review, security analysis, and best practices. Review code for bugs, security vulnerabilities, performance issues, and adherence to coding standards." \
+ --task "Review this Python code for security vulnerabilities and suggest improvements: def process_user_input(data): return eval(data)" \
+ --model-name "gpt-4" \
+ --temperature 0.05 \
+ --max-loops 2 \
+ --verbose
+```
+
+#### Financial Analysis Agent
+
+```bash
+swarms agent \
+ --name "Financial Analyst" \
+ --description "Expert financial analyst for market research and investment advice" \
+ --system-prompt "You are a certified financial analyst with expertise in market analysis, investment strategies, and risk assessment. Provide data-driven insights and recommendations based on current market conditions." \
+ --task "Analyze the current state of the technology sector and provide investment recommendations for the next quarter" \
+ --model-name "gpt-4" \
+ --temperature 0.2 \
+ --max-loops 2 \
+ --output-type "json"
+```
+
+### 3. Advanced Agent Configuration
+
+#### Agent with Dynamic Features
+
+```bash
+swarms agent \
+ --name "Adaptive Writer" \
+ --description "Content writer with dynamic temperature and context adjustment" \
+ --system-prompt "You are a professional content writer who adapts writing style based on audience and context. You can write in various tones from formal to casual, and adjust complexity based on the target audience." \
+ --task "Write a blog post about artificial intelligence for a general audience, explaining complex concepts in simple terms" \
+ --model-name "gpt-4" \
+ --dynamic-temperature-enabled \
+ --dynamic-context-window \
+ --context-length 8000 \
+ --retry-attempts 3 \
+ --return-step-meta \
+ --autosave \
+ --saved-state-path "./agent_states/"
+```
+
+#### Agent with MCP Integration
+
+```bash
+swarms agent \
+ --name "MCP Agent" \
+ --description "Agent with Model Context Protocol integration" \
+ --system-prompt "You are a agent with access to external tools and data sources through MCP. Use these capabilities to provide comprehensive and up-to-date information." \
+ --task "Search for recent news about climate change and summarize the key findings" \
+ --model-name "gpt-4" \
+ --mcp-url "https://api.example.com/mcp" \
+ --temperature 0.1 \
+ --max-loops 5
+```
+
+## Multi-Agent Workflow Examples
+
+### 4. Running Agents from YAML Configuration
+
+#### Create `research_team.yaml`
+
+```yaml
+agents:
+ - name: "Data Collector"
+ description: "Specialist in gathering and organizing data from various sources"
+ model_name: "gpt-4"
+ system_prompt: "You are a data collection specialist. Your role is to gather relevant information from multiple sources and organize it in a structured format."
+ temperature: 0.1
+ max_loops: 3
+
+ - name: "Data Analyzer"
+ description: "Expert in analyzing and interpreting complex datasets"
+ model_name: "gpt-4"
+ system_prompt: "You are a data analyst. Take the collected data and perform comprehensive analysis to identify patterns, trends, and insights."
+ temperature: 0.2
+ max_loops: 4
+
+ - name: "Report Writer"
+ description: "Professional writer who creates clear, compelling reports"
+ model_name: "gpt-4"
+ system_prompt: "You are a report writer. Take the analyzed data and create a comprehensive, well-structured report that communicates findings clearly."
+ temperature: 0.3
+ max_loops: 3
+```
+
+#### Execute the Team
+
+```bash
+swarms run-agents --yaml-file research_team.yaml
+```
+
+**Expected Output:**
+```
+Loading agents from research_team.yaml...
+[✓] Agents completed their tasks successfully!
+
+Results:
+Data Collector: [Collected data from 15 sources...]
+Data Analyzer: [Identified 3 key trends and 5 significant patterns...]
+Report Writer: [Generated comprehensive 25-page report...]
+```
+
+### 5. Loading Agents from Markdown
+
+#### Create `agents/researcher.md`
+
+```markdown
+---
+name: Market Researcher
+description: Expert in market research and competitive analysis
+model_name: gpt-4
+temperature: 0.1
+max_loops: 3
+---
+
+You are an expert market researcher with 15+ years of experience in competitive analysis, market sizing, and trend identification. You specialize in technology markets and have deep knowledge of consumer behavior, pricing strategies, and market dynamics.
+
+Your approach includes:
+- Systematic data collection from multiple sources
+- Quantitative and qualitative analysis
+- Competitive landscape mapping
+- Market opportunity identification
+- Risk assessment and mitigation strategies
+```
+
+#### Create `agents/analyst.md`
+
+```markdown
+---
+name: Business Analyst
+description: Strategic business analyst focusing on growth opportunities
+model_name: gpt-4
+temperature: 0.2
+max_loops: 4
+---
+
+You are a senior business analyst specializing in strategic planning and growth strategy. You excel at identifying market opportunities, analyzing competitive advantages, and developing actionable business recommendations.
+
+Your expertise covers:
+- Market opportunity analysis
+- Competitive positioning
+- Business model innovation
+- Risk assessment
+- Strategic planning frameworks
+```
+
+#### Load and Use Agents
+
+```bash
+swarms load-markdown --markdown-path ./agents/ --concurrent
+```
+
+**Expected Output:**
+```
+Loading agents from markdown: ./agents/
+✓ Successfully loaded 2 agents!
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ Loaded Agents │
+├─────────────────┬──────────────┬───────────────────────────────────────────┤
+│ Name │ Model │ Description │
+├─────────────────┼──────────────┼───────────────────────────────────────────┤
+│ Market Researcher│ gpt-4 │ Expert in market research and competitive │
+│ │ │ analysis │
+├─────────────────┼──────────────┼───────────────────────────────────────────┤
+│ Business Analyst│ gpt-4 │ Strategic business analyst focusing on │
+│ │ │ growth opportunities │
+└─────────────────┴──────────────┴───────────────────────────────────────────┘
+
+Ready to use 2 agents!
+You can now use these agents in your code or run them interactively.
+```
+
+## Configuration Examples
+
+### 6. YAML Configuration Templates
+
+#### Simple Agent Configuration
+
+```yaml
+# simple_agent.yaml
+agents:
+ - name: "Simple Assistant"
+ description: "Basic AI assistant for general tasks"
+ model_name: "gpt-3.5-turbo"
+ system_prompt: "You are a helpful AI assistant."
+ temperature: 0.7
+ max_loops: 1
+```
+
+#### Advanced Multi-Agent Configuration
+
+```yaml
+# advanced_team.yaml
+agents:
+ - name: "Project Manager"
+ description: "Coordinates team activities and ensures project success"
+ model_name: "gpt-4"
+ system_prompt: "You are a senior project manager with expertise in agile methodologies, risk management, and team coordination."
+ temperature: 0.1
+ max_loops: 5
+ auto_generate_prompt: true
+ dynamic_temperature_enabled: true
+
+ - name: "Technical Lead"
+ description: "Provides technical guidance and architecture decisions"
+ model_name: "gpt-4"
+ system_prompt: "You are a technical lead with deep expertise in software architecture, system design, and technical decision-making."
+ temperature: 0.2
+ max_loops: 4
+ context_length: 12000
+ retry_attempts: 3
+
+ - name: "Quality Assurance"
+ description: "Ensures quality standards and testing coverage"
+ model_name: "gpt-4"
+ system_prompt: "You are a QA specialist focused on quality assurance, testing strategies, and process improvement."
+ temperature: 0.1
+ max_loops: 3
+ return_step_meta: true
+ dashboard: true
+```
+
+### 7. Markdown Configuration Templates
+
+#### Research Agent Template
+
+```markdown
+---
+name: Research Specialist
+description: Academic research and literature review expert
+model_name: gpt-4
+temperature: 0.1
+max_loops: 5
+context_length: 16000
+auto_generate_prompt: true
+---
+
+You are a research specialist with expertise in academic research methodologies, literature review, and scholarly writing. You excel at:
+
+- Systematic literature reviews
+- Research methodology design
+- Data analysis and interpretation
+- Academic writing and citation
+- Research gap identification
+
+Always provide evidence-based responses and cite relevant sources when possible.
+```
+
+#### Creative Writing Agent Template
+
+```markdown
+---
+name: Creative Writer
+description: Professional creative writer and storyteller
+model_name: gpt-4
+temperature: 0.8
+max_loops: 3
+dynamic_temperature_enabled: true
+output_type: markdown
+---
+
+You are a creative writer with a passion for storytelling, character development, and engaging narratives. You specialize in:
+
+- Fiction writing across multiple genres
+- Character development and dialogue
+- Plot structure and pacing
+- Creative problem-solving
+- Engaging opening hooks and satisfying conclusions
+
+Your writing style is adaptable, engaging, and always focused on creating memorable experiences for readers.
+```
+
+## Advanced Usage Examples
+
+### 8. Autonomous Swarm Generation
+
+#### Simple Task
+```bash
+swarms autoswarm \
+ --task "Create a weekly meal plan for a family of 4 with dietary restrictions" \
+ --model "gpt-4"
+```
+
+#### Complex Research Task
+```bash
+swarms autoswarm \
+ --task "Conduct a comprehensive analysis of the impact of artificial intelligence on job markets, including historical trends, current state, and future projections. Include case studies from different industries and recommendations for workforce adaptation." \
+ --model "gpt-4"
+```
+
+### 9. Integration Examples
+
+#### CI/CD Pipeline Integration
+```yaml
+# .github/workflows/swarms-test.yml
+name: Swarms Agent Testing
+on: [push, pull_request]
+
+jobs:
+ test-agents:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v3
+ - name: Set up Python
+ uses: actions/setup-python@v4
+ with:
+ python-version: '3.9'
+ - name: Install dependencies
+ run: |
+ pip install swarms
+ - name: Run Swarms Agents
+ run: |
+ swarms run-agents --yaml-file ci_agents.yaml
+ env:
+ OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+```
+
+#### Shell Script Integration
+```bash
+#!/bin/bash
+# run_daily_analysis.sh
+
+echo "Starting daily market analysis..."
+
+# Run market research agent
+swarms agent \
+ --name "Daily Market Analyzer" \
+ --description "Daily market analysis and reporting" \
+ --system-prompt "You are a market analyst providing daily market insights." \
+ --task "Analyze today's market movements and provide key insights" \
+ --model-name "gpt-4" \
+ --temperature 0.1
+
+# Run risk assessment agent
+swarms agent \
+ --name "Risk Assessor" \
+ --description "Risk assessment and mitigation specialist" \
+ --system-prompt "You are a risk management expert." \
+ --task "Assess current market risks and suggest mitigation strategies" \
+ --model-name "gpt-4" \
+ --temperature 0.2
+
+echo "Daily analysis complete!"
+```
+
+## Troubleshooting Examples
+
+### 10. Common Error Scenarios
+
+#### Missing API Key
+```bash
+swarms agent \
+ --name "Test Agent" \
+ --description "Test" \
+ --system-prompt "Test" \
+ --task "Test"
+```
+
+**Expected Error:**
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ Error │
+├─────────────────────────────────────────────────────────────────────────────┤
+│ Failed to create or run agent: No API key found │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+Please check:
+1. Your API keys are set correctly
+2. The model name is valid
+3. All required parameters are provided
+4. Your system prompt is properly formatted
+```
+
+**Resolution:**
+```bash
+export OPENAI_API_KEY="your-api-key-here"
+```
+
+#### Invalid YAML Configuration
+```bash
+swarms run-agents --yaml-file invalid.yaml
+```
+
+**Expected Error:**
+```
+┌─────────────────────────────────────────────────────────────────────────────┘
+│ Configuration Error │
+├─────────────────────────────────────────────────────────────────────────────┤
+│ Error parsing YAML: Invalid YAML syntax │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+Please check your agents.yaml file format.
+```
+
+#### File Not Found
+```bash
+swarms load-markdown --markdown-path ./nonexistent/
+```
+
+**Expected Error:**
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ File Error │
+├─────────────────────────────────────────────────────────────────────────────┤
+│ Markdown file/directory not found: ./nonexistent/ │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+Please make sure the path exists and you're in the correct directory.
+```
+
+### 11. Debug Mode Usage
+
+#### Enable Verbose Output
+```bash
+swarms agent \
+ --name "Debug Agent" \
+ --description "Agent for debugging" \
+ --system-prompt "You are a debugging assistant." \
+ --task "Help debug this issue" \
+ --model-name "gpt-4" \
+ --verbose
+```
+
+This will provide detailed output including:
+- Step-by-step execution details
+- API call information
+- Internal state changes
+- Performance metrics
+
+## Environment Setup
+
+### 12. Environment Verification
+
+The `setup-check` command is essential for ensuring your environment is properly configured:
+
+```bash
+# Run comprehensive environment check
+swarms setup-check
+```
+
+This command checks:
+- Python version compatibility (3.10+)
+- Swarms package version and updates
+- API key configuration
+- Required dependencies
+- Environment file setup
+- Workspace directory configuration
+
+**Use Cases:**
+- **Before starting a new project**: Verify all requirements are met
+- **After environment changes**: Confirm configuration updates
+- **Troubleshooting**: Identify missing dependencies or configuration issues
+- **Team onboarding**: Ensure consistent environment setup across team members
+
+## Best Practices
+
+### 13. Performance Optimization
+
+#### Use Concurrent Processing
+```bash
+# For multiple markdown files
+swarms load-markdown \
+ --markdown-path ./large_agent_directory/ \
+ --concurrent
+```
+
+#### Optimize Model Selection
+```bash
+# For simple tasks
+--model-name "gpt-3.5-turbo" --temperature 0.1
+
+# For complex reasoning
+--model-name "gpt-4" --temperature 0.1 --max-loops 5
+```
+
+#### Context Length Management
+```bash
+# For long documents
+--context-length 16000 --dynamic-context-window
+
+# For concise responses
+--context-length 4000 --max-loops 2
+```
+
+### 14. Security Considerations
+
+#### Environment Variable Usage
+```bash
+# Secure API key management
+export OPENAI_API_KEY="your-secure-key"
+export ANTHROPIC_API_KEY="your-secure-key"
+
+# Use in CLI
+swarms agent [options]
+```
+
+#### File Permissions
+```bash
+# Secure configuration files
+chmod 600 agents.yaml
+chmod 600 .env
+```
+
+## Summary
+
+The Swarms CLI provides a powerful and flexible interface for managing AI agents and multi-agent workflows. These examples demonstrate:
+
+| Feature | Description |
+|------------------------|---------------------------------------------------------|
+| **Basic Usage** | Getting started with the CLI |
+| **Agent Management** | Creating and configuring custom agents |
+| **Multi-Agent Workflows** | Coordinating multiple agents |
+| **Configuration** | YAML and markdown configuration formats |
+| **Environment Setup** | Environment verification and setup checks |
+| **Advanced Features** | Dynamic configuration and MCP integration |
+| **Troubleshooting** | Common issues and solutions |
+| **Best Practices** | Performance and security considerations |
+
+For more information, refer to the [CLI Reference](cli_reference.md) documentation.
+
+
+--------------------------------------------------
+
+# File: swarms/cli/cli_guide.md
# The Ultimate Technical Guide to the Swarms CLI: A Step-by-Step Developer’s Guide
@@ -12478,7 +14540,485 @@ With the Swarms CLI, the future of automation is within reach.
--------------------------------------------------
-# File: swarms\cli\main.md
+# File: swarms/cli/cli_reference.md
+
+# Swarms CLI Reference
+
+The Swarms CLI is a comprehensive command-line interface for managing and executing Swarms agents and multi-agent architectures. This reference documents all available commands, arguments, and features.
+
+## Table of Contents
+
+- [Installation](#installation)
+
+- [Basic Usage](#basic-usage)
+
+- [Commands Reference](#commands-reference)
+
+- [Global Arguments](#global-arguments)
+
+- [Command-Specific Arguments](#command-specific-arguments)
+
+- [Error Handling](#error-handling)
+
+- [Examples](#examples)
+
+- [Configuration](#configuration)
+
+
+## Installation
+
+The CLI is included with the Swarms package installation:
+
+```bash
+pip install swarms
+```
+
+## Basic Usage
+
+```bash
+swarms [options]
+```
+
+## Commands Reference
+
+### Core Commands
+
+| Command | Description | Required Arguments |
+|---------|-------------|-------------------|
+| `onboarding` | Start interactive onboarding process | None |
+| `help` | Display help message | None |
+| `get-api-key` | Open API key portal in browser | None |
+| `check-login` | Verify login status and initialize cache | None |
+| `run-agents` | Execute agents from YAML configuration | `--yaml-file` |
+| `load-markdown` | Load agents from markdown files | `--markdown-path` |
+| `agent` | Create and run custom agent | `--name`, `--description`, `--system-prompt`, `--task` |
+| `auto-upgrade` | Update Swarms to latest version | None |
+| `book-call` | Schedule strategy session | None |
+| `autoswarm` | Generate and execute autonomous swarm | `--task`, `--model` |
+| `setup-check` | Run comprehensive environment setup check | None |
+
+## Global Arguments
+
+All commands support these global options:
+
+| Argument | Type | Default | Description |
+|----------|------|---------|-------------|
+| `--verbose` | `bool` | `False` | Enable verbose output |
+| `--help`, `-h` | `bool` | `False` | Show help message |
+
+## Command-Specific Arguments
+
+### `run-agents` Command
+
+Execute agents from YAML configuration files.
+
+```bash
+python -m swarms.cli.main run-agents [options]
+```
+
+| Argument | Type | Default | Required | Description |
+|----------|------|---------|----------|-------------|
+| `--yaml-file` | `str` | `"agents.yaml"` | No | Path to YAML configuration file |
+
+**Example:**
+```bash
+swarms run-agents --yaml-file my_agents.yaml
+```
+
+### `load-markdown` Command
+
+Load agents from markdown files with YAML frontmatter.
+
+```bash
+python -m swarms.cli.main load-markdown [options]
+```
+
+| Argument | Type | Default | Required | Description |
+|----------|------|---------|----------|-------------|
+| `--markdown-path` | `str` | `None` | **Yes** | Path to markdown file or directory |
+| `--concurrent` | `bool` | `True` | No | Enable concurrent processing for multiple files |
+
+**Example:**
+```bash
+swarms load-markdown --markdown-path ./agents/ --concurrent
+```
+
+### `agent` Command
+
+Create and run a custom agent with specified parameters.
+
+```bash
+python -m swarms.cli.main agent [options]
+```
+
+#### Required Arguments
+
+| Argument | Type | Description |
+|----------|------|-------------|
+| `--name` | `str` | Name of the custom agent |
+| `--description` | `str` | Description of the custom agent |
+| `--system-prompt` | `str` | System prompt for the custom agent |
+| `--task` | `str` | Task for the custom agent to execute |
+
+#### Optional Arguments
+
+| Argument | Type | Default | Description |
+|----------|------|---------|-------------|
+| `--model-name` | `str` | `"gpt-4"` | Model name for the custom agent |
+| `--temperature` | `float` | `None` | Temperature setting (0.0-2.0) |
+| `--max-loops` | `int` | `None` | Maximum number of loops for the agent |
+| `--auto-generate-prompt` | `bool` | `False` | Enable auto-generation of prompts |
+| `--dynamic-temperature-enabled` | `bool` | `False` | Enable dynamic temperature adjustment |
+| `--dynamic-context-window` | `bool` | `False` | Enable dynamic context window |
+| `--output-type` | `str` | `None` | Output type (e.g., 'str', 'json') |
+| `--verbose` | `bool` | `False` | Enable verbose mode for the agent |
+| `--streaming-on` | `bool` | `False` | Enable streaming mode for the agent |
+| `--context-length` | `int` | `None` | Context length for the agent |
+| `--retry-attempts` | `int` | `None` | Number of retry attempts for the agent |
+| `--return-step-meta` | `bool` | `False` | Return step metadata from the agent |
+| `--dashboard` | `bool` | `False` | Enable dashboard for the agent |
+| `--autosave` | `bool` | `False` | Enable autosave for the agent |
+| `--saved-state-path` | `str` | `None` | Path for saving agent state |
+| `--user-name` | `str` | `None` | Username for the agent |
+| `--mcp-url` | `str` | `None` | MCP URL for the agent |
+
+**Example:**
+```bash
+swarms agent \
+ --name "Trading Agent" \
+ --description "Advanced trading agent for market analysis" \
+ --system-prompt "You are an expert trader..." \
+ --task "Analyze market trends for AAPL" \
+ --model-name "gpt-4" \
+ --temperature 0.1 \
+ --max-loops 5
+```
+
+### `autoswarm` Command
+
+Generate and execute an autonomous swarm configuration.
+
+```bash
+swarms autoswarm [options]
+```
+
+| Argument | Type | Default | Required | Description |
+|----------|------|---------|----------|-------------|
+| `--task` | `str` | `None` | **Yes** | Task description for the swarm |
+| `--model` | `str` | `None` | **Yes** | Model name to use for the swarm |
+
+**Example:**
+
+```bash
+swarms autoswarm --task "analyze this data" --model "gpt-4"
+```
+
+### `setup-check` Command
+
+Run a comprehensive environment setup check to verify your Swarms installation and configuration.
+
+```bash
+swarms setup-check [--verbose]
+```
+
+**Arguments:**
+- `--verbose`: Enable detailed debug output showing version detection methods
+
+This command performs the following checks:
+- **Python Version**: Verifies Python 3.10+ compatibility
+- **Swarms Version**: Checks current version and compares with latest available
+- **API Keys**: Verifies presence of common API keys in environment variables
+- **Dependencies**: Ensures required packages are available
+- **Environment File**: Checks for .env file existence and content
+- **Workspace Directory**: Verifies WORKSPACE_DIR environment variable
+
+**Examples:**
+```bash
+# Basic setup check
+swarms setup-check
+
+# Verbose setup check with debug information
+swarms setup-check --verbose
+```
+
+**Expected Output:**
+```
+🔍 Running Swarms Environment Setup Check
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ Environment Check Results │
+├─────────┬─────────────────────────┬─────────────────────────────────────────┤
+│ Status │ Check │ Details │
+├─────────┼─────────────────────────┼─────────────────────────────────────────┤
+│ ✓ │ Python Version │ Python 3.11.5 │
+│ ✓ │ Swarms Version │ Current version: 8.1.1 │
+│ ✓ │ API Keys │ API keys found: OPENAI_API_KEY │
+│ ✓ │ Dependencies │ All required dependencies available │
+│ ✓ │ Environment File │ .env file exists with 1 API key(s) │
+│ ✓ │ Workspace Directory │ WORKSPACE_DIR is set to: /path/to/ws │
+└─────────┴─────────────────────────┴─────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ Setup Check Complete │
+├─────────────────────────────────────────────────────────────────────────────┤
+│ 🎉 All checks passed! Your environment is ready for Swarms. │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+## Error Handling
+
+The CLI provides comprehensive error handling with formatted error messages:
+
+### Error Types
+
+| Error Type | Description | Resolution |
+|------------|-------------|------------|
+| `FileNotFoundError` | Configuration file not found | Check file path and permissions |
+| `ValueError` | Invalid configuration format | Verify YAML/markdown syntax |
+| `SwarmCLIError` | Custom CLI-specific errors | Check command arguments and API keys |
+| `API Key Error` | Authentication issues | Verify API key configuration |
+| `Context Length Error` | Model context exceeded | Reduce input size or use larger model |
+
+### Error Display Format
+
+Errors are displayed in formatted panels with:
+
+- **Error Title**: Clear error identification
+
+- **Error Message**: Detailed error description
+
+- **Help Text**: Suggested resolution steps
+
+- **Color Coding**: Red borders for errors, yellow for warnings
+
+
+## Examples
+
+### Basic Agent Creation
+
+```bash
+# Create a simple agent
+swarms agent \
+ --name "Code Reviewer" \
+ --description "AI code review assistant" \
+ --system-prompt "You are an expert code reviewer..." \
+ --task "Review this Python code for best practices" \
+ --model-name "gpt-4" \
+ --temperature 0.1
+```
+
+### Loading Multiple Agents
+
+```bash
+# Load agents from markdown directory
+swarms load-markdown \
+ --markdown-path ./my_agents/ \
+ --concurrent
+```
+
+### Running YAML Configuration
+
+```bash
+# Execute agents from YAML file
+swarms run-agents \
+ --yaml-file production_agents.yaml
+```
+
+### Autonomous Swarm Generation
+
+```bash
+# Generate swarm for complex task
+swarms autoswarm \
+ --task "Create a comprehensive market analysis report for tech stocks" \
+ --model "gpt-4"
+```
+
+## Configuration
+
+### YAML Configuration Format
+
+For `run-agents` command, use this YAML structure:
+
+```yaml
+agents:
+ - name: "Research Agent"
+
+ description: "Research and analysis specialist"
+ model_name: "gpt-4"
+ system_prompt: "You are a research specialist..."
+ temperature: 0.1
+ max_loops: 3
+
+ - name: "Analysis Agent"
+
+ description: "Data analysis expert"
+ model_name: "gpt-4"
+ system_prompt: "You are a data analyst..."
+ temperature: 0.2
+ max_loops: 5
+```
+
+### Markdown Configuration Format
+
+For `load-markdown` command, use YAML frontmatter:
+
+```markdown
+---
+name: Research Agent
+description: AI research specialist
+model_name: gpt-4
+temperature: 0.1
+max_loops: 3
+---
+
+You are an expert research agent specializing in...
+```
+
+## Advanced Features
+
+### Progress Indicators
+
+The CLI provides rich progress indicators for long-running operations:
+
+- **Spinner Animations**: Visual feedback during execution
+
+
+- **Progress Bars**: For operations with known completion states
+
+- **Status Updates**: Real-time operation status
+
+
+### Concurrent Processing
+
+Multiple markdown files can be processed concurrently:
+
+- **Parallel Execution**: Improves performance for large directories
+
+- **Resource Management**: Automatic thread management
+
+- **Error Isolation**: Individual file failures don't affect others
+
+
+### Auto-upgrade System
+
+```bash
+swarms auto-upgrade
+```
+
+Automatically updates Swarms to the latest version with:
+
+- Version checking
+
+- Dependency resolution
+
+- Safe update process
+
+
+### Interactive Onboarding
+
+```bash
+swarms onboarding
+```
+
+Guided setup process including:
+
+- API key configuration
+
+- Environment setup
+
+- Basic agent creation
+
+- Usage examples
+
+
+## Troubleshooting
+
+### Common Issues
+
+1. **API Key Not Set**
+
+ ```bash
+ export OPENAI_API_KEY="your-api-key-here"
+ ```
+
+2. **File Permissions**
+ ```bash
+ chmod 644 agents.yaml
+ ```
+
+3. **Model Not Available**
+ - Verify model name spelling
+
+ - Check API key permissions
+
+ - Ensure sufficient quota
+
+
+### Debug Mode
+
+Enable verbose output for debugging:
+
+```bash
+swarms --verbose
+```
+
+## Integration
+
+### CI/CD Integration
+
+The CLI can be integrated into CI/CD pipelines:
+
+```yaml
+# GitHub Actions example
+- name: Run Swarms Agents
+
+ run: |
+ swarms run-agents --yaml-file ci_agents.yaml
+```
+
+### Scripting
+
+Use in shell scripts:
+
+```bash
+#!/bin/bash
+# Run multiple agent configurations
+swarms run-agents --yaml-file agents1.yaml
+swarms run-agents --yaml-file agents2.yaml
+```
+
+## Performance Considerations
+
+| Consideration | Recommendation |
+|------------------------|-----------------------------------------------------|
+| Concurrent Processing | Use `--concurrent` for multiple files |
+| Model Selection | Choose appropriate models for task complexity |
+| Context Length | Monitor and optimize input sizes |
+| Rate Limiting | Respect API provider limits |
+
+## Security
+
+| Security Aspect | Recommendation |
+|------------------------|--------------------------------------------------------|
+| API Key Management | Store keys in environment variables |
+| File Permissions | Restrict access to configuration files |
+| Input Validation | CLI validates all inputs before execution |
+| Error Sanitization | Sensitive information is not exposed in errors |
+
+## Support
+
+For additional support:
+
+| Support Option | Link |
+|----------------------|---------------------------------------------------------------------------------------|
+| **Community** | [Discord](https://discord.gg/EamjgSaEQf) |
+| **Issues** | [GitHub Issues](https://github.com/kyegomez/swarms/issues) |
+| **Strategy Sessions**| [Book a Call](https://cal.com/swarms/swarms-strategy-session) |
+
+
+--------------------------------------------------
+
+# File: swarms/cli/main.md
# Swarms CLI Documentation
@@ -12588,7 +15128,7 @@ Below is a detailed explanation of the available commands:
--------------------------------------------------
-# File: swarms\concept\framework_architecture.md
+# File: swarms/concept/framework_architecture.md
# Swarms Framework Architecture
@@ -12752,7 +15292,7 @@ By understanding the purpose and role of each folder in the Swarms framework, us
--------------------------------------------------
-# File: swarms\concept\future_swarm_architectures.md
+# File: swarms/concept/future_swarm_architectures.md
@@ -12879,7 +15419,7 @@ These swarm architectures provide different models for organizing and orchestrat
--------------------------------------------------
-# File: swarms\concept\how_to_choose_swarms.md
+# File: swarms/concept/how_to_choose_swarms.md
# Choosing the Right Swarm for Your Business Problem
@@ -13024,7 +15564,7 @@ When integrating agents in a business workflow, it's crucial to balance task com
--------------------------------------------------
-# File: swarms\concept\philosophy.md
+# File: swarms/concept/philosophy.md
# Our Philosophy: Simplifying Multi-Agent Collaboration Through Readable Code and Performance Optimization
@@ -13381,7 +15921,7 @@ By adhering to these principles, we create a robust foundation for scalable and
--------------------------------------------------
-# File: swarms\concept\purpose\limits_of_individual_agents.md
+# File: swarms/concept/purpose/limits_of_individual_agents.md
# The Limits of Individual Agents
@@ -13441,7 +15981,7 @@ While individual AI agents have made remarkable strides in various domains, thei
--------------------------------------------------
-# File: swarms\concept\purpose\why.md
+# File: swarms/concept/purpose/why.md
# The Swarms Framework: Orchestrating Agents for Enterprise Automation
@@ -13580,7 +16120,7 @@ As the field of artificial intelligence continues to advance, the Swarms Framewo
--------------------------------------------------
-# File: swarms\concept\purpose\why_swarms.md
+# File: swarms/concept/purpose/why_swarms.md
# Why Swarms?
@@ -13638,7 +16178,7 @@ The collaboration of multiple agents in AI systems presents a robust solution to
--------------------------------------------------
-# File: swarms\concept\swarm_architectures.md
+# File: swarms/concept/swarm_architectures.md
# Multi-Agent Architectures
@@ -14497,7 +17037,7 @@ graph TD
--------------------------------------------------
-# File: swarms\concept\swarm_ecosystem.md
+# File: swarms/concept/swarm_ecosystem.md
# Understanding the Swarms Ecosystem
@@ -14590,7 +17130,7 @@ Start exploring the possibilities by checking out the [Swarms Ecosystem GitHub r
--------------------------------------------------
-# File: swarms\concept\vision.md
+# File: swarms/concept/vision.md
# Swarms – The Ultimate Multi-Agent LLM Framework for Developers
@@ -14744,7 +17284,7 @@ Swarms is not just another multi-agent framework; it's built specifically for de
--------------------------------------------------
-# File: swarms\concept\why.md
+# File: swarms/concept/why.md
**Maximizing Enterprise Automation: Overcoming the Limitations of Individual AI Agents Through Multi-Agent Collaboration**
@@ -15254,7 +17794,7 @@ Implementing multi-agent systems requires thoughtful planning, adherence to best
--------------------------------------------------
-# File: swarms\contributing.md
+# File: swarms/contributing.md
# Contribution Guidelines
@@ -15497,162 +18037,75 @@ If you have any questions or need assistance, please feel free to open an issue
--------------------------------------------------
-# File: swarms\ecosystem.md
+# File: swarms/ecosystem.md
-# Swarms Ecosystem
+# Swarms Infrastructure Stack
-*The Complete Enterprise-Grade Multi-Agent AI Platform*
+**We're Building the Operating System for the Agent Economy**
----
-
-## **Join the Future of AI Development**
-
-**We're Building the Operating System for the Agent Economy** - The Swarms ecosystem represents the most comprehensive, production-ready multi-agent AI platform available today. From our flagship Python framework to high-performance Rust implementations and client libraries spanning every major programming language, we provide enterprise-grade tools that power the next generation of intelligent applications.
-
----
-
-## **Complete Product Portfolio**
-
-| **Product** | **Technology** | **Status** | **Repository** | **Documentation** |
-|-------------|---------------|------------|----------------|-------------------|
-| **Swarms Python Framework** | Python | **Production** | [swarms](https://github.com/kyegomez/swarms) | [Docs](https://docs.swarms.world/en/latest/swarms/install/install/) |
-| **Swarms Rust Framework** | Rust | **Production** | [swarms-rs](https://github.com/The-Swarm-Corporation/swarms-rs) | [Docs](https://docs.swarms.world/en/latest/swarms_rs/overview/) |
-| **Python API Client** | Python | **Production** | [swarms-sdk](https://github.com/The-Swarm-Corporation/swarms-sdk) | [Docs](https://docs.swarms.world/en/latest/swarms_cloud/python_client/) |
-| **TypeScript/Node.js Client** | TypeScript | **Production** | [swarms-ts](https://github.com/The-Swarm-Corporation/swarms-ts) | *Coming Soon* |
-| **Go Client** | Go | **Production** | [swarms-client-go](https://github.com/The-Swarm-Corporation/swarms-client-go) | *Coming Soon* |
-| **Java Client** | Java | **Production** | [swarms-java](https://github.com/The-Swarm-Corporation/swarms-java) | *Coming Soon* |
-| **Kotlin Client** | Kotlin | **Q2 2025** | *In Development* | *Coming Soon* |
-| **Ruby Client** | Ruby | **Q2 2025** | *In Development* | *Coming Soon* |
-| **Rust Client** | Rust | **Q2 2025** | *In Development* | *Coming Soon* |
-| **C#/.NET Client** | C# | **Q3 2025** | *In Development* | *Coming Soon* |
+The Swarms ecosystem represents the most comprehensive, production-ready multi-agent AI platform available today. From our flagship Python framework to high-performance Rust implementations and client libraries spanning every major programming language, we provide enterprise-grade tools that power the next generation of agentic applications.
---
-## **Why Choose the Swarms Ecosystem?**
+## **Product Portfolio by Language & API**
-### **Enterprise-Grade Architecture**
+### 🐍 **Python**
-- **Production Ready**: Battle-tested in enterprise environments with 99.9%+ uptime
-
-- **Scalable Infrastructure**: Handle millions of agent interactions with automatic scaling
-
-- **Security First**: End-to-end encryption, API key management, and enterprise compliance
-
-- **Observability**: Comprehensive logging, monitoring, and debugging capabilities
-
-### **Developer Experience**
-
-- **Multiple Language Support**: Native clients for every major programming language
-
-- **Unified API**: Consistent interface across all platforms and languages
-
-- **Rich Documentation**: Comprehensive guides, tutorials, and API references
-
-- **Active Community**: 24/7 support through Discord, GitHub, and direct channels
-
-### **Performance & Reliability**
-
-- **High Throughput**: Process thousands of concurrent agent requests
-
-- **Low Latency**: Optimized for real-time applications and user experiences
-
-- **Fault Tolerance**: Automatic retries, circuit breakers, and graceful degradation
-
-- **Multi-Cloud**: Deploy on AWS, GCP, Azure, or on-premises infrastructure
-
----
-
-## **Join Our Growing Community**
-
-### **Connect With Developers Worldwide**
-
-| **Platform** | **Purpose** | **Join Link** | **Benefits** |
-|--------------|-------------|---------------|--------------|
-| **Discord Community** | Real-time support & discussions | [Join Discord](https://discord.gg/EamjgSaEQf) | • 24/7 developer support
• Weekly community events
• Direct access to core team
• Beta feature previews |
-| **Twitter/X** | Latest updates & announcements | [Follow @swarms_corp](https://x.com/swarms_corp) | • Breaking news & updates
• Community highlights
• Technical insights
• Industry partnerships |
-| **LinkedIn** | Professional network & updates | [The Swarm Corporation](https://www.linkedin.com/company/the-swarm-corporation) | • Professional networking
• Career opportunities
• Enterprise partnerships
• Industry insights |
-| **YouTube** | Tutorials & technical content | [Swarms Channel](https://www.youtube.com/channel/UC9yXyitkbU_WSy7bd_41SqQ) | • In-depth tutorials
• Live coding sessions
• Architecture deep dives
• Community showcases |
+| **Product** | **Description** | **Status** | **Repository** | **Documentation** |
+|------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------|-------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------|
+| **Swarms Python Framework** | The core multi-agent orchestration framework for Python. Enables building, managing, and scaling complex agentic systems with robust abstractions, workflows, and integrations. | **Production** | [swarms](https://github.com/kyegomez/swarms) | [Docs](https://docs.swarms.world/en/latest/swarms/install/install/) |
+| **Python API Client** | Official Python SDK for interacting with Swarms Cloud and remote agent infrastructure. Simplifies API calls, authentication, and integration into Python applications. | **Production** | [swarms-sdk](https://github.com/The-Swarm-Corporation/swarms-sdk) | [Docs](https://docs.swarms.world/en/latest/swarms_cloud/python_client/) |
+| **Swarms Tools** | A comprehensive library of prebuilt tools for various domains, including finance, social media, data processing, and more. Accelerates agent development by providing ready-to-use capabilities and integrations. | **Production** | [swarms-tools](https://github.com/The-Swarm-Corporation/swarms-tools) | *Coming Soon* |
+| **Swarms Memory** | A robust library of memory structures and data loaders for Retrieval-Augmented Generation (RAG) processing. Provides advanced memory management, vector stores, and integration with agentic workflows. | **Production** | [swarms-memory](https://github.com/The-Swarm-Corporation/swarms-memory) | *Coming Soon* |
---
-## **Contribute to the Ecosystem**
-
-### **How You Can Make an Impact**
+### 🦀 **Rust**
-| **Contribution Area** | **Skills Needed** | **Impact Level** | **Getting Started** |
-|-----------------------|-------------------|------------------|---------------------|
-| **Core Framework Development** | Python, Rust, Systems Design | **High Impact** | [Contributing Guide](https://docs.swarms.world/en/latest/contributors/main/) |
-| **Client Library Development** | Various Languages (Go, Java, TS, etc.) | **High Impact** | [Client Development](https://github.com/The-Swarm-Corporation) |
-| **Documentation & Tutorials** | Technical Writing, Examples | **High Impact** | [Docs Contributing](https://docs.swarms.world/en/latest/contributors/docs/) |
-| **Testing & Quality Assurance** | Testing Frameworks, QA | **Medium Impact** | [Testing Guide](https://docs.swarms.world/en/latest/swarms/framework/test/) |
-| **UI/UX & Design** | Design, Frontend Development | **Medium Impact** | [Design Contributions](https://github.com/The-Swarm-Corporation/swarms/issues) |
-| **Bug Reports & Feature Requests** | User Experience, Testing | **Easy Start** | [Report Issues](https://github.com/The-Swarm-Corporation/swarms/issues) |
+| **Product** | **Description** | **Status** | **Repository** | **Documentation** |
+|----------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------|-------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------|
+| **Swarms Rust Framework** | High-performance, memory-safe multi-agent orchestration framework written in Rust. Designed for demanding production environments and seamless integration with Rust-based systems. | **Production** | [swarms-rs](https://github.com/The-Swarm-Corporation/swarms-rs) | [Docs](https://docs.swarms.world/en/latest/swarms_rs/overview/) |
+| **Rust Client** | Official Rust client library for connecting to Swarms Cloud and orchestrating agents from Rust applications. Provides idiomatic Rust APIs for agent management and communication. | **Q2 2025** | *In Development* | *Coming Soon* |
---
-## **We're Hiring Top Talent**
-
-### **Join the Team Building the Future Of The World Economy**
-
-**Ready to work on cutting-edge agent technology that's shaping the future?** We're actively recruiting exceptional engineers, researchers, and technical leaders to join our mission of building the operating system for the agent economy.
-
-| **Why Join Swarms?** | **What We Offer** |
-|-----------------------|-------------------|
-| **Cutting-Edge Technology** | Work on the most powerful multi-agent systems, distributed computing, and enterprise-scale infrastructure |
-| **Global Impact** | Your code will power agent applications used by Fortune 500 companies and millions of developers |
-| **World-Class Team** | Collaborate with top engineers, researchers, and industry experts from Google, OpenAI, and more |
-| **Fast Growth** | Join a rapidly scaling company with massive market opportunity and venture backing |
+### 🌐 **API Clients (Multi-Language)**
-### **Open Positions**
-
-| **Position** | **Role Description** |
-|-------------------------------|----------------------------------------------------------|
-| **Senior Rust Engineers** | Building high-performance agent infrastructure |
-| **Python Framework Engineers**| Expanding our core multi-agent capabilities |
-| **DevOps/Platform Engineers** | Scaling cloud infrastructure for millions of agents |
-| **Technical Writers** | Creating world-class developer documentation |
-| **Solutions Engineers** | Helping enterprises adopt multi-agent AI |
-
-**Ready to Build the Future?** **[Apply Now at swarms.ai/hiring](https://swarms.ai/hiring)**
-
----
+| **Language/Platform** | **Description** | **Status** | **Repository** | **Documentation** |
+|----------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------|-------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------|
+| **TypeScript/Node.js** | Official TypeScript/Node.js SDK for Swarms Cloud. Enables seamless integration of agentic workflows into JavaScript and TypeScript applications, both server-side and in the browser. | **Production** | [swarms-ts](https://github.com/The-Swarm-Corporation/swarms-ts) | *Coming Soon* |
+| **Go** | Go client library for Swarms Cloud, providing Go developers with native APIs to manage, orchestrate, and interact with agents in distributed systems and microservices. | **Production** | [swarms-client-go](https://github.com/The-Swarm-Corporation/swarms-client-go) | *Coming Soon* |
+| **Java** | Java SDK for Swarms Cloud, allowing enterprise Java applications to leverage multi-agent orchestration and integrate agentic capabilities into JVM-based systems. | **Production** | [swarms-java](https://github.com/The-Swarm-Corporation/swarms-java) | *Coming Soon* |
+| **Kotlin** | Native Kotlin client for Swarms Cloud, designed for modern JVM and Android applications seeking to embed agentic intelligence and orchestration. | **Q2 2025** | *In Development* | *Coming Soon* |
+| **Ruby** | Ruby SDK for Swarms Cloud, enabling Ruby and Rails developers to easily connect, manage, and orchestrate agents within their applications. | **Q2 2025** | *In Development* | *Coming Soon* |
+| **C#/.NET** | Official C#/.NET client library for Swarms Cloud, providing .NET developers with tools to integrate agentic workflows into desktop, web, and cloud applications. | **Q3 2025** | *In Development* | *Coming Soon* |
---
-## **Get Started Today**
-
-### **Quick Start Guide**
-
-| **Step** | **Action** | **Time Required** |
-|----------|------------|-------------------|
-| **1** | [Install Swarms Python Framework](https://docs.swarms.world/en/latest/swarms/install/install/) | 5 minutes |
-| **2** | [Run Your First Agent](https://docs.swarms.world/en/latest/swarms/examples/basic_agent/) | 10 minutes |
-| **3** | [Try Multi-Agent Workflows](https://docs.swarms.world/en/latest/swarms/examples/sequential_example/) | 15 minutes |
-| **4** | [Join Our Discord Community](https://discord.gg/EamjgSaEQf) | 2 minutes |
-| **5** | [Explore Enterprise Features](https://docs.swarms.world/en/latest/swarms_cloud/swarms_api/) | 20 minutes |
-
----
-
-## **Enterprise Support & Partnerships**
-
-### **Ready to Scale with Swarms?**
+## **Why Choose the Swarms Ecosystem?**
-| **Contact Type** | **Best For** | **Response Time** | **Contact Information** |
-|------------------|--------------|-------------------|-------------------------|
-| **Technical Support** | Development questions, troubleshooting | < 24 hours | [Book Support Call](https://cal.com/swarms/swarms-technical-support) |
-| **Enterprise Sales** | Custom deployments, enterprise licensing | < 4 hours | [kye@swarms.world](mailto:kye@swarms.world) |
-| **Partnerships** | Integration partnerships, technology alliances | < 48 hours | [kye@swarms.world](mailto:kye@swarms.world) |
-| **Investor Relations** | Investment opportunities, funding updates | By appointment | [kye@swarms.world](mailto:kye@swarms.world) |
+| **Feature** | **Description** |
+|----------------------------|------------------------------------------------------------------------------------------------------|
+| **Production Ready** | Battle-tested in enterprise environments with 99.9%+ uptime |
+| **Scalable Infrastructure** | Handle millions of agent interactions with automatic scaling |
+| **Security First** | End-to-end encryption, API key management, and enterprise compliance |
+| **Observability** | Comprehensive logging, monitoring, and debugging capabilities |
+| **Multiple Language Support** | Native clients for every major programming language |
+| **Unified API** | Consistent interface across all platforms and languages |
+| **Rich Documentation** | Comprehensive guides, tutorials, and API references |
+| **Active Community** | 24/7 support through Discord, GitHub, and direct channels |
+| **High Throughput** | Process thousands of concurrent agent requests |
+| **Low Latency** | Optimized for real-time applications and user experiences |
+| **Fault Tolerance** | Automatic retries, circuit breakers, and graceful degradation |
+| **Multi-Cloud** | Deploy on AWS, GCP, Azure, or on-premises infrastructure |
---
-**Ready to build the future of AI? Start with Swarms today and join thousands of developers creating the next generation of intelligent applications.**
-
--------------------------------------------------
-# File: swarms\examples\agent_output_types.md
+# File: swarms/examples/agent_output_types.md
# Agent Output Types Examples with Vision Capabilities
@@ -15736,7 +18189,7 @@ The vision-enabled agents support various image formats including:
--------------------------------------------------
-# File: swarms\examples\agent_structured_outputs.md
+# File: swarms/examples/agent_structured_outputs.md
# Agent Structured Outputs
@@ -15941,7 +18394,7 @@ This example shows how to structure complex nested objects, arrays, and various
--------------------------------------------------
-# File: swarms\examples\agent_with_tools.md
+# File: swarms/examples/agent_with_tools.md
# Basic Agent Example
@@ -16593,7 +19046,7 @@ agent.run("Get the market sentiment for bitcoin")
--------------------------------------------------
-# File: swarms\examples\agents_as_tools.md
+# File: swarms/examples/agents_as_tools.md
# Agents as Tools Tutorial
@@ -17185,7 +19638,7 @@ print(out)
--------------------------------------------------
-# File: swarms\examples\aggregate.md
+# File: swarms/examples/aggregate.md
# Aggregate Multi-Agent Responses
@@ -17263,7 +19716,7 @@ print(result)
--------------------------------------------------
-# File: swarms\examples\azure.md
+# File: swarms/examples/azure.md
# Azure OpenAI Integration
@@ -17317,11 +19770,175 @@ for model in model_list:
```
Common Azure model names include:
-- `azure/gpt-4`
+
+- `azure/gpt-4.1`
+
- `azure/gpt-4o`
+
- `azure/gpt-4o-mini`
-- `azure/gpt-35-turbo`
-- `azure/gpt-35-turbo-16k`
+
+
+
+## Models Supported
+
+```txt
+azure_ai/grok-3
+azure_ai/global/grok-3
+azure_ai/global/grok-3-mini
+azure_ai/grok-3-mini
+azure_ai/deepseek-r1
+azure_ai/deepseek-v3
+azure_ai/deepseek-v3-0324
+azure_ai/jamba-instruct
+azure_ai/jais-30b-chat
+azure_ai/mistral-nemo
+azure_ai/mistral-medium-2505
+azure_ai/mistral-large
+azure_ai/mistral-small
+azure_ai/mistral-small-2503
+azure_ai/mistral-large-2407
+azure_ai/mistral-large-latest
+azure_ai/ministral-3b
+azure_ai/Llama-3.2-11B-Vision-Instruct
+azure_ai/Llama-3.3-70B-Instruct
+azure_ai/Llama-4-Scout-17B-16E-Instruct
+azure_ai/Llama-4-Maverick-17B-128E-Instruct-FP8
+azure_ai/Llama-3.2-90B-Vision-Instruct
+azure_ai/Meta-Llama-3-70B-Instruct
+azure_ai/Meta-Llama-3.1-8B-Instruct
+azure_ai/Meta-Llama-3.1-70B-Instruct
+azure_ai/Meta-Llama-3.1-405B-Instruct
+azure_ai/Phi-4-mini-instruct
+azure_ai/Phi-4-multimodal-instruct
+azure_ai/Phi-4
+azure_ai/Phi-3.5-mini-instruct
+azure_ai/Phi-3.5-vision-instruct
+azure_ai/Phi-3.5-MoE-instruct
+azure_ai/Phi-3-mini-4k-instruct
+azure_ai/Phi-3-mini-128k-instruct
+azure_ai/Phi-3-small-8k-instruct
+azure_ai/Phi-3-small-128k-instruct
+azure_ai/Phi-3-medium-4k-instruct
+azure_ai/Phi-3-medium-128k-instruct
+azure_ai/cohere-rerank-v3.5
+azure_ai/cohere-rerank-v3-multilingual
+azure_ai/cohere-rerank-v3-english
+azure_ai/Cohere-embed-v3-english
+azure_ai/Cohere-embed-v3-multilingual
+azure_ai/embed-v-4-0
+azure/gpt-4o-mini-tts
+azure/computer-use-preview
+azure/gpt-4o-audio-preview-2024-12-17
+azure/gpt-4o-mini-audio-preview-2024-12-17
+azure/gpt-4.1
+azure/gpt-4.1-2025-04-14
+azure/gpt-4.1-mini
+azure/gpt-4.1-mini-2025-04-14
+azure/gpt-4.1-nano
+azure/gpt-4.1-nano-2025-04-14
+azure/o3-pro
+azure/o3-pro-2025-06-10
+azure/o3
+azure/o3-2025-04-16
+azure/o3-deep-research
+azure/o4-mini
+azure/gpt-4o-mini-realtime-preview-2024-12-17
+azure/eu/gpt-4o-mini-realtime-preview-2024-12-17
+azure/us/gpt-4o-mini-realtime-preview-2024-12-17
+azure/gpt-4o-realtime-preview-2024-12-17
+azure/us/gpt-4o-realtime-preview-2024-12-17
+azure/eu/gpt-4o-realtime-preview-2024-12-17
+azure/gpt-4o-realtime-preview-2024-10-01
+azure/us/gpt-4o-realtime-preview-2024-10-01
+azure/eu/gpt-4o-realtime-preview-2024-10-01
+azure/o4-mini-2025-04-16
+azure/o3-mini-2025-01-31
+azure/us/o3-mini-2025-01-31
+azure/eu/o3-mini-2025-01-31
+azure/tts-1
+azure/tts-1-hd
+azure/whisper-1
+azure/gpt-4o-transcribe
+azure/gpt-4o-mini-transcribe
+azure/o3-mini
+azure/o1-mini
+azure/o1-mini-2024-09-12
+azure/us/o1-mini-2024-09-12
+azure/eu/o1-mini-2024-09-12
+azure/o1
+azure/o1-2024-12-17
+azure/us/o1-2024-12-17
+azure/eu/o1-2024-12-17
+azure/codex-mini
+azure/o1-preview
+azure/o1-preview-2024-09-12
+azure/us/o1-preview-2024-09-12
+azure/eu/o1-preview-2024-09-12
+azure/gpt-4.5-preview
+azure/gpt-4o
+azure/global/gpt-4o-2024-11-20
+azure/gpt-4o-2024-08-06
+azure/global/gpt-4o-2024-08-06
+azure/gpt-4o-2024-11-20
+azure/us/gpt-4o-2024-11-20
+azure/eu/gpt-4o-2024-11-20
+azure/gpt-4o-2024-05-13
+azure/global-standard/gpt-4o-2024-08-06
+azure/us/gpt-4o-2024-08-06
+azure/eu/gpt-4o-2024-08-06
+azure/global-standard/gpt-4o-2024-11-20
+azure/global-standard/gpt-4o-mini
+azure/gpt-4o-mini
+azure/gpt-4o-mini-2024-07-18
+azure/us/gpt-4o-mini-2024-07-18
+azure/eu/gpt-4o-mini-2024-07-18
+azure/gpt-4-turbo-2024-04-09
+azure/gpt-4-0125-preview
+azure/gpt-4-1106-preview
+azure/gpt-4-0613
+azure/gpt-4-32k-0613
+azure/gpt-4-32k
+azure/gpt-4
+azure/gpt-4-turbo
+azure/gpt-4-turbo-vision-preview
+azure/gpt-35-turbo-16k-0613
+azure/gpt-35-turbo-1106
+azure/gpt-35-turbo-0613
+azure/gpt-35-turbo-0301
+azure/gpt-35-turbo-0125
+azure/gpt-3.5-turbo-0125
+azure/gpt-35-turbo-16k
+azure/gpt-35-turbo
+azure/gpt-3.5-turbo
+azure/mistral-large-latest
+azure/mistral-large-2402
+azure/command-r-plus
+azure/ada
+azure/text-embedding-ada-002
+azure/text-embedding-3-large
+azure/text-embedding-3-small
+azure/gpt-image-1
+azure/low/1024-x-1024/gpt-image-1
+azure/medium/1024-x-1024/gpt-image-1
+azure/high/1024-x-1024/gpt-image-1
+azure/low/1024-x-1536/gpt-image-1
+azure/medium/1024-x-1536/gpt-image-1
+azure/high/1024-x-1536/gpt-image-1
+azure/low/1536-x-1024/gpt-image-1
+azure/medium/1536-x-1024/gpt-image-1
+azure/high/1536-x-1024/gpt-image-1
+azure/standard/1024-x-1024/dall-e-3
+azure/hd/1024-x-1024/dall-e-3
+azure/standard/1024-x-1792/dall-e-3
+azure/standard/1792-x-1024/dall-e-3
+azure/hd/1024-x-1792/dall-e-3
+azure/hd/1792-x-1024/dall-e-3
+azure/standard/1024-x-1024/dall-e-2
+azure/gpt-3.5-turbo-instruct-0914
+azure/gpt-35-turbo-instruct
+azure/gpt-35-turbo-instruct-0914
+```
+
## Basic Usage
@@ -17428,7 +20045,7 @@ print(response)
--------------------------------------------------
-# File: swarms\examples\basic_agent.md
+# File: swarms/examples/basic_agent.md
# Basic Agent Example
@@ -17540,7 +20157,7 @@ You can modify the system prompt and agent parameters to create specialized agen
--------------------------------------------------
-# File: swarms\examples\claude.md
+# File: swarms/examples/claude.md
# Agent with Anthropic/Claude
@@ -17570,7 +20187,7 @@ agent.run("What are the components of a startup's stock incentive equity plan?")
--------------------------------------------------
-# File: swarms\examples\cohere.md
+# File: swarms/examples/cohere.md
# Agent with Cohere
@@ -17600,7 +20217,7 @@ agent.run("What are the components of a startup's stock incentive equity plan?")
--------------------------------------------------
-# File: swarms\examples\concurrent_workflow.md
+# File: swarms/examples/concurrent_workflow.md
# ConcurrentWorkflow Examples
@@ -18009,7 +20626,7 @@ This guide demonstrates how to effectively use the ConcurrentWorkflow architectu
--------------------------------------------------
-# File: swarms\examples\deepseek.md
+# File: swarms/examples/deepseek.md
# Agent with DeepSeek
@@ -18065,7 +20682,7 @@ agent.run("What are the components of a startup's stock incentive equity plan?")
--------------------------------------------------
-# File: swarms\examples\groq.md
+# File: swarms/examples/groq.md
# Agent with Groq
@@ -18078,8 +20695,6 @@ agent.run("What are the components of a startup's stock incentive equity plan?")
```python
import os
-from swarm_models import OpenAIChat
-
from swarms import Agent
company = "NVDA"
@@ -18111,7 +20726,7 @@ managing_director = Agent(
--------------------------------------------------
-# File: swarms\examples\groupchat_example.md
+# File: swarms/examples/groupchat_example.md
# GroupChat Example
@@ -18325,7 +20940,7 @@ from swarms import Agent, GroupChat
--------------------------------------------------
-# File: swarms\examples\hhcs_examples.md
+# File: swarms/examples/hhcs_examples.md
# Hybrid Hierarchical-Cluster Swarm (HHCS) Example
@@ -18458,7 +21073,7 @@ if __name__ == "__main__":
--------------------------------------------------
-# File: swarms\examples\hierarchical_swarm_example.md
+# File: swarms/examples/hierarchical_swarm_example.md
# Hierarchical Swarm Examples
@@ -18689,7 +21304,7 @@ For more detailed information about the `HierarchicalSwarm` API and advanced usa
--------------------------------------------------
-# File: swarms\examples\igc_example.md
+# File: swarms/examples/igc_example.md
## Interactive Groupchat Examples
@@ -18830,7 +21445,7 @@ Join our community of agent engineers and researchers for technical support, cut
--------------------------------------------------
-# File: swarms\examples\interactive_groupchat_example.md
+# File: swarms/examples/interactive_groupchat_example.md
# Interactive GroupChat Example
@@ -18971,7 +21586,7 @@ if __name__ == "__main__":
--------------------------------------------------
-# File: swarms\examples\llama4.md
+# File: swarms/examples/llama4.md
# Llama4 Model Integration
@@ -19149,7 +21764,7 @@ print(
--------------------------------------------------
-# File: swarms\examples\lumo.md
+# File: swarms/examples/lumo.md
# Lumo Example
Introducing Lumo-70B-Instruct - the largest and most advanced AI model ever created for the Solana ecosystem. Built on Meta's groundbreaking LLaMa 3.3 70B Instruct foundation, this revolutionary model represents a quantum leap in blockchain-specific artificial intelligence. With an unprecedented 70 billion parameters and trained on the most comprehensive Solana documentation dataset ever assembled, Lumo-70B-Instruct sets a new standard for developer assistance in the blockchain space.
@@ -19217,7 +21832,7 @@ Agent(
--------------------------------------------------
-# File: swarms\examples\mixture_of_agents.md
+# File: swarms/examples/mixture_of_agents.md
# MixtureOfAgents Examples
@@ -19483,7 +22098,7 @@ This comprehensive guide demonstrates how to effectively use the MixtureOfAgents
--------------------------------------------------
-# File: swarms\examples\moa_example.md
+# File: swarms/examples/moa_example.md
# Mixture of Agents Example
@@ -19621,7 +22236,7 @@ If you're facing issues or want to learn more, check out the following resources
--------------------------------------------------
-# File: swarms\examples\model_providers.md
+# File: swarms/examples/model_providers.md
# Model Providers Overview
@@ -19804,7 +22419,7 @@ agent = Agent(
--------------------------------------------------
-# File: swarms\examples\multi_agent_router_minimal.md
+# File: swarms/examples/multi_agent_router_minimal.md
# MultiAgentRouter Minimal Example
@@ -19842,7 +22457,7 @@ View the source on [GitHub](https://github.com/kyegomez/swarms/blob/master/examp
--------------------------------------------------
-# File: swarms\examples\multiple_images.md
+# File: swarms/examples/multiple_images.md
# Processing Multiple Images
@@ -19925,7 +22540,7 @@ If you're facing issues or want to learn more, check out the following resources
--------------------------------------------------
-# File: swarms\examples\ollama.md
+# File: swarms/examples/ollama.md
# Agent with Ollama
@@ -19954,7 +22569,7 @@ agent.run("What are the components of a startup's stock incentive equity plan?")
--------------------------------------------------
-# File: swarms\examples\openai_example.md
+# File: swarms/examples/openai_example.md
# Agent with GPT-4o-Mini
@@ -19975,7 +22590,7 @@ Agent(
--------------------------------------------------
-# File: swarms\examples\openrouter.md
+# File: swarms/examples/openrouter.md
# Agent with OpenRouter
@@ -20007,7 +22622,7 @@ agent.run("What are the components of a startup's stock incentive equity plan?")
--------------------------------------------------
-# File: swarms\examples\quant_crypto_agent.md
+# File: swarms/examples/quant_crypto_agent.md
# Quant Crypto Agent
@@ -20141,7 +22756,7 @@ agent.run(
--------------------------------------------------
-# File: swarms\examples\sequential_example.md
+# File: swarms/examples/sequential_example.md
# Sequential Workflow Example
@@ -20315,7 +22930,7 @@ from swarms import Agent, SequentialWorkflow
--------------------------------------------------
-# File: swarms\examples\swarm_router.md
+# File: swarms/examples/swarm_router.md
# SwarmRouter Examples
@@ -20560,7 +23175,7 @@ This comprehensive guide demonstrates how to effectively use the SwarmRouter in
--------------------------------------------------
-# File: swarms\examples\swarms_api_finance.md
+# File: swarms/examples/swarms_api_finance.md
# Finance Swarm Example
@@ -20693,7 +23308,7 @@ python financial_swarm.py
--------------------------------------------------
-# File: swarms\examples\swarms_api_medical.md
+# File: swarms/examples/swarms_api_medical.md
# Medical Swarm Example
@@ -20826,7 +23441,7 @@ python medical_swarm.py
--------------------------------------------------
-# File: swarms\examples\swarms_api_ml_model.md
+# File: swarms/examples/swarms_api_ml_model.md
# ML Model Code Generation Swarm Example
@@ -20969,7 +23584,7 @@ if __name__ == "__main__":
--------------------------------------------------
-# File: swarms\examples\swarms_dao.md
+# File: swarms/examples/swarms_dao.md
# Swarms DAO Example
@@ -21211,7 +23826,7 @@ print("Collaborative Strategy Output:\n", output)
--------------------------------------------------
-# File: swarms\examples\swarms_of_browser_agents.md
+# File: swarms/examples/swarms_of_browser_agents.md
# Swarms x Browser Use
@@ -21281,7 +23896,7 @@ swarm.run(
--------------------------------------------------
-# File: swarms\examples\swarms_tools_htx.md
+# File: swarms/examples/swarms_tools_htx.md
# Swarms Tools Example with HTX + CoinGecko
@@ -21323,7 +23938,7 @@ agent.run(
--------------------------------------------------
-# File: swarms\examples\swarms_tools_htx_gecko.md
+# File: swarms/examples/swarms_tools_htx_gecko.md
# Swarms Tools Example with HTX + CoinGecko
@@ -21371,7 +23986,7 @@ agent.run("Analyze the $swarms token on htx")
--------------------------------------------------
-# File: swarms\examples\templates_index.md
+# File: swarms/examples/templates_index.md
# The Swarms Index
@@ -21450,7 +24065,7 @@ The Swarms Index is a comprehensive catalog of repositories under The Swarm Corp
--------------------------------------------------
-# File: swarms\examples\unique_swarms.md
+# File: swarms/examples/unique_swarms.md
In this section, we present a diverse collection of unique swarms, each with its own distinct characteristics and applications. These examples are designed to illustrate the versatility and potential of swarm intelligence in various domains. By exploring these examples, you can gain a deeper understanding of how swarms can be leveraged to solve complex problems and improve decision-making processes.
@@ -22089,7 +24704,7 @@ if __name__ == "__main__":
--------------------------------------------------
-# File: swarms\examples\vision_processing.md
+# File: swarms/examples/vision_processing.md
# Vision Processing Examples
@@ -22245,7 +24860,7 @@ batch_results = process_image_batch(image_folder, visual_analyst)
--------------------------------------------------
-# File: swarms\examples\vision_tools.md
+# File: swarms/examples/vision_tools.md
# Agents with Vision and Tool Usage
@@ -22389,7 +25004,7 @@ If you're facing issues or want to learn more, check out the following resources
--------------------------------------------------
-# File: swarms\examples\vllm.md
+# File: swarms/examples/vllm.md
# VLLM Swarm Agents
@@ -22823,7 +25438,7 @@ swarm.run("Analyze the best etfs for gold and other similiar commodities in vola
--------------------------------------------------
-# File: swarms\examples\vllm_integration.md
+# File: swarms/examples/vllm_integration.md
@@ -23022,7 +25637,7 @@ result = workflow.run("Analyze the impact of renewable energy")
--------------------------------------------------
-# File: swarms\examples\xai.md
+# File: swarms/examples/xai.md
# Agent with XAI
@@ -23054,7 +25669,7 @@ agent.run("What are the components of a startup's stock incentive equity plan?")
--------------------------------------------------
-# File: swarms\examples\yahoo_finance.md
+# File: swarms/examples/yahoo_finance.md
# Swarms Tools Example with Yahoo Finance
@@ -23101,7 +25716,7 @@ agent.run("Analyze the latest metrics for nvidia")
--------------------------------------------------
-# File: swarms\features.md
+# File: swarms/features.md
## ✨ Enterprise Features
@@ -23149,7 +25764,7 @@ Our team is committed to ensuring Swarms meets your enterprise multi-agent infra
--------------------------------------------------
-# File: swarms\framework\agents_explained.md
+# File: swarms/framework/agents_explained.md
# An Analysis of Agents
@@ -23236,7 +25851,7 @@ The Swarms framework's agents are powerful units that combine LLMs, tools, and l
--------------------------------------------------
-# File: swarms\framework\code_cleanliness.md
+# File: swarms/framework/code_cleanliness.md
# Code Cleanliness in Python: A Comprehensive Guide
@@ -23648,7 +26263,7 @@ By following the principles and best practices outlined in this article, you'll
--------------------------------------------------
-# File: swarms\framework\concept.md
+# File: swarms/framework/concept.md
To create a comprehensive overview of the Swarms framework, we can break it down into key concepts such as models, agents, tools, Retrieval-Augmented Generation (RAG) systems, and swarm systems. Below are conceptual explanations of these components along with mermaid diagrams to illustrate their interactions.
@@ -23720,7 +26335,7 @@ The Swarms framework leverages models, agents, tools, RAG systems, and swarm sys
--------------------------------------------------
-# File: swarms\framework\index.md
+# File: swarms/framework/index.md
## Swarms Framework Conceptual Breakdown
@@ -23842,7 +26457,7 @@ This hierarchical design ensures scalability, flexibility, and robustness, makin
--------------------------------------------------
-# File: swarms\framework\reference.md
+# File: swarms/framework/reference.md
# API Reference Documentation
@@ -25267,7 +27882,7 @@ print(agent)
--------------------------------------------------
-# File: swarms\framework\test.md
+# File: swarms/framework/test.md
# How to Run Tests Using Pytest: A Comprehensive Guide
@@ -25516,7 +28131,7 @@ Happy testing!
--------------------------------------------------
-# File: swarms\framework\vision.md
+# File: swarms/framework/vision.md
### Swarms Vision
@@ -25676,7 +28291,7 @@ Swarms promotes an open and extensible ecosystem, encouraging community-driven i
--------------------------------------------------
-# File: swarms\glossary.md
+# File: swarms/glossary.md
# Glossary of Terms
@@ -25729,7 +28344,7 @@ By understanding these terms, you can effectively build and orchestrate agents a
--------------------------------------------------
-# File: swarms\install\docker_setup.md
+# File: swarms/install/docker_setup.md
# Docker Setup Guide for Contributors to Swarms
@@ -25921,7 +28536,7 @@ Remember to secure sensitive data, use tagged releases for your images, and foll
--------------------------------------------------
-# File: swarms\install\env.md
+# File: swarms/install/env.md
# Environment Variables
@@ -26129,7 +28744,7 @@ openai_key = os.getenv("OPENAI_API_KEY")
--------------------------------------------------
-# File: swarms\install\install.md
+# File: swarms/install/install.md
# Swarms Installation Guide
@@ -26159,9 +28774,9 @@ Before you begin, ensure you have the following installed:
=== "pip (Recommended)"
- #### Headless Installation
+ #### Simple Installation
- The headless installation of `swarms` is designed for environments where graphical user interfaces (GUI) are not needed, making it more lightweight and suitable for server-side applications.
+ Simplest manner of installing swarms leverages using PIP. For faster installs and build times, we recommend using UV
```bash
pip install swarms
@@ -26198,6 +28813,49 @@ Before you begin, ensure you have the following installed:
uv pip install -e .[desktop]
```
+=== "Poetry Installation"
+
+ Poetry is a modern dependency management and packaging tool for Python. It provides a more robust way to manage project dependencies and virtual environments.
+
+ === "Basic Installation"
+
+ ```bash
+ # Install Poetry first
+ curl -sSL https://install.python-poetry.org | python3 -
+
+ # Install swarms using Poetry
+ poetry add swarms
+ ```
+
+ === "Development Installation"
+
+ ```bash
+ # Clone the repository
+ git clone https://github.com/kyegomez/swarms.git
+ cd swarms
+
+ # Install in editable mode
+ poetry install
+ ```
+
+ For desktop installation with extras:
+
+ ```bash
+ poetry install --extras "desktop"
+ ```
+
+ === "Using Poetry with existing projects"
+
+ If you have an existing project with a `pyproject.toml` file:
+
+ ```bash
+ # Add swarms to your project dependencies
+ poetry add swarms
+
+ # Or add with specific extras
+ poetry add "swarms[desktop]"
+ ```
+
=== "Development Installation"
=== "Using virtualenv"
@@ -26465,7 +29123,7 @@ Before you begin, ensure you have the following installed:
--------------------------------------------------
-# File: swarms\install\quickstart.md
+# File: swarms/install/quickstart.md
## Quickstart
@@ -26973,7 +29631,7 @@ These are the key swarm architectures available in the **Swarms Framework**. Eac
--------------------------------------------------
-# File: swarms\install\workspace_manager.md
+# File: swarms/install/workspace_manager.md
# Swarms Framework Environment Configuration
@@ -27164,7 +29822,7 @@ Common issues and solutions:
--------------------------------------------------
-# File: swarms\memory\diy_memory.md
+# File: swarms/memory/diy_memory.md
# Integrating the Agent Class with Memory Systems/RAG in the Swarms Memory Framework
@@ -27289,7 +29947,7 @@ Happy coding!
--------------------------------------------------
-# File: swarms\papers.md
+# File: swarms/papers.md
# awesome-multi-agent-papers
@@ -27297,7 +29955,7 @@ An awesome list of multi-agent papers that show you various swarm architectures
--------------------------------------------------
-# File: swarms\products.md
+# File: swarms/products.md
# Swarms Products
@@ -27463,7 +30121,7 @@ Experience the future of multi-agent collaboration with Swarms. Start building y
--------------------------------------------------
-# File: swarms\prompts\essence.md
+# File: swarms/prompts/essence.md
# **The Essence of Enterprise-Grade Prompting**
@@ -27638,7 +30296,7 @@ Ready to take the next step? Let’s explore how to design adaptive prompting fr
--------------------------------------------------
-# File: swarms\prompts\main.md
+# File: swarms/prompts/main.md
# Managing Prompts in Production
@@ -27957,7 +30615,916 @@ By using this architecture, you'll be able to scale your system effortlessly whi
--------------------------------------------------
-# File: swarms\structs\abstractswarm.md
+# File: swarms/structs/BoardOfDirectors.md
+
+# Board of Directors - Multi-Agent Architecture
+
+The Board of Directors is a sophisticated multi-agent architecture that implements collective decision-making through democratic processes, voting mechanisms, and role-based leadership. This architecture provides an alternative to single-director patterns by enabling collaborative intelligence through structured governance.
+
+## Overview
+
+The Board of Directors architecture follows a democratic workflow pattern:
+
+1. **Task Reception**: User provides a task to the swarm
+2. **Board Meeting**: Board of Directors convenes to discuss and create a plan
+3. **Voting & Consensus**: Board members vote and reach consensus on task distribution
+4. **Order Distribution**: Board distributes orders to specialized worker agents
+5. **Execution**: Individual agents execute their assigned tasks
+6. **Feedback Loop**: Board evaluates results and issues new orders if needed (up to `max_loops`)
+7. **Context Preservation**: All conversation history and context is maintained throughout the process
+
+## Architecture Components
+
+### Core Components
+
+| Component | Description | Purpose |
+|-----------|-------------|---------|
+| **BoardOfDirectorsSwarm** | Main orchestration class | Manages the entire board workflow and agent coordination |
+| **Board Member Roles** | Role definitions and hierarchy | Defines responsibilities and voting weights for each board member |
+| **Decision Making Process** | Voting and consensus mechanisms | Implements democratic decision-making with weighted voting |
+| **Workflow Management** | Process orchestration | Manages the complete lifecycle from task reception to final delivery |
+
+### Board Member Interaction Flow
+
+```mermaid
+sequenceDiagram
+ participant User
+ participant Chairman
+ participant ViceChair
+ participant Secretary
+ participant Treasurer
+ participant ExecDir
+ participant Agents
+
+ User->>Chairman: Submit Task
+ Chairman->>ViceChair: Notify Board Meeting
+ Chairman->>Secretary: Request Meeting Setup
+ Chairman->>Treasurer: Resource Assessment
+ Chairman->>ExecDir: Strategic Planning
+
+ Note over Chairman,ExecDir: Board Discussion Phase
+
+ Chairman->>ViceChair: Lead Discussion
+ ViceChair->>Secretary: Document Decisions
+ Secretary->>Treasurer: Budget Considerations
+ Treasurer->>ExecDir: Resource Allocation
+ ExecDir->>Chairman: Strategic Recommendations
+
+ Note over Chairman,ExecDir: Voting & Consensus
+
+ Chairman->>ViceChair: Call for Vote
+ ViceChair->>Secretary: Record Votes
+ Secretary->>Treasurer: Financial Approval
+ Treasurer->>ExecDir: Resource Approval
+ ExecDir->>Chairman: Final Decision
+
+ Note over Chairman,Agents: Execution Phase
+
+ Chairman->>Agents: Distribute Orders
+ Agents->>Chairman: Execute Tasks
+ Agents->>ViceChair: Progress Reports
+ Agents->>Secretary: Documentation
+ Agents->>Treasurer: Resource Usage
+ Agents->>ExecDir: Strategic Updates
+
+ Note over Chairman,ExecDir: Review & Feedback
+
+ Chairman->>User: Deliver Results
+```
+
+## Board Member Roles
+
+The Board of Directors supports various roles with different responsibilities and voting weights:
+
+| Role | Description | Voting Weight | Responsibilities |
+|------|-------------|---------------|------------------|
+| `CHAIRMAN` | Primary leader responsible for board meetings and final decisions | 1.5 | Leading meetings, facilitating consensus, making final decisions |
+| `VICE_CHAIRMAN` | Secondary leader who supports the chairman | 1.2 | Supporting chairman, coordinating operations |
+| `SECRETARY` | Responsible for documentation and meeting minutes | 1.0 | Documenting meetings, maintaining records |
+| `TREASURER` | Manages financial aspects and resource allocation | 1.0 | Financial oversight, resource management |
+| `EXECUTIVE_DIRECTOR` | Executive-level board member with operational authority | 1.5 | Strategic planning, operational oversight |
+| `MEMBER` | General board member with specific expertise | 1.0 | Contributing expertise, participating in decisions |
+
+### Role Hierarchy and Authority
+
+```python
+# Example: Role hierarchy implementation
+class BoardRoleHierarchy:
+ def __init__(self):
+ self.roles = {
+ "CHAIRMAN": {
+ "voting_weight": 1.5,
+ "authority_level": "FINAL",
+ "supervises": ["VICE_CHAIRMAN", "EXECUTIVE_DIRECTOR", "SECRETARY", "TREASURER", "MEMBER"],
+ "responsibilities": ["leadership", "final_decision", "consensus_facilitation"],
+ "override_capability": True
+ },
+ "VICE_CHAIRMAN": {
+ "voting_weight": 1.2,
+ "authority_level": "SENIOR",
+ "supervises": ["MEMBER"],
+ "responsibilities": ["operational_support", "coordination", "implementation"],
+ "backup_for": "CHAIRMAN"
+ },
+ "EXECUTIVE_DIRECTOR": {
+ "voting_weight": 1.5,
+ "authority_level": "SENIOR",
+ "supervises": ["MEMBER"],
+ "responsibilities": ["strategic_planning", "execution_oversight", "performance_management"],
+ "strategic_authority": True
+ },
+ "SECRETARY": {
+ "voting_weight": 1.0,
+ "authority_level": "STANDARD",
+ "supervises": [],
+ "responsibilities": ["documentation", "record_keeping", "communication"],
+ "administrative_authority": True
+ },
+ "TREASURER": {
+ "voting_weight": 1.0,
+ "authority_level": "STANDARD",
+ "supervises": [],
+ "responsibilities": ["financial_oversight", "resource_management", "budget_control"],
+ "financial_authority": True
+ },
+ "MEMBER": {
+ "voting_weight": 1.0,
+ "authority_level": "STANDARD",
+ "supervises": [],
+ "responsibilities": ["expertise_contribution", "analysis", "voting"],
+ "specialized_expertise": True
+ }
+ }
+```
+
+## Quick Start
+
+### Basic Setup
+
+```python
+from swarms import Agent
+from swarms.structs.board_of_directors_swarm import (
+ BoardOfDirectorsSwarm,
+ BoardMember,
+ BoardMemberRole
+)
+from swarms.config.board_config import enable_board_feature
+
+# Enable the Board of Directors feature
+enable_board_feature()
+
+# Create board members with specific roles
+chairman = Agent(
+ agent_name="Chairman",
+ agent_description="Chairman of the Board responsible for leading meetings",
+ model_name="gpt-4o-mini",
+ system_prompt="You are the Chairman of the Board..."
+)
+
+vice_chairman = Agent(
+ agent_name="Vice-Chairman",
+ agent_description="Vice Chairman who supports the Chairman",
+ model_name="gpt-4o-mini",
+ system_prompt="You are the Vice Chairman..."
+)
+
+# Create BoardMember objects with roles and expertise
+board_members = [
+ BoardMember(chairman, BoardMemberRole.CHAIRMAN, 1.5, ["leadership", "strategy"]),
+ BoardMember(vice_chairman, BoardMemberRole.VICE_CHAIRMAN, 1.2, ["operations", "coordination"]),
+]
+
+# Create worker agents
+research_agent = Agent(
+ agent_name="Research-Specialist",
+ agent_description="Expert in market research and analysis",
+ model_name="gpt-4o",
+)
+
+financial_agent = Agent(
+ agent_name="Financial-Analyst",
+ agent_description="Specialist in financial analysis and valuation",
+ model_name="gpt-4o",
+)
+
+# Initialize the Board of Directors swarm
+board_swarm = BoardOfDirectorsSwarm(
+ name="Executive_Board_Swarm",
+ description="Executive board with specialized roles for strategic decision-making",
+ board_members=board_members,
+ agents=[research_agent, financial_agent],
+ max_loops=2,
+ verbose=True,
+ decision_threshold=0.6,
+ enable_voting=True,
+ enable_consensus=True,
+)
+
+# Execute a complex task with democratic decision-making
+result = board_swarm.run(task="Analyze the market potential for Tesla (TSLA) stock")
+print(result)
+```
+
+## Comprehensive Examples
+
+### 1. Strategic Investment Analysis
+
+```python
+# Create specialized agents for investment analysis
+market_research_agent = Agent(
+ agent_name="Market-Research-Specialist",
+ agent_description="Expert in market research, competitive analysis, and industry trends",
+ model_name="gpt-4o",
+ system_prompt="""You are a Market Research Specialist. Your responsibilities include:
+1. Conducting comprehensive market research and analysis
+2. Identifying market trends, opportunities, and risks
+3. Analyzing competitive landscape and positioning
+4. Providing market size and growth projections
+5. Supporting strategic decision-making with research findings
+
+You should be thorough, analytical, and objective in your research."""
+)
+
+financial_analyst_agent = Agent(
+ agent_name="Financial-Analyst",
+ agent_description="Specialist in financial analysis, valuation, and investment assessment",
+ model_name="gpt-4o",
+ system_prompt="""You are a Financial Analyst. Your responsibilities include:
+1. Conducting financial analysis and valuation
+2. Assessing investment opportunities and risks
+3. Analyzing financial performance and metrics
+4. Providing financial insights and recommendations
+5. Supporting financial decision-making
+
+You should be financially astute, analytical, and focused on value creation."""
+)
+
+technical_assessor_agent = Agent(
+ agent_name="Technical-Assessor",
+ agent_description="Expert in technical feasibility and implementation assessment",
+ model_name="gpt-4o",
+ system_prompt="""You are a Technical Assessor. Your responsibilities include:
+1. Evaluating technical feasibility and requirements
+2. Assessing implementation challenges and risks
+3. Analyzing technology stack and architecture
+4. Providing technical insights and recommendations
+5. Supporting technical decision-making
+
+You should be technically proficient, practical, and solution-oriented."""
+)
+
+# Create comprehensive board members
+board_members = [
+ BoardMember(
+ chairman,
+ BoardMemberRole.CHAIRMAN,
+ 1.5,
+ ["leadership", "strategy", "governance", "decision_making"]
+ ),
+ BoardMember(
+ vice_chairman,
+ BoardMemberRole.VICE_CHAIRMAN,
+ 1.2,
+ ["operations", "coordination", "communication", "implementation"]
+ ),
+ BoardMember(
+ secretary,
+ BoardMemberRole.SECRETARY,
+ 1.0,
+ ["documentation", "compliance", "record_keeping", "communication"]
+ ),
+ BoardMember(
+ treasurer,
+ BoardMemberRole.TREASURER,
+ 1.0,
+ ["finance", "budgeting", "risk_management", "resource_allocation"]
+ ),
+ BoardMember(
+ executive_director,
+ BoardMemberRole.EXECUTIVE_DIRECTOR,
+ 1.5,
+ ["strategy", "operations", "innovation", "performance_management"]
+ )
+]
+
+# Initialize the investment analysis board
+investment_board = BoardOfDirectorsSwarm(
+ name="Investment_Analysis_Board",
+ description="Specialized board for investment analysis and decision-making",
+ board_members=board_members,
+ agents=[market_research_agent, financial_analyst_agent, technical_assessor_agent],
+ max_loops=3,
+ verbose=True,
+ decision_threshold=0.75, # Higher threshold for investment decisions
+ enable_voting=True,
+ enable_consensus=True,
+ max_workers=3,
+ output_type="dict"
+)
+
+# Execute investment analysis
+investment_task = """
+Analyze the strategic investment opportunity for a $50M Series B funding round in a
+fintech startup. Consider market conditions, competitive landscape, financial projections,
+technical feasibility, and strategic fit. Provide comprehensive recommendations including:
+1. Investment recommendation (proceed/hold/decline)
+2. Valuation analysis and suggested terms
+3. Risk assessment and mitigation strategies
+4. Strategic value and synergies
+5. Implementation timeline and milestones
+"""
+
+result = investment_board.run(task=investment_task)
+print("Investment Analysis Results:")
+print(json.dumps(result, indent=2))
+```
+
+### 2. Technology Strategy Development
+
+```python
+# Create technology-focused agents
+tech_strategy_agent = Agent(
+ agent_name="Tech-Strategy-Specialist",
+ agent_description="Expert in technology strategy and digital transformation",
+ model_name="gpt-4o",
+ system_prompt="""You are a Technology Strategy Specialist. Your responsibilities include:
+1. Developing technology roadmaps and strategies
+2. Assessing digital transformation opportunities
+3. Evaluating emerging technologies and trends
+4. Planning technology investments and priorities
+5. Supporting technology decision-making
+
+You should be strategic, forward-thinking, and technology-savvy."""
+)
+
+implementation_planner_agent = Agent(
+ agent_name="Implementation-Planner",
+ agent_description="Expert in implementation planning and project management",
+ model_name="gpt-4o",
+ system_prompt="""You are an Implementation Planner. Your responsibilities include:
+1. Creating detailed implementation plans
+2. Assessing resource requirements and timelines
+3. Identifying implementation risks and challenges
+4. Planning change management strategies
+5. Supporting implementation decision-making
+
+You should be practical, organized, and execution-focused."""
+)
+
+# Technology strategy board configuration
+tech_board = BoardOfDirectorsSwarm(
+ name="Technology_Strategy_Board",
+ description="Specialized board for technology strategy and digital transformation",
+ board_members=board_members,
+ agents=[tech_strategy_agent, implementation_planner_agent, technical_assessor_agent],
+ max_loops=4, # More loops for complex technology planning
+ verbose=True,
+ decision_threshold=0.7,
+ enable_voting=True,
+ enable_consensus=True,
+ max_workers=3,
+ output_type="dict"
+)
+
+# Execute technology strategy development
+tech_strategy_task = """
+Develop a comprehensive technology strategy for a mid-size manufacturing company
+looking to digitize operations and implement Industry 4.0 technologies. Consider:
+1. Current technology assessment and gaps
+2. Technology roadmap and implementation plan
+3. Investment requirements and ROI analysis
+4. Risk assessment and mitigation strategies
+5. Change management and training requirements
+6. Competitive positioning and market advantages
+"""
+
+result = tech_board.run(task=tech_strategy_task)
+print("Technology Strategy Results:")
+print(json.dumps(result, indent=2))
+```
+
+### 3. Crisis Management and Response
+
+```python
+# Create crisis management agents
+crisis_coordinator_agent = Agent(
+ agent_name="Crisis-Coordinator",
+ agent_description="Expert in crisis management and emergency response",
+ model_name="gpt-4o",
+ system_prompt="""You are a Crisis Coordinator. Your responsibilities include:
+1. Coordinating crisis response efforts
+2. Assessing crisis severity and impact
+3. Developing immediate response plans
+4. Managing stakeholder communications
+5. Supporting crisis decision-making
+
+You should be calm, decisive, and action-oriented."""
+)
+
+communications_specialist_agent = Agent(
+ agent_name="Communications-Specialist",
+ agent_description="Expert in crisis communications and stakeholder management",
+ model_name="gpt-4o",
+ system_prompt="""You are a Communications Specialist. Your responsibilities include:
+1. Developing crisis communication strategies
+2. Managing stakeholder communications
+3. Coordinating public relations efforts
+4. Ensuring message consistency and accuracy
+5. Supporting communication decision-making
+
+You should be clear, empathetic, and strategic in communications."""
+)
+
+# Crisis management board configuration
+crisis_board = BoardOfDirectorsSwarm(
+ name="Crisis_Management_Board",
+ description="Specialized board for crisis management and emergency response",
+ board_members=board_members,
+ agents=[crisis_coordinator_agent, communications_specialist_agent, financial_analyst_agent],
+ max_loops=2, # Faster response needed
+ verbose=True,
+ decision_threshold=0.6, # Lower threshold for urgent decisions
+ enable_voting=True,
+ enable_consensus=True,
+ max_workers=3,
+ output_type="dict"
+)
+
+# Execute crisis management
+crisis_task = """
+Our company is facing a major data breach. Develop an immediate response plan.
+Include:
+1. Immediate containment and mitigation steps
+2. Communication strategy for stakeholders
+3. Legal and regulatory compliance requirements
+4. Financial impact assessment
+5. Long-term recovery and prevention measures
+6. Timeline and resource allocation
+"""
+
+result = crisis_board.run(task=crisis_task)
+print("Crisis Management Results:")
+print(json.dumps(result, indent=2))
+```
+
+## Configuration and Parameters
+
+### BoardOfDirectorsSwarm Parameters
+
+```python
+# Complete parameter reference
+board_swarm = BoardOfDirectorsSwarm(
+ # Basic Configuration
+ name="Board_Name", # Name of the board
+ description="Board description", # Description of the board's purpose
+
+ # Board Members and Agents
+ board_members=board_members, # List of BoardMember objects
+ agents=worker_agents, # List of worker Agent objects
+
+ # Execution Control
+ max_loops=3, # Maximum number of refinement loops
+ max_workers=4, # Maximum parallel workers
+
+ # Decision Making
+ decision_threshold=0.7, # Consensus threshold (0.0-1.0)
+ enable_voting=True, # Enable voting mechanisms
+ enable_consensus=True, # Enable consensus building
+
+ # Advanced Features
+ auto_assign_roles=True, # Auto-assign roles based on expertise
+ role_mapping={ # Custom role mapping
+ "financial_analysis": ["Treasurer", "Financial_Member"],
+ "strategic_planning": ["Chairman", "Executive_Director"]
+ },
+
+ # Consensus Configuration
+ consensus_timeout=300, # Consensus timeout in seconds
+ min_participation_rate=0.8, # Minimum participation rate
+ auto_fallback_to_chairman=True, # Chairman can make final decisions
+ consensus_rounds=3, # Maximum consensus building rounds
+
+ # Output Configuration
+ output_type="dict", # Output format: "dict", "str", "list"
+ verbose=True, # Enable detailed logging
+
+ # Quality Control
+ quality_threshold=0.8, # Quality threshold for outputs
+ enable_quality_gates=True, # Enable quality checkpoints
+ enable_peer_review=True, # Enable peer review mechanisms
+
+ # Performance Optimization
+ parallel_execution=True, # Enable parallel execution
+ enable_agent_pooling=True, # Enable agent pooling
+ timeout_per_agent=300, # Timeout per agent in seconds
+
+ # Monitoring and Logging
+ enable_logging=True, # Enable detailed logging
+ log_level="INFO", # Logging level
+ enable_metrics=True, # Enable performance metrics
+ enable_tracing=True # Enable request tracing
+)
+```
+
+### Voting Configuration
+
+```python
+# Voting system configuration
+voting_config = {
+ "method": "weighted_majority", # Voting method
+ "threshold": 0.75, # Consensus threshold
+ "weights": { # Role-based voting weights
+ "CHAIRMAN": 1.5,
+ "VICE_CHAIRMAN": 1.2,
+ "SECRETARY": 1.0,
+ "TREASURER": 1.0,
+ "EXECUTIVE_DIRECTOR": 1.5
+ },
+ "tie_breaker": "CHAIRMAN", # Tie breaker role
+ "allow_abstention": True, # Allow board members to abstain
+ "secret_ballot": False, # Use secret ballot voting
+ "transparent_process": True # Transparent voting process
+}
+```
+
+### Quality Control Configuration
+
+```python
+# Quality control configuration
+quality_config = {
+ "quality_gates": True, # Enable quality checkpoints
+ "quality_threshold": 0.8, # Quality threshold
+ "enable_peer_review": True, # Enable peer review
+ "review_required": True, # Require peer review
+ "output_validation": True, # Validate outputs
+ "enable_metrics_tracking": True, # Track quality metrics
+
+ # Quality metrics
+ "quality_metrics": {
+ "completeness": {"weight": 0.2, "threshold": 0.8},
+ "accuracy": {"weight": 0.25, "threshold": 0.85},
+ "feasibility": {"weight": 0.2, "threshold": 0.8},
+ "risk": {"weight": 0.15, "threshold": 0.7},
+ "impact": {"weight": 0.2, "threshold": 0.8}
+ }
+}
+```
+
+## Performance Monitoring and Analytics
+
+### Board Performance Metrics
+
+```python
+# Get comprehensive board performance metrics
+board_summary = board_swarm.get_board_summary()
+print("Board Summary:")
+print(f"Board Name: {board_summary['board_name']}")
+print(f"Total Board Members: {board_summary['total_members']}")
+print(f"Total Worker Agents: {board_summary['total_agents']}")
+print(f"Decision Threshold: {board_summary['decision_threshold']}")
+print(f"Max Loops: {board_summary['max_loops']}")
+
+# Display board member details
+print("\nBoard Members:")
+for member in board_summary['members']:
+ print(f"- {member['name']} (Role: {member['role']}, Weight: {member['voting_weight']})")
+ print(f" Expertise: {', '.join(member['expertise_areas'])}")
+
+# Display worker agent details
+print("\nWorker Agents:")
+for agent in board_summary['agents']:
+ print(f"- {agent['name']}: {agent['description']}")
+```
+
+### Decision Analysis
+
+```python
+# Analyze decision-making patterns
+if hasattr(result, 'get') and callable(result.get):
+ conversation_history = result.get('conversation_history', [])
+
+ print(f"\nDecision Analysis:")
+ print(f"Total Messages: {len(conversation_history)}")
+
+ # Count board member contributions
+ board_contributions = {}
+ for msg in conversation_history:
+ if 'Board' in msg.get('role', ''):
+ member_name = msg.get('agent_name', 'Unknown')
+ board_contributions[member_name] = board_contributions.get(member_name, 0) + 1
+
+ print(f"Board Member Contributions:")
+ for member, count in board_contributions.items():
+ print(f"- {member}: {count} contributions")
+
+ # Count agent executions
+ agent_executions = {}
+ for msg in conversation_history:
+ if any(agent.agent_name in msg.get('role', '') for agent in worker_agents):
+ agent_name = msg.get('agent_name', 'Unknown')
+ agent_executions[agent_name] = agent_executions.get(agent_name, 0) + 1
+
+ print(f"\nAgent Executions:")
+ for agent, count in agent_executions.items():
+ print(f"- {agent}: {count} executions")
+```
+
+### Performance Monitoring System
+
+```python
+# Performance monitoring system
+class PerformanceMonitor:
+ def __init__(self):
+ self.metrics = {
+ "execution_times": [],
+ "quality_scores": [],
+ "consensus_rounds": [],
+ "error_rates": []
+ }
+
+ def track_execution_time(self, phase, duration):
+ """Track execution time for different phases"""
+ self.metrics["execution_times"].append({
+ "phase": phase,
+ "duration": duration,
+ "timestamp": datetime.now().isoformat()
+ })
+
+ def track_quality_score(self, score):
+ """Track quality scores"""
+ self.metrics["quality_scores"].append({
+ "score": score,
+ "timestamp": datetime.now().isoformat()
+ })
+
+ def generate_performance_report(self):
+ """Generate comprehensive performance report"""
+ return {
+ "average_execution_time": self.calculate_average_execution_time(),
+ "quality_trends": self.analyze_quality_trends(),
+ "consensus_efficiency": self.analyze_consensus_efficiency(),
+ "error_analysis": self.analyze_errors(),
+ "recommendations": self.generate_recommendations()
+ }
+
+# Usage example
+monitor = PerformanceMonitor()
+# ... track metrics during execution ...
+report = monitor.generate_performance_report()
+print("Performance Report:")
+print(json.dumps(report, indent=2))
+```
+
+## Advanced Features and Customization
+
+### Custom Board Templates
+
+```python
+from swarms.config.board_config import get_default_board_template
+
+# Get pre-configured board templates
+financial_board = get_default_board_template("financial_analysis")
+strategic_board = get_default_board_template("strategic_planning")
+tech_board = get_default_board_template("technology_assessment")
+crisis_board = get_default_board_template("crisis_management")
+
+# Custom board template
+custom_template = {
+ "name": "Custom_Board",
+ "description": "Custom board for specific use case",
+ "board_members": [
+ {"role": "CHAIRMAN", "expertise": ["leadership", "strategy"]},
+ {"role": "VICE_CHAIRMAN", "expertise": ["operations", "coordination"]},
+ {"role": "SECRETARY", "expertise": ["documentation", "communication"]},
+ {"role": "TREASURER", "expertise": ["finance", "budgeting"]},
+ {"role": "EXECUTIVE_DIRECTOR", "expertise": ["strategy", "operations"]}
+ ],
+ "agents": [
+ {"name": "Research_Agent", "expertise": ["research", "analysis"]},
+ {"name": "Technical_Agent", "expertise": ["technical", "implementation"]}
+ ],
+ "config": {
+ "max_loops": 3,
+ "decision_threshold": 0.7,
+ "enable_voting": True,
+ "enable_consensus": True
+ }
+}
+```
+
+### Dynamic Role Assignment
+
+```python
+# Automatically assign roles based on task requirements
+board_swarm = BoardOfDirectorsSwarm(
+ board_members=board_members,
+ agents=agents,
+ auto_assign_roles=True,
+ role_mapping={
+ "financial_analysis": ["Treasurer", "Financial_Member"],
+ "strategic_planning": ["Chairman", "Executive_Director"],
+ "technical_assessment": ["Technical_Member", "Executive_Director"],
+ "research_analysis": ["Research_Member", "Secretary"],
+ "crisis_management": ["Chairman", "Vice_Chairman", "Communications_Member"]
+ }
+)
+```
+
+### Consensus Optimization
+
+```python
+# Advanced consensus-building mechanisms
+board_swarm = BoardOfDirectorsSwarm(
+ board_members=board_members,
+ agents=agents,
+ enable_consensus=True,
+ consensus_timeout=300, # 5 minutes timeout
+ min_participation_rate=0.8, # 80% minimum participation
+ auto_fallback_to_chairman=True, # Chairman can make final decisions
+ consensus_rounds=3, # Maximum consensus building rounds
+ consensus_method="weighted_majority", # Consensus method
+ enable_mediation=True, # Enable mediation for conflicts
+ mediation_timeout=120 # Mediation timeout in seconds
+)
+```
+
+## Troubleshooting and Debugging
+
+### Common Issues and Solutions
+
+1. **Consensus Failures**
+ - **Issue**: Board cannot reach consensus within loop limit
+ - **Solution**: Lower voting threshold, increase max_loops, or adjust voting weights
+ ```python
+ board_swarm = BoardOfDirectorsSwarm(
+ decision_threshold=0.6, # Lower threshold
+ max_loops=5, # More loops
+ consensus_timeout=600 # Longer timeout
+ )
+ ```
+
+2. **Agent Timeout**
+ - **Issue**: Individual agents take too long to respond
+ - **Solution**: Increase timeout settings or optimize agent prompts
+ ```python
+ board_swarm = BoardOfDirectorsSwarm(
+ timeout_per_agent=600, # 10 minutes per agent
+ enable_agent_pooling=True # Use agent pooling
+ )
+ ```
+
+3. **Poor Quality Output**
+ - **Issue**: Final output doesn't meet quality standards
+ - **Solution**: Enable quality gates, increase max_loops, or improve agent prompts
+ ```python
+ board_swarm = BoardOfDirectorsSwarm(
+ enable_quality_gates=True,
+ quality_threshold=0.8,
+ enable_peer_review=True,
+ max_loops=4
+ )
+ ```
+
+4. **Resource Exhaustion**
+ - **Issue**: System runs out of resources during execution
+ - **Solution**: Implement resource limits, use agent pooling, or optimize parallel execution
+ ```python
+ board_swarm = BoardOfDirectorsSwarm(
+ max_workers=2, # Limit parallel workers
+ enable_agent_pooling=True,
+ parallel_execution=False # Disable parallel execution
+ )
+ ```
+
+### Debugging Techniques
+
+```python
+# Debugging configuration
+debug_config = BoardConfig(
+ max_loops=1, # Limit loops for debugging
+ enable_logging=True,
+ log_level="DEBUG",
+ enable_tracing=True,
+ debug_mode=True
+)
+
+# Create debug swarm
+debug_swarm = BoardOfDirectorsSwarm(
+ agents=agents,
+ config=debug_config
+)
+
+# Execute with debugging
+try:
+ result = debug_swarm.run(task)
+except Exception as e:
+ print(f"Error: {e}")
+ print(f"Debug info: {debug_swarm.get_debug_info()}")
+
+# Enable detailed logging
+import logging
+logging.basicConfig(
+ level=logging.DEBUG,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
+# Create swarm with logging enabled
+logging_swarm = BoardOfDirectorsSwarm(
+ agents=agents,
+ config=BoardConfig(
+ enable_logging=True,
+ log_level="DEBUG",
+ enable_metrics=True,
+ enable_tracing=True
+ )
+)
+```
+
+## Use Cases
+
+### Corporate Governance
+- **Strategic Planning**: Long-term business strategy development
+- **Risk Management**: Comprehensive risk assessment and mitigation
+- **Resource Allocation**: Optimal distribution of company resources
+- **Performance Oversight**: Monitoring and evaluating organizational performance
+
+### Financial Analysis
+- **Portfolio Management**: Investment portfolio optimization and rebalancing
+- **Market Analysis**: Comprehensive market research and trend analysis
+- **Risk Assessment**: Financial risk evaluation and management
+- **Compliance Monitoring**: Regulatory compliance and audit preparation
+
+### Research & Development
+- **Technology Assessment**: Evaluation of emerging technologies
+- **Product Development**: Strategic product planning and development
+- **Innovation Management**: Managing innovation pipelines and initiatives
+- **Quality Assurance**: Ensuring high standards across development processes
+
+### Project Management
+- **Complex Project Planning**: Multi-faceted project strategy development
+- **Resource Optimization**: Efficient allocation of project resources
+- **Stakeholder Management**: Coordinating diverse stakeholder interests
+- **Risk Mitigation**: Identifying and addressing project risks
+
+### Crisis Management
+- **Emergency Response**: Rapid response to critical situations
+- **Stakeholder Communication**: Managing communications during crises
+- **Recovery Planning**: Developing recovery and prevention strategies
+- **Legal Compliance**: Ensuring compliance during crisis situations
+
+## Success Criteria
+
+A successful Board of Directors implementation should demonstrate:
+
+- **Democratic Decision Making**: All board members contribute to decisions
+- **Consensus Achievement**: Decisions reached through collaborative processes
+- **Role Effectiveness**: Each board member fulfills their responsibilities
+- **Agent Coordination**: Worker agents execute tasks efficiently
+- **Quality Output**: High-quality results through collective intelligence
+- **Process Transparency**: Clear visibility into decision-making processes
+- **Performance Optimization**: Efficient resource utilization and execution
+- **Continuous Improvement**: Learning from each execution cycle
+
+## Best Practices
+
+### 1. Role Definition
+- Clearly define responsibilities for each board member
+- Ensure expertise areas align with organizational needs
+- Balance voting weights based on role importance
+- Document role interactions and communication protocols
+
+### 2. Task Formulation
+- Provide clear, specific task descriptions
+- Include relevant context and constraints
+- Specify expected outputs and deliverables
+- Define quality criteria and success metrics
+
+### 3. Consensus Building
+- Allow adequate time for discussion and consensus
+- Encourage diverse perspectives and viewpoints
+- Use structured decision-making processes
+- Implement conflict resolution mechanisms
+
+### 4. Performance Monitoring
+- Track decision quality and outcomes
+- Monitor board member participation
+- Analyze agent utilization and effectiveness
+- Implement continuous improvement processes
+
+### 5. Resource Management
+- Optimize agent allocation and utilization
+- Implement parallel execution where appropriate
+- Monitor resource usage and performance
+- Scale resources based on task complexity
+
+---
+
+The Board of Directors architecture represents a sophisticated approach to multi-agent collaboration, enabling organizations to leverage collective intelligence through structured governance and democratic decision-making processes. This comprehensive implementation provides the tools and frameworks needed to build effective, scalable, and intelligent decision-making systems.
+
+
+--------------------------------------------------
+
+# File: swarms/structs/abstractswarm.md
# `BaseSwarm` Documentation
@@ -28478,31 +32045,9 @@ This comprehensive documentation covers the Swarms library, including the `BaseS
--------------------------------------------------
-# File: swarms\structs\agent.md
+# File: swarms/structs/agent.md
-# `Agent`
-
-Swarm Agent is a powerful autonomous agent framework designed to connect Language Models (LLMs) with various tools and long-term memory. This class provides the ability to ingest and process various types of documents such as PDFs, text files, Markdown files, JSON files, and more. The Agent structure offers a wide range of features to enhance the capabilities of LLMs and facilitate efficient task execution.
-
-## Overview
-
-The `Agent` class establishes a conversational loop with a language model, allowing for interactive task execution, feedback collection, and dynamic response generation. It includes features such as:
-
-1. **Conversational Loop**: Enables back-and-forth interaction with the model.
-2. **Feedback Collection**: Allows users to provide feedback on generated responses.
-3. **Stoppable Conversation**: Supports custom stopping conditions for the conversation.
-4. **Retry Mechanism**: Implements a retry system for handling issues in response generation.
-5. **Tool Integration**: Supports the integration of various tools for enhanced capabilities.
-6. **Long-term Memory Management**: Incorporates vector databases for efficient information retrieval.
-7. **Document Ingestion**: Processes various document types for information extraction.
-8. **Interactive Mode**: Allows real-time communication with the agent.
-9. **Sentiment Analysis**: Evaluates the sentiment of generated responses.
-10. **Output Filtering and Cleaning**: Ensures generated responses meet specific criteria.
-11. **Asynchronous and Concurrent Execution**: Supports efficient parallelization of tasks.
-12. **Planning and Reasoning**: Implements techniques like algorithm of thoughts for enhanced decision-making.
-
-
-## Architecture
+# `Agent` Structure Reference Documentation
```mermaid
graph TD
@@ -28523,113 +32068,170 @@ graph TD
L -->|Proceeds to Final LLM Processing| I
```
+The `Agent` class is the core component of the Swarm Agent framework. It serves as an autonomous agent that bridges Language Models (LLMs) with external tools and long-term memory systems. The class is designed to handle a variety of document types—including PDFs, text files, Markdown, and JSON—enabling robust document ingestion and processing. By integrating these capabilities, the `Agent` class empowers LLMs to perform complex tasks, utilize external resources, and manage information efficiently, making it a versatile solution for advanced autonomous workflows.
+
+
+## Features
+The `Agent` class establishes a conversational loop with a language model, allowing for interactive task execution, feedback collection, and dynamic response generation. It includes features such as:
+
+| Feature | Description |
+|------------------------------------------|--------------------------------------------------------------------------------------------------|
+| **Conversational Loop** | Enables back-and-forth interaction with the model. |
+| **Feedback Collection** | Allows users to provide feedback on generated responses. |
+| **Stoppable Conversation** | Supports custom stopping conditions for the conversation. |
+| **Retry Mechanism** | Implements a retry system for handling issues in response generation. |
+| **Tool Integration** | Supports the integration of various tools for enhanced capabilities. |
+| **Long-term Memory Management** | Incorporates vector databases for efficient information retrieval. |
+| **Document Ingestion** | Processes various document types for information extraction. |
+| **Interactive Mode** | Allows real-time communication with the agent. |
+| **Sentiment Analysis** | Evaluates the sentiment of generated responses. |
+| **Output Filtering and Cleaning** | Ensures generated responses meet specific criteria. |
+| **Asynchronous and Concurrent Execution**| Supports efficient parallelization of tasks. |
+| **Planning and Reasoning** | Implements techniques like algorithm of thoughts for enhanced decision-making. |
-## `Agent` Attributes
-| Attribute | Description |
-|-----------|-------------|
-| `id` | Unique identifier for the agent instance. |
-| `llm` | Language model instance used by the agent. |
-| `template` | Template used for formatting responses. |
-| `max_loops` | Maximum number of loops the agent can run. |
-| `stopping_condition` | Callable function determining when to stop looping. |
-| `loop_interval` | Interval (in seconds) between loops. |
-| `retry_attempts` | Number of retry attempts for failed LLM calls. |
-| `retry_interval` | Interval (in seconds) between retry attempts. |
-| `return_history` | Boolean indicating whether to return conversation history. |
-| `stopping_token` | Token that stops the agent from looping when present in the response. |
-| `dynamic_loops` | Boolean indicating whether to dynamically determine the number of loops. |
-| `interactive` | Boolean indicating whether to run in interactive mode. |
-| `dashboard` | Boolean indicating whether to display a dashboard. |
-| `agent_name` | Name of the agent instance. |
-| `agent_description` | Description of the agent instance. |
-| `system_prompt` | System prompt used to initialize the conversation. |
-| `tools` | List of callable functions representing tools the agent can use. |
-| `dynamic_temperature_enabled` | Boolean indicating whether to dynamically adjust the LLM's temperature. |
-| `sop` | Standard operating procedure for the agent. |
-| `sop_list` | List of strings representing the standard operating procedure. |
-| `saved_state_path` | File path for saving and loading the agent's state. |
-| `autosave` | Boolean indicating whether to automatically save the agent's state. |
-| `context_length` | Maximum length of the context window (in tokens) for the LLM. |
-| `user_name` | Name used to represent the user in the conversation. |
-| `self_healing_enabled` | Boolean indicating whether to attempt self-healing in case of errors. |
-| `code_interpreter` | Boolean indicating whether to interpret and execute code snippets. |
-| `multi_modal` | Boolean indicating whether to support multimodal inputs. |
-| `pdf_path` | File path of a PDF document to be ingested. |
-| `list_of_pdf` | List of file paths for PDF documents to be ingested. |
-| `tokenizer` | Instance of a tokenizer used for token counting and management. |
-| `long_term_memory` | Instance of a `BaseVectorDatabase` implementation for long-term memory management. |
-| `preset_stopping_token` | Boolean indicating whether to use a preset stopping token. |
-| `traceback` | Object used for traceback handling. |
-| `traceback_handlers` | List of traceback handlers. |
-| `streaming_on` | Boolean indicating whether to stream responses. |
-| `docs` | List of document paths or contents to be ingested. |
-| `docs_folder` | Path to a folder containing documents to be ingested. |
-| `verbose` | Boolean indicating whether to print verbose output. |
-| `parser` | Callable function used for parsing input data. |
-| `best_of_n` | Integer indicating the number of best responses to generate. |
-| `callback` | Callable function to be called after each agent loop. |
-| `metadata` | Dictionary containing metadata for the agent. |
-| `callbacks` | List of callable functions to be called during execution. |
-| `logger_handler` | Handler for logging messages. |
-| `search_algorithm` | Callable function for long-term memory retrieval. |
-| `logs_to_filename` | File path for logging agent activities. |
-| `evaluator` | Callable function for evaluating the agent's responses. |
-| `stopping_func` | Callable function used as a stopping condition. |
-| `custom_loop_condition` | Callable function used as a custom loop condition. |
-| `sentiment_threshold` | Float value representing the sentiment threshold for evaluating responses. |
-| `custom_exit_command` | String representing a custom command for exiting the agent's loop. |
-| `sentiment_analyzer` | Callable function for sentiment analysis on outputs. |
-| `limit_tokens_from_string` | Callable function for limiting the number of tokens in a string. |
-| `custom_tools_prompt` | Callable function for generating a custom prompt for tool usage. |
-| `tool_schema` | Data structure representing the schema for the agent's tools. |
-| `output_type` | Type representing the expected output type of responses. |
-| `function_calling_type` | String representing the type of function calling. |
-| `output_cleaner` | Callable function for cleaning the agent's output. |
-| `function_calling_format_type` | String representing the format type for function calling. |
-| `list_base_models` | List of base models used for generating tool schemas. |
-| `metadata_output_type` | String representing the output type for metadata. |
-| `state_save_file_type` | String representing the file type for saving the agent's state. |
-| `chain_of_thoughts` | Boolean indicating whether to use the chain of thoughts technique. |
-| `algorithm_of_thoughts` | Boolean indicating whether to use the algorithm of thoughts technique. |
-| `tree_of_thoughts` | Boolean indicating whether to use the tree of thoughts technique. |
-| `tool_choice` | String representing the method for tool selection. |
-| `execute_tool` | Boolean indicating whether to execute tools. |
-| `rules` | String representing the rules for the agent's behavior. |
-| `planning` | Boolean indicating whether to perform planning. |
-| `planning_prompt` | String representing the prompt for planning. |
-| `device` | String representing the device on which the agent should run. |
-| `custom_planning_prompt` | String representing a custom prompt for planning. |
-| `memory_chunk_size` | Integer representing the maximum size of memory chunks for long-term memory retrieval. |
-| `agent_ops_on` | Boolean indicating whether agent operations should be enabled. |
-| `return_step_meta` | Boolean indicating whether to return JSON of all steps and additional metadata. |
-| `output_type` | Literal type indicating whether to output "string", "str", "list", "json", "dict", or "yaml". |
-| `time_created` | Float representing the time the agent was created. |
-| `tags` | Optional list of strings for tagging the agent. |
-| `use_cases` | Optional list of dictionaries describing use cases for the agent. |
-| `step_pool` | List of Step objects representing the agent's execution steps. |
-| `print_every_step` | Boolean indicating whether to print every step of execution. |
-| `agent_output` | ManySteps object containing the agent's output and metadata. |
-| `executor_workers` | Integer representing the number of executor workers for concurrent operations. |
-| `data_memory` | Optional callable for data memory operations. |
-| `load_yaml_path` | String representing the path to a YAML file for loading configurations. |
-| `auto_generate_prompt` | Boolean indicating whether to automatically generate prompts. |
-| `rag_every_loop` | Boolean indicating whether to query RAG database for context on every loop |
-| `plan_enabled` | Boolean indicating whether planning functionality is enabled |
-| `artifacts_on` | Boolean indicating whether to save artifacts from agent execution |
-| `artifacts_output_path` | File path where artifacts should be saved |
-| `artifacts_file_extension` | File extension to use for saved artifacts |
-| `device` | Device to run computations on ("cpu" or "gpu") |
-| `all_cores` | Boolean indicating whether to use all CPU cores |
-| `device_id` | ID of the GPU device to use if running on GPU |
-| `scheduled_run_date` | Optional datetime for scheduling future agent runs |
+
+## `Agent` Attributes
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `id` | `Optional[str]` | Unique identifier for the agent instance. |
+| `llm` | `Optional[Any]` | Language model instance used by the agent. |
+| `template` | `Optional[str]` | Template used for formatting responses. |
+| `max_loops` | `Optional[Union[int, str]]` | Maximum number of loops the agent can run. |
+| `stopping_condition` | `Optional[Callable[[str], bool]]` | Callable function determining when to stop looping. |
+| `loop_interval` | `Optional[int]` | Interval (in seconds) between loops. |
+| `retry_attempts` | `Optional[int]` | Number of retry attempts for failed LLM calls. |
+| `retry_interval` | `Optional[int]` | Interval (in seconds) between retry attempts. |
+| `return_history` | `Optional[bool]` | Boolean indicating whether to return conversation history. |
+| `stopping_token` | `Optional[str]` | Token that stops the agent from looping when present in the response. |
+| `dynamic_loops` | `Optional[bool]` | Boolean indicating whether to dynamically determine the number of loops. |
+| `interactive` | `Optional[bool]` | Boolean indicating whether to run in interactive mode. |
+| `dashboard` | `Optional[bool]` | Boolean indicating whether to display a dashboard. |
+| `agent_name` | `Optional[str]` | Name of the agent instance. |
+| `agent_description` | `Optional[str]` | Description of the agent instance. |
+| `system_prompt` | `Optional[str]` | System prompt used to initialize the conversation. |
+| `tools` | `List[Callable]` | List of callable functions representing tools the agent can use. |
+| `dynamic_temperature_enabled` | `Optional[bool]` | Boolean indicating whether to dynamically adjust the LLM's temperature. |
+| `sop` | `Optional[str]` | Standard operating procedure for the agent. |
+| `sop_list` | `Optional[List[str]]` | List of strings representing the standard operating procedure. |
+| `saved_state_path` | `Optional[str]` | File path for saving and loading the agent's state. |
+| `autosave` | `Optional[bool]` | Boolean indicating whether to automatically save the agent's state. |
+| `context_length` | `Optional[int]` | Maximum length of the context window (in tokens) for the LLM. |
+| `user_name` | `Optional[str]` | Name used to represent the user in the conversation. |
+| `self_healing_enabled` | `Optional[bool]` | Boolean indicating whether to attempt self-healing in case of errors. |
+| `code_interpreter` | `Optional[bool]` | Boolean indicating whether to interpret and execute code snippets. |
+| `multi_modal` | `Optional[bool]` | Boolean indicating whether to support multimodal inputs. |
+| `pdf_path` | `Optional[str]` | File path of a PDF document to be ingested. |
+| `list_of_pdf` | `Optional[str]` | List of file paths for PDF documents to be ingested. |
+| `tokenizer` | `Optional[Any]` | Instance of a tokenizer used for token counting and management. |
+| `long_term_memory` | `Optional[Union[Callable, Any]]` | Instance of a `BaseVectorDatabase` implementation for long-term memory management. |
+| `preset_stopping_token` | `Optional[bool]` | Boolean indicating whether to use a preset stopping token. |
+| `traceback` | `Optional[Any]` | Object used for traceback handling. |
+| `traceback_handlers` | `Optional[Any]` | List of traceback handlers. |
+| `streaming_on` | `Optional[bool]` | Boolean indicating whether to stream responses. |
+| `docs` | `List[str]` | List of document paths or contents to be ingested. |
+| `docs_folder` | `Optional[str]` | Path to a folder containing documents to be ingested. |
+| `verbose` | `Optional[bool]` | Boolean indicating whether to print verbose output. |
+| `parser` | `Optional[Callable]` | Callable function used for parsing input data. |
+| `best_of_n` | `Optional[int]` | Integer indicating the number of best responses to generate. |
+| `callback` | `Optional[Callable]` | Callable function to be called after each agent loop. |
+| `metadata` | `Optional[Dict[str, Any]]` | Dictionary containing metadata for the agent. |
+| `callbacks` | `Optional[List[Callable]]` | List of callable functions to be called during execution. |
+| `search_algorithm` | `Optional[Callable]` | Callable function for long-term memory retrieval. |
+| `logs_to_filename` | `Optional[str]` | File path for logging agent activities. |
+| `evaluator` | `Optional[Callable]` | Callable function for evaluating the agent's responses. |
+| `stopping_func` | `Optional[Callable]` | Callable function used as a stopping condition. |
+| `custom_loop_condition` | `Optional[Callable]` | Callable function used as a custom loop condition. |
+| `sentiment_threshold` | `Optional[float]` | Float value representing the sentiment threshold for evaluating responses. |
+| `custom_exit_command` | `Optional[str]` | String representing a custom command for exiting the agent's loop. |
+| `sentiment_analyzer` | `Optional[Callable]` | Callable function for sentiment analysis on outputs. |
+| `limit_tokens_from_string` | `Optional[Callable]` | Callable function for limiting the number of tokens in a string. |
+| `custom_tools_prompt` | `Optional[Callable]` | Callable function for generating a custom prompt for tool usage. |
+| `tool_schema` | `ToolUsageType` | Data structure representing the schema for the agent's tools. |
+| `output_type` | `OutputType` | Type representing the expected output type of responses. |
+| `function_calling_type` | `str` | String representing the type of function calling. |
+| `output_cleaner` | `Optional[Callable]` | Callable function for cleaning the agent's output. |
+| `function_calling_format_type` | `Optional[str]` | String representing the format type for function calling. |
+| `list_base_models` | `Optional[List[BaseModel]]` | List of base models used for generating tool schemas. |
+| `metadata_output_type` | `str` | String representing the output type for metadata. |
+| `state_save_file_type` | `str` | String representing the file type for saving the agent's state. |
+| `chain_of_thoughts` | `bool` | Boolean indicating whether to use the chain of thoughts technique. |
+| `algorithm_of_thoughts` | `bool` | Boolean indicating whether to use the algorithm of thoughts technique. |
+| `tree_of_thoughts` | `bool` | Boolean indicating whether to use the tree of thoughts technique. |
+| `tool_choice` | `str` | String representing the method for tool selection. |
+| `execute_tool` | `bool` | Boolean indicating whether to execute tools. |
+| `rules` | `str` | String representing the rules for the agent's behavior. |
+| `planning` | `Optional[str]` | Boolean indicating whether to perform planning. |
+| `planning_prompt` | `Optional[str]` | String representing the prompt for planning. |
+| `device` | `str` | String representing the device on which the agent should run. |
+| `custom_planning_prompt` | `str` | String representing a custom prompt for planning. |
+| `memory_chunk_size` | `int` | Integer representing the maximum size of memory chunks for long-term memory retrieval. |
+| `agent_ops_on` | `bool` | Boolean indicating whether agent operations should be enabled. |
+| `return_step_meta` | `Optional[bool]` | Boolean indicating whether to return JSON of all steps and additional metadata. |
+| `time_created` | `Optional[str]` | Float representing the time the agent was created. |
+| `tags` | `Optional[List[str]]` | Optional list of strings for tagging the agent. |
+| `use_cases` | `Optional[List[Dict[str, str]]]` | Optional list of dictionaries describing use cases for the agent. |
+| `step_pool` | `List[Step]` | List of Step objects representing the agent's execution steps. |
+| `print_every_step` | `Optional[bool]` | Boolean indicating whether to print every step of execution. |
+| `agent_output` | `ManySteps` | ManySteps object containing the agent's output and metadata. |
+| `data_memory` | `Optional[Callable]` | Optional callable for data memory operations. |
+| `load_yaml_path` | `str` | String representing the path to a YAML file for loading configurations. |
+| `auto_generate_prompt` | `bool` | Boolean indicating whether to automatically generate prompts. |
+| `rag_every_loop` | `bool` | Boolean indicating whether to query RAG database for context on every loop |
+| `plan_enabled` | `bool` | Boolean indicating whether planning functionality is enabled |
+| `artifacts_on` | `bool` | Boolean indicating whether to save artifacts from agent execution |
+| `artifacts_output_path` | `str` | File path where artifacts should be saved |
+| `artifacts_file_extension` | `str` | File extension to use for saved artifacts |
+| `all_cores` | `bool` | Boolean indicating whether to use all CPU cores |
+| `device_id` | `int` | ID of the GPU device to use if running on GPU |
+| `scheduled_run_date` | `Optional[datetime]` | Optional datetime for scheduling future agent runs |
+| `do_not_use_cluster_ops` | `bool` | Boolean indicating whether to avoid cluster operations |
+| `all_gpus` | `bool` | Boolean indicating whether to use all available GPUs |
+| `model_name` | `str` | String representing the name of the model to use |
+| `llm_args` | `dict` | Dictionary containing additional arguments for the LLM |
+| `load_state_path` | `str` | String representing the path to load state from |
+| `role` | `agent_roles` | String representing the role of the agent (e.g., "worker") |
+| `print_on` | `bool` | Boolean indicating whether to print output |
+| `tools_list_dictionary` | `Optional[List[Dict[str, Any]]]` | List of dictionaries representing tool schemas |
+| `mcp_url` | `Optional[Union[str, MCPConnection]]` | String or MCPConnection representing the MCP server URL |
+| `mcp_urls` | `List[str]` | List of strings representing multiple MCP server URLs |
+| `react_on` | `bool` | Boolean indicating whether to enable ReAct reasoning |
+| `safety_prompt_on` | `bool` | Boolean indicating whether to enable safety prompts |
+| `random_models_on` | `bool` | Boolean indicating whether to randomly select models |
+| `mcp_config` | `Optional[MCPConnection]` | MCPConnection object containing MCP configuration |
+| `top_p` | `Optional[float]` | Float representing the top-p sampling parameter |
+| `conversation_schema` | `Optional[ConversationSchema]` | ConversationSchema object for conversation formatting |
+| `llm_base_url` | `Optional[str]` | String representing the base URL for the LLM API |
+| `llm_api_key` | `Optional[str]` | String representing the API key for the LLM |
+| `tool_call_summary` | `bool` | Boolean indicating whether to summarize tool calls |
+| `output_raw_json_from_tool_call` | `bool` | Boolean indicating whether to output raw JSON from tool calls |
+| `summarize_multiple_images` | `bool` | Boolean indicating whether to summarize multiple image outputs |
+| `tool_retry_attempts` | `int` | Integer representing the number of retry attempts for tool execution |
+| `reasoning_prompt_on` | `bool` | Boolean indicating whether to enable reasoning prompts |
+| `dynamic_context_window` | `bool` | Boolean indicating whether to dynamically adjust context window |
+| `show_tool_execution_output` | `bool` | Boolean indicating whether to show tool execution output |
+| `created_at` | `float` | Float representing the timestamp when the agent was created |
+| `workspace_dir` | `str` | String representing the workspace directory for the agent |
+| `timeout` | `Optional[int]` | Integer representing the timeout for operations in seconds |
+| `temperature` | `float` | Float representing the temperature for the LLM |
+| `max_tokens` | `int` | Integer representing the maximum number of tokens |
+| `frequency_penalty` | `float` | Float representing the frequency penalty |
+| `presence_penalty` | `float` | Float representing the presence penalty |
+| `tool_system_prompt` | `str` | String representing the system prompt for tools |
+| `log_directory` | `str` | String representing the directory for logs |
+
## `Agent` Methods
| Method | Description | Inputs | Usage Example |
|--------|-------------|--------|----------------|
-| `run(task, img=None, is_last=False, device="cpu", device_id=0, all_cores=True, *args, **kwargs)` | Runs the autonomous agent loop to complete the given task. | `task` (str): The task to be performed.
`img` (str, optional): Path to an image file.
`is_last` (bool): Whether this is the last task.
`device` (str): Device to run on ("cpu" or "gpu").
`device_id` (int): ID of the GPU to use.
`all_cores` (bool): Whether to use all CPU cores.
`*args`, `**kwargs`: Additional arguments. | `response = agent.run("Generate a report on financial performance.")` |
+| `run(task, img=None, imgs=None, correct_answer=None, streaming_callback=None, *args, **kwargs)` | Runs the autonomous agent loop to complete the given task with enhanced parameters. | `task` (str): The task to be performed.
`img` (str, optional): Path to a single image file.
`imgs` (List[str], optional): List of image paths for batch processing.
`correct_answer` (str, optional): Expected correct answer for validation with automatic retries.
`streaming_callback` (Callable, optional): Callback function for real-time token streaming.
`*args`, `**kwargs`: Additional arguments. | `response = agent.run("Generate a report on financial performance.")` |
+| `run_batched(tasks, imgs=None, *args, **kwargs)` | Runs multiple tasks concurrently in batch mode. | `tasks` (List[str]): List of tasks to run.
`imgs` (List[str], optional): List of images to process.
`*args`, `**kwargs`: Additional arguments. | `responses = agent.run_batched(["Task 1", "Task 2"])` |
+| `run_multiple_images(task, imgs, *args, **kwargs)` | Runs the agent with multiple images using concurrent processing. | `task` (str): The task to perform on each image.
`imgs` (List[str]): List of image paths or URLs.
`*args`, `**kwargs`: Additional arguments. | `outputs = agent.run_multiple_images("Describe image", ["img1.jpg", "img2.png"])` |
+| `continuous_run_with_answer(task, img=None, correct_answer=None, max_attempts=10)` | Runs the agent until the correct answer is provided. | `task` (str): The task to perform.
`img` (str, optional): Image to process.
`correct_answer` (str): Expected answer.
`max_attempts` (int): Maximum attempts. | `response = agent.continuous_run_with_answer("Math problem", correct_answer="42")` |
+| `tool_execution_retry(response, loop_count)` | Executes tools with retry logic for handling failures. | `response` (any): Response containing tool calls.
`loop_count` (int): Current loop number. | `agent.tool_execution_retry(response, 1)` |
| `__call__(task, img=None, *args, **kwargs)` | Alternative way to call the `run` method. | Same as `run`. | `response = agent("Generate a report on financial performance.")` |
| `parse_and_execute_tools(response, *args, **kwargs)` | Parses the agent's response and executes any tools mentioned in it. | `response` (str): The agent's response to be parsed.
`*args`, `**kwargs`: Additional arguments. | `agent.parse_and_execute_tools(response)` |
| `add_memory(message)` | Adds a message to the agent's memory. | `message` (str): The message to add. | `agent.add_memory("Important information")` |
@@ -28637,6 +32239,8 @@ graph TD
| `run_concurrent(task, *args, **kwargs)` | Runs a task concurrently. | `task` (str): The task to run.
`*args`, `**kwargs`: Additional arguments. | `response = await agent.run_concurrent("Concurrent task")` |
| `run_concurrent_tasks(tasks, *args, **kwargs)` | Runs multiple tasks concurrently. | `tasks` (List[str]): List of tasks to run.
`*args`, `**kwargs`: Additional arguments. | `responses = agent.run_concurrent_tasks(["Task 1", "Task 2"])` |
| `bulk_run(inputs)` | Generates responses for multiple input sets. | `inputs` (List[Dict[str, Any]]): List of input dictionaries. | `responses = agent.bulk_run([{"task": "Task 1"}, {"task": "Task 2"}])` |
+| `run_multiple_images(task, imgs, *args, **kwargs)` | Runs the agent with multiple images using concurrent processing. | `task` (str): The task to perform on each image.
`imgs` (List[str]): List of image paths or URLs.
`*args`, `**kwargs`: Additional arguments. | `outputs = agent.run_multiple_images("Describe image", ["img1.jpg", "img2.png"])` |
+| `continuous_run_with_answer(task, img=None, correct_answer=None, max_attempts=10)` | Runs the agent until the correct answer is provided. | `task` (str): The task to perform.
`img` (str, optional): Image to process.
`correct_answer` (str): Expected answer.
`max_attempts` (int): Maximum attempts. | `response = agent.continuous_run_with_answer("Math problem", correct_answer="42")` |
| `save()` | Saves the agent's history to a file. | None | `agent.save()` |
| `load(file_path)` | Loads the agent's history from a file. | `file_path` (str): Path to the file. | `agent.load("agent_history.json")` |
| `graceful_shutdown()` | Gracefully shuts down the system, saving the state. | None | `agent.graceful_shutdown()` |
@@ -28660,8 +32264,6 @@ graph TD
| `send_agent_message(agent_name, message, *args, **kwargs)` | Sends a message from the agent to a user. | `agent_name` (str): Name of the agent.
`message` (str): Message to send.
`*args`, `**kwargs`: Additional arguments. | `response = agent.send_agent_message("AgentX", "Task completed")` |
| `add_tool(tool)` | Adds a tool to the agent's toolset. | `tool` (Callable): Tool to add. | `agent.add_tool(my_custom_tool)` |
| `add_tools(tools)` | Adds multiple tools to the agent's toolset. | `tools` (List[Callable]): List of tools to add. | `agent.add_tools([tool1, tool2])` |
-| `remove_tool(tool)` | Removes a tool from the agent's toolset. || Method | Description | Inputs | Usage Example |
-|--------|-------------|--------|----------------|
| `remove_tool(tool)` | Removes a tool from the agent's toolset. | `tool` (Callable): Tool to remove. | `agent.remove_tool(my_custom_tool)` |
| `remove_tools(tools)` | Removes multiple tools from the agent's toolset. | `tools` (List[Callable]): List of tools to remove. | `agent.remove_tools([tool1, tool2])` |
| `get_docs_from_doc_folders()` | Retrieves and processes documents from the specified folder. | None | `agent.get_docs_from_doc_folders()` |
@@ -28690,75 +32292,135 @@ graph TD
| `handle_sop_ops()` | Handles operations related to standard operating procedures. | None | `agent.handle_sop_ops()` |
| `agent_output_type(responses)` | Processes and returns the agent's output based on the specified output type. | `responses` (list): List of responses. | `formatted_output = agent.agent_output_type(responses)` |
| `check_if_no_prompt_then_autogenerate(task)` | Checks if a system prompt is not set and auto-generates one if needed. | `task` (str): The task to use for generating a prompt. | `agent.check_if_no_prompt_then_autogenerate("Analyze data")` |
-| `check_if_no_prompt_then_autogenerate(task)` | Checks if auto_generate_prompt is enabled and generates a prompt by combining agent name, description and system prompt | `task` (str, optional): Task to use as fallback | `agent.check_if_no_prompt_then_autogenerate("Analyze data")` |
| `handle_artifacts(response, output_path, extension)` | Handles saving artifacts from agent execution | `response` (str): Agent response
`output_path` (str): Output path
`extension` (str): File extension | `agent.handle_artifacts(response, "outputs/", ".txt")` |
+| `showcase_config()` | Displays the agent's configuration in a formatted table. | None | `agent.showcase_config()` |
+| `talk_to(agent, task, img=None, *args, **kwargs)` | Initiates a conversation with another agent. | `agent` (Any): Target agent.
`task` (str): Task to discuss.
`img` (str, optional): Image to share.
`*args`, `**kwargs`: Additional arguments. | `response = agent.talk_to(other_agent, "Let's collaborate")` |
+| `talk_to_multiple_agents(agents, task, *args, **kwargs)` | Talks to multiple agents concurrently. | `agents` (List[Any]): List of target agents.
`task` (str): Task to discuss.
`*args`, `**kwargs`: Additional arguments. | `responses = agent.talk_to_multiple_agents([agent1, agent2], "Group discussion")` |
+| `get_agent_role()` | Returns the role of the agent. | None | `role = agent.get_agent_role()` |
+| `pretty_print(response, loop_count)` | Prints the response in a formatted panel. | `response` (str): Response to print.
`loop_count` (int): Current loop number. | `agent.pretty_print("Analysis complete", 1)` |
+| `parse_llm_output(response)` | Parses and standardizes the output from the LLM. | `response` (Any): Response from the LLM. | `parsed_response = agent.parse_llm_output(llm_output)` |
+| `sentiment_and_evaluator(response)` | Performs sentiment analysis and evaluation on the response. | `response` (str): Response to analyze. | `agent.sentiment_and_evaluator("Great response!")` |
+| `output_cleaner_op(response)` | Applies output cleaning operations to the response. | `response` (str): Response to clean. | `cleaned_response = agent.output_cleaner_op(response)` |
+| `mcp_tool_handling(response, current_loop)` | Handles MCP tool execution and responses. | `response` (Any): Response containing tool calls.
`current_loop` (int): Current loop number. | `agent.mcp_tool_handling(response, 1)` |
+| `temp_llm_instance_for_tool_summary()` | Creates a temporary LLM instance for tool summaries. | None | `temp_llm = agent.temp_llm_instance_for_tool_summary()` |
+| `execute_tools(response, loop_count)` | Executes tools based on the LLM response. | `response` (Any): Response containing tool calls.
`loop_count` (int): Current loop number. | `agent.execute_tools(response, 1)` |
+| `list_output_types()` | Returns available output types. | None | `types = agent.list_output_types()` |
+| `tool_execution_retry(response, loop_count)` | Executes tools with retry logic for handling failures. | `response` (Any): Response containing tool calls.
`loop_count` (int): Current loop number. | `agent.tool_execution_retry(response, 1)` |
-## Updated Run Method
+## `Agent.run(*args, **kwargs)`
-Update the run method documentation to include new parameters:
+The `run` method has been significantly enhanced with new parameters for advanced functionality:
-| Method | Description | Inputs | Usage Example |
-|--------|-------------|--------|----------------|
-| `run(task, img=None, is_last=False, device="cpu", device_id=0, all_cores=True, scheduled_run_date=None)` | Runs the agent with specified parameters | `task` (str): Task to run
`img` (str, optional): Image path
`is_last` (bool): If this is last task
`device` (str): Device to use
`device_id` (int): GPU ID
`all_cores` (bool): Use all CPU cores
`scheduled_run_date` (datetime, optional): Future run date | `agent.run("Analyze data", device="gpu", device_id=0)` |
+### Method Signature
+```python
+def run(
+ self,
+ task: Optional[Union[str, Any]] = None,
+ img: Optional[str] = None,
+ imgs: Optional[List[str]] = None,
+ correct_answer: Optional[str] = None,
+ streaming_callback: Optional[Callable[[str], None]] = None,
+ *args,
+ **kwargs,
+) -> Any:
+```
+### Parameters
+| Parameter | Type | Description | Default |
+|-----------|------|-------------|---------|
+| `task` | `Optional[Union[str, Any]]` | The task to be executed | `None` |
+| `img` | `Optional[str]` | Path to a single image file | `None` |
+| `imgs` | `Optional[List[str]]` | List of image paths for batch processing | `None` |
+| `correct_answer` | `Optional[str]` | Expected correct answer for validation with automatic retries | `None` |
+| `streaming_callback` | `Optional[Callable[[str], None]]` | Callback function to receive streaming tokens in real-time | `None` |
+| `*args` | `Any` | Additional positional arguments | - |
+| `**kwargs` | `Any` | Additional keyword arguments | - |
-## Getting Started
+### Examples
-To use the Swarm Agent, first install the required dependencies:
-```bash
-pip3 install -U swarms
-```
+```python
+# --- Enhanced Run Method Examples ---
-Then, you can initialize and use the agent as follows:
+# Basic Usage
+# Simple task execution
+response = agent.run("Generate a report on financial performance.")
-```python
-from swarms.structs.agent import Agent
-from swarms.prompts.finance_agent_sys_prompt import FINANCIAL_AGENT_SYS_PROMPT
+# Single Image Processing
+# Process a single image
+response = agent.run(
+ task="Analyze this image and describe what you see",
+ img="path/to/image.jpg"
+)
-# Initialize the Financial Analysis Agent with GPT-4o-mini model
-agent = Agent(
- agent_name="Financial-Analysis-Agent",
- system_prompt=FINANCIAL_AGENT_SYS_PROMPT,
- model_name="gpt-4o-mini",
- max_loops=1,
- autosave=True,
- dashboard=False,
- verbose=True,
- dynamic_temperature_enabled=True,
- saved_state_path="finance_agent.json",
- user_name="swarms_corp",
- retry_attempts=1,
- context_length=200000,
- return_step_meta=False,
- output_type="str",
+# 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"]
)
-# Run the agent
+# Answer Validation with Retries
+# Run until correct answer is found
response = agent.run(
- "How can I establish a ROTH IRA to buy stocks and get a tax break? What are the criteria?"
+ task="What is the capital of France?",
+ correct_answer="Paris"
)
-print(response)
+# 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
+)
```
-## Advanced Usage
+### Return Types
+
+The `run` method returns different types based on the input parameters:
+
+| Scenario | Return Type | Description |
+|-----------------------|-----------------------------------------------|---------------------------------------------------------|
+| Single task | `str` | Returns the agent's response |
+| Multiple images | `List[Any]` | Returns a list of results, one for each image |
+| Answer validation | `str` | Returns the correct answer as a string |
+| Streaming | `str` | Returns the complete response after streaming completes |
+
+
+
+## Advanced Capabilities
### Tool Integration
-To integrate tools with the Swarm `Agent`, you can pass a list of callable functions with types and doc strings to the `tools` parameter when initializing the `Agent` instance. The agent will automatically convert these functions into an OpenAI function calling schema and make them available for use during task execution.
+The `Agent` class allows seamless integration of external tools by accepting a list of Python functions via the `tools` parameter during initialization. Each tool function must include type annotations and a docstring. The `Agent` class automatically converts these functions into an OpenAI-compatible function calling schema, making them accessible for use during task execution.
+
+Learn more about tools [here](https://docs.swarms.world/en/latest/swarms/tools/tools_examples/)
## Requirements for a tool
-- Function
- - With types
- - with doc strings
+
+| Requirement | Description |
+|---------------------|------------------------------------------------------------------|
+| Function | The tool must be a Python function. |
+| With types | The function must have type annotations for its parameters. |
+| With doc strings | The function must include a docstring describing its behavior. |
+| Must return a string| The function must return a string value. |
```python
from swarms import Agent
-from swarm_models import OpenAIChat
import subprocess
def terminal(code: str):
@@ -28777,7 +32439,7 @@ def terminal(code: str):
# Initialize the agent with a tool
agent = Agent(
agent_name="Terminal-Agent",
- llm=OpenAIChat(api_key=os.getenv("OPENAI_API_KEY")),
+ model_name="claude-sonnet-4-20250514",
tools=[terminal],
system_prompt="You are an agent that can execute terminal commands. Use the tools provided to assist the user.",
)
@@ -28793,7 +32455,6 @@ The Swarm Agent supports integration with vector databases for long-term memory
```python
from swarms import Agent
-from swarm_models import Anthropic
from swarms_memory import ChromaDB
# Initialize ChromaDB
@@ -28805,7 +32466,7 @@ chromadb = ChromaDB(
# Initialize the agent with long-term memory
agent = Agent(
agent_name="Financial-Analysis-Agent",
- llm=Anthropic(anthropic_api_key=os.getenv("ANTHROPIC_API_KEY")),
+ model_name="claude-sonnet-4-20250514",
long_term_memory=chromadb,
system_prompt="You are a financial analysis agent with access to long-term memory.",
)
@@ -28822,7 +32483,7 @@ To enable interactive mode, set the `interactive` parameter to `True` when initi
```python
agent = Agent(
agent_name="Interactive-Agent",
- llm=OpenAIChat(api_key=os.getenv("OPENAI_API_KEY")),
+ model_name="claude-sonnet-4-20250514",
interactive=True,
system_prompt="You are an interactive agent. Engage in a conversation with the user.",
)
@@ -28831,31 +32492,6 @@ agent = Agent(
agent.run("Let's start a conversation")
```
-### Sentiment Analysis
-
-To perform sentiment analysis on the agent's outputs, you can provide a sentiment analyzer function:
-
-```python
-from textblob import TextBlob
-
-def sentiment_analyzer(text):
- analysis = TextBlob(text)
- return analysis.sentiment.polarity
-
-agent = Agent(
- agent_name="Sentiment-Analysis-Agent",
- llm=OpenAIChat(api_key=os.getenv("OPENAI_API_KEY")),
- sentiment_analyzer=sentiment_analyzer,
- sentiment_threshold=0.5,
- system_prompt="You are an agent that generates responses with sentiment analysis.",
-)
-
-response = agent.run("Generate a positive statement about AI")
-print(response)
-```
-
-
-
### Undo Functionality
```python
@@ -28902,9 +32538,79 @@ tasks = [
]
responses = agent.bulk_run(tasks)
print(responses)
+
+# Run multiple tasks in batch mode (new method)
+task_list = ["Analyze data", "Generate report", "Create summary"]
+batch_responses = agent.run_batched(task_list)
+print(f"Completed {len(batch_responses)} tasks in batch mode")
```
+### Batch Processing with `run_batched`
+
+The new `run_batched` method allows you to process multiple tasks efficiently:
+
+#### Method Signature
+
+```python
+def run_batched(
+ self,
+ tasks: List[str],
+ imgs: List[str] = None,
+ *args,
+ **kwargs,
+) -> List[Any]:
+```
+
+#### Parameters
+
+| Parameter | Type | Description | Default |
+|-----------|------|-------------|---------|
+| `tasks` | `List[str]` | List of tasks to run concurrently | Required |
+| `imgs` | `List[str]` | List of images to process with each task | `None` |
+| `*args` | `Any` | Additional positional arguments | - |
+| `**kwargs` | `Any` | Additional keyword arguments | - |
+
+#### Usage Examples
+
+```python
+# Process multiple tasks in batch
+tasks = [
+ "Analyze the financial data for Q1",
+ "Generate a summary report for stakeholders",
+ "Create recommendations for Q2 planning"
+]
+
+# Run all tasks concurrently
+batch_results = agent.run_batched(tasks)
+
+# Process results
+for i, (task, result) in enumerate(zip(tasks, batch_results)):
+ print(f"Task {i+1}: {task}")
+ print(f"Result: {result}\n")
+```
+
+#### Batch Processing with Images
+
+```python
+# Process multiple tasks with multiple images
+tasks = [
+ "Analyze this chart for trends",
+ "Identify patterns in this data visualization",
+ "Summarize the key insights from this graph"
+]
+
+images = ["chart1.png", "chart2.png", "chart3.png"]
+
+# Each task will process all images
+batch_results = agent.run_batched(tasks, imgs=images)
+```
+
+#### Return Type
+
+- **Returns**: `List[Any]` - List of results from each task execution
+- **Order**: Results are returned in the same order as the input tasks
+
### Various other settings
```python
@@ -28960,35 +32666,27 @@ agent.model_dump_json()
print(agent.to_toml())
```
-## Auto Generate Prompt + CPU Execution
+
+## Examples
+
+### Auto Generate Prompt + CPU Execution
```python
import os
from swarms import Agent
-from swarm_models import OpenAIChat
from dotenv import load_dotenv
# Load environment variables
load_dotenv()
-# Retrieve the OpenAI API key from the environment variable
-api_key = os.getenv("GROQ_API_KEY")
-
-# Initialize the model for OpenAI Chat
-model = OpenAIChat(
- openai_api_base="https://api.groq.com/openai/v1",
- openai_api_key=api_key,
- model_name="llama-3.1-70b-versatile",
- temperature=0.1,
-)
-
# Initialize the agent with automated prompt engineering enabled
agent = Agent(
agent_name="Financial-Analysis-Agent",
system_prompt=None, # System prompt is dynamically generated
+ model_name="gpt-4.1",
agent_description=None,
llm=model,
max_loops=1,
@@ -29007,22 +32705,23 @@ agent = Agent(
# Run the agent with a task description and specify the device
agent.run(
"How can I establish a ROTH IRA to buy stocks and get a tax break? What are the criteria",
- ## Will design a system prompt based on the task if description and system prompt are None
- device="cpu",
)
# Print the dynamically generated system prompt
print(agent.system_prompt)
-
```
## Agent Structured Outputs
- Create a structured output schema for the agent [List[Dict]]
+
- Input in the `tools_list_dictionary` parameter
+
- Output is a dictionary
+
- Use the `str_to_dict` function to convert the output to a dictionary
+
```python
from dotenv import load_dotenv
@@ -29093,28 +32792,283 @@ print(type(str_to_dict(out)))
```
+## Comprehensive Agent Configuration Examples
+
+### Advanced Agent with All New Features
+
+```python
+from swarms import Agent
+from swarms_memory import ChromaDB
+from datetime import datetime, timedelta
+
+# Initialize advanced agent with comprehensive configuration
+agent = Agent(
+ # Basic Configuration
+ agent_name="Advanced-Analysis-Agent",
+ agent_description="Multi-modal analysis agent with advanced capabilities",
+ system_prompt="You are an advanced analysis agent capable of processing multiple data types.",
+
+ # Enhanced Run Parameters
+ max_loops=3,
+ dynamic_loops=True,
+ interactive=False,
+ dashboard=True,
+
+ # Device and Resource Management
+ device="gpu",
+ device_id=0,
+ all_cores=True,
+ all_gpus=False,
+ do_not_use_cluster_ops=True,
+
+ # Memory and Context Management
+ context_length=100000,
+ memory_chunk_size=3000,
+ dynamic_context_window=True,
+ rag_every_loop=True,
+
+ # Advanced Features
+ auto_generate_prompt=True,
+ plan_enabled=True,
+ react_on=True,
+ safety_prompt_on=True,
+ reasoning_prompt_on=True,
+
+ # Tool Management
+ tool_retry_attempts=5,
+ tool_call_summary=True,
+ show_tool_execution_output=True,
+ function_calling_format_type="OpenAI",
+
+ # Artifacts and Output
+ artifacts_on=True,
+ artifacts_output_path="./outputs",
+ artifacts_file_extension=".md",
+ output_type="json",
+
+ # LLM Configuration
+ model_name="gpt-4o",
+ temperature=0.3,
+ max_tokens=8000,
+ top_p=0.95,
+ frequency_penalty=0.1,
+ presence_penalty=0.1,
+
+ # MCP Integration
+ mcp_url="http://localhost:8000",
+ mcp_config=None,
+
+ # Performance Settings
+ timeout=300,
+ retry_attempts=3,
+ retry_interval=2,
+
+ # Scheduling
+ scheduled_run_date=datetime.now() + timedelta(hours=1),
+
+ # Metadata and Organization
+ tags=["analysis", "multi-modal", "advanced"],
+ use_cases=[{"name": "Data Analysis", "description": "Process and analyze complex datasets"}],
+
+ # Verbosity and Logging
+ verbose=True,
+ print_on=True,
+ print_every_step=True,
+ log_directory="./logs"
+)
+
+# Run with multiple images and streaming
+def streaming_callback(token: str):
+ print(token, end="", flush=True)
+
+response = agent.run(
+ task="Analyze these financial charts and provide comprehensive insights",
+ imgs=["chart1.png", "chart2.png", "chart3.png"],
+ streaming_callback=streaming_callback
+)
+
+# Run batch processing
+tasks = [
+ "Analyze Q1 financial performance",
+ "Generate Q2 projections",
+ "Create executive summary"
+]
+
+batch_results = agent.run_batched(tasks)
+
+# Run with answer validation
+validated_response = agent.run(
+ task="What is the current market trend?",
+ correct_answer="bullish",
+ max_attempts=5
+)
+```
+
+### MCP-Enabled Agent Example
+
+```python
+from swarms import Agent
+from swarms.schemas.mcp_schemas import MCPConnection
+
+# Configure MCP connection
+mcp_config = MCPConnection(
+ server_path="http://localhost:8000",
+ server_name="my_mcp_server",
+ capabilities=["tools", "filesystem"]
+)
+
+# Initialize agent with MCP integration
+mcp_agent = Agent(
+ agent_name="MCP-Enabled-Agent",
+ system_prompt="You are an agent with access to external tools via MCP.",
+ mcp_config=mcp_config,
+ mcp_urls=["http://localhost:8000", "http://localhost:8001"],
+ tool_call_summary=True,
+ output_raw_json_from_tool_call=True
+)
+
+# Run with MCP tools
+response = mcp_agent.run("Use the available tools to analyze the current system status")
+```
+
+### Multi-Image Processing Agent
+
+```python
+# Initialize agent optimized for image processing
+image_agent = Agent(
+ agent_name="Image-Analysis-Agent",
+ system_prompt="You are an expert at analyzing images and extracting insights.",
+ multi_modal=True,
+ summarize_multiple_images=True,
+ artifacts_on=True,
+ artifacts_output_path="./image_analysis",
+ artifacts_file_extension=".txt"
+)
+
+# Process multiple images with summarization
+images = ["product1.jpg", "product2.jpg", "product3.jpg"]
+analysis = image_agent.run(
+ task="Analyze these product images and identify design patterns",
+ imgs=images
+)
+
+# The agent will automatically summarize results if summarize_multiple_images=True
+print(f"Analysis complete: {len(analysis)} images processed")
+```
+
+## New Features and Parameters
+
+### Enhanced Run Method Parameters
+
+The `run` method now supports several new parameters for advanced functionality:
+
+- **`imgs`**: Process multiple images simultaneously instead of just one
+- **`correct_answer`**: Validate responses against expected answers with automatic retries
+- **`streaming_callback`**: Real-time token streaming for interactive applications
+
+### MCP (Model Context Protocol) Integration
+
+| Parameter | Description |
+|----------------|-----------------------------------------------------|
+| `mcp_url` | Connect to a single MCP server |
+| `mcp_urls` | Connect to multiple MCP servers |
+| `mcp_config` | Advanced MCP configuration options |
+
+### Advanced Reasoning and Safety
+
+| Parameter | Description |
+|----------------------|--------------------------------------------------------------------|
+| `react_on` | Enable ReAct reasoning for complex problem-solving |
+| `safety_prompt_on` | Add safety constraints to agent responses |
+| `reasoning_prompt_on`| Enable multi-loop reasoning for complex tasks |
+
+### Performance and Resource Management
+
+| Parameter | Description |
+|--------------------------|--------------------------------------------------------------------------|
+| `dynamic_context_window` | Automatically adjust context window based on available tokens |
+| `tool_retry_attempts` | Configure retry behavior for tool execution |
+| `summarize_multiple_images` | Automatically summarize results from multiple image processing |
+
+### Device and Resource Management
+
+| Parameter | Description |
+|--------------------------|--------------------------------------------------------------------------|
+| `device` | Specify CPU or GPU execution (`"cpu"` or `"gpu"`) |
+| `device_id` | Specify which GPU device to use |
+| `all_cores` | Enable use of all available CPU cores |
+| `all_gpus` | Enable use of all available GPUs |
+| `do_not_use_cluster_ops` | Control cluster operation usage |
+
+### Advanced Memory and Context
+
+| Parameter | Description |
+|--------------------------|--------------------------------------------------------------------------|
+| `rag_every_loop` | Query RAG database on every loop iteration |
+| `memory_chunk_size` | Control memory chunk size for long-term memory |
+| `auto_generate_prompt` | Automatically generate system prompts based on tasks |
+| `plan_enabled` | Enable planning functionality for complex tasks |
+
+### Artifacts and Output Management
+
+| Parameter | Description |
+|--------------------------|--------------------------------------------------------------------------|
+| `artifacts_on` | Enable saving artifacts from agent execution |
+| `artifacts_output_path` | Specify where to save artifacts |
+| `artifacts_file_extension` | Control artifact file format |
+| `output_raw_json_from_tool_call` | Control tool call output format |
+
+### Enhanced Tool Management
+
+| Parameter | Description |
+|--------------------------|--------------------------------------------------------------------------|
+| `tools_list_dictionary` | Provide tool schemas in dictionary format |
+| `tool_call_summary` | Enable automatic summarization of tool calls |
+| `show_tool_execution_output` | Control visibility of tool execution details |
+| `function_calling_format_type` | Specify function calling format (OpenAI, etc.) |
+
+### Advanced LLM Configuration
+
+| Parameter | Description |
+|--------------------------|--------------------------------------------------------------------------|
+| `llm_args` | Pass additional arguments to the LLM |
+| `llm_base_url` | Specify custom LLM API endpoint |
+| `llm_api_key` | Provide LLM API key directly |
+| `top_p` | Control top-p sampling parameter |
+| `frequency_penalty` | Control frequency penalty |
+| `presence_penalty` | Control presence penalty |
+
+
+
+
## Best Practices
-1. Always provide a clear and concise `system_prompt` to guide the agent's behavior.
-2. Use `tools` to extend the agent's capabilities for specific tasks.
-3. Implement error handling and utilize the `retry_attempts` feature for robust execution.
-4. Leverage `long_term_memory` for tasks that require persistent information.
-5. Use `interactive` mode for real-time conversations and `dashboard` for monitoring.
-6. Implement `sentiment_analysis` for applications requiring tone management.
-7. Utilize `autosave` and `save`/`load` methods for continuity across sessions.
-8. Optimize token usage with `dynamic_context_window` and `tokens_checks` methods.
-9. Use `concurrent` and `async` methods for performance-critical applications.
-10. Regularly review and analyze feedback using the `analyze_feedback` method.
-11. Use `artifacts_on` to save important outputs from agent execution
-12. Configure `device` and `device_id` appropriately for optimal performance
-13. Enable `rag_every_loop` when continuous context from long-term memory is needed
-14. Use `scheduled_run_date` for automated task scheduling
+| Best Practice / Feature | Description |
+|---------------------------------------------------------|--------------------------------------------------------------------------------------------------|
+| `system_prompt` | Always provide a clear and concise system prompt to guide the agent's behavior. |
+| `tools` | Use tools to extend the agent's capabilities for specific tasks. |
+| `retry_attempts` & error handling | Implement error handling and utilize the retry_attempts feature for robust execution. |
+| `long_term_memory` | Leverage long_term_memory for tasks that require persistent information. |
+| `interactive` & `dashboard` | Use interactive mode for real-time conversations and dashboard for monitoring. |
+| `sentiment_analysis` | Implement sentiment_analysis for applications requiring tone management. |
+| `autosave`, `save`/`load` | Utilize autosave and save/load methods for continuity across sessions. |
+| `dynamic_context_window` & `tokens_checks` | Optimize token usage with dynamic_context_window and tokens_checks methods. |
+| `concurrent` & `async` methods | Use concurrent and async methods for performance-critical applications. |
+| `analyze_feedback` | Regularly review and analyze feedback using the analyze_feedback method. |
+| `artifacts_on` | Use artifacts_on to save important outputs from agent execution. |
+| `device` & `device_id` | Configure device and device_id appropriately for optimal performance. |
+| `rag_every_loop` | Enable rag_every_loop when continuous context from long-term memory is needed. |
+| `scheduled_run_date` | Use scheduled_run_date for automated task scheduling. |
+| `run_batched` | Leverage run_batched for efficient processing of multiple related tasks. |
+| `mcp_url` or `mcp_urls` | Use mcp_url or mcp_urls to extend agent capabilities with external tools. |
+| `react_on` | Enable react_on for complex reasoning tasks requiring step-by-step analysis. |
+| `tool_retry_attempts` | Configure tool_retry_attempts for robust tool execution in production environments. |
By following these guidelines and leveraging the Swarm Agent's extensive features, you can create powerful, flexible, and efficient autonomous agents for a wide range of applications.
--------------------------------------------------
-# File: swarms\structs\agent_docs_v1.md
+# File: swarms/structs/agent_docs_v1.md
# `Agent` Documentation
@@ -29654,7 +33608,7 @@ print(agent.to_toml())
--------------------------------------------------
-# File: swarms\structs\agent_mcp.md
+# File: swarms/structs/agent_mcp.md
# Agent MCP Integration Guide
@@ -30452,7 +34406,7 @@ The MCP integration brings powerful external tool connectivity to Swarms agents,
--------------------------------------------------
-# File: swarms\structs\agent_multi_agent_communication.md
+# File: swarms/structs/agent_multi_agent_communication.md
# Agent Multi-Agent Communication Methods
@@ -30662,11 +34616,11 @@ This comprehensive guide covers all aspects of multi-agent communication using t
--------------------------------------------------
-# File: swarms\structs\agent_rearrange.md
+# File: swarms/structs/agent_rearrange.md
# `AgentRearrange` Class
-The `AgentRearrange` class represents a swarm of agents for rearranging tasks. It allows you to create a swarm of agents, add or remove agents from the swarm, and run the swarm to process tasks based on a specified flow pattern.
+The `AgentRearrange` class represents a swarm of agents for rearranging tasks. It allows you to create a swarm of agents, add or remove agents from the swarm, and run the swarm to process tasks based on a specified flow pattern. The class now includes **sequential awareness** features that allow agents to know about the agents ahead and behind them in sequential flows.
## Attributes
----------
@@ -30683,26 +34637,38 @@ The `AgentRearrange` class represents a swarm of agents for rearranging tasks. I
| `memory_system` | `BaseVectorDatabase` | Memory system for storing agent interactions |
| `human_in_the_loop` | `bool` | Whether human intervention is enabled |
| `custom_human_in_the_loop` | `Callable` | Custom function for human intervention |
-| `return_json` | `bool` | Whether to return output in JSON format |
| `output_type` | `OutputType` | Format of output ("all", "final", "list", or "dict") |
-| `docs` | `List[str]` | List of document paths to add to agent prompts |
-| `doc_folder` | `str` | Folder path containing documents to add to agent prompts |
-| `swarm_history` | `dict` | History of agent interactions |
-
+| `autosave` | `bool` | Whether to automatically save agent data |
+| `rules` | `str` | Custom rules to add to the conversation |
+| `team_awareness` | `bool` | Whether to enable team awareness and sequential flow information |
+| `time_enabled` | `bool` | Whether to enable timestamps in conversation |
+| `message_id_on` | `bool` | Whether to enable message IDs in conversation |
## Methods
-------
-### `__init__(self, agents: List[Agent] = None, flow: str = None, max_loops: int = 1, verbose: bool = True)`
+### `__init__(self, id: str = swarm_id(), name: str = "AgentRearrange", description: str = "A swarm of agents for rearranging tasks.", agents: List[Union[Agent, Callable]] = None, flow: str = None, max_loops: int = 1, verbose: bool = True, memory_system: Any = None, human_in_the_loop: bool = False, custom_human_in_the_loop: Optional[Callable[[str], str]] = None, output_type: OutputType = "all", autosave: bool = True, rules: str = None, team_awareness: bool = False, time_enabled: bool = False, message_id_on: bool = False, *args, **kwargs)`
-Initializes the `AgentRearrange` object.
+Initializes the `AgentRearrange` object with enhanced sequential awareness capabilities.
| Parameter | Type | Description |
| --- | --- | --- |
-| `agents` | `List[Agent]` (optional) | A list of `Agent` objects. Defaults to `None`. |
+| `id` | `str` (optional) | Unique identifier for the swarm. Defaults to auto-generated UUID. |
+| `name` | `str` (optional) | Name of the swarm. Defaults to "AgentRearrange". |
+| `description` | `str` (optional) | Description of the swarm's purpose. Defaults to "A swarm of agents for rearranging tasks.". |
+| `agents` | `List[Union[Agent, Callable]]` (optional) | A list of `Agent` objects or callables. Defaults to `None`. |
| `flow` | `str` (optional) | The flow pattern of the tasks. Defaults to `None`. |
| `max_loops` | `int` (optional) | The maximum number of loops for the agents to run. Defaults to `1`. |
| `verbose` | `bool` (optional) | Whether to enable verbose logging or not. Defaults to `True`. |
+| `memory_system` | `Any` (optional) | Memory system for storing agent interactions. Defaults to `None`. |
+| `human_in_the_loop` | `bool` (optional) | Whether human intervention is enabled. Defaults to `False`. |
+| `custom_human_in_the_loop` | `Callable[[str], str]` (optional) | Custom function for human intervention. Defaults to `None`. |
+| `output_type` | `OutputType` (optional) | Format of output. Defaults to `"all"`. |
+| `autosave` | `bool` (optional) | Whether to automatically save agent data. Defaults to `True`. |
+| `rules` | `str` (optional) | Custom rules to add to the conversation. Defaults to `None`. |
+| `team_awareness` | `bool` (optional) | Whether to enable team awareness and sequential flow information. Defaults to `False`. |
+| `time_enabled` | `bool` (optional) | Whether to enable timestamps in conversation. Defaults to `False`. |
+| `message_id_on` | `bool` (optional) | Whether to enable message IDs in conversation. Defaults to `False`. |
### `add_agent(self, agent: Agent)`
@@ -30740,54 +34706,130 @@ Validates the flow pattern.
- `bool`: `True` if the flow pattern is valid.
-### `run(self, task: str = None, img: str = None, device: str = "cpu", device_id: int = 1, all_cores: bool = True, all_gpus: bool = False, *args, **kwargs)`
+### **Sequential Awareness Methods**
+
+#### `get_agent_sequential_awareness(self, agent_name: str) -> str`
+
+Gets the sequential awareness information for a specific agent, showing which agents come before and after in the sequence.
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| `agent_name` | `str` | The name of the agent to get awareness for. |
+
+**Returns:**
+
+- `str`: A string describing the agents ahead and behind in the sequence.
+
+**Example:**
+```python
+awareness = agent_system.get_agent_sequential_awareness("Agent2")
+# Returns: "Sequential awareness: Agent ahead: Agent1 | Agent behind: Agent3"
+```
+
+#### `get_sequential_flow_structure(self) -> str`
+
+Gets the overall sequential flow structure information showing the complete workflow with relationships between agents.
+
+**Returns:**
+
+- `str`: A string describing the complete sequential flow structure.
+
+**Example:**
+```python
+flow_structure = agent_system.get_sequential_flow_structure()
+# Returns: "Sequential Flow Structure:
+# Step 1: Agent1
+# Step 2: Agent2 (follows: Agent1) (leads to: Agent3)
+# Step 3: Agent3 (follows: Agent2)"
+```
+
+### `run(self, task: str = None, img: str = None, *args, **kwargs)`
Executes the agent rearrangement task with specified compute resources.
| Parameter | Type | Description |
| --- | --- | --- |
-| `task` | `str` | The task to execute |
-| `img` | `str` | Path to input image if required |
-| `device` | `str` | Computing device to use ('cpu' or 'gpu') |
-| `device_id` | `int` | ID of specific device to use |
-| `all_cores` | `bool` | Whether to use all CPU cores |
-| `all_gpus` | `bool` | Whether to use all available GPUs |
+| `task` | `str` (optional) | The task to execute. Defaults to `None`. |
+| `img` | `str` (optional) | Path to input image if required. Defaults to `None`. |
+| `*args` | - | Additional positional arguments passed to `_run()`. |
+| `**kwargs` | - | Additional keyword arguments passed to `_run()`. |
**Returns:**
-- `str`: The final processed task.
+- The result from executing the task through the cluster operations wrapper.
-### `batch_run(self, tasks: List[str], img: Optional[List[str]] = None, batch_size: int = 10, device: str = "cpu", device_id: int = None, all_cores: bool = True, all_gpus: bool = False, *args, **kwargs)`
+### `batch_run(self, tasks: List[str], img: Optional[List[str]] = None, batch_size: int = 10, *args, **kwargs)`
Process multiple tasks in batches.
| Parameter | Type | Description |
| --- | --- | --- |
| `tasks` | `List[str]` | List of tasks to process |
-| `img` | `List[str]` | Optional list of images corresponding to tasks |
+| `img` | `List[str]` (optional) | Optional list of images corresponding to tasks |
| `batch_size` | `int` | Number of tasks to process simultaneously |
-| `device` | `str` | Computing device to use |
-| `device_id` | `int` | Specific device ID if applicable |
-| `all_cores` | `bool` | Whether to use all CPU cores |
-| `all_gpus` | `bool` | Whether to use all available GPUs |
+| `*args` | - | Additional positional arguments |
+| `**kwargs` | - | Additional keyword arguments |
+**Returns:**
+- `List[str]`: List of results corresponding to input tasks
-### `concurrent_run(self, tasks: List[str], img: Optional[List[str]] = None, max_workers: Optional[int] = None, device: str = "cpu", device_id: int = None, all_cores: bool = True, all_gpus: bool = False, *args, **kwargs)`
+### `concurrent_run(self, tasks: List[str], img: Optional[List[str]] = None, max_workers: Optional[int] = None, *args, **kwargs)`
Process multiple tasks concurrently using ThreadPoolExecutor.
| Parameter | Type | Description |
| --- | --- | --- |
| `tasks` | `List[str]` | List of tasks to process |
-| `img` | `List[str]` | Optional list of images corresponding to tasks |
-| `max_workers` | `int` | Maximum number of worker threads |
-| `device` | `str` | Computing device to use |
-| `device_id` | `int` | Specific device ID if applicable |
-| `all_cores` | `bool` | Whether to use all CPU cores |
-| `all_gpus` | `bool` | Whether to use all available GPUs |
+| `img` | `List[str]` (optional) | Optional list of images corresponding to tasks |
+| `max_workers` | `int` (optional) | Maximum number of worker threads |
+| `*args` | - | Additional positional arguments |
+| `**kwargs` | - | Additional keyword arguments |
+
+**Returns:**
+
+- `List[str]`: List of results corresponding to input tasks
+## **Sequential Awareness Feature**
+
+The `AgentRearrange` class now includes a powerful **sequential awareness** feature that enhances agent collaboration in sequential workflows. When agents are executed sequentially, they automatically receive information about:
+
+- **Agent ahead**: The agent that completed their task before them
+- **Agent behind**: The agent that will receive their output next
+
+This feature is automatically enabled when using sequential flows and provides agents with context about their position in the workflow, improving coordination and task understanding.
+
+### How It Works
+
+1. **Automatic Detection**: The system automatically detects when agents are running sequentially vs. in parallel
+2. **Context Injection**: Before each sequential agent runs, awareness information is added to the conversation
+3. **Enhanced Collaboration**: Agents can reference previous agents' work and prepare output for the next agent
+
+### Example with Sequential Awareness
+
+```python
+from swarms import Agent, AgentRearrange
+
+# Create agents
+agent1 = Agent(agent_name="Researcher", system_prompt="Research the topic")
+agent2 = Agent(agent_name="Writer", system_prompt="Write based on research")
+agent3 = Agent(agent_name="Editor", system_prompt="Edit the written content")
+
+# Create sequential workflow
+workflow = AgentRearrange(
+ agents=[agent1, agent2, agent3],
+ flow="Researcher -> Writer -> Editor",
+ team_awareness=True # Enables sequential awareness
+)
+
+# Run the workflow
+result = workflow.run("Research and write about artificial intelligence")
+```
+**What happens automatically:**
+- **Researcher** runs first (no awareness info needed)
+- **Writer** receives: "Sequential awareness: Agent ahead: Researcher | Agent behind: Editor"
+- **Editor** receives: "Sequential awareness: Agent ahead: Writer"
## Documentation for `rearrange` Function
======================================
@@ -30799,9 +34841,12 @@ The `rearrange` function is a helper function that rearranges the given list of
| Parameter | Type | Description |
| --- | --- | --- |
+| `name` | `str` (optional) | Name for the agent system. Defaults to `None`. |
+| `description` | `str` (optional) | Description for the agent system. Defaults to `None`. |
| `agents` | `List[Agent]` | The list of agents to be rearranged. |
| `flow` | `str` | The flow used for rearranging the agents. |
| `task` | `str` (optional) | The task to be performed during rearrangement. Defaults to `None`. |
+| `img` | `str` (optional) | Path to input image if required. Defaults to `None`. |
| `*args` | - | Additional positional arguments. |
| `**kwargs` | - | Additional keyword arguments. |
@@ -30823,7 +34868,7 @@ rearrange(agents, flow, task)
### Example Usage
-------------
-Here's an example of how to use the `AgentRearrange` class and the `rearrange` function:
+Here's an example of how to use the `AgentRearrange` class and the `rearrange` function with the new sequential awareness features:
```python
from swarms import Agent, AgentRearrange
@@ -30877,20 +34922,35 @@ agents = [director, worker1, worker2]
# Define the flow pattern
flow = "Accounting Director -> Accountant 1 -> Accountant 2"
-# Using AgentRearrange class
-agent_system = AgentRearrange(agents=agents, flow=flow)
+# Using AgentRearrange class with sequential awareness
+agent_system = AgentRearrange(
+ agents=agents,
+ flow=flow,
+ team_awareness=True, # Enables sequential awareness
+ time_enabled=True, # Enable timestamps
+ message_id_on=True # Enable message IDs
+)
+
+# Get sequential flow information
+flow_structure = agent_system.get_sequential_flow_structure()
+print("Flow Structure:", flow_structure)
+
+# Get awareness for specific agents
+worker1_awareness = agent_system.get_agent_sequential_awareness("Accountant 1")
+print("Worker1 Awareness:", worker1_awareness)
+
+# Run the workflow
output = agent_system.run("Process monthly financial statements")
print(output)
-
```
In this example, we first initialize three agents: `director`, `worker1`, and `worker2`. Then, we create a list of these agents and define the flow pattern `"Director -> Worker1 -> Worker2"`.
-We can use the `AgentRearrange` class by creating an instance of it with the list of agents and the flow pattern. We then call the `run` method with the initial task, and it will execute the agents in the specified order, passing the output of one agent as the input to the next agent.
-
-Alternatively, we can use the `rearrange` function by passing the list of agents, the flow pattern, and the initial task as arguments.
-
-Both the `AgentRearrange` class and the `rearrange` function will return the final output after processing the task through the agents according to the specified flow pattern.
+The new sequential awareness features provide:
+- **Automatic context**: Each agent knows who came before and who comes after
+- **Better coordination**: Agents can reference previous work and prepare for next steps
+- **Flow visualization**: You can see the complete workflow structure
+- **Enhanced logging**: Better tracking of agent interactions
## Error Handling
--------------
@@ -30908,70 +34968,77 @@ output = agent_system.run("Some task")`
This will raise a `ValueError` with the message `"Agent 'Worker3' is not registered."`.
-
## Parallel and Sequential Processing
----------------------------------
-The `AgentRearrange` class supports both parallel and sequential processing of tasks based on the specified flow pattern. If the flow pattern includes multiple agents separated by commas (e.g., `"agent1, agent2"`), the agents will be executed in parallel, and their outputs will be concatenated with a semicolon (`;`). If the flow pattern includes a single agent, it will be executed sequentially.
-
+The `AgentRearrange` class supports both parallel and sequential processing of tasks based on the specified flow pattern. If the flow pattern includes multiple agents separated by commas (e.g., `"agent1, agent2"`), the agents will be executed in parallel, and their outputs will be concatenated. If the flow pattern includes a single agent, it will be executed sequentially with enhanced awareness.
### Parallel processing
`parallel_flow = "Worker1, Worker2 -> Director"`
-### Sequential processing
+### Sequential processing with awareness
`sequential_flow = "Worker1 -> Worker2 -> Director"`
-In the `parallel_flow` example, `Worker1` and `Worker2` will be executed in parallel, and their outputs will be concatenated and passed to `Director`. In the `sequential_flow` example, `Worker1` will be executed first, and its output will be passed to `Worker2`, and then the output of `Worker2` will be passed to `Director`.
+In the `parallel_flow` example, `Worker1` and `Worker2` will be executed in parallel, and their outputs will be concatenated and passed to `Director`.
-## Logging
--------
+In the `sequential_flow` example, `Worker1` will be executed first, then `Worker2` will receive awareness that `Worker1` came before and `Director` comes after, and finally `Director` will receive awareness that `Worker2` came before.
-The `AgentRearrange` class includes logging capabilities using the `loguru` library. If `verbose` is set to `True` during initialization, a log file named `agent_rearrange.log` will be created, and log messages will be written to it. You can use this log file to track the execution of the agents and any potential issues or errors that may occur.
+## Logging and Monitoring
+-------
+The `AgentRearrange` class includes comprehensive logging capabilities using the `loguru` library. The new sequential awareness features add enhanced logging:
```bash
2023-05-08 10:30:15.456 | INFO | agent_rearrange:__init__:34 - Adding agent Director to the swarm.
2023-05-08 10:30:15.457 | INFO | agent_rearrange:__init__:34 - Adding agent Worker1 to the swarm.
2023-05-08 10:30:15.457 | INFO | agent_rearrange:__init__:34 - Adding agent Worker2 to the swarm.
2023-05-08 10:30:15.458 | INFO | agent_rearrange:run:118 - Running agents in parallel: ['Worker1', 'Worker2']
-2023-05-08 10:30:15.459 | INFO | agent_rearrange:run:121 - Running agents sequentially: ['Director']`
+2023-05-08 10:30:15.459 | INFO | agent_rearrange:run:121 - Running agents sequentially: ['Director']
+2023-05-08 10:30:15.460 | INFO | agent_rearrange:run:125 - Added sequential awareness for Worker2: Sequential awareness: Agent ahead: Worker1 | Agent behind: Director
```
## Additional Parameters
---------------------
-The `AgentRearrange` class also accepts additional parameters that can be passed to the `run` method using `*args` and `**kwargs`. These parameters will be forwarded to the individual agents during execution.
-
-`agent_system = AgentRearrange(agents=agents, flow=flow)`
-`output = agent_system.run("Some task", max_tokens=200, temperature=0.7)`
+The `AgentRearrange` class now accepts additional parameters for enhanced functionality:
-In this example, the `max_tokens` and `temperature` parameters will be passed to each agent during execution.
+```python
+agent_system = AgentRearrange(
+ agents=agents,
+ flow=flow,
+ team_awareness=True, # Enable sequential awareness
+ time_enabled=True, # Enable conversation timestamps
+ message_id_on=True, # Enable message IDs
+ verbose=True # Enable detailed logging
+)
+```
## Customization
-------------
-The `AgentRearrange` class and the `rearrange` function can be customized and extended to suit specific use cases. For example, you can create custom agents by inheriting from the `Agent` class and implementing custom logic for task processing. You can then add these custom agents to the swarm and define the flow pattern accordingly.
-
-Additionally, you can modify the `run` method of the `AgentRearrange` class to implement custom logic for task processing and agent interaction.
-
+The `AgentRearrange` class and the `rearrange` function can be customized and extended to suit specific use cases. The new sequential awareness features provide a foundation for building more sophisticated agent coordination systems.
## Limitations
-----------
-It's important to note that the `AgentRearrange` class and the `rearrange` function rely on the individual agents to process tasks correctly. The quality of the output will depend on the capabilities and configurations of the agents used in the swarm. Additionally, the `AgentRearrange` class does not provide any mechanisms for task prioritization or load balancing among the agents.
+It's important to note that the `AgentRearrange` class and the `rearrange` function rely on the individual agents to process tasks correctly. The quality of the output will depend on the capabilities and configurations of the agents used in the swarm.
+
+The sequential awareness feature works best with agents that can understand and utilize context about their position in the workflow.
## Conclusion
----------
-The `AgentRearrange` class and the `rearrange` function provide a flexible and extensible framework for orchestrating swarms of agents to process tasks based on a specified flow pattern. By combining the capabilities of individual agents, you can create complex workflows and leverage the strengths of different agents to tackle various tasks efficiently.
+The `AgentRearrange` class and the `rearrange` function provide a flexible and extensible framework for orchestrating swarms of agents to process tasks based on a specified flow pattern. The new **sequential awareness** features significantly enhance agent collaboration by providing context about workflow relationships.
+
+By combining the capabilities of individual agents with enhanced awareness of their position in the workflow, you can create more intelligent and coordinated multi-agent systems that understand not just their individual tasks, but also their role in the larger workflow.
+
+Whether you're working on natural language processing tasks, data analysis, or any other domain where agent-based systems can be beneficial, the enhanced `AgentRearrange` class provides a solid foundation for building sophisticated swarm-based solutions with improved coordination and context awareness.
-While the current implementation offers basic functionality for agent rearrangement, there is room for future improvements and customizations to enhance the system's capabilities and cater to more specific use cases.
-Whether you're working on natural language processing tasks, data analysis, or any other domain where agent-based systems can be beneficial, the `AgentRearrange` class and the `rearrange` function provide a solid foundation for building and experimenting with swarm-based solutions.
--------------------------------------------------
-# File: swarms\structs\agent_registry.md
+# File: swarms/structs/agent_registry.md
# AgentRegistry Documentation
@@ -31216,7 +35283,7 @@ Each method in the `AgentRegistry` class includes logging to track the execution
--------------------------------------------------
-# File: swarms\structs\artifact.md
+# File: swarms/structs/artifact.md
# swarms.structs Documentation
@@ -31325,7 +35392,7 @@ This comprehensive documentation provides an in-depth understanding of the `Arti
--------------------------------------------------
-# File: swarms\structs\auto_agent_builder.md
+# File: swarms/structs/auto_agent_builder.md
# Agent Builder
@@ -31531,7 +35598,7 @@ Common issues and solutions:
--------------------------------------------------
-# File: swarms\structs\auto_swarm.md
+# File: swarms/structs/auto_swarm.md
# AutoSwarm
@@ -31727,7 +35794,7 @@ The `AutoSwarm` class provides a robust framework for managing and executing tas
--------------------------------------------------
-# File: swarms\structs\auto_swarm_builder.md
+# File: swarms/structs/auto_swarm_builder.md
# AutoSwarmBuilder Documentation
@@ -31912,7 +35979,7 @@ results = swarm.batch_run(tasks)
--------------------------------------------------
-# File: swarms\structs\auto_swarm_router.md
+# File: swarms/structs/auto_swarm_router.md
# AutoSwarmRouter
@@ -32082,7 +36149,7 @@ The `AutoSwarmRouter` class provides a flexible and customizable approach to rou
--------------------------------------------------
-# File: swarms\structs\basestructure.md
+# File: swarms/structs/basestructure.md
# Module/Function Name: BaseStructure
@@ -32225,7 +36292,7 @@ Please let me know if you need further elaboration on any specific aspect or fun
--------------------------------------------------
-# File: swarms\structs\concurrentworkflow.md
+# File: swarms/structs/concurrentworkflow.md
# ConcurrentWorkflow Documentation
@@ -32496,7 +36563,7 @@ except Exception as e:
--------------------------------------------------
-# File: swarms\structs\conversation.md
+# File: swarms/structs/conversation.md
# Module/Class Name: Conversation
@@ -32506,96 +36573,33 @@ The `Conversation` class is a powerful and flexible tool for managing conversati
### Key Features
-- **Multiple Storage Backends**: Support for various storage solutions:
- - In-memory: Fast, temporary storage for testing and development
- - Supabase: PostgreSQL-based cloud storage with real-time capabilities
- - Redis: High-performance caching and persistence
- - SQLite: Local file-based storage
- - DuckDB: Analytical workloads and columnar storage
- - Pulsar: Event streaming for distributed systems
- - Mem0: Memory-based storage with mem0 integration
-
-- **Token Management**:
- - Built-in token counting with configurable models
- - Automatic token tracking for input/output messages
- - Token usage analytics and reporting
- - Context length management
-
-- **Metadata and Categories**:
- - Support for message metadata
- - Message categorization (input/output)
- - Role-based message tracking
- - Custom message IDs
-
-- **Data Export/Import**:
- - JSON and YAML export formats
- - Automatic saving and loading
- - Conversation history management
- - Batch operations support
-
-- **Advanced Features**:
- - Message search and filtering
- - Conversation analytics
- - Multi-agent support
- - Error handling and fallbacks
- - Type hints and validation
+| Feature Category | Features / Description |
+|----------------------------|-------------------------------------------------------------------------------------------------------------|
+| **Multiple Storage Backends** | - In-memory: Fast, temporary storage for testing and development
- Supabase: PostgreSQL-based cloud storage with real-time capabilities
- Redis: High-performance caching and persistence
- SQLite: Local file-based storage
- DuckDB: Analytical workloads and columnar storage
- Pulsar: Event streaming for distributed systems
- Mem0: Memory-based storage with mem0 integration |
+| **Token Management** | - Built-in token counting with configurable models
- Automatic token tracking for input/output messages
- Token usage analytics and reporting
- Context length management |
+| **Metadata and Categories** | - Support for message metadata
- Message categorization (input/output)
- Role-based message tracking
- Custom message IDs |
+| **Data Export/Import** | - JSON and YAML export formats
- Automatic saving and loading
- Conversation history management
- Batch operations support |
+| **Advanced Features** | - Message search and filtering
- Conversation analytics
- Multi-agent support
- Error handling and fallbacks
- Type hints and validation |
### Use Cases
-1. **Chatbot Development**:
- - Store and manage conversation history
- - Track token usage and context length
- - Analyze conversation patterns
-
-2. **Multi-Agent Systems**:
- - Coordinate multiple AI agents
- - Track agent interactions
- - Store agent outputs and metadata
-
-3. **Analytics Applications**:
- - Track conversation metrics
- - Generate usage reports
- - Analyze user interactions
-
-4. **Production Systems**:
- - Persistent storage with various backends
- - Error handling and recovery
- - Scalable conversation management
-
-5. **Development and Testing**:
- - Fast in-memory storage
- - Debugging support
- - Easy export/import of test data
+| Use Case | Features / Description |
+|----------------------------|--------------------------------------------------------------------------------------------------------|
+| **Chatbot Development** | - Store and manage conversation history
- Track token usage and context length
- Analyze conversation patterns |
+| **Multi-Agent Systems** | - Coordinate multiple AI agents
- Track agent interactions
- Store agent outputs and metadata |
+| **Analytics Applications** | - Track conversation metrics
- Generate usage reports
- Analyze user interactions |
+| **Production Systems** | - Persistent storage with various backends
- Error handling and recovery
- Scalable conversation management |
+| **Development and Testing**| - Fast in-memory storage
- Debugging support
- Easy export/import of test data |
### Best Practices
-1. **Storage Selection**:
- - Use in-memory for testing and development
- - Choose Supabase for multi-user cloud applications
- - Use Redis for high-performance requirements
- - Select SQLite for single-user local applications
- - Pick DuckDB for analytical workloads
- - Opt for Pulsar in distributed systems
-
-2. **Token Management**:
- - Enable token counting for production use
- - Set appropriate context lengths
- - Monitor token usage with export_and_count_categories()
-
-3. **Error Handling**:
- - Implement proper fallback mechanisms
- - Use type hints for better code reliability
- - Monitor and log errors appropriately
-
-4. **Data Management**:
- - Use appropriate export formats (JSON/YAML)
- - Implement regular backup strategies
- - Clean up old conversations when needed
-
-5. **Security**:
- - Use environment variables for sensitive credentials
- - Implement proper access controls
- - Validate input data
+| Category | Best Practices |
+|---------------------|------------------------------------------------------------------------------------------------------------------------|
+| **Storage Selection** | - Use in-memory for testing and development
- Choose Supabase for multi-user cloud applications
- Use Redis for high-performance requirements
- Select SQLite for single-user local applications
- Pick DuckDB for analytical workloads
- Opt for Pulsar in distributed systems |
+| **Token Management** | - Enable token counting for production use
- Set appropriate context lengths
- Monitor token usage with `export_and_count_categories()` |
+| **Error Handling** | - Implement proper fallback mechanisms
- Use type hints for better code reliability
- Monitor and log errors appropriately |
+| **Data Management** | - Use appropriate export formats (JSON/YAML)
- Implement regular backup strategies
- Clean up old conversations when needed |
+| **Security** | - Use environment variables for sensitive credentials
- Implement proper access controls
- Validate input data |
## Table of Contents
@@ -32613,13 +36617,15 @@ The `Conversation` class is designed to manage conversations by keeping track of
**New in this version**: The class now supports multiple storage backends for persistent conversation storage:
-- **"in-memory"**: Default memory-based storage (no persistence)
-- **"mem0"**: Memory-based storage with mem0 integration (requires: `pip install mem0ai`)
-- **"supabase"**: PostgreSQL-based storage using Supabase (requires: `pip install supabase`)
-- **"redis"**: Redis-based storage (requires: `pip install redis`)
-- **"sqlite"**: SQLite-based storage (built-in to Python)
-- **"duckdb"**: DuckDB-based storage (requires: `pip install duckdb`)
-- **"pulsar"**: Apache Pulsar messaging backend (requires: `pip install pulsar-client`)
+| Backend | Description | Requirements |
+|--------------|-------------------------------------------------------------------------------------------------------------|------------------------------------|
+| **in-memory**| Default memory-based storage (no persistence) | None (built-in) |
+| **mem0** | Memory-based storage with mem0 integration | `pip install mem0ai` |
+| **supabase** | PostgreSQL-based storage using Supabase | `pip install supabase` |
+| **redis** | Redis-based storage | `pip install redis` |
+| **sqlite** | SQLite-based storage (local file) | None (built-in) |
+| **duckdb** | DuckDB-based storage (analytical workloads, columnar storage) | `pip install duckdb` |
+| **pulsar** | Apache Pulsar messaging backend | `pip install pulsar-client` |
All backends use **lazy loading** - database dependencies are only imported when the specific backend is instantiated. Each backend provides helpful error messages if required packages are not installed.
@@ -32632,7 +36638,6 @@ All backends use **lazy loading** - database dependencies are only imported when
| system_prompt | Optional[str] | System prompt for the conversation |
| time_enabled | bool | Flag to enable time tracking for messages |
| autosave | bool | Flag to enable automatic saving |
-| save_enabled | bool | Flag to control if saving is enabled |
| save_filepath | str | File path for saving conversation history |
| load_filepath | str | File path for loading conversation history |
| conversation_history | list | List storing conversation messages |
@@ -33578,7 +37583,7 @@ Choose the appropriate backend based on your needs:
--------------------------------------------------
-# File: swarms\structs\council_of_judges.md
+# File: swarms/structs/council_of_judges.md
# CouncilAsAJudge
@@ -33867,7 +37872,7 @@ print(evaluation)
--------------------------------------------------
-# File: swarms\structs\create_new_swarm.md
+# File: swarms/structs/create_new_swarm.md
# How to Add a New Swarm Class
@@ -34083,7 +38088,7 @@ By following these guidelines, you can create swarms that are powerful, flexible
--------------------------------------------------
-# File: swarms\structs\cron_job.md
+# File: swarms/structs/cron_job.md
# CronJob
@@ -34209,6 +38214,363 @@ cron_job = CronJob(
cron_job.run("Perform analysis")
```
+
+### Cron Jobs With Multi-Agent Structures
+
+You can also run Cron Jobs with multi-agent structures like `SequentialWorkflow`, `ConcurrentWorkflow`, `HiearchicalSwarm`, and other methods.
+
+- Just initialize the class as the agent parameter in the `CronJob(agent=swarm)`
+
+- Input your arguments into the `.run(task: str)` method
+
+
+```python
+"""
+Cryptocurrency Concurrent Multi-Agent Cron Job Example
+
+This example demonstrates how to use ConcurrentWorkflow with CronJob to create
+a powerful cryptocurrency tracking system. Each specialized agent analyzes a
+specific cryptocurrency concurrently every minute.
+
+Features:
+- ConcurrentWorkflow for parallel agent execution
+- CronJob scheduling for automated runs every 1 minute
+- Each agent specializes in analyzing one specific cryptocurrency
+- Real-time data fetching from CoinGecko API
+- Concurrent analysis of multiple cryptocurrencies
+- Structured output with professional formatting
+
+Architecture:
+CronJob -> ConcurrentWorkflow -> [Bitcoin Agent, Ethereum Agent, Solana Agent, etc.] -> Parallel Analysis
+"""
+
+from typing import List
+from loguru import logger
+
+from swarms import Agent, CronJob, ConcurrentWorkflow
+from swarms_tools import coin_gecko_coin_api
+
+
+def create_crypto_specific_agents() -> List[Agent]:
+ """
+ Creates agents that each specialize in analyzing a specific cryptocurrency.
+
+ Returns:
+ List[Agent]: List of cryptocurrency-specific Agent instances
+ """
+
+ # Bitcoin Specialist Agent
+ bitcoin_agent = Agent(
+ agent_name="Bitcoin-Analyst",
+ agent_description="Expert analyst specializing exclusively in Bitcoin (BTC) analysis and market dynamics",
+ system_prompt="""You are a Bitcoin specialist and expert analyst. Your expertise includes:
+
+BITCOIN SPECIALIZATION:
+- Bitcoin's unique position as digital gold
+- Bitcoin halving cycles and their market impact
+- Bitcoin mining economics and hash rate analysis
+- Lightning Network and Layer 2 developments
+- Bitcoin adoption by institutions and countries
+- Bitcoin's correlation with traditional markets
+- Bitcoin technical analysis and on-chain metrics
+- Bitcoin's role as a store of value and hedge against inflation
+
+ANALYSIS FOCUS:
+- Analyze ONLY Bitcoin data from the provided dataset
+- Focus on Bitcoin-specific metrics and trends
+- Consider Bitcoin's unique market dynamics
+- Evaluate Bitcoin's dominance and market leadership
+- Assess institutional adoption trends
+- Monitor on-chain activity and network health
+
+DELIVERABLES:
+- Bitcoin-specific analysis and insights
+- Price action assessment and predictions
+- Market dominance analysis
+- Institutional adoption impact
+- Technical and fundamental outlook
+- Risk factors specific to Bitcoin
+
+Extract Bitcoin data from the provided dataset and provide comprehensive Bitcoin-focused analysis.""",
+ model_name="groq/moonshotai/kimi-k2-instruct",
+ max_loops=1,
+ dynamic_temperature_enabled=True,
+ streaming_on=False,
+ tools=[coin_gecko_coin_api],
+ )
+
+ # Ethereum Specialist Agent
+ ethereum_agent = Agent(
+ agent_name="Ethereum-Analyst",
+ agent_description="Expert analyst specializing exclusively in Ethereum (ETH) analysis and ecosystem development",
+ system_prompt="""You are an Ethereum specialist and expert analyst. Your expertise includes:
+
+ETHEREUM SPECIALIZATION:
+- Ethereum's smart contract platform and DeFi ecosystem
+- Ethereum 2.0 transition and proof-of-stake mechanics
+- Gas fees, network usage, and scalability solutions
+- Layer 2 solutions (Arbitrum, Optimism, Polygon)
+- DeFi protocols and TVL (Total Value Locked) analysis
+- NFT markets and Ethereum's role in digital assets
+- Developer activity and ecosystem growth
+- EIP proposals and network upgrades
+
+ANALYSIS FOCUS:
+- Analyze ONLY Ethereum data from the provided dataset
+- Focus on Ethereum's platform utility and network effects
+- Evaluate DeFi ecosystem health and growth
+- Assess Layer 2 adoption and scalability solutions
+- Monitor network usage and gas fee trends
+- Consider Ethereum's competitive position vs other smart contract platforms
+
+DELIVERABLES:
+- Ethereum-specific analysis and insights
+- Platform utility and adoption metrics
+- DeFi ecosystem impact assessment
+- Network health and scalability evaluation
+- Competitive positioning analysis
+- Technical and fundamental outlook for ETH
+
+Extract Ethereum data from the provided dataset and provide comprehensive Ethereum-focused analysis.""",
+ model_name="groq/moonshotai/kimi-k2-instruct",
+ max_loops=1,
+ dynamic_temperature_enabled=True,
+ streaming_on=False,
+ tools=[coin_gecko_coin_api],
+ )
+
+ # Solana Specialist Agent
+ solana_agent = Agent(
+ agent_name="Solana-Analyst",
+ agent_description="Expert analyst specializing exclusively in Solana (SOL) analysis and ecosystem development",
+ system_prompt="""You are a Solana specialist and expert analyst. Your expertise includes:
+
+SOLANA SPECIALIZATION:
+- Solana's high-performance blockchain architecture
+- Proof-of-History consensus mechanism
+- Solana's DeFi ecosystem and DEX platforms (Serum, Raydium)
+- NFT marketplaces and creator economy on Solana
+- Network outages and reliability concerns
+- Developer ecosystem and Rust programming adoption
+- Validator economics and network decentralization
+- Cross-chain bridges and interoperability
+
+ANALYSIS FOCUS:
+- Analyze ONLY Solana data from the provided dataset
+- Focus on Solana's performance and scalability advantages
+- Evaluate network stability and uptime improvements
+- Assess ecosystem growth and developer adoption
+- Monitor DeFi and NFT activity on Solana
+- Consider Solana's competitive position vs Ethereum
+
+DELIVERABLES:
+- Solana-specific analysis and insights
+- Network performance and reliability assessment
+- Ecosystem growth and adoption metrics
+- DeFi and NFT market analysis
+- Competitive advantages and challenges
+- Technical and fundamental outlook for SOL
+
+Extract Solana data from the provided dataset and provide comprehensive Solana-focused analysis.""",
+ model_name="groq/moonshotai/kimi-k2-instruct",
+ max_loops=1,
+ dynamic_temperature_enabled=True,
+ streaming_on=False,
+ tools=[coin_gecko_coin_api],
+ )
+
+ # Cardano Specialist Agent
+ cardano_agent = Agent(
+ agent_name="Cardano-Analyst",
+ agent_description="Expert analyst specializing exclusively in Cardano (ADA) analysis and research-driven development",
+ system_prompt="""You are a Cardano specialist and expert analyst. Your expertise includes:
+
+CARDANO SPECIALIZATION:
+- Cardano's research-driven development approach
+- Ouroboros proof-of-stake consensus protocol
+- Smart contract capabilities via Plutus and Marlowe
+- Cardano's three-layer architecture (settlement, computation, control)
+- Academic partnerships and peer-reviewed research
+- Cardano ecosystem projects and DApp development
+- Native tokens and Cardano's UTXO model
+- Sustainability and treasury funding mechanisms
+
+ANALYSIS FOCUS:
+- Analyze ONLY Cardano data from the provided dataset
+- Focus on Cardano's methodical development approach
+- Evaluate smart contract adoption and ecosystem growth
+- Assess academic partnerships and research contributions
+- Monitor native token ecosystem development
+- Consider Cardano's long-term roadmap and milestones
+
+DELIVERABLES:
+- Cardano-specific analysis and insights
+- Development progress and milestone achievements
+- Smart contract ecosystem evaluation
+- Academic research impact assessment
+- Native token and DApp adoption metrics
+- Technical and fundamental outlook for ADA
+
+Extract Cardano data from the provided dataset and provide comprehensive Cardano-focused analysis.""",
+ model_name="groq/moonshotai/kimi-k2-instruct",
+ max_loops=1,
+ dynamic_temperature_enabled=True,
+ streaming_on=False,
+ tools=[coin_gecko_coin_api],
+ )
+
+ # Binance Coin Specialist Agent
+ bnb_agent = Agent(
+ agent_name="BNB-Analyst",
+ agent_description="Expert analyst specializing exclusively in BNB analysis and Binance ecosystem dynamics",
+ system_prompt="""You are a BNB specialist and expert analyst. Your expertise includes:
+
+BNB SPECIALIZATION:
+- BNB's utility within the Binance ecosystem
+- Binance Smart Chain (BSC) development and adoption
+- BNB token burns and deflationary mechanics
+- Binance exchange volume and market leadership
+- BSC DeFi ecosystem and yield farming
+- Cross-chain bridges and multi-chain strategies
+- Regulatory challenges facing Binance globally
+- BNB's role in transaction fee discounts and platform benefits
+
+ANALYSIS FOCUS:
+- Analyze ONLY BNB data from the provided dataset
+- Focus on BNB's utility value and exchange benefits
+- Evaluate BSC ecosystem growth and competition with Ethereum
+- Assess token burn impact on supply and price
+- Monitor Binance platform developments and regulations
+- Consider BNB's centralized vs decentralized aspects
+
+DELIVERABLES:
+- BNB-specific analysis and insights
+- Utility value and ecosystem benefits assessment
+- BSC adoption and DeFi growth evaluation
+- Token economics and burn mechanism impact
+- Regulatory risk and compliance analysis
+- Technical and fundamental outlook for BNB
+
+Extract BNB data from the provided dataset and provide comprehensive BNB-focused analysis.""",
+ model_name="groq/moonshotai/kimi-k2-instruct",
+ max_loops=1,
+ dynamic_temperature_enabled=True,
+ streaming_on=False,
+ tools=[coin_gecko_coin_api],
+ )
+
+ # XRP Specialist Agent
+ xrp_agent = Agent(
+ agent_name="XRP-Analyst",
+ agent_description="Expert analyst specializing exclusively in XRP analysis and cross-border payment solutions",
+ system_prompt="""You are an XRP specialist and expert analyst. Your expertise includes:
+
+XRP SPECIALIZATION:
+- XRP's role in cross-border payments and remittances
+- RippleNet adoption by financial institutions
+- Central Bank Digital Currency (CBDC) partnerships
+- Regulatory landscape and SEC lawsuit implications
+- XRP Ledger's consensus mechanism and energy efficiency
+- On-Demand Liquidity (ODL) usage and growth
+- Competition with SWIFT and traditional payment rails
+- Ripple's partnerships with banks and payment providers
+
+ANALYSIS FOCUS:
+- Analyze ONLY XRP data from the provided dataset
+- Focus on XRP's utility in payments and remittances
+- Evaluate RippleNet adoption and institutional partnerships
+- Assess regulatory developments and legal clarity
+- Monitor ODL usage and transaction volumes
+- Consider XRP's competitive position in payments
+
+DELIVERABLES:
+- XRP-specific analysis and insights
+- Payment utility and adoption assessment
+- Regulatory landscape and legal developments
+- Institutional partnership impact evaluation
+- Cross-border payment market analysis
+- Technical and fundamental outlook for XRP
+
+Extract XRP data from the provided dataset and provide comprehensive XRP-focused analysis.""",
+ model_name="groq/moonshotai/kimi-k2-instruct",
+ max_loops=1,
+ dynamic_temperature_enabled=True,
+ streaming_on=False,
+ tools=[coin_gecko_coin_api],
+ )
+
+ return [
+ bitcoin_agent,
+ ethereum_agent,
+ solana_agent,
+ cardano_agent,
+ bnb_agent,
+ xrp_agent,
+ ]
+
+
+def create_crypto_workflow() -> ConcurrentWorkflow:
+ """
+ Creates a ConcurrentWorkflow with cryptocurrency-specific analysis agents.
+
+ Returns:
+ ConcurrentWorkflow: Configured workflow for crypto analysis
+ """
+ agents = create_crypto_specific_agents()
+
+ workflow = ConcurrentWorkflow(
+ name="Crypto-Specific-Analysis-Workflow",
+ description="Concurrent execution of cryptocurrency-specific analysis agents",
+ agents=agents,
+ max_loops=1,
+ )
+
+ return workflow
+
+
+def create_crypto_cron_job() -> CronJob:
+ """
+ Creates a CronJob that runs cryptocurrency-specific analysis every minute using ConcurrentWorkflow.
+
+ Returns:
+ CronJob: Configured cron job for automated crypto analysis
+ """
+ # Create the concurrent workflow
+ workflow = create_crypto_workflow()
+
+ # Create the cron job
+ cron_job = CronJob(
+ agent=workflow, # Use the workflow as the agent
+ interval="5seconds", # Run every 1 minute
+ )
+
+ return cron_job
+
+
+def main():
+ """
+ Main function to run the cryptocurrency-specific concurrent analysis cron job.
+ """
+ cron_job = create_crypto_cron_job()
+
+ prompt = """
+
+ Conduct a comprehensive analysis of your assigned cryptocurrency.
+
+ """
+
+ # Start the cron job
+ logger.info("🔄 Starting automated analysis loop...")
+ logger.info("⏰ Press Ctrl+C to stop the cron job")
+
+ output = cron_job.run(task=prompt)
+ print(output)
+
+
+if __name__ == "__main__":
+ main()
+```
+
## Conclusion
The CronJob class provides a powerful way to schedule and automate tasks using Swarms Agents or custom functions. Key benefits include:
@@ -34227,7 +38589,7 @@ The CronJob class provides a powerful way to schedule and automate tasks using S
--------------------------------------------------
-# File: swarms\structs\custom_swarm.md
+# File: swarms/structs/custom_swarm.md
# Building Custom Swarms: A Comprehensive Guide for Swarm Engineers
@@ -35034,199 +39396,7 @@ For more advanced patterns and examples, explore the [Swarms Examples](../../exa
--------------------------------------------------
-# File: swarms\structs\deep_research_swarm.md
-
-# Deep Research Swarm
-
-!!! abstract "Overview"
- The Deep Research Swarm is a powerful, production-grade research system that conducts comprehensive analysis across multiple domains using parallel processing and advanced AI agents.
-
- Key Features:
-
- - Parallel search processing
-
- - Multi-agent research coordination
-
- - Advanced information synthesis
-
- - Automated query generation
-
- - Concurrent task execution
-
-## Getting Started
-
-!!! tip "Quick Installation"
- ```bash
- pip install swarms
- ```
-
-=== "Basic Usage"
- ```python
- from swarms.structs import DeepResearchSwarm
-
- # Initialize the swarm
- swarm = DeepResearchSwarm(
- name="MyResearchSwarm",
- output_type="json",
- max_loops=1
- )
-
- # Run a single research task
- results = swarm.run("What are the latest developments in quantum computing?")
- ```
-
-=== "Batch Processing"
- ```python
- # Run multiple research tasks in parallel
- tasks = [
- "What are the environmental impacts of electric vehicles?",
- "How is AI being used in drug discovery?",
- ]
- batch_results = swarm.batched_run(tasks)
- ```
-
-## Configuration
-
-!!! info "Constructor Arguments"
- | Parameter | Type | Default | Description |
- |-----------|------|---------|-------------|
- | `name` | str | "DeepResearchSwarm" | Name identifier for the swarm |
- | `description` | str | "A swarm that conducts..." | Description of the swarm's purpose |
- | `research_agent` | Agent | research_agent | Custom research agent instance |
- | `max_loops` | int | 1 | Maximum number of research iterations |
- | `nice_print` | bool | True | Enable formatted console output |
- | `output_type` | str | "json" | Output format ("json" or "string") |
- | `max_workers` | int | CPU_COUNT * 2 | Maximum concurrent threads |
- | `token_count` | bool | False | Enable token counting |
- | `research_model_name` | str | "gpt-4o-mini" | Model to use for research |
-
-## Core Methods
-
-### Run
-!!! example "Single Task Execution"
- ```python
- results = swarm.run("What are the latest breakthroughs in fusion energy?")
- ```
-
-### Batched Run
-!!! example "Parallel Task Execution"
- ```python
- tasks = [
- "What are current AI safety initiatives?",
- "How is CRISPR being used in agriculture?",
- ]
- results = swarm.batched_run(tasks)
- ```
-
-### Step
-!!! example "Single Step Execution"
- ```python
- results = swarm.step("Analyze recent developments in renewable energy storage")
- ```
-
-## Domain-Specific Examples
-
-=== "Scientific Research"
- ```python
- science_swarm = DeepResearchSwarm(
- name="ScienceSwarm",
- output_type="json",
- max_loops=2 # More iterations for thorough research
- )
-
- results = science_swarm.run(
- "What are the latest experimental results in quantum entanglement?"
- )
- ```
-
-=== "Market Research"
- ```python
- market_swarm = DeepResearchSwarm(
- name="MarketSwarm",
- output_type="json"
- )
-
- results = market_swarm.run(
- "What are the emerging trends in electric vehicle battery technology market?"
- )
- ```
-
-=== "News Analysis"
- ```python
- news_swarm = DeepResearchSwarm(
- name="NewsSwarm",
- output_type="string" # Human-readable output
- )
-
- results = news_swarm.run(
- "What are the global economic impacts of recent geopolitical events?"
- )
- ```
-
-=== "Medical Research"
- ```python
- medical_swarm = DeepResearchSwarm(
- name="MedicalSwarm",
- max_loops=2
- )
-
- results = medical_swarm.run(
- "What are the latest clinical trials for Alzheimer's treatment?"
- )
- ```
-
-## Advanced Features
-
-??? note "Custom Research Agent"
- ```python
- from swarms import Agent
-
- custom_agent = Agent(
- agent_name="SpecializedResearcher",
- system_prompt="Your specialized prompt here",
- model_name="gpt-4"
- )
-
- swarm = DeepResearchSwarm(
- research_agent=custom_agent,
- max_loops=2
- )
- ```
-
-??? note "Parallel Processing Control"
- ```python
- swarm = DeepResearchSwarm(
- max_workers=8, # Limit to 8 concurrent threads
- nice_print=False # Disable console output for production
- )
- ```
-
-## Best Practices
-
-!!! success "Recommended Practices"
- 1. **Query Formulation**: Be specific and clear in your research queries
- 2. **Resource Management**: Adjust `max_workers` based on your system's capabilities
- 3. **Output Handling**: Use appropriate `output_type` for your use case
- 4. **Error Handling**: Implement try-catch blocks around swarm operations
- 5. **Model Selection**: Choose appropriate models based on research complexity
-
-## Limitations
-
-!!! warning "Known Limitations"
-
- - Requires valid API keys for external services
-
- - Performance depends on system resources
-
- - Rate limits may apply to external API calls
-
- - Token limits apply to model responses
-
-
-
---------------------------------------------------
-
-# File: swarms\structs\diy_your_own_agent.md
+# File: swarms/structs/diy_your_own_agent.md
# Create your own agent with `Agent` class
@@ -35527,7 +39697,7 @@ Remember, the journey of building custom agent classes is an iterative and colla
--------------------------------------------------
-# File: swarms\structs\forest_swarm.md
+# File: swarms/structs/forest_swarm.md
# Forest Swarm
@@ -35725,7 +39895,7 @@ This **Multi-Agent Tree Structure** provides an efficient, scalable, and accurat
--------------------------------------------------
-# File: swarms\structs\graph_workflow.md
+# File: swarms/structs/graph_workflow.md
# GraphWorkflow
@@ -36532,7 +40702,7 @@ The GraphWorkflow system represents a significant advancement in multi-agent orc
--------------------------------------------------
-# File: swarms\structs\group_chat.md
+# File: swarms/structs/group_chat.md
# GroupChat Swarm Documentation
@@ -36568,24 +40738,6 @@ A production-grade multi-agent system enabling sophisticated group conversations
| max_loops | int | 10 | Maximum conversation turns |
-## Table of Contents
-
-- [Installation](#installation)
-- [Core Concepts](#core-concepts)
-- [Basic Usage](#basic-usage)
-- [Advanced Configuration](#advanced-configuration)
-- [Speaker Functions](#speaker-functions)
-- [Response Models](#response-models)
-- [Advanced Examples](#advanced-examples)
-- [API Reference](#api-reference)
-- [Best Practices](#best-practices)
-
-## Installation
-
-```bash
-pip3 install swarms swarm-models loguru
-```
-
## Core Concepts
The GroupChat system consists of several key components:
@@ -36601,55 +40753,23 @@ The GroupChat system consists of several key components:
import os
from dotenv import load_dotenv
-from swarm_models import OpenAIChat
from swarms import Agent, GroupChat, expertise_based
-
if __name__ == "__main__":
- load_dotenv()
-
- # Get the OpenAI API key from the environment variable
- api_key = os.getenv("OPENAI_API_KEY")
-
- # Create an instance of the OpenAIChat class
- model = OpenAIChat(
- openai_api_key=api_key,
- model_name="gpt-4o-mini",
- temperature=0.1,
- )
-
# Example agents
agent1 = Agent(
agent_name="Financial-Analysis-Agent",
system_prompt="You are a financial analyst specializing in investment strategies.",
- llm=model,
+ model_name="gpt-4.1",
max_loops=1,
- autosave=False,
- dashboard=False,
- verbose=True,
- dynamic_temperature_enabled=True,
- user_name="swarms_corp",
- retry_attempts=1,
- context_length=200000,
- output_type="string",
- streaming_on=False,
)
agent2 = Agent(
agent_name="Tax-Adviser-Agent",
system_prompt="You are a tax adviser who provides clear and concise guidance on tax-related queries.",
- llm=model,
+ model_name="gpt-4.1",
max_loops=1,
- autosave=False,
- dashboard=False,
- verbose=True,
- dynamic_temperature_enabled=True,
- user_name="swarms_corp",
- retry_attempts=1,
- context_length=200000,
- output_type="string",
- streaming_on=False,
)
agents = [agent1, agent2]
@@ -36748,36 +40868,6 @@ chat = GroupChat(
)
```
-## Response Models
-
-### Complete Schema
-
-```python
-class AgentResponse(BaseModel):
- """Individual agent response in a conversation turn"""
- agent_name: str
- role: str
- message: str
- timestamp: datetime = Field(default_factory=datetime.now)
- turn_number: int
- preceding_context: List[str] = Field(default_factory=list)
-
-class ChatTurn(BaseModel):
- """Single turn in the conversation"""
- turn_number: int
- responses: List[AgentResponse]
- task: str
- timestamp: datetime = Field(default_factory=datetime.now)
-
-class ChatHistory(BaseModel):
- """Complete conversation history"""
- turns: List[ChatTurn]
- total_messages: int
- name: str
- description: str
- start_time: datetime = Field(default_factory=datetime.now)
-```
-
## Advanced Examples
### Multi-Agent Analysis Team
@@ -36787,19 +40877,19 @@ class ChatHistory(BaseModel):
data_analyst = Agent(
agent_name="Data-Analyst",
system_prompt="You analyze numerical data and patterns",
- llm=model
+ model_name="gpt-4.1",
)
market_expert = Agent(
agent_name="Market-Expert",
system_prompt="You provide market insights and trends",
- llm=model
+ model_name="gpt-4.1",
)
strategy_advisor = Agent(
agent_name="Strategy-Advisor",
system_prompt="You formulate strategic recommendations",
- llm=model
+ model_name="gpt-4.1",
)
# Create analysis team
@@ -36844,29 +40934,12 @@ for task, history in zip(tasks, histories):
## Best Practices
-1. **Agent Design**
- - Give agents clear, specific roles
- - Use detailed system prompts
- - Set appropriate context lengths
- - Enable retries for reliability
-
-2. **Speaker Functions**
- - Match function to use case
- - Consider conversation flow
- - Handle edge cases
- - Add appropriate logging
-
-3. **Error Handling**
- - Use try-except blocks
- - Log errors appropriately
- - Implement retry logic
- - Provide fallback responses
-
-4. **Performance**
- - Use concurrent processing for multiple tasks
- - Monitor context lengths
- - Implement proper cleanup
- - Cache responses when appropriate
+| Category | Recommendations |
+|---------------------|--------------------------------------------------------------------------------------------------|
+| **Agent Design** | - Give agents clear, specific roles
- Use detailed system prompts
- Set appropriate context lengths
- Enable retries for reliability |
+| **Speaker Functions** | - Match function to use case
- Consider conversation flow
- Handle edge cases
- Add appropriate logging |
+| **Error Handling** | - Use try-except blocks
- Log errors appropriately
- Implement retry logic
- Provide fallback responses |
+| **Performance** | - Use concurrent processing for multiple tasks
- Monitor context lengths
- Implement proper cleanup
- Cache responses when appropriate |
## API Reference
@@ -36889,7 +40962,7 @@ for task, history in zip(tasks, histories):
--------------------------------------------------
-# File: swarms\structs\heavy_swarm.md
+# File: swarms/structs/heavy_swarm.md
# HeavySwarm Documentation
@@ -37217,7 +41290,7 @@ HeavySwarm is part of the Swarms ecosystem. Contributions are welcome for:
--------------------------------------------------
-# File: swarms\structs\hhcs.md
+# File: swarms/structs/hhcs.md
# Hybrid Hierarchical-Cluster Swarm [HHCS]
@@ -37445,7 +41518,190 @@ if __name__ == "__main__":
--------------------------------------------------
-# File: swarms\structs\hierarchical_swarm.md
+# File: swarms/structs/hierarchical_structured_communication_framework.md
+
+# Hierarchical Structured Communication Framework
+
+The Hierarchical Structured Communication Framework implements the "Talk Structurally, Act Hierarchically" approach for LLM multi-agent systems, based on the research paper arXiv:2502.11098.
+
+## Overview
+
+This framework provides:
+- **Structured Communication Protocol** with Message (M_ij), Background (B_ij), and Intermediate Output (I_ij)
+- **Hierarchical Evaluation System** with supervisor coordination
+- **Specialized Agent Classes** for different roles
+- **Main Swarm Orchestrator** for workflow management
+
+## Key Components
+
+### Agent Classes
+- `HierarchicalStructuredCommunicationGenerator` - Creates initial content
+- `HierarchicalStructuredCommunicationEvaluator` - Evaluates content quality
+- `HierarchicalStructuredCommunicationRefiner` - Improves content based on feedback
+- `HierarchicalStructuredCommunicationSupervisor` - Coordinates workflow
+
+### Main Framework
+- `HierarchicalStructuredCommunicationFramework` - Main orchestrator class
+- `HierarchicalStructuredCommunicationSwarm` - Convenience alias
+
+## Quick Start
+
+```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")
+```
+
+## Basic Usage
+
+```python
+from swarms.structs.hierarchical_structured_communication_framework import (
+ HierarchicalStructuredCommunicationFramework,
+ HierarchicalStructuredCommunicationGenerator,
+ HierarchicalStructuredCommunicationEvaluator,
+ HierarchicalStructuredCommunicationRefiner
+)
+
+# Create agents with custom names
+generator = HierarchicalStructuredCommunicationGenerator(agent_name="ContentGenerator")
+evaluator = HierarchicalStructuredCommunicationEvaluator(agent_name="QualityEvaluator")
+refiner = HierarchicalStructuredCommunicationRefiner(agent_name="ContentRefiner")
+
+# Create framework with default supervisor
+framework = HierarchicalStructuredCommunicationFramework(
+ generators=[generator],
+ evaluators=[evaluator],
+ refiners=[refiner],
+ max_loops=3,
+ verbose=True
+)
+
+# Execute task
+result = framework.run("Write a detailed report on renewable energy technologies")
+print(result["final_result"])
+```
+
+## Advanced Configuration
+
+```python
+from swarms.structs.hierarchical_structured_communication_framework import (
+ HierarchicalStructuredCommunicationFramework
+)
+
+# Create framework with custom configuration
+framework = HierarchicalStructuredCommunicationFramework(
+ name="AdvancedFramework",
+ max_loops=5,
+ enable_structured_communication=True,
+ enable_hierarchical_evaluation=True,
+ shared_memory=True,
+ model_name="gpt-4o-mini",
+ verbose=True
+)
+
+# Run with custom parameters
+result = framework.run(
+ "Analyze the impact of climate change on global agriculture",
+ max_loops=3
+)
+```
+
+## Integration with Other Swarms
+
+```python
+from swarms.structs.hierarchical_structured_communication_framework import (
+ HierarchicalStructuredCommunicationFramework
+)
+from swarms.structs import AutoSwarmBuilder
+
+# Use HierarchicalStructuredCommunicationFramework for content generation
+framework = HierarchicalStructuredCommunicationFramework(
+ max_loops=2,
+ verbose=True
+)
+
+# Integrate with AutoSwarmBuilder
+builder = AutoSwarmBuilder()
+swarm = builder.create_swarm(
+ swarm_type="HierarchicalStructuredCommunicationFramework",
+ task="Generate a comprehensive business plan"
+)
+```
+
+## API Reference
+
+### HierarchicalStructuredCommunicationFramework
+
+The main orchestrator class that implements the complete framework.
+
+#### Parameters
+- `name` (str): Name of the framework
+- `supervisor`: Main supervisor agent
+- `generators` (List): List of generator agents
+- `evaluators` (List): List of evaluator agents
+- `refiners` (List): List of refiner agents
+- `max_loops` (int): Maximum refinement loops
+- `enable_structured_communication` (bool): Enable structured protocol
+- `enable_hierarchical_evaluation` (bool): Enable hierarchical evaluation
+- `verbose` (bool): Enable verbose logging
+
+#### Methods
+- `run(task)`: Execute complete workflow
+- `step(task)`: Execute single workflow step
+- `send_structured_message()`: Send structured communication
+- `run_hierarchical_evaluation()`: Run evaluation system
+
+## Contributing
+
+Contributions to improve the Hierarchical Structured Communication Framework are welcome! Please:
+
+1. Follow the existing code style and patterns
+2. Add comprehensive tests for new features
+3. Update documentation for any API changes
+4. Ensure all imports use the correct module paths
+
+## License
+
+This framework is part of the Swarms project and follows the same licensing terms.
+
+
+--------------------------------------------------
+
+# File: swarms/structs/hierarchical_swarm.md
# `HierarchicalSwarm`
@@ -37810,7 +42066,7 @@ The `HierarchicalSwarm` includes comprehensive error handling with detailed logg
--------------------------------------------------
-# File: swarms\structs\image_batch_agent.md
+# File: swarms/structs/image_batch_agent.md
# ImageAgentBatchProcessor Documentation
@@ -38087,33 +42343,29 @@ This documentation provides a comprehensive guide to using the `ImageAgentBatchP
--------------------------------------------------
-# File: swarms\structs\index.md
+# File: swarms/structs/index.md
# Introduction to Multi-Agent Collaboration
---
-## 🚀 Benefits of Multi-Agent Collaboration
-
-
-
-
-
Fig. 1: Key benefits and structure of multi-agent collaboration
-