swarms 7.6.1__py3-none-any.whl → 7.6.4__py3-none-any.whl

swarms/structs/hybrid_hiearchical_peer_swarm.py

@@ -0,0 +1,256 @@
+import os
+from typing import List
+from swarms.structs.agent import Agent
+from swarms.structs.conversation import Conversation
+from swarms.structs.multi_agent_exec import get_swarms_info
+from swarms.structs.swarm_router import SwarmRouter
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+)
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Union, Callable
+
+tools = [
+    {
+        "type": "function",
+        "function": {
+            "name": "select_swarm",
+            "description": "Analyzes the input task and selects the most appropriate swarm configuration, outputting both the swarm name and the formatted task.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "reasoning": {
+                        "type": "string",
+                        "description": "The reasoning behind the selection of the swarm and task description.",
+                    },
+                    "swarm_name": {
+                        "type": "string",
+                        "description": "The name of the selected swarm that is most appropriate for handling the given task.",
+                    },
+                    "task_description": {
+                        "type": "string",
+                        "description": "A clear and structured description of the task to be performed by the swarm.",
+                    },
+                },
+                "required": [
+                    "reasoning",
+                    "swarm_name",
+                    "task_description",
+                ],
+            },
+        },
+    },
+]
+
+router_system_prompt = """
+You are an intelligent Router Agent responsible for analyzing tasks and directing them to the most appropriate swarm in our system. Your role is critical in ensuring optimal task execution and resource utilization.
+
+Key Responsibilities:
+1. Task Analysis:
+   - Carefully analyze the input task's requirements, complexity, and domain
+   - Identify key components and dependencies
+   - Determine the specialized skills needed for completion
+
+2. Swarm Selection Criteria:
+   - Match task requirements with swarm capabilities
+   - Consider swarm specializations and past performance
+   - Evaluate computational resources needed
+   - Account for task priority and time constraints
+
+3. Decision Making Framework:
+   - Use a systematic approach to evaluate all available swarms
+   - Consider load balancing across the system
+   - Factor in swarm availability and current workload
+   - Assess potential risks and failure points
+
+4. Output Requirements:
+   - Provide clear justification for swarm selection
+   - Structure the task description in a way that maximizes swarm efficiency
+   - Include any relevant context or constraints
+   - Ensure all critical information is preserved
+
+Best Practices:
+- Always prefer specialized swarms for domain-specific tasks
+- Consider breaking complex tasks into subtasks when appropriate
+- Maintain consistency in task formatting across different swarms
+- Include error handling considerations in task descriptions
+
+Your output must strictly follow the required format:
+{
+    "swarm_name": "Name of the selected swarm",
+    "task_description": "Detailed and structured task description"
+}
+
+Remember: Your selection directly impacts the overall system performance and task completion success rate. Take all factors into account before making your final decision.
+"""
+
+
+class HybridHierarchicalClusterSwarm:
+    """
+    A class representing a Hybrid Hierarchical-Cluster Swarm that routes tasks to appropriate swarms.
+
+    Attributes:
+        name (str): The name of the swarm.
+        description (str): A description of the swarm's functionality.
+        swarms (List[SwarmRouter]): A list of available swarm routers.
+        max_loops (int): The maximum number of loops for task processing.
+        output_type (str): The format of the output (e.g., list).
+        conversation (Conversation): An instance of the Conversation class to manage interactions.
+        router_agent (Agent): An instance of the Agent class responsible for routing tasks.
+    """
+
+    def __init__(
+        self,
+        name: str = "Hybrid Hierarchical-Cluster Swarm",
+        description: str = "A swarm that uses a hybrid hierarchical-peer model to solve complex tasks.",
+        swarms: List[Union[SwarmRouter, Callable]] = [],
+        max_loops: int = 1,
+        output_type: str = "list",
+        router_agent_model_name: str = "gpt-4o-mini",
+        *args,
+        **kwargs,
+    ):
+        self.name = name
+        self.description = description
+        self.swarms = swarms
+        self.max_loops = max_loops
+        self.output_type = output_type
+
+        self.conversation = Conversation()
+
+        self.router_agent = Agent(
+            agent_name="Router Agent",
+            agent_description="A router agent that routes tasks to the appropriate swarms.",
+            system_prompt=f"{router_system_prompt}\n\n{get_swarms_info()}",
+            tools_list_dictionary=tools,
+            model_name=router_agent_model_name,
+            max_loops=1,
+            output_type="final",
+        )
+
+    def convert_str_to_dict(self, response: str):
+        # Handle response whether it's a string or dictionary
+        if isinstance(response, str):
+            try:
+                import json
+
+                response = json.loads(response)
+            except json.JSONDecodeError:
+                raise ValueError(
+                    "Invalid JSON response from router agent"
+                )
+
+        return response
+
+    def run(self, task: str, *args, **kwargs):
+        """
+        Runs the routing process for a given task.
+
+        Args:
+            task (str): The task to be processed by the swarm.
+
+        Returns:
+            str: The formatted history output of the conversation.
+
+        Raises:
+            ValueError: If the task is empty or invalid.
+        """
+        if not task:
+            raise ValueError("Task cannot be empty.")
+
+        self.conversation.add(role="User", content=task)
+
+        response = self.router_agent.run(task=task)
+
+        if isinstance(response, str):
+            response = self.convert_str_to_dict(response)
+        else:
+            pass
+
+        swarm_name = response.get("swarm_name")
+        task_description = response.get("task_description")
+
+        if not swarm_name or not task_description:
+            raise ValueError(
+                "Invalid response from router agent: both 'swarm_name' and 'task_description' must be present. "
+                f"Received: swarm_name={swarm_name}, task_description={task_description}. "
+                f"Please check the response format from the model: {self.router_agent.model_name}."
+            )
+
+        self.route_task(swarm_name, task_description)
+
+        return history_output_formatter(
+            self.conversation, self.output_type
+        )
+
+    def find_swarm_by_name(self, swarm_name: str):
+        """
+        Finds a swarm by its name.
+
+        Args:
+            swarm_name (str): The name of the swarm to find.
+
+        Returns:
+            SwarmRouter: The found swarm router, or None if not found.
+        """
+        for swarm in self.swarms:
+            if swarm.name == swarm_name:
+                return swarm
+        return None
+
+    def route_task(self, swarm_name: str, task_description: str):
+        """
+        Routes the task to the specified swarm.
+
+        Args:
+            swarm_name (str): The name of the swarm to route the task to.
+            task_description (str): The description of the task to be executed.
+
+        Raises:
+            ValueError: If the swarm is not found.
+        """
+        swarm = self.find_swarm_by_name(swarm_name)
+
+        if swarm:
+            output = swarm.run(task_description)
+            self.conversation.add(role=swarm.name, content=output)
+        else:
+            raise ValueError(f"Swarm '{swarm_name}' not found.")
+
+    def batched_run(self, tasks: List[str]):
+        """
+        Runs the routing process for a list of tasks in batches.
+
+        Args:
+            tasks (List[str]): A list of tasks to be processed by the swarm.
+
+        Returns:
+            List[str]: A list of formatted history outputs for each batch.
+
+        Raises:
+            ValueError: If the task list is empty or invalid.
+        """
+        if not tasks:
+            raise ValueError("Task list cannot be empty.")
+
+        max_workers = os.cpu_count() * 2
+
+        results = []
+
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # Submit all tasks to the executor
+            future_to_task = {
+                executor.submit(self.run, task): task
+                for task in tasks
+            }
+
+            # Collect results as they complete
+            for future in as_completed(future_to_task):
+                try:
+                    result = future.result()
+                    results.append(result)
+                except Exception as e:
+                    # Handle any errors that occurred during task execution
+                    results.append(f"Error processing task: {str(e)}")
+
+        return results

