swarms 7.7.2__py3-none-any.whl → 7.7.3__py3-none-any.whl

swarms/structs/auto_swarm_builder.py

@@ -1,107 +1,131 @@
 import os
 from typing import List
-
+from loguru import logger
 from pydantic import BaseModel, Field
 
 from swarms.structs.agent import Agent
 from swarms.utils.function_caller_model import OpenAIFunctionCaller
-from swarms.structs.swarm_router import SwarmRouter
-from swarms.utils.loguru_logger import initialize_logger
-from swarms.structs.agents_available import showcase_available_agents
+from swarms.structs.ma_utils import set_random_models_for_agents
+from swarms.structs.swarm_router import SwarmRouter, SwarmRouterConfig
+from dotenv import load_dotenv
+
+
+load_dotenv()
 
-logger = initialize_logger(log_folder="auto_swarm_builder")
+BOSS_SYSTEM_PROMPT = """
+You are an expert swarm manager and agent architect. Your role is to create and coordinate a team of specialized AI agents, each with distinct personalities, roles, and capabilities. Your primary goal is to ensure the swarm operates efficiently while maintaining clear communication and well-defined responsibilities.
+
+### Core Principles:
+
+1. **Deep Task Understanding**:
+   - First, thoroughly analyze the task requirements, breaking them down into core components and sub-tasks
+   - Identify the necessary skills, knowledge domains, and personality traits needed for each component
+   - Consider potential challenges, dependencies, and required coordination between agents
+   - Map out the ideal workflow and information flow between agents
+
+2. **Agent Design Philosophy**:
+   - Each agent must have a clear, specific purpose and domain of expertise
+   - Agents should have distinct personalities that complement their roles
+   - Design agents to be self-aware of their limitations and when to seek help
+   - Ensure agents can effectively communicate their progress and challenges
+
+3. **Agent Creation Framework**:
+   For each new agent, define:
+   - **Role & Purpose**: Clear, specific description of what the agent does and why
+   - **Personality Traits**: Distinct characteristics that influence how the agent thinks and communicates
+   - **Expertise Level**: Specific knowledge domains and skill sets
+   - **Communication Style**: How the agent presents information and interacts
+   - **Decision-Making Process**: How the agent approaches problems and makes choices
+   - **Limitations & Boundaries**: What the agent cannot or should not do
+   - **Collaboration Protocol**: How the agent works with others
+
+4. **System Prompt Design**:
+   Create detailed system prompts that include:
+   - Role and purpose explanation
+   - Personality description and behavioral guidelines
+   - Specific capabilities and tools available
+   - Communication protocols and reporting requirements
+   - Problem-solving approach and decision-making framework
+   - Collaboration guidelines and team interaction rules
+   - Quality standards and success criteria
+
+5. **Swarm Coordination**:
+   - Design clear communication channels between agents
+   - Establish protocols for task handoffs and information sharing
+   - Create feedback loops for continuous improvement
+   - Implement error handling and recovery procedures
+   - Define escalation paths for complex issues
+
+6. **Quality Assurance**:
+   - Set clear success criteria for each agent and the overall swarm
+   - Implement verification steps for task completion
+   - Create mechanisms for self-assessment and improvement
+   - Establish protocols for handling edge cases and unexpected situations
+
+### Output Format:
+
+When creating a new agent or swarm, provide:
+
+1. **Agent Design**:
+   - Role and purpose statement
+   - Personality profile
+   - Capabilities and limitations
+   - Communication style
+   - Collaboration protocols
+
+2. **System Prompt**:
+   - Complete, detailed prompt that embodies the agent's identity
+   - Clear instructions for behavior and decision-making
+   - Specific guidelines for interaction and reporting
+
+3. **Swarm Architecture**:
+   - Team structure and hierarchy
+   - Communication flow
+   - Task distribution plan
+   - Quality control measures
+
+### Notes:
+
+- Always prioritize clarity and specificity in agent design
+- Ensure each agent has a unique, well-defined role
+- Create detailed, comprehensive system prompts
+- Maintain clear documentation of agent capabilities and limitations
+- Design for scalability and adaptability
+- Focus on creating agents that can work together effectively
+- Consider edge cases and potential failure modes
+- Implement robust error handling and recovery procedures
+"""
 
 
 class AgentConfig(BaseModel):
     """Configuration for an individual agent in a swarm"""
 
     name: str = Field(
-        description="The name of the agent", example="Research-Agent"
+        description="The name of the agent",
     )
     description: str = Field(
         description="A description of the agent's purpose and capabilities",
-        example="Agent responsible for researching and gathering information",
     )
     system_prompt: str = Field(
         description="The system prompt that defines the agent's behavior",
-        example="You are a research agent. Your role is to gather and analyze information...",
     )
