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

swarms/__init__.py

@@ -15,4 +15,3 @@ from swarms.structs import *  # noqa: E402, F403
 from swarms.telemetry import *  # noqa: E402, F403
 from swarms.tools import *  # noqa: E402, F403
 from swarms.utils import *  # noqa: E402, F403
-from swarms.client import *  # noqa: E402, F403

swarms/agents/cort_agent.py

@@ -0,0 +1,206 @@
+# AI generate initial response
+# AI decides how many "thinking rounds" it needs
+# For each round:
+# Generates 3 alternative responses
+# Evaluates all responses
+# Picks the best one
+# Final response is the survivor of this AI battle royale
+from swarms import Agent
+
+
+# OpenAI function schema for determining thinking rounds
+thinking_rounds_schema = {
+    "name": "determine_thinking_rounds",
+    "description": "Determines the optimal number of thinking rounds needed for a task",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "num_rounds": {
+                "type": "integer",
+                "description": "The number of thinking rounds needed (1-5)",
+                "minimum": 1,
+                "maximum": 5,
+            }
+        },
+        "required": ["num_rounds"],
+    },
+}
+
+# System prompt for determining thinking rounds
+THINKING_ROUNDS_PROMPT = """You are an expert at determining the optimal number of thinking rounds needed for complex tasks. Your role is to analyze the task and determine how many rounds of thinking and evaluation would be most beneficial.
+
+Consider the following factors when determining the number of rounds:
+1. Task Complexity: More complex tasks may require more rounds
+2. Potential for Multiple Valid Approaches: Tasks with multiple valid solutions need more rounds
+3. Risk of Error: Higher-stakes tasks may benefit from more rounds
+4. Time Sensitivity: Balance thoroughness with efficiency
+
+Guidelines for number of rounds:
+- 1 round: Simple, straightforward tasks with clear solutions
+- 2-3 rounds: Moderately complex tasks with some ambiguity
+- 4-5 rounds: Highly complex tasks with multiple valid approaches or high-stakes decisions
+
+Your response should be a single number between 1 and 5, representing the optimal number of thinking rounds needed."""
+
+# Schema for generating alternative responses
+alternative_responses_schema = {
+    "name": "generate_alternatives",
+    "description": "Generates multiple alternative responses to a task",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "alternatives": {
+                "type": "array",
+                "description": "List of alternative responses",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "response": {
+                            "type": "string",
+                            "description": "The alternative response",
+                        },
+                        "reasoning": {
+                            "type": "string",
+                            "description": "Explanation of why this approach was chosen",
+                        },
+                    },
+                    "required": ["response", "reasoning"],
+                },
+                "minItems": 3,
+                "maxItems": 3,
+            }
+        },
+        "required": ["alternatives"],
+    },
+}
+
+# Schema for evaluating responses
+evaluation_schema = {
+    "name": "evaluate_responses",
+    "description": "Evaluates and ranks alternative responses",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "evaluation": {
+                "type": "object",
+                "properties": {
+                    "best_response": {
+                        "type": "string",
+                        "description": "The selected best response",
+                    },
+                    "ranking": {
+                        "type": "array",
+                        "description": "Ranked list of responses from best to worst",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "response": {
+                                    "type": "string",
+                                    "description": "The response",
+                                },
+                                "score": {
+                                    "type": "number",
+                                    "description": "Score from 0-100",
+                                },
+                                "reasoning": {
+                                    "type": "string",
+                                    "description": "Explanation of the score",
+                                },
+                            },
+                            "required": [
+                                "response",
+                                "score",
+                                "reasoning",
+                            ],
+                        },
+                    },
+                },
+                "required": ["best_response", "ranking"],
+            }
+        },
+        "required": ["evaluation"],
+    },
+}
+
+# System prompt for generating alternatives
+ALTERNATIVES_PROMPT = """You are an expert at generating diverse and creative alternative responses to tasks. Your role is to generate 3 distinct approaches to solving the given task.
+
+For each alternative:
+1. Consider a different perspective or approach
+2. Provide clear reasoning for why this approach might be effective
+3. Ensure alternatives are meaningfully different from each other
+4. Maintain high quality and relevance to the task
+
+Your response should include 3 alternatives, each with its own reasoning."""
+
+# System prompt for evaluation
+EVALUATION_PROMPT = """You are an expert at evaluating and comparing different responses to tasks. Your role is to critically analyze each response and determine which is the most effective.
+
+Consider the following criteria when evaluating:
+1. Relevance to the task
+2. Completeness of the solution
+3. Creativity and innovation
+4. Practicality and feasibility
+5. Clarity and coherence
+
+Your response should include:
+1. The best response selected
+2. A ranked list of all responses with scores and reasoning"""
+
+
+class CortAgent:
+    def __init__(
+        self,
+        alternative_responses: int = 3,
+    ):
+        self.thinking_rounds = Agent(
+            agent_name="CortAgent",
+            agent_description="CortAgent is a multi-step agent that uses a battle royale approach to determine the best response to a task.",
+            model_name="gpt-4o-mini",
+            max_loops=1,
+            dynamic_temperature_enabled=True,
+            tools_list_dictionary=thinking_rounds_schema,
+            system_prompt=THINKING_ROUNDS_PROMPT,
+        )
+
+        self.alternatives_agent = Agent(
+            agent_name="CortAgentAlternatives",
+            agent_description="Generates multiple alternative responses to a task",
+            model_name="gpt-4o-mini",
+            max_loops=1,
+            dynamic_temperature_enabled=True,
+            tools_list_dictionary=alternative_responses_schema,
+            system_prompt=ALTERNATIVES_PROMPT,
+        )
+
+        self.evaluation_agent = Agent(
+            agent_name="CortAgentEvaluation",
+            agent_description="Evaluates and ranks alternative responses",
+            model_name="gpt-4o-mini",
+            max_loops=1,
+            dynamic_temperature_enabled=True,
+            tools_list_dictionary=evaluation_schema,
+            system_prompt=EVALUATION_PROMPT,
+        )
+
+    def run(self, task: str):
+        # First determine number of thinking rounds
+        num_rounds = self.thinking_rounds.run(task)
+
+        # Initialize with the task
+        current_task = task
+        best_response = None
+
+        # Run the battle royale for the determined number of rounds
+        for round_num in range(num_rounds):
+            # Generate alternatives
+            alternatives = self.alternatives_agent.run(current_task)
+
+            # Evaluate alternatives
+            evaluation = self.evaluation_agent.run(alternatives)
+
+            # Update best response and current task for next round
+            best_response = evaluation["evaluation"]["best_response"]
+            current_task = f"Previous best response: {best_response}\nOriginal task: {task}"
+
+        return best_response

