swarms 7.8.3__py3-none-any.whl → 7.8.4__py3-none-any.whl

swarms/prompts/agent_conversation_aggregator.py

@@ -0,0 +1,38 @@
+AGGREGATOR_SYSTEM_PROMPT = """You are a highly skilled Aggregator Agent responsible for analyzing, synthesizing, and summarizing conversations between multiple AI agents. Your primary goal is to distill complex multi-agent interactions into clear, actionable insights.
+
+Key Responsibilities:
+1. Conversation Analysis:
+   - Identify the main topics and themes discussed
+   - Track the progression of ideas and problem-solving approaches
+   - Recognize key decisions and turning points in the conversation
+   - Note any conflicts, agreements, or important conclusions reached
+
+2. Agent Contribution Assessment:
+   - Evaluate each agent's unique contributions to the discussion
+   - Highlight complementary perspectives and insights
+   - Identify any knowledge gaps or areas requiring further exploration
+   - Recognize patterns in agent interactions and collaborative dynamics
+
+3. Summary Generation Guidelines:
+   - Begin with a high-level overview of the conversation's purpose and outcome
+   - Structure the summary in a logical, hierarchical manner
+   - Prioritize critical information while maintaining context
+   - Include specific examples or quotes when they significantly impact understanding
+   - Maintain objectivity while synthesizing different viewpoints
+   - Highlight actionable insights and next steps if applicable
+
+4. Quality Standards:
+   - Ensure accuracy in representing each agent's contributions
+   - Maintain clarity and conciseness without oversimplifying
+   - Use consistent terminology throughout the summary
+   - Preserve important technical details and domain-specific language
+   - Flag any uncertainties or areas needing clarification
+
+5. Output Format:
+   - Present information in a structured, easy-to-read format
+   - Use bullet points or sections for better readability when appropriate
+   - Include a brief conclusion or recommendation section if relevant
+   - Maintain professional and neutral tone throughout
+
+Remember: Your role is crucial in making complex multi-agent discussions accessible and actionable. Focus on extracting value from the conversation while maintaining the integrity of each agent's contributions.
+"""

swarms/structs/__init__.py

@@ -80,6 +80,8 @@ from swarms.structs.swarming_architectures import (
 from swarms.structs.auto_swarm_builder import AutoSwarmBuilder
 from swarms.structs.council_judge import CouncilAsAJudge
 from swarms.structs.batch_agent_execution import batch_agent_execution
+from swarms.structs.ma_blocks import aggregate
+
 
 __all__ = [
     "Agent",
@@ -150,4 +152,5 @@ __all__ = [
     "AutoSwarmBuilder",
     "CouncilAsAJudge",
     "batch_agent_execution",
+    "aggregate",
 ]

swarms/structs/conversation.py

@@ -1,13 +1,12 @@
 import concurrent.futures
 import datetime
-import hashlib
 import json
 import os
 import threading
 import uuid
 from typing import (
     TYPE_CHECKING,
-    Any,
+    Callable,
     Dict,
     List,
     Optional,
@@ -33,6 +32,25 @@ def generate_conversation_id():
     return str(uuid.uuid4())
 
 
+def get_conversation_dir():
+    """Get the directory for storing conversation logs."""
+    # Get the current working directory
+    conversation_dir = os.path.join(os.getcwd(), "conversations")
+    try:
+        os.makedirs(conversation_dir, mode=0o755, exist_ok=True)
+    except Exception as e:
+        logger.error(
+            f"Failed to create conversations directory: {str(e)}"
+        )
+        # Fallback to the same directory as the script
+        conversation_dir = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)),
+            "conversations",
+        )
+        os.makedirs(conversation_dir, mode=0o755, exist_ok=True)
+    return conversation_dir
+
+
 # Define available providers
 providers = Literal["mem0", "in-memory"]
 
@@ -58,10 +76,6 @@ class Conversation(BaseStructure):
         save_as_json_bool (bool): Flag to save conversation history as JSON.
         token_count (bool): Flag to enable token counting for messages.
         conversation_history (list): List to store the history of messages.