swarms/structs/majority_voting.py

@@ -9,7 +9,7 @@ from typing import Any, Callable, List, Optional
 from swarms.structs.agent import Agent
 from swarms.structs.conversation import Conversation
 from swarms.structs.multi_agent_exec import run_agents_concurrently
-from swarms.structs.output_type import OutputType
+from swarms.structs.output_types import OutputType
 from swarms.utils.formatter import formatter
 from swarms.utils.loguru_logger import initialize_logger
 

swarms/structs/mixture_of_agents.py

@@ -11,7 +11,7 @@ from swarms.schemas.agent_step_schemas import ManySteps
 from swarms.prompts.ag_prompt import aggregator_system_prompt
 from swarms.utils.loguru_logger import initialize_logger
 import concurrent.futures
-from swarms.structs.output_type import OutputType
+from swarms.structs.output_types import OutputType
 from swarms.structs.conversation import Conversation
 
 logger = initialize_logger(log_folder="mixture_of_agents")

swarms/structs/multi_agent_exec.py

@@ -5,7 +5,7 @@ from concurrent.futures import (
     ThreadPoolExecutor,
 )
 from dataclasses import dataclass
-from typing import Any, List
+from typing import Any, Callable, List, Union
 
 import psutil
 
@@ -415,141 +415,65 @@ def run_agents_with_tasks_concurrently(
     )
 
 
