swarms 7.6.0__py3-none-any.whl → 7.6.2__py3-none-any.whl

swarms/structs/dynamic_conversational_swarm.py

@@ -0,0 +1,226 @@
+import json
+import random
+from swarms.structs.agent import Agent
+from typing import List
+from swarms.structs.conversation import Conversation
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+)
+from swarms.utils.any_to_str import any_to_str
+
+tools = [
+    {
+        "type": "function",
+        "function": {
+            "name": "select_agent",
+            "description": "Analyzes the input task and selects the most appropriate agent configuration, outputting both the agent name and the formatted response.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "respond_or_no_respond": {
+                        "type": "boolean",
+                        "description": "Whether the agent should respond to the response or not.",
+                    },
+                    "reasoning": {
+                        "type": "string",
+                        "description": "The reasoning behind the selection of the agent and response.",
+                    },
+                    "agent_name": {
+                        "type": "string",
+                        "description": "The name of the selected agent that is most appropriate for handling the given task.",
+                    },
+                    "response": {
+                        "type": "string",
+                        "description": "A clear and structured description of the response for the next agent.",
+                    },
+                },
+                "required": [
+                    "reasoning",
+                    "agent_name",
+                    "response",
+                    "respond_or_no_respond",
+                ],
+            },
+        },
+    },
+]
+
+
+class DynamicConversationalSwarm:
+    def __init__(
+        self,
+        name: str = "Dynamic Conversational Swarm",
+        description: str = "A swarm that uses a dynamic conversational model to solve complex tasks.",
+        agents: List[Agent] = [],
+        max_loops: int = 1,
+        output_type: str = "list",
+        *args,
+        **kwargs,
+    ):
+        self.name = name
+        self.description = description
+        self.agents = agents
+        self.max_loops = max_loops
+        self.output_type = output_type
+
+        self.conversation = Conversation()
+
+        # Agents in the chat
+        agents_in_chat = self.get_agents_info()
+        self.conversation.add(
+            role="Conversation Log", content=agents_in_chat
+        )
+
+        self.inject_tools()
+
+    # Inject tools into the agents
+    def inject_tools(self):
+        for agent in self.agents:
+            agent.tools_list_dictionary = tools
+
+    def parse_json_into_dict(self, json_str: str) -> dict:
+        try:
+            return json.loads(json_str)
+        except json.JSONDecodeError:
+            raise ValueError("Invalid JSON string")
+
+    def find_agent_by_name(self, agent_name: str) -> Agent:
+        for agent in self.agents:
+            if agent.name == agent_name:
+                return agent
+        raise ValueError(f"Agent with name {agent_name} not found")
+
+    def run_agent(self, agent_name: str, task: str) -> str:
+        agent = self.find_agent_by_name(agent_name)
+        return agent.run(task)
+
+    def fetch_random_agent_name(self) -> str:
+        return random.choice(self.agents).agent_name
+
+    def run(self, task: str) -> str:
+        """
+        Run the dynamic conversational swarm for a specified number of loops.
+        Each agent has access to the full conversation history.
+
+        Args:
+            task (str): The initial task/prompt to process
+
+        Returns:
+            str: The final response after all loops are complete
+        """
+        self.conversation.add(
+            role=f"{self.fetch_random_agent_name()}", content=task
+        )
+
+        # for loop in range(self.max_loops):
+        #     # Add loop marker to conversation for clarity
+        #     self.conversation.add(
+        #         role="System",
+        #         content=f"=== Starting Loop {loop + 1}/{self.max_loops} ==="
+        #     )
+
+        #     # First agent interaction
+        #     current_agent = self.randomly_select_agent()
+        #     response = self.run_agent(current_agent.name, self.conversation.get_str())
+        #     self.conversation.add(role=current_agent.name, content=any_to_str(response))
+
+        #     try:
+        #         # Parse response and get next agent
+        #         response_dict = self.parse_json_into_dict(response)
+
+        #         # Check if we should continue or end the loop
+        #         if not response_dict.get("respond_or_no_respond", True):
+        #             break
+
+        #         # Get the task description for the next agent
+        #         next_task = response_dict.get("task_description", self.conversation.get_str())
+
+        #         # Run the next agent with the specific task description
+        #         next_agent = self.find_agent_by_name(response_dict["agent_name"])
+        #         next_response = self.run_agent(next_agent.name, next_task)
+
+        #         # Add both the task description and response to the conversation
+        #         self.conversation.add(
+        #             role="System",
+        #             content=f"Response from {response_dict['agent_name']}: {next_task}"
+        #         )
+        #         self.conversation.add(role=next_agent.name, content=any_to_str(next_response))
+
+        #     except (ValueError, KeyError) as e:
+        #         self.conversation.add(
+        #             role="System",
+        #             content=f"Error in loop {loop + 1}: {str(e)}"
+        #         )
+        #         break
+
+        # Run first agent
+        current_agent = self.randomly_select_agent()
+        response = self.run_agent(
+            current_agent.agent_name, self.conversation.get_str()
+        )
+        self.conversation.add(
+            role=current_agent.agent_name,
+            content=any_to_str(response),
+        )
+
+        # Convert to json
+        response_dict = self.parse_json_into_dict(response)
+
+        # Fetch task
+        respone_two = response_dict["response"]
+        agent_name = response_dict["agent_name"]
+
+        print(f"Response from {agent_name}: {respone_two}")
+
+        # Run next agent
+        next_response = self.run_agent(
+            agent_name, self.conversation.get_str()
+        )
+        self.conversation.add(
+            role=agent_name, content=any_to_str(next_response)
+        )
+
+        # # Get the next agent
+        # response_three = self.parse_json_into_dict(next_response)
+        # agent_name_three = response_three["agent_name"]
+        # respone_four = response_three["response"]
+
+        # print(f"Response from {agent_name_three}: {respone_four}")
+        # # Run the next agent
+        # next_response = self.run_agent(agent_name_three, self.conversation.get_str())
+        # self.conversation.add(role=agent_name_three, content=any_to_str(next_response))
+
+        # Format and return the final conversation history
+        return history_output_formatter(
+            self.conversation, type=self.output_type
+        )
+
+    def randomly_select_agent(self) -> Agent:
+        return random.choice(self.agents)
+
+    def get_agents_info(self) -> str:
+        """
+        Fetches and formats information about all available agents in the system.
+
+        Returns:
+            str: A formatted string containing names and descriptions of all agents.
+        """
+        if not self.agents:
+            return "No agents currently available in the system."
+
+        agents_info = [
+            "Agents In the System:",
+            "",
+        ]  # Empty string for line spacing
+
+        for idx, agent in enumerate(self.agents, 1):
+            agents_info.extend(
+                [
+                    f"[Agent {idx}]",
+                    f"Name: {agent.name}",
+                    f"Description: {agent.description}",
+                    "",  # Empty string for line spacing between agents
+                ]
+            )
+
+        return "\n".join(agents_info).strip()