-        cache_enabled (bool): Flag to enable prompt caching.
-        cache_stats (dict): Statistics about cache usage.
-        cache_lock (threading.Lock): Lock for thread-safe cache operations.
-        conversations_dir (str): Directory to store cached conversations.
     """
 
     def __init__(
@@ -70,20 +84,20 @@ class Conversation(BaseStructure):
         name: str = None,
         system_prompt: Optional[str] = None,
         time_enabled: bool = False,
-        autosave: bool = False,
+        autosave: bool = False,  # Changed default to False
+        save_enabled: bool = False,  # New parameter to control if saving is enabled
         save_filepath: str = None,
-        tokenizer: Any = None,
+        load_filepath: str = None,  # New parameter to specify which file to load from
+        tokenizer: Callable = None,
         context_length: int = 8192,
         rules: str = None,
         custom_rules_prompt: str = None,
         user: str = "User:",
-        auto_save: bool = True,
-        save_as_yaml: bool = True,
+        save_as_yaml: bool = False,
         save_as_json_bool: bool = False,
         token_count: bool = True,
-        cache_enabled: bool = True,
-        conversations_dir: Optional[str] = None,
         provider: providers = "in-memory",
+        conversations_dir: Optional[str] = None,
         *args,
         **kwargs,
     ):
@@ -95,73 +109,87 @@ class Conversation(BaseStructure):
         self.system_prompt = system_prompt
         self.time_enabled = time_enabled
         self.autosave = autosave
-        self.save_filepath = save_filepath
+        self.save_enabled = save_enabled
+        self.conversations_dir = conversations_dir
+
+        # Handle save filepath
+        if save_enabled and save_filepath:
+            self.save_filepath = save_filepath
+        elif save_enabled and conversations_dir:
+            self.save_filepath = os.path.join(
+                conversations_dir, f"{self.id}.json"
+            )
+        else:
+            self.save_filepath = None
+
+        self.load_filepath = load_filepath
         self.conversation_history = []
         self.tokenizer = tokenizer
         self.context_length = context_length
         self.rules = rules
         self.custom_rules_prompt = custom_rules_prompt
         self.user = user
-        self.auto_save = auto_save
         self.save_as_yaml = save_as_yaml
         self.save_as_json_bool = save_as_json_bool
         self.token_count = token_count
-        self.cache_enabled = cache_enabled
         self.provider = provider
-        self.cache_stats = {
-            "hits": 0,
-            "misses": 0,
-            "cached_tokens": 0,
-            "total_tokens": 0,
-        }
-        self.cache_lock = threading.Lock()
-        self.conversations_dir = conversations_dir
 
+        # Create conversation directory if saving is enabled
+        if self.save_enabled and self.conversations_dir:
+            os.makedirs(self.conversations_dir, exist_ok=True)
+
+        # Try to load existing conversation or initialize new one
         self.setup()
 
     def setup(self):
-        # Set up conversations directory
-        self.conversations_dir = (
-            self.conversations_dir
-            or os.path.join(
-                os.path.expanduser("~"), ".swarms", "conversations"
-            )
-        )
-        os.makedirs(self.conversations_dir, exist_ok=True)
-
-        # Try to load existing conversation if it exists
-        conversation_file = os.path.join(
-            self.conversations_dir, f"{self.name}.json"
-        )
-        if os.path.exists(conversation_file):
-            with open(conversation_file, "r") as f:
-                saved_data = json.load(f)
-                # Update attributes from saved data
-                for key, value in saved_data.get(
-                    "metadata", {}
-                ).items():
-                    if hasattr(self, key):
-                        setattr(self, key, value)
-                self.conversation_history = saved_data.get(
-                    "history", []
+        """Set up the conversation by either loading existing data or initializing new."""
+        if self.load_filepath and os.path.exists(self.load_filepath):
+            try:
+                self.load_from_json(self.load_filepath)
+                logger.info(
+                    f"Loaded existing conversation from {self.load_filepath}"
+                )
+            except Exception as e:
+                logger.error(f"Failed to load conversation: {str(e)}")
+                self._initialize_new_conversation()
+        elif self.save_filepath and os.path.exists(
+            self.save_filepath
+        ):
+            try:
+                self.load_from_json(self.save_filepath)
+                logger.info(
+                    f"Loaded existing conversation from {self.save_filepath}"
                 )
+            except Exception as e:
+                logger.error(f"Failed to load conversation: {str(e)}")
+                self._initialize_new_conversation()
         else:
-            # If system prompt is not None, add it to the conversation history
-            if self.system_prompt is not None:
-                self.add("System", self.system_prompt)
-
-            if self.rules is not None:
-                self.add(self.user or "User", self.rules)
-
-            if self.custom_rules_prompt is not None:
-                self.add(
-                    self.user or "User", self.custom_rules_prompt
+            self._initialize_new_conversation()
+
+    def _initialize_new_conversation(self):
+        """Initialize a new conversation with system prompt and rules."""
+        if self.system_prompt is not None:
+            self.add("System", self.system_prompt)
+
+        if self.rules is not None:
+            self.add(self.user or "User", self.rules)
+
+        if self.custom_rules_prompt is not None:
+            self.add(self.user or "User", self.custom_rules_prompt)
+
+        if self.tokenizer is not None:
+            self.truncate_memory_with_tokenizer()
+
+    def _autosave(self):
+        """Automatically save the conversation if autosave is enabled."""
+        if self.autosave and self.save_filepath:
+            try:
+                self.save_as_json(self.save_filepath)
+            except Exception as e:
+                logger.error(
+                    f"Failed to autosave conversation: {str(e)}"
                 )
 
-            # If tokenizer then truncate
-            if self.tokenizer is not None:
-                self.truncate_memory_with_tokenizer()
-
     def mem0_provider(self):
         try:
             from mem0 import AsyncMemory
@@ -180,100 +208,6 @@ class Conversation(BaseStructure):
             )
             return None
 
-    def _generate_cache_key(
-        self, content: Union[str, dict, list]
-    ) -> str:
-        """Generate a cache key for the given content.
-
-        Args:
-            content (Union[str, dict, list]): The content to generate a cache key for.
-
-        Returns:
-            str: The cache key.
-        """
-        if isinstance(content, (dict, list)):
-            content = json.dumps(content, sort_keys=True)
-        return hashlib.md5(content.encode()).hexdigest()
-
-    def _get_cached_tokens(
-        self, content: Union[str, dict, list]
-    ) -> Optional[int]:
-        """Get the number of cached tokens for the given content.
-
-        Args:
-            content (Union[str, dict, list]): The content to check.
-
-        Returns:
-            Optional[int]: The number of cached tokens, or None if not cached.
-        """
-        if not self.cache_enabled:
-            return None
-
-        with self.cache_lock:
-            cache_key = self._generate_cache_key(content)
-            if cache_key in self.cache_stats:
-                self.cache_stats["hits"] += 1
-                return self.cache_stats[cache_key]
-            self.cache_stats["misses"] += 1
-            return None
-
-    def _update_cache_stats(
-        self, content: Union[str, dict, list], token_count: int
-    ):
-        """Update cache statistics for the given content.
-
-        Args:
-            content (Union[str, dict, list]): The content to update stats for.
-            token_count (int): The number of tokens in the content.
-        """
-        if not self.cache_enabled:
-            return
-
-        with self.cache_lock:
-            cache_key = self._generate_cache_key(content)
-            self.cache_stats[cache_key] = token_count
-            self.cache_stats["cached_tokens"] += token_count
-            self.cache_stats["total_tokens"] += token_count
-
-    def _save_to_cache(self):
-        """Save the current conversation state to the cache directory."""
-        if not self.conversations_dir:
-            return
-
-        conversation_file = os.path.join(
-            self.conversations_dir, f"{self.name}.json"
-        )
-
-        # Prepare metadata
-        metadata = {
-            "id": self.id,
-            "name": self.name,
-            "system_prompt": self.system_prompt,
-            "time_enabled": self.time_enabled,
-            "autosave": self.autosave,
-            "save_filepath": self.save_filepath,
-            "context_length": self.context_length,
-            "rules": self.rules,
-            "custom_rules_prompt": self.custom_rules_prompt,
-            "user": self.user,
-            "auto_save": self.auto_save,
-            "save_as_yaml": self.save_as_yaml,
-            "save_as_json_bool": self.save_as_json_bool,
-            "token_count": self.token_count,
-            "cache_enabled": self.cache_enabled,
-        }
-
-        # Prepare data to save
-        save_data = {
-            "metadata": metadata,
-            "history": self.conversation_history,
-            "cache_stats": self.cache_stats,
-        }
-
-        # Save to file
-        with open(conversation_file, "w") as f:
-            json.dump(save_data, f, indent=4)
-
     def add_in_memory(
         self,
         role: str,
@@ -287,9 +221,11 @@ class Conversation(BaseStructure):
             role (str): The role of the speaker (e.g., 'User', 'System').
             content (Union[str, dict, list]): The content of the message to be added.
         """
