diff --git a/playground/structs/multi_agent_collaboration/swarm_network_example.py b/playground/structs/swarm_network_example.py similarity index 92% rename from playground/structs/multi_agent_collaboration/swarm_network_example.py rename to playground/structs/swarm_network_example.py index f073719c..69cbe0ef 100644 --- a/playground/structs/multi_agent_collaboration/swarm_network_example.py +++ b/playground/structs/swarm_network_example.py @@ -2,12 +2,11 @@ import os from swarms import ( Agent, - OpenAIChat, SwarmNetwork, - Anthropic, + OpenAIChat, TogetherLLM, ) -from swarms.memory import ChromaDB +from playground.memory.chromadb_example import ChromaDB from dotenv import load_dotenv # load the environment variables @@ -22,7 +21,7 @@ llm = OpenAIChat( ) # Initialize the Anthropic -anthropic = Anthropic(max_tokens=3000) +anthropic = OpenAIChat(max_tokens=3000) # TogeterLM together_llm = TogetherLLM( diff --git a/swarms/agents/__init__.py b/swarms/agents/__init__.py index e5481f1d..35a8d54b 100644 --- a/swarms/agents/__init__.py +++ b/swarms/agents/__init__.py @@ -13,13 +13,10 @@ from swarms.agents.stopping_conditions import ( check_success, ) from swarms.agents.tool_agent import ToolAgent -from swarms.agents.worker_agent import Worker __all__ = [ "AbstractAgent", "ToolAgent", - "SimpleAgent", - "OmniModalAgent", "check_done", "check_finished", "check_complete", @@ -30,6 +27,5 @@ __all__ = [ "check_cancelled", "check_exit", "check_end", - "Worker", "agent_wrapper", ] diff --git a/swarms/agents/worker_agent.py b/swarms/agents/worker_agent.py deleted file mode 100644 index 1176e0a8..00000000 --- a/swarms/agents/worker_agent.py +++ /dev/null @@ -1,182 +0,0 @@ -from typing import List - -from langchain_experimental.autonomous_agents import AutoGPT - -from swarms.structs.agent import Agent -from swarms.tools.base_tool import BaseTool -from swarms.utils.decorators import error_decorator, timing_decorator - - -class Worker(Agent): - """ - The Worker class represents an autonomous agent that can perform tassks through - function calls or by running a chat. - - Args: - name (str, optional): Name of the agent. Defaults to "Autobot Swarm Worker". - role (str, optional): Role of the agent. Defaults to "Worker in a swarm". - external_tools (list, optional): List of external tools. Defaults to None. - human_in_the_loop (bool, optional): Whether to include human in the loop. Defaults to False. - temperature (float, optional): Temperature for the agent. Defaults to 0.5. - llm ([type], optional): Language model. Defaults to None. - openai_api_key (str, optional): OpenAI API key. Defaults to None. - - Raises: - RuntimeError: If there is an error while setting up the agent. - - Example: - >>> worker = Worker( - ... name="My Worker", - ... role="Worker", - ... external_tools=[MyTool1(), MyTool2()], - ... human_in_the_loop=False, - ... temperature=0.5, - ... ) - >>> worker.run("What's the weather in Miami?") - - """ - - def __init__( - self, - name: str = "WorkerAgent", - role: str = "Worker in a swarm", - external_tools=None, - human_in_the_loop: bool = False, - temperature: float = 0.5, - llm=None, - openai_api_key: str = None, - tools: List[BaseTool] = None, - embedding_size: int = 1536, - search_kwargs: dict = {"k": 8}, - verbose: bool = False, - memory: callable = None, - *args, - **kwargs, - ): - self.name = name - self.role = role - self.external_tools = external_tools - self.human_in_the_loop = human_in_the_loop - self.temperature = temperature - self.llm = llm - self.openai_api_key = openai_api_key - self.tools = tools - self.embedding_size = embedding_size - self.search_kwargs = search_kwargs - self.verbose = verbose - self.memory = memory - - self.setup_tools(external_tools) - self.setup_memory() - self.setup_agent() - - def reset(self): - """ - Reset the message history. - """ - self.message_history = [] - - def receieve(self, name: str, message: str) -> None: - """ - Receive a message and update the message history. - - Parameters: - - `name` (str): The name of the sender. - - `message` (str): The received message. - """ - self.message_history.append(f"{name}: {message}") - - def send(self) -> str: - """Send message history.""" - self.agent.run(task=self.message_history) - - def setup_tools(self, external_tools): - """ - Set up tools for the worker. - - Parameters: - - `external_tools` (list): List of external tools (optional). - - Example: - ``` - external_tools = [MyTool1(), MyTool2()] - worker = Worker(model_name="gpt-4", - openai_api_key="my_key", - name="My Worker", - role="Worker", - external_tools=external_tools, - human_in_the_loop=False, - temperature=0.5) - ``` - """ - if self.tools is None: - self.tools = [] - - if external_tools is not None: - self.tools.extend(external_tools) - - def setup_memory(self): - """ - Set up memory for the worker. - """ - try: - self.vectorstore = self.memory - - except Exception as error: - raise RuntimeError( - "Error setting up memory perhaps try try tuning the" - f" embedding size: {error}" - ) - - def setup_agent(self): - """ - Set up the autonomous agent. - """ - try: - self.agent = AutoGPT.from_llm_and_tools( - ai_name=self.name, - ai_role=self.role, - tools=self.tools, - llm=self.llm, - # memory = None, - human_in_the_loop=self.human_in_the_loop, - ) - - except Exception as error: - raise RuntimeError(f"Error setting up agent: {error}") - - @error_decorator - @timing_decorator - def run(self, task: str = None, *args, **kwargs): - """ - Run the autonomous agent on a given task. - - Parameters: - - `task`: The task to be processed. - - Returns: - - `result`: The result of the agent's processing. - """ - try: - result = self.agent.run([task], *args, **kwargs) - return result - except Exception as error: - raise RuntimeError(f"Error while running agent: {error}") - - @error_decorator - @timing_decorator - def __call__(self, task: str = None, *args, **kwargs): - """ - Make the worker callable to run the agent on a given task. - - Parameters: - - `task`: The task to be processed. - - Returns: - - `results`: The results of the agent's processing. - """ - try: - result = self.agent.run([task], *args, **kwargs) - return result - except Exception as error: - raise RuntimeError(f"Error while running agent: {error}") diff --git a/swarms/structs/base_swarm.py b/swarms/structs/base_swarm.py index f0a5d957..8a688b06 100644 --- a/swarms/structs/base_swarm.py +++ b/swarms/structs/base_swarm.py @@ -113,8 +113,10 @@ class BaseSwarm(ABC): self.collective_memory_system = collective_memory_system self.agent_ops_on = agent_ops_on + logger.info("Reliability checks activated.") # Ensure that agents is exists if self.agents is None: + logger.info("Agents must be provided.") raise ValueError("Agents must be provided.") # Ensure that agents is a list diff --git a/swarms/structs/swarm_net.py b/swarms/structs/swarm_net.py index bdb4724d..c9f6609c 100644 --- a/swarms/structs/swarm_net.py +++ b/swarms/structs/swarm_net.py @@ -120,7 +120,7 @@ class SwarmNetwork(BaseSwarm): *args, **kwargs, ): - super().__init__(*args, **kwargs) + super().__init__(agents=agents, *args, **kwargs) self.name = name self.description = description self.agents = agents diff --git a/tests/structs/test_moa.py b/tests/structs/test_moa.py new file mode 100644 index 00000000..2012be6c --- /dev/null +++ b/tests/structs/test_moa.py @@ -0,0 +1,74 @@ +import pytest +from unittest.mock import Mock, patch +from swarms.structs.mixture_of_agents import MixtureOfAgents +from swarms.structs.agent import Agent +from swarms.memory.base_vectordb import BaseVectorDatabase + + +def test_init(): + with patch.object( + MixtureOfAgents, "agent_check" + ) as mock_agent_check, patch.object( + MixtureOfAgents, "final_agent_check" + ) as mock_final_agent_check, patch.object( + MixtureOfAgents, "swarm_initialization" + ) as mock_swarm_initialization, patch.object( + MixtureOfAgents, "communication_protocol" + ) as mock_communication_protocol: + agents = [Mock(spec=Agent)] + final_agent = Mock(spec=Agent) + scp = Mock(spec=BaseVectorDatabase) + MixtureOfAgents(agents=agents, final_agent=final_agent, scp=scp) + mock_agent_check.assert_called_once() + mock_final_agent_check.assert_called_once() + mock_swarm_initialization.assert_called_once() + mock_communication_protocol.assert_called_once() + + +def test_communication_protocol(): + agents = [Mock(spec=Agent)] + final_agent = Mock(spec=Agent) + scp = Mock(spec=BaseVectorDatabase) + swarm = MixtureOfAgents( + agents=agents, final_agent=final_agent, scp=scp + ) + swarm.communication_protocol() + for agent in agents: + agent.long_term_memory.assert_called_once_with(scp) + + +def test_agent_check(): + final_agent = Mock(spec=Agent) + with pytest.raises(TypeError): + MixtureOfAgents(agents="not a list", final_agent=final_agent) + with pytest.raises(TypeError): + MixtureOfAgents(agents=["not an agent"], final_agent=final_agent) + + +def test_final_agent_check(): + agents = [Mock(spec=Agent)] + with pytest.raises(TypeError): + MixtureOfAgents(agents=agents, final_agent="not an agent") + + +def test_swarm_initialization(): + with patch("swarms.structs.mixture_of_agents.logger") as mock_logger: + agents = [Mock(spec=Agent)] + final_agent = Mock(spec=Agent) + swarm = MixtureOfAgents(agents=agents, final_agent=final_agent) + swarm.swarm_initialization() + assert mock_logger.info.call_count == 3 + + +def test_run(): + with patch("swarms.structs.mixture_of_agents.logger"), patch( + "builtins.open", new_callable=Mock + ) as mock_open: + agents = [Mock(spec=Agent)] + final_agent = Mock(spec=Agent) + swarm = MixtureOfAgents(agents=agents, final_agent=final_agent) + swarm.run("task") + for agent in agents: + agent.run.assert_called_once() + final_agent.run.assert_called_once() + mock_open.assert_called_once_with(swarm.saved_file_name, "w")