+
     # max_loops: int = Field(
-    #     description="Maximum number of reasoning loops the agent can perform",
-    #     example=3,
+    #     description="The maximum number of loops for the agent to run",
     # )
 
+    class Config:
+        arbitrary_types_allowed = True
 
-class SwarmConfig(BaseModel):
-    """Configuration for a swarm of cooperative agents"""
 
-    name: str = Field(
-        description="The name of the swarm",
-        example="Research-Writing-Swarm",
-    )
-    description: str = Field(
-        description="The description of the swarm's purpose and capabilities",
-        example="A swarm of agents that work together to research topics and write articles",
-    )
+class AgentsConfig(BaseModel):
+    """Configuration for a list of agents in a swarm"""
+
     agents: List[AgentConfig] = Field(
-        description="The list of agents that make up the swarm",
-        example=[
-            AgentConfig(
-                name="Research-Agent",
-                description="Gathers information",
-                system_prompt="You are a research agent...",
-            ),
-            AgentConfig(
-                name="Writing-Agent",
-                description="Writes content",
-                system_prompt="You are a writing agent...",
-            ),
-        ],
-    )
-    max_loops: int = Field(
-        description="The maximum number of loops to run the swarm",
-        example=1,
+        description="A list of agent configurations",
     )
 
 
-BOSS_SYSTEM_PROMPT = """
-Manage a swarm of worker agents to efficiently serve the user by deciding whether to create new agents or delegate tasks. Ensure operations are efficient and effective.
-
-### Instructions:
-
-1. **Task Assignment**:
-   - Analyze available worker agents when a task is presented.
-   - Delegate tasks to existing agents with clear, direct, and actionable instructions if an appropriate agent is available.
-   - If no suitable agent exists, create a new agent with a fitting system prompt to handle the task.
-
-2. **Agent Creation**:
-   - Name agents according to the task they are intended to perform (e.g., "Twitter Marketing Agent").
-   - Provide each new agent with a concise and clear system prompt that includes its role, objectives, and any tools it can utilize.
-
-3. **Efficiency**:
-   - Minimize redundancy and maximize task completion speed.
-   - Avoid unnecessary agent creation if an existing agent can fulfill the task.
-
-4. **Communication**:
-   - Be explicit in task delegation instructions to avoid ambiguity and ensure effective task execution.
-   - Require agents to report back on task completion or encountered issues.
-
-5. **Reasoning and Decisions**:
-   - Offer brief reasoning when selecting or creating agents to maintain transparency.
-   - Avoid using an agent if unnecessary, with a clear explanation if no agents are suitable for a task.
-
-# Output Format
-
-Present your plan in clear, bullet-point format or short concise paragraphs, outlining task assignment, agent creation, efficiency strategies, and communication protocols.
-
-# Notes
-
-- Preserve transparency by always providing reasoning for task-agent assignments and creation.
-- Ensure instructions to agents are unambiguous to minimize error.
-
-"""
-
-
 class AutoSwarmBuilder:
     """A class that automatically builds and manages swarms of AI agents.
 
@@ -114,6 +138,7 @@ class AutoSwarmBuilder:
         description (str): A description of the swarm's purpose
         verbose (bool, optional): Whether to output detailed logs. Defaults to True.
         max_loops (int, optional): Maximum number of execution loops. Defaults to 1.
+        random_models (bool, optional): Whether to use random models for agents. Defaults to True.
     """
 
     def __init__(
@@ -122,183 +147,219 @@ class AutoSwarmBuilder:
         description: str = None,
         verbose: bool = True,
         max_loops: int = 1,
+        random_models: bool = True,
     ):
