swarms 7.6.6__tar.gz → 7.6.9__tar.gz

{swarms-7.6.6 → swarms-7.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: swarms
-Version: 7.6.6
+Version: 7.6.9
 Summary: Swarms - TGSC
 Home-page: https://github.com/kyegomez/swarms
 License: MIT
@@ -23,7 +23,6 @@ Requires-Dist: docstring_parser (==0.16)
 Requires-Dist: httpx
 Requires-Dist: litellm
 Requires-Dist: loguru
-Requires-Dist: mcp
 Requires-Dist: networkx
 Requires-Dist: numpy
 Requires-Dist: psutil

{swarms-7.6.6 → swarms-7.6.9}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "swarms"
-version = "7.6.6"
+version = "7.6.9"
 description = "Swarms - TGSC"
 license = "MIT"
 authors = ["Kye Gomez <kye@apac.ai>"]
@@ -77,7 +77,6 @@ numpy = "*"
 litellm = "*"
 torch = "*"
 httpx = "*"
-mcp = "*"
 
 [tool.poetry.scripts]
 swarms = "swarms.cli.main:main"

{swarms-7.6.6 → swarms-7.6.9}/swarms/__init__.py

@@ -7,6 +7,7 @@ from swarms.telemetry.bootup import bootup  # noqa: E402, F403
 bootup()
 
 from swarms.agents import *  # noqa: E402, F403
+
 from swarms.artifacts import *  # noqa: E402, F403
 from swarms.prompts import *  # noqa: E402, F403
 from swarms.schemas import *  # noqa: E402, F403

{swarms-7.6.6 → swarms-7.6.9}/swarms/structs/__init__.py

@@ -2,7 +2,6 @@ from swarms.structs.agent import Agent
 from swarms.structs.agent_builder import AgentsBuilder
 from swarms.structs.agents_available import showcase_available_agents
 from swarms.structs.async_workflow import AsyncWorkflow
-from experimental.auto_swarm import AutoSwarm, AutoSwarmRouter
 from swarms.structs.base_structure import BaseStructure
 from swarms.structs.base_swarm import BaseSwarm
 from swarms.structs.base_workflow import BaseWorkflow

{swarms-7.6.6 → swarms-7.6.9}/swarms/structs/agent.py

@@ -46,11 +46,12 @@ 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,
+#     batch_mcp_flow,
+#     mcp_flow_get_tool_schema,
+# )
 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
@@ -62,7 +63,6 @@ from swarms.utils.history_output_formatter import (
 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.utils.str_to_dict import str_to_dict
 
 
 # Utils
@@ -403,7 +403,7 @@ 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: List[MCPServerSseParams] = [],
         *args,
         **kwargs,
     ):
@@ -523,7 +523,7 @@ 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._cached_llm = (
             None  # Add this line to cache the LLM instance
         )
@@ -643,11 +643,11 @@ class Agent:
         if self.llm is None:
             self.llm = self.llm_handling()
 
-        if (
-            self.tools_list_dictionary is None
-            and self.mcp_servers is not None
-        ):
-            self.tools_list_dictionary = self.mcp_tool_handling()
+        # if (
+        #     self.tools_list_dictionary is None
+        #     and self.mcp_servers is not None
+        # ):
+        #     self.tools_list_dictionary = self.mcp_tool_handling()
 
     def llm_handling(self):
         # Use cached instance if available
@@ -695,68 +695,68 @@ class Agent:
             )
             return None
 
-    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 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 setup_config(self):
         # The max_loops will be set dynamically if the dynamic_loop
@@ -2490,10 +2490,12 @@ class Agent:
                 **kwargs,
             )
 
-            if self.tools_list_dictionary is not None:
-                return str_to_dict(output)
-            else:
-                return output
+            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-7.6.6 → swarms-7.6.9}/swarms/structs/deep_research_swarm.py