-# from joblib import Parallel, delayed
-
-
-# def run_agents_joblib(
-#     agents: List[Any],
-#     tasks: List[str] = [],
-#     img: List[str] = None,
-#     max_workers: int = None,
-#     max_loops: int = 1,
-#     prefer: str = "threads",
-# ) -> List[Any]:
-#     """
-#     Executes a list of agents with their corresponding tasks concurrently using joblib.
-
-#     Each agent is expected to have a .run() method that accepts at least:
-#         - task: A string indicating the task to execute.
-#         - img: (Optional) A string representing image input.
-
-#     Args:
-#         agents (List[Any]): A list of agent instances.
-#         tasks (List[str], optional): A list of task strings. If provided, each agent gets a task.
-#                                      If fewer tasks than agents, the first task is reused.
-#         img (List[str], optional): A list of image strings. If provided, each agent gets an image.
-#                                    If fewer images than agents, the first image is reused.
-#         max_workers (int, optional): The maximum number of processes to use.
-#                                      Defaults to all available CPU cores.
-#         max_loops (int, optional): Number of times to execute the whole batch.
-
-#     Returns:
-#         List[Any]: The list of results returned by each agent’s run() method.
-#     """
-#     max_workers = max_workers or os.cpu_count()
-#     results = []
-
-#     for _ in range(max_loops):
-#         results.extend(
-#             Parallel(n_jobs=max_workers, prefer=prefer)(
-#                 delayed(lambda a, t, i: a.run(task=t, img=i))(
-#                     agent,
-#                     (
-#                         tasks[idx]
-#                         if tasks and idx < len(tasks)
-#                         else (tasks[0] if tasks else "")
-#                     ),
-#                     (
-#                         img[idx]
-#                         if img and idx < len(img)
-#                         else (img[0] if img else None)
-#                     ),
-#                 )
-#                 for idx, agent in enumerate(agents)
-#             )
-#         )
-
-#     return results
-
-
-# # Example usage:
-# if __name__ == '__main__':
-#     # Dummy Agent class for demonstration.
-#     class Agent:
-#         def __init__(self, agent_name, max_loops, model_name):
-#             self.agent_name = agent_name
-#             self.max_loops = max_loops
-#             self.model_name = model_name
-
-#         def run(self, task: str, img: str = None) -> str:
-#             img_info = f" with image '{img}'" if img else ""
-#             return (f"{self.agent_name} using model '{self.model_name}' processed task: '{task}'{img_info}")
-
-#     # Create a few Agent instances.
-#     agents = [
-#         Agent(
-#             agent_name=f"Financial-Analysis-Agent_parallel_swarm{i}",
-#             max_loops=1,
-#             model_name="gpt-4o-mini",
-#         )
-#         for i in range(3)
-#     ]
-
-#     task = "How can I establish a ROTH IRA to buy stocks and get a tax break? What are the criteria"
-#     outputs = run_agents_process_pool(agents, tasks=[task])
-
-#     for i, output in enumerate(outputs):
-#         print(f"Output from agent {i+1}:\n{output}")
-
-# # Example usage:
-# if __name__ == '__main__':
-#     # A sample agent class with a run method.
-#     class SampleAgent:
-#         def __init__(self, name):
-#             self.name = name
-
-#         def run(self, task, device, device_id, no_clusterops):
-#             # Simulate some processing.
-#             return (f"Agent {self.name} processed task '{task}' on {device} "
-#                     f"(device_id={device_id}), no_clusterops={no_clusterops}")
-
-#     # Create a list of sample agents.
-#     agents = [SampleAgent(f"Agent_{i}") for i in range(5)]
-#     # Define tasks; if fewer tasks than agents, the first task will be reused.
-#     tasks = ["task1", "task2", "task3"]
-
-#     outputs = run_agents_with_tasks_concurrently(
-#         agents=agents,
-#         tasks=tasks,
-#         max_workers=4,
-#         device="cpu",
-#         device_id=1,
-#         all_cores=True,
-#         no_clusterops=False
-#     )
-
-#     for output in outputs:
-#         print(output)
-
-
-# # Example usage:
-# if __name__ == "__main__":
-#     # Initialize your agents (for example, 3 agents)
-#     agents = [
-#         Agent(
-#             agent_name=f"Financial-Analysis-Agent_parallel_swarm{i}",
-#             max_loops=1,
-#             model_name="gpt-4o-mini",
-#         )
-#         for i in range(3)
-#     ]
-
-#     # Generate a list of tasks.
-#     tasks = [
-#         "How can I establish a ROTH IRA to buy stocks and get a tax break?",
-#         "What are the criteria for establishing a ROTH IRA?",
-#         "What are the tax benefits of a ROTH IRA?",
-#         "How to buy stocks using a ROTH IRA?",
-#         "What are the limitations of a ROTH IRA?",
-#     ]
-#     outputs = run_agents_joblib(agents, tasks)
+def get_swarms_info(swarms: List[Callable]) -> str:
+    """
+    Fetches and formats information about all available swarms in the system.
+
+    Returns:
+        str: A formatted string containing names and descriptions of all swarms.
+    """
+    if not swarms:
+        return "No swarms currently available in the system."
+
+    swarm_info = [
+        "Available Swarms:",
+        "",
+    ]  # Empty string for line spacing
+
+    for idx, swarm in enumerate(swarms, 1):
+        swarm_info.extend(
+            [
+                f"[Swarm {idx}]",
+                f"Name: {swarm.name}",
+                f"Description: {swarm.description}",
+                f"Length of Agents: {len(swarm.agents)}",
+                f"Swarm Type: {swarm.swarm_type}",
+                "",  # Empty string for line spacing between swarms
+            ]
+        )
+
+    return "\n".join(swarm_info).strip()
+
+
+def get_agents_info(
+    agents: List[Union[Agent, Callable]], team_name: str = None
+) -> str:
+    """
+    Fetches and formats information about all available agents in the system.
+
+    Returns:
+        str: A formatted string containing names and descriptions of all swarms.
+    """
+    if not agents:
+        return "No agents currently available in the system."
+
+    agent_info = [
+        f"Available Agents for Team: {team_name}",
+        "",
+    ]  # Empty string for line spacing
+
+    for idx, agent in enumerate(agents, 1):
+        agent_info.extend(
+            [
+                "\n",
+                f"[Agent {idx}]",
+                f"Name: {agent.agent_name}",
+                f"Description: {agent.agent_description}",
+                f"Role: {agent.role}",
+                f"Model: {agent.model_name}",
+                f"Max Loops: {agent.max_loops}",
+                "\n",
+            ]
+        )
+
+    return "\n".join(agent_info).strip()

swarms/structs/multi_agent_orchestrator.py

@@ -18,7 +18,7 @@ from pydantic import BaseModel, Field
 from swarms.utils.function_caller_model import OpenAIFunctionCaller
 from swarms.structs.agent import Agent
 from swarms.structs.conversation import Conversation
-from swarms.structs.output_type import OutputType
+from swarms.structs.output_types import OutputType
 from swarms.utils.any_to_str import any_to_str
 
 

swarms/structs/output_types.py

@@ -14,3 +14,6 @@ OutputType = Literal[
     "string",
     "str",
 ]
+
+# Use the OutputType for type annotations
+output_type: OutputType