+        """Initialize the AutoSwarmBuilder.
+
+        Args:
+            name (str): The name of the swarm
+            description (str): A description of the swarm's purpose
+            verbose (bool): Whether to output detailed logs
+            max_loops (int): Maximum number of execution loops
+            random_models (bool): Whether to use random models for agents
+        """
         self.name = name
         self.description = description
         self.verbose = verbose
         self.max_loops = max_loops
-        self.agents_pool = []
+        self.random_models = random_models
+
         logger.info(
-            f"Initialized AutoSwarmBuilder: {name} {description}"
+            f"Initializing AutoSwarmBuilder with name: {name}, description: {description}"
         )
 
-    # @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
-    def run(self, task: str, image_url: str = None, *args, **kwargs):
+    def run(self, task: str, *args, **kwargs):
         """Run the swarm on a given task.
 
         Args:
-            task (str): The task to be accomplished
-            image_url (str, optional): URL of an image input if needed. Defaults to None.
-            *args: Variable length argument list
-            **kwargs: Arbitrary keyword arguments
+            task (str): The task to execute
+            *args: Additional positional arguments
+            **kwargs: Additional keyword arguments
 
         Returns:
-            The output from the swarm's execution
-        """
-        logger.info(f"Running swarm on task: {task}")
-        agents = self._create_agents(task, image_url, *args, **kwargs)
-        logger.info(f"Agents created {len(agents)}")
-        logger.info("Routing task through swarm")
-        output = self.swarm_router(agents, task, image_url)
-        logger.info(f"Swarm execution complete with output: {output}")
-        return output
-
-    # @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
-    def _create_agents(self, task: str, *args, **kwargs):
-        """Create the necessary agents for a task.
+            Any: The result of the swarm execution
 
-        Args:
-            task (str): The task to create agents for
-            *args: Variable length argument list
-            **kwargs: Arbitrary keyword arguments
-
-        Returns:
-            list: List of created agents
+        Raises:
+            Exception: If there's an error during execution
         """
-        logger.info("Creating agents for task")
-        model = OpenAIFunctionCaller(
-            system_prompt=BOSS_SYSTEM_PROMPT,
-            api_key=os.getenv("OPENAI_API_KEY"),
-            temperature=0.1,
-            base_model=SwarmConfig,
-        )
-
-        agents_dictionary = model.run(task)
-        logger.info(f"Agents dictionary: {agents_dictionary}")
+        try:
+            logger.info(f"Starting swarm execution for task: {task}")
+            agents = self.create_agents(task)
+            logger.info(f"Created {len(agents)} agents")
 
-        # Convert dictionary to SwarmConfig if needed
-        if isinstance(agents_dictionary, dict):
-            agents_dictionary = SwarmConfig(**agents_dictionary)
+            if self.random_models:
+                logger.info("Setting random models for agents")
+                agents = set_random_models_for_agents(agents=agents)
 
-        # Set swarm config
-        self.name = agents_dictionary.name
-        self.description = agents_dictionary.description
-        self.max_loops = getattr(
-            agents_dictionary
-        )  # Default to 1 if not set
+            return self.initialize_swarm_router(
+                agents=agents, task=task
+            )
+        except Exception as e:
+            logger.error(
+                f"Error in swarm execution: {str(e)}", exc_info=True
+            )
+            raise
 
