From 9b4621e9ef80f464f732dd11685a90fb37300906 Mon Sep 17 00:00:00 2001 From: CI-DEV <154627941+IlumCI@users.noreply.github.com> Date: Mon, 29 Sep 2025 21:39:41 +0300 Subject: [PATCH] Delete swarms/structs/agent_builder.py --- swarms/structs/agent_builder.py | 292 -------------------------------- 1 file changed, 292 deletions(-) delete mode 100644 swarms/structs/agent_builder.py diff --git a/swarms/structs/agent_builder.py b/swarms/structs/agent_builder.py deleted file mode 100644 index 11ad79cc..00000000 --- a/swarms/structs/agent_builder.py +++ /dev/null @@ -1,292 +0,0 @@ -import os -from typing import Any, List, Optional, Tuple - -from loguru import logger -from pydantic import BaseModel, Field - -from swarms.structs.agent import Agent -from swarms.utils.litellm_wrapper import LiteLLM - -BOSS_SYSTEM_PROMPT = """ -# Swarm Intelligence Orchestrator - -You are the Chief Orchestrator of a sophisticated agent swarm. Your primary responsibility is to analyze tasks and create the optimal team of specialized agents to accomplish complex objectives efficiently. - -## Agent Creation Protocol - -1. **Task Analysis**: - - Thoroughly analyze the user's task to identify all required skills, knowledge domains, and subtasks - - Break down complex problems into discrete components that can be assigned to specialized agents - - Identify potential challenges and edge cases that might require specialized handling - -2. **Agent Design Principles**: - - Create highly specialized agents with clearly defined roles and responsibilities - - Design each agent with deep expertise in their specific domain - - Provide agents with comprehensive and extremely extensive system prompts that include: - * Precise definition of their role and scope of responsibility - * Detailed methodology for approaching problems in their domain - * Specific techniques, frameworks, and mental models to apply - * Guidelines for output format and quality standards - * Instructions for collaboration with other agents - * In-depth examples and scenarios to illustrate expected behavior and decision-making processes - * Extensive background information relevant to the tasks they will undertake - -3. **Cognitive Enhancement**: - - Equip agents with advanced reasoning frameworks: - * First principles thinking to break down complex problems - * Systems thinking to understand interconnections - * Lateral thinking for creative solutions - * Critical thinking to evaluate information quality - - Implement specialized thought patterns: - * Step-by-step reasoning for complex problems - * Hypothesis generation and testing - * Counterfactual reasoning to explore alternatives - * Analogical reasoning to apply solutions from similar domains - -4. **Swarm Architecture**: - - Design optimal agent interaction patterns based on task requirements - - Consider hierarchical, networked, or hybrid structures - - Establish clear communication protocols between agents - - Define escalation paths for handling edge cases - -5. **Agent Specialization Examples**: - - Research Agents: Literature review, data gathering, information synthesis - - Analysis Agents: Data processing, pattern recognition, insight generation - - Creative Agents: Idea generation, content creation, design thinking - - Planning Agents: Strategy development, resource allocation, timeline creation - - Implementation Agents: Code writing, document drafting, execution planning - - Quality Assurance Agents: Testing, validation, error detection - - Integration Agents: Combining outputs, ensuring consistency, resolving conflicts - -## Output Format - -For each agent, provide: - -1. **Agent Name**: Clear, descriptive title reflecting specialization -2. **Description**: Concise overview of the agent's purpose and capabilities -3. **System Prompt**: Comprehensive and extremely extensive instructions including: - - Role definition and responsibilities - - Specialized knowledge and methodologies - - Thinking frameworks and problem-solving approaches - - Output requirements and quality standards - - Collaboration guidelines with other agents - - Detailed examples and context to ensure clarity and effectiveness - -## Optimization Guidelines - -- Create only the agents necessary for the task - no more, no less -- Ensure each agent has a distinct, non-overlapping area of responsibility -- Design system prompts that maximize agent performance through clear guidance and specialized knowledge -- Balance specialization with the need for effective collaboration -- Prioritize agents that address the most critical aspects of the task - -Remember: Your goal is to create a swarm of agents that collectively possesses the intelligence, knowledge, and capabilities to deliver exceptional results for the user's task. -""" - - -class AgentSpec(BaseModel): - agent_name: Optional[str] = Field( - None, - description="The unique name assigned to the agent, which identifies its role and functionality within the swarm.", - ) - description: Optional[str] = Field( - None, - description="A detailed explanation of the agent's purpose, capabilities, and any specific tasks it is designed to perform.", - ) - system_prompt: Optional[str] = Field( - None, - description="The initial instruction or context provided to the agent, guiding its behavior and responses during execution.", - ) - model_name: Optional[str] = Field( - description="The name of the AI model that the agent will utilize for processing tasks and generating outputs. For example: gpt-4o, gpt-4o-mini, openai/o3-mini" - ) - auto_generate_prompt: Optional[bool] = Field( - description="A flag indicating whether the agent should automatically create prompts based on the task requirements." - ) - max_tokens: Optional[int] = Field( - None, - description="The maximum number of tokens that the agent is allowed to generate in its responses, limiting output length.", - ) - temperature: Optional[float] = Field( - description="A parameter that controls the randomness of the agent's output; lower values result in more deterministic responses." - ) - role: Optional[str] = Field( - description="The designated role of the agent within the swarm, which influences its behavior and interaction with other agents." - ) - max_loops: Optional[int] = Field( - description="The maximum number of times the agent is allowed to repeat its task, enabling iterative processing if necessary." - ) - - -class Agents(BaseModel): - """Configuration for a collection of agents that work together as a swarm to accomplish tasks.""" - - agents: List[AgentSpec] = Field( - description="A list containing the specifications of each agent that will participate in the swarm, detailing their roles and functionalities." - ) - - -class AgentsBuilder: - """A class that automatically builds and manages swarms of AI agents. - - This class handles the creation, coordination and execution of multiple AI agents working - together as a swarm to accomplish complex tasks. It uses a boss agent to delegate work - and create new specialized agents as needed. - - Args: - name (str): The name of the swarm - 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. - """ - - def __init__( - self, - name: str = "swarm-creator-01", - description: str = "This is a swarm that creates swarms", - verbose: bool = True, - max_loops: int = 1, - model_name: str = "gpt-4o", - return_dictionary: bool = True, - system_prompt: str = BOSS_SYSTEM_PROMPT, - ): - self.name = name - self.description = description - self.verbose = verbose - self.max_loops = max_loops - self.agents_pool = [] - self.model_name = model_name - self.return_dictionary = return_dictionary - self.system_prompt = system_prompt - logger.info( - f"Initialized AutoSwarmBuilder: {name} {description}" - ) - - def run( - self, task: str, image_url: str = None, *args, **kwargs - ) -> Tuple[List[Agent], int]: - """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 - - 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) - - return agents - - def _create_agents(self, task: str, *args, **kwargs): - """Create the necessary agents for a task. - - Args: - task (str): The task to create agents for - *args: Variable length argument list - **kwargs: Arbitrary keyword arguments - - Returns: - list: List of created agents - """ - logger.info("Creating agents for task") - model = LiteLLM( - model_name=self.model_name, - system_prompt=self.system_prompt, - temperature=0.1, - response_format=Agents, - max_tokens=8192, - ) - - agents_dictionary = model.run(task) - print(agents_dictionary) - - print(type(agents_dictionary)) - logger.info("Agents successfully created") - logger.info(f"Agents: {len(agents_dictionary.agents)}") - - if self.return_dictionary: - logger.info("Returning dictionary") - - # Convert swarm config to dictionary - agents_dictionary = agents_dictionary.model_dump() - return agents_dictionary - else: - logger.info("Returning agents") - return self.create_agents(agents_dictionary) - - def create_agents(self, agents_dictionary: Any): - # 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 = Agents(**agent_config) - - agent = self.build_agent( - agent_name=agent_config.model_name, - agent_description=agent_config.description, - agent_system_prompt=agent_config.system_prompt, - model_name=agent_config.model_name, - max_loops=agent_config.max_loops, - dynamic_temperature_enabled=True, - auto_generate_prompt=agent_config.auto_generate_prompt, - role=agent_config.role, - max_tokens=agent_config.max_tokens, - temperature=agent_config.temperature, - ) - agents.append(agent) - - return agents - - def build_agent( - self, - agent_name: str, - agent_description: str, - agent_system_prompt: str, - max_loops: int = 1, - model_name: str = "gpt-4o", - dynamic_temperature_enabled: bool = True, - auto_generate_prompt: bool = False, - role: str = "worker", - max_tokens: int = 8192, - temperature: float = 0.5, - ): - """Build a single agent with the given specifications. - - 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 - - Returns: - Agent: The constructed agent instance - """ - logger.info(f"Building agent: {agent_name}") - agent = Agent( - agent_name=agent_name, - description=agent_description, - system_prompt=agent_system_prompt, - model_name=model_name, - max_loops=max_loops, - dynamic_temperature_enabled=dynamic_temperature_enabled, - context_length=200000, - output_type="str", # "json", "dict", "csv" OR "string" soon "yaml" and - streaming_on=False, - auto_generate_prompt=auto_generate_prompt, - role=role, - max_tokens=max_tokens, - temperature=temperature, - ) - - return agent - - -# if __name__ == "__main__": -# builder = AgentsBuilder(model_name="gpt-4o") -# agents = builder.run("Create a swarm that can write a book about the history of the world") -# print(agents) -# print(type(agents))