swarms 7.8.9__py3-none-any.whl → 7.9.0__py3-none-any.whl

swarms/structs/mixture_of_agents.py

@@ -1,17 +1,18 @@
-import asyncio
 import os
 from typing import List, Optional
 
 
 from swarms.structs.agent import Agent
 from swarms.prompts.ag_prompt import aggregator_system_prompt_main
+from swarms.structs.ma_utils import list_all_agents
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+)
 from swarms.utils.loguru_logger import initialize_logger
 import concurrent.futures
 from swarms.utils.output_types import OutputType
 from swarms.structs.conversation import Conversation
-from swarms.utils.history_output_formatter import (
-    history_output_formatter,
-)
+
 
 logger = initialize_logger(log_folder="mixture_of_agents")
 
@@ -25,13 +26,13 @@ class MixtureOfAgents:
         self,
         name: str = "MixtureOfAgents",
         description: str = "A class to run a mixture of agents and aggregate their responses.",
-        agents: List[Agent] = [],
+        agents: List[Agent] = None,
         aggregator_agent: Agent = None,
         aggregator_system_prompt: str = aggregator_system_prompt_main,
         layers: int = 3,
         max_loops: int = 1,
-        return_str_on: bool = False,
-        output_type: OutputType = "dict",
+        output_type: OutputType = "final",
+        aggregator_model_name: str = "claude-3-5-sonnet-20240620",
     ) -> None:
         """
         Initialize the Mixture of Agents class with agents and configuration.
@@ -48,16 +49,36 @@ class MixtureOfAgents:
         self.description = description
         self.agents = agents
         self.aggregator_agent = aggregator_agent
-        self.aggregator_system_prompt = aggregator_system_prompt_main
+        self.aggregator_system_prompt = aggregator_system_prompt
         self.layers = layers
         self.max_loops = max_loops
-        self.return_str_on = return_str_on
         self.output_type = output_type
+        self.aggregator_model_name = aggregator_model_name
+        self.aggregator_agent = self.aggregator_agent_setup()
 
         self.reliability_check()
 
         self.conversation = Conversation()
 
+        list_all_agents(
+            agents=self.agents,
+            conversation=self.conversation,
+            description=self.description,
+            name=self.name,
+            add_to_conversation=True,
+        )
+
+    def aggregator_agent_setup(self):
+        return Agent(
+            agent_name="Aggregator Agent",
+            description="An agent that aggregates the responses of the other agents.",
+            system_prompt=aggregator_system_prompt_main,
+            model_name=self.aggregator_model_name,
+            temperature=0.5,
+            max_loops=1,
+            output_type="str-all-except-first",
+        )
+
     def reliability_check(self) -> None:
         """
         Performs a reliability check on the Mixture of Agents class.
@@ -66,8 +87,8 @@ class MixtureOfAgents:
             "Checking the reliability of the Mixture of Agents class."
         )
 
-        if not self.agents:
-            raise ValueError("No reference agents provided.")
+        if len(self.agents) == 0:
+            raise ValueError("No agents provided.")
 
         if not self.aggregator_agent:
             raise ValueError("No aggregator agent provided.")
@@ -78,129 +99,83 @@ class MixtureOfAgents:
         if not self.layers:
             raise ValueError("No layers provided.")
 
-        if self.layers < 1:
-            raise ValueError("Layers must be greater than 0.")
-
         logger.info("Reliability check passed.")
         logger.info("Mixture of Agents class is ready for use.")
 