swarms/agents/react_agent.py

@@ -0,0 +1,173 @@
+from swarms import Agent
+from typing import List
+
+
+# System prompt for REACT agent
+REACT_AGENT_PROMPT = """
+You are a REACT (Reason, Act, Observe) agent designed to solve tasks through an iterative process of reasoning and action. You maintain memory of previous steps to build upon past actions and observations.
+
+Your process follows these key components:
+
+1. MEMORY: Review and utilize previous steps
+   - Access and analyze previous observations
+   - Build upon past thoughts and plans
+   - Learn from previous actions
+   - Use historical context to make better decisions
+
+2. OBSERVE: Analyze current state
+   - Consider both new information and memory
+   - Identify relevant patterns from past steps
+   - Note any changes or progress made
+   - Evaluate success of previous actions
+
+3. THINK: Process and reason
+   - Combine new observations with historical knowledge
+   - Consider how past steps influence current decisions
+   - Identify patterns and learning opportunities
+   - Plan improvements based on previous outcomes
+
+4. PLAN: Develop next steps
+   - Create strategies that build on previous success
+   - Avoid repeating unsuccessful approaches
+   - Consider long-term goals and progress
+   - Maintain consistency with previous actions
+
+5. ACT: Execute with context
+   - Implement actions that progress from previous steps
+   - Build upon successful past actions
+   - Adapt based on learned experiences
+   - Maintain continuity in approach
+
+For each step, you should:
+- Reference relevant previous steps
+- Show how current decisions relate to past actions
+- Demonstrate learning and adaptation
+- Maintain coherent progression toward the goal
+
+Your responses should be structured, logical, and show clear reasoning that builds upon previous steps."""
+
+# Schema for REACT agent responses
+react_agent_schema = {
+    "type": "function",
+    "function": {
+        "name": "generate_react_response",
+        "description": "Generates a structured REACT agent response with memory of previous steps",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "memory_reflection": {
+                    "type": "string",
+                    "description": "Analysis of previous steps and their influence on current thinking",
+                },
+                "observation": {
+                    "type": "string",
+                    "description": "Current state observation incorporating both new information and historical context",
+                },
+                "thought": {
+                    "type": "string",
+                    "description": "Reasoning that builds upon previous steps and current observation",
+                },
+                "plan": {
+                    "type": "string",
+                    "description": "Structured plan that shows progression from previous actions",
+                },
+                "action": {
+                    "type": "string",
+                    "description": "Specific action that builds upon previous steps and advances toward the goal",
+                },
+            },
+            "required": [
+                "memory_reflection",
+                "observation",
+                "thought",
+                "plan",
+                "action",
+            ],
+        },
+    },
+}
+
+
+class ReactAgent:
+    def __init__(
+        self,
+        name: str = "react-agent-o1",
+        description: str = "A react agent that uses o1 preview to solve tasks",
+        model_name: str = "openai/gpt-4o",
+        max_loops: int = 1,
+    ):
+        self.name = name
+        self.description = description
+        self.model_name = model_name
+        self.max_loops = max_loops
+
+        self.agent = Agent(
+            agent_name=self.name,
+            agent_description=self.description,
+            model_name=self.model_name,
+            max_loops=1,
+            tools_list_dictionary=[react_agent_schema],
+            output_type="final",
+        )
+
+        # Initialize memory for storing steps
+        self.memory: List[str] = []
+
+    def step(self, task: str) -> str:
+        """Execute a single step of the REACT process.
+
+        Args:
+            task: The task description or current state
+
+        Returns:
+            String response from the agent
+        """
+        response = self.agent.run(task)
+        print(response)
+        return response
+
+    def run(self, task: str, *args, **kwargs) -> List[str]:
+        """Run the REACT agent for multiple steps with memory.
+
+        Args:
+            task: The initial task description
+            *args: Additional positional arguments
+            **kwargs: Additional keyword arguments
+
+        Returns:
+            List of all steps taken as strings
+        """
+        # Reset memory at the start of a new run
+        self.memory = []
+
+        current_task = task
+        for i in range(self.max_loops):
+            print(f"\nExecuting step {i+1}/{self.max_loops}")
+            step_result = self.step(current_task)
+            print(step_result)
+
+            # Store step in memory
+            self.memory.append(step_result)
+
+            # Update task with previous response and memory context
+            memory_context = (
+                "\n\nMemory of previous steps:\n"
+                + "\n".join(
+                    f"Step {j+1}:\n{step}"
+                    for j, step in enumerate(self.memory)
+                )
+            )
+
+            current_task = f"Previous response:\n{step_result}\n{memory_context}\n\nContinue with the original task: {task}"
+
+        return self.memory
+
+
+# if __name__ == "__main__":
+#     agent = ReactAgent(
+#         max_loops=1
+#     )  # Increased max_loops to see the iteration
+#     result = agent.run(
+#         "Write a short story about a robot that can fly."
+#     )
+#     print(result)