-        # Base message with role
+        # Base message with role and timestamp
         message = {
             "role": role,
+            "timestamp": datetime.datetime.now().isoformat(),
+            "message_id": str(uuid.uuid4()),
         }
 
         # Handle different content types
@@ -302,24 +238,20 @@ class Conversation(BaseStructure):
         else:
             message["content"] = content
 
-        # Check cache for token count
-        cached_tokens = self._get_cached_tokens(content)
-        if cached_tokens is not None:
-            message["token_count"] = cached_tokens
-            message["cached"] = True
-        else:
-            message["cached"] = False
-
-        # Add message to appropriate backend
+        # Add message to conversation history
         self.conversation_history.append(message)
 
-        if self.token_count is True and not message.get(
-            "cached", False
-        ):
+        if self.token_count is True:
             self._count_tokens(content, message)
 
-        # Save to cache after adding message
-        self._save_to_cache()
+        # Autosave after adding message, but only if saving is enabled
+        if self.autosave and self.save_enabled and self.save_filepath:
+            try:
+                self.save_as_json(self.save_filepath)
+            except Exception as e:
+                logger.error(
+                    f"Failed to autosave conversation: {str(e)}"
+                )
 
     def add_mem0(
         self,
@@ -367,8 +299,6 @@ class Conversation(BaseStructure):
                 tokens = count_tokens(any_to_str(content))
                 # Update the message that's already in the conversation history
                 message["token_count"] = int(tokens)
-                # Update cache stats
-                self._update_cache_stats(content, int(tokens))
 
                 # If autosave is enabled, save after token count is updated
                 if self.autosave:
@@ -413,7 +343,6 @@ class Conversation(BaseStructure):
             index (str): Index of the message to delete.
         """
         self.conversation_history.pop(index)
-        self._save_to_cache()
 
     def update(self, index: str, role, content):
         """Update a message in the conversation history.
@@ -427,7 +356,6 @@ class Conversation(BaseStructure):
             "role": role,
             "content": content,
         }
-        self._save_to_cache()
 
     def query(self, index: str):
         """Query a message in the conversation history.
@@ -462,9 +390,26 @@ class Conversation(BaseStructure):
             detailed (bool, optional): Flag to display detailed information. Defaults to False.
         """
         for message in self.conversation_history:
-            formatter.print_panel(
-                f"{message['role']}: {message['content']}\n\n"
-            )
+            content = message["content"]
+            role = message["role"]
+
+            # Format the message content
+            if isinstance(content, (dict, list)):
+                content = json.dumps(content, indent=2)
+
+            # Create the display string
+            display_str = f"{role}: {content}"
+
+            # Add details if requested
+            if detailed:
+                display_str += f"\nTimestamp: {message.get('timestamp', 'Unknown')}"
+                display_str += f"\nMessage ID: {message.get('message_id', 'Unknown')}"
+                if "token_count" in message:
+                    display_str += (
+                        f"\nTokens: {message['token_count']}"
+                    )
+
+            formatter.print_panel(display_str)
 
     def export_conversation(self, filename: str, *args, **kwargs):
         """Export the conversation history to a file.
@@ -531,9 +476,47 @@ class Conversation(BaseStructure):
         Args:
             filename (str): Filename to save the conversation history.
         """