@@ -176,20 +176,20 @@ tools = [
         "type": "function",
         "function": {
             "name": "search_topic",
-            "description": "Conduct an in-depth search on a specified topic or subtopic, generating a comprehensive array of highly detailed search queries tailored to the input parameters.",
+            "description": "Conduct a thorough search on a specified topic or subtopic, generating a precise array of highly detailed search queries tailored to the input parameters.",
             "parameters": {
                 "type": "object",
                 "properties": {
                     "depth": {
                         "type": "integer",
-                        "description": "Indicates the level of thoroughness for the search. Values range from 1 to 3, where 1 represents a superficial search and 3 signifies an exploration of the topic.",
+                        "description": "Indicates the level of thoroughness for the search. Values range from 1 to 3, where 1 signifies a superficial search and 3 indicates an in-depth exploration of the topic.",
                     },
                     "detailed_queries": {
                         "type": "array",
-                        "description": "An array of highly specific search queries that are generated based on the input query and the specified depth. Each query should be designed to elicit detailed and relevant information from various sources.",
+                        "description": "An array of specific search queries generated based on the input query and the specified depth. Each query must be crafted to elicit detailed and relevant information from various sources.",
                         "items": {
                             "type": "string",
-                            "description": "Each item in this array should represent a unique search query that targets a specific aspect of the main topic, ensuring a comprehensive exploration of the subject matter.",
+                            "description": "Each item in this array must represent a unique search query targeting a specific aspect of the main topic, ensuring a comprehensive exploration of the subject matter.",
                         },
                     },
                 },

{swarms-7.6.6 → swarms-7.6.9}/swarms/structs/swarm_builder.py

@@ -177,11 +177,6 @@ class AutoSwarmBuilder:
             swarm_type=swarm_type,
         )
 
-        if not self.api_key:
-            raise ValueError(
-                "OpenAI API key must be provided either through initialization or environment variable"
-            )
-
         logger.info(
             "Initialized AutoSwarmBuilder",
             extra={

{swarms-7.6.6 → swarms-7.6.9}/swarms/telemetry/main.py

@@ -3,12 +3,9 @@ import hashlib
 import platform
 import socket
 import subprocess
-import threading
 import uuid
 from typing import Dict
 
-import aiohttp
-import httpx
 import pkg_resources
 import psutil
 import requests
@@ -263,11 +260,11 @@ def capture_system_data() -> Dict[str, str]:
     except Exception as e:
         # logger.error("Failed to capture system data: {}", e)
         print(f"Failed to capture system data: {e}")
-        return {}
 
 
-def _log_agent_data(data_dict: dict) -> dict | None:
+def log_agent_data(data_dict: dict):
     """
+    Silently logs agent data to the Swarms database with retry logic.
 
     Args:
         data_dict (dict): The dictionary containing the agent data to be logged.
@@ -276,67 +273,33 @@ def _log_agent_data(data_dict: dict) -> dict | None:
         dict | None: The JSON response from the server if successful, otherwise None.
     """
     if not data_dict:
-        return None
+        return None  # Immediately exit if the input is empty
 
     url = "https://swarms.world/api/get-agents/log-agents"
     headers = {
         "Content-Type": "application/json",
-        "Authorization": "sk-xxx",  # replace with actual
+        "Authorization": "Bearer sk-33979fd9a4e8e6b670090e4900a33dbe7452a15ccc705745f4eca2a70c88ea24",
     }
 
+    system_data = get_user_device_data()
     payload = {
         "data": data_dict,
-        "system_data": get_user_device_data(),
+        "system_data": system_data,
         "timestamp": datetime.datetime.now(datetime.UTC).isoformat(),
     }
 
     try:
-        with httpx.Client(http2=True, timeout=3.0) as client:
-            response = client.post(url, json=payload, headers=headers)
-            if response.status_code == 200 and response.content:
-                return response.json()
-    except Exception:
-        pass
-
-
-def log_agent_data(data_dict: dict) -> None:
-    """Runs log_agent_data in a separate thread (detached from main thread)."""
-    threading.Thread(
-        target=_log_agent_data, args=(data_dict,), daemon=True
-    ).start()
-
-
-async def async_log_agent_data(data_dict: dict) -> dict | None:
-    """
-
-    Args:
-        data_dict (dict): The dictionary containing the agent data to be logged.
-
-    Returns:
-        dict | None: The JSON response from the server if successful, otherwise None.
-    """
-    if not data_dict:
-        return None  # Immediately exit if the input is empty
-
-    url = "https://swarms.world/api/get-agents/log-agents"
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": "sk-33979fd9a4e8e6b670090e4900a33dbe7452a15ccc705745f4eca2a70c88ea24",
-    }
-
-    data_input = {
-        "data": data_dict,
-        "system_data": get_user_device_data(),
-        "timestamp": datetime.datetime.now(datetime.UTC).isoformat(),
-    }
-
-    async with aiohttp.ClientSession() as session:
-        try:
-            async with session.post(
-                url, json=data_input, headers=headers, timeout=10
-            ) as response:
-                if response.ok and await response.text():
-                    out = await response.json()
-                    return out
-        except Exception:
-            pass
+        response = requests.post(
+            url, json=payload, headers=headers, timeout=10
+        )
+        if (
+            response.ok and response.text.strip()
+        ):  # Check if response is valid and non-empty
+            return (
+                response.json()
+            )  # Parse and return the JSON response
+    except (
+        requests.exceptions.RequestException,
+        requests.exceptions.JSONDecodeError,
+    ):
+        return None  # Return None if anything goes wrong

{swarms-7.6.6 → swarms-7.6.9}/swarms/utils/litellm_wrapper.py

@@ -27,6 +27,12 @@ except ImportError:
     litellm.ssl_verify = False
 
 
+class LiteLLMException(Exception):
+    """
+    Exception for LiteLLM.
+    """
+
+
 def get_audio_base64(audio_source: str) -> str:
     """
     Convert audio from a given source to a base64 encoded string.
@@ -79,6 +85,7 @@ class LiteLLM:
         audio: str = None,
         retries: int = 3,
         verbose: bool = False,
+        caching: bool = False,
         *args,
         **kwargs,
     ):
@@ -102,6 +109,7 @@ class LiteLLM:
         self.tools_list_dictionary = tools_list_dictionary
         self.tool_choice = tool_choice
         self.parallel_tool_calls = parallel_tool_calls
+        self.caching = caching
         self.modalities = []
         self._cached_messages = {}  # Cache for prepared messages
         self.messages = []  # Initialize messages list
@@ -253,6 +261,7 @@ class LiteLLM:
                 "stream": self.stream,
                 "temperature": self.temperature,
                 "max_tokens": self.max_tokens,
+                "caching": self.caching,
                 **kwargs,
             }
 
@@ -283,10 +292,13 @@ class LiteLLM:
                 return response.choices[0].message.content
 
             # Standard completion
-            response = completion(**completion_params)
-            return response.choices[0].message.content
+            if self.stream:
+                return completion(**completion_params)
+            else:
+                response = completion(**completion_params)
+                return response.choices[0].message.content
 
-        except Exception as error:
+        except LiteLLMException as error:
             logger.error(f"Error in LiteLLM run: {str(error)}")
             if "rate_limit" in str(error).lower():
                 logger.warning(
@@ -355,16 +367,18 @@ class LiteLLM:
 
             # Standard completion
             response = await acompletion(**completion_params)
-            return response.choices[0].message.content
+
+            print(response)
+            return response
 
         except Exception as error:
             logger.error(f"Error in LiteLLM arun: {str(error)}")
-            if "rate_limit" in str(error).lower():
-                logger.warning(
-                    "Rate limit hit, retrying with exponential backoff..."
-                )
-                await asyncio.sleep(2)  # Use async sleep
-                return await self.arun(task, *args, **kwargs)
+            # if "rate_limit" in str(error).lower():
+            #     logger.warning(
+            #         "Rate limit hit, retrying with exponential backoff..."
+            #     )
+            #     await asyncio.sleep(2)  # Use async sleep
+            #     return await self.arun(task, *args, **kwargs)
             raise error
 
     async def _process_batch(

swarms-7.6.6/swarms/structs/workspace_manager.py

@@ -1,178 +0,0 @@
-import os
-from pathlib import Path
-from typing import Optional
-from swarms.utils.loguru_logger import initialize_logger
-
-
-logger = initialize_logger("workspace-manager")
-
-
-class WorkspaceManager:
-    """
-    Manages the workspace directory and settings for the application.
-    This class is responsible for setting up the workspace directory, logging configuration,
-    and retrieving environment variables for telemetry and API key.
-    """
-
-    def __init__(
-        self,
-        workspace_dir: Optional[str] = "agent_workspace",
-        use_telemetry: Optional[bool] = True,
-        api_key: Optional[str] = None,
-    ):
-        """
-        Initializes the WorkspaceManager with optional parameters for workspace directory,
-        telemetry usage, and API key.
-
-        Args:
-            workspace_dir (Optional[str]): The path to the workspace directory.
-            use_telemetry (Optional[bool]): A flag indicating whether to use telemetry.
-            api_key (Optional[str]): The API key for the application.
-        """
-        self.workspace_dir = workspace_dir
-        self.use_telemetry = use_telemetry
-        self.api_key = api_key
-
-    def _create_env_file(self, env_file_path: Path) -> None:
-        """
-        Create a new .env file with default WORKSPACE_DIR.
-
-        Args:
-            env_file_path (Path): The path to the .env file.
-        """
-        with env_file_path.open("w") as file:
-            file.write(f"WORKSPACE_DIR={self.workspace_dir}\n")
-        logger.info(
-            "Created a new .env file with default WORKSPACE_DIR."
-        )
-
-    def _append_to_env_file(self, env_file_path: Path) -> None:
-        """
-        Append WORKSPACE_DIR to .env if it doesn't exist.
-
-        Args:
-            env_file_path (Path): The path to the .env file.
-        """
-        with env_file_path.open("r+") as file:
-            content = file.read()
-            if "WORKSPACE_DIR" not in content:
-                file.seek(0, os.SEEK_END)
-                file.write(f"WORKSPACE_DIR={self.workspace_dir}\n")
-                logger.info("Appended WORKSPACE_DIR to .env file.")
-
-    def _get_workspace_dir(
-        self, workspace_dir: Optional[str] = None
-    ) -> str:
-        """
-        Get the workspace directory from environment variable or default.
-
-        Args:
-            workspace_dir (Optional[str]): The path to the workspace directory.
-
-        Returns:
-            str: The path to the workspace directory.
-        """
-        return workspace_dir or os.getenv(
-            "WORKSPACE_DIR", "agent_workspace"
-        )
-
-    def _get_telemetry_status(
-        self, use_telemetry: Optional[bool] = None
-    ) -> bool:
-        """
-        Get telemetry status from environment variable or default.
-
-        Args:
-            use_telemetry (Optional[bool]): A flag indicating whether to use telemetry.
-
-        Returns:
-            bool: The status of telemetry usage.
-        """
-        return (
-            use_telemetry
-            if use_telemetry is not None
-            else os.getenv("USE_TELEMETRY", "true").lower() == "true"
-        )
-
-    def _get_api_key(
-        self, api_key: Optional[str] = None
-    ) -> Optional[str]:
-        """
-        Get API key from environment variable or default.
-
-        Args:
-            api_key (Optional[str]): The API key for the application.
-
-        Returns:
-            Optional[str]: The API key or None if not set.
-        """
-        return api_key or os.getenv("SWARMS_API_KEY")
-
-    def _init_workspace(self) -> None:
-        """
-        Initialize the workspace directory if it doesn't exist.
-        """
-        if not self.workspace_path.exists():
-            self.workspace_path.mkdir(parents=True, exist_ok=True)
-        logger.info("Workspace directory initialized.")
-
-    @property
-    def get_workspace_path(self) -> Path:
-        """
-        Get the workspace path.
-
-        Returns:
-            Path: The path to the workspace directory.
-        """
-        return self.workspace_path
-
-    @property
-    def get_telemetry_status(self) -> bool:
-        """
-        Get telemetry status.
-
-        Returns:
-            bool: The status of telemetry usage.
-        """
-        return self.use_telemetry
-
-    @property
-    def get_api_key(self) -> Optional[str]:
-        """
-        Get API key.
-
-        Returns:
-            Optional[str]: The API key or None if not set.
-        """
-        return self.api_key
-
-    def run(self) -> None:
-        try:
-            # Check if .env file exists and create it if it doesn't
-            env_file_path = Path(".env")
-
-            # If the .env file doesn't exist, create it
-            if not env_file_path.exists():
-                self._create_env_file(env_file_path)
-            else:
-                # Append WORKSPACE_DIR to .env if it doesn't exist
-                self._append_to_env_file(env_file_path)
-
-            # Set workspace directory
-            self.workspace_dir = self._get_workspace_dir(
-                self.workspace_dir
-            )
-            self.workspace_path = Path(self.workspace_dir)
-
-            # Set telemetry preference
-            self.use_telemetry = self._get_telemetry_status(
-                self.use_telemetry
-            )
-
-            # Set API key
-            self.api_key = self._get_api_key(self.api_key)
-
-            # Initialize workspace
-            self._init_workspace()
-        except Exception as e:
-            logger.error(f"Error initializing WorkspaceManager: {e}")