swarms 7.7.2__py3-none-any.whl → 7.7.3__py3-none-any.whl

swarms/structs/agent.py

@@ -1,4 +1,3 @@
-import concurrent.futures
 import asyncio
 import json
 import logging
@@ -46,12 +45,7 @@ from swarms.structs.safe_loading import (
 )
 from swarms.telemetry.main import log_agent_data
 from swarms.tools.base_tool import BaseTool
-
-# from swarms.tools.mcp_integration import (
-#     MCPServerSseParams,
-#     batch_mcp_flow,
-#     mcp_flow_get_tool_schema,
-# )
+from swarms.tools.mcp_integration import MCPServerSseParams
 from swarms.tools.tool_parse_exec import parse_and_execute_json
 from swarms.utils.any_to_str import any_to_str
 from swarms.utils.data_to_text import data_to_text
@@ -59,11 +53,18 @@ from swarms.utils.file_processing import create_file_in_folder
 from swarms.utils.formatter import formatter
 from swarms.utils.history_output_formatter import (
     history_output_formatter,
-    HistoryOutputType,
 )
 from swarms.utils.litellm_tokenizer import count_tokens
 from swarms.utils.litellm_wrapper import LiteLLM
 from swarms.utils.pdf_to_text import pdf_to_text
+from swarms.structs.output_types import OutputType
+from swarms.utils.str_to_dict import str_to_dict
+from swarms.tools.mcp_client import (
+    execute_mcp_tool,
+    list_tools_for_multiple_urls,
+    list_all,
+    find_and_execute_tool,
+)
 
 
 # Utils
@@ -335,7 +336,7 @@ class Agent:
         # [Tools]
         custom_tools_prompt: Optional[Callable] = None,
         tool_schema: ToolUsageType = None,
-        output_type: HistoryOutputType = "str",
+        output_type: OutputType = "str-all-except-first",
         function_calling_type: str = "json",
         output_cleaner: Optional[Callable] = None,
         function_calling_format_type: Optional[str] = "OpenAI",
@@ -392,7 +393,9 @@ class Agent:
         role: agent_roles = "worker",
         no_print: bool = False,
         tools_list_dictionary: Optional[List[Dict[str, Any]]] = None,
-        # mcp_servers: List[MCPServerSseParams] = [],
+        mcp_servers: MCPServerSseParams = None,
+        mcp_url: str = None,
+        mcp_urls: List[str] = None,
         *args,
         **kwargs,
     ):
@@ -512,105 +515,93 @@ class Agent:
         self.role = role
         self.no_print = no_print
         self.tools_list_dictionary = tools_list_dictionary
-        # self.mcp_servers = mcp_servers
+        self.mcp_servers = mcp_servers
+        self.mcp_url = mcp_url
+        self.mcp_urls = mcp_urls
 
         self._cached_llm = (
             None  # Add this line to cache the LLM instance
         )
-        self._default_model = (
-            "gpt-4o-mini"  # Move default model name here
-        )
 
+        self.short_memory = self.short_memory_init()
+
+        # Initialize the feedback
+        self.feedback = []
+
+        # self.init_handling()
+        # Define tasks as pairs of (function, condition)
+        # Each task will only run if its condition is True
+        self.setup_config()
+
+        if exists(self.docs_folder):
+            self.get_docs_from_doc_folders()
+
+        if exists(self.tools):
+            self.handle_tool_init()
+
+        if exists(self.tool_schema) or exists(self.list_base_models):
+            self.handle_tool_schema_ops()
+
+        if exists(self.sop) or exists(self.sop_list):
+            self.handle_sop_ops()
+
+        # Run sequential operations after all concurrent tasks are done
+        # self.agent_output = self.agent_output_model()
+        log_agent_data(self.to_dict())
+
+        if self.llm is None:
+            self.llm = self.llm_handling()
+
+        if self.mcp_url or self.mcp_servers is not None:
+            self.add_mcp_tools_to_memory()
+
+    def short_memory_init(self):
         if (
             self.agent_name is not None
             or self.agent_description is not None
         ):
