Updates to the agentic project

Author: fenar

agentic/README.md

@@ -77,6 +77,8 @@ Then open your browser and navigate to:
 http://localhost:8080
 ```
 
+**✅ System Status: Fully Functional** - All WebSocket connection issues have been resolved and the system works seamlessly.
+
 ![](https://raw.githubusercontent.com/open-experiments/Telco-AIX/refs/heads/main/agentic/images/agentic.png)<br>
 
 You'll see the dashboard with real-time visualization of agent activities, network telemetry, and workflow status.
@@ -147,24 +149,34 @@ The entire workflow is managed by the orchestration service, which ensures prope
 
 ## Troubleshooting
 
-### WebSocket Connection Issues
-
-If you see errors like:
-```
-WARNING: No supported WebSocket library detected
-```
-
-Install the required WebSocket support:
+### Prerequisites
+Make sure you have installed the WebSocket support:
 ```bash
 pip install websockets
 ```
 
-### Agent Communication Errors
+### Service URLs
+- **MCP Server**: http://localhost:8000
+- **ACP Broker**: http://localhost:8002  
+- **Dashboard**: http://localhost:8080
 
-If agents cannot communicate with each other:
-1. Ensure the ACP broker is running
-2. Confirm there are no firewall rules blocking the ports
-3. Verify all services are using the correct host/port configurations
+### Health Checks
+You can verify services are running:
+```bash
+# Check ACP broker health
+curl http://localhost:8002/health
+
+# Check if agents are connected
+curl http://localhost:8002/agents
+```
+
+### Recent Fixes Applied
+- ✅ **WebSocket Connection Issues**: All services now use `127.0.0.1` instead of `localhost` to avoid DNS resolution conflicts
+- ✅ **Service Startup**: Added health check verification before agent initialization
+- ✅ **Timeout Issues**: Enhanced retry logic and connection timeouts
+- ✅ **Python Compatibility**: Updated deprecated `datetime.utcnow()` calls for future Python versions
+- ✅ **Dashboard Issues**: Fixed agent details and workflow details pages with proper API endpoints
+- ✅ **Data Serialization**: Resolved JSON serialization issues with datetime and numpy data types
 
 ## Extending the Framework
 
@@ -222,9 +234,18 @@ agentic/
 ├── dashboard/             # Dashboard web interface
 ├── main.py                # Main application
 ├── dashboard_mode.py      # Dashboard-only mode
+├── CLAUDE.md              # AI assistant guidance for development
 └── requirements.txt       # Python dependencies
 ```
 
+## For AI Assistants
+
+This project includes a `CLAUDE.md` file that provides specific guidance for AI assistants working with this codebase, including:
+- Architecture overview and key components
+- Essential commands and troubleshooting steps  
+- Development workflow information
+- Implementation notes and best practices
+
 
 ## Disclaimer
 

agentic/agents/diagnostic/network_diagnostic_agent.py

@@ -6,7 +6,7 @@
 import time
 from typing import Dict, Any, List, Optional, Tuple
 import numpy as np
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 
 from agent.base import DiagnosticAgent
 from protocols.mcp.client import MCPClient
