Aksh Parekh
1 day ago
committed by
GitHub
commit
49cf716e2a
@ -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/)
|
||||
@ -1,336 +0,0 @@
|
||||
# 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.
|
||||
@ -1,11 +0,0 @@
|
||||
import json
|
||||
|
||||
from swarms.structs.aop import AOPCluster
|
||||
|
||||
aop_cluster = AOPCluster(
|
||||
urls=["http://localhost:8000/mcp"],
|
||||
transport="streamable-http",
|
||||
)
|
||||
|
||||
print(json.dumps(aop_cluster.get_tools(output_type="dict"), indent=4))
|
||||
print(aop_cluster.find_tool_by_server_name("Research-Agent"))
|
||||
@ -1,318 +0,0 @@
|
||||
# AOP Server Setup Example
|
||||
|
||||
This example demonstrates how to set up an AOP (Agent Orchestration Protocol) server with multiple specialized agents.
|
||||
|
||||
## Complete 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.""",
|
||||
)
|
||||
|
||||
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.""",
|
||||
)
|
||||
|
||||
# Create AOP instance
|
||||
deployer = AOP(
|
||||
server_name="MyAgentServer",
|
||||
port=8000,
|
||||
verbose=True,
|
||||
log_level="INFO"
|
||||
)
|
||||
|
||||
# Add all agents at once
|
||||
agents = [
|
||||
research_agent,
|
||||
analysis_agent,
|
||||
writing_agent,
|
||||
code_agent,
|
||||
financial_agent,
|
||||
]
|
||||
|
||||
tool_names = deployer.add_agents_batch(agents)
|
||||
print(f"Added {len(tool_names)} agents: {tool_names}")
|
||||
|
||||
# Display server information
|
||||
server_info = deployer.get_server_info()
|
||||
print(f"Server: {server_info['server_name']}")
|
||||
print(f"Total tools: {server_info['total_tools']}")
|
||||
print(f"Available tools: {server_info['tools']}")
|
||||
|
||||
# Start the server
|
||||
print("Starting AOP server...")
|
||||
deployer.run()
|
||||
```
|
||||
|
||||
## Running the Server
|
||||
|
||||
1. Save the code above to a file (e.g., `aop_server.py`)
|
||||
2. Install required dependencies:
|
||||
```bash
|
||||
pip install swarms
|
||||
```
|
||||
3. Run the server:
|
||||
```bash
|
||||
python aop_server.py
|
||||
```
|
||||
|
||||
The server will start on `http://localhost:8000` and make all agents available as MCP tools.
|
||||
|
||||
## Tool Usage Examples
|
||||
|
||||
Once the server is running, you can call the tools using MCP clients:
|
||||
|
||||
### Research Agent
|
||||
```python
|
||||
# Call the research agent
|
||||
result = research_tool(task="Research the latest AI trends in 2024")
|
||||
print(result)
|
||||
```
|
||||
|
||||
### Analysis Agent with Image
|
||||
```python
|
||||
# Call the analysis agent with an image
|
||||
result = analysis_tool(
|
||||
task="Analyze this chart and provide insights",
|
||||
img="path/to/chart.png"
|
||||
)
|
||||
print(result)
|
||||
```
|
||||
|
||||
### Writing Agent with Multiple Images
|
||||
```python
|
||||
# Call the writing agent with multiple images
|
||||
result = writing_tool(
|
||||
task="Write a comprehensive report based on these images",
|
||||
imgs=["image1.jpg", "image2.jpg", "image3.jpg"]
|
||||
)
|
||||
print(result)
|
||||
```
|
||||
|
||||
### Code Agent with Validation
|
||||
```python
|
||||
# Call the code agent with expected output
|
||||
result = code_tool(
|
||||
task="Debug this Python function",
|
||||
correct_answer="Expected output: Hello World"
|
||||
)
|
||||
print(result)
|
||||
```
|
||||
|
||||
### Financial Agent
|
||||
```python
|
||||
# Call the financial agent
|
||||
result = financial_tool(task="Analyze the current market trends for tech stocks")
|
||||
print(result)
|
||||
```
|
||||
|
||||
## Response Format
|
||||
|
||||
All tools return a standardized response:
|
||||
|
||||
```json
|
||||
{
|
||||
"result": "The agent's response to the task",
|
||||
"success": true,
|
||||
"error": null
|
||||
}
|
||||
```
|
||||
|
||||
## Advanced Configuration
|
||||
|
||||
### Custom Timeouts and Retries
|
||||
|
||||
```python
|
||||
# Add agent with custom configuration
|
||||
deployer.add_agent(
|
||||
agent=research_agent,
|
||||
tool_name="custom_research_tool",
|
||||
tool_description="Research tool with extended timeout",
|
||||
timeout=120, # 2 minutes
|
||||
max_retries=5,
|
||||
verbose=True
|
||||
)
|
||||
```
|
||||
|
||||
### Custom Input/Output Schemas
|
||||
|
||||
```python
|
||||
# Define custom schemas
|
||||
custom_input_schema = {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"task": {"type": "string", "description": "The research task"},
|
||||
"sources": {
|
||||
"type": "array",
|
||||
"items": {"type": "string"},
|
||||
"description": "Specific sources to research"
|
||||
},
|
||||
"depth": {
|
||||
"type": "string",
|
||||
"enum": ["shallow", "medium", "deep"],
|
||||
"description": "Research depth level"
|
||||
}
|
||||
},
|
||||
"required": ["task"]
|
||||
}
|
||||
|
||||
# Add agent with custom schemas
|
||||
deployer.add_agent(
|
||||
agent=research_agent,
|
||||
tool_name="advanced_research_tool",
|
||||
input_schema=custom_input_schema,
|
||||
timeout=60
|
||||
)
|
||||
```
|
||||
|
||||
## Monitoring and Debugging
|
||||
|
||||
### Enable Verbose Logging
|
||||
|
||||
```python
|
||||
deployer = AOP(
|
||||
server_name="DebugServer",
|
||||
verbose=True,
|
||||
traceback_enabled=True,
|
||||
log_level="DEBUG"
|
||||
)
|
||||
```
|
||||
|
||||
### Check Server Status
|
||||
|
||||
```python
|
||||
# List all registered agents
|
||||
agents = deployer.list_agents()
|
||||
print(f"Registered agents: {agents}")
|
||||
|
||||
# Get detailed agent information
|
||||
for agent_name in agents:
|
||||
info = deployer.get_agent_info(agent_name)
|
||||
print(f"Agent {agent_name}: {info}")
|
||||
|
||||
# Get server information
|
||||
server_info = deployer.get_server_info()
|
||||
print(f"Server info: {server_info}")
|
||||
```
|
||||
|
||||
## Production Deployment
|
||||
|
||||
### External Access
|
||||
|
||||
```python
|
||||
deployer = AOP(
|
||||
server_name="ProductionServer",
|
||||
host="0.0.0.0", # Allow external connections
|
||||
port=8000,
|
||||
verbose=False, # Disable verbose logging in production
|
||||
log_level="WARNING"
|
||||
)
|
||||
```
|
||||
|
||||
### Multiple Servers
|
||||
|
||||
```python
|
||||
# Server 1: Research and Analysis
|
||||
research_deployer = AOP("ResearchServer", port=8000)
|
||||
research_deployer.add_agent(research_agent)
|
||||
research_deployer.add_agent(analysis_agent)
|
||||
|
||||
# Server 2: Writing and Code
|
||||
content_deployer = AOP("ContentServer", port=8001)
|
||||
content_deployer.add_agent(writing_agent)
|
||||
content_deployer.add_agent(code_agent)
|
||||
|
||||
# Server 3: Financial
|
||||
finance_deployer = AOP("FinanceServer", port=8002)
|
||||
finance_deployer.add_agent(financial_agent)
|
||||
|
||||
# Start all servers
|
||||
import threading
|
||||
|
||||
threading.Thread(target=research_deployer.run).start()
|
||||
threading.Thread(target=content_deployer.run).start()
|
||||
threading.Thread(target=finance_deployer.run).start()
|
||||
```
|
||||
|
||||
This example demonstrates a complete AOP server setup with multiple specialized agents, proper configuration, and production-ready deployment options.
|
||||
@ -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,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,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,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)
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,140 @@
|
||||
"""
|
||||
Custom docstring parser implementation to replace the docstring_parser package.
|
||||
|
||||
This module provides a simple docstring parser that extracts parameter information
|
||||
and descriptions from Python docstrings in Google/NumPy style format.
|
||||
"""
|
||||
|
||||
import re
|
||||
from typing import List, Optional, NamedTuple
|
||||
|
||||
|
||||
class DocstringParam(NamedTuple):
|
||||
"""Represents a parameter in a docstring."""
|
||||
|
||||
arg_name: str
|
||||
description: str
|
||||
|
||||
|
||||
class DocstringInfo(NamedTuple):
|
||||
"""Represents parsed docstring information."""
|
||||
|
||||
short_description: Optional[str]
|
||||
params: List[DocstringParam]
|
||||
|
||||
|
||||
def parse(docstring: str) -> DocstringInfo:
|
||||
"""
|
||||
Parse a docstring and extract parameter information and description.
|
||||
|
||||
Args:
|
||||
docstring (str): The docstring to parse.
|
||||
|
||||
Returns:
|
||||
DocstringInfo: Parsed docstring information containing short description and parameters.
|
||||
"""
|
||||
if not docstring or not docstring.strip():
|
||||
return DocstringInfo(short_description=None, params=[])
|
||||
|
||||
# Clean up the docstring
|
||||
lines = [line.strip() for line in docstring.strip().split("\n")]
|
||||
|
||||
# Extract short description (first non-empty line that's not a section header)
|
||||
short_description = None
|
||||
for line in lines:
|
||||
if line and not line.startswith(
|
||||
(
|
||||
"Args:",
|
||||
"Parameters:",
|
||||
"Returns:",
|
||||
"Yields:",
|
||||
"Raises:",
|
||||
"Note:",
|
||||
"Example:",
|
||||
"Examples:",
|
||||
)
|
||||
):
|
||||
short_description = line
|
||||
break
|
||||
|
||||
# Extract parameters
|
||||
params = []
|
||||
|
||||
# Look for Args: or Parameters: section
|
||||
in_args_section = False
|
||||
current_param = None
|
||||
|
||||
for line in lines:
|
||||
# Check if we're entering the Args/Parameters section
|
||||
if line.lower().startswith(("args:", "parameters:")):
|
||||
in_args_section = True
|
||||
continue
|
||||
|
||||
# Check if we're leaving the Args/Parameters section
|
||||
if (
|
||||
in_args_section
|
||||
and line
|
||||
and not line.startswith(" ")
|
||||
and not line.startswith("\t")
|
||||
):
|
||||
# Check if this is a new section header
|
||||
if line.lower().startswith(
|
||||
(
|
||||
"returns:",
|
||||
"yields:",
|
||||
"raises:",
|
||||
"note:",
|
||||
"example:",
|
||||
"examples:",
|
||||
"see also:",
|
||||
"see_also:",
|
||||
)
|
||||
):
|
||||
in_args_section = False
|
||||
if current_param:
|
||||
params.append(current_param)
|
||||
current_param = None
|
||||
continue
|
||||
|
||||
if in_args_section and line:
|
||||
# Check if this line starts a new parameter (starts with parameter name)
|
||||
# Pattern: param_name (type): description
|
||||
param_match = re.match(
|
||||
r"^(\w+)\s*(?:\([^)]*\))?\s*:\s*(.+)$", line
|
||||
)
|
||||
if param_match:
|
||||
# Save previous parameter if exists
|
||||
if current_param:
|
||||
params.append(current_param)
|
||||
|
||||
param_name = param_match.group(1)
|
||||
param_desc = param_match.group(2).strip()
|
||||
current_param = DocstringParam(
|
||||
arg_name=param_name, description=param_desc
|
||||
)
|
||||
elif current_param and (
|
||||
line.startswith(" ") or line.startswith("\t")
|
||||
):
|
||||
# This is a continuation of the current parameter description
|
||||
current_param = DocstringParam(
|
||||
arg_name=current_param.arg_name,
|
||||
description=current_param.description
|
||||
+ " "
|
||||
+ line.strip(),
|
||||
)
|
||||
elif not line.startswith(" ") and not line.startswith(
|
||||
"\t"
|
||||
):
|
||||
# This might be a new section, stop processing args
|
||||
in_args_section = False
|
||||
if current_param:
|
||||
params.append(current_param)
|
||||
current_param = None
|
||||
|
||||
# Add the last parameter if it exists
|
||||
if current_param:
|
||||
params.append(current_param)
|
||||
|
||||
return DocstringInfo(
|
||||
short_description=short_description, params=params
|
||||
)
|
||||
File diff suppressed because it is too large
Load Diff
Binary file not shown.
|
After Width: | Height: | Size: 175 KiB |
|
After Width: | Height: | Size: 178 KiB |
|
After Width: | Height: | Size: 130 KiB |
|
After Width: | Height: | Size: 75 KiB |
|
After Width: | Height: | Size: 66 KiB |
|
|
After Width: | Height: | Size: 15 KiB |
|
Before Width: | Height: | Size: 19 MiB After Width: | Height: | Size: 19 MiB |
|
Before Width: | Height: | Size: 492 KiB After Width: | Height: | Size: 492 KiB |
@ -0,0 +1,293 @@
|
||||
"""
|
||||
Tests for bug #1115 fix in AutoSwarmBuilder.
|
||||
|
||||
This test module verifies the fix for AttributeError when creating agents
|
||||
from AgentSpec Pydantic models in AutoSwarmBuilder.
|
||||
|
||||
Bug: https://github.com/kyegomez/swarms/issues/1115
|
||||
"""
|
||||
|
||||
import pytest
|
||||
|
||||
from swarms.structs.agent import Agent
|
||||
from swarms.structs.auto_swarm_builder import (
|
||||
AgentSpec,
|
||||
AutoSwarmBuilder,
|
||||
)
|
||||
from swarms.structs.ma_utils import set_random_models_for_agents
|
||||
|
||||
|
||||
class TestAutoSwarmBuilderFix:
|
||||
"""Tests for bug #1115 fix in AutoSwarmBuilder."""
|
||||
|
||||
def test_create_agents_from_specs_with_dict(self):
|
||||
"""Test that create_agents_from_specs handles dict input correctly."""
|
||||
builder = AutoSwarmBuilder()
|
||||
|
||||
# Create specs as a dictionary
|
||||
specs = {
|
||||
"agents": [
|
||||
{
|
||||
"agent_name": "test_agent_1",
|
||||
"description": "Test agent 1 description",
|
||||
"system_prompt": "You are a helpful assistant",
|
||||
"model_name": "gpt-4o-mini",
|
||||
"max_loops": 1,
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
agents = builder.create_agents_from_specs(specs)
|
||||
|
||||
# Verify agents were created correctly
|
||||
assert len(agents) == 1
|
||||
assert isinstance(agents[0], Agent)
|
||||
assert agents[0].agent_name == "test_agent_1"
|
||||
|
||||
# Verify description was mapped to agent_description
|
||||
assert hasattr(agents[0], "agent_description")
|
||||
assert (
|
||||
agents[0].agent_description == "Test agent 1 description"
|
||||
)
|
||||
|
||||
def test_create_agents_from_specs_with_pydantic(self):
|
||||
"""Test that create_agents_from_specs handles Pydantic model input correctly.
|
||||
|
||||
This is the main test for bug #1115 - it verifies that AgentSpec
|
||||
Pydantic models can be unpacked correctly.
|
||||
"""
|
||||
builder = AutoSwarmBuilder()
|
||||
|
||||
# Create specs as Pydantic AgentSpec objects
|
||||
agent_spec = AgentSpec(
|
||||
agent_name="test_agent_pydantic",
|
||||
description="Pydantic test agent",
|
||||
system_prompt="You are a helpful assistant",
|
||||
model_name="gpt-4o-mini",
|
||||
max_loops=1,
|
||||
)
|
||||
|
||||
specs = {"agents": [agent_spec]}
|
||||
|
||||
agents = builder.create_agents_from_specs(specs)
|
||||
|
||||
# Verify agents were created correctly
|
||||
assert len(agents) == 1
|
||||
assert isinstance(agents[0], Agent)
|
||||
assert agents[0].agent_name == "test_agent_pydantic"
|
||||
|
||||
# Verify description was mapped to agent_description
|
||||
assert hasattr(agents[0], "agent_description")
|
||||
assert agents[0].agent_description == "Pydantic test agent"
|
||||
|
||||
def test_parameter_name_mapping(self):
|
||||
"""Test that 'description' field maps to 'agent_description' correctly."""
|
||||
builder = AutoSwarmBuilder()
|
||||
|
||||
# Test with dict that has 'description'
|
||||
specs = {
|
||||
"agents": [
|
||||
{
|
||||
"agent_name": "mapping_test",
|
||||
"description": "This should map to agent_description",
|
||||
"system_prompt": "You are helpful",
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
agents = builder.create_agents_from_specs(specs)
|
||||
|
||||
assert len(agents) == 1
|
||||
agent = agents[0]
|
||||
|
||||
# Verify description was mapped
|
||||
assert hasattr(agent, "agent_description")
|
||||
assert (
|
||||
agent.agent_description
|
||||
== "This should map to agent_description"
|
||||
)
|
||||
|
||||
def test_create_agents_from_specs_mixed_input(self):
|
||||
"""Test that create_agents_from_specs handles mixed dict and Pydantic input."""
|
||||
builder = AutoSwarmBuilder()
|
||||
|
||||
# Mix of dict and Pydantic objects
|
||||
dict_spec = {
|
||||
"agent_name": "dict_agent",
|
||||
"description": "Dict agent description",
|
||||
"system_prompt": "You are helpful",
|
||||
}
|
||||
|
||||
pydantic_spec = AgentSpec(
|
||||
agent_name="pydantic_agent",
|
||||
description="Pydantic agent description",
|
||||
system_prompt="You are smart",
|
||||
)
|
||||
|
||||
specs = {"agents": [dict_spec, pydantic_spec]}
|
||||
|
||||
agents = builder.create_agents_from_specs(specs)
|
||||
|
||||
# Verify both agents were created
|
||||
assert len(agents) == 2
|
||||
assert all(isinstance(agent, Agent) for agent in agents)
|
||||
|
||||
# Verify both have correct descriptions
|
||||
dict_agent = next(
|
||||
a for a in agents if a.agent_name == "dict_agent"
|
||||
)
|
||||
pydantic_agent = next(
|
||||
a for a in agents if a.agent_name == "pydantic_agent"
|
||||
)
|
||||
|
||||
assert (
|
||||
dict_agent.agent_description == "Dict agent description"
|
||||
)
|
||||
assert (
|
||||
pydantic_agent.agent_description
|
||||
== "Pydantic agent description"
|
||||
)
|
||||
|
||||
def test_set_random_models_for_agents_with_valid_agents(
|
||||
self,
|
||||
):
|
||||
"""Test set_random_models_for_agents with proper Agent objects."""
|
||||
# Create proper Agent objects
|
||||
agents = [
|
||||
Agent(
|
||||
agent_name="agent1",
|
||||
system_prompt="You are agent 1",
|
||||
max_loops=1,
|
||||
),
|
||||
Agent(
|
||||
agent_name="agent2",
|
||||
system_prompt="You are agent 2",
|
||||
max_loops=1,
|
||||
),
|
||||
]
|
||||
|
||||
# Set random models
|
||||
model_names = ["gpt-4o-mini", "gpt-4o", "claude-3-5-sonnet"]
|
||||
result = set_random_models_for_agents(
|
||||
agents=agents, model_names=model_names
|
||||
)
|
||||
|
||||
# Verify results
|
||||
assert len(result) == 2
|
||||
assert all(isinstance(agent, Agent) for agent in result)
|
||||
assert all(hasattr(agent, "model_name") for agent in result)
|
||||
assert all(
|
||||
agent.model_name in model_names for agent in result
|
||||
)
|
||||
|
||||
def test_set_random_models_for_agents_with_single_agent(
|
||||
self,
|
||||
):
|
||||
"""Test set_random_models_for_agents with a single agent."""
|
||||
agent = Agent(
|
||||
agent_name="single_agent",
|
||||
system_prompt="You are helpful",
|
||||
max_loops=1,
|
||||
)
|
||||
|
||||
model_names = ["gpt-4o-mini", "gpt-4o"]
|
||||
result = set_random_models_for_agents(
|
||||
agents=agent, model_names=model_names
|
||||
)
|
||||
|
||||
assert isinstance(result, Agent)
|
||||
assert hasattr(result, "model_name")
|
||||
assert result.model_name in model_names
|
||||
|
||||
def test_set_random_models_for_agents_with_none(self):
|
||||
"""Test set_random_models_for_agents with None returns random model name."""
|
||||
model_names = ["gpt-4o-mini", "gpt-4o", "claude-3-5-sonnet"]
|
||||
result = set_random_models_for_agents(
|
||||
agents=None, model_names=model_names
|
||||
)
|
||||
|
||||
assert isinstance(result, str)
|
||||
assert result in model_names
|
||||
|
||||
@pytest.mark.skip(
|
||||
reason="This test requires API key and makes LLM calls"
|
||||
)
|
||||
def test_auto_swarm_builder_return_agents_objects_integration(
|
||||
self,
|
||||
):
|
||||
"""Integration test for AutoSwarmBuilder with execution_type='return-agents-objects'.
|
||||
|
||||
This test requires OPENAI_API_KEY and makes actual LLM calls.
|
||||
Run manually with: pytest -k test_auto_swarm_builder_return_agents_objects_integration -v
|
||||
"""
|
||||
builder = AutoSwarmBuilder(
|
||||
execution_type="return-agents-objects",
|
||||
model_name="gpt-4o-mini",
|
||||
max_loops=1,
|
||||
verbose=False,
|
||||
)
|
||||
|
||||
agents = builder.run(
|
||||
"Create a team of 2 data analysis agents with specific roles"
|
||||
)
|
||||
|
||||
# Verify agents were created
|
||||
assert isinstance(agents, list)
|
||||
assert len(agents) >= 1
|
||||
assert all(isinstance(agent, Agent) for agent in agents)
|
||||
assert all(hasattr(agent, "agent_name") for agent in agents)
|
||||
assert all(
|
||||
hasattr(agent, "agent_description") for agent in agents
|
||||
)
|
||||
|
||||
def test_agent_spec_to_agent_all_fields(self):
|
||||
"""Test that all AgentSpec fields are properly passed to Agent."""
|
||||
builder = AutoSwarmBuilder()
|
||||
|
||||
agent_spec = AgentSpec(
|
||||
agent_name="full_test_agent",
|
||||
description="Full test description",
|
||||
system_prompt="You are a comprehensive test agent",
|
||||
model_name="gpt-4o-mini",
|
||||
auto_generate_prompt=False,
|
||||
max_tokens=4096,
|
||||
temperature=0.7,
|
||||
role="worker",
|
||||
max_loops=3,
|
||||
goal="Test all parameters",
|
||||
)
|
||||
|
||||
agents = builder.create_agents_from_specs(
|
||||
{"agents": [agent_spec]}
|
||||
)
|
||||
|
||||
assert len(agents) == 1
|
||||
agent = agents[0]
|
||||
|
||||
# Verify all fields were set
|
||||
assert agent.agent_name == "full_test_agent"
|
||||
assert agent.agent_description == "Full test description"
|
||||
# Agent may modify system_prompt by adding additional instructions
|
||||
assert (
|
||||
"You are a comprehensive test agent"
|
||||
in agent.system_prompt
|
||||
)
|
||||
assert agent.max_loops == 3
|
||||
assert agent.max_tokens == 4096
|
||||
assert agent.temperature == 0.7
|
||||
|
||||
def test_create_agents_from_specs_empty_list(self):
|
||||
"""Test that create_agents_from_specs handles empty agent list."""
|
||||
builder = AutoSwarmBuilder()
|
||||
|
||||
specs = {"agents": []}
|
||||
|
||||
agents = builder.create_agents_from_specs(specs)
|
||||
|
||||
assert isinstance(agents, list)
|
||||
assert len(agents) == 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Run tests with pytest
|
||||
pytest.main([__file__, "-v", "--tb=short"])
|
||||
@ -0,0 +1,150 @@
|
||||
from pydantic import BaseModel
|
||||
from swarms.tools.pydantic_to_json import (
|
||||
base_model_to_openai_function,
|
||||
multi_base_model_to_openai_function,
|
||||
)
|
||||
from swarms.tools.base_tool import BaseTool
|
||||
|
||||
|
||||
# Test Pydantic model
|
||||
class TestModel(BaseModel):
|
||||
"""A test model for validation."""
|
||||
|
||||
name: str
|
||||
age: int
|
||||
email: str = "test@example.com"
|
||||
|
||||
|
||||
def test_base_model_to_openai_function():
|
||||
"""Test that base_model_to_openai_function accepts output_str parameter."""
|
||||
print(
|
||||
"Testing base_model_to_openai_function with output_str=False..."
|
||||
)
|
||||
result_dict = base_model_to_openai_function(
|
||||
TestModel, output_str=False
|
||||
)
|
||||
print(f"✓ Dict result type: {type(result_dict)}")
|
||||
print(f"✓ Dict result keys: {list(result_dict.keys())}")
|
||||
|
||||
print(
|
||||
"\nTesting base_model_to_openai_function with output_str=True..."
|
||||
)
|
||||
result_str = base_model_to_openai_function(
|
||||
TestModel, output_str=True
|
||||
)
|
||||
print(f"✓ String result type: {type(result_str)}")
|
||||
print(f"✓ String result preview: {result_str[:100]}...")
|
||||
|
||||
|
||||
def test_multi_base_model_to_openai_function():
|
||||
"""Test that multi_base_model_to_openai_function handles output_str correctly."""
|
||||
print(
|
||||
"\nTesting multi_base_model_to_openai_function with output_str=False..."
|
||||
)
|
||||
result_dict = multi_base_model_to_openai_function(
|
||||
[TestModel], output_str=False
|
||||
)
|
||||
print(f"✓ Dict result type: {type(result_dict)}")
|
||||
print(f"✓ Dict result keys: {list(result_dict.keys())}")
|
||||
|
||||
print(
|
||||
"\nTesting multi_base_model_to_openai_function with output_str=True..."
|
||||
)
|
||||
result_str = multi_base_model_to_openai_function(
|
||||
[TestModel], output_str=True
|
||||
)
|
||||
print(f"✓ String result type: {type(result_str)}")
|
||||
print(f"✓ String result preview: {result_str[:100]}...")
|
||||
|
||||
|
||||
def test_base_tool_methods():
|
||||
"""Test that BaseTool methods handle output_str parameter correctly."""
|
||||
print(
|
||||
"\nTesting BaseTool.base_model_to_dict with output_str=False..."
|
||||
)
|
||||
tool = BaseTool()
|
||||
result_dict = tool.base_model_to_dict(TestModel, output_str=False)
|
||||
print(f"✓ Dict result type: {type(result_dict)}")
|
||||
print(f"✓ Dict result keys: {list(result_dict.keys())}")
|
||||
|
||||
print(
|
||||
"\nTesting BaseTool.base_model_to_dict with output_str=True..."
|
||||
)
|
||||
result_str = tool.base_model_to_dict(TestModel, output_str=True)
|
||||
print(f"✓ String result type: {type(result_str)}")
|
||||
print(f"✓ String result preview: {result_str[:100]}...")
|
||||
|
||||
print(
|
||||
"\nTesting BaseTool.multi_base_models_to_dict with output_str=False..."
|
||||
)
|
||||
result_dict = tool.multi_base_models_to_dict(
|
||||
[TestModel], output_str=False
|
||||
)
|
||||
print(f"✓ Dict result type: {type(result_dict)}")
|
||||
print(f"✓ Dict result length: {len(result_dict)}")
|
||||
|
||||
print(
|
||||
"\nTesting BaseTool.multi_base_models_to_dict with output_str=True..."
|
||||
)
|
||||
result_str = tool.multi_base_models_to_dict(
|
||||
[TestModel], output_str=True
|
||||
)
|
||||
print(f"✓ String result type: {type(result_str)}")
|
||||
print(f"✓ String result preview: {result_str[:100]}...")
|
||||
|
||||
|
||||
def test_agent_integration():
|
||||
"""Test that the Agent class can use the fixed methods without errors."""
|
||||
print("\nTesting Agent integration...")
|
||||
try:
|
||||
from swarms import Agent
|
||||
|
||||
# Create a simple agent with a tool schema
|
||||
agent = Agent(
|
||||
model_name="gpt-4o-mini",
|
||||
tool_schema=TestModel,
|
||||
max_loops=1,
|
||||
verbose=True,
|
||||
)
|
||||
|
||||
# This should not raise an error anymore
|
||||
agent.handle_tool_schema_ops()
|
||||
print(
|
||||
"✓ Agent.handle_tool_schema_ops() completed successfully"
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
print(f"✗ Agent integration failed: {e}")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
print("=" * 60)
|
||||
print("Testing output_str parameter fix")
|
||||
print("=" * 60)
|
||||
|
||||
try:
|
||||
test_base_model_to_openai_function()
|
||||
test_multi_base_model_to_openai_function()
|
||||
test_base_tool_methods()
|
||||
|
||||
if test_agent_integration():
|
||||
print("\n" + "=" * 60)
|
||||
print(
|
||||
"✅ All tests passed! The output_str parameter fix is working correctly."
|
||||
)
|
||||
print("=" * 60)
|
||||
else:
|
||||
print("\n" + "=" * 60)
|
||||
print(
|
||||
"❌ Some tests failed. Please check the implementation."
|
||||
)
|
||||
print("=" * 60)
|
||||
|
||||
except Exception as e:
|
||||
print(f"\n❌ Test failed with error: {e}")
|
||||
import traceback
|
||||
|
||||
traceback.print_exc()
|
||||
@ -0,0 +1,431 @@
|
||||
"""
|
||||
Test suite for the custom docstring parser implementation.
|
||||
|
||||
This module contains comprehensive tests to ensure the docstring parser
|
||||
works correctly with various docstring formats and edge cases.
|
||||
"""
|
||||
|
||||
import pytest
|
||||
from swarms.utils.docstring_parser import (
|
||||
parse,
|
||||
DocstringParam,
|
||||
)
|
||||
|
||||
|
||||
class TestDocstringParser:
|
||||
"""Test cases for the docstring parser functionality."""
|
||||
|
||||
def test_empty_docstring(self):
|
||||
"""Test parsing of empty docstring."""
|
||||
result = parse("")
|
||||
assert result.short_description is None
|
||||
assert result.params == []
|
||||
|
||||
def test_none_docstring(self):
|
||||
"""Test parsing of None docstring."""
|
||||
result = parse(None)
|
||||
assert result.short_description is None
|
||||
assert result.params == []
|
||||
|
||||
def test_whitespace_only_docstring(self):
|
||||
"""Test parsing of whitespace-only docstring."""
|
||||
result = parse(" \n \t \n ")
|
||||
assert result.short_description is None
|
||||
assert result.params == []
|
||||
|
||||
def test_simple_docstring_no_args(self):
|
||||
"""Test parsing of simple docstring without Args section."""
|
||||
docstring = """
|
||||
This is a simple function.
|
||||
|
||||
Returns:
|
||||
str: A simple string
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert (
|
||||
result.short_description == "This is a simple function."
|
||||
)
|
||||
assert result.params == []
|
||||
|
||||
def test_docstring_with_args(self):
|
||||
"""Test parsing of docstring with Args section."""
|
||||
docstring = """
|
||||
This is a test function.
|
||||
|
||||
Args:
|
||||
param1 (str): First parameter
|
||||
param2 (int): Second parameter
|
||||
param3 (bool, optional): Third parameter with default
|
||||
|
||||
Returns:
|
||||
str: Return value description
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert result.short_description == "This is a test function."
|
||||
assert len(result.params) == 3
|
||||
assert result.params[0] == DocstringParam(
|
||||
"param1", "First parameter"
|
||||
)
|
||||
assert result.params[1] == DocstringParam(
|
||||
"param2", "Second parameter"
|
||||
)
|
||||
assert result.params[2] == DocstringParam(
|
||||
"param3", "Third parameter with default"
|
||||
)
|
||||
|
||||
def test_docstring_with_parameters_section(self):
|
||||
"""Test parsing of docstring with Parameters section."""
|
||||
docstring = """
|
||||
Another test function.
|
||||
|
||||
Parameters:
|
||||
name (str): The name parameter
|
||||
age (int): The age parameter
|
||||
|
||||
Returns:
|
||||
None: Nothing is returned
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert result.short_description == "Another test function."
|
||||
assert len(result.params) == 2
|
||||
assert result.params[0] == DocstringParam(
|
||||
"name", "The name parameter"
|
||||
)
|
||||
assert result.params[1] == DocstringParam(
|
||||
"age", "The age parameter"
|
||||
)
|
||||
|
||||
def test_docstring_with_multiline_param_description(self):
|
||||
"""Test parsing of docstring with multiline parameter descriptions."""
|
||||
docstring = """
|
||||
Function with multiline descriptions.
|
||||
|
||||
Args:
|
||||
param1 (str): This is a very long description
|
||||
that spans multiple lines and should be
|
||||
properly concatenated.
|
||||
param2 (int): Short description
|
||||
|
||||
Returns:
|
||||
str: Result
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert (
|
||||
result.short_description
|
||||
== "Function with multiline descriptions."
|
||||
)
|
||||
assert len(result.params) == 2
|
||||
expected_desc = "This is a very long description that spans multiple lines and should be properly concatenated."
|
||||
assert result.params[0] == DocstringParam(
|
||||
"param1", expected_desc
|
||||
)
|
||||
assert result.params[1] == DocstringParam(
|
||||
"param2", "Short description"
|
||||
)
|
||||
|
||||
def test_docstring_without_type_annotations(self):
|
||||
"""Test parsing of docstring without type annotations."""
|
||||
docstring = """
|
||||
Function without type annotations.
|
||||
|
||||
Args:
|
||||
param1: First parameter without type
|
||||
param2: Second parameter without type
|
||||
|
||||
Returns:
|
||||
str: Result
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert (
|
||||
result.short_description
|
||||
== "Function without type annotations."
|
||||
)
|
||||
assert len(result.params) == 2
|
||||
assert result.params[0] == DocstringParam(
|
||||
"param1", "First parameter without type"
|
||||
)
|
||||
assert result.params[1] == DocstringParam(
|
||||
"param2", "Second parameter without type"
|
||||
)
|
||||
|
||||
def test_pydantic_style_docstring(self):
|
||||
"""Test parsing of Pydantic-style docstring."""
|
||||
docstring = """
|
||||
Convert a Pydantic model to a dictionary representation of functions.
|
||||
|
||||
Args:
|
||||
pydantic_type (type[BaseModel]): The Pydantic model type to convert.
|
||||
|
||||
Returns:
|
||||
dict[str, Any]: A dictionary representation of the functions.
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert (
|
||||
result.short_description
|
||||
== "Convert a Pydantic model to a dictionary representation of functions."
|
||||
)
|
||||
assert len(result.params) == 1
|
||||
assert result.params[0] == DocstringParam(
|
||||
"pydantic_type", "The Pydantic model type to convert."
|
||||
)
|
||||
|
||||
def test_docstring_with_various_sections(self):
|
||||
"""Test parsing of docstring with multiple sections."""
|
||||
docstring = """
|
||||
Complex function with multiple sections.
|
||||
|
||||
Args:
|
||||
input_data (dict): Input data dictionary
|
||||
validate (bool): Whether to validate input
|
||||
|
||||
Returns:
|
||||
dict: Processed data
|
||||
|
||||
Raises:
|
||||
ValueError: If input is invalid
|
||||
|
||||
Note:
|
||||
This is a note section
|
||||
|
||||
Example:
|
||||
>>> result = complex_function({"key": "value"})
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert (
|
||||
result.short_description
|
||||
== "Complex function with multiple sections."
|
||||
)
|
||||
assert len(result.params) == 2
|
||||
assert result.params[0] == DocstringParam(
|
||||
"input_data", "Input data dictionary"
|
||||
)
|
||||
assert result.params[1] == DocstringParam(
|
||||
"validate", "Whether to validate input"
|
||||
)
|
||||
|
||||
def test_docstring_with_see_also_section(self):
|
||||
"""Test parsing of docstring with See Also section."""
|
||||
docstring = """
|
||||
Function with See Also section.
|
||||
|
||||
Args:
|
||||
param1 (str): First parameter
|
||||
|
||||
See Also:
|
||||
related_function: For related functionality
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert (
|
||||
result.short_description
|
||||
== "Function with See Also section."
|
||||
)
|
||||
assert len(result.params) == 1
|
||||
assert result.params[0] == DocstringParam(
|
||||
"param1", "First parameter"
|
||||
)
|
||||
|
||||
def test_docstring_with_see_also_underscore_section(self):
|
||||
"""Test parsing of docstring with See_Also section (underscore variant)."""
|
||||
docstring = """
|
||||
Function with See_Also section.
|
||||
|
||||
Args:
|
||||
param1 (str): First parameter
|
||||
|
||||
See_Also:
|
||||
related_function: For related functionality
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert (
|
||||
result.short_description
|
||||
== "Function with See_Also section."
|
||||
)
|
||||
assert len(result.params) == 1
|
||||
assert result.params[0] == DocstringParam(
|
||||
"param1", "First parameter"
|
||||
)
|
||||
|
||||
def test_docstring_with_yields_section(self):
|
||||
"""Test parsing of docstring with Yields section."""
|
||||
docstring = """
|
||||
Generator function.
|
||||
|
||||
Args:
|
||||
items (list): List of items to process
|
||||
|
||||
Yields:
|
||||
str: Processed item
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert result.short_description == "Generator function."
|
||||
assert len(result.params) == 1
|
||||
assert result.params[0] == DocstringParam(
|
||||
"items", "List of items to process"
|
||||
)
|
||||
|
||||
def test_docstring_with_raises_section(self):
|
||||
"""Test parsing of docstring with Raises section."""
|
||||
docstring = """
|
||||
Function that can raise exceptions.
|
||||
|
||||
Args:
|
||||
value (int): Value to process
|
||||
|
||||
Raises:
|
||||
ValueError: If value is negative
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert (
|
||||
result.short_description
|
||||
== "Function that can raise exceptions."
|
||||
)
|
||||
assert len(result.params) == 1
|
||||
assert result.params[0] == DocstringParam(
|
||||
"value", "Value to process"
|
||||
)
|
||||
|
||||
def test_docstring_with_examples_section(self):
|
||||
"""Test parsing of docstring with Examples section."""
|
||||
docstring = """
|
||||
Function with examples.
|
||||
|
||||
Args:
|
||||
x (int): Input value
|
||||
|
||||
Examples:
|
||||
>>> result = example_function(5)
|
||||
>>> print(result)
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert result.short_description == "Function with examples."
|
||||
assert len(result.params) == 1
|
||||
assert result.params[0] == DocstringParam("x", "Input value")
|
||||
|
||||
def test_docstring_with_note_section(self):
|
||||
"""Test parsing of docstring with Note section."""
|
||||
docstring = """
|
||||
Function with a note.
|
||||
|
||||
Args:
|
||||
data (str): Input data
|
||||
|
||||
Note:
|
||||
This function is deprecated
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert result.short_description == "Function with a note."
|
||||
assert len(result.params) == 1
|
||||
assert result.params[0] == DocstringParam(
|
||||
"data", "Input data"
|
||||
)
|
||||
|
||||
def test_docstring_with_complex_type_annotations(self):
|
||||
"""Test parsing of docstring with complex type annotations."""
|
||||
docstring = """
|
||||
Function with complex types.
|
||||
|
||||
Args:
|
||||
data (List[Dict[str, Any]]): Complex data structure
|
||||
callback (Callable[[str], int]): Callback function
|
||||
optional (Optional[str], optional): Optional parameter
|
||||
|
||||
Returns:
|
||||
Union[str, None]: Result or None
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert (
|
||||
result.short_description == "Function with complex types."
|
||||
)
|
||||
assert len(result.params) == 3
|
||||
assert result.params[0] == DocstringParam(
|
||||
"data", "Complex data structure"
|
||||
)
|
||||
assert result.params[1] == DocstringParam(
|
||||
"callback", "Callback function"
|
||||
)
|
||||
assert result.params[2] == DocstringParam(
|
||||
"optional", "Optional parameter"
|
||||
)
|
||||
|
||||
def test_docstring_with_no_description(self):
|
||||
"""Test parsing of docstring with no description, only Args."""
|
||||
docstring = """
|
||||
Args:
|
||||
param1 (str): First parameter
|
||||
param2 (int): Second parameter
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert result.short_description is None
|
||||
assert len(result.params) == 2
|
||||
assert result.params[0] == DocstringParam(
|
||||
"param1", "First parameter"
|
||||
)
|
||||
assert result.params[1] == DocstringParam(
|
||||
"param2", "Second parameter"
|
||||
)
|
||||
|
||||
def test_docstring_with_empty_args_section(self):
|
||||
"""Test parsing of docstring with empty Args section."""
|
||||
docstring = """
|
||||
Function with empty Args section.
|
||||
|
||||
Args:
|
||||
|
||||
Returns:
|
||||
str: Result
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert (
|
||||
result.short_description
|
||||
== "Function with empty Args section."
|
||||
)
|
||||
assert result.params == []
|
||||
|
||||
def test_docstring_with_mixed_indentation(self):
|
||||
"""Test parsing of docstring with mixed indentation."""
|
||||
docstring = """
|
||||
Function with mixed indentation.
|
||||
|
||||
Args:
|
||||
param1 (str): First parameter
|
||||
with continuation
|
||||
param2 (int): Second parameter
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert (
|
||||
result.short_description
|
||||
== "Function with mixed indentation."
|
||||
)
|
||||
assert len(result.params) == 2
|
||||
assert result.params[0] == DocstringParam(
|
||||
"param1", "First parameter with continuation"
|
||||
)
|
||||
assert result.params[1] == DocstringParam(
|
||||
"param2", "Second parameter"
|
||||
)
|
||||
|
||||
def test_docstring_with_tab_indentation(self):
|
||||
"""Test parsing of docstring with tab indentation."""
|
||||
docstring = """
|
||||
Function with tab indentation.
|
||||
|
||||
Args:
|
||||
param1 (str): First parameter
|
||||
param2 (int): Second parameter
|
||||
"""
|
||||
result = parse(docstring)
|
||||
assert (
|
||||
result.short_description
|
||||
== "Function with tab indentation."
|
||||
)
|
||||
assert len(result.params) == 2
|
||||
assert result.params[0] == DocstringParam(
|
||||
"param1", "First parameter"
|
||||
)
|
||||
assert result.params[1] == DocstringParam(
|
||||
"param2", "Second parameter"
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
pytest.main([__file__])
|
||||
@ -1,120 +0,0 @@
|
||||
import pytest
|
||||
|
||||
from swarms.utils import print_class_parameters
|
||||
|
||||
|
||||
class TestObject:
|
||||
def __init__(self, value1, value2: int):
|
||||
pass
|
||||
|
||||
|
||||
class TestObject2:
|
||||
def __init__(self: "TestObject2", value1, value2: int = 5):
|
||||
pass
|
||||
|
||||
|
||||
def test_class_with_complex_parameters():
|
||||
class ComplexArgs:
|
||||
def __init__(self, value1: list, value2: dict = {}):
|
||||
pass
|
||||
|
||||
output = {"value1": "<class 'list'>", "value2": "<class 'dict'>"}
|
||||
assert (
|
||||
print_class_parameters(ComplexArgs, api_format=True) == output
|
||||
)
|
||||
|
||||
|
||||
def test_empty_class():
|
||||
class Empty:
|
||||
pass
|
||||
|
||||
with pytest.raises(Exception):
|
||||
print_class_parameters(Empty)
|
||||
|
||||
|
||||
def test_class_with_no_annotations():
|
||||
class NoAnnotations:
|
||||
def __init__(self, value1, value2):
|
||||
pass
|
||||
|
||||
output = {
|
||||
"value1": "<class 'inspect._empty'>",
|
||||
"value2": "<class 'inspect._empty'>",
|
||||
}
|
||||
assert (
|
||||
print_class_parameters(NoAnnotations, api_format=True)
|
||||
== output
|
||||
)
|
||||
|
||||
|
||||
def test_class_with_partial_annotations():
|
||||
class PartialAnnotations:
|
||||
def __init__(self, value1, value2: int):
|
||||
pass
|
||||
|
||||
output = {
|
||||
"value1": "<class 'inspect._empty'>",
|
||||
"value2": "<class 'int'>",
|
||||
}
|
||||
assert (
|
||||
print_class_parameters(PartialAnnotations, api_format=True)
|
||||
== output
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"obj, expected",
|
||||
[
|
||||
(
|
||||
TestObject,
|
||||
{
|
||||
"value1": "<class 'inspect._empty'>",
|
||||
"value2": "<class 'int'>",
|
||||
},
|
||||
),
|
||||
(
|
||||
TestObject2,
|
||||
{
|
||||
"value1": "<class 'inspect._empty'>",
|
||||
"value2": "<class 'int'>",
|
||||
},
|
||||
),
|
||||
],
|
||||
)
|
||||
def test_parametrized_class_parameters(obj, expected):
|
||||
assert print_class_parameters(obj, api_format=True) == expected
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"value",
|
||||
[
|
||||
int,
|
||||
float,
|
||||
str,
|
||||
list,
|
||||
set,
|
||||
dict,
|
||||
bool,
|
||||
tuple,
|
||||
complex,
|
||||
bytes,
|
||||
bytearray,
|
||||
memoryview,
|
||||
range,
|
||||
frozenset,
|
||||
slice,
|
||||
object,
|
||||
],
|
||||
)
|
||||
def test_not_class_exception(value):
|
||||
with pytest.raises(Exception):
|
||||
print_class_parameters(value)
|
||||
|
||||
|
||||
def test_api_format_flag():
|
||||
assert print_class_parameters(TestObject2, api_format=True) == {
|
||||
"value1": "<class 'inspect._empty'>",
|
||||
"value2": "<class 'int'>",
|
||||
}
|
||||
print_class_parameters(TestObject)
|
||||
# TODO: Capture printed output and assert correctness.
|
||||
Loading…
Reference in new issue