363 lines
13 KiB
Python
363 lines
13 KiB
Python
"""
|
|
Framework-Specific Multi-Agent Implementations
|
|
|
|
Templates for CrewAI, AutoGen, LangGraph, and Swarm.
|
|
"""
|
|
|
|
from typing import Dict, List, Optional, Any
|
|
from dataclasses import dataclass
|
|
|
|
|
|
@dataclass
|
|
class CrewAITemplate:
|
|
"""Template for CrewAI implementation."""
|
|
|
|
@staticmethod
|
|
def create_financial_team() -> Dict[str, Any]:
|
|
"""Create CrewAI financial analysis team."""
|
|
return {
|
|
"agents": [
|
|
{
|
|
"name": "Market Analyst",
|
|
"role": "Market Research Specialist",
|
|
"goal": "Analyze market conditions and trends",
|
|
"backstory": "Expert market analyst with 10+ years experience",
|
|
"tools": ["market_data_api", "financial_news"],
|
|
},
|
|
{
|
|
"name": "Financial Analyst",
|
|
"role": "Financial Analysis Specialist",
|
|
"goal": "Analyze company financial statements",
|
|
"backstory": "CFA with deep financial analysis expertise",
|
|
"tools": ["financial_statements", "ratio_calculator"],
|
|
},
|
|
{
|
|
"name": "Risk Manager",
|
|
"role": "Risk Assessment Specialist",
|
|
"goal": "Assess investment risks and scenarios",
|
|
"backstory": "Risk management expert",
|
|
"tools": ["risk_models", "scenario_analysis"],
|
|
},
|
|
{
|
|
"name": "Report Writer",
|
|
"role": "Report Generation Specialist",
|
|
"goal": "Synthesize findings into comprehensive report",
|
|
"backstory": "Professional technical writer",
|
|
"tools": ["document_generator"],
|
|
},
|
|
],
|
|
"tasks": [
|
|
{
|
|
"agent": "Market Analyst",
|
|
"description": "Analyze market conditions for {company}",
|
|
},
|
|
{
|
|
"agent": "Financial Analyst",
|
|
"description": "Analyze Q3 financial results for {company}",
|
|
},
|
|
{
|
|
"agent": "Risk Manager",
|
|
"description": "Assess risks and create scenarios for {company}",
|
|
},
|
|
{
|
|
"agent": "Report Writer",
|
|
"description": "Write comprehensive investment analysis report",
|
|
},
|
|
],
|
|
"process": "sequential",
|
|
}
|
|
|
|
@staticmethod
|
|
def create_legal_team() -> Dict[str, Any]:
|
|
"""Create CrewAI legal team."""
|
|
return {
|
|
"agents": [
|
|
{
|
|
"name": "Contract Analyzer",
|
|
"role": "Legal Contract Specialist",
|
|
"goal": "Analyze and review contract terms",
|
|
"backstory": "Senior contract attorney",
|
|
},
|
|
{
|
|
"name": "Precedent Researcher",
|
|
"role": "Legal Research Specialist",
|
|
"goal": "Research relevant case law and precedents",
|
|
"backstory": "Legal researcher specializing in case law",
|
|
},
|
|
{
|
|
"name": "Risk Assessor",
|
|
"role": "Legal Risk Specialist",
|
|
"goal": "Identify and assess legal risks",
|
|
"backstory": "Risk management expert in legal domain",
|
|
},
|
|
{
|
|
"name": "Document Drafter",
|
|
"role": "Legal Document Specialist",
|
|
"goal": "Draft legal documents and recommendations",
|
|
"backstory": "Legal document drafting expert",
|
|
},
|
|
],
|
|
"process": "sequential",
|
|
}
|
|
|
|
|
|
@dataclass
|
|
class AutoGenTemplate:
|
|
"""Template for AutoGen implementation."""
|
|
|
|
@staticmethod
|
|
def create_group_chat_config() -> Dict[str, Any]:
|
|
"""Create AutoGen group chat configuration."""
|
|
return {
|
|
"agents": [
|
|
{
|
|
"name": "analyst",
|
|
"system_message": "You are a financial analyst. Provide analysis based on data.",
|
|
"llm_config": {"model": "gpt-4", "temperature": 0.7},
|
|
},
|
|
{
|
|
"name": "researcher",
|
|
"system_message": "You are a market researcher. Research trends and competition.",
|
|
"llm_config": {"model": "gpt-4", "temperature": 0.7},
|
|
},
|
|
{
|
|
"name": "critic",
|
|
"system_message": "You are a critical evaluator. Challenge assumptions and findings.",
|
|
"llm_config": {"model": "gpt-4", "temperature": 0.7},
|
|
},
|
|
],
|
|
"group_chat_config": {
|
|
"agents": ["analyst", "researcher", "critic"],
|
|
"max_round": 10,
|
|
"speaker_selection_method": "auto",
|
|
},
|
|
}
|
|
|
|
@staticmethod
|
|
def create_hierarchical_structure() -> Dict[str, Any]:
|
|
"""Create hierarchical AutoGen structure."""
|
|
return {
|
|
"primary_agents": [
|
|
{
|
|
"name": "senior_analyst",
|
|
"role": "Senior analyst coordinating teams",
|
|
"subordinates": ["junior_analyst_1", "junior_analyst_2"],
|
|
}
|
|
],
|
|
"secondary_agents": [
|
|
{
|
|
"name": "junior_analyst_1",
|
|
"role": "Fundamental analysis specialist",
|
|
},
|
|
{
|
|
"name": "junior_analyst_2",
|
|
"role": "Technical analysis specialist",
|
|
},
|
|
],
|
|
}
|
|
|
|
|
|
@dataclass
|
|
class LangGraphTemplate:
|
|
"""Template for LangGraph workflow implementation."""
|
|
|
|
@staticmethod
|
|
def create_research_workflow() -> Dict[str, Any]:
|
|
"""Create LangGraph research workflow."""
|
|
return {
|
|
"name": "research_workflow",
|
|
"state_schema": {
|
|
"topic": str,
|
|
"research_findings": str,
|
|
"analysis": str,
|
|
"recommendations": str,
|
|
},
|
|
"nodes": [
|
|
{
|
|
"name": "researcher",
|
|
"agent": "research_agent",
|
|
"description": "Research the topic",
|
|
},
|
|
{
|
|
"name": "analyst",
|
|
"agent": "analyst_agent",
|
|
"description": "Analyze research findings",
|
|
},
|
|
{
|
|
"name": "critic",
|
|
"agent": "critic_agent",
|
|
"description": "Critique and improve",
|
|
},
|
|
{
|
|
"name": "writer",
|
|
"agent": "writer_agent",
|
|
"description": "Write final report",
|
|
},
|
|
],
|
|
"edges": [
|
|
("researcher", "analyst"),
|
|
("analyst", "critic"),
|
|
("critic", "writer"),
|
|
],
|
|
"entry_point": "researcher",
|
|
"exit_point": "writer",
|
|
}
|
|
|
|
@staticmethod
|
|
def create_dynamic_workflow() -> Dict[str, Any]:
|
|
"""Create dynamic LangGraph workflow with conditions."""
|
|
return {
|
|
"name": "dynamic_workflow",
|
|
"nodes": [
|
|
{
|
|
"name": "start",
|
|
"type": "input",
|
|
},
|
|
{
|
|
"name": "analyze",
|
|
"type": "agent",
|
|
"agent": "analyzer",
|
|
},
|
|
{
|
|
"name": "quality_check",
|
|
"type": "decision",
|
|
"condition": "analyze_quality > threshold",
|
|
},
|
|
{
|
|
"name": "refine",
|
|
"type": "agent",
|
|
"agent": "refiner",
|
|
},
|
|
{
|
|
"name": "end",
|
|
"type": "output",
|
|
},
|
|
],
|
|
"conditional_edges": [
|
|
{
|
|
"source": "quality_check",
|
|
"true_target": "end",
|
|
"false_target": "refine",
|
|
}
|
|
],
|
|
}
|
|
|
|
|
|
@dataclass
|
|
class SwarmTemplate:
|
|
"""Template for OpenAI Swarm implementation."""
|
|
|
|
@staticmethod
|
|
def create_customer_support_swarm() -> Dict[str, Any]:
|
|
"""Create customer support Swarm."""
|
|
return {
|
|
"agents": [
|
|
{
|
|
"name": "triage_agent",
|
|
"instructions": "Determine which specialist to route the customer to. "
|
|
"Ask clarifying questions if needed.",
|
|
"functions": [
|
|
"route_to_billing",
|
|
"route_to_technical",
|
|
"route_to_account",
|
|
],
|
|
},
|
|
{
|
|
"name": "billing_specialist",
|
|
"instructions": "Handle all billing and payment related questions. "
|
|
"Can access billing records.",
|
|
"tools": ["billing_system", "payment_processor"],
|
|
},
|
|
{
|
|
"name": "technical_support",
|
|
"instructions": "Handle technical issues and troubleshooting. "
|
|
"Can access diagnostic tools.",
|
|
"tools": ["diagnostic_tools", "knowledge_base"],
|
|
},
|
|
{
|
|
"name": "account_specialist",
|
|
"instructions": "Handle account management and profile changes.",
|
|
"tools": ["account_system"],
|
|
},
|
|
],
|
|
"handoff_functions": {
|
|
"route_to_billing": "Transfer to billing specialist",
|
|
"route_to_technical": "Transfer to technical support",
|
|
"route_to_account": "Transfer to account specialist",
|
|
},
|
|
}
|
|
|
|
@staticmethod
|
|
def create_sales_swarm() -> Dict[str, Any]:
|
|
"""Create sales team Swarm."""
|
|
return {
|
|
"agents": [
|
|
{
|
|
"name": "sales_router",
|
|
"instructions": "Route customer inquiries to appropriate sales agent",
|
|
"functions": ["route_to_enterprise", "route_to_smb"],
|
|
},
|
|
{
|
|
"name": "enterprise_sales",
|
|
"instructions": "Handle enterprise customer inquiries",
|
|
},
|
|
{
|
|
"name": "smb_sales",
|
|
"instructions": "Handle small business inquiries",
|
|
},
|
|
],
|
|
}
|
|
|
|
|
|
class AgentCommunicationManager:
|
|
"""Manage communication patterns between agents."""
|
|
|
|
def __init__(self, agents: Dict[str, Any]):
|
|
"""Initialize communication manager."""
|
|
self.agents = agents
|
|
self.message_queue = []
|
|
|
|
def broadcast_message(self, sender: str, message: str, recipients: List[str]):
|
|
"""Broadcast message to multiple agents."""
|
|
for recipient in recipients:
|
|
self.message_queue.append({
|
|
"from": sender,
|
|
"to": recipient,
|
|
"message": message,
|
|
"type": "broadcast",
|
|
})
|
|
|
|
def direct_message(self, sender: str, recipient: str, message: str):
|
|
"""Send direct message between agents."""
|
|
self.message_queue.append({
|
|
"from": sender,
|
|
"to": recipient,
|
|
"message": message,
|
|
"type": "direct",
|
|
})
|
|
|
|
def publish_shared_state(self, state_key: str, value: Any):
|
|
"""Publish to shared state (tool-mediated communication)."""
|
|
self.message_queue.append({
|
|
"type": "shared_state",
|
|
"key": state_key,
|
|
"value": value,
|
|
})
|
|
|
|
def get_pending_messages(self, agent: str) -> List[Dict]:
|
|
"""Get messages for specific agent."""
|
|
return [msg for msg in self.message_queue if msg.get("to") == agent]
|
|
|
|
def process_message_queue(self) -> Dict[str, Any]:
|
|
"""Process and summarize message queue."""
|
|
direct_messages = [m for m in self.message_queue if m["type"] == "direct"]
|
|
broadcasts = [m for m in self.message_queue if m["type"] == "broadcast"]
|
|
shared_states = [m for m in self.message_queue if m["type"] == "shared_state"]
|
|
|
|
return {
|
|
"direct_messages": len(direct_messages),
|
|
"broadcasts": len(broadcasts),
|
|
"shared_states": len(shared_states),
|
|
"total_messages": len(self.message_queue),
|
|
}
|