swarms 7.5.2__tar.gz → 7.5.5__tar.gz

{swarms-7.5.2 → swarms-7.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: swarms
-Version: 7.5.2
+Version: 7.5.5
 Summary: Swarms - TGSC
 Home-page: https://github.com/kyegomez/swarms
 License: MIT

{swarms-7.5.2 → swarms-7.5.5}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "swarms"
-version = "7.5.2"
+version = "7.5.5"
 description = "Swarms - TGSC"
 license = "MIT"
 authors = ["Kye Gomez <kye@apac.ai>"]

{swarms-7.5.2 → swarms-7.5.5}/swarms/agents/__init__.py

@@ -16,6 +16,10 @@ from swarms.agents.create_agents_from_yaml import (
     create_agents_from_yaml,
 )
 
+from swarms.agents.i_agent import IterativeReflectiveExpansion
+from swarms.agents.consistency_agent import SelfConsistencyAgent
+from swarms.agents.reasoning_duo import ReasoningDuo
+
 __all__ = [
     # "ToolAgent",
     "check_done",
@@ -29,4 +33,7 @@ __all__ = [
     "check_exit",
     "check_end",
     "create_agents_from_yaml",
+    "IterativeReflectiveExpansion",
+    "SelfConsistencyAgent",
+    "ReasoningDuo",
 ]

swarms-7.5.5/swarms/agents/consistency_agent.py

@@ -0,0 +1,207 @@
+from collections import Counter
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import List
+
+from loguru import logger
+
+from swarms.structs.agent import Agent
+from swarms.structs.conversation import Conversation
+from swarms.structs.malt import majority_voting_prompt
+from swarms.structs.output_types import OutputType
+from swarms.utils.any_to_str import any_to_str
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+)
+
+CONSISTENCY_SYSTEM_PROMPT = """
+You are a reasoning agent designed for complex problem-solving and decision-making. Your objective is to provide clear and reliable responses through structured reasoning. Begin by thoroughly understanding the problem, rephrasing it for clarity, and identifying key components. Develop a logical plan that breaks the problem into manageable steps, detailing your approach and any assumptions made. Validate your information with reliable sources and assess the accuracy of your calculations. Explore multiple solutions, weighing their pros and cons, and maintain transparency by documenting your reasoning process, uncertainties, and biases. Summarize your findings in a concise final answer that reflects your thorough analysis, ensuring it is well-organized and accessible. Adapt your reasoning to the context of the problem, integrating new information as needed, and implement error-handling strategies to address any issues that arise. Finally, reflect on your reasoning process to identify areas for improvement and ensure consistency across all reasoning paths.
+"""
+
+
+def aggregation_agent(
+    responses: List[str],
+    prompt: str = majority_voting_prompt,
+    model_name: str = "gpt-4o-mini",
+) -> str:
+    """
+    Aggregates a list of responses into a single final answer.
+    """
+    task = any_to_str(responses)
+
+    agent = Agent(
+        agent_name="Aggregation-Agent",
+        description="An agent that aggregates a list of responses into a single final answer.",
+        model_name=model_name,
+        system_prompt=prompt,
+        max_loops=1,
+    )
+
+    final_answer = agent.run(task)
+
+    return final_answer
+
+
+class SelfConsistencyAgent(Agent):
+    def __init__(
+        self,
+        name: str = "Self-Consistency-Agent",
+        description: str = "An agent that uses self consistency to generate a final answer.",
+        system_prompt: str = CONSISTENCY_SYSTEM_PROMPT,
+        num_samples: int = 5,
+        max_loops: int = 1,
+        majority_voting_prompt: str = None,
+        eval: bool = False,
+        output_type: OutputType = "dict",
+        **kwargs,
+    ):
+        """
+        Initializes the SelfConsistencyAgent.
+
+        Args:
+            num_samples (int): Number of independent responses to sample.
+            **kwargs: Other keyword arguments passed to the base Agent.
+        """
+        super().__init__(
+            name=name,
+            description=description,
+            **kwargs,
+        )
+        self.num_samples = num_samples
+        self.conversation = Conversation()
+        self.max_loops = max_loops
+        self.majority_voting_prompt = majority_voting_prompt
+        self.eval = eval
+        self.output_type = output_type
+        self.system_prompt = system_prompt
+
+    def run(
+        self, task: str, answer: str = None, *args, **kwargs
+    ) -> str:
+        """
+        Generates multiple responses for the given prompt and aggregates them concurrently.
+
+        Args:
+            task (str): The input prompt.
+
+        Returns:
+            str: The aggregated final answer.
+        """
+        responses = []
+        logger.info(
+            f"Generating {self.num_samples} responses concurrently..."
+        )
+
+        self.conversation.add(role="User", content=task)
+
+        with ThreadPoolExecutor() as executor:
+            futures = {
+                executor.submit(super().run, task, *args, **kwargs): i
+                for i in range(self.num_samples)
+            }
+            for future in as_completed(futures):
+                response = future.result()
+                responses.append(response)
+
+        self.conversation.add(role=self.agent_name, content=responses)
+
+        if self.eval:
+            if answer is not None:
+                correct = self.check_responses_for_answer(
+                    responses, answer
+                )
+
+                if not correct:
+                    logger.info(
+                        "The answer is not correct. Please try again."
+                    )
+                    return None
+
+        # Aggregation agent
+        # final_answer = self.aggregation_agent(responses)
+
+        final_answer = aggregation_agent(responses)
+
+        self.conversation.add(
+            role="Majority Voting Agent", content=final_answer
+        )
+
+        return history_output_formatter(
+            self.conversation, self.output_type
+        )
+
+    def aggregate(self, responses: List[str]) -> str:
+        """
+        Aggregates a list of responses into a single final answer.
+
+        Here we use a simple majority vote (most common answer) as an example. Depending on
+        the task, you might need a more sophisticated aggregation (e.g., weighting, consensus reasoning, etc.).
+
+        Args:
+            responses (list of str): The list of responses.
+
+        Returns:
+            str: The aggregated answer.
+        """
+        # Count the frequency of each response.
+        counts = Counter(responses)
+        most_common, freq = counts.most_common(1)[0]
+        logger.info(
+            f"Aggregation complete. Most common response (appeared {freq} times):"
+        )
+        return most_common
+
+    def check_responses_for_answer(
+        self, responses: List[str], answer: str
+    ) -> bool:
+        """
+        Checks if the specified answer is present in any of the provided responses.
+
+        Args:
+            responses (List[str]): A list of responses to check.
+            answer (str): The answer to look for in the responses.
+
+        Returns:
+            bool: True if the answer is found in any response, False otherwise.
+        """
+        for response in responses:
+            if answer in response:
+                return True
+
+        # If the answer is not found, log the absence for each response
+        for response in responses:
+            if answer not in response:
+                self.conversation.add(
+                    role="User",
+                    content=f"The answer '{answer}' is not found in the response: '{response}'",
+                )
+                logger.info(
+                    f"The answer '{answer}' is not found in the response: '{response}'"
+                )
+        return False
+
+    def batched_run(
+        self, tasks: List[str], *args, **kwargs
+    ) -> List[str]:
+        """
+        Runs the agent in a batched manner.
+        """
+        responses = []
+        for task in tasks:
+            response = self.run(task, *args, **kwargs)
+            responses.append(response)
+        return responses
+
+
+# # Example usage:
+# if __name__ == "__main__":
+#     agent = SelfConsistencyAgent(
+#         agent_name="Reasoning-Agent",
+#         model_name="gpt-4o-mini",
+#         max_loops=1,
+#         num_samples=5,  # Number of samples for self consistency
+#     )
+
+#     prompt = "What is the 40th prime number?"
+#     final_answer = agent.run(prompt)
+#     print("\nFinal aggregated answer:")
+#     print(final_answer)

swarms-7.5.5/swarms/agents/i_agent.py

@@ -0,0 +1,302 @@
+"""
+Iterative Reflective Expansion (IRE) Algorithm
+
+A sophisticated reasoning framework that employs iterative hypothesis generation, simulation, and refinement to solve complex problems. IRE leverages a multi-step approach where an AI agent generates initial solution paths, evaluates their effectiveness through simulation, reflects on errors, and dynamically revises reasoning strategies. Through continuous cycles of hypothesis testing and meta-cognitive reflection, the algorithm progressively converges on optimal solutions by learning from both successful and unsuccessful reasoning attempts.
+
+
+- IRE is a multi-step approach where an AI agent generates initial solution paths, evaluates their effectiveness through simulation, reflects on errors, and dynamically revises reasoning strategies.
+- Through continuous cycles of hypothesis testing and meta-cognitive reflection, the algorithm progressively converges on optimal solutions by learning from both successful and unsuccessful reasoning attempts.
+
+
+Workflow:
+1. Generate initial hypotheses
+2. Simulate paths
+3. Reflect on errors
+4. Revise paths
+5. Select promising paths
+6. Synthesize solution
+
+"""
+
+from typing import List, Tuple
+from loguru import logger
+from swarms.structs.agent import Agent
+from swarms.structs.conversation import Conversation
+from swarms.structs.output_types import OutputType
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+)
+
+# Define a new system prompt for general problem solving
+GENERAL_REASONING_AGENT_SYS_PROMPT = """
+You are a highly capable problem-solving agent with a unique ability to reason through complex challenges via iterative reflection and hypothesis testing.
+Your role is to assist in generating innovative solutions to a wide array of general problems by engaging in trial and error, reflective evaluation, and dynamic hypothesis expansion.
+When presented with a problem statement, generate multiple hypotheses, simulate reasoning paths, reflect on errors, and iteratively refine your approach to produce the best solution.
+Do not include any finance-related content.
+
+"""
+
+
+class IterativeReflectiveExpansion:
+    """
+    A class implementing the Iterative Reflective Expansion (IRE) reasoning algorithm.
+
+    This algorithm leverages a Swarms agent to iteratively generate, simulate, reflect on, and refine reasoning paths
+    in order to solve complex problems through trial and error, reflective evaluation, and dynamic hypothesis expansion.
+    """
+
+    def __init__(
+        self,
+        agent_name: str = "General-Reasoning-Agent",
+        description: str = "A reasoning agent that can answer questions and help with tasks.",
+        agent: Agent = None,
+        max_iterations: int = 5,
+        system_prompt: str = GENERAL_REASONING_AGENT_SYS_PROMPT,
+        model_name: str = "gpt-4o-mini",
+        output_type: OutputType = "dict",
+    ) -> None:
+        """
+        Initialize the Iterative Reflective Expansion engine.
+
+        :param agent: The Swarms agent instance used to perform reasoning tasks.
+        :param max_iterations: Maximum number of iterations for the reasoning process.
+        """
+        self.agent_name = agent_name
+        self.description = description
+        self.agent = agent
+        self.max_iterations = max_iterations
+        self.output_type = output_type
+        self.system_prompt = system_prompt
+        self.conversation = Conversation()
+
+        self.agent = Agent(
+            agent_name=self.agent_name,
+            system_prompt=self.system_prompt,
+            model_name=model_name,
+            max_loops=1,
+            dynamic_temperature_enabled=True,
+        )
+
+    def generate_initial_hypotheses(self, task: str) -> List[str]:
+        """
+        Generate an initial set of reasoning hypotheses based on the problem input.
+
+        :param task: The problem statement.
+        :return: A list of candidate reasoning paths/hypotheses.
+        """
+        logger.info("Generating initial hypotheses for the problem.")
+        prompt = (
+            f"Given the following problem:\n\n"
+            f"'{task}'\n\n"
+            "Generate a list of possible approaches and strategies to solve it. "
+            "Present each approach on a new line."
+        )
+        response = self.agent.run(prompt)
+        self.conversation.add(
+            role=self.agent.agent_name, content=response
+        )
+        hypotheses = [
+            line.strip()
+            for line in response.split("\n")
+            if line.strip()
+        ]
+        logger.debug(f"Initial hypotheses: {hypotheses}")
+        return hypotheses
+
+    def simulate_path(self, path: str) -> Tuple[str, float, str]:
+        """
+        Simulate a given reasoning path and evaluate its effectiveness.
+
+        :param path: A candidate reasoning path.
+        :return: A tuple containing the simulated outcome, a numerical score (0.0 to 1.0), and error information.
+        """
+        logger.info(f"Simulating path: {path}")
+        prompt = (
+            f"Simulate the following reasoning path step by step and provide:\n"
+            f"1. Outcome: A brief summary of the resulting solution.\n"
+            f"2. Score: A numerical effectiveness score between 0.0 and 1.0.\n"
+            f"3. Errors: Any potential errors or shortcomings identified during the reasoning.\n\n"
+            f"Reasoning Path: {path}"
+        )
+        response = self.agent.run(prompt)
+        self.conversation.add(
+            role=self.agent.agent_name, content=response
+        )
+        outcome = ""
+        score = 0.0
+        error_info = ""
+        try:
+            # Expecting a response with lines starting with "Outcome:", "Score:", and "Errors:"
+            for line in response.splitlines():
+                if line.startswith("Outcome:"):
+                    outcome = line[len("Outcome:") :].strip()
+                elif line.startswith("Score:"):
+                    score = float(line[len("Score:") :].strip())
+                elif line.startswith("Errors:"):
+                    error_info = line[len("Errors:") :].strip()
+        except Exception as e:
+            logger.error(f"Error parsing simulation response: {e}")
+        logger.debug(
+            f"Simulated outcome: {outcome}, Score: {score}, Errors: {error_info}"
+        )
+        return outcome, score, error_info
+
+    def meta_reflect(self, error_info: str) -> str:
+        """
+        Perform meta-cognitive reflection on the provided error information.
+
+        :param error_info: Information regarding errors in the reasoning path.
+        :return: Feedback and suggestions for revising the reasoning path.
+        """
+        logger.info(
+            "Performing meta-reflection on error information."
+        )
+        prompt = (
+            f"Analyze the following error information and suggest modifications to improve the reasoning process:\n"
+            f"{error_info}\n"
+            "Provide clear and actionable feedback."
+        )
+        feedback = self.agent.run(prompt)
+        self.conversation.add(
+            role=self.agent.agent_name, content=feedback
+        )
+        logger.debug(f"Meta-reflection feedback: {feedback}")
+        return feedback
+
+    def revise_path(self, path: str, feedback: str) -> List[str]:
+        """
+        Revise the reasoning path based on the provided feedback.
+
+        :param path: The original reasoning path.
+        :param feedback: Feedback from meta-cognitive reflection.
+        :return: A list of revised reasoning paths.
+        """
+        logger.info("Revising reasoning path based on feedback.")
+        prompt = (
+            f"Given the reasoning path:\n'{path}'\n\n"
+            f"and the following feedback:\n'{feedback}'\n\n"
+            "Generate revised reasoning paths that address the issues raised. "
+            "Present each revised path on a new line."
+        )
+        response = self.agent.run(prompt)
+        self.conversation.add(
+            role=self.agent.agent_name, content=response
+        )
+        revised_paths = [
+            line.strip()
+            for line in response.split("\n")
+            if line.strip()
+        ]
+        logger.debug(f"Revised paths: {revised_paths}")
+        return revised_paths
+
+    def select_promising_paths(self, paths: List[str]) -> List[str]:
+        """
+        Select the most promising reasoning paths from a list of candidates.
+
+        :param paths: A list of candidate reasoning paths.
+        :return: A pruned list containing the most promising paths.
+        """
+        logger.info("Selecting promising reasoning paths.")
+        prompt = (
+            "Evaluate the following reasoning paths and select the ones that appear most promising for further exploration. "
+            "List each selected path on a new line:\n"
+            + "\n".join(paths)
+        )
+        response = self.agent.run(prompt)
+        self.conversation.add(
+            role=self.agent.agent_name, content=response
+        )
+        selected_paths = [
+            line.strip()
+            for line in response.split("\n")
+            if line.strip()
+        ]
+        logger.debug(f"Selected paths: {selected_paths}")
+        return selected_paths
+
+    def synthesize_solution(
+        self, paths: List[str], memory_pool: List[str]
+    ) -> str:
+        """
+        Synthesize a final solution from the promising reasoning paths and historical memory.
+
+        :param paths: The current promising reasoning paths.
+        :param memory_pool: A list of all previously generated reasoning paths.
+        :return: A coherent final solution.
+        """
+        logger.info(
+            "Synthesizing final solution from promising paths."
+        )
+        prompt = (
+            "Based on the following promising reasoning paths:\n"
+            f"{chr(10).join(paths)}\n\n"
+            "and the historical reasoning memory:\n"
+            f"{chr(10).join(memory_pool)}\n\n"
+            "Synthesize a final, coherent solution to the problem."
+        )
+        solution = self.agent.run(prompt)
+        self.conversation.add(
+            role=self.agent.agent_name, content=solution
+        )
+        logger.debug(f"Synthesized solution: {solution}")
+        return solution
+
+    def run(self, task: str) -> str:
+        """
+        Execute the Iterative Reflective Expansion process on the provided problem.
+
+        :param task: The problem statement.
+        :return: The final solution generated after iterative reasoning.
+        """
+        logger.info(
+            f"Starting iterative reflective expansion for problem: {task}"
+        )
+        candidate_paths = self.generate_initial_hypotheses(task)
+        memory_pool: List[str] = []
+
+        for iteration in range(self.max_iterations):
+            logger.info(
+                f"Iteration {iteration + 1}/{self.max_iterations}"
+            )
+            expanded_paths: List[str] = []
+
+            for path in candidate_paths:
+                outcome, score, error_info = self.simulate_path(path)
+                # Use a threshold score of 0.7 (this can be adjusted)
+                if score < 0.7:
+                    feedback = self.meta_reflect(error_info)
+                    revised_paths = self.revise_path(path, feedback)
+                    expanded_paths.extend(revised_paths)
+                else:
+                    expanded_paths.append(path)
+
+            memory_pool.extend(candidate_paths)
+            candidate_paths = self.select_promising_paths(
+                expanded_paths
+            )
+            logger.info(
+                f"Candidate paths for next iteration: {candidate_paths}"
+            )
+
+        self.synthesize_solution(candidate_paths, memory_pool)
+        logger.info("Final solution generated.")
+
+        return history_output_formatter(
+            self.conversation, self.output_type
+        )
+
+
+# def main() -> None:
+#     """
+#     Main function to execute the Iterative Reflective Expansion algorithm on a sample problem.
+#     """
+#     problem_statement = "What is the 40th prime number?"
+#     reasoning_engine = IterativeReflectiveExpansion(max_iterations=1)
+#     final_solution = reasoning_engine.run(problem_statement)
+#     print("Final Solution:")
+#     print(final_solution)
+
+
+# if __name__ == "__main__":
+#     main()

swarms-7.5.5/swarms/agents/reasoning_agents.py

@@ -0,0 +1,130 @@
+from typing import List, Literal
+
+from swarms.agents.consistency_agent import SelfConsistencyAgent
+from swarms.agents.i_agent import (
+    IterativeReflectiveExpansion as IREAgent,
+)
+from swarms.agents.reasoning_duo import ReasoningDuo
+from swarms.structs.output_types import OutputType
+
+agent_types = Literal[
+    "reasoning-duo",
+    "self-consistency",
+    "ire",
+    "reasoning-agent",
+    "consistency-agent",
+    "ire-agent",
+]
+
+
+class ReasoningAgentRouter:
+    """
+    A Reasoning Agent that can answer questions and assist with various tasks using different reasoning strategies.
+
+    Attributes:
+        agent_name (str): The name of the agent.
+        description (str): A brief description of the agent's capabilities.
+        model_name (str): The name of the model used for reasoning.
+        system_prompt (str): The prompt that guides the agent's reasoning process.
+        max_loops (int): The maximum number of loops for the reasoning process.
+        swarm_type (agent_types): The type of reasoning swarm to use (e.g., reasoning duo, self-consistency, IRE).
+        num_samples (int): The number of samples to generate for self-consistency agents.
+        output_type (OutputType): The format of the output (e.g., dict, list).
+    """
+
+    def __init__(
+        self,
+        agent_name: str = "reasoning_agent",
+        description: str = "A reasoning agent that can answer questions and help with tasks.",
+        model_name: str = "gpt-4o-mini",
+        system_prompt: str = "You are a helpful assistant that can answer questions and help with tasks.",
+        max_loops: int = 1,
+        swarm_type: agent_types = "reasoning_duo",
+        num_samples: int = 1,
+        output_type: OutputType = "dict",
+    ):
+        self.agent_name = agent_name
+        self.description = description
+        self.model_name = model_name
+        self.system_prompt = system_prompt
+        self.max_loops = max_loops
+        self.swarm_type = swarm_type
+        self.num_samples = num_samples
+        self.output_type = output_type
+
+    def select_swarm(self):
+        """
+        Selects and initializes the appropriate reasoning swarm based on the specified swarm type.
+
+        Returns:
+            An instance of the selected reasoning swarm.
+        """
+        if (
+            self.swarm_type == "reasoning-duo"
+            or self.swarm_type == "reasoning-agent"
+        ):
+            return ReasoningDuo(
+                agent_name=self.agent_name,
+                agent_description=self.description,
+                model_name=[self.model_name, self.model_name],
+                system_prompt=self.system_prompt,
+                output_type=self.output_type,
+            )
+
+        elif (
+            self.swarm_type == "self-consistency"
+            or self.swarm_type == "consistency-agent"
+        ):
+            return SelfConsistencyAgent(
+                agent_name=self.agent_name,
+                description=self.description,
+                model_name=self.model_name,
+                system_prompt=self.system_prompt,
+                max_loops=self.max_loops,
+                num_samples=self.num_samples,
+                output_type=self.output_type,
+            )
+
+        elif (
+            self.swarm_type == "ire" or self.swarm_type == "ire-agent"
+        ):
+            return IREAgent(
+                agent_name=self.agent_name,
+                description=self.description,
+                model_name=self.model_name,
+                system_prompt=self.system_prompt,
+                max_loops=self.max_loops,
+                max_iterations=self.num_samples,
+                output_type=self.output_type,
+            )
+
+        else:
+            raise ValueError(f"Invalid swarm type: {self.swarm_type}")
+
+    def run(self, task: str, *args, **kwargs):
+        """
+        Executes the selected swarm's reasoning process on the given task.
+
+        Args:
+            task (str): The task or question to be processed by the reasoning agent.
+
+        Returns:
+            The result of the reasoning process.
+        """
+        swarm = self.select_swarm()
+        return swarm.run(task=task)
+
+    def batched_run(self, tasks: List[str], *args, **kwargs):
+        """
+        Executes the reasoning process on a batch of tasks.
+
+        Args:
+            tasks (List[str]): A list of tasks to be processed.
+
+        Returns:
+            List of results from the reasoning process for each task.
+        """
+        results = []
+        for task in tasks:
+            results.append(self.run(task, *args, **kwargs))
+        return results