-        if filename is not None:
-            with open(filename, "w") as f:
-                json.dump(self.conversation_history, f)
+        # Don't save if saving is disabled
+        if not self.save_enabled:
+            return
+
+        save_path = filename or self.save_filepath
+        if save_path is not None:
+            try:
+                # Prepare metadata
+                metadata = {
+                    "id": self.id,
+                    "name": self.name,
+                    "created_at": datetime.datetime.now().isoformat(),
+                    "system_prompt": self.system_prompt,
+                    "rules": self.rules,
+                    "custom_rules_prompt": self.custom_rules_prompt,
+                }
+
+                # Prepare save data
+                save_data = {
+                    "metadata": metadata,
+                    "history": self.conversation_history,
+                }
+
+                # Create directory if it doesn't exist
+                os.makedirs(
+                    os.path.dirname(save_path),
+                    mode=0o755,
+                    exist_ok=True,
+                )
+
+                # Write directly to file
+                with open(save_path, "w") as f:
+                    json.dump(save_data, f, indent=2)
+
+                # Only log explicit saves, not autosaves
+                if not self.autosave:
+                    logger.info(
+                        f"Successfully saved conversation to {save_path}"
+                    )
+            except Exception as e:
+                logger.error(f"Failed to save conversation: {str(e)}")
 
     def load_from_json(self, filename: str):
         """Load the conversation history from a JSON file.
@@ -541,9 +524,32 @@ class Conversation(BaseStructure):
         Args:
             filename (str): Filename to load from.
         """
-        if filename is not None:
-            with open(filename) as f:
-                self.conversation_history = json.load(f)
+        if filename is not None and os.path.exists(filename):
+            try:
+                with open(filename) as f:
+                    data = json.load(f)
+
+                # Load metadata
+                metadata = data.get("metadata", {})
+                self.id = metadata.get("id", self.id)
+                self.name = metadata.get("name", self.name)
+                self.system_prompt = metadata.get(
+                    "system_prompt", self.system_prompt
+                )
+                self.rules = metadata.get("rules", self.rules)
+                self.custom_rules_prompt = metadata.get(
+                    "custom_rules_prompt", self.custom_rules_prompt
+                )
+
+                # Load conversation history
+                self.conversation_history = data.get("history", [])
+
+                logger.info(
+                    f"Successfully loaded conversation from {filename}"
+                )
+            except Exception as e:
+                logger.error(f"Failed to load conversation: {str(e)}")
+                raise
 
     def search_keyword_in_conversation(self, keyword: str):
         """Search for a keyword in the conversation history.
@@ -600,7 +606,6 @@ class Conversation(BaseStructure):
     def clear(self):
         """Clear the conversation history."""
         self.conversation_history = []
-        self._save_to_cache()
 
     def to_json(self):
         """Convert the conversation history to a JSON string.
@@ -759,79 +764,121 @@ class Conversation(BaseStructure):
         """
         self.conversation_history.extend(messages)
 
-    def get_cache_stats(self) -> Dict[str, int]:
-        """Get statistics about cache usage.
-
-        Returns:
-            Dict[str, int]: Statistics about cache usage.
-        """
-        with self.cache_lock:
-            return {
-                "hits": self.cache_stats["hits"],
-                "misses": self.cache_stats["misses"],
-                "cached_tokens": self.cache_stats["cached_tokens"],
-                "total_tokens": self.cache_stats["total_tokens"],
-                "hit_rate": (
-                    self.cache_stats["hits"]
-                    / (
-                        self.cache_stats["hits"]
-                        + self.cache_stats["misses"]
-                    )
-                    if (
-                        self.cache_stats["hits"]
-                        + self.cache_stats["misses"]
-                    )
-                    > 0
-                    else 0
-                ),
-            }
+    def clear_memory(self):
+        """Clear the memory of the conversation."""
+        self.conversation_history = []
 
     @classmethod
     def load_conversation(
-        cls, name: str, conversations_dir: Optional[str] = None
+        cls,
+        name: str,
+        conversations_dir: Optional[str] = None,
+        load_filepath: Optional[str] = None,
     ) -> "Conversation":
-        """Load a conversation from the cache by name.
+        """Load a conversation from saved file by name or specific file.
 
         Args:
             name (str): Name of the conversation to load
-            conversations_dir (Optional[str]): Directory containing cached conversations
+            conversations_dir (Optional[str]): Directory containing conversations
+            load_filepath (Optional[str]): Specific file to load from
 
         Returns:
             Conversation: The loaded conversation object
         """
-        return cls(name=name, conversations_dir=conversations_dir)
+        if load_filepath:
+            return cls(
+                name=name,
+                load_filepath=load_filepath,
+                save_enabled=False,  # Don't enable saving when loading specific file
+            )
+
+        conv_dir = conversations_dir or get_conversation_dir()
+        # Try loading by name first
+        filepath = os.path.join(conv_dir, f"{name}.json")
+
+        # If not found by name, try loading by ID
+        if not os.path.exists(filepath):
+            filepath = os.path.join(conv_dir, f"{name}")
+            if not os.path.exists(filepath):
+                logger.warning(
+                    f"No conversation found with name or ID: {name}"
+                )
+                return cls(
+                    name=name,
+                    conversations_dir=conv_dir,
+                    save_enabled=True,
+                )
+
+        return cls(
+            name=name,
+            conversations_dir=conv_dir,
+            load_filepath=filepath,
+            save_enabled=True,
+        )
 
     @classmethod
