swarms 7.7.1__tar.gz → 7.7.3__tar.gz

{swarms-7.7.1 → swarms-7.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: swarms
-Version: 7.7.1
+Version: 7.7.3
 Summary: Swarms - TGSC
 Home-page: https://github.com/kyegomez/swarms
 License: MIT
@@ -18,11 +18,14 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Dist: PyYAML
 Requires-Dist: aiofiles
+Requires-Dist: aiohttp
 Requires-Dist: asyncio (>=3.4.3,<4.0)
 Requires-Dist: docstring_parser (==0.16)
+Requires-Dist: fastmcp
 Requires-Dist: httpx
 Requires-Dist: litellm
 Requires-Dist: loguru
+Requires-Dist: mcp
 Requires-Dist: networkx
 Requires-Dist: numpy
 Requires-Dist: psutil
@@ -40,7 +43,7 @@ Description-Content-Type: text/markdown
 
 <div align="center">
   <a href="https://swarms.world">
-    <img src="https://github.com/kyegomez/swarms/blob/master/images/swarmslogobanner.png" style="margin: 15px; max-width: 300px" width="50%" alt="Logo">
+    <img src="https://github.com/kyegomez/swarms/blob/master/images/swarmslogobanner.png" style="margin: 15px; max-width: 500px" width="50%" alt="Logo">
   </a>
 </div>
 <p align="center">
@@ -59,9 +62,11 @@ Description-Content-Type: text/markdown
     <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
     <a href="https://discord.gg/jM3Z6M9uMq">📢 Discord</a>
     <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
-    <a href="https://swarms.world">Swarms Platform</a>
+    <a href="https://swarms.ai">Swarms Website</a>
     <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
     <a href="https://docs.swarms.world">📙 Documentation</a>
+    <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+    <a href="https://swarms.world"> Swarms Marketplace</a>
 </p>
 
 <p align="center">
@@ -75,7 +80,7 @@ Description-Content-Type: text/markdown
     <a href="https://www.linkedin.com/in/kye-g-38759a207/">
         <img src="https://img.shields.io/badge/LinkedIn-Connect-blue?style=for-the-badge&logo=linkedin&logoColor=white" alt="LinkedIn">
     </a>
-    <a href="https://x.com/kyegomezb">
+    <a href="https://x.com/swarms_corp">
         <img src="https://img.shields.io/badge/X.com-Follow-1DA1F2?style=for-the-badge&logo=x&logoColor=white" alt="X.com">
     </a>
 </p>
@@ -150,15 +155,6 @@ Description-Content-Type: text/markdown
 | 🎯 Use Case Support | • Task-Specific Agents<br>• Custom Workflows<br>• Industry Solutions<br>• Extensible Framework | • Quick deployment<br>• Flexible solutions<br>• Industry readiness<br>• Easy customization |
 
 
-----
-
-## Requirements
-- `python3.10` or above!
-- `$ pip install -U swarms` And, don't forget to install swarms!
-- `.env` file with API keys from your providers like `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`
--  Set an `.env` Variable with your desired workspace dir: `WORKSPACE_DIR="agent_workspace"` or do it in your terminal with `export WORKSPACE_DIR="agent_workspace"`
--  Finally, `swarms onboarding` to get you started.
-
 ## Guides and Walkthroughs
 Refer to our documentation for production grade implementation details.
 
@@ -178,46 +174,60 @@ Refer to our documentation for production grade implementation details.
 
 
 ## Install 💻
-Install the following packages with copy and paste
 
+### Using pip
 ```bash
-$ pip3 install -U swarms swarms-memory
+$ pip3 install -U swarms
 ```
 
+### Using uv (Recommended)
+[uv](https://github.com/astral-sh/uv) is a fast Python package installer and resolver, written in Rust.
 
-## [Optional] Onboarding
+```bash
+# Install uv
+$ curl -LsSf https://astral.sh/uv/install.sh | sh
 
-Now that you have downloaded swarms with `pip3 install -U swarms`, we get access to the `CLI`. Get Onboarded with CLI Now with:
+# Install swarms using uv
+$ uv pip install swarms
+```
 
+### Using poetry
 ```bash
-swarms onboarding
-```
+# Install poetry if you haven't already
+$ curl -sSL https://install.python-poetry.org | python3 -
 
-You can also run this command for help:
+# Add swarms to your project
+$ poetry add swarms
+```
 
+### From source
 ```bash
-swarms help
-```
+# Clone the repository
+$ git clone https://github.com/kyegomez/swarms.git
+$ cd swarms
 
-For more documentation on the CLI [CLICK HERE](https://docs.swarms.world/en/latest/swarms/cli/main/)
+# Install with pip
+$ pip install -e .
+```
 
 ---
 
-# Usage Examples 🤖
-Here are some example scripts to get you started. For more comprehensive documentation, visit our [docs](https://docs.swarms.world/en/latest/).
-
-| Example Name | Description | Type of Examples | Link |
-| --- | --- | --- | --- |
-| Swarms Examples | A collection of simple examples to demonstrate Swarms capabilities. | Basic Usage | [https://github.com/The-Swarm-Corporation/swarms-examples?tab=readme-ov-file](https://github.com/The-Swarm-Corporation/swarms-examples?tab=readme-ov-file) |
-| Cookbook | A comprehensive guide with recipes for various use cases and scenarios. | Advanced Usage | [https://github.com/The-Swarm-Corporation/Cookbook](https://github.com/The-Swarm-Corporation/Cookbook) |
-
+## Environment Configuration
 
+```
+OPENAI_API_KEY=""
+WORKSPACE_DIR="agent_workspace"
+ANTHROPIC_API_KEY=""
+GROQ_API_KEY=""
+```
 
+- [Learn more about the environment configuration here](https://docs.swarms.world/en/latest/swarms/install/env/)
 
 ---
 
 ## `Agent` Class
-The `Agent` class is a fundamental component of the Swarms framework, designed to execute tasks autonomously. It fuses llms, tools and long-term memory capabilities to create a full stack agent. The `Agent` class is highly customizable, allowing for fine-grained control over its behavior and interactions.
+The `Agent` class is a customizable autonomous component of the Swarms framework that integrates LLMs, tools, and long-term memory. Its `run` method processes text tasks and optionally handles image inputs through vision-language models.
+
 
 ```mermaid
 graph TD
@@ -230,8 +240,6 @@ graph TD
     G --> C
 ```
 
-### `run` Method
-The `run` method is the primary entry point for executing tasks with an `Agent` instance. It accepts a task string as the main input task and processes it according to the agent's configuration. And, it can also accept an `img` parameter such as `img="image_filepath.png` to process images if you have a VLM attached such as `GPT4VisionAPI`
 
 
 
@@ -253,6 +261,7 @@ agent.run("What is the current market trend for tech stocks?")
 ```
 
 ### Settings and Customization
+
 The `Agent` class offers a range of settings to tailor its behavior to specific needs. Some key settings include:
 
 | Setting | Description | Default Value |
@@ -308,6 +317,7 @@ agent.run(
 -----
 
 ### Integrating RAG with Swarms for Enhanced Long-Term Memory
+
 `Agent` equipped with quasi-infinite long term memory using RAG (Relational Agent Graph) for advanced document understanding, analysis, and retrieval capabilities.
 
 **Mermaid Diagram for RAG Integration**
@@ -820,40 +830,8 @@ print(json.dumps(response, indent=4))
 
 
 ### `SequentialWorkflow`
-Sequential Workflow enables you to sequentially execute tasks with `Agent` and then pass the output into the next agent and onwards until you have specified your max loops.
-
-```mermaid
-graph LR
-    A[Agent 1] --> B[Agent 2]
-    B --> C[Agent 3]
-    C --> D[Agent 4]
-    D --> E[Max Loops]
-    E --> F[End]
-```
-
-
-
-### Methods
-
-| Method | Description | Parameters | Return Value |
-|--------|-------------|------------|--------------|
-| `__init__` | Initialize the SequentialWorkflow | `agents`: List of Agent objects<br>`max_loops`: Maximum number of iterations<br>`verbose`: Boolean for verbose output | None |
-| `run` | Execute the workflow | `input_data`: Initial input for the first agent | Final output after all agents have processed |
-
-### Inputs
-
-| Input | Type | Description |
-|-------|------|-------------|
-| `agents` | List[Agent] | List of Agent objects to be executed sequentially |
-| `max_loops` | int | Maximum number of times the entire sequence will be repeated |
-| `verbose` | bool | If True, print detailed information during execution |
-
-### Output
-
-The `run` method returns the final output after all agents have processed the input sequentially.
-
-In this example, each `Agent` represents a task that is executed sequentially. The output of each agent is passed to the next agent in the sequence until the maximum number of loops is reached. This workflow is particularly useful for tasks that require a series of steps to be executed in a specific order, such as data processing pipelines or complex calculations that rely on the output of previous steps.
 
+The SequentialWorkflow in the Swarms framework enables sequential task execution across multiple Agent objects. Each agent's output serves as input for the next agent in the sequence, continuing until reaching the specified maximum number of loops (max_loops). This workflow is particularly well-suited for tasks requiring a specific order of operations, such as data processing pipelines. To learn more, visit: [Learn More](https://docs.swarms.world/en/latest/swarms/structs/sequential_workflow/)
 
 ```python
 import os
@@ -1043,32 +1021,10 @@ print(
 
 ------
 
-## `AgentRearrange`
-
-The `AgentRearrange` orchestration technique, inspired by Einops and einsum, allows you to define and map out the relationships between various agents. It provides a powerful tool for orchestrating complex workflows, enabling you to specify linear and sequential relationships such as `a -> a1 -> a2 -> a3`, or concurrent relationships where the first agent sends a message to 3 agents simultaneously: `a -> a1, a2, a3`. This level of customization allows for the creation of highly efficient and dynamic workflows, where agents can work in parallel or in sequence as needed. The `AgentRearrange` technique is a valuable addition to the swarms library, providing a new level of flexibility and control over the orchestration of agents. For more detailed information and examples, please refer to the [official documentation](https://docs.swarms.world/en/latest/swarms/structs/agent_rearrange/).
-
-[Check out my video on agent rearrange!](https://youtu.be/Rq8wWQ073mg)
-
-
-
-### Methods
-
-| Method | Description | Parameters | Return Value |
-|--------|-------------|------------|--------------|
-| `__init__` | Initialize the AgentRearrange | `agents`: List of Agent objects<br>`flow`: String describing the agent flow | None |
-| `run` | Execute the workflow | `input_data`: Initial input for the first agent | Final output after all agents have processed |
-
-### Inputs
-
-| Input | Type | Description |
-|-------|------|-------------|
-| `agents` | List[Agent] | List of Agent objects to be orchestrated |
-| `flow` | str | String describing the flow of agents (e.g., "A -> B, C") |
 
-### Output
-
-The `run` method returns the final output after all agents have processed the input according to the specified flow.
+## `AgentRearrange`
 
+The `AgentRearrange` orchestration technique, inspired by Einops and einsum, enables you to define and map relationships between multiple agents. This powerful tool facilitates the orchestration of complex workflows by allowing you to specify both linear and concurrent relationships. For example, you can create sequential workflows like `a -> a1 -> a2 -> a3` or parallel workflows where a single agent distributes tasks to multiple agents simultaneously: `a -> a1, a2, a3`. This flexibility enables the creation of highly efficient and dynamic workflows, with agents operating either in parallel or sequence as required. As a valuable addition to the swarms library, `AgentRearrange` provides enhanced flexibility and precise control over agent orchestration. For comprehensive information and examples, visit the [official documentation](https://docs.swarms.world/en/latest/swarms/structs/agent_rearrange/). [Watch my video tutorial on agent rearrange!](https://youtu.be/Rq8wWQ073mg)
 
 
 
@@ -1255,80 +1211,46 @@ if __name__ == "__main__":
 
 ```
 
-## `HierarhicalSwarm`
-Coming soon...
-
-
-## `GraphSwarm`
-
-
-The `GraphSwarm` is a workflow management system designed to orchestrate complex tasks by leveraging the power of graph theory. It enables the creation of a directed acyclic graph (DAG) to model dependencies between tasks and agents. This allows for efficient task assignment, execution, and monitoring.
-
-Here's a breakdown of how the `GraphSwarm` works:
-
-1. **Node Creation**: The `GraphSwarm` workflow is composed of nodes, which can be either agents or tasks. Agents are responsible for executing tasks, and tasks represent specific operations that need to be performed. In the example, two agents (`agent1` and `agent2`) and one task (`task1`) are created.
-2. **Edge Definition**: Edges are used to define the relationships between nodes. In this case, edges are created to connect `agent1` and `agent2` to `task1`, indicating that both agents are capable of executing `task1`.
-3. **Entry and End Points**: The `GraphSwarm` workflow requires the definition of entry points (where the workflow starts) and end points (where the workflow concludes). In this example, `agent1` and `agent2` are set as entry points, and `task1` is set as the end point.
-4. **Visualization**: The `GraphSwarm` provides a visualization feature to graphically represent the workflow. This allows for easy understanding and debugging of the workflow structure.
-5. **Execution**: The `GraphSwarm` workflow is executed by traversing the graph from the entry points to the end points. In this case, both `agent1` and `agent2` execute `task1` concurrently, and the results are collected.
-6. **Results**: The final results of the workflow execution are aggregated and returned. In this example, the result of executing `task1` is "Task completed".
-
-The `GraphSwarm` offers several benefits, including:
-
-* **Concurrency**: Enables the execution of tasks concurrently, improving overall workflow efficiency.
-* **Flexibility**: Allows for dynamic task assignment based on agent availability and task requirements.
-* **Scalability**: Supports the addition of new agents and tasks as needed, making it suitable for large-scale workflows.
-* **Visualization**: Provides a graphical representation of the workflow, facilitating understanding and debugging.
-
-By leveraging the `GraphSwarm`, complex workflows can be efficiently managed, and tasks can be executed in a coordinated and scalable manner.
 
+------------
 
 
-### Methods
+## `HierarhicalSwarm`
+Coming soon...
 
-| Method | Description | Parameters | Return Value |
-|--------|-------------|------------|--------------|
-| `add_node` | Add a node to the graph | `node`: Node object | None |
-| `add_edge` | Add an edge to the graph | `edge`: Edge object | None |
-| `set_entry_points` | Set the entry points of the graph | `entry_points`: List of node IDs | None |
-| `set_end_points` | Set the end points of the graph | `end_points`: List of node IDs | None |
-| `visualize` | Generate a visual representation of the graph | None | String representation of the graph |
-| `run` | Execute the workflow | None | Dictionary of execution results |
 
-### Inputs
+-----------------
 
-| Input | Type | Description |
-|-------|------|-------------|
-| `Node` | Object | Represents a node in the graph (agent or task) |
-| `Edge` | Object | Represents an edge connecting two nodes |
-| `entry_points` | List[str] | List of node IDs where the workflow starts |
-| `end_points` | List[str] | List of node IDs where the workflow ends |
+## `GraphWorkflow`
 
-### Output
 
-The `run` method returns a dictionary containing the execution results of all nodes in the graph.
+GraphWorkflow is a workflow management system using a directed acyclic graph (DAG) to orchestrate complex tasks. Nodes (agents or tasks) and edges define dependencies, with agents executing tasks concurrently. It features entry/end points, visualization for debugging, and scalability for dynamic task assignment. Benefits include concurrency, flexibility, scalability, and clear workflow visualization. [Learn more:](https://docs.swarms.world/en/latest/swarms/structs/graph_swarm/) The `run` method returns a dictionary containing the execution results of all nodes in the graph.
 
 
 
 ```python
-import os
-
-from dotenv import load_dotenv
-
-
 from swarms import Agent, Edge, GraphWorkflow, Node, NodeType
 
-from swarm_models import OpenAIChat
-
-load_dotenv()
-
-api_key = os.environ.get("OPENAI_API_KEY")
+# Initialize agents with model_name parameter
+agent1 = Agent(
+    agent_name="Agent1",
+    model_name="openai/gpt-4o-mini",  # Using provider prefix
+    temperature=0.5,
+    max_tokens=4000,
+    max_loops=1,
+    autosave=True,
+    dashboard=True,
+)
 
-llm = OpenAIChat(
-    temperature=0.5, openai_api_key=api_key, max_tokens=4000
+agent2 = Agent(
+    agent_name="Agent2",
+    model_name="openai/gpt-4o-mini",  # Using provider prefix
+    temperature=0.5,
+    max_tokens=4000,
+    max_loops=1,
+    autosave=True,
+    dashboard=True,
 )
-agent1 = Agent(llm=llm, max_loops=1, autosave=True, dashboard=True)
-agent2 = Agent(llm=llm, max_loops=1, autosave=True, dashboard=True)
 
 def sample_task():
     print("Running sample task")
@@ -1337,9 +1259,8 @@ def sample_task():
 wf_graph = GraphWorkflow()
 wf_graph.add_node(Node(id="agent1", type=NodeType.AGENT, agent=agent1))
 wf_graph.add_node(Node(id="agent2", type=NodeType.AGENT, agent=agent2))
-wf_graph.add_node(
-    Node(id="task1", type=NodeType.TASK, callable=sample_task)
-)
+wf_graph.add_node(Node(id="task1", type=NodeType.TASK, callable=sample_task))
+
 wf_graph.add_edge(Edge(source="agent1", target="task1"))
 wf_graph.add_edge(Edge(source="agent2", target="task1"))
 
@@ -1348,36 +1269,16 @@ wf_graph.set_end_points(["task1"])
 
 print(wf_graph.visualize())
 
-# Run the workflow
 results = wf_graph.run()
 print("Execution results:", results)
-
 ```
 
-## `MixtureOfAgents`
-This is an implementation based on the paper: "Mixture-of-Agents Enhances Large Language Model Capabilities" by together.ai, available at [https://arxiv.org/abs/2406.04692](https://arxiv.org/abs/2406.04692). It achieves state-of-the-art (SOTA) results on AlpacaEval 2.0, MT-Bench, and FLASK, surpassing GPT-4 Omni. This architecture is particularly suitable for tasks that require parallelization followed by sequential processing in another loop.
-
-
-
-### Methods
-
-| Method | Description | Parameters | Return Value |
-|--------|-------------|------------|--------------|
-| `__init__` | Initialize the MixtureOfAgents | `name`: Name of the swarm<br>`agents`: List of Agent objects<br>`layers`: Number of processing layers<br>`final_agent`: Agent for final processing | None |
-| `run` | Execute the swarm | `task`: Input task for the swarm | Final output after all agents have processed |
-
-### Inputs
+-----
 
-| Input | Type | Description |
-|-------|------|-------------|
-| `name` | str | Name of the swarm |
-| `agents` | List[Agent] | List of Agent objects to be used in the swarm |
-| `layers` | int | Number of processing layers in the swarm |
-| `final_agent` | Agent | Agent responsible for final processing |
 
-### Output
+## `MixtureOfAgents`
 
-The `run` method returns the final output after all agents have processed the input according to the specified layers and final agent.
+The MixtureOfAgents architecture, inspired by together.ai's paper (arXiv:2406.04692), achieves SOTA performance on AlpacaEval 2.0, MT-Bench, and FLASK, surpassing GPT-4 Omni. It processes tasks via parallel agent collaboration and sequential layering, with documentation [HERE](https://docs.swarms.world/en/latest/swarms/structs/moa/)
 
 
 ```python
@@ -1520,42 +1421,12 @@ print(out)
 
 ```
 
+-------
 
 ## SpreadSheetSwarm
-The `SpreadSheetSwarm` is designed for concurrent management and oversight of thousands of agents, facilitating a one-to-many approach for efficient task processing and output analysis.
-
-### Key Features
-
-* **Concurrency**: Enables the simultaneous execution of multiple agents, significantly reducing processing time and increasing overall system efficiency.
-* **One-to-Many**: Allows a single task to be dynamically distributed among multiple agents, ensuring that each agent is utilized to its full potential.
-* **Scalability**: Supports the integration of thousands of agents, making it an ideal solution for large-scale task processing and data analysis.
-
-
-### Methods
-
-| Method | Description | Parameters | Return Value |
-|--------|-------------|------------|--------------|
-| `__init__` | Initialize the SpreadSheetSwarm | `name`: Name of the swarm<br>`description`: Description of the swarm<br>`agents`: List of Agent objects<br>`autosave_on`: Boolean to enable autosave<br>`save_file_path`: Path to save the spreadsheet<br>`run_all_agents`: Boolean to run all agents or not<br>`max_loops`: Maximum number of loops | None |
-| `run` | Execute the swarm | `task`: Input task for the swarm | Dictionary of agent outputs |
-
-### Inputs
-
-| Input | Type | Description |
-|-------|------|-------------|
-| `name` | str | Name of the swarm |
-| `description` | str | Description of the swarm's purpose |
-| `agents` | List[Agent] | List of Agent objects to be used in the swarm |
-| `autosave_on` | bool | Enable autosaving of results |
-| `save_file_path` | str | Path to save the spreadsheet results |
-| `run_all_agents` | bool | Whether to run all agents or select based on relevance |
-| `max_loops` | int | Maximum number of processing loops |
-
-### Output
-
-The `run` method returns a dictionary containing the outputs of each agent that processed the task.
+SpreadSheetSwarm manages thousands of agents concurrently for efficient task processing. It supports one-to-many task distribution, scalability, and autosaving results. Initialized with a name, description, agents, and settings, the run method executes tasks and returns a dictionary of agent outputs.
 
-
-[Learn more at the docs here:](https://docs.swarms.world/en/latest/swarms/structs/spreadsheet_swarm/)
+[Learn more:](https://docs.swarms.world/en/latest/swarms/structs/spreadsheet_swarm/)
 
 ```python
 import os
@@ -1712,28 +1583,13 @@ swarm.run(
 ```
 
 
-## `ForestSwarm`
-The `ForestSwarm` architecture is designed for efficient task assignment by dynamically selecting the most suitable agent from a collection of trees. This is achieved through asynchronous task processing, where agents are chosen based on their relevance to the task at hand. The relevance is determined by calculating the similarity between the system prompts associated with each agent and the keywords present in the task itself. For a more in-depth understanding of how `ForestSwarm` works, please refer to the [official documentation](https://docs.swarms.world/en/latest/swarms/structs/forest_swarm/).
-
-
-
-### Methods
-
-| Method | Description | Parameters | Return Value |
-|--------|-------------|------------|--------------|
-| `__init__` | Initialize the ForestSwarm | `trees`: List of Tree objects | None |
-| `run` | Execute the ForestSwarm | `task`: Input task for the swarm | Output from the most relevant agent |
+----------
 
-### Inputs
+## `ForestSwarm`
 
-| Input | Type | Description |
-|-------|------|-------------|
-| `trees` | List[Tree] | List of Tree objects, each containing TreeAgent objects |
-| `task` | str | The task to be processed by the ForestSwarm |
+The `ForestSwarm` architecture is an intelligent system designed to optimize task assignment by dynamically selecting the most appropriate agent from a collection of specialized trees. Through asynchronous task processing, the system intelligently matches tasks with agents based on their relevance. This matching is accomplished by computing the semantic similarity between each agent's system prompts and the keywords present in the task. For comprehensive details about the `ForestSwarm` implementation and capabilities, please consult the [official documentation](https://docs.swarms.world/en/latest/swarms/structs/forest_swarm/).
 
-### Output
 
-The `run` method returns the output from the most relevant agent selected based on the input task.
 
 
 ```python
@@ -1851,25 +1707,11 @@ print(output)
 
 
 
+------------
 
 ## `SwarmRouter`
-The `SwarmRouter` class is a flexible routing system designed to manage different types of swarms for task execution. It provides a unified interface to interact with various swarm types, including `AgentRearrange`, `MixtureOfAgents`, `SpreadSheetSwarm`, `SequentialWorkflow`, and `ConcurrentWorkflow`. We will be continuously adding more and more swarm architectures here as we progress with new architectures.
-
-#### Attributes:
-- `name` (str): Name of the SwarmRouter instance.
-- `description` (str): Description of the SwarmRouter instance.
-- `max_loops` (int): Maximum number of loops to perform.
-- `agents` (List[Agent]): List of Agent objects to be used in the swarm.
-- `swarm_type` (SwarmType): Type of swarm to be used.
-- `swarm` (Union[AgentRearrange, MixtureOfAgents, SpreadSheetSwarm, SequentialWorkflow, ConcurrentWorkflow]): Instantiated swarm object.
-- `logs` (List[SwarmLog]): List of log entries captured during operations.
 
-#### Methods:
-- `__init__(self, name: str, description: str, max_loops: int, agents: List[Agent], swarm_type: SwarmType, *args, **kwargs)`: Initialize the SwarmRouter.
-- `_create_swarm(self, *args, **kwargs)`: Create and return the specified swarm type.
-- `_log(self, level: str, message: str, task: str, metadata: Dict[str, Any])`: Create a log entry and add it to the logs list.
-- `run(self, task: str, *args, **kwargs)`: Run the specified task on the selected swarm.
-- `get_logs(self)`: Retrieve all logged entries.
+The `SwarmRouter` class is a flexible routing system designed to manage different types of swarms for task execution. It provides a unified interface to interact with various swarm types, including `AgentRearrange`, `MixtureOfAgents`, `SpreadSheetSwarm`, `SequentialWorkflow`, and `ConcurrentWorkflow`. We will be continuously adding more and more swarm architectures here as we progress with new architectures. [Learn More](https://docs.swarms.world/en/latest/swarms/structs/swarm_router/)
 
 
 ```python
@@ -2256,21 +2098,20 @@ Documentation is located here at: [docs.swarms.world](https://docs.swarms.world)
 -----
 
 ## Folder Structure
-The swarms package has been meticlously crafted for extreme use-ability and understanding, the swarms package is split up into various modules such as `swarms.agents` that holds pre-built agents, `swarms.structs` that holds a vast array of structures like `Agent` and multi agent structures. The 3 most important are `structs`, `models`, and `agents`.
+The swarms package has been meticulously crafted for extreme usability and understanding,the swarms package is split up into various modules such as `swarms.agents` that holds pre-built agents, `swarms.structs` that holds a vast array of structures like `Agent` and multi agent structures. The package is split into various modules, with the most important being `structs`, `tools`, and `agents`.
 
 ```sh
 ├── __init__.py
-├── agents
-├── artifacts
-├── memory
-├── schemas
-├── models -> swarm_models
-├── prompts
-├── structs
-├── telemetry
-├── tools
-├── utils
-└── workers
+├── agents/
+├── artifacts/
+├── client/
+├── cli/
+├── prompts/
+├── schemas/
+├── structs/
+├── telemetry/
+├── tools/
+└── utils/
 ```
 
 ----
@@ -2284,23 +2125,17 @@ Swarms is an open-source project, and contributions are VERY welcome. If you wan
 ----
 
 
-
-## Accelerate Backlog
-Accelerate Bugs, Features, and Demos to implement by supporting us here:
-
-<a href="https://polar.sh/kyegomez"><img src="https://polar.sh/embed/fund-our-backlog.svg?org=kyegomez" /></a>
-
 ## Community
 
 Join our growing community around the world, for real-time support, ideas, and discussions on Swarms 😊 
 
-- View our official [Blog](https://docs.swarms.world)
+- View our official [Documents](https://docs.swarms.world)
+- View our official [Blog](https://medium.com/@kyeg)
 - Chat live with us on [Discord](https://discord.gg/jM3Z6M9uMq)
 - Follow us on [Twitter](https://twitter.com/kyegomez)
 - Connect with us on [LinkedIn](https://www.linkedin.com/company/the-swarm-corporation)
 - Visit us on [YouTube](https://www.youtube.com/channel/UC9yXyitkbU_WSy7bd_41SqQ)
-- [Join the Swarms community on Discord!](https://discord.gg/AJazBmhKnr)
-- Join our Swarms Community Gathering every Thursday at 1pm NYC Time to unlock the potential of autonomous agents in automating your daily tasks [Sign up here](https://lu.ma/5p2jnc2v)
+- Sign up for our events [Sign up here](https://lu.ma/5p2jnc2v)
 
 # License