-            prompt = f"Your Name: {self.agent_name} \n\n Your Description: {self.agent_description} \n\n {system_prompt}"
+            prompt = f"\n Your Name: {self.agent_name} \n\n Your Description: {self.agent_description} \n\n {self.system_prompt}"
         else:
-            prompt = system_prompt
+            prompt = self.system_prompt
 
         # Initialize the short term memory
         self.short_memory = Conversation(
             system_prompt=prompt,
             time_enabled=False,
-            user=user_name,
-            rules=rules,
+            user=self.user_name,
+            rules=self.rules,
             token_count=False,
-            *args,
-            **kwargs,
-        )
-
-        # Initialize the feedback
-        self.feedback = []
-
-        # Initialize the executor
-        self.executor = ThreadPoolExecutor(
-            max_workers=executor_workers
         )
 
-        self.init_handling()
+        return self.short_memory
 
     def init_handling(self):
         # Define tasks as pairs of (function, condition)
         # Each task will only run if its condition is True
-        tasks = [
-            (self.setup_config, True),  # Always run setup_config
-            (
-                self.get_docs_from_doc_folders,
-                exists(self.docs_folder),
-            ),
-            (self.handle_tool_init, True),  # Always run tool init
-            (
-                self.handle_tool_schema_ops,
-                exists(self.tool_schema)
-                or exists(self.list_base_models),
-            ),
-            (
-                self.handle_sop_ops,
-                exists(self.sop) or exists(self.sop_list),
-            ),
-        ]
-
-        # Filter out tasks whose conditions are False
-        filtered_tasks = [
-            task for task, condition in tasks if condition
-        ]
-
-        # Execute all tasks concurrently
-        with concurrent.futures.ThreadPoolExecutor(
-            max_workers=os.cpu_count() * 4
-        ) as executor:
-            # Map tasks to futures and collect results
-            results = {}
-            future_to_task = {
-                executor.submit(task): task.__name__
-                for task in filtered_tasks
-            }
+        self.setup_config()
 
-            # Wait for each future to complete and collect results/exceptions
-            for future in concurrent.futures.as_completed(
-                future_to_task
-            ):
-                task_name = future_to_task[future]
-                try:
-                    result = future.result()
-                    results[task_name] = result
-                    logging.info(
-                        f"Task {task_name} completed successfully"
-                    )
-                except Exception as e:
-                    results[task_name] = None
-                    logging.error(
-                        f"Task {task_name} failed with error: {e}"
-                    )
+        if exists(self.docs_folder):
+            self.get_docs_from_doc_folders()
+
+        if exists(self.tools):
+            self.handle_tool_init()
+
+        if exists(self.tool_schema) or exists(self.list_base_models):
+            self.handle_tool_schema_ops()
+
+        if exists(self.sop) or exists(self.sop_list):
+            self.handle_sop_ops()
 
         # Run sequential operations after all concurrent tasks are done
-        self.agent_output = self.agent_output_model()
+        # self.agent_output = self.agent_output_model()
         log_agent_data(self.to_dict())
 
         if self.llm is None:
             self.llm = self.llm_handling()
 
+        if self.mcp_url or self.mcp_servers is not None:
+            self.add_mcp_tools_to_memory()
+
     def agent_output_model(self):
         # Many steps
         id = agent_id()
@@ -637,10 +628,7 @@ class Agent:
             return self._cached_llm
 
         if self.model_name is None:
-            logger.warning(
-                f"Model name is not provided, using {self._default_model}. You can configure any model from litellm if desired."
-            )
-            self.model_name = self._default_model
+            self.model_name = "gpt-4o-mini"
 
         try:
             # Simplify initialization logic
@@ -719,68 +707,122 @@ class Agent:
                 tool.__name__: tool for tool in self.tools
             }
 
