swarms 7.7.7__tar.gz → 7.7.9__tar.gz

{swarms-7.7.7 → swarms-7.7.9}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: swarms
-Version: 7.7.7
+Version: 7.7.9
 Summary: Swarms - TGSC
-Home-page: https://github.com/kyegomez/swarms
 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
 Author: Kye Gomez
@@ -15,6 +14,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Dist: PyYAML
 Requires-Dist: aiofiles
@@ -38,6 +38,7 @@ Requires-Dist: tenacity
 Requires-Dist: toml
 Requires-Dist: torch
 Project-URL: Documentation, https://docs.swarms.world
+Project-URL: Homepage, https://github.com/kyegomez/swarms
 Project-URL: Repository, https://github.com/kyegomez/swarms
 Description-Content-Type: text/markdown
 

{swarms-7.7.7 → swarms-7.7.9}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "swarms"
-version = "7.7.7"
+version = "7.7.9"
 description = "Swarms - TGSC"
 license = "MIT"
 authors = ["Kye Gomez <kye@apac.ai>"]
@@ -119,10 +119,3 @@ exclude = '''
 )/
 '''
 
-
-
-[tool.maturin]
-module-name = "swarms_rust"
-
-[tool.maturin.build]
-features = ["extension-module"]

{swarms-7.7.7 → swarms-7.7.9}/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-7.7.9/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-7.7.9/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)