mixture of agents improvement and fix and example in docs with image

docs/mkdocs.yml

@@ -61,19 +61,19 @@ extra:
     provider: google
     property: G-MPE9C65596
 
-  alternate:
+  # alternate:
-    - name: English
+  #   - name: English
-      link: /
+  #     link: /
-      lang: en
+  #     lang: en
-    - name: 简体中文
+  #   - name: 简体中文
-      link: /zh/
+  #     link: /zh/
-      lang: zh
+  #     lang: zh
-    - name: 日本語
+  #   - name: 日本語
-      link: /ja/
+  #     link: /ja/
-      lang: ja
+  #     lang: ja
-    - name: 한국어
+  #   - name: 한국어
-      link: /ko/
+  #     link: /ko/
-      lang: ko
+  #     lang: ko
 
 theme:
   name: material
@@ -348,7 +348,8 @@ nav:
       - SwarmRouter Example: "swarms/examples/swarm_router.md"
       - MultiAgentRouter Minimal Example: "swarms/examples/multi_agent_router_minimal.md"
       - ConcurrentWorkflow Example: "swarms/examples/concurrent_workflow.md"
-      - MixtureOfAgents Example: "swarms/examples/mixture_of_agents.md"
+      # - MixtureOfAgents Example: "swarms/examples/mixture_of_agents.md"
+      - Mixture of Agents Example: "swarms/examples/moa_example.md"
       - Unique Swarms: "swarms/examples/unique_swarms.md"
       - Agents as Tools: "swarms/examples/agents_as_tools.md"
       - Aggregate Multi-Agent Responses: "swarms/examples/aggregate.md"

docs/swarms/examples/moa_example.md

@@ -0,0 +1,132 @@
+# Mixture of Agents Example
+
+The Mixture of Agents (MoA) is a sophisticated multi-agent architecture that implements parallel processing with iterative refinement. This approach processes multiple specialized agents simultaneously, concatenates their outputs, and then performs multiple parallel runs to achieve consensus or enhanced results.
+
+## How It Works
+
+1. **Parallel Processing**: Multiple agents work simultaneously on the same input
+2. **Output Concatenation**: Results from all agents are combined into a unified response
+3. **Iterative Refinement**: The process repeats for `n` layers/iterations to improve quality
+4. **Consensus Building**: Multiple runs help achieve more reliable and comprehensive outputs
+
+This architecture is particularly effective for complex tasks that benefit from diverse perspectives and iterative improvement, such as financial analysis, risk assessment, and multi-faceted problem solving.
+
+![Mixture of Agents](https://files.readme.io/ddb138e-moa-3layer.png)
+
+
+## Installation
+
+Install the swarms package using pip:
+
+```bash
+pip install -U swarms
+```
+
+## Basic Setup
+
+1. First, set up your environment variables:
+
+```python
+WORKSPACE_DIR="agent_workspace"
+ANTHROPIC_API_KEY=""
+```
+
+## Code
+
+```python
+from swarms import Agent, MixtureOfAgents
+
+# Agent 1: Risk Metrics Calculator
+risk_metrics_agent = Agent(
+    agent_name="Risk-Metrics-Calculator",
+    agent_description="Calculates key risk metrics like VaR, Sharpe ratio, and volatility",
+    system_prompt="""You are a risk metrics specialist. Calculate and explain:
+    - Value at Risk (VaR)
+    - Sharpe ratio
+    - Volatility
+    - Maximum drawdown
+    - Beta coefficient
+    
+    Provide clear, numerical results with brief explanations.""",
+    max_loops=1,
+    # model_name="gpt-4o-mini",
+    random_model_enabled=True,
+    dynamic_temperature_enabled=True,
+    output_type="str-all-except-first",
+    max_tokens=4096,
+)
+
+# Agent 2: Portfolio Risk Analyzer
+portfolio_risk_agent = Agent(
+    agent_name="Portfolio-Risk-Analyzer",
+    agent_description="Analyzes portfolio diversification and concentration risk",
+    system_prompt="""You are a portfolio risk analyst. Focus on:
+    - Portfolio diversification analysis
+    - Concentration risk assessment
+    - Correlation analysis
+    - Sector/asset allocation risk
+    - Liquidity risk evaluation
+    
+    Provide actionable insights for risk reduction.""",
+    max_loops=1,
+    # model_name="gpt-4o-mini",
+    random_model_enabled=True,
+    dynamic_temperature_enabled=True,
+    output_type="str-all-except-first",
+    max_tokens=4096,
+)
+
+# Agent 3: Market Risk Monitor
+market_risk_agent = Agent(
+    agent_name="Market-Risk-Monitor",
+    agent_description="Monitors market conditions and identifies risk factors",
+    system_prompt="""You are a market risk monitor. Identify and assess:
+    - Market volatility trends
+    - Economic risk factors
+    - Geopolitical risks
+    - Interest rate risks
+    - Currency risks
+    
+    Provide current risk alerts and trends.""",
+    max_loops=1,
+    # model_name="gpt-4o-mini",
+    random_model_enabled=True,
+    dynamic_temperature_enabled=True,
+    output_type="str-all-except-first",
+    max_tokens=4096,
+)
+
+
+swarm = MixtureOfAgents(
+    agents=[
+        risk_metrics_agent,
+        portfolio_risk_agent,
+        market_risk_agent,
+    ],
+    layers=1,
+    max_loops=1,
+    output_type="final",
+)
+
+
+out = swarm.run(
+    "Calculate VaR and Sharpe ratio for a portfolio with 15% annual return and 20% volatility"
+)
+
+print(out)
+```
+
+## Support and Community
+
+If you're facing issues or want to learn more, check out the following resources to join our Discord, stay updated on Twitter, and watch tutorials on YouTube!
+
+| Platform | Link | Description |
+|----------|------|-------------|
+| 📚 Documentation | [docs.swarms.world](https://docs.swarms.world) | Official documentation and guides |
+| 📝 Blog | [Medium](https://medium.com/@kyeg) | Latest updates and technical articles |
+| 💬 Discord | [Join Discord](https://discord.gg/jM3Z6M9uMq) | Live chat and community support |
+| 🐦 Twitter | [@kyegomez](https://twitter.com/kyegomez) | Latest news and announcements |
+| 👥 LinkedIn | [The Swarm Corporation](https://www.linkedin.com/company/the-swarm-corporation) | Professional network and updates |
+| 📺 YouTube | [Swarms Channel](https://www.youtube.com/channel/UC9yXyitkbU_WSy7bd_41SqQ) | Tutorials and demos |
+| 🎫 Events | [Sign up here](https://lu.ma/5p2jnc2v) | Join our community events |
+

mixture_of_agents_example.py

@@ -0,0 +1,80 @@
+from swarms import Agent, MixtureOfAgents
+
+# Agent 1: Risk Metrics Calculator
+risk_metrics_agent = Agent(
+    agent_name="Risk-Metrics-Calculator",
+    agent_description="Calculates key risk metrics like VaR, Sharpe ratio, and volatility",
+    system_prompt="""You are a risk metrics specialist. Calculate and explain:
+    - Value at Risk (VaR)
+    - Sharpe ratio
+    - Volatility
+    - Maximum drawdown
+    - Beta coefficient
+    
+    Provide clear, numerical results with brief explanations.""",
+    max_loops=1,
+    # model_name="gpt-4o-mini",
+    random_model_enabled=True,
+    dynamic_temperature_enabled=True,
+    output_type="str-all-except-first",
+    max_tokens=4096,
+)
+
+# Agent 2: Portfolio Risk Analyzer
+portfolio_risk_agent = Agent(
+    agent_name="Portfolio-Risk-Analyzer",
+    agent_description="Analyzes portfolio diversification and concentration risk",
+    system_prompt="""You are a portfolio risk analyst. Focus on:
+    - Portfolio diversification analysis
+    - Concentration risk assessment
+    - Correlation analysis
+    - Sector/asset allocation risk
+    - Liquidity risk evaluation
+    
+    Provide actionable insights for risk reduction.""",
+    max_loops=1,
+    # model_name="gpt-4o-mini",
+    random_model_enabled=True,
+    dynamic_temperature_enabled=True,
+    output_type="str-all-except-first",
+    max_tokens=4096,
+)
+
+# Agent 3: Market Risk Monitor
+market_risk_agent = Agent(
+    agent_name="Market-Risk-Monitor",
+    agent_description="Monitors market conditions and identifies risk factors",
+    system_prompt="""You are a market risk monitor. Identify and assess:
+    - Market volatility trends
+    - Economic risk factors
+    - Geopolitical risks
+    - Interest rate risks
+    - Currency risks
+    
+    Provide current risk alerts and trends.""",
+    max_loops=1,
+    # model_name="gpt-4o-mini",
+    random_model_enabled=True,
+    dynamic_temperature_enabled=True,
+    output_type="str-all-except-first",
+    max_tokens=4096,
+)
+
+
+swarm = MixtureOfAgents(
+    agents=[
+        risk_metrics_agent,
+        portfolio_risk_agent,
+        market_risk_agent,
+    ],
+    layers=1,
+    max_loops=1,
+    output_type="final",
+)
+
+
+out = swarm.run(
+    "Calculate VaR and Sharpe ratio for a portfolio with 15% annual return and 20% volatility"
+)
+
+print(out)

swarms/structs/ma_utils.py

@@ -5,8 +5,9 @@ import random
 def list_all_agents(
     agents: List[Union[Callable, Any]],
     conversation: Optional[Any] = None,
-    name: str = "",
+    name: Optional[str] = None,
-    add_to_conversation: bool = False,
+    description: Optional[str] = None,
+    add_to_conversation: Optional[bool] = False,
 ) -> str:
     """Lists all agents in a swarm and optionally adds them to a conversation.
 
@@ -27,6 +28,7 @@ def list_all_agents(
         >>> conversation = Conversation()
         >>> agent_info = list_all_agents(agents, conversation, "MySwarm")
         >>> print(agent_info)
+        Swarm: MySwarm
         Total Agents: 2
 
         Agent: Agent1
@@ -39,8 +41,15 @@ def list_all_agents(
     # Compile information about all agents
     total_agents = len(agents)
 
-    all_agents = f"Total Agents: {total_agents}\n\n" + "\n\n".join(
+    all_agents = f"Team Name: {name}\n" if name else ""
-        f"Agent: {agent.agent_name} \n\n Description: {agent.description or (agent.system_prompt[:50] + '...' if len(agent.system_prompt) > 50 else agent.system_prompt)}"
+    all_agents += (
+        f"Team Description: {description}\n" if description else ""
+    )
+    all_agents += f"Total Agents: {total_agents}\n\n"
+    all_agents += "| Agent | Description |\n"
+    all_agents += "|-------|-------------|\n"
+    all_agents += "\n".join(
+        f"| {agent.agent_name} | {agent.description or (agent.system_prompt[:50] + '...' if len(agent.system_prompt) > 50 else agent.system_prompt)} |"
         for agent in agents
     )
 
@@ -48,7 +57,7 @@ def list_all_agents(
         # Add the agent information to the conversation
         conversation.add(
             role="System",
-            content=f"All Agents Available in the Swarm {name}:\n\n{all_agents}",
+            content=all_agents,
         )
 
     return all_agents

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 = "final",
-        output_type: OutputType = "dict",
+        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:
+        if len(self.agents) == 0:
-            raise ValueError("No reference agents provided.")
+            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(
+    def save_to_markdown_file(self, file_path: str = "moa.md"):
-        self, system_prompt: str, results: List[str]
+        with open(file_path, "w") as f:
-    ) -> str:
+            f.write(self.conversation.get_str())
-        """
-        Constructs a system prompt for subsequent layers that includes previous responses.
 
-        Args:
+    def step(
-            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(
         self,
-        agent: Agent,
         task: str,
-        prev_responses: Optional[List[str]] = None,
+        img: Optional[str] = None,
-    ) -> str:
+        imgs: Optional[List[str]] = None,
-        """
+    ):
-        Asynchronous method to run a single agent.
+        # self.conversation.add(role="User", content=task)
 
-        Args:
+        # Run agents concurrently
-            agent (Agent): The agent to be run.
+        with concurrent.futures.ThreadPoolExecutor(
-            task (str): The task for the agent.
+            max_workers=os.cpu_count()
-            prev_responses (Optional[List[str]], optional): A list of previous responses. Defaults to None.
+        ) 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:
+            # Collect results and add to conversation in completion order
-            str: The response from the agent.
+            for future in concurrent.futures.as_completed(
-        """
+                future_to_agent
-        # If there are previous responses, update the agent's system prompt
+            ):
-        if prev_responses:
+                agent = future_to_agent[future]
-            system_prompt_with_responses = (
+                output = future.result()
-                self._get_final_system_prompt(
+                self.conversation.add(role=agent.name, content=output)
-                    self.aggregator_system_prompt, prev_responses
-                )
-            )
-            agent.system_prompt = system_prompt_with_responses
 
-        # Run the agent asynchronously
+        return self.conversation.get_str()
-        response = await asyncio.to_thread(agent.run, task)
 
-        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
+        self.conversation.add(role="User", content=task)
-        print(f"Agent {agent.agent_name} response: {response}")
-        return response
 
-    async def _run_async(self, task: str) -> None:
+        for i in range(self.layers):
-        """
+            out = self.step(
-        Asynchronous method to run the Mixture of Agents process.
+                task=self.conversation.get_str(), img=img, imgs=imgs
+            )
+            task = out
 
-        Args:
+        out = self.aggregator_agent.run(
-            task (str): The task for the mixture of agents.
+            task=self.conversation.get_str()
-        """
-        # Gather initial responses from reference agents
-        results: List[str] = await asyncio.gather(
-            *[
-                self._run_agent_async(agent, task)
-                for agent in self.agents
-            ]
         )
 
-        # Process additional layers, if applicable
+        self.conversation.add(
-        for _ in range(1, self.layers - 1):
+            role=self.aggregator_agent.agent_name, content=out
-            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
         )
 
-        print(f"Final Aggregated Response: {final_result}")
+        out = history_output_formatter(
+            conversation=self.conversation, type=self.output_type
+        )
 
-    def run(self, task: str) -> None:
+        return out
-        """
-        Synchronous wrapper to run the async process.
 
-        Args:
+    def run(
-            task (str): The task for the mixture of agents.
+        self,
-        """
+        task: str,
+        img: Optional[str] = None,
+        imgs: Optional[List[str]] = None,
+    ):
         try:
-            self.conversation.add("user", task)
+            return self._run(task=task, img=img, imgs=imgs)
-
-            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,
-            )
-
         except Exception as e:
-            logger.error(f"Error running mixture of agents: {str(e)}")
+            logger.error(f"Error running Mixture of Agents: {e}")
-            raise e
+            return f"Error: {e}"
 
     def run_batched(self, tasks: List[str]) -> List[str]:
         """