add agent module for AI-DATA (#4373)

Author: chenliang613

.DS_Store

@@ -0,0 +1,189 @@
+async def demo_single_agents():
+    """Demo individual agents"""
+    print("=== Single Agent Demo ===\n")
+    
+    # Create agents
+    echo_agent = EchoAgent()
+    calculator_agent = CalculatorAgent()
+    weather_agent = WeatherAgent()
+    translator_agent = TranslatorAgent()
+    chat_agent = ChatAgent()
+    
+    # Test echo agent
+    print("1. Testing Echo Agent:")
+    response = await echo_agent.process(AgentMessage(
+        content="Hello, world!", 
+        sender="User",
+        timestamp=time.time()
+    ))
+    print(f"Input: Hello, world!")
+    print(f"Output: {response.content}\n")
+    
+    # Test calculator agent
+    print("2. Testing Calculator Agent:")
+    response = await calculator_agent.process(AgentMessage(
+        content="(15 + 25) * 2", 
+        sender="User",
+        timestamp=time.time()
+    ))
+    print(f"Input: (15 + 25) * 2")
+    print(f"Output: {response.content}\n")
+    
+    # Test weather agent
+    print("3. Testing Weather Agent:")
+    response = await weather_agent.process(AgentMessage(
+        content="Tokyo", 
+        sender="User",
+        timestamp=time.time()
+    ))
+    print(f"Input: Tokyo")
+    print(f"Output: {response.content}\n")
+    
+    # Test translator agent
+    print("4. Testing Translator Agent:")
+    response = await translator_agent.process(AgentMessage(
+        content="Hello, how are you?", 
+        sender="User",
+        timestamp=time.time(),
+        metadata={"target_language": "french"}
+    ))
+    print(f"Input: Hello, how are you? (to French)")
+    print(f"Output: {response.content}\n")
+    
+    # Test chat agent
+    print("5. Testing Chat Agent:")
+    response = await chat_agent.process(AgentMessage(
+        content="Hello! What can you do?", 
+        sender="User",
+        timestamp=time.time()
+    ))
+    print(f"Input: Hello! What can you do?")
+    print(f"Output: {response.content}\n")
+
+async def demo_agent_system():
+    """Demo the complete agent system"""
+    print("\n=== Agent System Demo ===\n")
+    
+    # Create agent manager and register agents
+    manager = AgentManager()
+    
+    manager.register_agent(EchoAgent())
+    manager.register_agent(CalculatorAgent())
+    manager.register_agent(WeatherAgent())
+    manager.register_agent(TranslatorAgent())
+    manager.register_agent(ChatAgent())
+    
+    print(f"Registered {len(manager.agents)} agents:")
+    for agent_name in manager.agents.keys():
+        print(f"  - {agent_name}")
+    
+    # Test individual agent communication
+    print("\n1. Testing Calculator Agent through Manager:")
+    response = await manager.send_message("CalculatorAgent", "45 + 17 * 3")
+    print(f"Response: {response.content}")
+    
+    print("\n2. Testing Weather Agent through Manager:")
+    response = await manager.send_message("WeatherAgent", "London")
+    print(f"Response: {response.content}")
+    
+    print("\n3. Testing Broadcast Message:")
+    responses = await manager.broadcast_message("Hello everyone!")
+    print("Broadcast responses:")
+    for agent_name, response in responses.items():
+        print(f"  {agent_name}: {response.content[:50]}...")
+    
+    # Demonstrate agent discovery
+    print("\n4. Agent Discovery:")
+    math_agents = manager.find_agent_by_capability("calculation")
+    print(f"Agents for calculations: {math_agents}")
+    
+    weather_agents = manager.find_agent_by_capability("weather")
+    print(f"Agents for weather: {weather_agents}")
+    
+    # Show system statistics
+    print("\n5. System Statistics:")
+    stats = manager.get_system_stats()
+    for key, value in stats.items():
+        print(f"  {key}: {value}")
+
+async def interactive_demo():
+    """Interactive demo where users can talk to agents"""
+    print("\n=== Interactive Demo ===\n")
+    
+    manager = AgentManager()
+    manager.register_agent(ChatAgent())
+    manager.register_agent(CalculatorAgent())
+    manager.register_agent(WeatherAgent())
+    manager.register_agent(TranslatorAgent())
+    
+    print("Available agents: ChatAgent, CalculatorAgent, WeatherAgent, TranslatorAgent")
+    print("Type 'quit' to exit, 'help' for commands, 'agents' to list agents\n")
+    
+    while True:
+        try:
+            user_input = input("You: ").strip()
+            
+            if user_input.lower() in ['quit', 'exit']:
+                break
+            elif user_input.lower() == 'help':
+                print("\nAvailable commands:")
+                print("  'calc [expression]' - Use calculator")
+                print("  'weather [city]' - Get weather")
+                print("  'translate [text] to [language]' - Translate text")
+                print("  'agents' - List all agents")
+                print("  'stats' - Show system statistics")
+                print("  'quit' - Exit\n")
+                continue
+            elif user_input.lower() == 'agents':
+                print("\nRegistered agents:")
+                for name, agent in manager.agents.items():
+                    print(f"  {name}: {agent.description}")
+                print()
+                continue
+            elif user_input.lower() == 'stats':
+                stats = manager.get_system_stats()
+                print("\nSystem Statistics:")
+                for key, value in stats.items():
+                    print(f"  {key}: {value}")
+                print()
+                continue
+            
+            # Route to appropriate agent based on input
+            if user_input.startswith('calc '):
+                expression = user_input[5:]
+                response = await manager.send_message("CalculatorAgent", expression)
+                print(f"Calculator: {response.content}\n")
+            
+            elif user_input.startswith('weather '):
+                city = user_input[8:]
+                response = await manager.send_message("WeatherAgent", city)
+                print(f"Weather: {response.content}\n")
+            
+            elif user_input.startswith('translate '):
+                # Simple parsing for translation commands
+                parts = user_input[10:].split(' to ')
+                if len(parts) == 2:
+                    text, language = parts
+                    response = await manager.send_message(
+                        "TranslatorAgent", 
+                        text, 
+                        {"target_language": language.strip()}
+                    )
+                    print(f"Translator: {response.content}\n")
+                else:
+                    print("Usage: translate [text] to [language]\n")
+            
+            else:
+                # Default to chat agent
+                response = await manager.send_message("ChatAgent", user_input)
+                print(f"ChatAgent: {response.content}\n")
+                
+        except KeyboardInterrupt:
+            break
+        except Exception as e:
+            print(f"Error: {e}\n")
+
+if __name__ == "__main__":
+    # Run demos
+    asyncio.run(demo_single_agents())
+    asyncio.run(demo_agent_system())

Agent_module/Agent_Demo.python

@@ -0,0 +1,97 @@
+class ChatAgent(BaseAgent):
+    """Intelligent chat agent with context awareness"""
+    
+    def __init__(self, name: str = "ChatAgent"):
+        super().__init__(name, "Intelligent conversational agent")
+        self.context = {}
+        self.personality_traits = [
+            "friendly", "helpful", "knowledgeable", "enthusiastic"
+        ]
+    
+    async def _process_impl(self, message: AgentMessage) -> AgentMessage:
+        user_input = str(message.content).lower()
+        user_id = message.metadata.get("user_id", "unknown")
+        
+        # Update context
+        if user_id not in self.context:
+            self.context[user_id] = {
+                "conversation_count": 0,
+                "last_interaction": time.time(),
+                "topics": set()
+            }
+        
+        self.context[user_id]["conversation_count"] += 1
+        self.context[user_id]["last_interaction"] = time.time()
+        
+        # Simple intent recognition
+        response = await self._generate_response(user_input, user_id)
+        
+        return AgentMessage(
+            content=response,
+            sender=self.name,
+            timestamp=time.time(),
+            message_type="chat_response",
+            metadata={"user_context": self.context[user_id]}
+        )
+    
+    async def _generate_response(self, user_input: str, user_id: str) -> str:
+        """Generate context-aware responses"""
+        
+        # Greeting detection
+        if any(word in user_input for word in ["hello", "hi", "hey", "greetings"]):
+            return random.choice([
+                "Hello! How can I assist you today?",
+                "Hi there! What can I help you with?",
+                "Greetings! I'm here to help.",
+                "Hello! Nice to meet you."
+            ])
+        
+        # Question detection
+        elif "?" in user_input or any(word in user_input for word in ["what", "how", "when", "where", "why"]):
+            return await self._answer_question(user_input)
+        
+        # Weather inquiry
+        elif "weather" in user_input:
+            return "I can help with weather information! Please use the WeatherAgent for accurate weather data."
+        
+        # Calculation request
+        elif any(word in user_input for word in ["calculate", "math", "equation"]):
+            return "I can help with calculations! Try using the CalculatorAgent for mathematical operations."
+        
+        # Translation request
+        elif any(word in user_input for word in ["translate", "translation"]):
+            return "I can assist with translations! The TranslatorAgent specializes in language translation."
+        
+        # Default response
+        else:
+            return random.choice([
+                "That's interesting! Can you tell me more?",
+                "I understand. How can I help you with that?",
+                "Thanks for sharing! Is there anything specific you'd like to know?",
+                "I see. What would you like to do next?"
+            ])
+    
+    async def _answer_question(self, question: str) -> str:
+        """Answer general knowledge questions"""
+        question_lower = question.lower()
+        
+        if "time" in question_lower:
+            return f"The current time is {time.strftime('%H:%M:%S')}"
+        
+        elif "date" in question_lower:
+            return f"Today's date is {time.strftime('%Y-%m-%d')}"
+        
+        elif "name" in question_lower:
+            return "I'm ChatAgent, your friendly AI assistant!"
+        
+        elif "purpose" in question_lower or "what can you do" in question_lower:
+            return "I can chat with you, answer questions, and coordinate with other specialized agents for weather, calculations, translations, and more!"
+        
+        else:
+            responses = [
+                "That's a good question! Let me think about it...",
+                "I'm not entirely sure about that, but I'd be happy to help you find out!",
+                "Interesting question! Here's what I know about that topic...",
+                "I understand your curiosity about that subject."
+            ]
+            return random.choice(responses)

Agent_module/Chat_Agent.python

@@ -0,0 +1,78 @@
+import asyncio
+import time
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional, Callable
+from dataclasses import dataclass
+from enum import Enum
+import random
+import json
+
+class AgentStatus(Enum):
+    IDLE = "idle"
+    PROCESSING = "processing"
+    ERROR = "error"
+    STOPPED = "stopped"
+
+@dataclass
+class AgentMessage:
+    content: Any
+    sender: str
+    timestamp: float
+    message_type: str = "text"
+    metadata: Dict[str, Any] = None
+
+    def __post_init__(self):
+        if self.metadata is None:
+            self.metadata = {}
+        self.timestamp = self.timestamp or time.time()
+
+class BaseAgent(ABC):
+    """Base class for all agents"""
+    
+    def __init__(self, name: str, description: str = ""):
+        self.name = name
+        self.description = description
+        self.status = AgentStatus.IDLE
+        self.message_history: List[AgentMessage] = []
+        self._callbacks: List[Callable] = []
+        
+    async def process(self, message: AgentMessage) -> AgentMessage:
+        """Process a message and return response"""
+        self.status = AgentStatus.PROCESSING
+        self.message_history.append(message)
+        
+        try:
+            result = await self._process_impl(message)
+            self.status = AgentStatus.IDLE
+            self._notify_callbacks(message, result)
+            return result
+        except Exception as e:
+            self.status = AgentStatus.ERROR
+            error_msg = AgentMessage(
+                content=f"Error: {str(e)}",
+                sender=self.name,
+                timestamp=time.time(),
+                message_type="error"
+            )
+            return error_msg
+    
+    @abstractmethod
+    async def _process_impl(self, message: AgentMessage) -> AgentMessage:
+        """Agent-specific processing logic"""
+        pass
+    
+    def add_callback(self, callback: Callable):
+        """Add callback for message processing events"""
+        self._callbacks.append(callback)
+    
+    def _notify_callbacks(self, input_msg: AgentMessage, output_msg: AgentMessage):
+        """Notify all callbacks"""
+        for callback in self._callbacks:
+            try:
+                callback(input_msg, output_msg)
+            except Exception:
+                pass  # Don't break agent if callback fails
+    
+    def get_recent_messages(self, count: int = 10) -> List[AgentMessage]:
+        """Get recent message history"""
+        return self.message_history[-count:]