-    def _get_final_system_prompt(
-        self, system_prompt: str, results: List[str]
-    ) -> str:
-        """
-        Constructs a system prompt for subsequent layers that includes previous responses.
+    def save_to_markdown_file(self, file_path: str = "moa.md"):
+        with open(file_path, "w") as f:
+            f.write(self.conversation.get_str())
 
-        Args:
-            system_prompt (str): The initial system prompt.
-            results (List[str]): A list of previous responses.
-
-        Returns:
-            str: The final system prompt including previous responses.
-        """
-        return (
-            system_prompt
-            + "\n"
-            + "\n".join(
-                [
-                    f"{i+1}. {str(element)}"
-                    for i, element in enumerate(results)
-                ]
-            )
-        )
-
-    async def _run_agent_async(
+    def step(
         self,
-        agent: Agent,
         task: str,
-        prev_responses: Optional[List[str]] = None,
-    ) -> str:
-        """
-        Asynchronous method to run a single agent.
+        img: Optional[str] = None,
+        imgs: Optional[List[str]] = None,
+    ):
+        # self.conversation.add(role="User", content=task)
 
-        Args:
-            agent (Agent): The agent to be run.
-            task (str): The task for the agent.
-            prev_responses (Optional[List[str]], optional): A list of previous responses. Defaults to None.
+        # Run agents concurrently
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=os.cpu_count()
+        ) as executor:
+            # Submit all agent tasks and store with their index
+            future_to_agent = {
+                executor.submit(
+                    agent.run, task=task, img=img, imgs=imgs
+                ): agent
+                for agent in self.agents
+            }
 
-        Returns:
-            str: The response from the agent.
-        """
-        # If there are previous responses, update the agent's system prompt
-        if prev_responses:
-            system_prompt_with_responses = (
-                self._get_final_system_prompt(
-                    self.aggregator_system_prompt, prev_responses
-                )
-            )
-            agent.system_prompt = system_prompt_with_responses
+            # Collect results and add to conversation in completion order
+            for future in concurrent.futures.as_completed(
+                future_to_agent
+            ):
+                agent = future_to_agent[future]
+                output = future.result()
+                self.conversation.add(role=agent.name, content=output)
 
-        # Run the agent asynchronously
-        response = await asyncio.to_thread(agent.run, task)
+        return self.conversation.get_str()
 
-        self.conversation.add(agent.agent_name, response)
+    def _run(
+        self,
+        task: str,
+        img: Optional[str] = None,
+        imgs: Optional[List[str]] = None,
+    ):
 
-        # Log the agent's response
-        print(f"Agent {agent.agent_name} response: {response}")
-        return response
+        self.conversation.add(role="User", content=task)
 
-    async def _run_async(self, task: str) -> None:
-        """
-        Asynchronous method to run the Mixture of Agents process.
+        for i in range(self.layers):
+            out = self.step(
+                task=self.conversation.get_str(), img=img, imgs=imgs
+            )
+            task = out
 
-        Args:
-            task (str): The task for the mixture of agents.
-        """
-        # Gather initial responses from reference agents
-        results: List[str] = await asyncio.gather(
-            *[
-                self._run_agent_async(agent, task)
-                for agent in self.agents
-            ]
+        out = self.aggregator_agent.run(
+            task=self.conversation.get_str()
         )
 
-        # Process additional layers, if applicable
-        for _ in range(1, self.layers - 1):
-            results = await asyncio.gather(
-                *[
-                    self._run_agent_async(
-                        agent, task, prev_responses=results
-                    )
-                    for agent in self.agents
-                ]
-            )
-
-        # Perform final aggregation using the aggregator agent
-        final_result = await self._run_agent_async(
-            self.aggregator_agent, task, prev_responses=results
+        self.conversation.add(
+            role=self.aggregator_agent.agent_name, content=out
         )
 
-        print(f"Final Aggregated Response: {final_result}")
+        out = history_output_formatter(
+            conversation=self.conversation, type=self.output_type
+        )
 
-    def run(self, task: str) -> None:
-        """
-        Synchronous wrapper to run the async process.
+        return out
 
-        Args:
-            task (str): The task for the mixture of agents.
-        """
+    def run(
+        self,
+        task: str,
+        img: Optional[str] = None,
+        imgs: Optional[List[str]] = None,
+    ):
         try:
-            self.conversation.add("user", task)
-
-            for _ in range(self.max_loops):
-                # Add previous context to task if available
-                prompt = f"History: {self.conversation.get_str()}\n\nTask: {task}"
-
-                # Run async process
-                asyncio.run(self._run_async(prompt))
-
-            return history_output_formatter(
-                conversation=self.conversation,
-                type=self.output_type,
-            )
-
+            return self._run(task=task, img=img, imgs=imgs)
         except Exception as e:
-            logger.error(f"Error running mixture of agents: {str(e)}")
-            raise e
+            logger.error(f"Error running Mixture of Agents: {e}")
+            return f"Error: {e}"
 
     def run_batched(self, tasks: List[str]) -> List[str]:
         """