swarms 7.7.9__py3-none-any.whl → 7.8.0__py3-none-any.whl

swarms/structs/long_agent.py

@@ -0,0 +1,424 @@
+import concurrent.futures
+import os
+from typing import Union, List
+import PyPDF2
+import markdown
+from pathlib import Path
+from swarms.utils.litellm_tokenizer import count_tokens
+from swarms.structs.agent import Agent
+from swarms.structs.conversation import Conversation
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+)
+from swarms.utils.formatter import formatter
+
+
+class LongAgent:
+    """
+    A class to handle and process long-form content from various sources including PDFs,
+    markdown files, and large text documents.
+    """
+
+    def __init__(
+        self,
+        name: str = "LongAgent",
+        description: str = "A long-form content processing agent",
+        token_count_per_agent: int = 16000,
+        output_type: str = "final",
+        model_name: str = "gpt-4o-mini",
+        aggregator_model_name: str = "gpt-4o-mini",
+    ):
+        """Initialize the LongAgent."""
+        self.name = name
+        self.description = description
+        self.model_name = model_name
+        self.aggregator_model_name = aggregator_model_name
+        self.content = ""
+        self.metadata = {}
+        self.token_count_per_agent = token_count_per_agent
+        self.output_type = output_type
+        self.agents = []
+        self.conversation = Conversation()
+
+    def load_pdf(self, file_path: Union[str, Path]) -> str:
+        """
+        Load and extract text from a PDF file.
+
+        Args:
+            file_path (Union[str, Path]): Path to the PDF file
+
+        Returns:
+            str: Extracted text from the PDF
+        """
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(
+                f"PDF file not found at {file_path}"
+            )
+
+        text = ""
+        with open(file_path, "rb") as file:
+            pdf_reader = PyPDF2.PdfReader(file)
+            for page in pdf_reader.pages:
+                text += page.extract_text()
+
+        self.content = text
+        self.metadata["source"] = "pdf"
+        self.metadata["file_path"] = str(file_path)
+        return text
+
+    def load_markdown(self, file_path: Union[str, Path]) -> str:
+        """
+        Load and process a markdown file.
+
+        Args:
+            file_path (Union[str, Path]): Path to the markdown file
+
+        Returns:
+            str: Processed markdown content
+        """
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(
+                f"Markdown file not found at {file_path}"
+            )
+
+        with open(file_path, "r", encoding="utf-8") as file:
+            content = file.read()
+
+        # Convert markdown to HTML for processing
+        markdown.markdown(content)
+
+        self.content = content
+        self.metadata["source"] = "markdown"
+        self.metadata["file_path"] = str(file_path)
+        return content
+
+    def load_text(self, text: str) -> str:
+        """
+        Load and process a large text string.
+
+        Args:
+            text (str): The text content to process
+
+        Returns:
+            str: The processed text
+        """
+        self.content = text
+        self.metadata["source"] = "text"
+        return text
+
+    def get_content(self) -> str:
+        """
+        Get the current content being processed.
+
+        Returns:
+            str: The current content
+        """
+        return self.content
+
+    def get_metadata(self) -> dict:
+        """
+        Get the metadata associated with the current content.
+
+        Returns:
+            dict: The metadata dictionary
+        """
+        return self.metadata
+
+    def count_token_document(
+        self, file_path: Union[str, Path]
+    ) -> int:
+        """
+        Count the number of tokens in a document.
+
+        Args:
+            document (str): The document to count tokens for
+        """
+        if file_path.endswith(".pdf"):
+            count = count_tokens(self.load_pdf(file_path))
+            formatter.print_panel(
+                f"Token count for {file_path}: {count}",
+                title="Token Count",
+            )
+            print(f"Token count for {file_path}: {count}")
+        elif file_path.endswith(".md"):
+            count = count_tokens(self.load_markdown(file_path))
+            formatter.print_panel(
+                f"Token count for {file_path}: {count}",
+                title="Token Count",
+            )
+            print(f"Token count for {file_path}: {count}")
+        elif file_path.endswith(".txt"):
+            count = count_tokens(self.load_text(file_path))
+            formatter.print_panel(
+                f"Token count for {file_path}: {count}",
+                title="Token Count",
+            )
+            print(f"Token count for {file_path}: {count}")
+        else:
+            raise ValueError(f"Unsupported file type: {file_path}")
+        return count
+
+    def count_multiple_documents(
+        self, file_paths: List[Union[str, Path]]
+    ) -> int:
+        """
+        Count the number of tokens in multiple documents.
+
+        Args:
+            file_paths (List[Union[str, Path]]): The list of file paths to count tokens for
+
+        Returns:
+            int: Total token count across all documents
+        """
+        total_tokens = 0
+        # Calculate max_workers as 20% of CPU count
+        max_workers = max(1, int(os.cpu_count() * 0.2))
+
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=max_workers
+        ) as executor:
+            futures = [
+                executor.submit(self.count_token_document, file_path)
+                for file_path in file_paths
+            ]
+            for future in concurrent.futures.as_completed(futures):
+                try:
+                    total_tokens += future.result()
+                except Exception as e:
+                    formatter.print_panel(
+                        f"Error processing document: {str(e)}",
+                        title="Error",
+                    )
+                    continue
+        return total_tokens
+
+    def create_agents_for_documents(
+        self, file_paths: List[Union[str, Path]]
+    ) -> List[Agent]:
+        """
+        Create agents for each document chunk and process them.
+
+        Args:
+            file_paths (List[Union[str, Path]]): The list of file paths to create agents for
+
+        Returns:
+            List[Agent]: List of created agents
+        """
+        for file_path in file_paths:
+            # Load the document content
+            if str(file_path).endswith(".pdf"):
+                content = self.load_pdf(file_path)
+            elif str(file_path).endswith(".md"):
+                content = self.load_markdown(file_path)
+            else:
+                content = self.load_text(str(file_path))
+
+            # Split content into chunks based on token count
+            chunks = self._split_into_chunks(content)
+
+            # Create an agent for each chunk
+            for i, chunk in enumerate(chunks):
+                agent = Agent(
+                    agent_name=f"Document Analysis Agent - {Path(file_path).name} - Chunk {i+1}",
+                    system_prompt="""
+                    You are an expert document analysis and summarization agent specialized in processing and understanding complex documents. Your primary responsibilities include:
+
+                    1. Document Analysis:
+                    - Thoroughly analyze the provided document chunk
+                    - Identify key themes, main arguments, and important details
+                    - Extract critical information and relationships between concepts
+
+                    2. Summarization Capabilities:
+                    - Create concise yet comprehensive summaries
+                    - Generate both high-level overviews and detailed breakdowns
+                    - Highlight key points, findings, and conclusions
+                    - Maintain context and relationships between different sections
+
+                    3. Information Extraction:
+                    - Identify and extract important facts, figures, and data points
+                    - Recognize and preserve technical terminology and domain-specific concepts
+                    - Maintain accuracy in representing the original content
+
+                    4. Response Format:
+                    - Provide clear, structured responses
+                    - Use bullet points for key findings
+                    - Include relevant quotes or references when necessary
+                    - Maintain professional and academic tone
+
+                    5. Context Awareness:
+                    - Consider the document's purpose and target audience
+                    - Adapt your analysis based on the document type (academic, technical, general)
+                    - Preserve the original meaning and intent
+
+                    Your goal is to help users understand and extract value from this document chunk while maintaining accuracy and completeness in your analysis.
+                    """,
+                    model_name=self.model_name,
+                    max_loops=1,
+                    max_tokens=self.token_count_per_agent,
+                )
+
+                # Run the agent on the chunk
+                output = agent.run(
+                    f"Please analyze and summarize the following document chunk:\n\n{chunk}"
+                )
+
+                # Add the output to the conversation
+                self.conversation.add(
+                    role=agent.agent_name,
+                    content=output,
+                )
+
+                self.agents.append(agent)
+
+        return self.agents
+
+    def _split_into_chunks(self, content: str) -> List[str]:
+        """
+        Split content into chunks based on token count.
+
+        Args:
+            content (str): The content to split
+
+        Returns:
+            List[str]: List of content chunks
+        """
+        chunks = []
+        current_chunk = ""
+        current_tokens = 0
+
+        # Split content into sentences (simple approach)
+        sentences = content.split(". ")
+
+        for sentence in sentences:
+            sentence_tokens = count_tokens(sentence)
+
+            if (
+                current_tokens + sentence_tokens
+                > self.token_count_per_agent
+            ):
+                if current_chunk:
+                    chunks.append(current_chunk)
+                current_chunk = sentence
+                current_tokens = sentence_tokens
+            else:
+                current_chunk += (
+                    ". " + sentence if current_chunk else sentence
+                )
+                current_tokens += sentence_tokens
+
+        if current_chunk:
+            chunks.append(current_chunk)
+
+        return chunks
+
+    def count_total_agents(self) -> int:
+        """
+        Count the total number of agents.
+        """
+        count = len(self.agents)
+        formatter.print_panel(f"Total agents created: {count}")
+        return count
+
+    def _create_aggregator_agent(self) -> Agent:
+        """
+        Create an aggregator agent for synthesizing document summaries.
+
+        Returns:
+            Agent: The configured aggregator agent
+        """
+        return Agent(
+            agent_name="Document Aggregator Agent",
+            system_prompt="""
+            You are an expert document synthesis agent specialized in creating comprehensive reports from multiple document summaries. Your responsibilities include:
+
+            1. Synthesis and Integration:
+            - Combine multiple document summaries into a coherent narrative
+            - Identify and resolve any contradictions or inconsistencies
+            - Maintain logical flow and structure in the final report
+            - Preserve important details while eliminating redundancy
+
+            2. Report Structure:
+            - Create a clear, hierarchical structure for the report
+            - Include an executive summary at the beginning
+            - Organize content into logical sections with clear headings
+            - Ensure smooth transitions between different topics
+
+            3. Analysis and Insights:
+            - Identify overarching themes and patterns across summaries
+            - Draw meaningful conclusions from the combined information
+            - Highlight key findings and their implications
+            - Provide context and connections between different pieces of information
+
+            4. Quality Assurance:
+            - Ensure factual accuracy and consistency
+            - Maintain professional and academic tone
+            - Verify that all important information is included
+            - Check for clarity and readability
+
+            Your goal is to create a comprehensive, well-structured report that effectively synthesizes all the provided document summaries into a single coherent document.
+            """,
+            model_name=self.aggregator_model_name,
+            max_loops=1,
+            max_tokens=self.token_count_per_agent,
+        )
+
+    def run(self, file_paths: List[Union[str, Path]]) -> str:
+        """
+        Run the document processing pipeline and generate a comprehensive report.
+
+        Args:
+            file_paths (List[Union[str, Path]]): The list of file paths to process
+
+        Returns:
+            str: The final comprehensive report
+        """
+        # Count total tokens
+        total_tokens = self.count_multiple_documents(file_paths)
+        formatter.print_panel(
+            f"Total tokens: {total_tokens}", title="Total Tokens"
+        )
+
+        total_amount_of_agents = (
+            total_tokens / self.token_count_per_agent
+        )
+        formatter.print_panel(
+            f"Total amount of agents: {total_amount_of_agents}",
+            title="Total Amount of Agents",
+        )
+
+        # First, process all documents and create chunk agents
+        self.create_agents_for_documents(file_paths)
+
+        # Format the number of agents
+        # formatter.print_panel(f"Number of agents: {len(self.agents)}", title="Number of Agents")
+
+        # Create aggregator agent and collect summaries
+        aggregator_agent = self._create_aggregator_agent()
+        combined_summaries = self.conversation.get_str()
+
+        # Generate the final comprehensive report
+        final_report = aggregator_agent.run(
+            f"""
+            Please create a comprehensive report by synthesizing the following document summaries:
+
+            {combined_summaries}
+
+            Please structure your response as follows:
+            1. Executive Summary
+            2. Main Findings and Analysis
+            3. Key Themes and Patterns
+            4. Detailed Breakdown by Topic
+            5. Conclusions and Implications
+
+            Ensure the report is well-organized, comprehensive, and maintains a professional tone throughout.
+            """
+        )
+
+        # Add the final report to the conversation
+        self.conversation.add(
+            role="Document Aggregator Agent", content=final_report
+        )
+
+        return history_output_formatter(
+            conversation=self.conversation, type=self.output_type
+        )

swarms/structs/ma_utils.py

@@ -1,10 +1,9 @@
-from swarms.structs.agent import Agent
-from typing import List, Any, Optional, Union
+from typing import List, Any, Optional, Union, Callable
 import random
 
 
 def list_all_agents(
-    agents: List[Union[Agent, Any]],
+    agents: List[Union[Callable, Any]],
     conversation: Optional[Any] = None,
     name: str = "",
     add_to_conversation: bool = False,
@@ -74,17 +73,21 @@ models = [
 
 
 def set_random_models_for_agents(
-    agents: Union[List[Agent], Agent], model_names: List[str] = models
-) -> Union[List[Agent], Agent]:
-    """Sets random models for agents in the swarm.
+    agents: Optional[Union[List[Callable], Callable]] = None,
+    model_names: List[str] = models,
+) -> Union[List[Callable], Callable, str]:
+    """Sets random models for agents in the swarm or returns a random model name.
 
     Args:
-        agents (Union[List[Agent], Agent]): Either a single agent or a list of agents
+        agents (Optional[Union[List[Agent], Agent]]): Either a single agent, list of agents, or None
         model_names (List[str], optional): List of model names to choose from. Defaults to models.
 
     Returns:
-        Union[List[Agent], Agent]: The agent(s) with randomly assigned models
+        Union[List[Agent], Agent, str]: The agent(s) with randomly assigned models or a random model name
     """
+    if agents is None:
+        return random.choice(model_names)
+
     if isinstance(agents, list):
         return [
             setattr(agent, "model_name", random.choice(model_names))

swarms/structs/malt.py

@@ -198,7 +198,7 @@ class MALT:
             system_prompt=proof_verifier_prompt,
         )
 
-        majority_voting_agent = Agent(
+        Agent(
             agent_name="Majority-Voting-Agent",
             model_name="gpt-4o-mini",
             max_loops=1,

swarms/structs/swarm_router.py

@@ -24,6 +24,7 @@ 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
+from swarms.structs.council_judge import CouncilAsAJudge
 
 logger = initialize_logger(log_folder="swarm_router")
 
@@ -41,6 +42,7 @@ SwarmType = Literal[
     "MajorityVoting",
     "MALT",
     "DeepResearchSwarm",
+    "CouncilAsAJudge",
 ]
 
 
@@ -225,13 +227,7 @@ class SwarmRouter:
                 csv_path=self.csv_file_path
             ).load_agents()
 
-        # Log initialization
-        self._log(
-            "info",
-            f"SwarmRouter initialized with swarm type: {swarm_type}",
-        )
-
-        # Handle Automated Prompt Engineering
+    def setup(self):
         if self.auto_generate_prompts is True:
             self.activate_ape()
 
@@ -289,18 +285,52 @@ class SwarmRouter:
             raise RuntimeError(error_msg) from e
 
     def reliability_check(self):
-        logger.info("Initializing reliability checks")
+        """Perform reliability checks on swarm configuration.
 
-        if not self.agents:
-            raise ValueError("No agents provided for the swarm.")
+        Validates essential swarm parameters and configuration before execution.
+        Handles special case for CouncilAsAJudge which may not require agents.
+        """
+        logger.info(
+            "🔍 [SYSTEM] Initializing advanced swarm reliability diagnostics..."
+        )
+        logger.info(
+            "⚡ [SYSTEM] Running pre-flight checks and system validation..."
+        )
+
+        # Check swarm type first since it affects other validations
         if self.swarm_type is None:
+            logger.error(
+                "❌ [CRITICAL] Swarm type validation failed - type cannot be 'none'"
+            )
             raise ValueError("Swarm type cannot be 'none'.")
+
+        # Special handling for CouncilAsAJudge
+        if self.swarm_type == "CouncilAsAJudge":
+            if self.agents is not None:
+                logger.warning(
+                    "⚠️ [ADVISORY] CouncilAsAJudge detected with agents - this is atypical"
+                )
+        elif not self.agents:
+            logger.error(
+                "❌ [CRITICAL] Agent validation failed - no agents detected in swarm"
+            )
+            raise ValueError("No agents provided for the swarm.")
+
+        # Validate max_loops
         if self.max_loops == 0:
+            logger.error(
+                "❌ [CRITICAL] Loop validation failed - max_loops cannot be 0"
+            )
             raise ValueError("max_loops cannot be 0.")
 
+        # Setup other functionality
+        logger.info("🔄 [SYSTEM] Initializing swarm subsystems...")
+        self.setup()
+
         logger.info(
-            "Reliability checks completed your swarm is ready."
+            "✅ [SYSTEM] All reliability checks passed successfully"
         )
+        logger.info("🚀 [SYSTEM] Swarm is ready for deployment")
 
     def _create_swarm(
         self, task: str = None, *args, **kwargs
@@ -358,6 +388,15 @@ class SwarmRouter:
                 preset_agents=True,
             )
 
+        elif self.swarm_type == "CouncilAsAJudge":
+            return CouncilAsAJudge(
+                name=self.name,
+                description=self.description,
+                model_name=self.model_name,
+                output_type=self.output_type,
+                base_agent=self.agents[0] if self.agents else None,
+            )
+
         elif self.swarm_type == "DeepResearchSwarm":
             return DeepResearchSwarm(
                 name=self.name,
@@ -496,7 +535,14 @@ class SwarmRouter:
         self.logs.append(log_entry)
         logger.log(level.upper(), message)
 
-    def _run(self, task: str, img: str, *args, **kwargs) -> Any:
+    def _run(
+        self,
+        task: str,
+        img: str,
+        model_response: str,
+        *args,
+        **kwargs,
+    ) -> Any:
         """
         Dynamically run the specified task on the selected or matched swarm type.
 
@@ -520,7 +566,16 @@ class SwarmRouter:
             logger.info(
                 f"Running task on {self.swarm_type} swarm with task: {task}"
             )
-            result = self.swarm.run(task=task, *args, **kwargs)
+
+            if self.swarm_type == "CouncilAsAJudge":
+                result = self.swarm.run(
+                    task=task,
+                    model_response=model_response,
+                    *args,
+                    **kwargs,
+                )
+            else:
+                result = self.swarm.run(task=task, *args, **kwargs)
 
             logger.info("Swarm completed successfully")
             return result

swarms/tools/__init__.py

@@ -27,6 +27,13 @@ from swarms.tools.cohere_func_call_schema import (
 )
 from swarms.tools.tool_registry import ToolStorage, tool_registry
 from swarms.tools.json_utils import base_model_to_json
+from swarms.tools.mcp_client_call import (
+    execute_tool_call_simple,
+    _execute_tool_call_simple,
+    get_tools_for_multiple_mcp_servers,
+    get_mcp_tools_sync,
+    aget_mcp_tools,
+)
 
 
 __all__ = [
@@ -50,4 +57,9 @@ __all__ = [
     "ToolStorage",
     "tool_registry",
     "base_model_to_json",
+    "execute_tool_call_simple",
+    "_execute_tool_call_simple",
+    "get_tools_for_multiple_mcp_servers",
+    "get_mcp_tools_sync",
+    "aget_mcp_tools",
 ]