8.1 KiB

Raw Blame History

AOP Server Setup Example

This example demonstrates how to set up an AOP (Agent Orchestration Protocol) server with multiple specialized agents.

Complete Server Setup

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

Save the code above to a file (e.g., aop_server.py)
Install required dependencies:
```
pip install swarms
```
Run the server:
```
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

# Call the research agent
result = research_tool(task="Research the latest AI trends in 2024")
print(result)

Analysis Agent with Image

# 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

# 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

# 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

# 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:

{
  "result": "The agent's response to the task",
  "success": true,
  "error": null
}

Advanced Configuration

Custom Timeouts and Retries

# 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

# 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

deployer = AOP(
    server_name="DebugServer",
    verbose=True,
    traceback_enabled=True,
    log_level="DEBUG"
)

Check Server Status

# 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

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

# 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.

8.1 KiB Raw Blame History