Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-opus-4-20250514-thinking-16k· AnthropicHugging Face LMArena Human Preference 140K

напиши код на Pyton для мультиагентной (MAS) системы, которая служит помощником…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Amazon Novaamazon.nova-pro-v1:0’s answer.
  1. User

    напиши код на Pyton для мультиагентной (MAS) системы, которая служит помощником руководителя-координатора программы разработки и внедрения MAS систем в очень крупной коммерческой компании. Основные задачи системы: 1. Постоянное развитие навыков и компетенций руководителя-координатора в области AI, ML, DL, MAS-систем, совершенствование менеджерских навыков, карьерное планирование и продвижение, анализ рынка и современных технологий в области AI, ML, DL, MAS-систем и смежных областях, тайм-менеджмент, управление программой разработки и внедрения MAS систем.

  2. Claude Assistant

    Вот код мультиагентной системы для помощника руководителя-координатора:

    import asyncio
    import json
    from datetime import datetime, timedelta
    from typing import Dict, List, Any, Optional
    from dataclasses import dataclass
    from enum import Enum
    import logging
    
    # Настройка логирования
    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger(__name__)
    
    # Типы сообщений между агентами
    class MessageType(Enum):
        REQUEST = "request"
        RESPONSE = "response"
        NOTIFICATION = "notification"
        UPDATE = "update"
    
    # Структура сообщения
    @dataclass
    class Message:
        sender: str
        receiver: str
        type: MessageType
        content: Dict[str, Any]
        timestamp: datetime = None
        
        def __post_init__(self):
            if self.timestamp is None:
                self.timestamp = datetime.now()
    
    # Базовый класс агента
    class BaseAgent:
        def __init__(self, name: str, coordinator=None):
            self.name = name
            self.coordinator = coordinator
            self.inbox = asyncio.Queue()
            self.knowledge_base = {}
            self.active = True
            
        async def send_message(self, receiver: str, msg_type: MessageType, content: Dict):
            message = Message(
                sender=self.name,
                receiver=receiver,
                type=msg_type,
                content=content
            )
            if self.coordinator:
                await self.coordinator.route_message(message)
        
        async def receive_message(self, message: Message):
            await self.inbox.put(message)
        
        async def process_messages(self):
            while self.active:
                try:
                    message = await asyncio.wait_for(self.inbox.get(), timeout=1.0)
                    await self.handle_message(message)
                except asyncio.TimeoutError:
                    continue
        
        async def handle_message(self, message: Message):
            # Переопределяется в дочерних классах
            pass
        
        async def run(self):
            await self.process_messages()
    
    # Агент развития компетенций
    class SkillDevelopmentAgent(BaseAgent):
        def __init__(self, name: str, coordinator=None):
            super().__init__(name, coordinator)
            self.skills_database = {
                "AI": ["Machine Learning", "Deep Learning", "NLP", "Computer Vision"],
                "MAS": ["Agent Architecture", "Communication Protocols", "Coordination", "Negotiation"],
                "Management": ["Leadership", "Project Management", "Strategic Planning", "Team Building"]
            }
            self.learning_paths = {}
            
        async def handle_message(self, message: Message):
            if message.type == MessageType.REQUEST:
                if message.content.get("action") == "get_learning_path":
                    skill_area = message.content.get("skill_area")
                    path = await self.generate_learning_path(skill_area)
                    await self.send_message(
                        message.sender,
                        MessageType.RESPONSE,
                        {"learning_path": path}
                    )
                elif message.content.get("action") == "assess_skills":
                    assessment = await self.assess_current_skills()
                    await self.send_message(
                        message.sender,
                        MessageType.RESPONSE,
                        {"skill_assessment": assessment}
                    )
        
        async def generate_learning_path(self, skill_area: str) -> Dict:
            if skill_area in self.skills_database:
                return {
                    "area": skill_area,
                    "topics": self.skills_database[skill_area],
                    "timeline": "3-6 months",
                    "resources": [
                        f"Course: Advanced {skill_area}",
                        f"Book: Mastering {skill_area}",
                        "Online tutorials and workshops"
                    ]
                }
            return {"error": "Unknown skill area"}
        
        async def assess_current_skills(self) -> Dict:
            return {
                "AI": 75,
                "MAS": 80,
                "Management": 70,
                "recommendations": ["Focus on Deep Learning", "Improve strategic planning"]
            }
    
    # Агент анализа рынка
    class MarketAnalysisAgent(BaseAgent):
        def __init__(self, name: str, coordinator=None):
            super().__init__(name, coordinator)
            self.market_trends = {
                "AI": ["LLMs", "Multimodal AI", "Edge AI"],
                "MAS": ["Swarm Intelligence", "Federated Learning", "Agent-based Simulation"],
                "Tools": ["AutoML", "MLOps", "Agent Frameworks"]
            }
            
        async def handle_message(self, message: Message):
            if message.type == MessageType.REQUEST:
                if message.content.get("action") == "analyze_trends":
                    trends = await self.analyze_market_trends()
                    await self.send_message(
                        message.sender,
                        MessageType.RESPONSE,
                        {"market_trends": trends}
                    )
                elif message.content.get("action") == "competitor_analysis":
                    analysis = await self.analyze_competitors()
                    await self.send_message(
                        message.sender,
                        MessageType.RESPONSE,
                        {"competitor_analysis": analysis}
                    )
        
        async def analyze_market_trends(self) -> Dict:
            return {
                "trending_technologies": self.market_trends,
                "adoption_rate": "High",
                "investment_areas": ["AutoML platforms", "MAS frameworks"],
                "forecast": "Continued growth in enterprise AI adoption"
            }
        
        async def analyze_competitors(self) -> Dict:
            return {
                "leaders": ["Company A", "Company B"],
                "their_focus": ["Automation", "Predictive Analytics"],
                "opportunities": ["Real-time MAS", "Industry-specific solutions"]
            }
    
    # Агент управления временем
    class TimeManagementAgent(BaseAgent):
        def __init__(self, name: str, coordinator=None):
            super().__init__(name, coordinator)
            self.schedule = {}
            self.priorities = []
            
        async def handle_message(self, message: Message):
            if message.type == MessageType.REQUEST:
                if message.content.get("action") == "optimize_schedule":
                    optimized = await self.optimize_schedule()
                    await self.send_message(
                        message.sender,
                        MessageType.RESPONSE,
                        {"optimized_schedule": optimized}
                    )
                elif message.content.get("action") == "set_reminder":
                    reminder = message.content.get("reminder")
                    await self.set_reminder(reminder)
                    await self.send_message(
                        message.sender,
                        MessageType.RESPONSE,
                        {"status": "Reminder set"}
                    )
        
        async def optimize_schedule(self) -> Dict:
            current_time = datetime.now()
            return {
                "today": [
                    {"time": "09:00", "task": "Team standup", "duration": "30m"},
                    {"time": "10:00", "task": "AI strategy review", "duration": "1h"},
                    {"time": "14:00", "task": "MAS development meeting", "duration": "2h"}
                ],
                "recommendations": [
                    "Block time for deep work",
                    "Schedule regular learning sessions",
                    "Reserve time for strategic planning"
                ]
            }
        
        async def set_reminder(self, reminder: Dict):
            self.schedule[reminder.get("time")] = reminder.get("task")
    
    # Агент карьерного планирования
    class CareerPlanningAgent(BaseAgent):
        def __init__(self, name: str, coordinator=None):
            super().__init__(name, coordinator)
            self.career_goals = {}
            self.milestones = []
            
        async def handle_message(self, message: Message):
            if message.type == MessageType.REQUEST:
                if message.content.get("action") == "create_career_plan":
                    plan = await self.create_career_plan()
                    await self.send_message(
                        message.sender,
                        MessageType.RESPONSE,
                        {"career_plan": plan}
                    )
                elif message.content.get("action") == "track_progress":
                    progress = await self.track_career_progress()
                    await self.send_message(
                        message.sender,
                        MessageType.RESPONSE,
                        {"progress": progress}
                    )
        
        async def create_career_plan(self) -> Dict:
            return {
                "current_position": "MAS Program Coordinator",
                "short_term_goals": [
                    "Master advanced MAS architectures",
                    "Lead 3+ successful MAS implementations",
                    "Build team of 10+ AI specialists"
                ],
                "long_term_goals": [
                    "VP of AI Strategy",
                    "Chief AI Officer",
                    "Industry thought leader"
                ],
                "timeline": "3-5 years",
                "key_milestones": [
                    "Complete advanced AI certification",
                    "Publish research paper on MAS",
                    "Speak at major AI conference"
                ]
            }
        
        async def track_career_progress(self) -> Dict:
            return {
                "completed_milestones": ["Basic MAS implementation", "Team of 5 built"],
                "in_progress": ["Advanced certification", "Second MAS project"],
                "completion_rate": 40
            }
    
    # Агент управления программой
    class ProgramManagementAgent(BaseAgent):
        def __init__(self, name: str, coordinator=None):
            super().__init__(name, coordinator)
            self.projects = {}
            self.resources = {}
            
        async def handle_message(self, message: Message):
            if message.type == MessageType.REQUEST:
                if message.content.get("action") == "project_status":
                    status = await self.get_project_status()
                    await self.send_message(
                        message.sender,
                        MessageType.RESPONSE,
                        {"project_status": status}
                    )
                elif message.content.get("action") == "resource_allocation":
                    allocation = await self.optimize_resources()
                    await self.send_message(
                        message.sender,
                        MessageType.RESPONSE,
                        {"resource_allocation": allocation}
                    )
        
        async def get_project_status(self) -> Dict:
            return {
                "active_projects": [
                    {"name": "Customer Service MAS", "completion": 65, "status": "On track"},
                    {"name": "Supply Chain MAS", "completion": 30, "status": "Planning"},
                    {"name": "Analytics MAS", "completion": 85, "status": "Testing"}
                ],
                "risks": ["Resource constraints", "Technical complexity"],
                "opportunities": ["Early adoption advantage", "Cost savings potential"]
            }
        
        async def optimize_resources(self) -> Dict:
            return {
                "team_allocation": {
                    "Customer Service MAS": 5,
                    "Supply Chain MAS": 3,
                    "Analytics MAS": 4
                },
                "budget_status": "Within limits",
                "recommendations": ["Hire 2 more ML engineers", "Invest in cloud infrastructure"]
            }
    
    # Координатор системы
    class MASCoordinator:
        def __init__(self):
            self.agents = {}
            self.message_log = []
            
        def register_agent(self, agent: BaseAgent):
            self.agents[agent.name] = agent
            agent.coordinator = self
            logger.info(f"Registered agent: {agent.name}")
            
        async def route_message(self, message: Message):
            self.message_log.append(message)
            if message.receiver in self.agents:
                await self.agents[message.receiver].receive_message(message)
            elif message.receiver == "coordinator":
                await self.handle_coordinator_message(message)
            else:
                logger.warning(f"Unknown receiver: {message.receiver}")
        
        async def handle_coordinator_message(self, message: Message):
            if message.content.get("action") == "system_status":
                status = {
                    "active_agents": list(self.agents.keys()),
                    "message_count": len(self.message_log),
                    "system_health": "Operational"
                }
                await self.route_message(Message(
                    sender="coordinator",
                    receiver=message.sender,
                    type=MessageType.RESPONSE,
                    content={"status": status}
                ))
        
        async def broadcast_message(self, sender: str, msg_type: MessageType, content: Dict):
            for agent_name in self.agents:
                if agent_name != sender:
                    await self.route_message(Message(
                        sender=sender,
                        receiver=agent_name,
                        type=msg_type,
                        content=content
                    ))
        
        async def start(self):
            tasks = []
            for agent in self.agents.values():
                tasks.append(asyncio.create_task(agent.run()))
            
            # Запуск интерфейса взаимодействия
            tasks.append(asyncio.create_task(self.interactive_interface()))
            
            await asyncio.gather(*tasks)
        
        async def interactive_interface(self):
            """Простой интерфейс для взаимодействия с системой"""
            print("\nMAS Assistant System Started")
            print("Available commands:")
            print("- skills: Get skill development recommendations")
            print("- market: Analyze market trends")
            print("- schedule: Optimize schedule")
            print("- career: Get career planning advice")
            print("- projects: Check project status")
            print("- quit: Exit system\n")
            
            while True:
                await asyncio.sleep(0.1)  # Небольшая задержка для корректной работы
                
                # В реальной системе здесь был бы GUI или веб-интерфейс
                # Для демонстрации используем симуляцию команд
                
    # Главная функция запуска
    async def main():
        # Создание координатора
        coordinator = MASCoordinator()
        
        # Создание и регистрация агентов
        skill_agent = SkillDevelopmentAgent("SkillDevelopment")
        market_agent = MarketAnalysisAgent("MarketAnalysis")
        time_agent = TimeManagementAgent("TimeManagement")
        career_agent = CareerPlanningAgent("CareerPlanning")
        program_agent = ProgramManagementAgent("ProgramManagement")
        
        coordinator.register_agent(skill_agent)
        coordinator.register_agent(market_agent)
        coordinator.register_agent(time_agent)
        coordinator.register_agent(career_agent)
        coordinator.register_agent(program_agent)
        
        # Запуск системы
        try:
            await coordinator.start()
        except KeyboardInterrupt:
            logger.info("System shutdown initiated")
    
    if __name__ == "__main__":
        asyncio.run(main())
    

    Эта мультиагентная система включает:

    1. Базовую архитектуру:

      • Асинхронную обработку сообщений
      • Систему маршрутизации сообщений между агентами
      • Логирование действий
    2. Специализированные агенты:

      • SkillDevelopmentAgent - развитие навыков и компетенций
      • MarketAnalysisAgent - анализ рынка и технологий
      • TimeManagementAgent - управление временем
      • CareerPlanningAgent - карьерное планирование
      • ProgramManagementAgent - управление программой разработки
    3. Возможности расширения:

      • Легко добавлять новых агентов
      • Интеграция с внешними API и базами данных
      • Добавление машинного обучения для персонализации рекомендаций
      • Веб-интерфейс или мобильное приложение

    Для использования системы в продакшене рекомендую добавить:

    • Постоянное хранилище данных (PostgreSQL, MongoDB)
    • REST API или GraphQL для внешнего взаимодействия
    • Интеграцию с корпоративными системами
    • Механизмы безопасности и аутентификации
    • Дашборды для визуализации данных

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.