swarms/structs/hiearchical_swarm.py

@@ -8,7 +8,7 @@ from pydantic import BaseModel, Field
 from swarms.structs.agent import Agent
 from swarms.structs.base_swarm import BaseSwarm
 from swarms.structs.conversation import Conversation
-from swarms.structs.output_type import OutputType
+from swarms.structs.output_types import OutputType
 from swarms.utils.formatter import formatter
 
 from swarms.utils.function_caller_model import OpenAIFunctionCaller

swarms/structs/hybrid_hiearchical_peer_swarm.py

@@ -0,0 +1,273 @@
+import os
+from typing import List
+from swarms.structs.agent import Agent
+from swarms.structs.conversation import Conversation
+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{self.get_swarms_info()}",
+            tools_list_dictionary=tools,
+            model_name=router_agent_model_name,
+            max_loops=1,
+        )
+
+    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)
+
+        # 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"
+                )
+
+        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: missing swarm_name or task_description."
+            )
+
+        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
+
+    def get_swarms_info(self) -> 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 self.swarms:
+            return "No swarms currently available in the system."
+
+        swarm_info = [
+            "Available Swarms:",
+            "",
+        ]  # Empty string for line spacing
+
+        for idx, swarm in enumerate(self.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()

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_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

swarms/structs/rearrange.py

@@ -15,7 +15,7 @@ from swarms.structs.base_swarm import BaseSwarm
 from swarms.utils.loguru_logger import initialize_logger
 from swarms.telemetry.main import log_agent_data
 from swarms.structs.conversation import Conversation
-from swarms.structs.output_type import OutputType
+from swarms.structs.output_types import OutputType
 
 logger = initialize_logger(log_folder="rearrange")
 

swarms/structs/sequential_workflow.py

@@ -1,7 +1,7 @@
 from typing import List, Optional
 from swarms.structs.agent import Agent
 from swarms.structs.rearrange import AgentRearrange
-from swarms.structs.output_type import OutputType
+from swarms.structs.output_types import OutputType
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from swarms.utils.loguru_logger import initialize_logger
 

swarms/structs/swarm_router.py

@@ -18,9 +18,10 @@ from swarms.structs.rearrange import AgentRearrange
 from swarms.structs.sequential_workflow import SequentialWorkflow
 from swarms.structs.spreadsheet_swarm import SpreadSheetSwarm
 from swarms.structs.swarm_matcher import swarm_matcher
-from swarms.structs.output_type import OutputType
+from swarms.structs.output_types import OutputType
 from swarms.utils.loguru_logger import initialize_logger
 from swarms.structs.malt import MALT
+from swarms.structs.deep_research_swarm import DeepResearchSwarm
 
 logger = initialize_logger(log_folder="swarm_router")
 
@@ -37,6 +38,7 @@ SwarmType = Literal[
     "auto",
     "MajorityVoting",
     "MALT",
+    "DeepResearchSwarm",
 ]
 
 
@@ -316,6 +318,15 @@ class SwarmRouter:
                 preset_agents=True,
             )
 