-    # def mcp_execution_flow(self, response: any):
-    #     """
-    #     Executes the MCP (Model Context Protocol) flow based on the provided response.
-
-    #     This method takes a response, converts it from a string to a dictionary format,
-    #     and checks for the presence of a tool name or a name in the response. If either
-    #     is found, it retrieves the tool name and proceeds to call the batch_mcp_flow
-    #     function to execute the corresponding tool actions.
-
-    #     Args:
-    #         response (any): The response to be processed, which can be in string format
-    #         that represents a dictionary.
-
-    #     Returns:
-    #         The output from the batch_mcp_flow function, which contains the results of
-    #         the tool execution. If an error occurs during processing, it logs the error
-    #         and returns None.
-
-    #     Raises:
-    #         Exception: Logs any exceptions that occur during the execution flow.
-    #     """
-    #     try:
-    #         response = str_to_dict(response)
-
-    #         tool_output = batch_mcp_flow(
-    #             self.mcp_servers,
-    #             function_call=response,
-    #         )
-
-    #         return tool_output
-    #     except Exception as e:
-    #         logger.error(f"Error in mcp_execution_flow: {e}")
-    #         return None
-
-    # def mcp_tool_handling(self):
-    #     """
-    #     Handles the retrieval of tool schemas from the MCP servers.
-
-    #     This method iterates over the list of MCP servers, retrieves the tool schema
-    #     for each server using the mcp_flow_get_tool_schema function, and compiles
-    #     these schemas into a list. The resulting list is stored in the
-    #     tools_list_dictionary attribute.
-
-    #     Returns:
-    #         list: A list of tool schemas retrieved from the MCP servers. If an error
-    #         occurs during the retrieval process, it logs the error and returns None.
-
-    #     Raises:
-    #         Exception: Logs any exceptions that occur during the tool handling process.
-    #     """
-    #     try:
-    #         self.tools_list_dictionary = []
-
-    #         for mcp_server in self.mcp_servers:
-    #             tool_schema = mcp_flow_get_tool_schema(mcp_server)
-    #             self.tools_list_dictionary.append(tool_schema)
-
-    #         print(self.tools_list_dictionary)
-    #         return self.tools_list_dictionary
-    #     except Exception as e:
-    #         logger.error(f"Error in mcp_tool_handling: {e}")
-    #         return None
+    def add_mcp_tools_to_memory(self):
+        """
+        Adds MCP tools to the agent's short-term memory.
+
+        This function checks for either a single MCP URL or multiple MCP URLs and adds the available tools
+        to the agent's memory. The tools are listed in JSON format.
+
+        Raises:
+            Exception: If there's an error accessing the MCP tools
+        """
+        try:
+            if self.mcp_url is not None:
+                tools_available = list_all(
+                    self.mcp_url, output_type="json"
+                )
+                self.short_memory.add(
+                    role="Tools Available",
+                    content=f"\n{tools_available}",
+                )
+
+            elif (
+                self.mcp_url is None
+                and self.mcp_urls is not None
+                and len(self.mcp_urls) > 1
+            ):
+                tools_available = list_tools_for_multiple_urls(
+                    urls=self.mcp_urls,
+                    output_type="json",
+                )
+
+                self.short_memory.add(
+                    role="Tools Available",
+                    content=f"\n{tools_available}",
+                )
+        except Exception as e:
+            logger.error(f"Error adding MCP tools to memory: {e}")
+            raise e
+
+    def _single_mcp_tool_handling(self, response: any):
+        """
+        Handles execution of a single MCP tool.
+
+        Args:
+            response (str): The tool response to process
+
+        Raises:
+            Exception: If there's an error executing the tool
+        """
+        try:
+            if isinstance(response, dict):
+                result = response
+                print(type(result))
+            else:
+                result = str_to_dict(response)
+                print(type(result))
+
+            output = execute_mcp_tool(
+                url=self.mcp_url,
+                parameters=result,
+            )
+
+            self.short_memory.add(
+                role="Tool Executor", content=str(output)
+            )
+        except Exception as e:
+            logger.error(f"Error in single MCP tool handling: {e}")
+            raise e
+
+    def _multiple_mcp_tool_handling(self, response: any):
+        """
+        Handles execution of multiple MCP tools.
+
+        Args:
+            response (any): The tool response to process
+
+        Raises:
+            Exception: If there's an error executing the tools
+        """
+        try:
+            if isinstance(response, str):
+                response = str_to_dict(response)
+
+            execution = find_and_execute_tool(
+                self.mcp_urls,
+                response["name"],
+                parameters=response,
+            )
+
+            self.short_memory.add(
+                role="Tool Executor", content=str(execution)
+            )
+        except Exception as e:
+            logger.error(f"Error in multiple MCP tool handling: {e}")
+            raise e
+
+    def mcp_tool_handling(self, response: any):
+        """
+        Main handler for MCP tool execution.
+
+        Args:
+            response (any): The tool response to process
+
+        Raises:
+            ValueError: If no MCP URL or MCP Servers are provided
+            Exception: If there's an error in tool handling
+        """
+        try:
+            # if self.mcp_url is not None:
+            self._single_mcp_tool_handling(response)
+            # elif self.mcp_url is None and len(self.mcp_servers) > 1:
+            #     self._multiple_mcp_tool_handling(response)
+            # else:
+            #     raise ValueError("No MCP URL or MCP Servers provided")
+        except Exception as e:
+            logger.error(f"Error in mcp_tool_handling: {e}")
+            raise e
 
     def setup_config(self):
         # The max_loops will be set dynamically if the dynamic_loop