-    def list_cached_conversations(
+    def list_conversations(
         cls, conversations_dir: Optional[str] = None
-    ) -> List[str]:
-        """List all cached conversations.
+    ) -> List[Dict[str, str]]:
+        """List all saved conversations.
 
         Args:
-            conversations_dir (Optional[str]): Directory containing cached conversations
+            conversations_dir (Optional[str]): Directory containing conversations
 
         Returns:
-            List[str]: List of conversation names (without .json extension)
+            List[Dict[str, str]]: List of conversation metadata
         """
-        if conversations_dir is None:
-            conversations_dir = os.path.join(
-                os.path.expanduser("~"), ".swarms", "conversations"
-            )
-
-        if not os.path.exists(conversations_dir):
+        conv_dir = conversations_dir or get_conversation_dir()
+        if not os.path.exists(conv_dir):
             return []
 
         conversations = []
-        for file in os.listdir(conversations_dir):
-            if file.endswith(".json"):
-                conversations.append(
-                    file[:-5]
-                )  # Remove .json extension
-        return conversations
+        seen_ids = (
+            set()
+        )  # Track seen conversation IDs to avoid duplicates
+
+        for filename in os.listdir(conv_dir):
+            if filename.endswith(".json"):
+                try:
+                    filepath = os.path.join(conv_dir, filename)
+                    with open(filepath) as f:
+                        data = json.load(f)
+                        metadata = data.get("metadata", {})
+                        conv_id = metadata.get("id")
+                        name = metadata.get("name")
+                        created_at = metadata.get("created_at")
+
+                        # Skip if we've already seen this ID or if required fields are missing
+                        if (
+                            not all([conv_id, name, created_at])
+                            or conv_id in seen_ids
+                        ):
+                            continue
+
+                        seen_ids.add(conv_id)
+                        conversations.append(
+                            {
+                                "id": conv_id,
+                                "name": name,
+                                "created_at": created_at,
+                                "filepath": filepath,
+                            }
+                        )
+                except json.JSONDecodeError:
+                    logger.warning(
+                        f"Skipping corrupted conversation file: {filename}"
+                    )
+                    continue
+                except Exception as e:
+                    logger.error(
+                        f"Failed to read conversation {filename}: {str(e)}"
+                    )
+                    continue
 
-    def clear_memory(self):
-        """Clear the memory of the conversation."""
-        self.conversation_history = []
+        # Sort by creation date, newest first
+        return sorted(
+            conversations, key=lambda x: x["created_at"], reverse=True
+        )
 
 
 # # Example usage

swarms/structs/ma_blocks.py

@@ -0,0 +1,84 @@
+from swarms.structs.agent import Agent
+from typing import List, Callable
+from swarms.structs.conversation import Conversation
+from swarms.structs.multi_agent_exec import run_agents_concurrently
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+    HistoryOutputType,
+)
+
+from swarms.prompts.agent_conversation_aggregator import (
+    AGGREGATOR_SYSTEM_PROMPT,
+)
+
+
+def aggregator_agent_task_prompt(
+    task: str, workers: List[Agent], conversation: Conversation
+):
+    return f"""
+    Please analyze and summarize the following multi-agent conversation, following your guidelines for comprehensive synthesis:
+
+    Conversation Context:
+    Original Task: {task}
+    Number of Participating Agents: {len(workers)}
+
+    Conversation Content:
+    {conversation.get_str()}
+
+    Please provide a 3,000 word comprehensive summary report of the conversation.
+    """
+
+
+def aggregate(
+    workers: List[Callable],
+    task: str = None,
+    type: HistoryOutputType = "all",
+    aggregator_model_name: str = "anthropic/claude-3-sonnet-20240229",
+):
+    """
+    Aggregate a list of tasks into a single task.
+    """
+
+    if task is None:
+        raise ValueError("Task is required in the aggregator block")
+
+    if workers is None:
+        raise ValueError(
+            "Workers is required in the aggregator block"
+        )
+
+    if not isinstance(workers, list):
+        raise ValueError("Workers must be a list of Callable")
+
+    if not all(isinstance(worker, Callable) for worker in workers):
+        raise ValueError("Workers must be a list of Callable")
+
+    conversation = Conversation()
+
+    aggregator_agent = Agent(
+        agent_name="Aggregator",
+        agent_description="Expert agent specializing in analyzing and synthesizing multi-agent conversations",
+        system_prompt=AGGREGATOR_SYSTEM_PROMPT,
+        max_loops=1,
+        model_name=aggregator_model_name,
+        output_type="final",
+        max_tokens=4000,
+    )
+
+    results = run_agents_concurrently(agents=workers, task=task)
+
+    # Zip the results with the agents
+    for result, agent in zip(results, workers):
+        conversation.add(content=result, role=agent.agent_name)
+
+    final_result = aggregator_agent.run(
+        task=aggregator_agent_task_prompt(task, workers, conversation)
+    )
+
+    conversation.add(
+        content=final_result, role=aggregator_agent.agent_name
+    )
+
+    return history_output_formatter(
+        conversation=conversation, type=type
+    )

swarms/structs/multi_agent_exec.py

@@ -1,3 +1,4 @@
+import concurrent.futures
 import asyncio
 import os
 import threading
@@ -5,7 +6,7 @@ from concurrent.futures import (
     ThreadPoolExecutor,
 )
 from dataclasses import dataclass
-from typing import Any, Callable, List, Union
+from typing import Any, Callable, List, Optional, Union
 
 import psutil
 
@@ -68,44 +69,42 @@ async def run_agents_concurrently_async(
 def run_agents_concurrently(
     agents: List[AgentType],
     task: str,
-    batch_size: int = None,
-    max_workers: int = None,
+    max_workers: Optional[int] = None,
 ) -> List[Any]:
     """
-    Optimized concurrent agent runner using both uvloop and ThreadPoolExecutor.
+    Optimized concurrent agent runner using ThreadPoolExecutor.
 
     Args:
         agents: List of Agent instances to run concurrently
         task: Task string to execute
-        batch_size: Number of agents to run in parallel in each batch (defaults to CPU count)
-        max_workers: Maximum number of threads in the executor (defaults to CPU count * 2)
+        max_workers: Maximum number of threads in the executor (defaults to 95% of CPU cores)
 
     Returns:
         List of outputs from each agent
     """
-    # Optimize defaults based on system resources
-    cpu_cores = os.cpu_count()
-    batch_size = batch_size or cpu_cores
-    max_workers = max_workers or cpu_cores * 2
+    if max_workers is None:
+        # 95% of the available CPU cores
+        num_cores = os.cpu_count()
+        max_workers = int(num_cores * 0.95) if num_cores else 1
 
     results = []
 
-    # Get or create event loop
-    try:
-        loop = asyncio.get_event_loop()
-    except RuntimeError:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-
-    # Create a shared thread pool executor with optimal worker count
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        # Process agents in batches
-        for i in range(0, len(agents), batch_size):
-            batch = agents[i : i + batch_size]
-            batch_results = loop.run_until_complete(
-                run_agents_concurrently_async(batch, task, executor)
-            )
-            results.extend(batch_results)
+    with concurrent.futures.ThreadPoolExecutor(
+        max_workers=max_workers
+    ) as executor:
+        # Submit all tasks and get futures
+        futures = [
+            executor.submit(agent.run, task) for agent in agents
+        ]
+
+        # Wait for all futures to complete and get results
+        for future in concurrent.futures.as_completed(futures):
+            try:
+                result = future.result()
+                results.append(result)
+            except Exception as e:
+                # Append the error if an agent fails
+                results.append(e)
 
     return results
 

swarms/structs/swarm_matcher.py

@@ -1,7 +1,6 @@
 import json
 from typing import List, Optional, Tuple
 
-import numpy as np
 from pydantic import BaseModel, Field
 from tenacity import retry, stop_after_attempt, wait_exponential
 
@@ -80,7 +79,7 @@ class SwarmMatcher:
         stop=stop_after_attempt(3),
         wait=wait_exponential(multiplier=1, min=4, max=10),
     )
-    def get_embedding(self, text: str) -> np.ndarray:
+    def get_embedding(self, text: str):
         """
         Generates an embedding for a given text using the configured model.
 
@@ -90,6 +89,7 @@ class SwarmMatcher:
         Returns:
             np.ndarray: The embedding vector for the text.
         """
+
         logger.debug(f"Getting embedding for text: {text[:50]}...")
         try:
             inputs = self.tokenizer(
@@ -141,6 +141,8 @@ class SwarmMatcher:
         Returns:
             Tuple[str, float]: A tuple containing the name of the best matching swarm type and the score.
         """
+        import numpy as np
+
         logger.debug(f"Finding best match for task: {task[:50]}...")
         try:
             task_embedding = self.get_embedding(task)

swarms/utils/vllm_wrapper.py

@@ -1,3 +1,5 @@
+import os
+import concurrent.futures
 from typing import List, Optional, Dict, Any
 from loguru import logger
 
@@ -131,16 +133,16 @@ class VLLMWrapper:
         Returns:
             List[str]: List of model responses.
         """
-        logger.info(
-            f"Running tasks in batches of size {batch_size}. Total tasks: {len(tasks)}"
-        )
-        results = []
-
-        for i in range(0, len(tasks), batch_size):
-            batch = tasks[i : i + batch_size]
-            for task in batch:
-                logger.info(f"Running task: {task}")
-                results.append(self.run(task))
-
-        logger.info("Completed all tasks.")
-        return results
+        # Fetch 95% of the available CPU cores
+        num_cores = os.cpu_count()
+        num_workers = int(num_cores * 0.95)
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=num_workers
+        ) as executor:
+            futures = [
+                executor.submit(self.run, task) for task in tasks
+            ]
+            return [
+                future.result()
+                for future in concurrent.futures.as_completed(futures)
+            ]

{swarms-7.8.3.dist-info → swarms-7.8.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: swarms
-Version: 7.8.3
+Version: 7.8.4
 Summary: Swarms - TGSC
 License: MIT
 Keywords: artificial intelligence,deep learning,optimizers,Prompt Engineering,swarms,agents,llms,transformers,multi-agent,swarms of agents,Enterprise-Grade Agents,Production-Grade Agents,Agents,Multi-Grade-Agents,Swarms,Transformers,LLMs,Prompt Engineering,Agents,Generative Agents,Generative AI,Agent Marketplace,Agent Store,quant,finance,algorithmic trading,portfolio optimization,risk management,financial modeling,machine learning for finance,natural language processing for finance

{swarms-7.8.3.dist-info → swarms-7.8.4.dist-info}/RECORD

@@ -32,6 +32,7 @@ swarms/prompts/__init__.py,sha256=ZFcghAs4b0Rsjcc_DIFssiztZub5tJ66rxmJD2_tXpQ,74
 swarms/prompts/accountant_swarm_prompts.py,sha256=swceN1B0fZCOedd3-y3gjNOHDmR-3H5YK17ytp7tTDM,11320
 swarms/prompts/ag_prompt.py,sha256=mMeqC84SMNrCjQcBeejroSXLuF_wWrVRebHU1MrEQko,4577
 swarms/prompts/aga.py,sha256=4rRG7r9LF9JBrGOLN4Hy_6cSe0z5YOeKFbGnOmRfFJ0,9156
+swarms/prompts/agent_conversation_aggregator.py,sha256=B7fi8INZUV2OLLYAfn9P8ghzDRfb6CqDdffzgvX3crE,2161
 swarms/prompts/agent_judge_prompt.py,sha256=-2q5mWLRyO7pj7j512ZNYRm-uEZttPgDGaxZo3oM_QQ,2235
 swarms/prompts/agent_prompt.py,sha256=6SXkMWcFIIAY02N9P6kMdzo4wtPwzg1Bl9R2qsIdicM,2705
 swarms/prompts/agent_prompts.py,sha256=63ZqAO1jfH3TKtl9ibLLagSG5kAPlbq4xtCGgGEuuoA,6886
@@ -97,7 +98,7 @@ swarms/schemas/agent_tool_schema.py,sha256=XdaKie6R0WhNXlnEl9f5T3hHmMedFbVwG17fd
 swarms/schemas/base_schemas.py,sha256=UvBLVWg2qRen4tK5GJz50v42SiX95EQ5qK7hfyAHTEU,3267
 swarms/schemas/llm_agent_schema.py,sha256=om3tPSjwbkIj2Hr38mKMLJvWs0E2BaE1jw2kzzd0Www,3020
 swarms/schemas/mcp_schemas.py,sha256=XZJ4HyiY_cv8Gvj-53ddjzXuqT9hBU2f0cHbhIKs_jY,1330
-swarms/structs/__init__.py,sha256=VEHVLHULQDqpCKGhBQ-oxiQAwP_9dI9K1mRF8WSYRvg,4231
+swarms/structs/__init__.py,sha256=plgl4yHp-4guyP6dk32KGFFU_Kc9G3bOY6wkFc8WBWw,4296
 swarms/structs/agent.py,sha256=MsPTIbIeOCa43eU6hIIp1pd8VSm07SjWB0he19msoyQ,100435
 swarms/structs/agent_builder.py,sha256=tYNpfO4_8cgfMHfgA5DAOWffHnt70p6CLt59esqfVCY,12133
 swarms/structs/agent_registry.py,sha256=il507cO1NF-d4ChyANVLuWrN8bXsEAi8_7bLJ_sTU6A,12112
@@ -111,7 +112,7 @@ swarms/structs/base_workflow.py,sha256=DTfFwX3AdFYxACDYwUDqhsbcDZnITlg5TeEYyxmJB
 swarms/structs/batch_agent_execution.py,sha256=d85DzeCq4uTbbPqLhAXFqFx_cxXUS5yRnJ1-gJkwU5w,1871
 swarms/structs/concat.py,sha256=utezSxNyh1mIwXgdf8-dJ803NDPyEy79WE8zJHuooGk,732
 swarms/structs/concurrent_workflow.py,sha256=OqXI-X-9a0hG2a7aLzobwd7CVF2ez0rgLj3ZHqri5bg,12952
-swarms/structs/conversation.py,sha256=88FgnM5tHOjC_F0TGRT04gkiPnE3tiept4ipnCO4iw8,27501
+swarms/structs/conversation.py,sha256=fnzBYzMt-Zk7bRwOeV41m7_IQz1YGFNqACzX4nmAXsY,30051
 swarms/structs/council_judge.py,sha256=siYDKiHMvFmShUTXxdo4R6vXiQhKt7bEBI205oC3kU4,19639
 swarms/structs/csv_to_agent.py,sha256=ug9JqQFPguXeU9JQpSUXuVtOpHYdJhlpKJUJBovo694,9443
 swarms/structs/de_hallucination_swarm.py,sha256=9cC0rSSXGwYu6SRDwpeMbCcQ40C1WI1RE9SNapKRLOQ,10309
@@ -122,6 +123,7 @@ swarms/structs/groupchat.py,sha256=jjH0BqU9Nrd_3jl9QzrcvbSce527SFpUaepawaRiw2o,1
 swarms/structs/hiearchical_swarm.py,sha256=2x3InS4HJg4T9Y195l_ANTGu6DYcllqCdJcR3v5Xuro,33402
 swarms/structs/hybrid_hiearchical_peer_swarm.py,sha256=D1iBtNNee_mxPoOWS5WGTqcci5FQKtt38mW-J42GvfM,9494
 swarms/structs/long_agent.py,sha256=KFjE2uUI8ONTkeJO43Sh3y5-Ec0kga28BECGklic-S4,15049
+swarms/structs/ma_blocks.py,sha256=dT7kzTp3MMyypPrGKR_OfurjNfcqjful0mEoIrT0z0A,2478
 swarms/structs/ma_utils.py,sha256=s8uTCplQtiFvxyqyTTTUCnJDMwNLJEuxbdGZyOURjLg,3244
 swarms/structs/majority_voting.py,sha256=F_t_MOC3YCRyMw5N6qKdFThpaXZxwixRw592Ku5Uhto,10122
 swarms/structs/malt.py,sha256=uLofKBWHkP3uNhyCkkgEyE4Z7qnOHTtcg-OTiR19x_Y,19572
@@ -130,7 +132,7 @@ swarms/structs/meme_agent_persona_generator.py,sha256=b3kKlumhsV4KV88-GS3CUnGO1U
 swarms/structs/mixture_of_agents.py,sha256=Ix2YTdrzISPQJLrQ5vrZtYOpZwIYDx0vUaNmvBwDDVM,7762
 swarms/structs/model_router.py,sha256=V5pZHYlxSmCvAA2Gsns7LaCz8dXtRi7pCvb-oLGHYIY,12739
 swarms/structs/multi_agent_collab.py,sha256=odh2NQRR23LidsphCxUfAke369lDdgL__w3Xovu9jkA,7731
-swarms/structs/multi_agent_exec.py,sha256=Gxwr9mHADX3n29pdxor-dQDnKPSNdnicpCxBLmPwnLg,14344
+swarms/structs/multi_agent_exec.py,sha256=3hIGgwJ_mQwgD16N096jN48-DEIZWFPoetR2nCxIe6I,14203
 swarms/structs/multi_agent_router.py,sha256=21PfswEuxMHqlWDBCyritj9UuHTShYVQRaK0o23eia8,10999
 swarms/structs/multi_model_gpu_manager.py,sha256=gHC6MmVia4etMD6RlpEdbqZtV7ng4f-6jVMH0Zrt8y4,47356
 swarms/structs/omni_agent_types.py,sha256=RdKLfZ-lXDJrEa0aJT_Rfx9TypJQo8SISqKz4fnLkAk,230
@@ -144,7 +146,7 @@ swarms/structs/stopping_conditions.py,sha256=JHHwqgPoUvjX897ofW2gpPZH_cqEWmv5lDT
 swarms/structs/swarm_arange.py,sha256=5ewEfL52Y4gh-a0lRjFcleHWlsCBuc5XR1nVEEGh07w,15481
 swarms/structs/swarm_eval.py,sha256=148E2R2zaCmt_LZYx15nmdFjybXHiQ2CZbl6pk77jNs,11635
 swarms/structs/swarm_id_generator.py,sha256=Wly7AtGM9e6VgzhYmfg8_gSOdxAdsOvWHJFK81cpQNQ,68
-swarms/structs/swarm_matcher.py,sha256=E2KwHHEJxmW-UfTeMPWZ6VCmYdQ_I9_fwrfJbxD02GY,23322
+swarms/structs/swarm_matcher.py,sha256=cV3xkoab9FiKTVL4C9Po6akNlWCMM4DFFj6xhINAqEM,23318
 swarms/structs/swarm_registry.py,sha256=P0XRrqp1qBNyt0BycqPQljUzKv9jClaQMhtaBMinhYg,5578
 swarms/structs/swarm_router.py,sha256=5zMhcWiNTTdQKH1D0oi8zsR0vH3AMESeNtsT57ArPgY,30673
 swarms/structs/swarming_architectures.py,sha256=q2XrY2lOqFhVckA8oin65Dz1VPUe-lfbEJHlP1Z8aTE,28278
@@ -195,11 +197,11 @@ swarms/utils/pdf_to_text.py,sha256=nkySOS_sJ4Jf4RP5SoDpMB5WfjJ_GGc5z8gJfn2cxOM,1
 swarms/utils/str_to_dict.py,sha256=T3Jsdjz87WIlkSo7jAW6BB80sv0Ns49WT1qXlOrdEoE,874
 swarms/utils/try_except_wrapper.py,sha256=uvDZDZJcH986EF0Ej6zZBLcqHJ58NHizPsAH5olrE7Q,3919
 swarms/utils/visualizer.py,sha256=0ylohEk62MAS6iPRaDOV03m9qo2k5J56tWlKJk_46p4,16927
-swarms/utils/vllm_wrapper.py,sha256=OIGnU9Vf81vE_hul1FK-xEhChFK8fxqZX6-fhQeW22c,4987
+swarms/utils/vllm_wrapper.py,sha256=AUoJuZhBc9iD70Uo400toAlIcY1P0LkA67eVau5rDhw,5067
 swarms/utils/wrapper_clusterop.py,sha256=PMSCVM7ZT1vgj1D_MYAe835RR3SMLYxA-si2JS02yNQ,4220
 swarms/utils/xml_utils.py,sha256=j8byUa56VT7V4e18pL8UBftLdyWKsUHbid1KDxnAWBo,1416
-swarms-7.8.3.dist-info/LICENSE,sha256=jwRtEmTWjLrEsvFB6QFdYs2cEeZPRMdj-UMOFkPF8_0,11363
-swarms-7.8.3.dist-info/METADATA,sha256=-MUnJFhqdfzWFjfdGiu6hIRq8-zHGJbthF6sdjNHcBE,94945
-swarms-7.8.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-swarms-7.8.3.dist-info/entry_points.txt,sha256=2K0rTtfO1X1WaO-waJlXIKw5Voa_EpAL_yU0HXE2Jgc,47
-swarms-7.8.3.dist-info/RECORD,,
+swarms-7.8.4.dist-info/LICENSE,sha256=jwRtEmTWjLrEsvFB6QFdYs2cEeZPRMdj-UMOFkPF8_0,11363
+swarms-7.8.4.dist-info/METADATA,sha256=dV2n6Kb8uRJa8-hF4AK4cpo_OM_S4cyoSyoWFhRanYM,94945
+swarms-7.8.4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+swarms-7.8.4.dist-info/entry_points.txt,sha256=2K0rTtfO1X1WaO-waJlXIKw5Voa_EpAL_yU0HXE2Jgc,47
+swarms-7.8.4.dist-info/RECORD,,