Aksh Parekh
1 day ago
committed by
GitHub
commit
2b4fd96899
@ -1,20 +1,18 @@
|
||||
import orjson
|
||||
from dotenv import load_dotenv
|
||||
import json
|
||||
|
||||
from swarms.structs.auto_swarm_builder import AutoSwarmBuilder
|
||||
|
||||
load_dotenv()
|
||||
from swarms import AutoSwarmBuilder
|
||||
|
||||
swarm = AutoSwarmBuilder(
|
||||
name="My Swarm",
|
||||
description="My Swarm Description",
|
||||
verbose=True,
|
||||
max_loops=1,
|
||||
return_agents=True,
|
||||
execution_type="return-agents",
|
||||
model_name="gpt-4.1",
|
||||
)
|
||||
|
||||
result = swarm.run(
|
||||
task="Build a swarm to write a research paper on the topic of AI"
|
||||
)
|
||||
|
||||
print(orjson.dumps(result, option=orjson.OPT_INDENT_2).decode())
|
||||
print(json.dumps(result, indent=2))
|
||||
@ -0,0 +1,171 @@
|
||||
# Medical AOP Example
|
||||
|
||||
A real-world demonstration of the Agent Orchestration Protocol (AOP) using medical agents deployed as MCP tools.
|
||||
|
||||
## Overview
|
||||
|
||||
This example showcases how to:
|
||||
- Deploy multiple medical agents as MCP tools via AOP
|
||||
- Use discovery tools for dynamic agent collaboration
|
||||
- Execute real tool calls with structured schemas
|
||||
- Integrate with keyless APIs for enhanced context
|
||||
|
||||
## Architecture
|
||||
|
||||
```mermaid
|
||||
graph LR
|
||||
A[Medical Agents] --> B[AOP MCP Server<br/>Port 8000]
|
||||
B --> C[Client<br/>Cursor/Python]
|
||||
B --> D[Discovery Tools]
|
||||
B --> E[Tool Execution]
|
||||
|
||||
subgraph "Medical Agents"
|
||||
F[Chief Medical Officer]
|
||||
G[Virologist]
|
||||
H[Internist]
|
||||
I[Medical Coder]
|
||||
J[Diagnostic Synthesizer]
|
||||
end
|
||||
|
||||
A --> F
|
||||
A --> G
|
||||
A --> H
|
||||
A --> I
|
||||
A --> J
|
||||
```
|
||||
|
||||
### Medical Agents
|
||||
- **Chief Medical Officer**: Coordination, diagnosis, triage
|
||||
- **Virologist**: Viral disease analysis and ICD-10 coding
|
||||
- **Internist**: Internal medicine evaluation and HCC tagging
|
||||
- **Medical Coder**: ICD-10 code assignment and compliance
|
||||
- **Diagnostic Synthesizer**: Final report synthesis with confidence levels
|
||||
|
||||
## Files
|
||||
|
||||
| File | Description |
|
||||
|------|-------------|
|
||||
| `medical_aop/server.py` | AOP server exposing medical agents as MCP tools |
|
||||
| `medical_aop/client.py` | Discovery client with real tool execution |
|
||||
| `README.md` | This documentation |
|
||||
|
||||
## Usage
|
||||
|
||||
### 1. Start the AOP Server
|
||||
```bash
|
||||
python -m examples.aop_examples.medical_aop.server
|
||||
```
|
||||
|
||||
### 2. Configure Cursor MCP Integration
|
||||
|
||||
Add to `~/.cursor/mcp.json`:
|
||||
|
||||
```json
|
||||
{
|
||||
"mcpServers": {
|
||||
"Medical AOP": {
|
||||
"type": "http",
|
||||
"url": "http://localhost:8000/mcp"
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 3. Use in Cursor
|
||||
|
||||
Enable "Medical AOP" in Cursor's MCP settings, then:
|
||||
|
||||
#### Discover agents:
|
||||
```
|
||||
Call tool discover_agents with: {}
|
||||
```
|
||||
|
||||
#### Execute medical coding:
|
||||
```
|
||||
Call tool Medical Coder with: {"task":"Patient: 45M, egfr 59 ml/min/1.73; non-African American. Provide ICD-10 suggestions and coding notes.","priority":"normal","include_images":false}
|
||||
```
|
||||
|
||||
#### Review infection control:
|
||||
```
|
||||
Call tool Chief Medical Officer with: {"task":"Review current hospital infection control protocols in light of recent MRSA outbreak in ICU. Provide executive summary, policy adjustment recommendations, and estimated implementation costs.","priority":"high"}
|
||||
```
|
||||
|
||||
### 4. Run Python Client
|
||||
```bash
|
||||
python -m examples.aop_examples.medical_aop.client
|
||||
```
|
||||
|
||||
## Features
|
||||
|
||||
### Structured Schemas
|
||||
- Custom input/output schemas with validation
|
||||
- Priority levels (low/normal/high)
|
||||
- Image processing support
|
||||
- Confidence scoring
|
||||
|
||||
### Discovery Tools
|
||||
| Tool | Description |
|
||||
|------|-------------|
|
||||
| `discover_agents` | List all available agents |
|
||||
| `get_agent_details` | Detailed agent information |
|
||||
| `search_agents` | Keyword-based agent search |
|
||||
| `list_agents` | Simple agent name list |
|
||||
|
||||
### Real-world Integration
|
||||
- Keyless API integration (disease.sh for epidemiology data)
|
||||
- Structured medical coding workflows
|
||||
- Executive-level policy recommendations
|
||||
- Cost estimation and implementation timelines
|
||||
|
||||
## Response Format
|
||||
|
||||
All tools return consistent JSON:
|
||||
```json
|
||||
{
|
||||
"result": "Agent response text",
|
||||
"success": true,
|
||||
"error": null,
|
||||
"confidence": 0.95,
|
||||
"codes": ["N18.3", "Z51.11"]
|
||||
}
|
||||
```
|
||||
|
||||
## Configuration
|
||||
|
||||
### Server Settings
|
||||
| Setting | Value |
|
||||
|---------|-------|
|
||||
| Port | 8000 |
|
||||
| Transport | streamable-http |
|
||||
| Timeouts | 40-50 seconds per agent |
|
||||
| Logging | INFO level with traceback enabled |
|
||||
|
||||
### Agent Metadata
|
||||
Each agent includes:
|
||||
- Tags for categorization
|
||||
- Capabilities for matching
|
||||
- Role classification
|
||||
- Model configuration
|
||||
|
||||
## Best Practices
|
||||
|
||||
1. **Use structured inputs**: Leverage the custom schemas for better results
|
||||
2. **Chain agents**: Pass results between agents for comprehensive analysis
|
||||
3. **Monitor timeouts**: Adjust based on task complexity
|
||||
4. **Validate responses**: Check the `success` field in all responses
|
||||
5. **Use discovery**: Query available agents before hardcoding tool names
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
| Issue | Solution |
|
||||
|-------|----------|
|
||||
| Connection refused | Ensure server is running on port 8000 |
|
||||
| Tool not found | Use `discover_agents` to verify available tools |
|
||||
| Timeout errors | Increase timeout values for complex tasks |
|
||||
| Schema validation | Ensure input matches the defined JSON schema |
|
||||
|
||||
## References
|
||||
|
||||
- [AOP Reference](https://docs.swarms.world/en/latest/swarms/structs/aop/)
|
||||
- [MCP Integration](https://docs.swarms.ai/examples/mcp-integration)
|
||||
- [Protocol Overview](https://docs.swarms.world/en/latest/protocol/overview/)
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,336 @@
|
||||
# AOP Cluster Example
|
||||
|
||||
This example demonstrates how to use AOPCluster to connect to and manage multiple MCP servers running AOP agents.
|
||||
|
||||
## Basic Cluster Setup
|
||||
|
||||
```python
|
||||
import json
|
||||
from swarms.structs.aop import AOPCluster
|
||||
|
||||
# Connect to multiple MCP servers
|
||||
cluster = AOPCluster(
|
||||
urls=[
|
||||
"http://localhost:8000/mcp", # Research and Analysis server
|
||||
"http://localhost:8001/mcp", # Writing and Code server
|
||||
"http://localhost:8002/mcp" # Financial server
|
||||
],
|
||||
transport="streamable-http"
|
||||
)
|
||||
|
||||
# Get all available tools from all servers
|
||||
all_tools = cluster.get_tools(output_type="dict")
|
||||
print(f"Found {len(all_tools)} tools across all servers")
|
||||
|
||||
# Pretty print all tools
|
||||
print(json.dumps(all_tools, indent=2))
|
||||
```
|
||||
|
||||
## Finding Specific Tools
|
||||
|
||||
```python
|
||||
# Find a specific tool by name
|
||||
research_tool = cluster.find_tool_by_server_name("Research-Agent")
|
||||
if research_tool:
|
||||
print("Found Research-Agent tool:")
|
||||
print(json.dumps(research_tool, indent=2))
|
||||
else:
|
||||
print("Research-Agent tool not found")
|
||||
|
||||
# Find multiple tools
|
||||
tool_names = ["Research-Agent", "Analysis-Agent", "Writing-Agent", "Code-Agent"]
|
||||
found_tools = {}
|
||||
|
||||
for tool_name in tool_names:
|
||||
tool = cluster.find_tool_by_server_name(tool_name)
|
||||
if tool:
|
||||
found_tools[tool_name] = tool
|
||||
print(f"✓ Found {tool_name}")
|
||||
else:
|
||||
print(f"✗ {tool_name} not found")
|
||||
|
||||
print(f"Found {len(found_tools)} out of {len(tool_names)} tools")
|
||||
```
|
||||
|
||||
## Tool Discovery and Management
|
||||
|
||||
```python
|
||||
# Get tools in different formats
|
||||
json_tools = cluster.get_tools(output_type="json")
|
||||
dict_tools = cluster.get_tools(output_type="dict")
|
||||
str_tools = cluster.get_tools(output_type="str")
|
||||
|
||||
print(f"JSON format: {len(json_tools)} tools")
|
||||
print(f"Dict format: {len(dict_tools)} tools")
|
||||
print(f"String format: {len(str_tools)} tools")
|
||||
|
||||
# Analyze tool distribution across servers
|
||||
server_tools = {}
|
||||
for tool in dict_tools:
|
||||
server_name = tool.get("server", "unknown")
|
||||
if server_name not in server_tools:
|
||||
server_tools[server_name] = []
|
||||
server_tools[server_name].append(tool.get("function", {}).get("name", "unknown"))
|
||||
|
||||
print("\nTools by server:")
|
||||
for server, tools in server_tools.items():
|
||||
print(f" {server}: {len(tools)} tools - {tools}")
|
||||
```
|
||||
|
||||
## Advanced Cluster Management
|
||||
|
||||
```python
|
||||
class AOPClusterManager:
|
||||
def __init__(self, urls, transport="streamable-http"):
|
||||
self.cluster = AOPCluster(urls, transport)
|
||||
self.tools_cache = {}
|
||||
self.last_update = None
|
||||
|
||||
def refresh_tools(self):
|
||||
"""Refresh the tools cache"""
|
||||
self.tools_cache = {}
|
||||
tools = self.cluster.get_tools(output_type="dict")
|
||||
for tool in tools:
|
||||
tool_name = tool.get("function", {}).get("name")
|
||||
if tool_name:
|
||||
self.tools_cache[tool_name] = tool
|
||||
self.last_update = time.time()
|
||||
return len(self.tools_cache)
|
||||
|
||||
def get_tool(self, tool_name):
|
||||
"""Get a specific tool by name"""
|
||||
if not self.tools_cache or time.time() - self.last_update > 300: # 5 min cache
|
||||
self.refresh_tools()
|
||||
return self.tools_cache.get(tool_name)
|
||||
|
||||
def list_tools_by_category(self):
|
||||
"""Categorize tools by their names"""
|
||||
categories = {
|
||||
"research": [],
|
||||
"analysis": [],
|
||||
"writing": [],
|
||||
"code": [],
|
||||
"financial": [],
|
||||
"other": []
|
||||
}
|
||||
|
||||
for tool_name in self.tools_cache.keys():
|
||||
tool_name_lower = tool_name.lower()
|
||||
if "research" in tool_name_lower:
|
||||
categories["research"].append(tool_name)
|
||||
elif "analysis" in tool_name_lower:
|
||||
categories["analysis"].append(tool_name)
|
||||
elif "writing" in tool_name_lower:
|
||||
categories["writing"].append(tool_name)
|
||||
elif "code" in tool_name_lower:
|
||||
categories["code"].append(tool_name)
|
||||
elif "financial" in tool_name_lower:
|
||||
categories["financial"].append(tool_name)
|
||||
else:
|
||||
categories["other"].append(tool_name)
|
||||
|
||||
return categories
|
||||
|
||||
def get_available_servers(self):
|
||||
"""Get list of available servers"""
|
||||
servers = set()
|
||||
for tool in self.tools_cache.values():
|
||||
server = tool.get("server", "unknown")
|
||||
servers.add(server)
|
||||
return list(servers)
|
||||
|
||||
# Usage example
|
||||
import time
|
||||
|
||||
manager = AOPClusterManager([
|
||||
"http://localhost:8000/mcp",
|
||||
"http://localhost:8001/mcp",
|
||||
"http://localhost:8002/mcp"
|
||||
])
|
||||
|
||||
# Refresh and display tools
|
||||
tool_count = manager.refresh_tools()
|
||||
print(f"Loaded {tool_count} tools")
|
||||
|
||||
# Categorize tools
|
||||
categories = manager.list_tools_by_category()
|
||||
for category, tools in categories.items():
|
||||
if tools:
|
||||
print(f"{category.title()}: {tools}")
|
||||
|
||||
# Get available servers
|
||||
servers = manager.get_available_servers()
|
||||
print(f"Available servers: {servers}")
|
||||
```
|
||||
|
||||
## Error Handling and Resilience
|
||||
|
||||
```python
|
||||
class ResilientAOPCluster:
|
||||
def __init__(self, urls, transport="streamable-http"):
|
||||
self.urls = urls
|
||||
self.transport = transport
|
||||
self.cluster = AOPCluster(urls, transport)
|
||||
self.failed_servers = set()
|
||||
|
||||
def get_tools_with_fallback(self, output_type="dict"):
|
||||
"""Get tools with fallback for failed servers"""
|
||||
try:
|
||||
return self.cluster.get_tools(output_type=output_type)
|
||||
except Exception as e:
|
||||
print(f"Error getting tools: {e}")
|
||||
# Try individual servers
|
||||
all_tools = []
|
||||
for url in self.urls:
|
||||
if url in self.failed_servers:
|
||||
continue
|
||||
try:
|
||||
single_cluster = AOPCluster([url], self.transport)
|
||||
tools = single_cluster.get_tools(output_type=output_type)
|
||||
all_tools.extend(tools)
|
||||
except Exception as server_error:
|
||||
print(f"Server {url} failed: {server_error}")
|
||||
self.failed_servers.add(url)
|
||||
return all_tools
|
||||
|
||||
def find_tool_with_retry(self, tool_name, max_retries=3):
|
||||
"""Find tool with retry logic"""
|
||||
for attempt in range(max_retries):
|
||||
try:
|
||||
return self.cluster.find_tool_by_server_name(tool_name)
|
||||
except Exception as e:
|
||||
print(f"Attempt {attempt + 1} failed: {e}")
|
||||
if attempt < max_retries - 1:
|
||||
time.sleep(2 ** attempt) # Exponential backoff
|
||||
return None
|
||||
|
||||
# Usage
|
||||
resilient_cluster = ResilientAOPCluster([
|
||||
"http://localhost:8000/mcp",
|
||||
"http://localhost:8001/mcp",
|
||||
"http://localhost:8002/mcp"
|
||||
])
|
||||
|
||||
# Get tools with error handling
|
||||
tools = resilient_cluster.get_tools_with_fallback()
|
||||
print(f"Retrieved {len(tools)} tools")
|
||||
|
||||
# Find tool with retry
|
||||
research_tool = resilient_cluster.find_tool_with_retry("Research-Agent")
|
||||
if research_tool:
|
||||
print("Found Research-Agent tool")
|
||||
else:
|
||||
print("Research-Agent tool not found after retries")
|
||||
```
|
||||
|
||||
## Monitoring and Health Checks
|
||||
|
||||
```python
|
||||
class AOPClusterMonitor:
|
||||
def __init__(self, cluster_manager):
|
||||
self.manager = cluster_manager
|
||||
self.health_status = {}
|
||||
|
||||
def check_server_health(self, url):
|
||||
"""Check if a server is healthy"""
|
||||
try:
|
||||
single_cluster = AOPCluster([url], self.manager.cluster.transport)
|
||||
tools = single_cluster.get_tools(output_type="dict")
|
||||
return {
|
||||
"status": "healthy",
|
||||
"tool_count": len(tools),
|
||||
"timestamp": time.time()
|
||||
}
|
||||
except Exception as e:
|
||||
return {
|
||||
"status": "unhealthy",
|
||||
"error": str(e),
|
||||
"timestamp": time.time()
|
||||
}
|
||||
|
||||
def check_all_servers(self):
|
||||
"""Check health of all servers"""
|
||||
for url in self.manager.cluster.urls:
|
||||
health = self.check_server_health(url)
|
||||
self.health_status[url] = health
|
||||
status_icon = "✓" if health["status"] == "healthy" else "✗"
|
||||
print(f"{status_icon} {url}: {health['status']}")
|
||||
if health["status"] == "healthy":
|
||||
print(f" Tools available: {health['tool_count']}")
|
||||
else:
|
||||
print(f" Error: {health['error']}")
|
||||
|
||||
def get_health_summary(self):
|
||||
"""Get summary of server health"""
|
||||
healthy_count = sum(1 for status in self.health_status.values()
|
||||
if status["status"] == "healthy")
|
||||
total_count = len(self.health_status)
|
||||
return {
|
||||
"healthy_servers": healthy_count,
|
||||
"total_servers": total_count,
|
||||
"health_percentage": (healthy_count / total_count) * 100 if total_count > 0 else 0
|
||||
}
|
||||
|
||||
# Usage
|
||||
monitor = AOPClusterMonitor(manager)
|
||||
monitor.check_all_servers()
|
||||
|
||||
summary = monitor.get_health_summary()
|
||||
print(f"Health Summary: {summary['healthy_servers']}/{summary['total_servers']} servers healthy ({summary['health_percentage']:.1f}%)")
|
||||
```
|
||||
|
||||
## Complete Example
|
||||
|
||||
```python
|
||||
import json
|
||||
import time
|
||||
from swarms.structs.aop import AOPCluster
|
||||
|
||||
def main():
|
||||
# Initialize cluster
|
||||
cluster = AOPCluster(
|
||||
urls=[
|
||||
"http://localhost:8000/mcp",
|
||||
"http://localhost:8001/mcp",
|
||||
"http://localhost:8002/mcp"
|
||||
],
|
||||
transport="streamable-http"
|
||||
)
|
||||
|
||||
print("AOP Cluster Management System")
|
||||
print("=" * 40)
|
||||
|
||||
# Get all tools
|
||||
print("\n1. Discovering tools...")
|
||||
tools = cluster.get_tools(output_type="dict")
|
||||
print(f"Found {len(tools)} tools across all servers")
|
||||
|
||||
# List all tool names
|
||||
tool_names = [tool.get("function", {}).get("name") for tool in tools]
|
||||
print(f"Available tools: {tool_names}")
|
||||
|
||||
# Find specific tools
|
||||
print("\n2. Finding specific tools...")
|
||||
target_tools = ["Research-Agent", "Analysis-Agent", "Writing-Agent", "Code-Agent", "Financial-Agent"]
|
||||
|
||||
for tool_name in target_tools:
|
||||
tool = cluster.find_tool_by_server_name(tool_name)
|
||||
if tool:
|
||||
print(f"✓ {tool_name}: Available")
|
||||
else:
|
||||
print(f"✗ {tool_name}: Not found")
|
||||
|
||||
# Display tool details
|
||||
print("\n3. Tool details:")
|
||||
for tool in tools[:3]: # Show first 3 tools
|
||||
print(f"\nTool: {tool.get('function', {}).get('name')}")
|
||||
print(f"Description: {tool.get('function', {}).get('description')}")
|
||||
print(f"Parameters: {list(tool.get('function', {}).get('parameters', {}).get('properties', {}).keys())}")
|
||||
|
||||
print("\nAOP Cluster setup complete!")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
```
|
||||
|
||||
This example demonstrates comprehensive AOP cluster management including tool discovery, error handling, health monitoring, and advanced cluster operations.
|
||||
@ -0,0 +1,164 @@
|
||||
# AOP Server Setup Example
|
||||
|
||||
This example demonstrates how to set up an Agent Orchestration Protocol (AOP) server with multiple specialized agents.
|
||||
|
||||
## Overview
|
||||
|
||||
The AOP server allows you to deploy multiple agents that can be discovered and called by other agents or clients in the network. This example shows how to create a server with specialized agents for different tasks.
|
||||
|
||||
## Code Example
|
||||
|
||||
```python
|
||||
from swarms import Agent
|
||||
from swarms.structs.aop import (
|
||||
AOP,
|
||||
)
|
||||
|
||||
# Create specialized agents
|
||||
research_agent = Agent(
|
||||
agent_name="Research-Agent",
|
||||
agent_description="Expert in research, data collection, and information gathering",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are a research specialist. Your role is to:
|
||||
1. Gather comprehensive information on any given topic
|
||||
2. Analyze data from multiple sources
|
||||
3. Provide well-structured research findings
|
||||
4. Cite sources and maintain accuracy
|
||||
5. Present findings in a clear, organized manner
|
||||
|
||||
Always provide detailed, factual information with proper context.""",
|
||||
)
|
||||
|
||||
analysis_agent = Agent(
|
||||
agent_name="Analysis-Agent",
|
||||
agent_description="Expert in data analysis, pattern recognition, and generating insights",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are an analysis specialist. Your role is to:
|
||||
1. Analyze data and identify patterns
|
||||
2. Generate actionable insights
|
||||
3. Create visualizations and summaries
|
||||
4. Provide statistical analysis
|
||||
5. Make data-driven recommendations
|
||||
|
||||
Focus on extracting meaningful insights from information.""",
|
||||
)
|
||||
|
||||
writing_agent = Agent(
|
||||
agent_name="Writing-Agent",
|
||||
agent_description="Expert in content creation, editing, and communication",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are a writing specialist. Your role is to:
|
||||
1. Create engaging, well-structured content
|
||||
2. Edit and improve existing text
|
||||
3. Adapt tone and style for different audiences
|
||||
4. Ensure clarity and coherence
|
||||
5. Follow best practices in writing
|
||||
|
||||
Always produce high-quality, professional content.""",
|
||||
)
|
||||
|
||||
code_agent = Agent(
|
||||
agent_name="Code-Agent",
|
||||
agent_description="Expert in programming, code review, and software development",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are a coding specialist. Your role is to:
|
||||
1. Write clean, efficient code
|
||||
2. Debug and fix issues
|
||||
3. Review and optimize code
|
||||
4. Explain programming concepts
|
||||
5. Follow best practices and standards
|
||||
|
||||
Always provide working, well-documented code.""",
|
||||
)
|
||||
|
||||
financial_agent = Agent(
|
||||
agent_name="Financial-Agent",
|
||||
agent_description="Expert in financial analysis, market research, and investment insights",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are a financial specialist. Your role is to:
|
||||
1. Analyze financial data and markets
|
||||
2. Provide investment insights
|
||||
3. Assess risk and opportunities
|
||||
4. Create financial reports
|
||||
5. Explain complex financial concepts
|
||||
|
||||
Always provide accurate, well-reasoned financial analysis.""",
|
||||
)
|
||||
|
||||
# Basic usage - individual agent addition
|
||||
deployer = AOP("MyAgentServer", verbose=True, port=5932)
|
||||
|
||||
agents = [
|
||||
research_agent,
|
||||
analysis_agent,
|
||||
writing_agent,
|
||||
code_agent,
|
||||
financial_agent,
|
||||
]
|
||||
|
||||
deployer.add_agents_batch(agents)
|
||||
|
||||
deployer.run()
|
||||
```
|
||||
|
||||
## Key Components
|
||||
|
||||
### 1. Agent Creation
|
||||
|
||||
Each agent is created with:
|
||||
|
||||
- **agent_name**: Unique identifier for the agent
|
||||
- **agent_description**: Brief description of the agent's capabilities
|
||||
- **model_name**: The language model to use
|
||||
- **system_prompt**: Detailed instructions defining the agent's role and behavior
|
||||
|
||||
### 2. AOP Server Setup
|
||||
|
||||
- **Server Name**: "MyAgentServer" - identifies your server
|
||||
- **Port**: 5932 - the port where the server will run
|
||||
- **Verbose**: True - enables detailed logging
|
||||
|
||||
### 3. Agent Registration
|
||||
|
||||
- **add_agents_batch()**: Registers multiple agents at once
|
||||
- Agents become available for discovery and remote calls
|
||||
|
||||
## Usage
|
||||
|
||||
1. **Start the Server**: Run the script to start the AOP server
|
||||
2. **Agent Discovery**: Other agents or clients can discover available agents
|
||||
3. **Remote Calls**: Agents can be called remotely by their names
|
||||
|
||||
## Server Features
|
||||
|
||||
- **Agent Discovery**: Automatically registers agents for network discovery
|
||||
- **Remote Execution**: Agents can be called from other network nodes
|
||||
- **Load Balancing**: Distributes requests across available agents
|
||||
- **Health Monitoring**: Tracks agent status and availability
|
||||
|
||||
## Configuration Options
|
||||
|
||||
- **Port**: Change the port number as needed
|
||||
- **Verbose**: Set to False for reduced logging
|
||||
- **Server Name**: Use a descriptive name for your server
|
||||
|
||||
## Next Steps
|
||||
|
||||
- See [AOP Cluster Example](aop_cluster_example.md) for multi-server setups
|
||||
- Check [AOP Reference](../structs/aop.md) for advanced configuration options
|
||||
- Explore agent communication patterns in the examples directory
|
||||
@ -0,0 +1,817 @@
|
||||
# AOP (Agent Orchestration Protocol)
|
||||
|
||||
The Agent Orchestration Protocol (AOP) is a powerful framework for deploying multiple Swarms agents as tools in an MCP (Model Context Protocol) server. This enables you to create a distributed system where agents can be accessed as individual tools, making them available for use by other systems, applications, or clients.
|
||||
|
||||
AOP provides two main classes:
|
||||
|
||||
- **AOP**: Deploy agents as tools in a single MCP server
|
||||
- **AOPCluster**: Connect to and manage multiple MCP servers
|
||||
|
||||
## Core Classes
|
||||
|
||||
### AgentToolConfig
|
||||
|
||||
Configuration dataclass for converting an agent to an MCP tool.
|
||||
|
||||
| Attribute | Type | Default | Description |
|
||||
|-----------|------|---------|-------------|
|
||||
| `tool_name` | `str` | Required | The name of the tool in the MCP server |
|
||||
| `tool_description` | `str` | Required | Description of what the tool does |
|
||||
| `input_schema` | `Dict[str, Any]` | Required | JSON schema for the tool's input parameters |
|
||||
| `output_schema` | `Dict[str, Any]` | Required | JSON schema for the tool's output |
|
||||
| `timeout` | `int` | `30` | Maximum time to wait for agent execution (seconds) |
|
||||
| `max_retries` | `int` | `3` | Number of retries if agent execution fails |
|
||||
| `verbose` | `bool` | `False` | Enable verbose logging for this tool |
|
||||
| `traceback_enabled` | `bool` | `True` | Enable traceback logging for errors |
|
||||
|
||||
### AOP Class
|
||||
|
||||
Main class for deploying agents as tools in an MCP server.
|
||||
|
||||
#### Constructor Parameters
|
||||
|
||||
| Parameter | Type | Default | Description |
|
||||
|-----------|------|---------|-------------|
|
||||
| `server_name` | `str` | `"AOP Cluster"` | Name for the MCP server |
|
||||
| `description` | `str` | `"A cluster that enables you to deploy multiple agents as tools in an MCP server."` | Server description |
|
||||
| `agents` | `any` | `None` | Optional list of agents to add initially |
|
||||
| `port` | `int` | `8000` | Port for the MCP server |
|
||||
| `transport` | `str` | `"streamable-http"` | Transport type for the MCP server |
|
||||
| `verbose` | `bool` | `False` | Enable verbose logging |
|
||||
| `traceback_enabled` | `bool` | `True` | Enable traceback logging for errors |
|
||||
| `host` | `str` | `"localhost"` | Host to bind the server to |
|
||||
| `log_level` | `str` | `"INFO"` | Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL) |
|
||||
| `*args` | `Any` | - | Additional positional arguments passed to FastMCP |
|
||||
| `**kwargs` | `Any` | - | Additional keyword arguments passed to FastMCP |
|
||||
|
||||
#### Methods
|
||||
|
||||
##### add_agent()
|
||||
|
||||
Add an agent to the MCP server as a tool.
|
||||
|
||||
| Parameter | Type | Default | Description |
|
||||
|-----------|------|---------|-------------|
|
||||
| `agent` | `AgentType` | Required | The swarms Agent instance to deploy |
|
||||
| `tool_name` | `str` | `None` | Name for the tool (defaults to agent.agent_name) |
|
||||
| `tool_description` | `str` | `None` | Description of the tool (defaults to agent.agent_description) |
|
||||
| `input_schema` | `Dict[str, Any]` | `None` | JSON schema for input parameters |
|
||||
| `output_schema` | `Dict[str, Any]` | `None` | JSON schema for output |
|
||||
| `timeout` | `int` | `30` | Maximum execution time in seconds |
|
||||
| `max_retries` | `int` | `3` | Number of retries on failure |
|
||||
| `verbose` | `bool` | `None` | Enable verbose logging for this tool |
|
||||
| `traceback_enabled` | `bool` | `None` | Enable traceback logging for this tool |
|
||||
|
||||
**Returns:** `str` - The tool name that was registered
|
||||
|
||||
##### add_agents_batch()
|
||||
|
||||
Add multiple agents to the MCP server as tools in batch.
|
||||
|
||||
| Parameter | Type | Default | Description |
|
||||
|-----------|------|---------|-------------|
|
||||
| `agents` | `List[Agent]` | Required | List of swarms Agent instances |
|
||||
| `tool_names` | `List[str]` | `None` | Optional list of tool names |
|
||||
| `tool_descriptions` | `List[str]` | `None` | Optional list of tool descriptions |
|
||||
| `input_schemas` | `List[Dict[str, Any]]` | `None` | Optional list of input schemas |
|
||||
| `output_schemas` | `List[Dict[str, Any]]` | `None` | Optional list of output schemas |
|
||||
| `timeouts` | `List[int]` | `None` | Optional list of timeout values |
|
||||
| `max_retries_list` | `List[int]` | `None` | Optional list of max retry values |
|
||||
| `verbose_list` | `List[bool]` | `None` | Optional list of verbose settings |
|
||||
| `traceback_enabled_list` | `List[bool]` | `None` | Optional list of traceback settings |
|
||||
|
||||
**Returns:** `List[str]` - List of tool names that were registered
|
||||
|
||||
##### remove_agent()
|
||||
|
||||
Remove an agent from the MCP server.
|
||||
|
||||
| Parameter | Type | Description |
|
||||
|-----------|------|-------------|
|
||||
| `tool_name` | `str` | Name of the tool to remove |
|
||||
|
||||
**Returns:** `bool` - True if agent was removed, False if not found
|
||||
|
||||
##### list_agents()
|
||||
|
||||
Get a list of all registered agent tool names.
|
||||
|
||||
**Returns:** `List[str]` - List of tool names
|
||||
|
||||
##### get_agent_info()
|
||||
|
||||
Get information about a specific agent tool.
|
||||
|
||||
| Parameter | Type | Description |
|
||||
|-----------|------|-------------|
|
||||
| `tool_name` | `str` | Name of the tool |
|
||||
|
||||
**Returns:** `Dict[str, Any]` - Agent information, or None if not found
|
||||
|
||||
##### start_server()
|
||||
|
||||
Start the MCP server.
|
||||
|
||||
##### run()
|
||||
|
||||
Run the MCP server (alias for start_server).
|
||||
|
||||
##### get_server_info()
|
||||
|
||||
Get information about the MCP server and registered tools.
|
||||
|
||||
**Returns:** `Dict[str, Any]` - Server information
|
||||
|
||||
##### _register_tool()
|
||||
|
||||
Register a single agent as an MCP tool (internal method).
|
||||
|
||||
| Parameter | Type | Description |
|
||||
|-----------|------|-------------|
|
||||
| `tool_name` | `str` | Name of the tool to register |
|
||||
| `agent` | `AgentType` | The agent instance to register |
|
||||
|
||||
##### _execute_agent_with_timeout()
|
||||
|
||||
Execute an agent with a timeout and all run method parameters (internal method).
|
||||
|
||||
| Parameter | Type | Default | Description |
|
||||
|-----------|------|---------|-------------|
|
||||
| `agent` | `AgentType` | Required | The agent to execute |
|
||||
| `task` | `str` | Required | The task to execute |
|
||||
| `timeout` | `int` | Required | Maximum execution time in seconds |
|
||||
| `img` | `str` | `None` | Optional image to be processed by the agent |
|
||||
| `imgs` | `List[str]` | `None` | Optional list of images to be processed by the agent |
|
||||
| `correct_answer` | `str` | `None` | Optional correct answer for validation or comparison |
|
||||
|
||||
**Returns:** `str` - The agent's response
|
||||
|
||||
**Raises:** `TimeoutError` if execution exceeds timeout, `Exception` if agent execution fails
|
||||
|
||||
##### _get_agent_discovery_info()
|
||||
|
||||
Get discovery information for a specific agent (internal method).
|
||||
|
||||
| Parameter | Type | Description |
|
||||
|-----------|------|-------------|
|
||||
| `tool_name` | `str` | Name of the agent tool |
|
||||
|
||||
**Returns:** `Optional[Dict[str, Any]]` - Agent discovery information, or None if not found
|
||||
|
||||
## Discovery Tools
|
||||
|
||||
AOP automatically registers several discovery tools that allow agents to learn about each other and enable dynamic agent discovery within the cluster.
|
||||
|
||||
### discover_agents
|
||||
|
||||
Discover information about agents in the cluster including their name, description, system prompt (truncated to 200 chars), and tags.
|
||||
|
||||
| Parameter | Type | Default | Description |
|
||||
|-----------|------|---------|-------------|
|
||||
| `agent_name` | `str` | `None` | Optional specific agent name to get info for. If None, returns info for all agents. |
|
||||
|
||||
**Returns:** `Dict[str, Any]` - Agent information for discovery
|
||||
|
||||
**Response Format:**
|
||||
|
||||
```json
|
||||
{
|
||||
"success": true,
|
||||
"agents": [
|
||||
{
|
||||
"tool_name": "agent_name",
|
||||
"agent_name": "Agent Name",
|
||||
"description": "Agent description",
|
||||
"short_system_prompt": "Truncated system prompt...",
|
||||
"tags": ["tag1", "tag2"],
|
||||
"capabilities": ["capability1", "capability2"],
|
||||
"role": "worker",
|
||||
"model_name": "model_name",
|
||||
"max_loops": 1,
|
||||
"temperature": 0.5,
|
||||
"max_tokens": 4096
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
### get_agent_details
|
||||
|
||||
Get detailed information about a single agent by name including configuration, capabilities, and metadata.
|
||||
|
||||
| Parameter | Type | Description |
|
||||
|-----------|------|-------------|
|
||||
| `agent_name` | `str` | Name of the agent to get information for. |
|
||||
|
||||
**Returns:** `Dict[str, Any]` - Detailed agent information
|
||||
|
||||
**Response Format:**
|
||||
|
||||
```json
|
||||
{
|
||||
"success": true,
|
||||
"agent_info": {
|
||||
"tool_name": "agent_name",
|
||||
"agent_name": "Agent Name",
|
||||
"agent_description": "Agent description",
|
||||
"model_name": "model_name",
|
||||
"max_loops": 1,
|
||||
"tool_description": "Tool description",
|
||||
"timeout": 30,
|
||||
"max_retries": 3,
|
||||
"verbose": false,
|
||||
"traceback_enabled": true
|
||||
},
|
||||
"discovery_info": {
|
||||
"tool_name": "agent_name",
|
||||
"agent_name": "Agent Name",
|
||||
"description": "Agent description",
|
||||
"short_system_prompt": "Truncated system prompt...",
|
||||
"tags": ["tag1", "tag2"],
|
||||
"capabilities": ["capability1", "capability2"],
|
||||
"role": "worker",
|
||||
"model_name": "model_name",
|
||||
"max_loops": 1,
|
||||
"temperature": 0.5,
|
||||
"max_tokens": 4096
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### get_agents_info
|
||||
|
||||
Get detailed information about multiple agents by providing a list of agent names.
|
||||
|
||||
| Parameter | Type | Description |
|
||||
|-----------|------|-------------|
|
||||
| `agent_names` | `List[str]` | List of agent names to get information for. |
|
||||
|
||||
**Returns:** `Dict[str, Any]` - Detailed information for all requested agents
|
||||
|
||||
**Response Format:**
|
||||
|
||||
```json
|
||||
{
|
||||
"success": true,
|
||||
"agents_info": [
|
||||
{
|
||||
"agent_name": "agent_name",
|
||||
"agent_info": { /* detailed agent info */ },
|
||||
"discovery_info": { /* discovery info */ }
|
||||
}
|
||||
],
|
||||
"not_found": ["missing_agent"],
|
||||
"total_found": 1,
|
||||
"total_requested": 2
|
||||
}
|
||||
```
|
||||
|
||||
### list_agents
|
||||
|
||||
Get a simple list of all available agent names in the cluster.
|
||||
|
||||
**Returns:** `Dict[str, Any]` - List of agent names
|
||||
|
||||
**Response Format:**
|
||||
|
||||
```json
|
||||
{
|
||||
"success": true,
|
||||
"agent_names": ["agent1", "agent2", "agent3"],
|
||||
"total_count": 3
|
||||
}
|
||||
```
|
||||
|
||||
### search_agents
|
||||
|
||||
Search for agents by name, description, tags, or capabilities using keyword matching.
|
||||
|
||||
| Parameter | Type | Default | Description |
|
||||
|-----------|------|---------|-------------|
|
||||
| `query` | `str` | Required | Search query string |
|
||||
| `search_fields` | `List[str]` | `["name", "description", "tags", "capabilities"]` | Optional list of fields to search in. If None, searches all fields. |
|
||||
|
||||
**Returns:** `Dict[str, Any]` - Matching agents
|
||||
|
||||
**Response Format:**
|
||||
|
||||
```json
|
||||
{
|
||||
"success": true,
|
||||
"matching_agents": [
|
||||
{
|
||||
"tool_name": "agent_name",
|
||||
"agent_name": "Agent Name",
|
||||
"description": "Agent description",
|
||||
"short_system_prompt": "Truncated system prompt...",
|
||||
"tags": ["tag1", "tag2"],
|
||||
"capabilities": ["capability1", "capability2"],
|
||||
"role": "worker",
|
||||
"model_name": "model_name",
|
||||
"max_loops": 1,
|
||||
"temperature": 0.5,
|
||||
"max_tokens": 4096
|
||||
}
|
||||
],
|
||||
"total_matches": 1,
|
||||
"query": "search_term",
|
||||
"search_fields": ["name", "description", "tags", "capabilities"]
|
||||
}
|
||||
```
|
||||
|
||||
### AOPCluster Class
|
||||
|
||||
Class for connecting to and managing multiple MCP servers.
|
||||
|
||||
#### AOPCluster Constructor Parameters
|
||||
|
||||
| Parameter | Type | Default | Description |
|
||||
|-----------|------|---------|-------------|
|
||||
| `urls` | `List[str]` | Required | List of MCP server URLs to connect to |
|
||||
| `transport` | `str` | `"streamable-http"` | Transport type for connections |
|
||||
|
||||
#### AOPCluster Methods
|
||||
|
||||
##### get_tools()
|
||||
|
||||
Get tools from all connected MCP servers.
|
||||
|
||||
| Parameter | Type | Default | Description |
|
||||
|-----------|------|---------|-------------|
|
||||
| `output_type` | `Literal["json", "dict", "str"]` | `"dict"` | Format of the output |
|
||||
|
||||
**Returns:** `List[Dict[str, Any]]` - List of available tools
|
||||
|
||||
##### find_tool_by_server_name()
|
||||
|
||||
Find a tool by its server name (function name).
|
||||
|
||||
| Parameter | Type | Description |
|
||||
|-----------|------|-------------|
|
||||
| `server_name` | `str` | The name of the tool/function to find |
|
||||
|
||||
**Returns:** `Dict[str, Any]` - Tool information, or None if not found
|
||||
|
||||
## Tool Parameters
|
||||
|
||||
All agent tools accept the following parameters:
|
||||
|
||||
| Parameter | Type | Required | Description |
|
||||
|-----------|------|----------|-------------|
|
||||
| `task` | `str` | Yes | The main task or prompt to execute |
|
||||
| `img` | `str` | No | Single image to be processed by the agent |
|
||||
| `imgs` | `List[str]` | No | Multiple images to be processed by the agent |
|
||||
| `correct_answer` | `str` | No | Correct answer for validation or comparison |
|
||||
|
||||
## Output Format
|
||||
|
||||
All agent tools return a standardized response format:
|
||||
|
||||
```json
|
||||
{
|
||||
"result": "string", // The agent's response to the task
|
||||
"success": "boolean", // Whether the task was executed successfully
|
||||
"error": "string" // Error message if execution failed (null if successful)
|
||||
}
|
||||
```
|
||||
|
||||
## Complete Examples
|
||||
|
||||
### Basic Server Setup
|
||||
|
||||
```python
|
||||
from swarms import Agent
|
||||
from swarms.structs.aop import AOP
|
||||
|
||||
# Create specialized agents
|
||||
research_agent = Agent(
|
||||
agent_name="Research-Agent",
|
||||
agent_description="Expert in research, data collection, and information gathering",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are a research specialist. Your role is to:
|
||||
1. Gather comprehensive information on any given topic
|
||||
2. Analyze data from multiple sources
|
||||
3. Provide well-structured research findings
|
||||
4. Cite sources and maintain accuracy
|
||||
5. Present findings in a clear, organized manner
|
||||
|
||||
Always provide detailed, factual information with proper context.""",
|
||||
)
|
||||
|
||||
analysis_agent = Agent(
|
||||
agent_name="Analysis-Agent",
|
||||
agent_description="Expert in data analysis, pattern recognition, and generating insights",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are an analysis specialist. Your role is to:
|
||||
1. Analyze data and identify patterns
|
||||
2. Generate actionable insights
|
||||
3. Create visualizations and summaries
|
||||
4. Provide statistical analysis
|
||||
5. Make data-driven recommendations
|
||||
|
||||
Focus on extracting meaningful insights from information.""",
|
||||
)
|
||||
|
||||
# Create AOP instance
|
||||
deployer = AOP(
|
||||
server_name="MyAgentServer",
|
||||
port=8000,
|
||||
verbose=True,
|
||||
log_level="INFO"
|
||||
)
|
||||
|
||||
# Add agents individually
|
||||
deployer.add_agent(research_agent)
|
||||
deployer.add_agent(analysis_agent)
|
||||
|
||||
# Start the server
|
||||
deployer.run()
|
||||
```
|
||||
|
||||
### Batch Agent Addition
|
||||
|
||||
```python
|
||||
from swarms import Agent
|
||||
from swarms.structs.aop import AOP
|
||||
|
||||
# Create multiple agents
|
||||
agents = [
|
||||
Agent(
|
||||
agent_name="Research-Agent",
|
||||
agent_description="Expert in research and data collection",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
),
|
||||
Agent(
|
||||
agent_name="Writing-Agent",
|
||||
agent_description="Expert in content creation and editing",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
),
|
||||
Agent(
|
||||
agent_name="Code-Agent",
|
||||
agent_description="Expert in programming and code review",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
),
|
||||
]
|
||||
|
||||
# Create AOP instance
|
||||
deployer = AOP("MyAgentServer", verbose=True)
|
||||
|
||||
# Add all agents at once
|
||||
tool_names = deployer.add_agents_batch(agents)
|
||||
|
||||
print(f"Added {len(tool_names)} agents: {tool_names}")
|
||||
|
||||
# Start the server
|
||||
deployer.run()
|
||||
```
|
||||
|
||||
### Advanced Configuration with Tags and Capabilities
|
||||
|
||||
```python
|
||||
from swarms import Agent
|
||||
from swarms.structs.aop import AOP
|
||||
|
||||
# Create agent with custom configuration, tags, and capabilities
|
||||
research_agent = Agent(
|
||||
agent_name="Research-Agent",
|
||||
agent_description="Expert in research and data collection",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
# Add tags and capabilities for better discovery
|
||||
tags=["research", "data-collection", "analysis"],
|
||||
capabilities=["web-search", "data-gathering", "report-generation"],
|
||||
role="researcher"
|
||||
)
|
||||
|
||||
# Create AOP with custom settings
|
||||
deployer = AOP(
|
||||
server_name="AdvancedAgentServer",
|
||||
port=8001,
|
||||
host="0.0.0.0", # Allow external connections
|
||||
verbose=True,
|
||||
traceback_enabled=True,
|
||||
log_level="DEBUG"
|
||||
)
|
||||
|
||||
# Add agent with custom tool configuration
|
||||
deployer.add_agent(
|
||||
agent=research_agent,
|
||||
tool_name="custom_research_tool",
|
||||
tool_description="Custom research tool with extended capabilities",
|
||||
timeout=60, # 60 second timeout
|
||||
max_retries=5, # 5 retries
|
||||
verbose=True,
|
||||
traceback_enabled=True
|
||||
)
|
||||
|
||||
# Add custom input/output schemas
|
||||
custom_input_schema = {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"task": {
|
||||
"type": "string",
|
||||
"description": "The research task to execute"
|
||||
},
|
||||
"sources": {
|
||||
"type": "array",
|
||||
"items": {"type": "string"},
|
||||
"description": "Specific sources to research"
|
||||
},
|
||||
"depth": {
|
||||
"type": "string",
|
||||
"enum": ["shallow", "medium", "deep"],
|
||||
"description": "Research depth level"
|
||||
}
|
||||
},
|
||||
"required": ["task"]
|
||||
}
|
||||
|
||||
custom_output_schema = {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"result": {"type": "string"},
|
||||
"sources": {"type": "array", "items": {"type": "string"}},
|
||||
"confidence": {"type": "number", "minimum": 0, "maximum": 1},
|
||||
"success": {"type": "boolean"},
|
||||
"error": {"type": "string"}
|
||||
},
|
||||
"required": ["result", "success"]
|
||||
}
|
||||
|
||||
# Add another agent with custom schemas
|
||||
analysis_agent = Agent(
|
||||
agent_name="Analysis-Agent",
|
||||
agent_description="Expert in data analysis",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
)
|
||||
|
||||
deployer.add_agent(
|
||||
agent=analysis_agent,
|
||||
tool_name="custom_analysis_tool",
|
||||
tool_description="Custom analysis tool",
|
||||
input_schema=custom_input_schema,
|
||||
output_schema=custom_output_schema,
|
||||
timeout=45,
|
||||
max_retries=3
|
||||
)
|
||||
|
||||
# List all registered agents
|
||||
print("Registered agents:", deployer.list_agents())
|
||||
|
||||
# Get server information
|
||||
server_info = deployer.get_server_info()
|
||||
print("Server info:", server_info)
|
||||
|
||||
# Start the server
|
||||
deployer.run()
|
||||
```
|
||||
|
||||
### AOPCluster Usage
|
||||
|
||||
```python
|
||||
import json
|
||||
from swarms.structs.aop import AOPCluster
|
||||
|
||||
# Connect to multiple MCP servers
|
||||
cluster = AOPCluster(
|
||||
urls=[
|
||||
"http://localhost:8000/mcp",
|
||||
"http://localhost:8001/mcp",
|
||||
"http://localhost:8002/mcp"
|
||||
],
|
||||
transport="streamable-http"
|
||||
)
|
||||
|
||||
# Get all available tools from all servers
|
||||
all_tools = cluster.get_tools(output_type="dict")
|
||||
print(f"Found {len(all_tools)} tools across all servers")
|
||||
|
||||
# Pretty print all tools
|
||||
print(json.dumps(all_tools, indent=2))
|
||||
|
||||
# Find a specific tool by name
|
||||
research_tool = cluster.find_tool_by_server_name("Research-Agent")
|
||||
if research_tool:
|
||||
print("Found Research-Agent tool:")
|
||||
print(json.dumps(research_tool, indent=2))
|
||||
else:
|
||||
print("Research-Agent tool not found")
|
||||
```
|
||||
|
||||
### Discovery Tools Examples
|
||||
|
||||
The AOP server automatically provides discovery tools that allow agents to learn about each other. Here are examples of how to use these tools:
|
||||
|
||||
```python
|
||||
# Example discovery tool calls (these would be made by MCP clients)
|
||||
|
||||
# Discover all agents in the cluster
|
||||
all_agents = discover_agents()
|
||||
print(f"Found {len(all_agents['agents'])} agents in the cluster")
|
||||
|
||||
# Discover a specific agent
|
||||
research_agent_info = discover_agents(agent_name="Research-Agent")
|
||||
if research_agent_info['success']:
|
||||
agent = research_agent_info['agents'][0]
|
||||
print(f"Agent: {agent['agent_name']}")
|
||||
print(f"Description: {agent['description']}")
|
||||
print(f"Tags: {agent['tags']}")
|
||||
print(f"Capabilities: {agent['capabilities']}")
|
||||
|
||||
# Get detailed information about a specific agent
|
||||
agent_details = get_agent_details(agent_name="Research-Agent")
|
||||
if agent_details['success']:
|
||||
print("Agent Info:", agent_details['agent_info'])
|
||||
print("Discovery Info:", agent_details['discovery_info'])
|
||||
|
||||
# Get information about multiple agents
|
||||
multiple_agents = get_agents_info(agent_names=["Research-Agent", "Analysis-Agent"])
|
||||
print(f"Found {multiple_agents['total_found']} out of {multiple_agents['total_requested']} agents")
|
||||
print("Not found:", multiple_agents['not_found'])
|
||||
|
||||
# List all available agents
|
||||
agent_list = list_agents()
|
||||
print(f"Available agents: {agent_list['agent_names']}")
|
||||
|
||||
# Search for agents by keyword
|
||||
search_results = search_agents(query="research")
|
||||
print(f"Found {search_results['total_matches']} agents matching 'research'")
|
||||
|
||||
# Search in specific fields only
|
||||
tag_search = search_agents(
|
||||
query="data",
|
||||
search_fields=["tags", "capabilities"]
|
||||
)
|
||||
print(f"Found {tag_search['total_matches']} agents with 'data' in tags or capabilities")
|
||||
```
|
||||
|
||||
### Dynamic Agent Discovery Example
|
||||
|
||||
Here's a practical example of how agents can use discovery tools to find and collaborate with other agents:
|
||||
|
||||
```python
|
||||
from swarms import Agent
|
||||
from swarms.structs.aop import AOP
|
||||
|
||||
# Create a coordinator agent that can discover and use other agents
|
||||
coordinator = Agent(
|
||||
agent_name="Coordinator-Agent",
|
||||
agent_description="Coordinates tasks between different specialized agents",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
tags=["coordination", "orchestration", "management"],
|
||||
capabilities=["agent-discovery", "task-distribution", "workflow-management"],
|
||||
role="coordinator"
|
||||
)
|
||||
|
||||
# Create specialized agents
|
||||
research_agent = Agent(
|
||||
agent_name="Research-Agent",
|
||||
agent_description="Expert in research and data collection",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
tags=["research", "data-collection", "analysis"],
|
||||
capabilities=["web-search", "data-gathering", "report-generation"],
|
||||
role="researcher"
|
||||
)
|
||||
|
||||
analysis_agent = Agent(
|
||||
agent_name="Analysis-Agent",
|
||||
agent_description="Expert in data analysis and insights",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
tags=["analysis", "data-processing", "insights"],
|
||||
capabilities=["statistical-analysis", "pattern-recognition", "visualization"],
|
||||
role="analyst"
|
||||
)
|
||||
|
||||
# Create AOP server
|
||||
deployer = AOP(
|
||||
server_name="DynamicAgentCluster",
|
||||
port=8000,
|
||||
verbose=True
|
||||
)
|
||||
|
||||
# Add all agents
|
||||
deployer.add_agent(coordinator)
|
||||
deployer.add_agent(research_agent)
|
||||
deployer.add_agent(analysis_agent)
|
||||
|
||||
# The coordinator can now discover other agents and use them
|
||||
# This would be done through MCP tool calls in practice
|
||||
def coordinate_research_task(task_description):
|
||||
"""
|
||||
Example of how the coordinator might use discovery tools
|
||||
"""
|
||||
# 1. Discover available research agents
|
||||
research_agents = discover_agents()
|
||||
research_agents = [a for a in research_agents['agents'] if 'research' in a['tags']]
|
||||
|
||||
# 2. Get detailed info about the best research agent
|
||||
if research_agents:
|
||||
best_agent = research_agents[0]
|
||||
agent_details = get_agent_details(agent_name=best_agent['agent_name'])
|
||||
|
||||
# 3. Use the research agent for the task
|
||||
research_result = research_agent.run(task=task_description)
|
||||
|
||||
# 4. Find analysis agents for processing the research
|
||||
analysis_agents = search_agents(query="analysis", search_fields=["tags"])
|
||||
if analysis_agents['matching_agents']:
|
||||
analysis_agent_name = analysis_agents['matching_agents'][0]['agent_name']
|
||||
analysis_result = analysis_agent.run(task=f"Analyze this research: {research_result}")
|
||||
|
||||
return {
|
||||
"research_result": research_result,
|
||||
"analysis_result": analysis_result,
|
||||
"agents_used": [best_agent['agent_name'], analysis_agent_name]
|
||||
}
|
||||
|
||||
return {"error": "No suitable agents found"}
|
||||
|
||||
# Start the server
|
||||
deployer.run()
|
||||
```
|
||||
|
||||
### Tool Execution Examples
|
||||
|
||||
Once your AOP server is running, you can call the tools using MCP clients. Here are examples of how the tools would be called:
|
||||
|
||||
```python
|
||||
# Example tool calls (these would be made by MCP clients)
|
||||
|
||||
# Basic task execution
|
||||
result = research_tool(task="Research the latest AI trends in 2024")
|
||||
|
||||
# Task with single image
|
||||
result = analysis_tool(
|
||||
task="Analyze this chart and provide insights",
|
||||
img="path/to/chart.png"
|
||||
)
|
||||
|
||||
# Task with multiple images
|
||||
result = writing_tool(
|
||||
task="Write a comprehensive report based on these images",
|
||||
imgs=["image1.jpg", "image2.jpg", "image3.jpg"]
|
||||
)
|
||||
|
||||
# Task with validation
|
||||
result = code_tool(
|
||||
task="Debug this Python function",
|
||||
correct_answer="Expected output: Hello World"
|
||||
)
|
||||
|
||||
# The response format for all calls:
|
||||
# {
|
||||
# "result": "The agent's response...",
|
||||
# "success": true,
|
||||
# "error": null
|
||||
# }
|
||||
```
|
||||
|
||||
## Error Handling
|
||||
|
||||
AOP provides comprehensive error handling:
|
||||
|
||||
- **Timeout Protection**: Each agent has configurable timeout limits
|
||||
- **Retry Logic**: Automatic retries on failure with configurable retry counts
|
||||
- **Detailed Logging**: Verbose logging with traceback information
|
||||
- **Graceful Degradation**: Failed agents don't crash the entire server
|
||||
|
||||
## Best Practices
|
||||
|
||||
| Best Practice | Description |
|
||||
|------------------------------|--------------------------------------------------------------------|
|
||||
| **Use Descriptive Names** | Choose clear, descriptive tool names |
|
||||
| **Set Appropriate Timeouts** | Configure timeouts based on expected task complexity |
|
||||
| **Enable Logging** | Use verbose logging for debugging and monitoring |
|
||||
| **Handle Errors** | Always check the `success` field in tool responses |
|
||||
| **Resource Management** | Monitor server resources when running multiple agents |
|
||||
| **Security** | Use appropriate host/port settings for your deployment environment |
|
||||
| **Use Tags and Capabilities** | Add meaningful tags and capabilities to agents for better discovery |
|
||||
| **Define Agent Roles** | Use the `role` attribute to categorize agents (coordinator, worker, etc.) |
|
||||
| **Leverage Discovery Tools** | Use built-in discovery tools for dynamic agent collaboration |
|
||||
| **Design for Scalability** | Plan for adding/removing agents dynamically using discovery tools |
|
||||
|
||||
## Integration with Other Systems
|
||||
|
||||
AOP servers can be integrated with:
|
||||
|
||||
| Integration Target | Description |
|
||||
|------------------------|--------------------------------------------------|
|
||||
| **MCP Clients** | Any MCP-compatible client |
|
||||
| **Web Applications** | Via HTTP transport |
|
||||
| **Other Swarms** | As part of larger multi-agent systems |
|
||||
| **External APIs** | Through MCP protocol |
|
||||
|
||||
This makes AOP a powerful tool for creating distributed, scalable agent systems that can be easily integrated into existing workflows and applications.
|
||||
@ -1,200 +0,0 @@
|
||||
# Agent Builder
|
||||
|
||||
The Agent Builder is a powerful class that automatically builds and manages swarms of AI agents. It provides a flexible and extensible framework for creating, coordinating, and executing multiple AI agents working together to accomplish complex tasks.
|
||||
|
||||
## Overview
|
||||
|
||||
The Agent Builder uses a boss agent to delegate work and create new specialized agents as needed. It's designed to be production-ready with robust error handling, logging, and configuration options.
|
||||
|
||||
## Architecture
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
A[Agent Builder] --> B[Configuration]
|
||||
A --> C[Agent Creation]
|
||||
A --> D[Task Execution]
|
||||
|
||||
B --> B1[Name]
|
||||
B --> B2[Description]
|
||||
B --> B3[Model Settings]
|
||||
|
||||
C --> C1[Agent Pool]
|
||||
C --> C2[Agent Registry]
|
||||
C --> C3[Agent Configuration]
|
||||
|
||||
D --> D1[Task Distribution]
|
||||
D --> D2[Result Collection]
|
||||
D --> D3[Error Handling]
|
||||
|
||||
C1 --> E[Specialized Agents]
|
||||
C2 --> E
|
||||
C3 --> E
|
||||
|
||||
E --> F[Task Execution]
|
||||
F --> G[Results]
|
||||
```
|
||||
|
||||
## Class Structure
|
||||
|
||||
### AgentsBuilder Class
|
||||
|
||||
| Parameter | Type | Default | Description |
|
||||
|-----------|------|---------|-------------|
|
||||
| name | str | "swarm-creator-01" | The name of the swarm |
|
||||
| description | str | "This is a swarm that creates swarms" | A description of the swarm's purpose |
|
||||
| verbose | bool | True | Whether to output detailed logs |
|
||||
| max_loops | int | 1 | Maximum number of execution loops |
|
||||
| model_name | str | "gpt-4o" | The model to use for agent creation |
|
||||
| return_dictionary | bool | True | Whether to return results as a dictionary |
|
||||
| system_prompt | str | BOSS_SYSTEM_PROMPT | The system prompt for the boss agent |
|
||||
|
||||
### Methods
|
||||
|
||||
| Method | Description | Parameters | Returns |
|
||||
|--------|-------------|------------|---------|
|
||||
| run | Run the swarm on a given task | task: str, image_url: str = None, *args, **kwargs | Tuple[List[Agent], int] |
|
||||
| _create_agents | Create necessary agents for a task | task: str, *args, **kwargs | List[Agent] |
|
||||
| build_agent | Build a single agent with specifications | agent_name: str, agent_description: str, agent_system_prompt: str, max_loops: int = 1, model_name: str = "gpt-4o", dynamic_temperature_enabled: bool = True, auto_generate_prompt: bool = False, role: str = "worker", max_tokens: int = 8192, temperature: float = 0.5 | Agent |
|
||||
|
||||
## Enterprise Use Cases
|
||||
|
||||
### 1. Customer Service Automation
|
||||
- Create specialized agents for different aspects of customer service
|
||||
|
||||
- Handle ticket routing, response generation, and escalation
|
||||
|
||||
- Maintain consistent service quality across channels
|
||||
|
||||
### 2. Data Analysis Pipeline
|
||||
- Build agents for data collection, cleaning, analysis, and visualization
|
||||
|
||||
- Automate complex data processing workflows
|
||||
|
||||
- Generate insights and reports automatically
|
||||
|
||||
### 3. Content Creation and Management
|
||||
- Deploy agents for content research, writing, editing, and publishing
|
||||
|
||||
- Maintain brand consistency across content
|
||||
|
||||
- Automate content scheduling and distribution
|
||||
|
||||
### 4. Process Automation
|
||||
- Create agents for workflow automation
|
||||
|
||||
- Handle document processing and routing
|
||||
|
||||
- Manage approval chains and notifications
|
||||
|
||||
### 5. Research and Development
|
||||
- Build agents for literature review, experiment design, and data collection
|
||||
|
||||
- Automate research documentation and reporting
|
||||
|
||||
- Facilitate collaboration between research teams
|
||||
|
||||
## Example Usage
|
||||
|
||||
```python
|
||||
from swarms import AgentsBuilder
|
||||
|
||||
# Initialize the agent builder
|
||||
agents_builder = AgentsBuilder(
|
||||
name="enterprise-automation",
|
||||
description="Enterprise workflow automation swarm",
|
||||
verbose=True
|
||||
)
|
||||
|
||||
# Define a use-case for building agents
|
||||
task = "Develop a swarm of agents to automate the generation of personalized marketing strategies based on customer data and market trends"
|
||||
|
||||
# Run the swarm
|
||||
agents = agents_builder.run(task)
|
||||
|
||||
# Access results
|
||||
print(agents)
|
||||
```
|
||||
|
||||
## Best Practices
|
||||
|
||||
1. **Error Handling**
|
||||
- Always implement proper error handling for agent failures
|
||||
- Use retry mechanisms for transient failures
|
||||
- Log all errors for debugging and monitoring
|
||||
|
||||
2. **Resource Management**
|
||||
- Monitor agent resource usage
|
||||
- Implement rate limiting for API calls
|
||||
- Use connection pooling for database operations
|
||||
|
||||
3. **Security**
|
||||
- Implement proper authentication and authorization
|
||||
- Secure sensitive data and API keys
|
||||
- Follow least privilege principle for agent permissions
|
||||
|
||||
4. **Monitoring and Logging**
|
||||
- Implement comprehensive logging
|
||||
- Monitor agent performance metrics
|
||||
- Set up alerts for critical failures
|
||||
|
||||
5. **Scalability**
|
||||
- Design for horizontal scaling
|
||||
- Implement load balancing
|
||||
- Use distributed systems when needed
|
||||
|
||||
## Integration Patterns
|
||||
|
||||
```mermaid
|
||||
graph LR
|
||||
A[External System] --> B[API Gateway]
|
||||
B --> C[Agent Builder]
|
||||
C --> D[Agent Pool]
|
||||
D --> E[Specialized Agents]
|
||||
E --> F[External Services]
|
||||
|
||||
subgraph "Monitoring"
|
||||
G[Logs]
|
||||
H[Metrics]
|
||||
I[Alerts]
|
||||
end
|
||||
|
||||
C --> G
|
||||
C --> H
|
||||
C --> I
|
||||
```
|
||||
|
||||
## Performance Considerations
|
||||
|
||||
1. **Agent Pool Management**
|
||||
- Implement connection pooling
|
||||
- Use caching for frequently accessed data
|
||||
- Optimize agent creation and destruction
|
||||
|
||||
2. **Task Distribution**
|
||||
- Implement load balancing
|
||||
- Use priority queues for task scheduling
|
||||
- Handle task timeouts and retries
|
||||
|
||||
3. **Resource Optimization**
|
||||
- Monitor memory usage
|
||||
- Implement garbage collection
|
||||
- Use efficient data structures
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
Common issues and solutions:
|
||||
|
||||
1. **Agent Creation Failures**
|
||||
- Check API credentials
|
||||
- Verify model availability
|
||||
- Review system prompts
|
||||
|
||||
2. **Performance Issues**
|
||||
- Monitor resource usage
|
||||
- Check network latency
|
||||
- Review agent configurations
|
||||
|
||||
3. **Integration Problems**
|
||||
- Verify API endpoints
|
||||
- Check authentication
|
||||
- Review data formats
|
||||
@ -0,0 +1,47 @@
|
||||
import json
|
||||
import asyncio
|
||||
|
||||
from swarms.structs.aop import AOPCluster
|
||||
from swarms.tools.mcp_client_tools import execute_tool_call_simple
|
||||
|
||||
|
||||
async def discover_agents_example():
|
||||
"""
|
||||
Discover all agents using the AOPCluster and print the result.
|
||||
"""
|
||||
aop_cluster = AOPCluster(
|
||||
urls=["http://localhost:5932/mcp"],
|
||||
transport="streamable-http",
|
||||
)
|
||||
tool = aop_cluster.find_tool_by_server_name("discover_agents")
|
||||
if not tool:
|
||||
print("discover_agents tool not found.")
|
||||
return None
|
||||
|
||||
tool_call_request = {
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": "discover_agents",
|
||||
"arguments": "{}",
|
||||
},
|
||||
}
|
||||
|
||||
result = await execute_tool_call_simple(
|
||||
response=tool_call_request,
|
||||
server_path="http://localhost:5932/mcp",
|
||||
output_type="dict",
|
||||
verbose=False,
|
||||
)
|
||||
print(json.dumps(result, indent=2))
|
||||
return result
|
||||
|
||||
|
||||
def main():
|
||||
"""
|
||||
Run the discover_agents_example coroutine.
|
||||
"""
|
||||
asyncio.run(discover_agents_example())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -0,0 +1,149 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Example demonstrating the AOP queue system for agent execution.
|
||||
|
||||
This example shows how to use the new queue-based execution system
|
||||
in the AOP framework for improved performance and reliability.
|
||||
"""
|
||||
|
||||
import time
|
||||
from swarms import Agent
|
||||
from swarms.structs.aop import AOP
|
||||
|
||||
|
||||
def main():
|
||||
"""Demonstrate AOP queue functionality."""
|
||||
|
||||
# Create some sample agents
|
||||
agent1 = Agent(
|
||||
agent_name="Research Agent",
|
||||
agent_description="Specialized in research tasks",
|
||||
model_name="gpt-4",
|
||||
max_loops=1,
|
||||
)
|
||||
|
||||
agent2 = Agent(
|
||||
agent_name="Writing Agent",
|
||||
agent_description="Specialized in writing tasks",
|
||||
model_name="gpt-4",
|
||||
max_loops=1,
|
||||
)
|
||||
|
||||
# Create AOP with queue enabled
|
||||
aop = AOP(
|
||||
server_name="Queue Demo Cluster",
|
||||
description="A demonstration of queue-based agent execution",
|
||||
queue_enabled=True,
|
||||
max_workers_per_agent=2, # 2 workers per agent
|
||||
max_queue_size_per_agent=100, # Max 100 tasks per queue
|
||||
processing_timeout=60, # 60 second timeout
|
||||
retry_delay=2.0, # 2 second delay between retries
|
||||
verbose=True,
|
||||
)
|
||||
|
||||
# Add agents to the cluster
|
||||
print("Adding agents to cluster...")
|
||||
aop.add_agent(agent1, tool_name="researcher")
|
||||
aop.add_agent(agent2, tool_name="writer")
|
||||
|
||||
# Get initial queue stats
|
||||
print("\nInitial queue stats:")
|
||||
stats = aop.get_queue_stats()
|
||||
print(f"Stats: {stats}")
|
||||
|
||||
# Add some tasks to the queues
|
||||
print("\nAdding tasks to queues...")
|
||||
|
||||
# Add high priority research task
|
||||
research_task_id = aop.task_queues["researcher"].add_task(
|
||||
task="Research the latest developments in quantum computing",
|
||||
priority=10, # High priority
|
||||
max_retries=2,
|
||||
)
|
||||
print(f"Added research task: {research_task_id}")
|
||||
|
||||
# Add medium priority writing task
|
||||
writing_task_id = aop.task_queues["writer"].add_task(
|
||||
task="Write a summary of AI trends in 2024",
|
||||
priority=5, # Medium priority
|
||||
max_retries=3,
|
||||
)
|
||||
print(f"Added writing task: {writing_task_id}")
|
||||
|
||||
# Add multiple low priority tasks
|
||||
for i in range(3):
|
||||
task_id = aop.task_queues["researcher"].add_task(
|
||||
task=f"Research task {i+1}: Analyze market trends",
|
||||
priority=1, # Low priority
|
||||
max_retries=1,
|
||||
)
|
||||
print(f"Added research task {i+1}: {task_id}")
|
||||
|
||||
# Get updated queue stats
|
||||
print("\nUpdated queue stats:")
|
||||
stats = aop.get_queue_stats()
|
||||
print(f"Stats: {stats}")
|
||||
|
||||
# Monitor task progress
|
||||
print("\nMonitoring task progress...")
|
||||
for _ in range(10): # Monitor for 10 iterations
|
||||
time.sleep(1)
|
||||
|
||||
# Check research task status
|
||||
research_status = aop.get_task_status(
|
||||
"researcher", research_task_id
|
||||
)
|
||||
print(
|
||||
f"Research task status: {research_status['task']['status'] if research_status['success'] else 'Error'}"
|
||||
)
|
||||
|
||||
# Check writing task status
|
||||
writing_status = aop.get_task_status(
|
||||
"writer", writing_task_id
|
||||
)
|
||||
print(
|
||||
f"Writing task status: {writing_status['task']['status'] if writing_status['success'] else 'Error'}"
|
||||
)
|
||||
|
||||
# Get current queue stats
|
||||
current_stats = aop.get_queue_stats()
|
||||
if current_stats["success"]:
|
||||
for agent_name, agent_stats in current_stats[
|
||||
"stats"
|
||||
].items():
|
||||
print(
|
||||
f"{agent_name}: {agent_stats['pending_tasks']} pending, {agent_stats['processing_tasks']} processing, {agent_stats['completed_tasks']} completed"
|
||||
)
|
||||
|
||||
print("---")
|
||||
|
||||
# Demonstrate queue management
|
||||
print("\nDemonstrating queue management...")
|
||||
|
||||
# Pause the research agent queue
|
||||
print("Pausing research agent queue...")
|
||||
aop.pause_agent_queue("researcher")
|
||||
|
||||
# Get queue status
|
||||
research_queue_status = aop.task_queues["researcher"].get_status()
|
||||
print(f"Research queue status: {research_queue_status.value}")
|
||||
|
||||
# Resume the research agent queue
|
||||
print("Resuming research agent queue...")
|
||||
aop.resume_agent_queue("researcher")
|
||||
|
||||
# Clear all queues
|
||||
print("Clearing all queues...")
|
||||
cleared = aop.clear_all_queues()
|
||||
print(f"Cleared tasks: {cleared}")
|
||||
|
||||
# Final stats
|
||||
print("\nFinal queue stats:")
|
||||
final_stats = aop.get_queue_stats()
|
||||
print(f"Final stats: {final_stats}")
|
||||
|
||||
print("\nQueue demonstration completed!")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -0,0 +1,88 @@
|
||||
import json
|
||||
import asyncio
|
||||
|
||||
from swarms.structs.aop import AOPCluster
|
||||
from swarms.tools.mcp_client_tools import execute_tool_call_simple
|
||||
from mcp import ClientSession
|
||||
from mcp.client.streamable_http import streamablehttp_client
|
||||
|
||||
|
||||
async def discover_agents_example():
|
||||
"""
|
||||
Discover all agents using the AOPCluster and print the result.
|
||||
"""
|
||||
aop_cluster = AOPCluster(
|
||||
urls=["http://localhost:5932/mcp"],
|
||||
transport="streamable-http",
|
||||
)
|
||||
tool = aop_cluster.find_tool_by_server_name("discover_agents")
|
||||
if not tool:
|
||||
print("discover_agents tool not found.")
|
||||
return None
|
||||
|
||||
tool_call_request = {
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": "discover_agents",
|
||||
"arguments": "{}",
|
||||
},
|
||||
}
|
||||
|
||||
result = await execute_tool_call_simple(
|
||||
response=tool_call_request,
|
||||
server_path="http://localhost:5932/mcp",
|
||||
output_type="dict",
|
||||
verbose=False,
|
||||
)
|
||||
print(json.dumps(result, indent=2))
|
||||
return result
|
||||
|
||||
|
||||
async def raw_mcp_discover_agents_example():
|
||||
"""
|
||||
Call the MCP server directly using the raw MCP client to execute the
|
||||
built-in "discover_agents" tool and print the JSON result.
|
||||
|
||||
This demonstrates how to:
|
||||
- Initialize an MCP client over streamable HTTP
|
||||
- List available tools (optional)
|
||||
- Call a specific tool by name with arguments
|
||||
"""
|
||||
url = "http://localhost:5932/mcp"
|
||||
|
||||
# Open a raw MCP client connection
|
||||
async with streamablehttp_client(url, timeout=10) as ctx:
|
||||
if len(ctx) == 2:
|
||||
read, write = ctx
|
||||
else:
|
||||
read, write, *_ = ctx
|
||||
|
||||
async with ClientSession(read, write) as session:
|
||||
# Initialize the MCP session and optionally inspect tools
|
||||
await session.initialize()
|
||||
|
||||
# Optional: list tools (uncomment to print)
|
||||
# tools = await session.list_tools()
|
||||
# print(json.dumps(tools.model_dump(), indent=2))
|
||||
|
||||
# Call the built-in discovery tool with empty arguments
|
||||
result = await session.call_tool(
|
||||
name="discover_agents",
|
||||
arguments={},
|
||||
)
|
||||
|
||||
# Convert to dict for pretty printing
|
||||
print(json.dumps(result.model_dump(), indent=2))
|
||||
return result.model_dump()
|
||||
|
||||
|
||||
def main():
|
||||
"""
|
||||
Run the helper-based and raw MCP client discovery examples.
|
||||
"""
|
||||
asyncio.run(discover_agents_example())
|
||||
asyncio.run(raw_mcp_discover_agents_example())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -0,0 +1,107 @@
|
||||
import json
|
||||
import asyncio
|
||||
|
||||
from mcp import ClientSession
|
||||
from mcp.client.streamable_http import streamablehttp_client
|
||||
|
||||
|
||||
async def call_agent_tool_raw(
|
||||
url: str,
|
||||
tool_name: str,
|
||||
task: str,
|
||||
img: str | None = None,
|
||||
imgs: list[str] | None = None,
|
||||
correct_answer: str | None = None,
|
||||
) -> dict:
|
||||
"""
|
||||
Call a specific agent tool on an MCP server using the raw MCP client.
|
||||
|
||||
Args:
|
||||
url: MCP server URL (e.g., "http://localhost:5932/mcp").
|
||||
tool_name: Name of the tool/agent to invoke.
|
||||
task: Task prompt to execute.
|
||||
img: Optional single image path/URL.
|
||||
imgs: Optional list of image paths/URLs.
|
||||
correct_answer: Optional expected answer for validation.
|
||||
|
||||
Returns:
|
||||
A dict containing the tool's JSON response.
|
||||
"""
|
||||
# Open a raw MCP client connection over streamable HTTP
|
||||
async with streamablehttp_client(url, timeout=30) as ctx:
|
||||
if len(ctx) == 2:
|
||||
read, write = ctx
|
||||
else:
|
||||
read, write, *_ = ctx
|
||||
|
||||
async with ClientSession(read, write) as session:
|
||||
# Initialize the MCP session
|
||||
await session.initialize()
|
||||
|
||||
# Prepare arguments in the canonical AOP tool format
|
||||
arguments: dict = {"task": task}
|
||||
if img is not None:
|
||||
arguments["img"] = img
|
||||
if imgs is not None:
|
||||
arguments["imgs"] = imgs
|
||||
if correct_answer is not None:
|
||||
arguments["correct_answer"] = correct_answer
|
||||
|
||||
# Invoke the tool by name
|
||||
result = await session.call_tool(
|
||||
name=tool_name, arguments=arguments
|
||||
)
|
||||
|
||||
# Convert to dict for return/printing
|
||||
return result.model_dump()
|
||||
|
||||
|
||||
async def list_available_tools(url: str) -> dict:
|
||||
"""
|
||||
List tools from an MCP server using the raw client.
|
||||
|
||||
Args:
|
||||
url: MCP server URL (e.g., "http://localhost:5932/mcp").
|
||||
|
||||
Returns:
|
||||
A dict representation of the tools listing.
|
||||
"""
|
||||
async with streamablehttp_client(url, timeout=30) as ctx:
|
||||
if len(ctx) == 2:
|
||||
read, write = ctx
|
||||
else:
|
||||
read, write, *_ = ctx
|
||||
|
||||
async with ClientSession(read, write) as session:
|
||||
await session.initialize()
|
||||
tools = await session.list_tools()
|
||||
return tools.model_dump()
|
||||
|
||||
|
||||
def main() -> None:
|
||||
"""
|
||||
Demonstration entrypoint: list tools, then call a specified tool with a task.
|
||||
"""
|
||||
url = "http://localhost:5932/mcp"
|
||||
tool_name = "Research-Agent" # Change to your agent tool name
|
||||
task = "Summarize the latest advances in agent orchestration protocols."
|
||||
|
||||
# List tools
|
||||
tools_info = asyncio.run(list_available_tools(url))
|
||||
print("Available tools:")
|
||||
print(json.dumps(tools_info, indent=2))
|
||||
|
||||
# Call the tool
|
||||
print(f"\nCalling tool '{tool_name}' with task...\n")
|
||||
result = asyncio.run(
|
||||
call_agent_tool_raw(
|
||||
url=url,
|
||||
tool_name=tool_name,
|
||||
task=task,
|
||||
)
|
||||
)
|
||||
print(json.dumps(result, indent=2))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -0,0 +1,149 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Example showing how agents can use the discovery tool to learn about each other
|
||||
and collaborate more effectively.
|
||||
"""
|
||||
|
||||
from swarms import Agent
|
||||
from swarms.structs.aop import AOP
|
||||
|
||||
|
||||
def simulate_agent_discovery():
|
||||
"""Simulate how an agent would use the discovery tool."""
|
||||
|
||||
# Create a sample agent that will use the discovery tool
|
||||
Agent(
|
||||
agent_name="ProjectCoordinator",
|
||||
agent_description="Coordinates projects and assigns tasks to other agents",
|
||||
system_prompt="You are a project coordinator who helps organize work and delegate tasks to the most appropriate team members. You can discover information about other agents to make better decisions.",
|
||||
model_name="gpt-4o-mini",
|
||||
temperature=0.4,
|
||||
)
|
||||
|
||||
# Create the AOP cluster
|
||||
aop = AOP(
|
||||
server_name="Project Team",
|
||||
description="A team of specialized agents for project coordination",
|
||||
verbose=True,
|
||||
)
|
||||
|
||||
# Add some specialized agents
|
||||
data_agent = Agent(
|
||||
agent_name="DataSpecialist",
|
||||
agent_description="Handles all data-related tasks and analysis",
|
||||
system_prompt="You are a data specialist with expertise in data processing, analysis, and visualization. You work with large datasets and create insights.",
|
||||
tags=["data", "analysis", "python", "sql", "statistics"],
|
||||
capabilities=[
|
||||
"data_processing",
|
||||
"statistical_analysis",
|
||||
"visualization",
|
||||
],
|
||||
role="specialist",
|
||||
)
|
||||
|
||||
code_agent = Agent(
|
||||
agent_name="CodeSpecialist",
|
||||
agent_description="Handles all coding and development tasks",
|
||||
system_prompt="You are a software development specialist who writes clean, efficient code and follows best practices. You handle both frontend and backend development.",
|
||||
tags=[
|
||||
"coding",
|
||||
"development",
|
||||
"python",
|
||||
"javascript",
|
||||
"react",
|
||||
],
|
||||
capabilities=[
|
||||
"software_development",
|
||||
"code_review",
|
||||
"debugging",
|
||||
],
|
||||
role="developer",
|
||||
)
|
||||
|
||||
writing_agent = Agent(
|
||||
agent_name="ContentSpecialist",
|
||||
agent_description="Creates and manages all written content",
|
||||
system_prompt="You are a content specialist who creates engaging written content, documentation, and marketing materials. You ensure all content is clear and compelling.",
|
||||
tags=["writing", "content", "documentation", "marketing"],
|
||||
capabilities=[
|
||||
"content_creation",
|
||||
"technical_writing",
|
||||
"editing",
|
||||
],
|
||||
role="writer",
|
||||
)
|
||||
|
||||
# Add agents to the cluster
|
||||
aop.add_agent(data_agent, tool_name="data_specialist")
|
||||
aop.add_agent(code_agent, tool_name="code_specialist")
|
||||
aop.add_agent(writing_agent, tool_name="content_specialist")
|
||||
|
||||
print("🏢 Project Team AOP Cluster Created!")
|
||||
print(f"👥 Team members: {aop.list_agents()}")
|
||||
print()
|
||||
|
||||
# Simulate the coordinator discovering team members
|
||||
print("🔍 Project Coordinator discovering team capabilities...")
|
||||
print()
|
||||
|
||||
# Get discovery info for each agent
|
||||
for tool_name in aop.list_agents():
|
||||
if (
|
||||
tool_name != "discover_agents"
|
||||
): # Skip the discovery tool itself
|
||||
agent_info = aop._get_agent_discovery_info(tool_name)
|
||||
if agent_info:
|
||||
print(f"📋 {agent_info['agent_name']}:")
|
||||
print(f" Description: {agent_info['description']}")
|
||||
print(f" Role: {agent_info['role']}")
|
||||
print(f" Tags: {', '.join(agent_info['tags'])}")
|
||||
print(
|
||||
f" Capabilities: {', '.join(agent_info['capabilities'])}"
|
||||
)
|
||||
print(
|
||||
f" System Prompt: {agent_info['short_system_prompt'][:100]}..."
|
||||
)
|
||||
print()
|
||||
|
||||
print("💡 How agents would use this in practice:")
|
||||
print(" 1. Agent calls 'discover_agents' MCP tool")
|
||||
print(" 2. Gets information about all available agents")
|
||||
print(
|
||||
" 3. Uses this info to make informed decisions about task delegation"
|
||||
)
|
||||
print(
|
||||
" 4. Can discover specific agents by name for targeted collaboration"
|
||||
)
|
||||
print()
|
||||
|
||||
# Show what the MCP tool response would look like
|
||||
print("📡 Sample MCP tool response structure:")
|
||||
|
||||
print(" discover_agents() -> {")
|
||||
print(" 'success': True,")
|
||||
print(" 'agents': [")
|
||||
print(" {")
|
||||
print(" 'tool_name': 'data_specialist',")
|
||||
print(" 'agent_name': 'DataSpecialist',")
|
||||
print(
|
||||
" 'description': 'Handles all data-related tasks...',"
|
||||
)
|
||||
print(
|
||||
" 'short_system_prompt': 'You are a data specialist...',"
|
||||
)
|
||||
print(" 'tags': ['data', 'analysis', 'python'],")
|
||||
print(
|
||||
" 'capabilities': ['data_processing', 'statistics'],"
|
||||
)
|
||||
print(" 'role': 'specialist',")
|
||||
print(" ...")
|
||||
print(" }")
|
||||
print(" ]")
|
||||
print(" }")
|
||||
print()
|
||||
|
||||
print("✅ Agent discovery system ready for collaborative work!")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
simulate_agent_discovery()
|
||||
@ -0,0 +1,117 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Example demonstrating the new agent discovery MCP tool in AOP.
|
||||
|
||||
This example shows how agents can discover information about each other
|
||||
using the new 'discover_agents' MCP tool.
|
||||
"""
|
||||
|
||||
from swarms import Agent
|
||||
from swarms.structs.aop import AOP
|
||||
|
||||
|
||||
def main():
|
||||
"""Demonstrate the agent discovery functionality."""
|
||||
|
||||
# Create some sample agents with different configurations
|
||||
agent1 = Agent(
|
||||
agent_name="DataAnalyst",
|
||||
agent_description="Specialized in data analysis and visualization",
|
||||
system_prompt="You are a data analyst with expertise in Python, pandas, and statistical analysis. You help users understand data patterns and create visualizations.",
|
||||
tags=["data", "analysis", "python", "pandas"],
|
||||
capabilities=["data_analysis", "visualization", "statistics"],
|
||||
role="analyst",
|
||||
model_name="gpt-4o-mini",
|
||||
temperature=0.3,
|
||||
)
|
||||
|
||||
agent2 = Agent(
|
||||
agent_name="CodeReviewer",
|
||||
agent_description="Expert code reviewer and quality assurance specialist",
|
||||
system_prompt="You are a senior software engineer who specializes in code review, best practices, and quality assurance. You help identify bugs, suggest improvements, and ensure code follows industry standards.",
|
||||
tags=["code", "review", "quality", "python", "javascript"],
|
||||
capabilities=[
|
||||
"code_review",
|
||||
"quality_assurance",
|
||||
"best_practices",
|
||||
],
|
||||
role="reviewer",
|
||||
model_name="gpt-4o-mini",
|
||||
temperature=0.2,
|
||||
)
|
||||
|
||||
agent3 = Agent(
|
||||
agent_name="CreativeWriter",
|
||||
agent_description="Creative content writer and storyteller",
|
||||
system_prompt="You are a creative writer who specializes in storytelling, content creation, and engaging narratives. You help create compelling stories, articles, and marketing content.",
|
||||
tags=["writing", "creative", "content", "storytelling"],
|
||||
capabilities=[
|
||||
"creative_writing",
|
||||
"content_creation",
|
||||
"storytelling",
|
||||
],
|
||||
role="writer",
|
||||
model_name="gpt-4o-mini",
|
||||
temperature=0.8,
|
||||
)
|
||||
|
||||
# Create AOP cluster with the agents
|
||||
aop = AOP(
|
||||
server_name="Agent Discovery Demo",
|
||||
description="A demo cluster showing agent discovery capabilities",
|
||||
agents=[agent1, agent2, agent3],
|
||||
verbose=True,
|
||||
)
|
||||
|
||||
print("🚀 AOP Cluster initialized with agent discovery tool!")
|
||||
print(f"📊 Total agents registered: {len(aop.agents)}")
|
||||
print(f"🔧 Available tools: {aop.list_agents()}")
|
||||
print()
|
||||
|
||||
# Demonstrate the discovery tool
|
||||
print("🔍 Testing agent discovery functionality...")
|
||||
print()
|
||||
|
||||
# Test discovering all agents
|
||||
print("1. Discovering all agents:")
|
||||
all_agents_info = aop._get_agent_discovery_info(
|
||||
"DataAnalyst"
|
||||
) # This would normally be called via MCP
|
||||
print(
|
||||
f" Found agent: {all_agents_info['agent_name'] if all_agents_info else 'None'}"
|
||||
)
|
||||
print()
|
||||
|
||||
# Show what the MCP tool would return
|
||||
print("2. What the 'discover_agents' MCP tool would return:")
|
||||
print(" - Tool name: discover_agents")
|
||||
print(
|
||||
" - Description: Discover information about other agents in the cluster"
|
||||
)
|
||||
print(" - Parameters: agent_name (optional)")
|
||||
print(
|
||||
" - Returns: Agent info including name, description, short system prompt, tags, capabilities, role, etc."
|
||||
)
|
||||
print()
|
||||
|
||||
# Show sample agent info structure
|
||||
if all_agents_info:
|
||||
print("3. Sample agent discovery info structure:")
|
||||
for key, value in all_agents_info.items():
|
||||
if key == "short_system_prompt":
|
||||
print(f" {key}: {value[:100]}...")
|
||||
else:
|
||||
print(f" {key}: {value}")
|
||||
print()
|
||||
|
||||
print("✅ Agent discovery tool successfully integrated!")
|
||||
print(
|
||||
"💡 Agents can now use the 'discover_agents' MCP tool to learn about each other."
|
||||
)
|
||||
print(
|
||||
"🔄 The tool is automatically updated when new agents are added to the cluster."
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -0,0 +1,231 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Simple example showing how to call the discover_agents tool synchronously.
|
||||
"""
|
||||
|
||||
import json
|
||||
import asyncio
|
||||
from swarms.structs.aop import AOPCluster
|
||||
from swarms.tools.mcp_client_tools import execute_tool_call_simple
|
||||
|
||||
|
||||
def call_discover_agents_sync(server_url="http://localhost:5932/mcp"):
|
||||
"""
|
||||
Synchronously call the discover_agents tool.
|
||||
|
||||
Args:
|
||||
server_url: URL of the MCP server
|
||||
|
||||
Returns:
|
||||
Dict containing the discovery results
|
||||
"""
|
||||
|
||||
# Create the tool call request
|
||||
tool_call_request = {
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": "discover_agents",
|
||||
"arguments": json.dumps({}), # Empty = get all agents
|
||||
},
|
||||
}
|
||||
|
||||
# Run the async function
|
||||
return asyncio.run(
|
||||
execute_tool_call_simple(
|
||||
response=tool_call_request,
|
||||
server_path=server_url,
|
||||
output_type="dict",
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
def call_discover_specific_agent_sync(
|
||||
agent_name, server_url="http://localhost:5932/mcp"
|
||||
):
|
||||
"""
|
||||
Synchronously call the discover_agents tool for a specific agent.
|
||||
|
||||
Args:
|
||||
agent_name: Name of the specific agent to discover
|
||||
server_url: URL of the MCP server
|
||||
|
||||
Returns:
|
||||
Dict containing the discovery results
|
||||
"""
|
||||
|
||||
# Create the tool call request
|
||||
tool_call_request = {
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": "discover_agents",
|
||||
"arguments": json.dumps({"agent_name": agent_name}),
|
||||
},
|
||||
}
|
||||
|
||||
# Run the async function
|
||||
return asyncio.run(
|
||||
execute_tool_call_simple(
|
||||
response=tool_call_request,
|
||||
server_path=server_url,
|
||||
output_type="dict",
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
def main():
|
||||
"""Main function demonstrating discovery tool usage."""
|
||||
|
||||
print("🔍 AOP Agent Discovery Tool Example")
|
||||
print("=" * 40)
|
||||
print()
|
||||
|
||||
# First, check what tools are available
|
||||
print("1. Checking available MCP tools...")
|
||||
aop_cluster = AOPCluster(
|
||||
urls=["http://localhost:5932/mcp"],
|
||||
transport="streamable-http",
|
||||
)
|
||||
|
||||
tools = aop_cluster.get_tools(output_type="dict")
|
||||
print(f" Found {len(tools)} tools")
|
||||
|
||||
# Check if discover_agents is available
|
||||
discover_tool = aop_cluster.find_tool_by_server_name(
|
||||
"discover_agents"
|
||||
)
|
||||
if not discover_tool:
|
||||
print("❌ discover_agents tool not found!")
|
||||
print(
|
||||
" Make sure your AOP server is running with agents registered."
|
||||
)
|
||||
return
|
||||
|
||||
print("✅ discover_agents tool found!")
|
||||
print()
|
||||
|
||||
# Discover all agents
|
||||
print("2. Discovering all agents...")
|
||||
try:
|
||||
result = call_discover_agents_sync()
|
||||
|
||||
if isinstance(result, list) and len(result) > 0:
|
||||
discovery_data = result[0]
|
||||
|
||||
if discovery_data.get("success"):
|
||||
agents = discovery_data.get("agents", [])
|
||||
print(f" ✅ Found {len(agents)} agents:")
|
||||
|
||||
for i, agent in enumerate(agents, 1):
|
||||
print(
|
||||
f" {i}. {agent.get('agent_name', 'Unknown')}"
|
||||
)
|
||||
print(
|
||||
f" Role: {agent.get('role', 'worker')}"
|
||||
)
|
||||
print(
|
||||
f" Description: {agent.get('description', 'No description')}"
|
||||
)
|
||||
print(
|
||||
f" Tags: {', '.join(agent.get('tags', []))}"
|
||||
)
|
||||
print(
|
||||
f" Capabilities: {', '.join(agent.get('capabilities', []))}"
|
||||
)
|
||||
print(
|
||||
f" System Prompt: {agent.get('short_system_prompt', 'No prompt')[:100]}..."
|
||||
)
|
||||
print()
|
||||
else:
|
||||
print(
|
||||
f" ❌ Discovery failed: {discovery_data.get('error', 'Unknown error')}"
|
||||
)
|
||||
else:
|
||||
print(" ❌ No valid result returned")
|
||||
|
||||
except Exception as e:
|
||||
print(f" ❌ Error: {e}")
|
||||
|
||||
print()
|
||||
|
||||
# Example of discovering a specific agent (if any exist)
|
||||
print("3. Example: Discovering a specific agent...")
|
||||
try:
|
||||
# Try to discover the first agent specifically
|
||||
if isinstance(result, list) and len(result) > 0:
|
||||
discovery_data = result[0]
|
||||
if discovery_data.get("success") and discovery_data.get(
|
||||
"agents"
|
||||
):
|
||||
first_agent_name = discovery_data["agents"][0].get(
|
||||
"agent_name"
|
||||
)
|
||||
if first_agent_name:
|
||||
print(
|
||||
f" Looking for specific agent: {first_agent_name}"
|
||||
)
|
||||
specific_result = (
|
||||
call_discover_specific_agent_sync(
|
||||
first_agent_name
|
||||
)
|
||||
)
|
||||
|
||||
if (
|
||||
isinstance(specific_result, list)
|
||||
and len(specific_result) > 0
|
||||
):
|
||||
specific_data = specific_result[0]
|
||||
if specific_data.get("success"):
|
||||
agent = specific_data.get("agents", [{}])[
|
||||
0
|
||||
]
|
||||
print(
|
||||
f" ✅ Found specific agent: {agent.get('agent_name', 'Unknown')}"
|
||||
)
|
||||
print(
|
||||
f" Model: {agent.get('model_name', 'Unknown')}"
|
||||
)
|
||||
print(
|
||||
f" Max Loops: {agent.get('max_loops', 1)}"
|
||||
)
|
||||
print(
|
||||
f" Temperature: {agent.get('temperature', 0.5)}"
|
||||
)
|
||||
else:
|
||||
print(
|
||||
f" ❌ Specific discovery failed: {specific_data.get('error')}"
|
||||
)
|
||||
else:
|
||||
print(" ❌ No valid specific result")
|
||||
else:
|
||||
print(
|
||||
" ⚠️ No agents found to test specific discovery"
|
||||
)
|
||||
else:
|
||||
print(
|
||||
" ⚠️ No agents available for specific discovery"
|
||||
)
|
||||
else:
|
||||
print(
|
||||
" ⚠️ No previous discovery results to use for specific discovery"
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
print(f" ❌ Error in specific discovery: {e}")
|
||||
|
||||
print()
|
||||
print("✅ Discovery tool demonstration complete!")
|
||||
print()
|
||||
print("💡 Usage Summary:")
|
||||
print(
|
||||
" • Call discover_agents() with no arguments to get all agents"
|
||||
)
|
||||
print(
|
||||
" • Call discover_agents(agent_name='AgentName') to get specific agent"
|
||||
)
|
||||
print(
|
||||
" • Each agent returns: name, description, role, tags, capabilities, system prompt, etc."
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -0,0 +1,198 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Test script to verify the agent discovery functionality works correctly.
|
||||
"""
|
||||
|
||||
import sys
|
||||
import os
|
||||
|
||||
# Add the swarms directory to the path
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "swarms"))
|
||||
|
||||
from swarms import Agent
|
||||
from swarms.structs.aop import AOP
|
||||
|
||||
|
||||
def test_agent_discovery():
|
||||
"""Test the agent discovery functionality."""
|
||||
|
||||
print("🧪 Testing AOP Agent Discovery Functionality")
|
||||
print("=" * 50)
|
||||
|
||||
# Create test agents
|
||||
agent1 = Agent(
|
||||
agent_name="TestAgent1",
|
||||
agent_description="First test agent for discovery",
|
||||
system_prompt="This is a test agent with a very long system prompt that should be truncated to 200 characters when returned by the discovery tool. This prompt contains detailed instructions about how the agent should behave and what tasks it can perform.",
|
||||
tags=["test", "agent", "discovery"],
|
||||
capabilities=["testing", "validation"],
|
||||
role="tester",
|
||||
)
|
||||
|
||||
agent2 = Agent(
|
||||
agent_name="TestAgent2",
|
||||
agent_description="Second test agent for discovery",
|
||||
system_prompt="Another test agent with different capabilities and a shorter prompt.",
|
||||
tags=["test", "agent", "analysis"],
|
||||
capabilities=["analysis", "reporting"],
|
||||
role="analyst",
|
||||
)
|
||||
|
||||
# Create AOP cluster
|
||||
aop = AOP(
|
||||
server_name="Test Cluster",
|
||||
description="Test cluster for agent discovery",
|
||||
verbose=False,
|
||||
)
|
||||
|
||||
# Add agents
|
||||
aop.add_agent(agent1, tool_name="test_agent_1")
|
||||
aop.add_agent(agent2, tool_name="test_agent_2")
|
||||
|
||||
print(f"✅ Created AOP cluster with {len(aop.agents)} agents")
|
||||
print(f"📋 Available tools: {aop.list_agents()}")
|
||||
print()
|
||||
|
||||
# Test discovery functionality
|
||||
print("🔍 Testing agent discovery...")
|
||||
|
||||
# Test getting info for specific agent
|
||||
agent1_info = aop._get_agent_discovery_info("test_agent_1")
|
||||
assert (
|
||||
agent1_info is not None
|
||||
), "Should be able to get info for test_agent_1"
|
||||
assert (
|
||||
agent1_info["agent_name"] == "TestAgent1"
|
||||
), "Agent name should match"
|
||||
assert (
|
||||
agent1_info["description"] == "First test agent for discovery"
|
||||
), "Description should match"
|
||||
assert (
|
||||
len(agent1_info["short_system_prompt"]) <= 203
|
||||
), "System prompt should be truncated to ~200 chars"
|
||||
assert "test" in agent1_info["tags"], "Tags should include 'test'"
|
||||
assert (
|
||||
"testing" in agent1_info["capabilities"]
|
||||
), "Capabilities should include 'testing'"
|
||||
assert agent1_info["role"] == "tester", "Role should be 'tester'"
|
||||
|
||||
print("✅ Specific agent discovery test passed")
|
||||
|
||||
# Test getting info for non-existent agent
|
||||
non_existent_info = aop._get_agent_discovery_info(
|
||||
"non_existent_agent"
|
||||
)
|
||||
assert (
|
||||
non_existent_info is None
|
||||
), "Should return None for non-existent agent"
|
||||
|
||||
print("✅ Non-existent agent test passed")
|
||||
|
||||
# Test that discovery tool is registered
|
||||
# Note: In a real scenario, this would be tested via MCP tool calls
|
||||
# For now, we just verify the method exists and works
|
||||
try:
|
||||
# This simulates what the MCP tool would do
|
||||
discovery_result = {"success": True, "agents": []}
|
||||
|
||||
for tool_name in aop.agents.keys():
|
||||
agent_info = aop._get_agent_discovery_info(tool_name)
|
||||
if agent_info:
|
||||
discovery_result["agents"].append(agent_info)
|
||||
|
||||
assert (
|
||||
len(discovery_result["agents"]) == 2
|
||||
), "Should discover both agents"
|
||||
assert (
|
||||
discovery_result["success"] is True
|
||||
), "Discovery should be successful"
|
||||
|
||||
print("✅ Discovery tool simulation test passed")
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Discovery tool test failed: {e}")
|
||||
return False
|
||||
|
||||
# Test system prompt truncation
|
||||
long_prompt = "A" * 300 # 300 character string
|
||||
agent_with_long_prompt = Agent(
|
||||
agent_name="LongPromptAgent",
|
||||
agent_description="Agent with very long system prompt",
|
||||
system_prompt=long_prompt,
|
||||
)
|
||||
|
||||
aop.add_agent(
|
||||
agent_with_long_prompt, tool_name="long_prompt_agent"
|
||||
)
|
||||
long_prompt_info = aop._get_agent_discovery_info(
|
||||
"long_prompt_agent"
|
||||
)
|
||||
|
||||
assert (
|
||||
long_prompt_info is not None
|
||||
), "Should get info for long prompt agent"
|
||||
assert (
|
||||
len(long_prompt_info["short_system_prompt"]) == 203
|
||||
), "Should truncate to 200 chars + '...'"
|
||||
assert long_prompt_info["short_system_prompt"].endswith(
|
||||
"..."
|
||||
), "Should end with '...'"
|
||||
|
||||
print("✅ System prompt truncation test passed")
|
||||
|
||||
# Test with missing attributes
|
||||
minimal_agent = Agent(
|
||||
agent_name="MinimalAgent",
|
||||
# No description, tags, capabilities, or role specified
|
||||
)
|
||||
|
||||
aop.add_agent(minimal_agent, tool_name="minimal_agent")
|
||||
minimal_info = aop._get_agent_discovery_info("minimal_agent")
|
||||
|
||||
assert (
|
||||
minimal_info is not None
|
||||
), "Should get info for minimal agent"
|
||||
assert (
|
||||
minimal_info["description"] == "No description available"
|
||||
), "Should have default description"
|
||||
assert minimal_info["tags"] == [], "Should have empty tags list"
|
||||
assert (
|
||||
minimal_info["capabilities"] == []
|
||||
), "Should have empty capabilities list"
|
||||
assert (
|
||||
minimal_info["role"] == "worker"
|
||||
), "Should have default role"
|
||||
|
||||
print("✅ Minimal agent attributes test passed")
|
||||
|
||||
print()
|
||||
print(
|
||||
"🎉 All tests passed! Agent discovery functionality is working correctly."
|
||||
)
|
||||
print()
|
||||
print("📊 Summary of discovered agents:")
|
||||
for tool_name in aop.agents.keys():
|
||||
info = aop._get_agent_discovery_info(tool_name)
|
||||
if info:
|
||||
print(
|
||||
f" • {info['agent_name']} ({info['role']}) - {info['description']}"
|
||||
)
|
||||
|
||||
return True
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
try:
|
||||
success = test_agent_discovery()
|
||||
if success:
|
||||
print("\n✅ All tests completed successfully!")
|
||||
sys.exit(0)
|
||||
else:
|
||||
print("\n❌ Some tests failed!")
|
||||
sys.exit(1)
|
||||
except Exception as e:
|
||||
print(f"\n💥 Test failed with exception: {e}")
|
||||
import traceback
|
||||
|
||||
traceback.print_exc()
|
||||
sys.exit(1)
|
||||
@ -0,0 +1,225 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Example demonstrating the new agent information tools in AOP.
|
||||
|
||||
This example shows how to use the new MCP tools for getting agent information.
|
||||
"""
|
||||
|
||||
import json
|
||||
import asyncio
|
||||
from swarms.structs.aop import AOPCluster
|
||||
from swarms.tools.mcp_client_tools import execute_tool_call_simple
|
||||
|
||||
|
||||
async def demonstrate_new_agent_tools():
|
||||
"""Demonstrate the new agent information tools."""
|
||||
|
||||
# Create AOP cluster connection
|
||||
AOPCluster(
|
||||
urls=["http://localhost:5932/mcp"],
|
||||
transport="streamable-http",
|
||||
)
|
||||
|
||||
print("🔧 New AOP Agent Information Tools Demo")
|
||||
print("=" * 50)
|
||||
print()
|
||||
|
||||
# 1. List all agents
|
||||
print("1. Listing all agents...")
|
||||
try:
|
||||
tool_call = {
|
||||
"type": "function",
|
||||
"function": {"name": "list_agents", "arguments": "{}"},
|
||||
}
|
||||
|
||||
result = await execute_tool_call_simple(
|
||||
response=tool_call,
|
||||
server_path="http://localhost:5932/mcp",
|
||||
output_type="dict",
|
||||
verbose=False,
|
||||
)
|
||||
|
||||
if isinstance(result, list) and len(result) > 0:
|
||||
data = result[0]
|
||||
if data.get("success"):
|
||||
agent_names = data.get("agent_names", [])
|
||||
print(
|
||||
f" Found {len(agent_names)} agents: {agent_names}"
|
||||
)
|
||||
else:
|
||||
print(f" Error: {data.get('error')}")
|
||||
else:
|
||||
print(" No valid result returned")
|
||||
except Exception as e:
|
||||
print(f" Error: {e}")
|
||||
print()
|
||||
|
||||
# 2. Get details for a specific agent
|
||||
print("2. Getting details for a specific agent...")
|
||||
try:
|
||||
tool_call = {
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": "get_agent_details",
|
||||
"arguments": json.dumps(
|
||||
{"agent_name": "Research-Agent"}
|
||||
),
|
||||
},
|
||||
}
|
||||
|
||||
result = await execute_tool_call_simple(
|
||||
response=tool_call,
|
||||
server_path="http://localhost:5932/mcp",
|
||||
output_type="dict",
|
||||
verbose=False,
|
||||
)
|
||||
|
||||
if isinstance(result, list) and len(result) > 0:
|
||||
data = result[0]
|
||||
if data.get("success"):
|
||||
data.get("agent_info", {})
|
||||
discovery_info = data.get("discovery_info", {})
|
||||
print(
|
||||
f" Agent: {discovery_info.get('agent_name', 'Unknown')}"
|
||||
)
|
||||
print(
|
||||
f" Description: {discovery_info.get('description', 'No description')}"
|
||||
)
|
||||
print(
|
||||
f" Model: {discovery_info.get('model_name', 'Unknown')}"
|
||||
)
|
||||
print(f" Tags: {discovery_info.get('tags', [])}")
|
||||
print(
|
||||
f" Capabilities: {discovery_info.get('capabilities', [])}"
|
||||
)
|
||||
else:
|
||||
print(f" Error: {data.get('error')}")
|
||||
else:
|
||||
print(" No valid result returned")
|
||||
except Exception as e:
|
||||
print(f" Error: {e}")
|
||||
print()
|
||||
|
||||
# 3. Get info for multiple agents
|
||||
print("3. Getting info for multiple agents...")
|
||||
try:
|
||||
tool_call = {
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": "get_agents_info",
|
||||
"arguments": json.dumps(
|
||||
{
|
||||
"agent_names": [
|
||||
"Research-Agent",
|
||||
"DataAnalyst",
|
||||
"Writer",
|
||||
]
|
||||
}
|
||||
),
|
||||
},
|
||||
}
|
||||
|
||||
result = await execute_tool_call_simple(
|
||||
response=tool_call,
|
||||
server_path="http://localhost:5932/mcp",
|
||||
output_type="dict",
|
||||
verbose=False,
|
||||
)
|
||||
|
||||
if isinstance(result, list) and len(result) > 0:
|
||||
data = result[0]
|
||||
if data.get("success"):
|
||||
agents_info = data.get("agents_info", [])
|
||||
not_found = data.get("not_found", [])
|
||||
print(
|
||||
f" Found {len(agents_info)} agents out of {data.get('total_requested', 0)} requested"
|
||||
)
|
||||
for agent in agents_info:
|
||||
discovery_info = agent.get("discovery_info", {})
|
||||
print(
|
||||
f" • {discovery_info.get('agent_name', 'Unknown')}: {discovery_info.get('description', 'No description')}"
|
||||
)
|
||||
if not_found:
|
||||
print(f" Not found: {not_found}")
|
||||
else:
|
||||
print(f" Error: {data.get('error')}")
|
||||
else:
|
||||
print(" No valid result returned")
|
||||
except Exception as e:
|
||||
print(f" Error: {e}")
|
||||
print()
|
||||
|
||||
# 4. Search for agents
|
||||
print("4. Searching for agents...")
|
||||
try:
|
||||
tool_call = {
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": "search_agents",
|
||||
"arguments": json.dumps(
|
||||
{
|
||||
"query": "data",
|
||||
"search_fields": [
|
||||
"name",
|
||||
"description",
|
||||
"tags",
|
||||
"capabilities",
|
||||
],
|
||||
}
|
||||
),
|
||||
},
|
||||
}
|
||||
|
||||
result = await execute_tool_call_simple(
|
||||
response=tool_call,
|
||||
server_path="http://localhost:5932/mcp",
|
||||
output_type="dict",
|
||||
verbose=False,
|
||||
)
|
||||
|
||||
if isinstance(result, list) and len(result) > 0:
|
||||
data = result[0]
|
||||
if data.get("success"):
|
||||
matching_agents = data.get("matching_agents", [])
|
||||
print(
|
||||
f" Found {len(matching_agents)} agents matching 'data'"
|
||||
)
|
||||
for agent in matching_agents:
|
||||
print(
|
||||
f" • {agent.get('agent_name', 'Unknown')}: {agent.get('description', 'No description')}"
|
||||
)
|
||||
print(f" Tags: {agent.get('tags', [])}")
|
||||
print(
|
||||
f" Capabilities: {agent.get('capabilities', [])}"
|
||||
)
|
||||
else:
|
||||
print(f" Error: {data.get('error')}")
|
||||
else:
|
||||
print(" No valid result returned")
|
||||
except Exception as e:
|
||||
print(f" Error: {e}")
|
||||
print()
|
||||
|
||||
print("✅ New agent tools demonstration complete!")
|
||||
print()
|
||||
print("💡 Available Tools:")
|
||||
print(
|
||||
" • discover_agents - Get discovery info for all or specific agents"
|
||||
)
|
||||
print(
|
||||
" • get_agent_details - Get detailed info for a single agent"
|
||||
)
|
||||
print(
|
||||
" • get_agents_info - Get detailed info for multiple agents"
|
||||
)
|
||||
print(" • list_agents - Get simple list of all agent names")
|
||||
print(" • search_agents - Search agents by keywords")
|
||||
|
||||
|
||||
def main():
|
||||
"""Main function to run the demonstration."""
|
||||
asyncio.run(demonstrate_new_agent_tools())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -0,0 +1,10 @@
|
||||
import json
|
||||
from swarms.tools.mcp_client_tools import get_mcp_tools_sync
|
||||
|
||||
|
||||
print(
|
||||
json.dumps(
|
||||
get_mcp_tools_sync(server_path="http://0.0.0.0:8000/mcp"),
|
||||
indent=4,
|
||||
)
|
||||
)
|
||||
@ -0,0 +1,105 @@
|
||||
import json
|
||||
from swarms.tools.mcp_client_tools import (
|
||||
get_mcp_tools_sync,
|
||||
execute_tool_call_simple,
|
||||
)
|
||||
|
||||
|
||||
def get_available_tools(
|
||||
server_path: str = "http://localhost:8000/mcp",
|
||||
) -> list:
|
||||
"""
|
||||
Get all available MCP tools from the server.
|
||||
|
||||
Args:
|
||||
server_path: URL of the MCP server
|
||||
|
||||
Returns:
|
||||
List of available tools
|
||||
"""
|
||||
tools = get_mcp_tools_sync(server_path=server_path)
|
||||
return tools
|
||||
|
||||
|
||||
def call_agent_tool(
|
||||
tool_name: str,
|
||||
task: str,
|
||||
server_path: str = "http://localhost:8000/mcp",
|
||||
) -> dict:
|
||||
"""
|
||||
Call a specific agent tool with a task.
|
||||
|
||||
Args:
|
||||
tool_name: Name of the agent tool to call
|
||||
task: Task or prompt to send to the agent
|
||||
server_path: URL of the MCP server
|
||||
|
||||
Returns:
|
||||
Response from the agent tool
|
||||
"""
|
||||
call = {
|
||||
"function": {
|
||||
"name": tool_name,
|
||||
"arguments": {"task": task},
|
||||
}
|
||||
}
|
||||
|
||||
try:
|
||||
import asyncio
|
||||
|
||||
result = asyncio.run(
|
||||
execute_tool_call_simple(
|
||||
response=call, server_path=server_path
|
||||
)
|
||||
)
|
||||
return result
|
||||
except Exception as e:
|
||||
return {"error": str(e)}
|
||||
|
||||
|
||||
def main():
|
||||
"""
|
||||
Main function to demonstrate MCP tool usage.
|
||||
"""
|
||||
server_path = "http://localhost:8000/mcp"
|
||||
|
||||
# Step 1: Get available tools
|
||||
tools = get_available_tools(server_path)
|
||||
|
||||
if not tools:
|
||||
return {
|
||||
"error": "No tools available. Make sure the MCP server is running."
|
||||
}
|
||||
|
||||
# Step 2: Find an agent tool to call
|
||||
agent_tools = [
|
||||
tool
|
||||
for tool in tools
|
||||
if "agent" in tool.get("function", {}).get("name", "").lower()
|
||||
]
|
||||
|
||||
if not agent_tools:
|
||||
return {
|
||||
"error": "No agent tools found",
|
||||
"available_tools": [
|
||||
tool.get("function", {}).get("name", "Unknown")
|
||||
for tool in tools
|
||||
],
|
||||
}
|
||||
|
||||
# Step 3: Call the first available agent tool
|
||||
agent_tool = agent_tools[0]
|
||||
tool_name = agent_tool.get("function", {}).get("name")
|
||||
|
||||
# Example task
|
||||
task = "Hello! Can you help me understand what you do and what capabilities you have?"
|
||||
|
||||
# Call the agent
|
||||
result = call_agent_tool(tool_name, task, server_path)
|
||||
|
||||
return result
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
result = main()
|
||||
print(json.dumps(result, indent=4))
|
||||
@ -0,0 +1,113 @@
|
||||
import asyncio
|
||||
import json
|
||||
from typing import Dict
|
||||
|
||||
import requests
|
||||
|
||||
from swarms.structs.aop import AOPCluster
|
||||
from swarms.tools.mcp_client_tools import execute_tool_call_simple
|
||||
|
||||
|
||||
def _select_tools_by_keyword(tools: list, keyword: str) -> list:
|
||||
"""
|
||||
Return tools whose name or description contains the keyword
|
||||
(case-insensitive).
|
||||
"""
|
||||
kw = keyword.lower()
|
||||
selected = []
|
||||
for t in tools:
|
||||
name = t.get("function", {}).get("name", "")
|
||||
desc = t.get("function", {}).get("description", "")
|
||||
if kw in name.lower() or kw in desc.lower():
|
||||
selected.append(t)
|
||||
return selected
|
||||
|
||||
|
||||
def _example_payload_from_schema(tools: list, tool_name: str) -> dict:
|
||||
"""
|
||||
Construct a minimal example payload for a given tool using its JSON schema.
|
||||
Falls back to a generic 'task' if schema not present.
|
||||
"""
|
||||
for t in tools:
|
||||
fn = t.get("function", {})
|
||||
if fn.get("name") == tool_name:
|
||||
schema = fn.get("parameters", {})
|
||||
required = schema.get("required", [])
|
||||
props = schema.get("properties", {})
|
||||
payload = {}
|
||||
for r in required:
|
||||
if r in props:
|
||||
if props[r].get("type") == "string":
|
||||
payload[r] = (
|
||||
"Example patient case: 45M, egfr 59 ml/min/1.73"
|
||||
)
|
||||
elif props[r].get("type") == "boolean":
|
||||
payload[r] = False
|
||||
else:
|
||||
payload[r] = None
|
||||
if not payload:
|
||||
payload = {
|
||||
"task": "Provide ICD-10 suggestions for the case above"
|
||||
}
|
||||
return payload
|
||||
return {"task": "Provide ICD-10 suggestions for the case above"}
|
||||
|
||||
|
||||
def main() -> None:
|
||||
cluster = AOPCluster(
|
||||
urls=["http://localhost:8000/mcp"],
|
||||
transport="streamable-http",
|
||||
)
|
||||
|
||||
tools = cluster.get_tools(output_type="dict")
|
||||
print(f"Tools: {len(tools)}")
|
||||
|
||||
coding_tools = _select_tools_by_keyword(tools, "coder")
|
||||
names = [t.get("function", {}).get("name") for t in coding_tools]
|
||||
print(f"Coding-related tools: {names}")
|
||||
|
||||
# Build a real payload for "Medical Coder" and execute the tool call
|
||||
tool_name = "Medical Coder"
|
||||
payload: Dict[str, object] = _example_payload_from_schema(tools, tool_name)
|
||||
|
||||
# Enrich with public keyless data (epidemiology context via disease.sh)
|
||||
try:
|
||||
epi = requests.get(
|
||||
"https://disease.sh/v3/covid-19/countries/USA?strict=true",
|
||||
timeout=5,
|
||||
)
|
||||
if epi.ok:
|
||||
data = epi.json()
|
||||
epi_summary = (
|
||||
f"US COVID-19 context: cases={data.get('cases')}, "
|
||||
f"todayCases={data.get('todayCases')}, deaths={data.get('deaths')}"
|
||||
)
|
||||
base_task = payload.get("task") or ""
|
||||
payload["task"] = (
|
||||
f"{base_task}\n\nEpidemiology context (no key API): {epi_summary}"
|
||||
)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
print("Calling tool:", tool_name)
|
||||
request = {
|
||||
"function": {
|
||||
"name": tool_name,
|
||||
"arguments": payload,
|
||||
}
|
||||
}
|
||||
result = asyncio.run(
|
||||
execute_tool_call_simple(
|
||||
response=request,
|
||||
server_path="http://localhost:8000/mcp",
|
||||
output_type="json",
|
||||
transport="streamable-http",
|
||||
verbose=False,
|
||||
)
|
||||
)
|
||||
print("Response:")
|
||||
print(result)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -0,0 +1,166 @@
|
||||
# Import medical agents defined in the demo module
|
||||
from examples.demos.medical.medical_coder_agent import (chief_medical_officer,
|
||||
internist,
|
||||
medical_coder,
|
||||
synthesizer,
|
||||
virologist)
|
||||
from swarms.structs.aop import AOP
|
||||
|
||||
|
||||
def _enrich_agents_metadata() -> None:
|
||||
"""
|
||||
Add lightweight tags/capabilities/roles to imported agents for
|
||||
better discovery results.
|
||||
"""
|
||||
chief_medical_officer.tags = [
|
||||
"coordination",
|
||||
"diagnosis",
|
||||
"triage",
|
||||
]
|
||||
chief_medical_officer.capabilities = [
|
||||
"case-intake",
|
||||
"differential",
|
||||
"planning",
|
||||
]
|
||||
chief_medical_officer.role = "coordinator"
|
||||
|
||||
virologist.tags = ["virology", "infectious-disease"]
|
||||
virologist.capabilities = ["viral-analysis", "icd10-suggestion"]
|
||||
virologist.role = "specialist"
|
||||
|
||||
internist.tags = ["internal-medicine", "evaluation"]
|
||||
internist.capabilities = [
|
||||
"system-review",
|
||||
"hcc-tagging",
|
||||
"risk-stratification",
|
||||
]
|
||||
internist.role = "specialist"
|
||||
|
||||
medical_coder.tags = ["coding", "icd10", "compliance"]
|
||||
medical_coder.capabilities = [
|
||||
"code-assignment",
|
||||
"documentation-review",
|
||||
]
|
||||
medical_coder.role = "coder"
|
||||
|
||||
synthesizer.tags = ["synthesis", "reporting"]
|
||||
synthesizer.capabilities = [
|
||||
"evidence-reconciliation",
|
||||
"final-report",
|
||||
]
|
||||
synthesizer.role = "synthesizer"
|
||||
|
||||
|
||||
def _medical_input_schema() -> dict:
|
||||
return {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"task": {
|
||||
"type": "string",
|
||||
"description": "Patient case or instruction for the agent",
|
||||
},
|
||||
"priority": {
|
||||
"type": "string",
|
||||
"enum": ["low", "normal", "high"],
|
||||
"description": "Processing priority",
|
||||
},
|
||||
"include_images": {
|
||||
"type": "boolean",
|
||||
"description": "Whether to consider linked images if provided",
|
||||
"default": False,
|
||||
},
|
||||
"img": {
|
||||
"type": "string",
|
||||
"description": "Optional image path/URL",
|
||||
},
|
||||
"imgs": {
|
||||
"type": "array",
|
||||
"items": {"type": "string"},
|
||||
"description": "Optional list of images",
|
||||
},
|
||||
},
|
||||
"required": ["task"],
|
||||
"additionalProperties": False,
|
||||
}
|
||||
|
||||
|
||||
def _medical_output_schema() -> dict:
|
||||
return {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"result": {"type": "string"},
|
||||
"success": {"type": "boolean"},
|
||||
"error": {"type": "string"},
|
||||
"confidence": {
|
||||
"type": "number",
|
||||
"minimum": 0,
|
||||
"maximum": 1,
|
||||
"description": "Optional confidence in the assessment",
|
||||
},
|
||||
"codes": {
|
||||
"type": "array",
|
||||
"items": {"type": "string"},
|
||||
"description": "Optional list of suggested ICD-10 codes",
|
||||
},
|
||||
},
|
||||
"required": ["result", "success"],
|
||||
"additionalProperties": True,
|
||||
}
|
||||
|
||||
|
||||
def main() -> None:
|
||||
"""
|
||||
Start an AOP MCP server that exposes the medical agents as tools with
|
||||
structured schemas and per-agent settings.
|
||||
"""
|
||||
_enrich_agents_metadata()
|
||||
|
||||
deployer = AOP(
|
||||
server_name="Medical-AOP-Server",
|
||||
port=8000,
|
||||
verbose=False,
|
||||
traceback_enabled=True,
|
||||
log_level="INFO",
|
||||
transport="streamable-http",
|
||||
)
|
||||
|
||||
input_schema = _medical_input_schema()
|
||||
output_schema = _medical_output_schema()
|
||||
|
||||
# Register each agent with a modest, role-appropriate timeout
|
||||
deployer.add_agent(
|
||||
chief_medical_officer,
|
||||
timeout=45,
|
||||
input_schema=input_schema,
|
||||
output_schema=output_schema,
|
||||
)
|
||||
deployer.add_agent(
|
||||
virologist,
|
||||
timeout=40,
|
||||
input_schema=input_schema,
|
||||
output_schema=output_schema,
|
||||
)
|
||||
deployer.add_agent(
|
||||
internist,
|
||||
timeout=40,
|
||||
input_schema=input_schema,
|
||||
output_schema=output_schema,
|
||||
)
|
||||
deployer.add_agent(
|
||||
medical_coder,
|
||||
timeout=50,
|
||||
input_schema=input_schema,
|
||||
output_schema=output_schema,
|
||||
)
|
||||
deployer.add_agent(
|
||||
synthesizer,
|
||||
timeout=45,
|
||||
input_schema=input_schema,
|
||||
output_schema=output_schema,
|
||||
)
|
||||
|
||||
deployer.run()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -0,0 +1,106 @@
|
||||
from swarms import Agent
|
||||
from swarms.structs.aop import (
|
||||
AOP,
|
||||
)
|
||||
|
||||
# Create specialized agents
|
||||
research_agent = Agent(
|
||||
agent_name="Research-Agent",
|
||||
agent_description="Expert in research, data collection, and information gathering",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are a research specialist. Your role is to:
|
||||
1. Gather comprehensive information on any given topic
|
||||
2. Analyze data from multiple sources
|
||||
3. Provide well-structured research findings
|
||||
4. Cite sources and maintain accuracy
|
||||
5. Present findings in a clear, organized manner
|
||||
|
||||
Always provide detailed, factual information with proper context.""",
|
||||
)
|
||||
|
||||
analysis_agent = Agent(
|
||||
agent_name="Analysis-Agent",
|
||||
agent_description="Expert in data analysis, pattern recognition, and generating insights",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are an analysis specialist. Your role is to:
|
||||
1. Analyze data and identify patterns
|
||||
2. Generate actionable insights
|
||||
3. Create visualizations and summaries
|
||||
4. Provide statistical analysis
|
||||
5. Make data-driven recommendations
|
||||
|
||||
Focus on extracting meaningful insights from information.""",
|
||||
)
|
||||
|
||||
writing_agent = Agent(
|
||||
agent_name="Writing-Agent",
|
||||
agent_description="Expert in content creation, editing, and communication",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are a writing specialist. Your role is to:
|
||||
1. Create engaging, well-structured content
|
||||
2. Edit and improve existing text
|
||||
3. Adapt tone and style for different audiences
|
||||
4. Ensure clarity and coherence
|
||||
5. Follow best practices in writing
|
||||
|
||||
Always produce high-quality, professional content.""",
|
||||
)
|
||||
|
||||
code_agent = Agent(
|
||||
agent_name="Code-Agent",
|
||||
agent_description="Expert in programming, code review, and software development",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are a coding specialist. Your role is to:
|
||||
1. Write clean, efficient code
|
||||
2. Debug and fix issues
|
||||
3. Review and optimize code
|
||||
4. Explain programming concepts
|
||||
5. Follow best practices and standards
|
||||
|
||||
Always provide working, well-documented code.""",
|
||||
)
|
||||
|
||||
financial_agent = Agent(
|
||||
agent_name="Financial-Agent",
|
||||
agent_description="Expert in financial analysis, market research, and investment insights",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are a financial specialist. Your role is to:
|
||||
1. Analyze financial data and markets
|
||||
2. Provide investment insights
|
||||
3. Assess risk and opportunities
|
||||
4. Create financial reports
|
||||
5. Explain complex financial concepts
|
||||
|
||||
Always provide accurate, well-reasoned financial analysis.""",
|
||||
)
|
||||
|
||||
# Basic usage - individual agent addition
|
||||
deployer = AOP("MyAgentServer", verbose=True, port=5932)
|
||||
|
||||
agents = [
|
||||
research_agent,
|
||||
analysis_agent,
|
||||
writing_agent,
|
||||
code_agent,
|
||||
financial_agent,
|
||||
]
|
||||
|
||||
deployer.add_agents_batch(agents)
|
||||
|
||||
|
||||
deployer.run()
|
||||
@ -0,0 +1,73 @@
|
||||
from swarms import Agent, AgentRearrange
|
||||
|
||||
# Create specialized quantitative research agents
|
||||
weather_data_agent = Agent(
|
||||
agent_name="Weather-Data-Agent",
|
||||
agent_description="Expert in weather data collection, agricultural commodity research, and meteorological analysis",
|
||||
model_name="claude-sonnet-4-20250514",
|
||||
max_loops=1,
|
||||
system_prompt="""You are a quantitative weather data research specialist. Your role is to:
|
||||
1. Collect and analyze weather data from multiple sources (NOAA, Weather APIs, satellite data)
|
||||
2. Research agricultural commodity markets and their weather dependencies
|
||||
3. Identify weather patterns that historically impact crop yields and commodity prices
|
||||
4. Gather data on seasonal weather trends, precipitation patterns, temperature anomalies
|
||||
5. Research specific regions and their agricultural production cycles
|
||||
6. Collect data on extreme weather events and their market impact
|
||||
7. Analyze historical correlations between weather data and commodity price movements
|
||||
|
||||
Focus on actionable weather intelligence for trading opportunities. Always provide specific data points,
|
||||
timeframes, and geographic regions. Include confidence levels and data quality assessments.""",
|
||||
)
|
||||
|
||||
quant_analysis_agent = Agent(
|
||||
agent_name="Quant-Analysis-Agent",
|
||||
agent_description="Expert in quantitative analysis of weather patterns, arbitrage opportunities, and statistical modeling",
|
||||
model_name="claude-sonnet-4-20250514",
|
||||
max_loops=1,
|
||||
system_prompt="""You are a quantitative analysis specialist focused on weather-driven arbitrage opportunities. Your role is to:
|
||||
1. Analyze weather data correlations with commodity price movements
|
||||
2. Identify statistical arbitrage opportunities in agricultural futures markets
|
||||
3. Calculate risk-adjusted returns for weather-based trading strategies
|
||||
4. Model price impact scenarios based on weather forecasts
|
||||
5. Identify seasonal patterns and mean reversion opportunities
|
||||
6. Analyze basis risk and correlation breakdowns between weather and prices
|
||||
7. Calculate optimal position sizes and hedging ratios
|
||||
8. Assess market inefficiencies in weather-sensitive commodities
|
||||
|
||||
Focus on actionable trading signals with specific entry/exit criteria, risk metrics, and expected returns.
|
||||
Always provide quantitative justification and statistical confidence levels.""",
|
||||
)
|
||||
|
||||
trading_strategy_agent = Agent(
|
||||
agent_name="Trading-Strategy-Agent",
|
||||
agent_description="Expert in trading strategy development, risk assessment, and portfolio management for weather-driven arbitrage",
|
||||
model_name="claude-sonnet-4-20250514",
|
||||
max_loops=1,
|
||||
system_prompt="""You are a quantitative trading strategy specialist focused on weather-driven arbitrage opportunities. Your role is to:
|
||||
1. Develop comprehensive trading strategies based on weather data and commodity analysis
|
||||
2. Create detailed risk management frameworks for weather-sensitive positions
|
||||
3. Design portfolio allocation strategies for agricultural commodity arbitrage
|
||||
4. Develop hedging strategies to mitigate weather-related risks
|
||||
5. Create position sizing models based on volatility and correlation analysis
|
||||
6. Design entry and exit criteria for weather-based trades
|
||||
7. Develop contingency plans for unexpected weather events
|
||||
8. Create performance monitoring and evaluation frameworks
|
||||
|
||||
Focus on practical, implementable trading strategies with clear risk parameters,
|
||||
position management rules, and performance metrics. Always include specific trade setups,
|
||||
risk limits, and monitoring protocols.""",
|
||||
)
|
||||
|
||||
rearrange_system = AgentRearrange(
|
||||
agents=[
|
||||
weather_data_agent,
|
||||
quant_analysis_agent,
|
||||
trading_strategy_agent,
|
||||
],
|
||||
flow=f"{trading_strategy_agent.agent_name} -> {quant_analysis_agent.agent_name}, {weather_data_agent.agent_name}",
|
||||
max_loops=1,
|
||||
)
|
||||
|
||||
rearrange_system.run(
|
||||
"What are the best weather trades for the rest of the year 2025? Can we short wheat futures, corn futures, soybean futures, etc.?"
|
||||
)
|
||||
@ -0,0 +1,17 @@
|
||||
import json
|
||||
from swarms import AutoSwarmBuilder
|
||||
|
||||
swarm = AutoSwarmBuilder(
|
||||
name="My Swarm",
|
||||
description="A swarm of agents",
|
||||
verbose=True,
|
||||
max_loops=1,
|
||||
model_name="gpt-4o-mini",
|
||||
execution_type="return-agents",
|
||||
)
|
||||
|
||||
out = swarm.run(
|
||||
task="Create an accounting team to analyze crypto transactions, there must be 5 agents in the team with extremely extensive prompts. Make the prompts extremely detailed and specific and long and comprehensive. Make sure to include all the details of the task in the prompts."
|
||||
)
|
||||
|
||||
print(json.dumps(out, indent=4))
|
||||
@ -0,0 +1,19 @@
|
||||
from swarms import Agent
|
||||
|
||||
# Initialize the agent
|
||||
agent = Agent(
|
||||
agent_name="Quantitative-Trading-Agent",
|
||||
agent_description="Advanced quantitative trading and algorithmic analysis agent",
|
||||
model_name="claude-sonnet-4-2025051eqfewfwmfkmekef",
|
||||
dynamic_temperature_enabled=True,
|
||||
max_loops=1,
|
||||
dynamic_context_window=True,
|
||||
streaming_on=True,
|
||||
fallback_models=["gpt-4o-mini", "anthropic/claude-sonnet-4-5"],
|
||||
)
|
||||
|
||||
out = agent.run(
|
||||
task="What are the top five best energy stocks across nuclear, solar, gas, and other energy sources?",
|
||||
)
|
||||
|
||||
print(out)
|
||||
@ -0,0 +1,106 @@
|
||||
from swarms import Agent
|
||||
from swarms.structs.aop import (
|
||||
AOP,
|
||||
)
|
||||
|
||||
# Create specialized agents
|
||||
research_agent = Agent(
|
||||
agent_name="Research-Agent",
|
||||
agent_description="Expert in research, data collection, and information gathering",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are a research specialist. Your role is to:
|
||||
1. Gather comprehensive information on any given topic
|
||||
2. Analyze data from multiple sources
|
||||
3. Provide well-structured research findings
|
||||
4. Cite sources and maintain accuracy
|
||||
5. Present findings in a clear, organized manner
|
||||
|
||||
Always provide detailed, factual information with proper context.""",
|
||||
)
|
||||
|
||||
analysis_agent = Agent(
|
||||
agent_name="Analysis-Agent",
|
||||
agent_description="Expert in data analysis, pattern recognition, and generating insights",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are an analysis specialist. Your role is to:
|
||||
1. Analyze data and identify patterns
|
||||
2. Generate actionable insights
|
||||
3. Create visualizations and summaries
|
||||
4. Provide statistical analysis
|
||||
5. Make data-driven recommendations
|
||||
|
||||
Focus on extracting meaningful insights from information.""",
|
||||
)
|
||||
|
||||
writing_agent = Agent(
|
||||
agent_name="Writing-Agent",
|
||||
agent_description="Expert in content creation, editing, and communication",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are a writing specialist. Your role is to:
|
||||
1. Create engaging, well-structured content
|
||||
2. Edit and improve existing text
|
||||
3. Adapt tone and style for different audiences
|
||||
4. Ensure clarity and coherence
|
||||
5. Follow best practices in writing
|
||||
|
||||
Always produce high-quality, professional content.""",
|
||||
)
|
||||
|
||||
code_agent = Agent(
|
||||
agent_name="Code-Agent",
|
||||
agent_description="Expert in programming, code review, and software development",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are a coding specialist. Your role is to:
|
||||
1. Write clean, efficient code
|
||||
2. Debug and fix issues
|
||||
3. Review and optimize code
|
||||
4. Explain programming concepts
|
||||
5. Follow best practices and standards
|
||||
|
||||
Always provide working, well-documented code.""",
|
||||
)
|
||||
|
||||
financial_agent = Agent(
|
||||
agent_name="Financial-Agent",
|
||||
agent_description="Expert in financial analysis, market research, and investment insights",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
max_loops=1,
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
system_prompt="""You are a financial specialist. Your role is to:
|
||||
1. Analyze financial data and markets
|
||||
2. Provide investment insights
|
||||
3. Assess risk and opportunities
|
||||
4. Create financial reports
|
||||
5. Explain complex financial concepts
|
||||
|
||||
Always provide accurate, well-reasoned financial analysis.""",
|
||||
)
|
||||
|
||||
# Basic usage - individual agent addition
|
||||
deployer = AOP("MyAgentServer", verbose=True, port=5932)
|
||||
|
||||
agents = [
|
||||
research_agent,
|
||||
analysis_agent,
|
||||
writing_agent,
|
||||
code_agent,
|
||||
financial_agent,
|
||||
]
|
||||
|
||||
deployer.add_agents_batch(agents)
|
||||
|
||||
|
||||
deployer.run()
|
||||
@ -1,9 +0,0 @@
|
||||
from swarms.structs.agent_builder import AgentsBuilder
|
||||
|
||||
example_task = "Write a blog post about the benefits of using Swarms for AI agents."
|
||||
|
||||
agents_builder = AgentsBuilder()
|
||||
|
||||
agents = agents_builder.run(example_task)
|
||||
|
||||
print(agents)
|
||||
@ -0,0 +1,28 @@
|
||||
from swarms import Agent, SequentialWorkflow
|
||||
|
||||
# Agent 1: The Researcher
|
||||
researcher = Agent(
|
||||
agent_name="Researcher",
|
||||
system_prompt="Your job is to research the provided topic and provide a detailed summary.",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
)
|
||||
|
||||
# Agent 2: The Writer
|
||||
writer = Agent(
|
||||
agent_name="Writer",
|
||||
system_prompt="Your job is to take the research summary and write a beautiful, engaging blog post about it.",
|
||||
model_name="anthropic/claude-sonnet-4-5",
|
||||
top_p=None,
|
||||
dynamic_temperature_enabled=True,
|
||||
)
|
||||
|
||||
# Create a sequential workflow where the researcher's output feeds into the writer's input
|
||||
workflow = SequentialWorkflow(agents=[researcher, writer])
|
||||
|
||||
# Run the workflow on a task
|
||||
final_post = workflow.run(
|
||||
"Create a comprehensive and detailed report on Gold ETFs"
|
||||
)
|
||||
print(final_post)
|
||||
@ -1,122 +0,0 @@
|
||||
"""
|
||||
Example demonstrating the use of uvloop for running multiple agents concurrently.
|
||||
|
||||
This example shows how to use the new uvloop-based functions:
|
||||
- run_agents_concurrently_uvloop: For running multiple agents with the same task
|
||||
- run_agents_with_tasks_uvloop: For running agents with different tasks
|
||||
|
||||
uvloop provides significant performance improvements over standard asyncio,
|
||||
especially for I/O-bound operations and concurrent task execution.
|
||||
"""
|
||||
|
||||
import os
|
||||
from swarms.structs.multi_agent_exec import (
|
||||
run_agents_concurrently_uvloop,
|
||||
run_agents_with_tasks_uvloop,
|
||||
)
|
||||
from swarms.structs.agent import Agent
|
||||
|
||||
|
||||
def create_example_agents(num_agents: int = 3):
|
||||
"""Create example agents for demonstration."""
|
||||
agents = []
|
||||
for i in range(num_agents):
|
||||
agent = Agent(
|
||||
agent_name=f"Agent_{i+1}",
|
||||
system_prompt=f"You are Agent {i+1}, a helpful AI assistant.",
|
||||
model_name="gpt-4o-mini", # Using a lightweight model for examples
|
||||
max_loops=1,
|
||||
autosave=False,
|
||||
verbose=False,
|
||||
)
|
||||
agents.append(agent)
|
||||
return agents
|
||||
|
||||
|
||||
def example_same_task():
|
||||
"""Example: Running multiple agents with the same task using uvloop."""
|
||||
print("=== Example 1: Same Task for All Agents (uvloop) ===")
|
||||
|
||||
agents = create_example_agents(3)
|
||||
task = (
|
||||
"Write a one-sentence summary about artificial intelligence."
|
||||
)
|
||||
|
||||
print(f"Running {len(agents)} agents with the same task...")
|
||||
print(f"Task: {task}")
|
||||
|
||||
try:
|
||||
results = run_agents_concurrently_uvloop(agents, task)
|
||||
|
||||
print("\nResults:")
|
||||
for i, result in enumerate(results, 1):
|
||||
print(f"Agent {i}: {result}")
|
||||
|
||||
except Exception as e:
|
||||
print(f"Error: {e}")
|
||||
|
||||
|
||||
def example_different_tasks():
|
||||
"""Example: Running agents with different tasks using uvloop."""
|
||||
print(
|
||||
"\n=== Example 2: Different Tasks for Each Agent (uvloop) ==="
|
||||
)
|
||||
|
||||
agents = create_example_agents(3)
|
||||
tasks = [
|
||||
"Explain what machine learning is in simple terms.",
|
||||
"Describe the benefits of cloud computing.",
|
||||
"What are the main challenges in natural language processing?",
|
||||
]
|
||||
|
||||
print(f"Running {len(agents)} agents with different tasks...")
|
||||
|
||||
try:
|
||||
results = run_agents_with_tasks_uvloop(agents, tasks)
|
||||
|
||||
print("\nResults:")
|
||||
for i, (result, task) in enumerate(zip(results, tasks), 1):
|
||||
print(f"Agent {i} (Task: {task[:50]}...):")
|
||||
print(f" Response: {result}")
|
||||
print()
|
||||
|
||||
except Exception as e:
|
||||
print(f"Error: {e}")
|
||||
|
||||
|
||||
def performance_comparison():
|
||||
"""Demonstrate the performance benefit of uvloop vs standard asyncio."""
|
||||
print("\n=== Performance Comparison ===")
|
||||
|
||||
# Note: This is a conceptual example. In practice, you'd need to measure actual performance
|
||||
print("uvloop vs Standard asyncio:")
|
||||
print("• uvloop: Cython-based event loop, ~2-4x faster")
|
||||
print("• Better for I/O-bound operations")
|
||||
print("• Lower latency and higher throughput")
|
||||
print("• Especially beneficial for concurrent agent execution")
|
||||
print("• Automatic fallback to asyncio if uvloop unavailable")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Check if API key is available
|
||||
if not os.getenv("OPENAI_API_KEY"):
|
||||
print(
|
||||
"Please set your OPENAI_API_KEY environment variable to run this example."
|
||||
)
|
||||
print("Example: export OPENAI_API_KEY='your-api-key-here'")
|
||||
exit(1)
|
||||
|
||||
print("🚀 uvloop Multi-Agent Execution Examples")
|
||||
print("=" * 50)
|
||||
|
||||
# Run examples
|
||||
example_same_task()
|
||||
example_different_tasks()
|
||||
performance_comparison()
|
||||
|
||||
print("\n✅ Examples completed!")
|
||||
print("\nTo use uvloop functions in your code:")
|
||||
print(
|
||||
"from swarms.structs.multi_agent_exec import run_agents_concurrently_uvloop"
|
||||
)
|
||||
print("results = run_agents_concurrently_uvloop(agents, task)")
|
||||
@ -0,0 +1,30 @@
|
||||
from swarms.structs.agent import Agent
|
||||
from swarms.structs.multi_agent_exec import (
|
||||
run_agents_concurrently_uvloop,
|
||||
)
|
||||
|
||||
|
||||
def create_example_agents(num_agents: int = 3):
|
||||
"""Create example agents for demonstration."""
|
||||
agents = []
|
||||
for i in range(num_agents):
|
||||
agent = Agent(
|
||||
agent_name=f"Agent_{i+1}",
|
||||
system_prompt=f"You are Agent {i+1}, a helpful AI assistant.",
|
||||
model_name="gpt-4o-mini", # Using a lightweight model for examples
|
||||
max_loops=1,
|
||||
autosave=False,
|
||||
verbose=False,
|
||||
)
|
||||
agents.append(agent)
|
||||
return agents
|
||||
|
||||
|
||||
agents = create_example_agents(3)
|
||||
|
||||
task = "Write a one-sentence summary about artificial intelligence."
|
||||
|
||||
|
||||
results = run_agents_concurrently_uvloop(agents, task)
|
||||
|
||||
print(results)
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue