pull/951/merge
Kye Gomez 2 days ago
parent 504f40f2b7
commit 2d558061ba

@ -47,10 +47,9 @@ We invite you to explore these implementations, contribute to our research effor
| Paper Name | Description | Original Paper | Implementation | Status | Key Features | | Paper Name | Description | Original Paper | Implementation | Status | Key Features |
|------------|-------------|----------------|----------------|--------|--------------| |------------|-------------|----------------|----------------|--------|--------------|
| **MALT (Multi-Agent Learning Task)** | A sophisticated orchestration framework that coordinates multiple specialized AI agents to tackle complex tasks through structured conversations. | [arXiv:2412.01928](https://arxiv.org/pdf/2412.01928) | [`swarms.structs.malt`](https://docs.swarms.world/en/latest/swarms/structs/malt/) | ✅ Complete | Creator-Verifier-Refiner architecture, structured conversations, reliability guarantees | | **MALT (Multi-Agent Learning Task)** | A sophisticated orchestration framework that coordinates multiple specialized AI agents to tackle complex tasks through structured conversations. | [arXiv:2412.01928](https://arxiv.org/pdf/2412.01928) | [`swarms.structs.malt`](https://docs.swarms.world/en/latest/swarms/structs/malt/) | ✅ Complete | Creator-Verifier-Refiner architecture, structured conversations, reliability guarantees |
| **MAI-DxO (MAI Diagnostic Orchestrator)** | An open-source implementation of Microsoft Research's "Sequential Diagnosis with Language Models" paper, simulating a virtual panel of physician-agents for iterative medical diagnosis. | Microsoft Research Paper | [GitHub Repository](https://github.com/The-Swarm-Corporation/Open-MAI-Dx-Orchestrator) | ✅ Complete | Cost-effective medical diagnosis, physician-agent panel, iterative refinement | | **[MAI-DxO (MAI Diagnostic Orchestrator)](https://arxiv.org/abs/2506.22405)** | An open-source implementation of Microsoft Research's "[Sequential Diagnosis with Language Models](https://arxiv.org/abs/2506.22405)" paper, simulating a virtual panel of physician-agents for iterative medical diagnosis. | Microsoft Research Paper | [GitHub Repository](https://github.com/The-Swarm-Corporation/Open-MAI-Dx-Orchestrator) | ✅ Complete | Cost-effective medical diagnosis, physician-agent panel, iterative refinement |
| **AI-CoScientist** | A multi-agent AI framework for collaborative scientific research, implementing the "Towards an AI Co-Scientist" methodology with tournament-based hypothesis evolution. | "Towards an AI Co-Scientist" Paper | [GitHub Repository](https://github.com/The-Swarm-Corporation/AI-CoScientist) | ✅ Complete | Tournament-based selection, peer review systems, hypothesis evolution, Elo rating system | | **[AI-CoScientist](https://storage.googleapis.com/coscientist_paper/ai_coscientist.pdf)** | A multi-agent AI framework for collaborative scientific research, implementing the "Towards an AI Co-Scientist" methodology with tournament-based hypothesis evolution. | "Towards an AI Co-Scientist" Paper | [GitHub Repository](https://github.com/The-Swarm-Corporation/AI-CoScientist) | ✅ Complete | Tournament-based selection, peer review systems, hypothesis evolution, Elo rating system |
| **Mixture of Agents (MoA)** | A sophisticated multi-agent architecture that implements parallel processing with iterative refinement, combining diverse expert agents for comprehensive analysis. | Multi-agent collaboration concepts | [`swarms.structs.moa`](https://docs.swarms.world/en/latest/swarms/structs/moa/) | ✅ Complete | Parallel processing, expert agent combination, iterative refinement, state-of-the-art performance | | **[Mixture of Agents (MoA)](https://arxiv.org/abs/2406.04692)** | A sophisticated multi-agent architecture that implements parallel processing with iterative refinement, combining diverse expert agents for comprehensive analysis. | Multi-agent collaboration concepts | [`swarms.structs.moa`](https://docs.swarms.world/en/latest/swarms/structs/moa/) | ✅ Complete | Parallel processing, expert agent combination, iterative refinement, state-of-the-art performance |
| **Open Scientist** | A multi-agent system for scientific research exploration using specialized agents for hypothesis generation, peer review, ranking, evolution, and meta-analysis. | Scientific research methodology | [`examples/demos/open_scientist.py`](https://github.com/kyegomez/swarms/blob/main/examples/demos/open_scientist.py) | ✅ Complete | Hypothesis generation, peer review, ranking, evolution, meta-analysis, proximity control |
| **Deep Research Swarm** | A production-grade research system that conducts comprehensive analysis across multiple domains using parallel processing and advanced AI agents. | Research methodology | [`swarms.structs.deep_research_swarm`](https://docs.swarms.world/en/latest/swarms/structs/deep_research_swarm/) | ✅ Complete | Parallel search processing, multi-agent coordination, information synthesis, concurrent execution | | **Deep Research Swarm** | A production-grade research system that conducts comprehensive analysis across multiple domains using parallel processing and advanced AI agents. | Research methodology | [`swarms.structs.deep_research_swarm`](https://docs.swarms.world/en/latest/swarms/structs/deep_research_swarm/) | ✅ Complete | Parallel search processing, multi-agent coordination, information synthesis, concurrent execution |
| **Agent-as-a-Judge** | An evaluation framework that uses agents to evaluate other agents, implementing the "Agent-as-a-Judge: Evaluate Agents with Agents" methodology. | [arXiv:2410.10934](https://arxiv.org/abs/2410.10934) | [`swarms.agents.agent_judge`](https://docs.swarms.world/en/latest/swarms/agents/agent_judge/) | ✅ Complete | Agent evaluation, quality assessment, automated judging, performance metrics | | **Agent-as-a-Judge** | An evaluation framework that uses agents to evaluate other agents, implementing the "Agent-as-a-Judge: Evaluate Agents with Agents" methodology. | [arXiv:2410.10934](https://arxiv.org/abs/2410.10934) | [`swarms.agents.agent_judge`](https://docs.swarms.world/en/latest/swarms/agents/agent_judge/) | ✅ Complete | Agent evaluation, quality assessment, automated judging, performance metrics |

@ -1,5 +1,6 @@
import requests import requests
def get_example_py_urls(): def get_example_py_urls():
owner = "kyegomez" owner = "kyegomez"
repo = "swarms" repo = "swarms"
@ -7,7 +8,9 @@ def get_example_py_urls():
examples_path = "examples" examples_path = "examples"
api_url = f"https://api.github.com/repos/{owner}/{repo}/git/trees/{branch}?recursive=1" api_url = f"https://api.github.com/repos/{owner}/{repo}/git/trees/{branch}?recursive=1"
raw_base = f"https://raw.githubusercontent.com/{owner}/{repo}/{branch}/" raw_base = (
f"https://raw.githubusercontent.com/{owner}/{repo}/{branch}/"
)
response = requests.get(api_url) response = requests.get(api_url)
response.raise_for_status() response.raise_for_status()
@ -25,6 +28,7 @@ def get_example_py_urls():
return example_files return example_files
if __name__ == "__main__": if __name__ == "__main__":
urls = get_example_py_urls() urls = get_example_py_urls()
for url in urls: for url in urls:

@ -11,7 +11,7 @@ Flow:
""" """
import traceback import traceback
from typing import Any, List, Literal, Optional, Union, Callable from typing import Any, Callable, List, Literal, Optional, Union
from pydantic import BaseModel, Field from pydantic import BaseModel, Field
@ -21,15 +21,13 @@ from swarms.prompts.hiearchical_system_prompt import (
from swarms.structs.agent import Agent from swarms.structs.agent import Agent
from swarms.structs.base_swarm import BaseSwarm from swarms.structs.base_swarm import BaseSwarm
from swarms.structs.conversation import Conversation from swarms.structs.conversation import Conversation
from swarms.structs.ma_utils import list_all_agents
from swarms.tools.base_tool import BaseTool
from swarms.utils.history_output_formatter import ( from swarms.utils.history_output_formatter import (
history_output_formatter, history_output_formatter,
) )
from swarms.utils.output_types import OutputType
from swarms.utils.loguru_logger import initialize_logger from swarms.utils.loguru_logger import initialize_logger
from swarms.tools.base_tool import BaseTool from swarms.utils.output_types import OutputType
from swarms.structs.ma_utils import list_all_agents
logger = initialize_logger(log_folder="hierarchical_swarm") logger = initialize_logger(log_folder="hierarchical_swarm")
@ -118,6 +116,7 @@ class HierarchicalSwarm(BaseSwarm):
planning_director_agent: Optional[ planning_director_agent: Optional[
Union[Agent, Callable, Any] Union[Agent, Callable, Any]
] = None, ] = None,
director_feedback_on: bool = True,
*args, *args,
**kwargs, **kwargs,
): ):
@ -150,6 +149,7 @@ class HierarchicalSwarm(BaseSwarm):
self.director_model_name = director_model_name self.director_model_name = director_model_name
self.add_collaboration_prompt = add_collaboration_prompt self.add_collaboration_prompt = add_collaboration_prompt
self.planning_director_agent = planning_director_agent self.planning_director_agent = planning_director_agent
self.director_feedback_on = director_feedback_on
self.init_swarm() self.init_swarm()
@ -354,7 +354,10 @@ class HierarchicalSwarm(BaseSwarm):
if self.verbose: if self.verbose:
logger.info(f"⚡ Executed {len(outputs)} orders") logger.info(f"⚡ Executed {len(outputs)} orders")
if self.director_feedback_on is True:
feedback = self.feedback_director(outputs) feedback = self.feedback_director(outputs)
else:
feedback = outputs
if self.verbose: if self.verbose:
logger.success("✅ Step completed successfully") logger.success("✅ Step completed successfully")
@ -469,7 +472,9 @@ class HierarchicalSwarm(BaseSwarm):
f"Worker Agent Responses: {task}" f"Worker Agent Responses: {task}"
) )
) )
self.conversation.add(role="Director", content=output) self.conversation.add(
role=self.director.agent_name, content=output
)
if self.verbose: if self.verbose:
logger.success( logger.success(

@ -1,10 +1,8 @@
import os import os
import json import json
import time
from datetime import datetime from datetime import datetime
from typing import List, Dict, Any, Callable from typing import List, Dict, Any, Callable
import requests
from dotenv import load_dotenv from dotenv import load_dotenv
# Basic Imports for Swarms # Basic Imports for Swarms
@ -20,16 +18,19 @@ from swarms.structs import (
MajorityVoting, MajorityVoting,
SwarmRouter, SwarmRouter,
RoundRobinSwarm, RoundRobinSwarm,
InteractiveGroupChat InteractiveGroupChat,
) )
# Import swarms not in __init__.py directly # Import swarms not in __init__.py directly
from swarms.structs.hiearchical_swarm import HierarchicalSwarm from swarms.structs.hiearchical_swarm import HierarchicalSwarm
from swarms.structs.tree_swarm import ForestSwarm, Tree, TreeAgent from swarms.structs.tree_swarm import ForestSwarm, Tree, TreeAgent
from swarms.tools.base_tool import BaseTool
# Setup Logging # Setup Logging
from loguru import logger from loguru import logger
logger.add("test_runs/test_failures.log", rotation="10 MB", level="ERROR")
logger.add(
"test_runs/test_failures.log", rotation="10 MB", level="ERROR"
)
# Load environment variables # Load environment variables
load_dotenv() load_dotenv()
@ -49,18 +50,24 @@ API_KEY = os.getenv("OPENAI_API_KEY")
# --- Helper Functions --- # --- Helper Functions ---
def generate_timestamp() -> str: def generate_timestamp() -> str:
"""Generate a timestamp string for filenames""" """Generate a timestamp string for filenames"""
return datetime.now().strftime("%Y%m%d_%H%M%S") return datetime.now().strftime("%Y%m%d_%H%M%S")
def write_markdown_report(results: List[Dict[str, Any]], filename: str):
def write_markdown_report(
results: List[Dict[str, Any]], filename: str
):
"""Write test results to a markdown file""" """Write test results to a markdown file"""
if not os.path.exists("test_runs"): if not os.path.exists("test_runs"):
os.makedirs("test_runs") os.makedirs("test_runs")
with open(f"test_runs/{filename}.md", "w") as f: with open(f"test_runs/{filename}.md", "w") as f:
f.write("# Swarms Comprehensive Test Report\n\n") f.write("# Swarms Comprehensive Test Report\n\n")
f.write(f"Test Run: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n") f.write(
f"Test Run: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
)
total = len(results) total = len(results)
passed = sum(1 for r in results if r["status"] == "passed") passed = sum(1 for r in results if r["status"] == "passed")
@ -80,16 +87,23 @@ def write_markdown_report(results: List[Dict[str, Any]], filename: str):
f.write("Response:\n```json\n") f.write("Response:\n```json\n")
response_str = result["response"] response_str = result["response"]
try: try:
response_json = json.loads(response_str) if isinstance(response_str, str) else response_str response_json = (
json.loads(response_str)
if isinstance(response_str, str)
else response_str
)
f.write(json.dumps(response_json, indent=2)) f.write(json.dumps(response_json, indent=2))
except (json.JSONDecodeError, TypeError): except (json.JSONDecodeError, TypeError):
f.write(str(response_str)) f.write(str(response_str))
f.write("\n```\n\n") f.write("\n```\n\n")
if result.get("error"): if result.get("error"):
f.write(f"**Error:**\n```\n{result['error']}\n```\n\n") f.write(
f"**Error:**\n```\n{result['error']}\n```\n\n"
)
f.write("---\n\n") f.write("---\n\n")
# def create_github_issue(test_result: Dict[str, Any]) -> Dict[str, Any]: # def create_github_issue(test_result: Dict[str, Any]) -> Dict[str, Any]:
# """Create a GitHub issue for a failed test""" # """Create a GitHub issue for a failed test"""
# if not all([GITHUB_TOKEN, GITHUB_REPO_OWNER, GITHUB_REPO_NAME]): # if not all([GITHUB_TOKEN, GITHUB_REPO_OWNER, GITHUB_REPO_NAME]):
@ -141,43 +155,66 @@ def write_markdown_report(results: List[Dict[str, Any]], filename: str):
# logger.error(f"Failed to create GitHub issue: {e.response.text if e.response else str(e)}") # logger.error(f"Failed to create GitHub issue: {e.response.text if e.response else str(e)}")
# return None # return None
def create_test_agent(name: str, system_prompt: str = None, model_name: str = "gpt-4o-mini", tools: List[Callable] = None, **kwargs) -> Agent:
def create_test_agent(
name: str,
system_prompt: str = None,
model_name: str = "gpt-4o-mini",
tools: List[Callable] = None,
**kwargs,
) -> Agent:
"""Create a properly configured test agent with error handling""" """Create a properly configured test agent with error handling"""
try: try:
return Agent( return Agent(
agent_name=name, agent_name=name,
system_prompt=system_prompt or f"You are {name}, a helpful AI assistant.", system_prompt=system_prompt
or f"You are {name}, a helpful AI assistant.",
model_name=model_name, # Use mini model for faster/cheaper testing model_name=model_name, # Use mini model for faster/cheaper testing
max_loops=1, max_loops=1,
max_tokens=200, max_tokens=200,
tools=tools, tools=tools,
**kwargs **kwargs,
) )
except Exception as e: except Exception as e:
logger.error(f"Failed to create agent {name}: {e}") logger.error(f"Failed to create agent {name}: {e}")
raise raise
# --- Basic Agent Tests --- # --- Basic Agent Tests ---
def test_basic_agent_functionality(): def test_basic_agent_functionality():
"""Test basic agent creation and execution""" """Test basic agent creation and execution"""
agent = create_test_agent("BasicAgent") agent = create_test_agent("BasicAgent")
response = agent.run("Say hello and explain what you are.") response = agent.run("Say hello and explain what you are.")
assert isinstance(response, str) and len(response) > 0 assert isinstance(response, str) and len(response) > 0
return {"test_name": "test_basic_agent_functionality", "status": "passed", "response": "Agent created and responded successfully"} return {
"test_name": "test_basic_agent_functionality",
"status": "passed",
"response": "Agent created and responded successfully",
}
def test_agent_with_custom_prompt(): def test_agent_with_custom_prompt():
"""Test agent with custom system prompt""" """Test agent with custom system prompt"""
custom_prompt = "You are a mathematician who only responds with numbers and mathematical expressions." custom_prompt = "You are a mathematician who only responds with numbers and mathematical expressions."
agent = create_test_agent("MathAgent", system_prompt=custom_prompt) agent = create_test_agent(
"MathAgent", system_prompt=custom_prompt
)
response = agent.run("What is 2+2?") response = agent.run("What is 2+2?")
assert isinstance(response, str) and len(response) > 0 assert isinstance(response, str) and len(response) > 0
return {"test_name": "test_agent_with_custom_prompt", "status": "passed", "response": response[:100]} return {
"test_name": "test_agent_with_custom_prompt",
"status": "passed",
"response": response[:100],
}
def test_tool_execution_with_agent(): def test_tool_execution_with_agent():
"""Test agent's ability to use tools""" """Test agent's ability to use tools"""
def simple_calculator(a: int, b: int) -> int: def simple_calculator(a: int, b: int) -> int:
"""Add two numbers together""" """Add two numbers together"""
return a + b return a + b
@ -189,118 +226,218 @@ def test_tool_execution_with_agent():
agent = create_test_agent( agent = create_test_agent(
"ToolAgent", "ToolAgent",
system_prompt="You are a helpful assistant that can use tools to help users.", system_prompt="You are a helpful assistant that can use tools to help users.",
tools=[simple_calculator, get_weather] tools=[simple_calculator, get_weather],
)
response = agent.run(
"What's 5 + 7 and what's the weather like in New York?"
) )
response = agent.run("What's 5 + 7 and what's the weather like in New York?")
assert isinstance(response, str) and len(response) > 0 assert isinstance(response, str) and len(response) > 0
return {"test_name": "test_tool_execution_with_agent", "status": "passed", "response": "Tool execution completed"} return {
"test_name": "test_tool_execution_with_agent",
"status": "passed",
"response": "Tool execution completed",
}
# --- Multi-Modal Tests --- # --- Multi-Modal Tests ---
def test_multimodal_execution(): def test_multimodal_execution():
"""Test agent's ability to process images""" """Test agent's ability to process images"""
agent = create_test_agent("VisionAgent", model_name="gpt-4o", multi_modal=True) agent = create_test_agent(
"VisionAgent", model_name="gpt-4o", multi_modal=True
)
try: try:
# Check if test images exist, if not skip the test # Check if test images exist, if not skip the test
if os.path.exists("tests/test_data/image1.jpg"): if os.path.exists("tests/test_data/image1.jpg"):
response = agent.run("Describe this image.", img="tests/test_data/image1.jpg") response = agent.run(
"Describe this image.",
img="tests/test_data/image1.jpg",
)
assert isinstance(response, str) and len(response) > 0 assert isinstance(response, str) and len(response) > 0
else: else:
logger.warning("Test image not found, skipping multimodal test") logger.warning(
"Test image not found, skipping multimodal test"
)
response = "Test skipped - no test image available" response = "Test skipped - no test image available"
return {"test_name": "test_multimodal_execution", "status": "passed", "response": "Multimodal response received"} return {
"test_name": "test_multimodal_execution",
"status": "passed",
"response": "Multimodal response received",
}
except Exception as e: except Exception as e:
logger.warning(f"Multimodal test failed: {e}") logger.warning(f"Multimodal test failed: {e}")
return {"test_name": "test_multimodal_execution", "status": "passed", "response": "Multimodal test skipped due to missing dependencies"} return {
"test_name": "test_multimodal_execution",
"status": "passed",
"response": "Multimodal test skipped due to missing dependencies",
}
# --- Workflow Tests --- # --- Workflow Tests ---
def test_sequential_workflow(): def test_sequential_workflow():
"""Test SequentialWorkflow with multiple agents""" """Test SequentialWorkflow with multiple agents"""
agents = [ agents = [
create_test_agent("ResearchAgent", "You are a research specialist who gathers information."), create_test_agent(
create_test_agent("AnalysisAgent", "You are an analyst who analyzes information and provides insights."), "ResearchAgent",
create_test_agent("WriterAgent", "You are a writer who creates clear, concise summaries.") "You are a research specialist who gathers information.",
),
create_test_agent(
"AnalysisAgent",
"You are an analyst who analyzes information and provides insights.",
),
create_test_agent(
"WriterAgent",
"You are a writer who creates clear, concise summaries.",
),
] ]
workflow = SequentialWorkflow( workflow = SequentialWorkflow(
name="research-analysis-workflow", name="research-analysis-workflow", agents=agents, max_loops=1
agents=agents,
max_loops=1
) )
try: try:
response = workflow.run("Research and analyze the benefits of renewable energy, then write a brief summary.") response = workflow.run(
logger.info(f"SequentialWorkflow response type: {type(response)}") "Research and analyze the benefits of renewable energy, then write a brief summary."
)
logger.info(
f"SequentialWorkflow response type: {type(response)}"
)
# SequentialWorkflow returns conversation history # SequentialWorkflow returns conversation history
assert response is not None assert response is not None
return {"test_name": "test_sequential_workflow", "status": "passed", "response": "Sequential workflow completed"} return {
"test_name": "test_sequential_workflow",
"status": "passed",
"response": "Sequential workflow completed",
}
except Exception as e: except Exception as e:
logger.error(f"SequentialWorkflow test failed with exception: {e}") logger.error(
return {"test_name": "test_sequential_workflow", "status": "failed", "error": str(e)} f"SequentialWorkflow test failed with exception: {e}"
)
return {
"test_name": "test_sequential_workflow",
"status": "failed",
"error": str(e),
}
def test_concurrent_workflow(): def test_concurrent_workflow():
"""Test ConcurrentWorkflow with multiple agents""" """Test ConcurrentWorkflow with multiple agents"""
agents = [ agents = [
create_test_agent("TechAnalyst", "You are a technology analyst who focuses on tech trends."), create_test_agent(
create_test_agent("MarketAnalyst", "You are a market analyst who focuses on market conditions.") "TechAnalyst",
"You are a technology analyst who focuses on tech trends.",
),
create_test_agent(
"MarketAnalyst",
"You are a market analyst who focuses on market conditions.",
),
] ]
workflow = ConcurrentWorkflow( workflow = ConcurrentWorkflow(
name="concurrent-analysis", name="concurrent-analysis", agents=agents, max_loops=1
agents=agents,
max_loops=1
) )
try: try:
response = workflow.run("Analyze the current state of AI technology and its market impact.") response = workflow.run(
logger.info(f"ConcurrentWorkflow response type: {type(response)}") "Analyze the current state of AI technology and its market impact."
)
logger.info(
f"ConcurrentWorkflow response type: {type(response)}"
)
assert response is not None assert response is not None
return {"test_name": "test_concurrent_workflow", "status": "passed", "response": "Concurrent workflow completed"} return {
"test_name": "test_concurrent_workflow",
"status": "passed",
"response": "Concurrent workflow completed",
}
except Exception as e: except Exception as e:
logger.error(f"ConcurrentWorkflow test failed with exception: {e}") logger.error(
return {"test_name": "test_concurrent_workflow", "status": "failed", "error": str(e)} f"ConcurrentWorkflow test failed with exception: {e}"
)
return {
"test_name": "test_concurrent_workflow",
"status": "failed",
"error": str(e),
}
# --- Advanced Swarm Tests --- # --- Advanced Swarm Tests ---
def test_agent_rearrange(): def test_agent_rearrange():
"""Test AgentRearrange dynamic workflow""" """Test AgentRearrange dynamic workflow"""
agents = [ agents = [
create_test_agent("Researcher", "You are a researcher who gathers information."), create_test_agent(
create_test_agent("Analyst", "You are an analyst who analyzes information."), "Researcher",
create_test_agent("Writer", "You are a writer who creates final reports.") "You are a researcher who gathers information.",
),
create_test_agent(
"Analyst", "You are an analyst who analyzes information."
),
create_test_agent(
"Writer", "You are a writer who creates final reports."
),
] ]
flow = "Researcher -> Analyst -> Writer" flow = "Researcher -> Analyst -> Writer"
swarm = AgentRearrange(agents=agents, flow=flow, max_loops=1) swarm = AgentRearrange(agents=agents, flow=flow, max_loops=1)
response = swarm.run("Research renewable energy, analyze the benefits, and write a summary.") response = swarm.run(
"Research renewable energy, analyze the benefits, and write a summary."
)
assert response is not None assert response is not None
return {"test_name": "test_agent_rearrange", "status": "passed", "response": "AgentRearrange completed"} return {
"test_name": "test_agent_rearrange",
"status": "passed",
"response": "AgentRearrange completed",
}
def test_mixture_of_agents(): def test_mixture_of_agents():
"""Test MixtureOfAgents collaboration""" """Test MixtureOfAgents collaboration"""
agents = [ agents = [
create_test_agent("TechExpert", "You are a technology expert."), create_test_agent(
create_test_agent("BusinessAnalyst", "You are a business analyst."), "TechExpert", "You are a technology expert."
create_test_agent("Strategist", "You are a strategic planner.") ),
create_test_agent(
"BusinessAnalyst", "You are a business analyst."
),
create_test_agent(
"Strategist", "You are a strategic planner."
),
] ]
swarm = MixtureOfAgents(agents=agents, max_loops=1) swarm = MixtureOfAgents(agents=agents, max_loops=1)
response = swarm.run("Analyze the impact of AI on modern businesses.") response = swarm.run(
"Analyze the impact of AI on modern businesses."
)
assert response is not None assert response is not None
return {"test_name": "test_mixture_of_agents", "status": "passed", "response": "MixtureOfAgents completed"} return {
"test_name": "test_mixture_of_agents",
"status": "passed",
"response": "MixtureOfAgents completed",
}
def test_spreadsheet_swarm(): def test_spreadsheet_swarm():
"""Test SpreadSheetSwarm for data processing""" """Test SpreadSheetSwarm for data processing"""
agents = [ agents = [
create_test_agent("DataProcessor1", "You process and analyze numerical data."), create_test_agent(
create_test_agent("DataProcessor2", "You perform calculations and provide insights.") "DataProcessor1",
"You process and analyze numerical data.",
),
create_test_agent(
"DataProcessor2",
"You perform calculations and provide insights.",
),
] ]
swarm = SpreadSheetSwarm( swarm = SpreadSheetSwarm(
@ -308,24 +445,39 @@ def test_spreadsheet_swarm():
description="A swarm for processing data", description="A swarm for processing data",
agents=agents, agents=agents,
max_loops=1, max_loops=1,
autosave_on=False autosave_on=False,
) )
response = swarm.run("Calculate the sum of 25 + 75 and provide analysis.") response = swarm.run(
"Calculate the sum of 25 + 75 and provide analysis."
)
assert response is not None assert response is not None
return {"test_name": "test_spreadsheet_swarm", "status": "passed", "response": "SpreadSheetSwarm completed"} return {
"test_name": "test_spreadsheet_swarm",
"status": "passed",
"response": "SpreadSheetSwarm completed",
}
def test_hierarchical_swarm(): def test_hierarchical_swarm():
"""Test HierarchicalSwarm structure""" """Test HierarchicalSwarm structure"""
try: try:
from swarms.utils.function_caller_model import OpenAIFunctionCaller from swarms.utils.function_caller_model import (
OpenAIFunctionCaller,
)
from swarms.structs.hiearchical_swarm import SwarmSpec from swarms.structs.hiearchical_swarm import SwarmSpec
# Create worker agents # Create worker agents
workers = [ workers = [
create_test_agent("Worker1", "You are Worker1 who handles research tasks and data gathering."), create_test_agent(
create_test_agent("Worker2", "You are Worker2 who handles analysis tasks and reporting.") "Worker1",
"You are Worker1 who handles research tasks and data gathering.",
),
create_test_agent(
"Worker2",
"You are Worker2 who handles analysis tasks and reporting.",
),
] ]
# Create director agent with explicit knowledge of available agents # Create director agent with explicit knowledge of available agents
@ -344,63 +496,107 @@ def test_hierarchical_swarm():
"4. Provide actionable task descriptions" "4. Provide actionable task descriptions"
), ),
temperature=0.1, temperature=0.1,
max_tokens=1000 max_tokens=1000,
) )
swarm = HierarchicalSwarm( swarm = HierarchicalSwarm(
description="A test hierarchical swarm for task delegation", description="A test hierarchical swarm for task delegation",
director=director, director=director,
agents=workers, agents=workers,
max_loops=1 max_loops=1,
) )
response = swarm.run("Research current team meeting best practices and analyze them to create recommendations.") response = swarm.run(
"Research current team meeting best practices and analyze them to create recommendations."
)
assert response is not None assert response is not None
return {"test_name": "test_hierarchical_swarm", "status": "passed", "response": "HierarchicalSwarm completed"} return {
"test_name": "test_hierarchical_swarm",
"status": "passed",
"response": "HierarchicalSwarm completed",
}
except ImportError as e: except ImportError as e:
logger.warning(f"HierarchicalSwarm test skipped due to missing dependencies: {e}") logger.warning(
return {"test_name": "test_hierarchical_swarm", "status": "passed", "response": "Test skipped due to missing dependencies"} f"HierarchicalSwarm test skipped due to missing dependencies: {e}"
)
return {
"test_name": "test_hierarchical_swarm",
"status": "passed",
"response": "Test skipped due to missing dependencies",
}
def test_majority_voting(): def test_majority_voting():
"""Test MajorityVoting consensus mechanism""" """Test MajorityVoting consensus mechanism"""
agents = [ agents = [
create_test_agent("Judge1", "You are a judge who evaluates options carefully."), create_test_agent(
create_test_agent("Judge2", "You are a judge who provides thorough analysis."), "Judge1",
create_test_agent("Judge3", "You are a judge who considers all perspectives.") "You are a judge who evaluates options carefully.",
),
create_test_agent(
"Judge2",
"You are a judge who provides thorough analysis.",
),
create_test_agent(
"Judge3",
"You are a judge who considers all perspectives.",
),
] ]
swarm = MajorityVoting(agents=agents) swarm = MajorityVoting(agents=agents)
response = swarm.run("Should companies invest more in renewable energy? Provide YES or NO with reasoning.") response = swarm.run(
"Should companies invest more in renewable energy? Provide YES or NO with reasoning."
)
assert response is not None assert response is not None
return {"test_name": "test_majority_voting", "status": "passed", "response": "MajorityVoting completed"} return {
"test_name": "test_majority_voting",
"status": "passed",
"response": "MajorityVoting completed",
}
def test_round_robin_swarm(): def test_round_robin_swarm():
"""Test RoundRobinSwarm task distribution""" """Test RoundRobinSwarm task distribution"""
agents = [ agents = [
create_test_agent("Agent1", "You handle counting tasks."), create_test_agent("Agent1", "You handle counting tasks."),
create_test_agent("Agent2", "You handle color-related tasks."), create_test_agent(
create_test_agent("Agent3", "You handle animal-related tasks.") "Agent2", "You handle color-related tasks."
),
create_test_agent(
"Agent3", "You handle animal-related tasks."
),
] ]
swarm = RoundRobinSwarm(agents=agents) swarm = RoundRobinSwarm(agents=agents)
tasks = [ tasks = [
"Count from 1 to 5", "Count from 1 to 5",
"Name 3 primary colors", "Name 3 primary colors",
"List 3 common pets" "List 3 common pets",
] ]
response = swarm.run(tasks) response = swarm.run(tasks)
assert response is not None assert response is not None
return {"test_name": "test_round_robin_swarm", "status": "passed", "response": "RoundRobinSwarm completed"} return {
"test_name": "test_round_robin_swarm",
"status": "passed",
"response": "RoundRobinSwarm completed",
}
def test_swarm_router(): def test_swarm_router():
"""Test SwarmRouter dynamic routing""" """Test SwarmRouter dynamic routing"""
agents = [ agents = [
create_test_agent("DataAnalyst", "You specialize in data analysis and statistics."), create_test_agent(
create_test_agent("ReportWriter", "You specialize in writing clear, professional reports.") "DataAnalyst",
"You specialize in data analysis and statistics.",
),
create_test_agent(
"ReportWriter",
"You specialize in writing clear, professional reports.",
),
] ]
router = SwarmRouter( router = SwarmRouter(
@ -408,65 +604,111 @@ def test_swarm_router():
description="Routes analysis and reporting tasks to appropriate agents", description="Routes analysis and reporting tasks to appropriate agents",
agents=agents, agents=agents,
swarm_type="SequentialWorkflow", swarm_type="SequentialWorkflow",
max_loops=1 max_loops=1,
) )
response = router.run("Analyze customer satisfaction data and write a summary report.") response = router.run(
"Analyze customer satisfaction data and write a summary report."
)
assert response is not None assert response is not None
return {"test_name": "test_swarm_router", "status": "passed", "response": "SwarmRouter completed"} return {
"test_name": "test_swarm_router",
"status": "passed",
"response": "SwarmRouter completed",
}
def test_groupchat(): def test_groupchat():
"""Test GroupChat functionality""" """Test GroupChat functionality"""
agents = [ agents = [
create_test_agent("Moderator", "You are a discussion moderator who guides conversations."), create_test_agent(
create_test_agent("Expert1", "You are a subject matter expert who provides insights."), "Moderator",
create_test_agent("Expert2", "You are another expert who offers different perspectives.") "You are a discussion moderator who guides conversations.",
),
create_test_agent(
"Expert1",
"You are a subject matter expert who provides insights.",
),
create_test_agent(
"Expert2",
"You are another expert who offers different perspectives.",
),
] ]
groupchat = GroupChat( groupchat = GroupChat(agents=agents, messages=[], max_round=2)
agents=agents,
messages=[],
max_round=2
)
# GroupChat requires a different interface than other swarms # GroupChat requires a different interface than other swarms
response = groupchat.run("Discuss the benefits and challenges of remote work.") response = groupchat.run(
"Discuss the benefits and challenges of remote work."
)
assert response is not None assert response is not None
return {"test_name": "test_groupchat", "status": "passed", "response": "GroupChat completed"} return {
"test_name": "test_groupchat",
"status": "passed",
"response": "GroupChat completed",
}
def test_multi_agent_router(): def test_multi_agent_router():
"""Test MultiAgentRouter functionality""" """Test MultiAgentRouter functionality"""
agents = [ agents = [
create_test_agent("TechAgent", "You handle technology-related queries."), create_test_agent(
create_test_agent("BusinessAgent", "You handle business-related queries."), "TechAgent", "You handle technology-related queries."
create_test_agent("GeneralAgent", "You handle general queries.") ),
create_test_agent(
"BusinessAgent", "You handle business-related queries."
),
create_test_agent(
"GeneralAgent", "You handle general queries."
),
] ]
router = MultiAgentRouter(agents=agents) router = MultiAgentRouter(agents=agents)
response = router.run("What are the latest trends in business technology?") response = router.run(
"What are the latest trends in business technology?"
)
assert response is not None assert response is not None
return {"test_name": "test_multi_agent_router", "status": "passed", "response": "MultiAgentRouter completed"} return {
"test_name": "test_multi_agent_router",
"status": "passed",
"response": "MultiAgentRouter completed",
}
def test_interactive_groupchat(): def test_interactive_groupchat():
"""Test InteractiveGroupChat functionality""" """Test InteractiveGroupChat functionality"""
agents = [ agents = [
create_test_agent("Facilitator", "You facilitate group discussions."), create_test_agent(
create_test_agent("Participant1", "You are an active discussion participant."), "Facilitator", "You facilitate group discussions."
create_test_agent("Participant2", "You provide thoughtful contributions to discussions.") ),
create_test_agent(
"Participant1",
"You are an active discussion participant.",
),
create_test_agent(
"Participant2",
"You provide thoughtful contributions to discussions.",
),
] ]
interactive_chat = InteractiveGroupChat( interactive_chat = InteractiveGroupChat(
agents=agents, agents=agents, max_loops=2
max_loops=2
) )
response = interactive_chat.run("Let's discuss the future of artificial intelligence.") response = interactive_chat.run(
"Let's discuss the future of artificial intelligence."
)
assert response is not None assert response is not None
return {"test_name": "test_interactive_groupchat", "status": "passed", "response": "InteractiveGroupChat completed"} return {
"test_name": "test_interactive_groupchat",
"status": "passed",
"response": "InteractiveGroupChat completed",
}
def test_forest_swarm(): def test_forest_swarm():
"""Test ForestSwarm tree-based structure""" """Test ForestSwarm tree-based structure"""
@ -475,23 +717,23 @@ def test_forest_swarm():
tree1_agents = [ tree1_agents = [
TreeAgent( TreeAgent(
system_prompt="You analyze market trends", system_prompt="You analyze market trends",
agent_name="Market-Analyst" agent_name="Market-Analyst",
), ),
TreeAgent( TreeAgent(
system_prompt="You provide financial insights", system_prompt="You provide financial insights",
agent_name="Financial-Advisor" agent_name="Financial-Advisor",
) ),
] ]
tree2_agents = [ tree2_agents = [
TreeAgent( TreeAgent(
system_prompt="You assess investment risks", system_prompt="You assess investment risks",
agent_name="Risk-Assessor" agent_name="Risk-Assessor",
), ),
TreeAgent( TreeAgent(
system_prompt="You create investment strategies", system_prompt="You create investment strategies",
agent_name="Strategy-Planner" agent_name="Strategy-Planner",
) ),
] ]
# Create trees # Create trees
@ -501,29 +743,50 @@ def test_forest_swarm():
# Create ForestSwarm # Create ForestSwarm
forest = ForestSwarm(trees=[tree1, tree2]) forest = ForestSwarm(trees=[tree1, tree2])
response = forest.run("Analyze the current market and develop an investment strategy.") response = forest.run(
"Analyze the current market and develop an investment strategy."
)
assert response is not None assert response is not None
return {"test_name": "test_forest_swarm", "status": "passed", "response": "ForestSwarm completed"} return {
"test_name": "test_forest_swarm",
"status": "passed",
"response": "ForestSwarm completed",
}
except Exception as e: except Exception as e:
logger.error(f"ForestSwarm test failed: {e}") logger.error(f"ForestSwarm test failed: {e}")
return {"test_name": "test_forest_swarm", "status": "failed", "error": str(e)} return {
"test_name": "test_forest_swarm",
"status": "failed",
"error": str(e),
}
# --- Performance & Features Tests --- # --- Performance & Features Tests ---
def test_streaming_mode(): def test_streaming_mode():
"""Test streaming response generation""" """Test streaming response generation"""
agent = create_test_agent("StreamingAgent", streaming_on=True) agent = create_test_agent("StreamingAgent", streaming_on=True)
response = agent.run("Tell me a very short story about technology.") response = agent.run(
"Tell me a very short story about technology."
)
assert response is not None assert response is not None
return {"test_name": "test_streaming_mode", "status": "passed", "response": "Streaming mode tested"} return {
"test_name": "test_streaming_mode",
"status": "passed",
"response": "Streaming mode tested",
}
def test_agent_memory_persistence(): def test_agent_memory_persistence():
"""Test agent memory functionality""" """Test agent memory functionality"""
agent = create_test_agent("MemoryAgent", agent = create_test_agent(
"MemoryAgent",
system_prompt="You remember information from previous conversations.", system_prompt="You remember information from previous conversations.",
return_history=True) return_history=True,
)
# First interaction # First interaction
response1 = agent.run("My name is Alice. Please remember this.") response1 = agent.run("My name is Alice. Please remember this.")
@ -531,7 +794,12 @@ def test_agent_memory_persistence():
response2 = agent.run("What is my name?") response2 = agent.run("What is my name?")
assert response1 is not None and response2 is not None assert response1 is not None and response2 is not None
return {"test_name": "test_agent_memory_persistence", "status": "passed", "response": "Memory persistence tested"} return {
"test_name": "test_agent_memory_persistence",
"status": "passed",
"response": "Memory persistence tested",
}
def test_error_handling(): def test_error_handling():
"""Test agent error handling with various inputs""" """Test agent error handling with various inputs"""
@ -546,46 +814,78 @@ def test_error_handling():
response = agent.run("Hi") response = agent.run("Hi")
assert response is not None assert response is not None
return {"test_name": "test_error_handling", "status": "passed", "response": "Error handling tests passed"} return {
"test_name": "test_error_handling",
"status": "passed",
"response": "Error handling tests passed",
}
except Exception as e: except Exception as e:
return {"test_name": "test_error_handling", "status": "failed", "error": str(e)} return {
"test_name": "test_error_handling",
"status": "failed",
"error": str(e),
}
# --- Integration Tests --- # --- Integration Tests ---
def test_complex_workflow_integration(): def test_complex_workflow_integration():
"""Test complex multi-agent workflow integration""" """Test complex multi-agent workflow integration"""
try: try:
# Create specialized agents # Create specialized agents
researcher = create_test_agent("Researcher", "You research topics thoroughly and gather information.") researcher = create_test_agent(
analyst = create_test_agent("Analyst", "You analyze research data and provide insights.") "Researcher",
writer = create_test_agent("Writer", "You write clear, comprehensive summaries.") "You research topics thoroughly and gather information.",
)
analyst = create_test_agent(
"Analyst",
"You analyze research data and provide insights.",
)
writer = create_test_agent(
"Writer", "You write clear, comprehensive summaries."
)
# Test SequentialWorkflow # Test SequentialWorkflow
sequential = SequentialWorkflow( sequential = SequentialWorkflow(
name="research-workflow", name="research-workflow",
agents=[researcher, analyst, writer], agents=[researcher, analyst, writer],
max_loops=1 max_loops=1,
) )
seq_response = sequential.run("Research AI trends, analyze them, and write a summary.") seq_response = sequential.run(
"Research AI trends, analyze them, and write a summary."
)
# Test ConcurrentWorkflow # Test ConcurrentWorkflow
concurrent = ConcurrentWorkflow( concurrent = ConcurrentWorkflow(
name="parallel-analysis", name="parallel-analysis",
agents=[researcher, analyst], agents=[researcher, analyst],
max_loops=1 max_loops=1,
) )
conc_response = concurrent.run("What are the benefits and challenges of AI?") conc_response = concurrent.run(
"What are the benefits and challenges of AI?"
)
assert seq_response is not None and conc_response is not None assert seq_response is not None and conc_response is not None
return {"test_name": "test_complex_workflow_integration", "status": "passed", "response": "Complex workflow integration completed"} return {
"test_name": "test_complex_workflow_integration",
"status": "passed",
"response": "Complex workflow integration completed",
}
except Exception as e: except Exception as e:
logger.error(f"Complex workflow integration test failed: {e}") logger.error(f"Complex workflow integration test failed: {e}")
return {"test_name": "test_complex_workflow_integration", "status": "failed", "error": str(e)} return {
"test_name": "test_complex_workflow_integration",
"status": "failed",
"error": str(e),
}
# --- Test Orchestrator --- # --- Test Orchestrator ---
def run_all_tests(): def run_all_tests():
"""Run all tests and generate a comprehensive report""" """Run all tests and generate a comprehensive report"""
logger.info("Starting Enhanced Swarms Comprehensive Test Suite") logger.info("Starting Enhanced Swarms Comprehensive Test Suite")
@ -595,14 +895,11 @@ def run_all_tests():
test_basic_agent_functionality, test_basic_agent_functionality,
test_agent_with_custom_prompt, test_agent_with_custom_prompt,
test_tool_execution_with_agent, test_tool_execution_with_agent,
# Multi-Modal Tests # Multi-Modal Tests
test_multimodal_execution, test_multimodal_execution,
# Workflow Tests # Workflow Tests
test_sequential_workflow, test_sequential_workflow,
test_concurrent_workflow, test_concurrent_workflow,
# Advanced Swarm Tests # Advanced Swarm Tests
test_agent_rearrange, test_agent_rearrange,
test_mixture_of_agents, test_mixture_of_agents,
@ -615,12 +912,10 @@ def run_all_tests():
test_multi_agent_router, test_multi_agent_router,
# test_interactive_groupchat, # test_interactive_groupchat,
# test_forest_swarm, # test_forest_swarm,
# Performance & Features # Performance & Features
test_streaming_mode, test_streaming_mode,
test_agent_memory_persistence, test_agent_memory_persistence,
test_error_handling, test_error_handling,
# Integration Tests # Integration Tests
test_complex_workflow_integration, test_complex_workflow_integration,
] ]
@ -639,30 +934,39 @@ def run_all_tests():
"test_name": test_name, "test_name": test_name,
"status": "failed", "status": "failed",
"error": str(e), "error": str(e),
"response": "Test execution failed" "response": "Test execution failed",
} }
results.append(error_details) results.append(error_details)
# create_github_issue(error_details) # Uncomment to enable GitHub issue creation # create_github_issue(error_details) # Uncomment to enable GitHub issue creation
timestamp = generate_timestamp() timestamp = generate_timestamp()
write_markdown_report(results, f"comprehensive_test_report_{timestamp}") write_markdown_report(
results, f"comprehensive_test_report_{timestamp}"
)
# Summary # Summary
total_tests = len(results) total_tests = len(results)
passed_tests = sum(1 for r in results if r['status'] == 'passed') passed_tests = sum(1 for r in results if r["status"] == "passed")
failed_tests = total_tests - passed_tests failed_tests = total_tests - passed_tests
logger.info(f"Test Summary: {passed_tests}/{total_tests} passed ({(passed_tests/total_tests)*100:.1f}%)") logger.info(
f"Test Summary: {passed_tests}/{total_tests} passed ({(passed_tests/total_tests)*100:.1f}%)"
)
if failed_tests > 0: if failed_tests > 0:
logger.error(f"{failed_tests} tests failed. Check the report and logs.") logger.error(
f"{failed_tests} tests failed. Check the report and logs."
)
exit(1) exit(1)
else: else:
logger.success("All tests passed successfully!") logger.success("All tests passed successfully!")
if __name__ == "__main__": if __name__ == "__main__":
if not API_KEY: if not API_KEY:
logger.error("OPENAI_API_KEY environment variable not set. Aborting tests.") logger.error(
"OPENAI_API_KEY environment variable not set. Aborting tests."
)
exit(1) exit(1)
else: else:
run_all_tests() run_all_tests()

Loading…
Cancel
Save