cc-codeconductor 0.4.3 → 1.0.0

package/presets/cursor/skills/multi-agent-orchestration/examples/framework_implementations.py

@@ -0,0 +1,362 @@
+"""
+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),
+        }