@@ -39,7 +39,7 @@ def add_value(self, value: float, timestamp: Optional[datetime] = None):
             timestamp: Timestamp for the value (default: current time)
         """
         if timestamp is None:
-            timestamp = datetime.utcnow()
+            timestamp = datetime.now(timezone.utc)
 
         self.values.append(value)
         self.timestamps.append(timestamp)
@@ -91,21 +91,21 @@ def get_statistics(self) -> Dict[str, Any]:
         return {
             "name": self.name,
             "count": len(self.values),
-            "current": self.values[-1],
-            "mean": np.mean(self.values),
-            "std": np.std(self.values),
-            "min": np.min(self.values),
-            "max": np.max(self.values),
+            "current": float(self.values[-1]),
+            "mean": float(np.mean(self.values)),
+            "std": float(np.std(self.values)),
+            "min": float(np.min(self.values)),
+            "max": float(np.max(self.values)),
             "timestamp": self.timestamps[-1].isoformat()
         }
 
 class NetworkDiagnosticAgent(DiagnosticAgent):
     """Agent for diagnosing network issues based on telemetry data."""
 
     def __init__(self, agent_id: Optional[str] = None, name: str = None, 
-                 telemetry_url: str = "http://localhost:8001/telemetry",
-                 mcp_url: str = "http://localhost:8000",
-                 acp_broker_url: str = "http://localhost:8002",
+                 telemetry_url: str = "http://127.0.0.1:8001/telemetry",
+                 mcp_url: str = "http://127.0.0.1:8000",
+                 acp_broker_url: str = "ws://127.0.0.1:8002",
                  metrics_config: Optional[Dict[str, Dict[str, Any]]] = None,
                  poll_interval: float = 60.0,
                  config: Dict[str, Any] = None):
@@ -133,6 +133,7 @@ def __init__(self, agent_id: Optional[str] = None, name: str = None,
         self.acp_broker_url = acp_broker_url
         self.poll_interval = poll_interval
 
+        
         # Set up metrics to monitor
         self.metrics: Dict[str, NetworkMetric] = {}
         metrics_config = metrics_config or {
@@ -241,7 +242,7 @@ async def _fetch_telemetry(self) -> Dict[str, Any]:
         """
         # In a real implementation, this would make an API call to get telemetry data
         # For this example, we'll generate some simulated telemetry data
