swarms 7.6.4__py3-none-any.whl → 7.6.6__py3-none-any.whl

swarms/utils/litellm_wrapper.py

@@ -5,7 +5,7 @@ import asyncio
 from typing import List
 
 from loguru import logger
-
+import litellm
 
 try:
     from litellm import completion, acompletion
@@ -77,6 +77,8 @@ class LiteLLM:
         tool_choice: str = "auto",
         parallel_tool_calls: bool = False,
         audio: str = None,
+        retries: int = 3,
+        verbose: bool = False,
         *args,
         **kwargs,
     ):
@@ -100,7 +102,18 @@ class LiteLLM:
         self.tools_list_dictionary = tools_list_dictionary
         self.tool_choice = tool_choice
         self.parallel_tool_calls = parallel_tool_calls
-        self.modalities = ["text"]
+        self.modalities = []
+        self._cached_messages = {}  # Cache for prepared messages
+        self.messages = []  # Initialize messages list
+
+        # Configure litellm settings
+        litellm.set_verbose = (
+            verbose  # Disable verbose mode for better performance
+        )
+        litellm.ssl_verify = ssl_verify
+        litellm.num_retries = (
+            retries  # Add retries for better reliability
+        )
 
     def _prepare_messages(self, task: str) -> list:
         """
@@ -112,15 +125,20 @@ class LiteLLM:
         Returns:
             list: A list of messages prepared for the task.
         """
-        messages = []
+        # Check cache first
+        cache_key = f"{self.system_prompt}:{task}"
+        if cache_key in self._cached_messages:
+            return self._cached_messages[cache_key].copy()
 
-        if self.system_prompt:  # Check if system_prompt is not None
+        messages = []
+        if self.system_prompt:
             messages.append(
                 {"role": "system", "content": self.system_prompt}
             )
-
         messages.append({"role": "user", "content": task})
 
+        # Cache the prepared messages
+        self._cached_messages[cache_key] = messages.copy()
         return messages
 
     def audio_processing(self, task: str, audio: str):
@@ -182,15 +200,16 @@ class LiteLLM:
         """
         Handle the modalities for the given task.
         """
+        self.messages = []  # Reset messages
+        self.modalities.append("text")
+
         if audio is not None:
             self.audio_processing(task=task, audio=audio)
+            self.modalities.append("audio")
 
         if img is not None:
             self.vision_processing(task=task, image=img)
-
-        if audio is not None and img is not None:
-            self.audio_processing(task=task, audio=audio)
-            self.vision_processing(task=task, image=img)
+            self.modalities.append("vision")
 
     def run(
         self,
@@ -205,58 +224,78 @@ class LiteLLM:
 
         Args:
             task (str): The task to run the model for.
-            *args: Additional positional arguments to pass to the model.
-            **kwargs: Additional keyword arguments to pass to the model.
+            audio (str, optional): Audio input if any. Defaults to None.
+            img (str, optional): Image input if any. Defaults to None.
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
 
         Returns:
             str: The content of the response from the model.
+
+        Raises:
+            Exception: If there is an error in processing the request.
         """
         try:
-
             messages = self._prepare_messages(task)
 
-            self.handle_modalities(task=task, audio=audio, img=img)
+            if audio is not None or img is not None:
+                self.handle_modalities(
+                    task=task, audio=audio, img=img
+                )
+                messages = (
+                    self.messages
+                )  # Use modality-processed messages
+
+            # Prepare common completion parameters
+            completion_params = {
+                "model": self.model_name,
+                "messages": messages,
+                "stream": self.stream,
+                "temperature": self.temperature,
+                "max_tokens": self.max_tokens,
+                **kwargs,
+            }
 
+            # Handle tool-based completion
             if self.tools_list_dictionary is not None:
-                response = completion(
-                    model=self.model_name,
-                    messages=messages,
-                    stream=self.stream,
-                    temperature=self.temperature,
-                    max_tokens=self.max_tokens,
-                    tools=self.tools_list_dictionary,
-                    modalities=self.modalities,
-                    tool_choice=self.tool_choice,
-                    parallel_tool_calls=self.parallel_tool_calls,
-                    *args,
-                    **kwargs,
+                completion_params.update(
+                    {
+                        "tools": self.tools_list_dictionary,
+                        "tool_choice": self.tool_choice,
+                        "parallel_tool_calls": self.parallel_tool_calls,
+                    }
                 )
-
+                response = completion(**completion_params)
                 return (
                     response.choices[0]
                     .message.tool_calls[0]
                     .function.arguments
                 )
 
-            else:
-                response = completion(
-                    model=self.model_name,
-                    messages=messages,
-                    stream=self.stream,
-                    temperature=self.temperature,
-                    max_tokens=self.max_tokens,
-                    modalities=self.modalities,
-                    *args,
-                    **kwargs,
+            # Handle modality-based completion
+            if (
+                self.modalities and len(self.modalities) > 1
+            ):  # More than just text
+                completion_params.update(
+                    {"modalities": self.modalities}
                 )
+                response = completion(**completion_params)
+                return response.choices[0].message.content
 
-                content = response.choices[
-                    0
-                ].message.content  # Accessing the content
+            # Standard completion
+            response = completion(**completion_params)
+            return response.choices[0].message.content
 
-                return content
         except Exception as error:
-            logger.error(f"Error in LiteLLM: {error}")
+            logger.error(f"Error in LiteLLM run: {str(error)}")
+            if "rate_limit" in str(error).lower():
+                logger.warning(
+                    "Rate limit hit, retrying with exponential backoff..."
+                )
+                import time
+
+                time.sleep(2)  # Add a small delay before retry
+                return self.run(task, audio, img, *args, **kwargs)
             raise error
 
     def __call__(self, task: str, *args, **kwargs):
@@ -275,12 +314,12 @@ class LiteLLM:
 
     async def arun(self, task: str, *args, **kwargs):
         """
-        Run the LLM model for the given task.
+        Run the LLM model asynchronously for the given task.
 
         Args:
             task (str): The task to run the model for.
-            *args: Additional positional arguments to pass to the model.
-            **kwargs: Additional keyword arguments to pass to the model.
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
 
         Returns:
             str: The content of the response from the model.
@@ -288,72 +327,113 @@ class LiteLLM:
         try:
             messages = self._prepare_messages(task)
 
+            # Prepare common completion parameters
+            completion_params = {
+                "model": self.model_name,
+                "messages": messages,
+                "stream": self.stream,
+                "temperature": self.temperature,
+                "max_tokens": self.max_tokens,
+                **kwargs,
+            }
+
+            # Handle tool-based completion
             if self.tools_list_dictionary is not None:
-                response = await acompletion(
-                    model=self.model_name,
-                    messages=messages,
-                    stream=self.stream,
-                    temperature=self.temperature,
-                    max_tokens=self.max_tokens,
-                    tools=self.tools_list_dictionary,
-                    tool_choice=self.tool_choice,
-                    parallel_tool_calls=self.parallel_tool_calls,
-                    *args,
-                    **kwargs,
+                completion_params.update(
+                    {
+                        "tools": self.tools_list_dictionary,
+                        "tool_choice": self.tool_choice,
+                        "parallel_tool_calls": self.parallel_tool_calls,
+                    }
                 )
-
-                content = (
+                response = await acompletion(**completion_params)
+                return (
                     response.choices[0]
                     .message.tool_calls[0]
                     .function.arguments
                 )
 
-                # return response
-
-            else:
-                response = await acompletion(
-                    model=self.model_name,
-                    messages=messages,
-                    stream=self.stream,
-                    temperature=self.temperature,
-                    max_tokens=self.max_tokens,
-                    *args,
-                    **kwargs,
-                )
+            # Standard completion
+            response = await acompletion(**completion_params)
+            return response.choices[0].message.content
 
-                content = response.choices[
-                    0
-                ].message.content  # Accessing the content
-
-            return content
         except Exception as error:
-            logger.error(f"Error in LiteLLM: {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)
             raise error
 
+    async def _process_batch(
+        self, tasks: List[str], batch_size: int = 10
+    ):
+        """
+        Process a batch of tasks asynchronously.
+
+        Args:
+            tasks (List[str]): List of tasks to process.
+            batch_size (int): Size of each batch.
+
+        Returns:
+            List[str]: List of responses.
+        """
+        results = []
+        for i in range(0, len(tasks), batch_size):
+            batch = tasks[i : i + batch_size]
+            batch_results = await asyncio.gather(
+                *[self.arun(task) for task in batch],
+                return_exceptions=True,
+            )
+
+            # Handle any exceptions in the batch
+            for result in batch_results:
+                if isinstance(result, Exception):
+                    logger.error(
+                        f"Error in batch processing: {str(result)}"
+                    )
+                    results.append(str(result))
+                else:
+                    results.append(result)
+
+            # Add a small delay between batches to avoid rate limits
+            if i + batch_size < len(tasks):
+                await asyncio.sleep(0.5)
+
+        return results
+
     def batched_run(self, tasks: List[str], batch_size: int = 10):
         """
-        Run the LLM model for the given tasks in batches.
+        Run multiple tasks in batches synchronously.
+
+        Args:
+            tasks (List[str]): List of tasks to process.
+            batch_size (int): Size of each batch.
+
+        Returns:
+            List[str]: List of responses.
         """
         logger.info(
-            f"Running tasks in batches of size {batch_size}. Total tasks: {len(tasks)}"
+            f"Running {len(tasks)} tasks in batches of {batch_size}"
         )
-        results = []
-        for task in tasks:
-            logger.info(f"Running task: {task}")
-            results.append(self.run(task))
-        logger.info("Completed all tasks.")
-        return results
+        return asyncio.run(self._process_batch(tasks, batch_size))
 
-    def batched_arun(self, tasks: List[str], batch_size: int = 10):
+    async def batched_arun(
+        self, tasks: List[str], batch_size: int = 10
+    ):
         """
-        Run the LLM model for the given tasks in batches.
+        Run multiple tasks in batches asynchronously.
+
+        Args:
+            tasks (List[str]): List of tasks to process.
+            batch_size (int): Size of each batch.
+
+        Returns:
+            List[str]: List of responses.
         """
         logger.info(
-            f"Running asynchronous tasks in batches of size {batch_size}. Total tasks: {len(tasks)}"
+            f"Running {len(tasks)} tasks asynchronously in batches of {batch_size}"
         )
-        results = []
-        for task in tasks:
-            logger.info(f"Running asynchronous task: {task}")
-            results.append(asyncio.run(self.arun(task)))
-        logger.info("Completed all asynchronous tasks.")
-        return results
+        return await self._process_batch(tasks, batch_size)

swarms/utils/vllm_wrapper.py

@@ -0,0 +1,146 @@
+from typing import List, Optional, Dict, Any
+from loguru import logger
+
+try:
+    from vllm import LLM, SamplingParams
+except ImportError:
+    import subprocess
+    import sys
+
+    print("Installing vllm")
+    subprocess.check_call(
+        [sys.executable, "-m", "pip", "install", "-U", "vllm"]
+    )
+    print("vllm installed")
+    from vllm import LLM, SamplingParams
+
+
+class VLLMWrapper:
+    """
+    A wrapper class for vLLM that provides a similar interface to LiteLLM.
+    This class handles model initialization and inference using vLLM.
+    """
+
+    def __init__(
+        self,
+        model_name: str = "meta-llama/Llama-2-7b-chat-hf",
+        system_prompt: Optional[str] = None,
+        stream: bool = False,
+        temperature: float = 0.5,
+        max_tokens: int = 4000,
+        max_completion_tokens: int = 4000,
+        tools_list_dictionary: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: str = "auto",
+        parallel_tool_calls: bool = False,
+        *args,
+        **kwargs,
+    ):
+        """
+        Initialize the vLLM wrapper with the given parameters.
+
+        Args:
+            model_name (str): The name of the model to use. Defaults to "meta-llama/Llama-2-7b-chat-hf".
+            system_prompt (str, optional): The system prompt to use. Defaults to None.
+            stream (bool): Whether to stream the output. Defaults to False.
+            temperature (float): The temperature for sampling. Defaults to 0.5.
+            max_tokens (int): The maximum number of tokens to generate. Defaults to 4000.
+            max_completion_tokens (int): The maximum number of completion tokens. Defaults to 4000.
+            tools_list_dictionary (List[Dict[str, Any]], optional): List of available tools. Defaults to None.
+            tool_choice (str): How to choose tools. Defaults to "auto".
+            parallel_tool_calls (bool): Whether to allow parallel tool calls. Defaults to False.
+        """
+        self.model_name = model_name
+        self.system_prompt = system_prompt
+        self.stream = stream
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.max_completion_tokens = max_completion_tokens
+        self.tools_list_dictionary = tools_list_dictionary
+        self.tool_choice = tool_choice
+        self.parallel_tool_calls = parallel_tool_calls
+
+        # Initialize vLLM
+        self.llm = LLM(model=model_name, **kwargs)
+        self.sampling_params = SamplingParams(
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+
+    def _prepare_prompt(self, task: str) -> str:
+        """
+        Prepare the prompt for the given task.
+
+        Args:
+            task (str): The task to prepare the prompt for.
+
+        Returns:
+            str: The prepared prompt.
+        """
+        if self.system_prompt:
+            return f"{self.system_prompt}\n\nUser: {task}\nAssistant:"
+        return f"User: {task}\nAssistant:"
+
+    def run(self, task: str, *args, **kwargs) -> str:
+        """
+        Run the model for the given task.
+
+        Args:
+            task (str): The task to run the model for.
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            str: The model's response.
+        """
+        try:
+            prompt = self._prepare_prompt(task)
+
+            outputs = self.llm.generate(prompt, self.sampling_params)
+            response = outputs[0].outputs[0].text.strip()
+
+            return response
+
+        except Exception as error:
+            logger.error(f"Error in VLLMWrapper: {error}")
+            raise error
+
+    def __call__(self, task: str, *args, **kwargs) -> str:
+        """
+        Call the model for the given task.
+
+        Args:
+            task (str): The task to run the model for.
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            str: The model's response.
+        """
+        return self.run(task, *args, **kwargs)
+
+    def batched_run(
+        self, tasks: List[str], batch_size: int = 10
+    ) -> List[str]:
+        """
+        Run the model for multiple tasks in batches.
+
+        Args:
+            tasks (List[str]): List of tasks to run.
+            batch_size (int): Size of each batch. Defaults to 10.
+
+        Returns:
+            List[str]: List of model responses.
+        """
+        logger.info(
+            f"Running tasks in batches of size {batch_size}. Total tasks: {len(tasks)}"
+        )
+        results = []
+
+        for i in range(0, len(tasks), batch_size):
+            batch = tasks[i : i + batch_size]
+            for task in batch:
+                logger.info(f"Running task: {task}")
+                results.append(self.run(task))
+
+        logger.info("Completed all tasks.")
+        return results

{swarms-7.6.4.dist-info → swarms-7.6.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: swarms
-Version: 7.6.4
+Version: 7.6.6
 Summary: Swarms - TGSC
 Home-page: https://github.com/kyegomez/swarms
 License: MIT
@@ -23,6 +23,7 @@ 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.4.dist-info → swarms-7.6.6.dist-info}/RECORD

@@ -81,15 +81,14 @@ swarms/schemas/__init__.py,sha256=EqqtVcpoptF1kfy19Wykp22ut4AA0z-yMQ5H9WB7ptA,18
 swarms/schemas/agent_input_schema.py,sha256=qhPyThMx2on91yG9mzNdP_08GpMh1IRDHDwFna29jPs,6345
 swarms/schemas/agent_step_schemas.py,sha256=a14gb58vR0xOwB_fwSJQbN6yb9HddEaT30E6hUrzEQA,2573
 swarms/schemas/base_schemas.py,sha256=UvBLVWg2qRen4tK5GJz50v42SiX95EQ5qK7hfyAHTEU,3267
-swarms/structs/__init__.py,sha256=LgAeWDQxbBpUyIYgvikgSdDoDPrvNryDKYTBfflmLMk,4352
-swarms/structs/agent.py,sha256=JC48tv2Jn4hNGTBvBb5Lk-LiTwnyfBO81Doyv6EWbOA,92409
+swarms/structs/__init__.py,sha256=ER0HI-9RQI22i10x6XQj6TaKoWJgk1a5XIP1KxiBsCU,4310
+swarms/structs/agent.py,sha256=L8ZnvSNrmvK6z0n6RwHZ7MfZtRbwtQ5t6pQPcL2OLfA,96742
 swarms/structs/agent_builder.py,sha256=tYNpfO4_8cgfMHfgA5DAOWffHnt70p6CLt59esqfVCY,12133
 swarms/structs/agent_registry.py,sha256=il507cO1NF-d4ChyANVLuWrN8bXsEAi8_7bLJ_sTU6A,12112
 swarms/structs/agent_roles.py,sha256=8XEw6RjOOZelaZaWt4gXaYQm5WMLEhSO7W6Z8sQjmFg,582
 swarms/structs/agent_router.py,sha256=YZw5AaK2yTvxkOA7ouED_4MoYgn0XZggvo1wrglp-4E,13017
 swarms/structs/agents_available.py,sha256=SedxDim-0IWgGsNwJZxRIUMfKyAFFXdvXSYeBNu0zGw,2804
 swarms/structs/async_workflow.py,sha256=7YWsLPyGY-1-mMxoIXWQ0FnYH6F227nxsS9PFAJoF9Q,26214
-swarms/structs/auto_swarm.py,sha256=AHWswlEWDL_i3V8IP362tx6pi_B2arlZhALykrkI5OA,8215
 swarms/structs/auto_swarm_builder.py,sha256=vPM5Kq59D_FvuWJB8hxgHuEvTXsxDxovlBnHGVQsM4o,10938
 swarms/structs/base_structure.py,sha256=GDu4QJQQmhU7IyuFJHIh9UVThACCva-L7uoMbVD9l4s,15901
 swarms/structs/base_swarm.py,sha256=LSGJDPJdyUCcK6698mNtjxoC1OU3s_J2NxC2k_ccGUs,23779
@@ -153,7 +152,7 @@ swarms/tools/function_util.py,sha256=DAnAPO0Ik__TAqL7IJzFmkukHnhpsW_QtALl3yj837g
 swarms/tools/json_former.py,sha256=4ugLQ_EZpghhuhFsVKsy-ehin9K64pqVE2gLU7BTO_M,14376
 swarms/tools/json_utils.py,sha256=WKMZjcJ0Vt6lgIjiTBenslcfjgRSLX4UWs4uDkKFMQI,1316
 swarms/tools/logits_processor.py,sha256=NifZZ5w9yemWGJAJ5nHFrphtZVX1XlyesgvYZTxK1GM,2965
-swarms/tools/mcp_integration.py,sha256=Aqt2gLTIinJdHM_ZnIICqCXp2Fz_AbDPfaJVljDuIAI,17529
+swarms/tools/mcp_integration.py,sha256=rUXxC9NvXQ3V4B7Lt1AoI4ZYiCl2-T4FW3_689HTRZk,12839
 swarms/tools/openai_func_calling_schema_pydantic.py,sha256=6BAH9kuaVTvJIbjgSSJ5XvHhWvWszPxgarkfUuE5Ads,978
 swarms/tools/openai_tool_creator_decorator.py,sha256=SYZjHnARjWvnH9cBdj7Kc_Yy1muvNxMT3RQz8KkA2SE,2578
 swarms/tools/py_func_to_openai_func_str.py,sha256=W112Gu0CmAiHrNWnRMcnoGiVZEy2FxAU4xMvnG9XP4g,15710
@@ -173,7 +172,7 @@ swarms/utils/formatter.py,sha256=YykmcuWXkxvQ7a2Vq6OzWuqUDiIwro6VrtSt4ITbXcU,419
 swarms/utils/function_caller_model.py,sha256=ZfgCMzOizNnuZipYLclTziECNHszH9p8RQcUq7VNr4Q,4156
 swarms/utils/history_output_formatter.py,sha256=WHcd0xhSNRDKakXtkCjv0nW1NF-GM9SYcey3RrN5gl8,778
 swarms/utils/litellm_tokenizer.py,sha256=0AAj4NffBe2eHii_3_5SpQAhSiBbunJR8MzaBTIm7hg,484
-swarms/utils/litellm_wrapper.py,sha256=cXZ6nUrHnGhpVgolgbpNsyKq1_TzupJs8vmw-_XtCRM,11255
+swarms/utils/litellm_wrapper.py,sha256=wmWFD_TJI1_puVJTm9w3ZZYN6R0vQ6IRxAoEULHcysg,14194
 swarms/utils/loguru_logger.py,sha256=hIoSK3NHLpe7eAmjHRURrEYzNXYC2gbR7_Vv63Yaydk,685
 swarms/utils/markdown_message.py,sha256=RThHNnMf6ZLTlYK4vKn3yuewChaxWAYAWb0Xm_pTyIU,652
 swarms/utils/parse_code.py,sha256=XFOLymbdP3HzMZuqsj7pwUyisvUmTm0ev9iThR_ambI,1987
@@ -182,9 +181,10 @@ swarms/utils/str_to_dict.py,sha256=T3Jsdjz87WIlkSo7jAW6BB80sv0Ns49WT1qXlOrdEoE,8
 swarms/utils/swarm_reliability_checks.py,sha256=MsgUULt3HYg72D0HifZNmtCyJYpLA2UDA2wQixI-NbA,2562
 swarms/utils/try_except_wrapper.py,sha256=appEGu9Afy3TmdkNNXUgQ9yU9lj2j0uNkIoW0JhVzzY,3917
 swarms/utils/visualizer.py,sha256=0ylohEk62MAS6iPRaDOV03m9qo2k5J56tWlKJk_46p4,16927
+swarms/utils/vllm_wrapper.py,sha256=OIGnU9Vf81vE_hul1FK-xEhChFK8fxqZX6-fhQeW22c,4987
 swarms/utils/wrapper_clusterop.py,sha256=PMSCVM7ZT1vgj1D_MYAe835RR3SMLYxA-si2JS02yNQ,4220
-swarms-7.6.4.dist-info/LICENSE,sha256=jwRtEmTWjLrEsvFB6QFdYs2cEeZPRMdj-UMOFkPF8_0,11363
-swarms-7.6.4.dist-info/METADATA,sha256=FihAIDYyoPwxvfsXfvpCsMzdQMHvBZ7fXkp5v06DIUE,104909
-swarms-7.6.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-swarms-7.6.4.dist-info/entry_points.txt,sha256=2K0rTtfO1X1WaO-waJlXIKw5Voa_EpAL_yU0HXE2Jgc,47
-swarms-7.6.4.dist-info/RECORD,,
+swarms-7.6.6.dist-info/LICENSE,sha256=jwRtEmTWjLrEsvFB6QFdYs2cEeZPRMdj-UMOFkPF8_0,11363
+swarms-7.6.6.dist-info/METADATA,sha256=TEtg7nZgZwYoprC2ACZmn1n_CC_c7LOWXBIs1aPLLeM,104928
+swarms-7.6.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+swarms-7.6.6.dist-info/entry_points.txt,sha256=2K0rTtfO1X1WaO-waJlXIKw5Voa_EpAL_yU0HXE2Jgc,47
+swarms-7.6.6.dist-info/RECORD,,