@@ -1095,6 +1137,15 @@ class Agent:
                         ) as executor:
                             executor.map(lambda f: f(), update_tasks)
 
+                        ####### MCP TOOL HANDLING #######
+                        if (
+                            self.mcp_servers
+                            and self.tools_list_dictionary is not None
+                        ):
+                            self.mcp_tool_handling(response)
+
+                        ####### MCP TOOL HANDLING #######
+
                         # Check and execute tools
                         if self.tools is not None:
                             out = self.parse_and_execute_tools(
@@ -1739,10 +1790,11 @@ class Agent:
                 )
 
             # Reinitialize executor if needed
-            if not hasattr(self, "executor") or self.executor is None:
-                self.executor = ThreadPoolExecutor(
-                    max_workers=os.cpu_count()
-                )
+            # if not hasattr(self, "executor") or self.executor is None:
+            with ThreadPoolExecutor(
+                max_workers=os.cpu_count()
+            ) as executor:
+                self.executor = executor
 
             # # Reinitialize tool structure if needed
             # if hasattr(self, 'tools') and (self.tools or getattr(self, 'list_base_models', None)):
@@ -2494,12 +2546,7 @@ class Agent:
         self,
         task: Optional[Union[str, Any]] = None,
         img: Optional[str] = None,
-        device: Optional[str] = "cpu",  # gpu
-        device_id: Optional[int] = 0,
-        all_cores: Optional[bool] = True,
         scheduled_run_date: Optional[datetime] = None,
-        do_not_use_cluster_ops: Optional[bool] = True,
-        all_gpus: Optional[bool] = False,
         *args,
         **kwargs,
     ) -> Any:
@@ -2539,7 +2586,6 @@ class Agent:
                 )  # Sleep for a short period to avoid busy waiting
 
         try:
-            # If cluster ops disabled, run directly
             output = self._run(
                 task=task,
                 img=img,
@@ -2549,11 +2595,6 @@ class Agent:
 
             return output
 
-            # if self.tools_list_dictionary is not None:
-            #     return str_to_dict(output)
-            # else:
-            #     return output
-
         except ValueError as e:
             self._handle_run_error(e)
 

swarms/structs/aop.py

@@ -27,6 +27,7 @@ class AOP:
         name: Optional[str] = None,
         description: Optional[str] = None,
         url: Optional[str] = "http://localhost:8000/sse",
+        urls: Optional[list[str]] = None,
         *args,
         **kwargs,
     ):
@@ -44,7 +45,7 @@ class AOP:
         self.name = name
         self.description = description
         self.url = url
-
+        self.urls = urls
         self.tools = {}
         self.swarms = {}
 
@@ -527,6 +528,12 @@ class AOP:
                 return tool
         return None
 
+    def list_tools_for_multiple_urls(self):
+        out = []
+        for url in self.urls:
+            out.append(self.list_all(url))
+        return out
+
     def search_if_tool_exists(self, name: str):
         out = self.list_all()
         for tool in out: