swarms 7.9.2__py3-none-any.whl → 7.9.4__py3-none-any.whl

swarms/agents/reasoning_agents.py

@@ -1,4 +1,13 @@
-from typing import List, Literal, Dict, Callable, Any
+from typing import (
+    List,
+    Literal,
+    Dict,
+    Callable,
+    Any,
+    Tuple,
+    Hashable,
+)
+
 
 from swarms.agents.consistency_agent import SelfConsistencyAgent
 from swarms.agents.flexion_agent import ReflexionAgent
@@ -10,6 +19,7 @@ from swarms.agents.reasoning_duo import ReasoningDuo
 from swarms.utils.output_types import OutputType
 from swarms.agents.agent_judge import AgentJudge
 
+
 agent_types = Literal[
     "reasoning-duo",
     "self-consistency",
@@ -27,6 +37,7 @@ 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.
@@ -38,6 +49,9 @@ class ReasoningAgentRouter:
         output_type (OutputType): The format of the output (e.g., dict, list).
     """
 
+    # Class variable to store cached agent instances
+    _agent_cache: Dict[Tuple[Hashable, ...], Any] = {}
+
     def __init__(
         self,
         agent_name: str = "reasoning_agent",
@@ -63,16 +77,16 @@ class ReasoningAgentRouter:
         self.memory_capacity = memory_capacity
 
         # Added: Initialize the factory mapping dictionary
+
         self._initialize_agent_factories()
 
-    # Added: Factory method initialization function
     def _initialize_agent_factories(self) -> None:
         """
         Initialize the agent factory mapping dictionary, mapping various agent types to their respective creation functions.
-        This method replaces the original if-elif chain, making the code easier to maintain and extend.
+        This method replaces the original if-elif chain, making the code more maintainable and extensible.
         """
         self.agent_factories: Dict[str, Callable[[], Any]] = {
-            # ReasoningDuo factory methods
+            # ReasoningDuo factory method
             "reasoning-duo": self._create_reasoning_duo,
             "reasoning-agent": self._create_reasoning_duo,
             # SelfConsistencyAgent factory methods
@@ -87,9 +101,30 @@ class ReasoningAgentRouter:
             "GKPAgent": self._create_gkp_agent,
         }
 
-    # Added: Concrete factory methods for various agent types
+    def _get_cache_key(self) -> Tuple[Hashable, ...]:
+        """
+        Generate a unique key for cache lookup.
+        The key is based on all relevant configuration parameters of the agent.
+
+
+        Returns:
+            Tuple[Hashable, ...]: A hashable tuple to serve as the cache key
+        """
+        return (
+            self.swarm_type,
+            self.agent_name,
+            self.description,
+            self.model_name,
+            self.system_prompt,
+            self.max_loops,
+            self.num_samples,
+            self.output_type,
+            self.num_knowledge_items,
+            self.memory_capacity,
+        )
+
     def _create_reasoning_duo(self):
-        """Creates an agent instance for ReasoningDuo type"""
+        """Create an agent instance for the ReasoningDuo type"""
         return ReasoningDuo(
             agent_name=self.agent_name,
             agent_description=self.description,
@@ -99,7 +134,7 @@ class ReasoningAgentRouter:
         )
 
     def _create_consistency_agent(self):
-        """Creates an agent instance for SelfConsistencyAgent type"""
+        """Create an agent instance for the SelfConsistencyAgent type"""
         return SelfConsistencyAgent(
             agent_name=self.agent_name,
             description=self.description,
@@ -111,7 +146,7 @@ class ReasoningAgentRouter:
         )
 
     def _create_ire_agent(self):
-        """Creates an agent instance for IREAgent type"""
+        """Create an agent instance for the IREAgent type"""
         return IREAgent(
             agent_name=self.agent_name,
             description=self.description,
@@ -123,7 +158,7 @@ class ReasoningAgentRouter:
         )
 
     def _create_agent_judge(self):
-        """Creates an agent instance for AgentJudge type"""
+        """Create an agent instance for the AgentJudge type"""
         return AgentJudge(
             agent_name=self.agent_name,
             model_name=self.model_name,
@@ -132,7 +167,7 @@ class ReasoningAgentRouter:
         )
 
     def _create_reflexion_agent(self):
-        """Creates an agent instance for ReflexionAgent type"""
+        """Create an agent instance for the ReflexionAgent type"""
         return ReflexionAgent(
             agent_name=self.agent_name,
             system_prompt=self.system_prompt,
@@ -141,7 +176,7 @@ class ReasoningAgentRouter:
         )
 
     def _create_gkp_agent(self):
-        """Creates an agent instance for GKPAgent type"""
+        """Create an agent instance for the GKPAgent type"""
         return GKPAgent(
             agent_name=self.agent_name,
             model_name=self.model_name,
@@ -150,92 +185,42 @@ class ReasoningAgentRouter:
 
     def select_swarm(self):
         """
-        Selects and initializes the appropriate reasoning swarm based on the specified swarm type.
+        Select and initialize the appropriate reasoning swarm based on the specified swarm type.
+        Uses a caching mechanism to return a cached instance if an agent with the same configuration already exists.
+
+
         Returns:
-            An instance of the selected reasoning swarm.
-        """
-        # Commented out original if-elif chain implementation
-        """
-        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,
-            )
-
-        elif self.swarm_type == "AgentJudge":
-            return AgentJudge(
-                agent_name=self.agent_name,
-                model_name=self.model_name,
-                system_prompt=self.system_prompt,
-                max_loops=self.max_loops,
-            )
-
-        elif self.swarm_type == "ReflexionAgent":
-            return ReflexionAgent(
-                agent_name=self.agent_name,
-                system_prompt=self.system_prompt,
-                model_name=self.model_name,
-                max_loops=self.max_loops,
-            )
-
-        elif self.swarm_type == "GKPAgent":
-            return GKPAgent(
-                agent_name=self.agent_name,
-                model_name=self.model_name,
-                num_knowledge_items=self.num_knowledge_items,
-            )
-        else:
-            raise ValueError(f"Invalid swarm type: {self.swarm_type}")
+            The selected reasoning swarm instance.
         """
 
-        # Added: Implementation using factory pattern and dictionary mapping
+        # Generate cache key
+        cache_key = self._get_cache_key()
+
+        # Check if an instance with the same configuration already exists in the cache
+        if cache_key in self.__class__._agent_cache:
+            return self.__class__._agent_cache[cache_key]
+
         try:
-            # Get the corresponding creation function from the factory dictionary and call it
-            return self.agent_factories[self.swarm_type]()
+            # Use the factory method to create a new instance
+            agent = self.agent_factories[self.swarm_type]()
+
+            # Add the newly created instance to the cache
+            self.__class__._agent_cache[cache_key] = agent
+
+            return agent
         except KeyError:
-            # Maintain the same error handling as the original code
+            # Keep the same error handling as the original code
             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.
+        Execute the reasoning process of the selected swarm on a given task.
+
 
         Args:
             task (str): The task or question to be processed by the reasoning agent.
 
+
         Returns:
             The result of the reasoning process.
         """
@@ -244,15 +229,25 @@ class ReasoningAgentRouter:
 
     def batched_run(self, tasks: List[str], *args, **kwargs):
         """
-        Executes the reasoning process on a batch of tasks.
+        Execute the reasoning process on a batch of tasks.
+
 
         Args:
-            tasks (List[str]): A list of tasks to be processed.
+            tasks (List[str]): The list of tasks to process.
+
 
         Returns:
-            List of results from the reasoning process for each task.
+            A list of reasoning process results for each task.
         """
         results = []
         for task in tasks:
             results.append(self.run(task, *args, **kwargs))
         return results
+
+    @classmethod
+    def clear_cache(cls):
+        """
+        Clear the agent instance cache.
+        Use this when you need to free memory or force the creation of new instances.
+        """
+        cls._agent_cache.clear()

swarms/structs/agent.py

@@ -161,7 +161,6 @@ class AgentToolExecutionError(AgentError):
     pass
 
 
-# [FEAT][AGENT]
 class Agent:
     """
     Agent is the backbone to connect LLMs with tools and long term memory. Agent also provides the ability to
@@ -434,6 +433,7 @@ class Agent:
         output_raw_json_from_tool_call: bool = False,
         summarize_multiple_images: bool = False,
         tool_retry_attempts: int = 3,
+        speed_mode: str = "fast",
         *args,
         **kwargs,
     ):
@@ -574,6 +574,7 @@ class Agent:
         )
         self.summarize_multiple_images = summarize_multiple_images
         self.tool_retry_attempts = tool_retry_attempts
+        self.speed_mode = speed_mode
 
         # self.short_memory = self.short_memory_init()
 
@@ -1152,12 +1153,7 @@ class Agent:
                             self.save()
 
                         logger.error(
-                            f"Attempt {attempt+1}/{self.max_retries}: Error generating response in loop {loop_count} for agent '{self.agent_name}': {str(e)} | "
-                            f"Error type: {type(e).__name__}, Error details: {e.__dict__ if hasattr(e, '__dict__') else 'No additional details'} | "
-                            f"Current task: '{task}', Agent state: max_loops={self.max_loops}, "
-                            f"model={getattr(self.llm, 'model_name', 'unknown')}, "
-                            f"temperature={getattr(self.llm, 'temperature', 'unknown')}"
-                            f"{f' | Traceback: {e.__traceback__}' if hasattr(e, '__traceback__') else ''}"
+                            f"Attempt {attempt+1}/{self.retry_attempts}: Error generating response in loop {loop_count} for agent '{self.agent_name}': {str(e)} | "
                         )
                         attempt += 1
 
@@ -1237,6 +1233,192 @@ class Agent:
         except KeyboardInterrupt as error:
             self._handle_run_error(error)
 
+    def _run_fast(
+        self,
+        task: Optional[Union[str, Any]] = None,
+        img: Optional[str] = None,
+        print_task: Optional[bool] = False,
+        *args,
+        **kwargs,
+    ) -> Any:
+        """
+        run the agent
+
+        Args:
+            task (str): The task to be performed.
+            img (str): The image to be processed.
+            is_last (bool): Indicates if this is the last task.
+
+        Returns:
+            Any: The output of the agent.
+            (string, list, json, dict, yaml, xml)
+
+        Examples:
+            agent(task="What is the capital of France?")
+            agent(task="What is the capital of France?", img="path/to/image.jpg")
+            agent(task="What is the capital of France?", img="path/to/image.jpg", is_last=True)
+        """
+        try:
+
+            self.short_memory.add(role=self.user_name, content=task)
+
+            # Set the loop count
+            loop_count = 0
+
+            # Clear the short memory
+            response = None
+
+            # Query the long term memory first for the context
+            if self.long_term_memory is not None:
+                self.memory_query(task)
+
+            # Print the request
+            if print_task is True:
+                formatter.print_panel(
+                    content=f"\n User: {task}",
+                    title=f"Task Request for {self.agent_name}",
+                )
+
+            while (
+                self.max_loops == "auto"
+                or loop_count < self.max_loops
+            ):
+                loop_count += 1
+
+                if self.max_loops >= 2:
+                    self.short_memory.add(
+                        role=self.agent_name,
+                        content=f"Current Internal Reasoning Loop: {loop_count}/{self.max_loops}",
+                    )
+
+                # If it is the final loop, then add the final loop message
+                if loop_count >= 2 and loop_count == self.max_loops:
+                    self.short_memory.add(
+                        role=self.agent_name,
+                        content=f"🎉 Final Internal Reasoning Loop: {loop_count}/{self.max_loops} Prepare your comprehensive response.",
+                    )
+
+                # Dynamic temperature
+                if self.dynamic_temperature_enabled is True:
+                    self.dynamic_temperature()
+
+                # Task prompt
+                task_prompt = (
+                    self.short_memory.return_history_as_string()
+                )
+
+                # Parameters
+                attempt = 0
+                success = False
+                while attempt < self.retry_attempts and not success:
+                    try:
+                        if (
+                            self.long_term_memory is not None
+                            and self.rag_every_loop is True
+                        ):
+                            logger.info(
+                                "Querying RAG database for context..."
+                            )
+                            self.memory_query(task_prompt)
+
+                        if img is not None:
+                            response = self.call_llm(
+                                task=task_prompt,
+                                img=img,
+                                current_loop=loop_count,
+                                *args,
+                                **kwargs,
+                            )
+                        else:
+                            response = self.call_llm(
+                                task=task_prompt,
+                                current_loop=loop_count,
+                                *args,
+                                **kwargs,
+                            )
+
+                        # If streaming is enabled, then don't print the response
+
+                        # Parse the response from the agent with the output type
+                        if exists(self.tools_list_dictionary):
+                            if isinstance(response, BaseModel):
+                                response = response.model_dump()
+
+                        # Parse the response from the agent with the output type
+                        response = self.parse_llm_output(response)
+
+                        self.short_memory.add(
+                            role=self.agent_name,
+                            content=response,
+                        )
+
+                        # Print
+                        if self.print_on is True:
+                            if isinstance(response, list):
+                                self.pretty_print(
+                                    f"Structured Output - Attempting Function Call Execution [{time.strftime('%H:%M:%S')}] \n\n {format_data_structure(response)} ",
+                                    loop_count,
+                                )
+                            elif self.streaming_on is True:
+                                pass
+                            else:
+                                self.pretty_print(
+                                    response, loop_count
+                                )
+
+                        # Check and execute callable tools
+                        if exists(self.tools):
+                            self.tool_execution_retry(
+                                response, loop_count
+                            )
+
+                        # Handle MCP tools
+                        if (
+                            exists(self.mcp_url)
+                            or exists(self.mcp_config)
+                            or exists(self.mcp_urls)
+                        ):
+                            # Only handle MCP tools if response is not None
+                            if response is not None:
+                                self.mcp_tool_handling(
+                                    response=response,
+                                    current_loop=loop_count,
+                                )
+                            else:
+                                logger.warning(
+                                    f"LLM returned None response in loop {loop_count}, skipping MCP tool handling"
+                                )
+
+                        success = True  # Mark as successful to exit the retry loop
+
+                    except Exception as e:
+
+                        logger.error(
+                            f"Attempt {attempt+1}/{self.retry_attempts}: Error generating response in loop {loop_count} for agent '{self.agent_name}': {str(e)} | "
+                        )
+                        attempt += 1
+
+                if not success:
+
+                    logger.error(
+                        "Failed to generate a valid response after"
+                        " retry attempts."
+                    )
+                    break  # Exit the loop if all retry attempts fail
+
+            # log_agent_data(self.to_dict())
+
+            # Output formatting based on output_type
+            return history_output_formatter(
+                self.short_memory, type=self.output_type
+            )
+
+        except Exception as error:
+            self._handle_run_error(error)
+
+        except KeyboardInterrupt as error:
+            self._handle_run_error(error)
+
     def __handle_run_error(self, error: any):
         import traceback
 
@@ -2534,6 +2716,10 @@ class Agent:
             ValueError: If task is empty.
         """
 
+        # Filter out is_last from kwargs if present
+        if "is_last" in kwargs:
+            del kwargs["is_last"]
+
         try:
             # Set streaming parameter in LLM if streaming is enabled
             if self.streaming_on and hasattr(self.llm, "stream"):
@@ -2678,6 +2864,13 @@ class Agent:
                     *args,
                     **kwargs,
                 )
+            elif self.speed_mode == "fast":
+                output = self._run_fast(
+                    task=task,
+                    img=img,
+                    *args,
+                    **kwargs,
+                )
             else:
                 output = self._run(
                     task=task,