-        timestamp = datetime.utcnow()
+        timestamp = datetime.now(timezone.utc)
 
         # Generate baseline values
         base_values = {
@@ -356,7 +357,7 @@ async def _notify_planning_agents(self, anomalies: List[Dict[str, Any]], context
             payload={
                 "anomalies": anomalies,
                 "severity": "medium",
-                "detection_time": datetime.utcnow().isoformat()
+                "detection_time": datetime.now(timezone.utc).isoformat()
             },
             priority=MessagePriority.HIGH,
             context_refs=[context_id]
@@ -407,7 +408,7 @@ async def perform_diagnostic(self, request: Dict[str, Any]) -> Dict[str, Any]:
             "metrics_statistics": {
                 name: metric.get_statistics() for name, metric in self.metrics.items()
             },
-            "diagnostic_time": datetime.utcnow().isoformat(),
+            "diagnostic_time": datetime.now(timezone.utc).isoformat(),
             "diagnostic_agent": self.agent_id
         }
 
@@ -435,7 +436,7 @@ async def process_message(self, message: Dict[str, Any]) -> Dict[str, Any]:
         # For now, we'll just return a simple acknowledgement
         return {
             "status": "acknowledged",
-            "timestamp": datetime.utcnow().isoformat()
+            "timestamp": datetime.now(timezone.utc).isoformat()
         }
 
     def get_capabilities(self) -> List[str]:

agentic/agents/execution/network_execution_agent.py

@@ -5,7 +5,7 @@
 import logging
 import uuid
 from typing import Dict, Any, List, Optional
-from datetime import datetime
+from datetime import datetime, timezone
 
 from agent.base import ExecutionAgent
 from protocols.mcp.client import MCPClient
@@ -17,9 +17,9 @@ class NetworkExecutionAgent(ExecutionAgent):
     """Agent for executing network configuration and optimization plans."""
 
     def __init__(self, agent_id: Optional[str] = None, name: str = None,
-                 mcp_url: str = "http://localhost:8000",
-                 acp_broker_url: str = "http://localhost:8002",
-                 network_api_url: str = "http://localhost:8003/api/network",
+                 mcp_url: str = "http://127.0.0.1:8000",
+                 acp_broker_url: str = "ws://127.0.0.1:8002",
+                 network_api_url: str = "http://127.0.0.1:8003/api/network",
                  config: Dict[str, Any] = None):
         """Initialize a new network execution agent.
         
@@ -111,7 +111,7 @@ async def _check_executing_plans(self) -> None:
 
         for plan_id, plan_data in self.executing_plans.items():
             # Check if the plan has timed out
-            current_time = datetime.utcnow()
+            current_time = datetime.now(timezone.utc)
             start_time = datetime.fromisoformat(plan_data["start_time"])
             timeout = plan_data.get("timeout", 3600)  # Default 1 hour timeout
 
@@ -234,7 +234,7 @@ async def _store_execution_result(self, plan_id: str, result: Dict[str, Any]) ->
                 "execution_result": result,
                 "plan_id": plan_id,
                 "agent_id": self.agent_id,
-                "timestamp": datetime.utcnow().isoformat()
+                "timestamp": datetime.now(timezone.utc).isoformat()
             },
             priority=3,
             confidence=ConfidenceLevel.HIGH,
@@ -298,7 +298,7 @@ async def execute_network_command(self, command: str, target: str) -> Dict[str,
             "status": "success",
             "command": command,
             "target": target,
-            "timestamp": datetime.utcnow().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "output": f"Simulated output for {command} on {target}"
         }
 
@@ -319,16 +319,16 @@ async def execute_plan(self, plan: Dict[str, Any]) -> Dict[str, Any]:
                 "plan_id": plan_id,
                 "status": "failed",
                 "error": "Plan contains no steps to execute",
-                "start_time": datetime.utcnow().isoformat(),
-                "end_time": datetime.utcnow().isoformat(),
+                "start_time": datetime.now(timezone.utc).isoformat(),
+                "end_time": datetime.now(timezone.utc).isoformat(),
                 "executed_by": self.agent_id
             }
 
         # Initialize execution result
         result = {
             "plan_id": plan_id,
             "status": "in_progress",
-            "start_time": datetime.utcnow().isoformat(),
+            "start_time": datetime.now(timezone.utc).isoformat(),
             "executed_by": self.agent_id,
             "steps_total": len(steps),
             "steps_completed": 0,
@@ -354,7 +354,7 @@ async def execute_plan(self, plan: Dict[str, Any]) -> Dict[str, Any]:
                 "step_id": step_id,
                 "name": step_name,
                 "status": "in_progress",
-                "start_time": datetime.utcnow().isoformat()
+                "start_time": datetime.now(timezone.utc).isoformat()
             }
 
             try:
@@ -396,7 +396,7 @@ async def execute_plan(self, plan: Dict[str, Any]) -> Dict[str, Any]:
                 result["steps_failed"] += 1
             finally:
                 # Finalize step result
-                step_result["end_time"] = datetime.utcnow().isoformat()
+                step_result["end_time"] = datetime.now(timezone.utc).isoformat()
                 step_result["duration"] = (datetime.fromisoformat(step_result["end_time"]) - 
                                          datetime.fromisoformat(step_result["start_time"])).total_seconds()
                 result["step_results"].append(step_result)
@@ -409,7 +409,7 @@ async def execute_plan(self, plan: Dict[str, Any]) -> Dict[str, Any]:
                 self.executing_plans[plan_id] = result
 
         # Finalize execution result
-        end_time = datetime.utcnow().isoformat()
+        end_time = datetime.now(timezone.utc).isoformat()
         result.update({
             "status": "completed" if result["steps_failed"] == 0 else "partial",
             "end_time": end_time,
@@ -445,7 +445,7 @@ async def process_message(self, message: Dict[str, Any]) -> Dict[str, Any]:
         # Default response for other message types
         return {
             "status": "acknowledged",
-            "timestamp": datetime.utcnow().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "execution_agent": self.agent_id
         }
 

agentic/agents/planning/network_planning_agent.py

@@ -5,7 +5,7 @@
 import logging
 import uuid
 from typing import Dict, Any, List, Optional
-from datetime import datetime
+from datetime import datetime, timezone
 
 from agent.base import PlanningAgent
 from protocols.mcp.client import MCPClient
@@ -17,8 +17,8 @@ class NetworkPlanningAgent(PlanningAgent):
     """Agent for generating plans to resolve network issues."""
 
     def __init__(self, agent_id: Optional[str] = None, name: str = None,
-                 mcp_url: str = "http://localhost:8000",
-                 acp_broker_url: str = "http://localhost:8002",
+                 mcp_url: str = "http://127.0.0.1:8000",
+                 acp_broker_url: str = "ws://127.0.0.1:8002",
                  config: Dict[str, Any] = None):
         """Initialize a new network planning agent.
         
@@ -210,7 +210,7 @@ async def _notify_execution_agents(self, plan: Dict[str, Any], plan_context_id:
             payload={
                 "plan_summary": plan.get("summary", "Network issue resolution plan"),
                 "priority": plan.get("priority", "medium"),
-                "generation_time": datetime.utcnow().isoformat()
+                "generation_time": datetime.now(timezone.utc).isoformat()
             },
             priority=MessagePriority.HIGH,
             context_refs=[plan_context_id]
@@ -235,7 +235,7 @@ async def generate_plan(self, problem_context: Dict[str, Any]) -> Dict[str, Any]
         if not anomalies:
             return {
                 "error": "No anomalies provided to generate a plan",
-                "timestamp": datetime.utcnow().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
                 "planning_agent": self.agent_id
             }
 
@@ -245,7 +245,7 @@ async def generate_plan(self, problem_context: Dict[str, Any]) -> Dict[str, Any]
             "summary": f"Plan to resolve {len(anomalies)} network anomalies",
             "severity": severity,
             "priority": self._calculate_priority(anomalies, severity),
-            "created_at": datetime.utcnow().isoformat(),
+            "created_at": datetime.now(timezone.utc).isoformat(),
             "created_by": self.agent_id,
             "steps": [],
             "estimated_duration": 0,  # Will be calculated based on steps
@@ -494,7 +494,7 @@ async def process_message(self, message: Dict[str, Any]) -> Dict[str, Any]:
         # Default response for other message types
         return {
             "status": "acknowledged",
-            "timestamp": datetime.utcnow().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "planning_agent": self.agent_id
         }
 

agentic/agents/validation/network_validation_agent.py

@@ -5,7 +5,7 @@
 import logging
 import uuid
 from typing import Dict, Any, List, Optional
-from datetime import datetime
+from datetime import datetime, timezone
 
 from agent.base import ValidationAgent
 from protocols.mcp.client import MCPClient
@@ -17,9 +17,9 @@ class NetworkValidationAgent(ValidationAgent):
     """Agent for validating network changes and resolution of issues."""
 
     def __init__(self, agent_id: Optional[str] = None, name: str = None,
-                 mcp_url: str = "http://localhost:8000",
-                 acp_broker_url: str = "http://localhost:8002",
-                 telemetry_url: str = "http://localhost:8001/telemetry",
+                 mcp_url: str = "http://127.0.0.1:8000",
+                 acp_broker_url: str = "ws://127.0.0.1:8002",
+                 telemetry_url: str = "http://127.0.0.1:8001/telemetry",
                  config: Dict[str, Any] = None):
         """Initialize a new network validation agent.
         
@@ -237,7 +237,7 @@ async def _store_validation_result(self, result: Dict[str, Any], correlation_id:
             payload={
                 "validation_result": result,
                 "agent_id": self.agent_id,
-                "timestamp": datetime.utcnow().isoformat()
+                "timestamp": datetime.now(timezone.utc).isoformat()
             },
             priority=3,
             confidence=ConfidenceLevel.HIGH,
@@ -301,7 +301,7 @@ async def _fetch_current_telemetry(self, scope: str) -> Dict[str, Any]:
         }
 
         # Add timestamp and metadata
-        telemetry["timestamp"] = datetime.utcnow().isoformat()
+        telemetry["timestamp"] = datetime.now(timezone.utc).isoformat()
         telemetry["cell_id"] = scope
         telemetry["region"] = scope.split("_")[0] if "_" in scope else "UNKNOWN"
 
@@ -331,7 +331,7 @@ async def validate_execution(self,
         result = {
             "plan_id": plan_id,
             "validation_status": "in_progress",
-            "validation_time": datetime.utcnow().isoformat(),
+            "validation_time": datetime.now(timezone.utc).isoformat(),
             "executed_by": execution_result.get("executed_by", "unknown"),
             "validated_by": self.agent_id,
             "scope": scope,
@@ -523,7 +523,7 @@ async def process_message(self, message: Dict[str, Any]) -> Dict[str, Any]:
         # Default response for other message types
         return {
             "status": "acknowledged",
-            "timestamp": datetime.utcnow().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "validation_agent": self.agent_id
         }