-        logger.info(
-            f"Swarm config: {self.name}, {self.description}, {self.max_loops}"
-        )
+    def create_agents(self, task: str):
+        """Create agents for a given task.
 
-        # Create agents from config
-        agents = []
-        for agent_config in agents_dictionary.agents:
-            # Convert dict to AgentConfig if needed
-            if isinstance(agent_config, dict):
-                agent_config = AgentConfig(**agent_config)
-
-            agent = self.build_agent(
-                agent_name=agent_config.name,
-                agent_description=agent_config.description,
-                agent_system_prompt=agent_config.system_prompt,
-            )
-            agents.append(agent)
+        Args:
+            task (str): The task to create agents for
 
-        # Showcasing available agents
-        agents_available = showcase_available_agents(
-            name=self.name,
-            description=self.description,
-            agents=agents,
-        )
+        Returns:
+            List[Agent]: List of created agents
 
-        for agent in agents:
-            agent.system_prompt += "\n" + agents_available
+        Raises:
+            Exception: If there's an error during agent creation
+        """
+        try:
+            logger.info(f"Creating agents for task: {task}")
+            model = OpenAIFunctionCaller(
+                system_prompt=BOSS_SYSTEM_PROMPT,
+                api_key=os.getenv("OPENAI_API_KEY"),
+                temperature=0.5,
+                base_model=AgentsConfig,
+            )
 
-        return agents
+            logger.info(
+                "Getting agent configurations from boss agent"
+            )
+            output = model.run(
+                f"Create the agents for the following task: {task}"
+            )
+            logger.debug(
+                f"Received agent configurations: {output.model_dump()}"
+            )
+            output = output.model_dump()
+
+            agents = []
+            if isinstance(output, dict):
+                for agent_config in output["agents"]:
+                    logger.info(
+                        f"Building agent: {agent_config['name']}"
+                    )
+                    agent = self.build_agent(
+                        agent_name=agent_config["name"],
+                        agent_description=agent_config["description"],
+                        agent_system_prompt=agent_config[
+                            "system_prompt"
+                        ],
+                    )
+                    agents.append(agent)
+                    logger.info(
+                        f"Successfully built agent: {agent_config['name']}"
+                    )
+
+            return agents
+        except Exception as e:
+            logger.error(
+                f"Error creating agents: {str(e)}", exc_info=True
+            )
+            raise
 
     def build_agent(
         self,
         agent_name: str,
         agent_description: str,
         agent_system_prompt: str,
-        max_loops: int = 1,
-    ):
-        """Build a single agent with the given specifications.
+    ) -> Agent:
+        """Build a single agent with enhanced error handling.
 
         Args:
             agent_name (str): Name of the agent
-            agent_description (str): Description of the agent's purpose
-            agent_system_prompt (str): The system prompt for the agent
+            agent_description (str): Description of the agent
+            agent_system_prompt (str): System prompt for the agent
 
         Returns:
-            Agent: The constructed agent instance
+            Agent: The constructed agent
+
+        Raises:
+            Exception: If there's an error during agent construction
         """
         logger.info(f"Building agent: {agent_name}")
-        agent = Agent(
-            agent_name=agent_name,
-            description=agent_description,
-            system_prompt=agent_system_prompt,
-            model_name="gpt-4o",
-            max_loops=max_loops,
-            autosave=True,
-            dashboard=False,
-            verbose=True,
-            dynamic_temperature_enabled=True,
-            saved_state_path=f"{agent_name}.json",
-            user_name="swarms_corp",
-            retry_attempts=1,
-            context_length=200000,
-            return_step_meta=False,
-            output_type="str",  # "json", "dict", "csv" OR "string" soon "yaml" and
-            streaming_on=False,
-            auto_generate_prompt=True,
-        )
-
-        return agent
+        try:
+            agent = Agent(
+                agent_name=agent_name,
+                description=agent_description,
+                system_prompt=agent_system_prompt,
+                verbose=self.verbose,
+                dynamic_temperature_enabled=False,
+            )
+            logger.info(f"Successfully built agent: {agent_name}")
+            return agent
+        except Exception as e:
+            logger.error(
+                f"Error building agent {agent_name}: {str(e)}",
+                exc_info=True,
+            )
+            raise
 
-    def swarm_router(
-        self,
-        agents: List[Agent],
-        task: str,
-        image_url: str = None,
-        *args,
-        **kwargs,
-    ):
-        """Route tasks between agents in the swarm.
+    def initialize_swarm_router(self, agents: List[Agent], task: str):
+        """Initialize and run the swarm router.
 
         Args:
-            agents (List[Agent]): List of available agents
-            task (str): The task to route
-            image_url (str, optional): URL of an image input if needed. Defaults to None.
-            *args: Variable length argument list
-            **kwargs: Arbitrary keyword arguments
+            agents (List[Agent]): List of agents to use
+            task (str): The task to execute
 
         Returns:
-            The output from the routed task execution
+            Any: The result of the swarm router execution
+
+        Raises:
+            Exception: If there's an error during router initialization or execution
         """
-        logger.info("Routing task through swarm")
-        swarm_router_instance = SwarmRouter(
-            name=self.name,
-            description=self.description,
-            agents=agents,
-            swarm_type="auto",
-            max_loops=1,
-        )
+        try:
+            logger.info("Initializing swarm router")
+            model = OpenAIFunctionCaller(
+                system_prompt=BOSS_SYSTEM_PROMPT,
+                api_key=os.getenv("OPENAI_API_KEY"),
+                temperature=0.5,
+                base_model=SwarmRouterConfig,
+            )
 
-        return swarm_router_instance.run(
-            self.name + " " + self.description + " " + task,
-        )
+            logger.info("Creating swarm specification")
+            swarm_spec = model.run(
+                f"Create the swarm spec for the following task: {task}"
+            )
+            logger.debug(
+                f"Received swarm specification: {swarm_spec.model_dump()}"
+            )
+            swarm_spec = swarm_spec.model_dump()
+
+            logger.info("Initializing SwarmRouter")
+            swarm_router = SwarmRouter(
+                name=swarm_spec["name"],
+                description=swarm_spec["description"],
+                max_loops=1,
+                swarm_type=swarm_spec["swarm_type"],
+                rearrange_flow=swarm_spec["rearrange_flow"],
+                rules=swarm_spec["rules"],
+                multi_agent_collab_prompt=swarm_spec[
+                    "multi_agent_collab_prompt"
+                ],
+                agents=agents,
+                output_type="dict",
+            )
 
+            logger.info("Starting swarm router execution")
+            return swarm_router.run(task)
+        except Exception as e:
+            logger.error(
+                f"Error in swarm router initialization/execution: {str(e)}",
+                exc_info=True,
+            )
+            raise
 
-# example = AutoSwarmBuilder(
-#     name="ChipDesign-Swarm",
-#     description="A swarm of specialized AI agents collaborating on chip architecture, logic design, verification, and optimization to create novel semiconductor designs",
-#     max_loops=1,
-# )
+    def batch_run(self, tasks: List[str]):
+        """Run the swarm on a list of tasks.
+
+        Args:
+            tasks (List[str]): List of tasks to execute
+
+        Returns:
+            List[Any]: List of results from each task execution
+
+        Raises:
+            Exception: If there's an error during batch execution
+        """
 
-# print(
-#     example.run(
-#         "Design a new AI accelerator chip optimized for transformer model inference. Consider the following aspects: 1) Overall chip architecture and block diagram 2) Memory hierarchy and interconnects 3) Processing elements and data flow 4) Power and thermal considerations 5) Physical layout recommendations -> "
-#     )
-# )
+        return [self.run(task) for task in tasks]