+        elif self.swarm_type == "DeepResearchSwarm":
+            return DeepResearchSwarm(
+                name=self.name,
+                description=self.description,
+                agents=self.agents,
+                max_loops=self.max_loops,
+                output_type=self.output_type,
+            )
+
         elif self.swarm_type == "HiearchicalSwarm":
             return HierarchicalSwarm(
                 name=self.name,

swarms/structs/swarms_api.py

@@ -142,7 +142,7 @@ class SwarmsAPIClient:
     def __init__(
         self,
         api_key: Optional[str] = None,
-        base_url: str = "https://swarms-api-285321057562.us-east1.run.app",
+        base_url: str = "https://api.swarms.world",
         timeout: int = 30,
         max_retries: int = 3,
         format_type: Literal["pydantic", "json", "dict"] = "pydantic",

swarms/telemetry/main.py

@@ -1,5 +1,4 @@
 import hashlib
-import os
 import platform
 import socket
 import subprocess
@@ -279,12 +278,17 @@ def log_agent_data(data_dict: dict) -> dict | None:
     url = "https://swarms.world/api/get-agents/log-agents"
     headers = {
         "Content-Type": "application/json",
-        "Authorization": os.getenv("SWARMS_API_KEY"),
+        "Authorization": "sk-33979fd9a4e8e6b670090e4900a33dbe7452a15ccc705745f4eca2a70c88ea24",
+    }
+
+    data_input = {
+        "data": data_dict,
+        "system_data": get_user_device_data(),
     }
 
     try:
         response = requests.post(
-            url, json=data_dict, headers=headers, timeout=10
+            url, json=data_input, headers=headers, timeout=10
         )
         if (
             response.ok and response.text.strip()