AutoGen and CrewAI

# AutoGen Implementation Example
import autogen
from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager

# Configure LLM
config_list = [
    {
        "model": "gpt-4",
        "api_key": "your-api-key",
    }
]

llm_config = {
    "config_list": config_list,
    "temperature": 0,
}

# Create specialized agents
user_proxy = UserProxyAgent(
    name="user_proxy",
    system_message="A human admin who will give the task and manage the conversation.",
    code_execution_config={"last_n_messages": 2, "work_dir": "groupchat"},
    human_input_mode="TERMINATE"
)

coder = AssistantAgent(
    name="coder",
    system_message="""You are a senior software engineer. You write clean, efficient code 
    and provide detailed explanations. You can execute code and debug issues.""",
    llm_config=llm_config,
)

reviewer = AssistantAgent(
    name="reviewer",
    system_message="""You are a code reviewer. You review code for best practices, 
    security issues, and optimization opportunities. Provide constructive feedback.""",
    llm_config=llm_config,
)

tester = AssistantAgent(
    name="tester",
    system_message="""You are a QA engineer. You write comprehensive tests, 
    identify edge cases, and ensure code quality.""",
    llm_config=llm_config,
)

# Create group chat
groupchat = GroupChat(
    agents=[user_proxy, coder, reviewer, tester],
    messages=[],
    max_round=20
)

manager = GroupChatManager(groupchat=groupchat, llm_config=llm_config)

# Execute conversation
user_proxy.initiate_chat(
    manager,
    message="Create a Python function to calculate fibonacci numbers with proper error handling and tests."
)

# Advanced AutoGen with custom conversation patterns
class CustomGroupChat(GroupChat):
    """Custom group chat with specialized conversation patterns"""
    
    def select_speaker(self, last_speaker, selector):
        """Custom speaker selection logic"""
        if last_speaker.name == "coder":
            return self.agent_by_name("reviewer")
        elif last_speaker.name == "reviewer":
            return self.agent_by_name("tester")
        elif last_speaker.name == "tester":
            return self.agent_by_name("coder")
        else:
            return super().select_speaker(last_speaker, selector)

# CrewAI Implementation Example
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool, WebsiteSearchTool

# Initialize tools
search_tool = SerperDevTool()
web_search_tool = WebsiteSearchTool()

# Create specialized agents with roles
researcher = Agent(
    role='Senior Research Analyst',
    goal='Uncover cutting-edge developments in AI and data science',
    backstory="""You work at a leading tech think tank. Your expertise lies in 
    identifying emerging trends and technologies in AI, machine learning, and data science.""",
    verbose=True,
    allow_delegation=False,
    tools=[search_tool, web_search_tool]
)

writer = Agent(
    role='Tech Content Strategist',
    goal='Craft compelling content on tech advancements',
    backstory="""You are a renowned Content Strategist, known for your insightful 
    and engaging articles on technology and innovation.""",
    verbose=True,
    allow_delegation=True,
)

editor = Agent(
    role='Content Editor',
    goal='Edit and refine content for publication',
    backstory="""You are an experienced editor with a keen eye for detail and 
    a passion for clear, concise communication.""",
    verbose=True,
    allow_delegation=False,
)

# Define tasks
research_task = Task(
    description="""Conduct a comprehensive analysis of the latest advancements in AI agents.
    Identify key trends, breakthrough technologies, and their potential impact on various industries.
    Your final answer MUST be a full analysis report""",
    agent=researcher
)

write_task = Task(
    description="""Using the research analyst's report, develop an engaging blog post 
    that highlights the most significant AI advancements. Make it accessible to a general audience 
    while maintaining technical accuracy.""",
    agent=writer
)

edit_task = Task(
    description="""Review and edit the blog post for clarity, engagement, and accuracy. 
    Ensure it meets publication standards and flows well.""",
    agent=editor
)

# Create crew with hierarchical process
crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, write_task, edit_task],
    verbose=2,
    process=Process.sequential  # or Process.hierarchical
)

# Execute the crew
result = crew.kickoff()

# Advanced CrewAI with custom processes
class CustomCrew(Crew):
    """Custom crew with specialized workflow patterns"""
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.quality_threshold = 0.8
        self.max_iterations = 3
    
    def execute_with_quality_control(self):
        """Execute crew with quality control loops"""
        iteration = 0
        while iteration < self.max_iterations:
            result = self.kickoff()
            quality_score = self.evaluate_quality(result)
            
            if quality_score >= self.quality_threshold:
                return result
            
            # Provide feedback for improvement
            self.provide_feedback(result, quality_score)
            iteration += 1
        
        return result
    
    def evaluate_quality(self, result):
        """Evaluate the quality of the crew's output"""
        # Implement quality evaluation logic
        return 0.9  # Placeholder
    
    def provide_feedback(self, result, score):
        """Provide feedback to agents for improvement"""
        feedback_agent = Agent(
            role='Quality Assessor',
            goal='Provide constructive feedback for improvement',
            backstory='You are an expert in quality assessment and improvement.'
        )
        
        feedback_task = Task(
            description=f"""Review the following result and provide specific feedback 
            for improvement. Current quality score: {score}
            
            Result: {result}""",
            agent=feedback_agent
        )
        
        # Execute feedback task
        feedback = feedback_task.execute()
        return feedback

# Comparison: AutoGen vs CrewAI for different use cases

def autogen_code_review_workflow():
    """AutoGen workflow for code review and development"""
    
    # Specialized agents for code development
    architect = AssistantAgent(
        name="architect",
        system_message="You design software architecture and system design.",
        llm_config=llm_config
    )
    
    developer = AssistantAgent(
        name="developer", 
        system_message="You implement code based on architectural designs.",
        llm_config=llm_config
    )
    
    reviewer = AssistantAgent(
        name="reviewer",
        system_message="You review code for quality, security, and best practices.",
        llm_config=llm_config
    )
    
    # Create conversation flow
    groupchat = GroupChat(
        agents=[user_proxy, architect, developer, reviewer],
        messages=[],
        max_round=15
    )
    
    manager = GroupChatManager(groupchat=groupchat, llm_config=llm_config)
    
    return manager

def crewai_business_workflow():
    """CrewAI workflow for business process automation"""
    
    # Business-focused agents
    analyst = Agent(
        role='Business Analyst',
        goal='Analyze business requirements and processes',
        backstory='Expert in business process analysis and optimization.'
    )
    
    strategist = Agent(
        role='Strategy Consultant', 
        goal='Develop strategic recommendations',
        backstory='Senior consultant with expertise in business strategy.'
    )
    
    implementer = Agent(
        role='Implementation Specialist',
        goal='Create actionable implementation plans',
        backstory='Expert in turning strategies into executable plans.'
    )
    
    # Define business tasks
    analysis_task = Task(
        description="Analyze the current business process and identify improvement opportunities.",
        agent=analyst
    )
    
    strategy_task = Task(
        description="Develop strategic recommendations based on the analysis.",
        agent=strategist
    )
    
    implementation_task = Task(
        description="Create a detailed implementation plan for the recommended strategies.",
        agent=implementer
    )
    
    # Create business crew
    business_crew = Crew(
        agents=[analyst, strategist, implementer],
        tasks=[analysis_task, strategy_task, implementation_task],
        process=Process.sequential
    )
    
    return business_crew

# Usage examples
if __name__ == "__main__":
    # AutoGen for technical collaboration
    print("=== AutoGen Code Review Workflow ===")
    autogen_manager = autogen_code_review_workflow()
    
    # CrewAI for business processes
    print("=== CrewAI Business Workflow ===")
    business_crew = crewai_business_workflow()
    result = business_crew.kickoff()
    print(f"Business workflow result: {result}")