swarms/communication/base_communication.py

@@ -0,0 +1,290 @@
+from abc import ABC, abstractmethod
+from typing import List, Optional, Union, Dict, Any
+from enum import Enum
+from dataclasses import dataclass
+from pathlib import Path
+
+
+class MessageType(Enum):
+    """Enum for different types of messages in the conversation."""
+
+    SYSTEM = "system"
+    USER = "user"
+    ASSISTANT = "assistant"
+    FUNCTION = "function"
+    TOOL = "tool"
+
+
+@dataclass
+class Message:
+    """Data class representing a message in the conversation."""
+
+    role: str
+    content: Union[str, dict, list]
+    timestamp: Optional[str] = None
+    message_type: Optional[MessageType] = None
+    metadata: Optional[Dict] = None
+    token_count: Optional[int] = None
+
+
+class BaseCommunication(ABC):
+    """
+    Abstract base class defining the interface for conversation implementations.
+    This class provides the contract that all conversation implementations must follow.
+
+    Attributes:
+        system_prompt (Optional[str]): The system prompt for the conversation.
+        time_enabled (bool): Flag to enable time tracking for messages.
+        autosave (bool): Flag to enable automatic saving of conversation history.
+        save_filepath (str): File path for saving the conversation history.
+        tokenizer (Any): Tokenizer for counting tokens in messages.
+        context_length (int): Maximum number of tokens allowed in the conversation history.
+        rules (str): Rules for the conversation.
+        custom_rules_prompt (str): Custom prompt for rules.
+        user (str): The user identifier for messages.
+        auto_save (bool): Flag to enable auto-saving of conversation history.
+        save_as_yaml (bool): Flag to save conversation history as YAML.
+        save_as_json_bool (bool): Flag to save conversation history as JSON.
+        token_count (bool): Flag to enable token counting for messages.
+        cache_enabled (bool): Flag to enable prompt caching.
+    """
+
+    @staticmethod
+    def get_default_db_path(db_name: str) -> Path:
+        """Calculate the default database path in user's home directory.
+
+        Args:
+            db_name (str): Name of the database file (e.g. 'conversations.db')
+
+        Returns:
+            Path: Path object pointing to the database location
+        """
+        # Get user's home directory
+        home = Path.home()
+
+        # Create .swarms directory if it doesn't exist
+        swarms_dir = home / ".swarms" / "db"
+        swarms_dir.mkdir(parents=True, exist_ok=True)
+
+        return swarms_dir / db_name
+
+    @abstractmethod
+    def __init__(
+        self,
+        system_prompt: Optional[str] = None,
+        time_enabled: bool = False,
+        autosave: bool = False,
+        save_filepath: str = None,
+        tokenizer: Any = 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_json_bool: bool = False,
+        token_count: bool = True,
+        cache_enabled: bool = True,
+        *args,
+        **kwargs,
+    ):
+        """Initialize the communication interface."""
+        pass
+
+    @abstractmethod
+    def add(
+        self,
+        role: str,
+        content: Union[str, dict, list],
+        message_type: Optional[MessageType] = None,
+        metadata: Optional[Dict] = None,
+        token_count: Optional[int] = None,
+    ) -> int:
+        """Add a message to the conversation history."""
+        pass
+
+    @abstractmethod
+    def batch_add(self, messages: List[Message]) -> List[int]:
+        """Add multiple messages to the conversation history."""
+        pass
+
+    @abstractmethod
+    def delete(self, index: str):
+        """Delete a message from the conversation history."""
+        pass
+
+    @abstractmethod
+    def update(
+        self, index: str, role: str, content: Union[str, dict]
+    ):
+        """Update a message in the conversation history."""
+        pass
+
+    @abstractmethod
+    def query(self, index: str) -> Dict:
+        """Query a message in the conversation history."""
+        pass
+
+    @abstractmethod
+    def search(self, keyword: str) -> List[Dict]:
+        """Search for messages containing a keyword."""
+        pass
+
+    @abstractmethod
+    def get_str(self) -> str:
+        """Get the conversation history as a string."""
+        pass
+
+    @abstractmethod
+    def display_conversation(self, detailed: bool = False):
+        """Display the conversation history."""
+        pass
+
+    @abstractmethod
+    def export_conversation(self, filename: str):
+        """Export the conversation history to a file."""
+        pass
+
+    @abstractmethod
+    def import_conversation(self, filename: str):
+        """Import a conversation history from a file."""
+        pass
+
+    @abstractmethod
+    def count_messages_by_role(self) -> Dict[str, int]:
+        """Count messages by role."""
+        pass
+
+    @abstractmethod
+    def return_history_as_string(self) -> str:
+        """Return the conversation history as a string."""
+        pass
+
+    @abstractmethod
+    def get_messages(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> List[Dict]:
+        """Get messages with optional pagination."""
+        pass
+
+    @abstractmethod
+    def clear(self):
+        """Clear the conversation history."""
+        pass
+
+    @abstractmethod
+    def to_dict(self) -> List[Dict]:
+        """Convert the conversation history to a dictionary."""
+        pass
+
+    @abstractmethod
+    def to_json(self) -> str:
+        """Convert the conversation history to a JSON string."""
+        pass
+
+    @abstractmethod
+    def to_yaml(self) -> str:
+        """Convert the conversation history to a YAML string."""
+        pass
+
+    @abstractmethod
+    def save_as_json(self, filename: str):
+        """Save the conversation history as a JSON file."""
+        pass
+
+    @abstractmethod
+    def load_from_json(self, filename: str):
+        """Load the conversation history from a JSON file."""
+        pass
+
+    @abstractmethod
+    def save_as_yaml(self, filename: str):
+        """Save the conversation history as a YAML file."""
+        pass
+
+    @abstractmethod
+    def load_from_yaml(self, filename: str):
+        """Load the conversation history from a YAML file."""
+        pass
+
+    @abstractmethod
+    def get_last_message(self) -> Optional[Dict]:
+        """Get the last message from the conversation history."""
+        pass
+
+    @abstractmethod
+    def get_last_message_as_string(self) -> str:
+        """Get the last message as a formatted string."""
+        pass
+
+    @abstractmethod
+    def get_messages_by_role(self, role: str) -> List[Dict]:
+        """Get all messages from a specific role."""
+        pass
+
+    @abstractmethod
+    def get_conversation_summary(self) -> Dict:
+        """Get a summary of the conversation."""
+        pass
+
+    @abstractmethod
+    def get_statistics(self) -> Dict:
+        """Get statistics about the conversation."""
+        pass
+
+    @abstractmethod
+    def get_conversation_id(self) -> str:
+        """Get the current conversation ID."""
+        pass
+
+    @abstractmethod
+    def start_new_conversation(self) -> str:
+        """Start a new conversation and return its ID."""
+        pass
+
+    @abstractmethod
+    def delete_current_conversation(self) -> bool:
+        """Delete the current conversation."""
+        pass
+
+    @abstractmethod
+    def search_messages(self, query: str) -> List[Dict]:
+        """Search for messages containing specific text."""
+        pass
+
+    @abstractmethod
+    def update_message(
+        self,
+        message_id: int,
+        content: Union[str, dict, list],
+        metadata: Optional[Dict] = None,
+    ) -> bool:
+        """Update an existing message."""
+        pass
+
+    @abstractmethod
+    def get_conversation_metadata_dict(self) -> Dict:
+        """Get detailed metadata about the conversation."""
+        pass
+
+    @abstractmethod
+    def get_conversation_timeline_dict(self) -> Dict[str, List[Dict]]:
+        """Get the conversation organized by timestamps."""
+        pass
+
+    @abstractmethod
+    def get_conversation_by_role_dict(self) -> Dict[str, List[Dict]]:
+        """Get the conversation organized by roles."""
+        pass
+
+    @abstractmethod
+    def get_conversation_as_dict(self) -> Dict:
+        """Get the entire conversation as a dictionary with messages and metadata."""
+        pass
+
+    @abstractmethod
+    def truncate_memory_with_tokenizer(self):
+        """Truncate the conversation history based on token count."""
+        pass