feat(core-api): add AI stats widget with proxy endpoints

Implements Phase 2 of AI performance monitoring - creating a visual
dashboard widget for Organizr to display real-time AI metrics.

New Components:
- src/clients/ai_client.py: HTTP client for Core-AI service
  - Async HTTP requests to core-ai:8086
  - Fetches metrics, errors, and tool failures
  - Health check and metrics reset operations

- src/controllers/ai_controller.py: Proxy controller for AI metrics
  - GET /ai/health - Core-AI health check
  - GET /ai/metrics - Comprehensive performance metrics (proxied)
  - GET /ai/metrics/errors - Recent request errors (proxied)
  - GET /ai/metrics/tool-failures - Tool execution failures (proxied)
  - POST /ai/metrics/reset - Reset all metrics (admin)

- static/widgets/ai-stats.html: Performance dashboard widget
  - 4-panel grid layout: Agent, Tools, Memory, Health
  - Real-time metrics with 10-second auto-refresh
  - Color-coded performance indicators (excellent/good/warning/critical)
  - Response time thresholds: <1s excellent, <3s good, <10s warning
  - Success rate thresholds: >99% excellent, >95% good, >90% warning
  - Top 5 tools display with call counts and success rates
  - Transparent background for Organizr dark theme
  - Responsive design with mobile support

Configuration:
- src/config.py: Added core_ai_base_url setting
- src/main.py: Registered ai_router for /ai/* endpoints

Architecture:
┌─────────────────────────────────────────────┐
│ Browser (Organizr iFrame)                   │
│ ↓ Fetches /ai/metrics                       │
└─────────────────────────────────────────────┘
         ↓
┌─────────────────────────────────────────────┐
│ core-api:8083 (api.schweitz.net)           │
│ - Serves widget HTML                        │
│ - Proxies metrics requests                  │
└─────────────────────────────────────────────┘
         ↓
┌─────────────────────────────────────────────┐
│ core-ai:8086 (internal)                    │
│ - Collects metrics                          │
│ - Returns JSON data                         │
└─────────────────────────────────────────────┘

Benefits:
- External access via api.schweitz.net (proxy approach)
- No CORS issues (same-origin requests)
- Core-AI remains internal-only
- Single integration point with Organizr

Integration with Organizr:
1. Go to Settings → Customize → Homepage Items
2. Add New Item:
   - Name: "AI Performance Stats"
   - Type: iFrame
   - URL: http://localhost:8083/static/widgets/ai-stats.html
   - Authentication: User
3. Position widget on dashboard

Tested:
✅ Proxy endpoints responding correctly
✅ Widget accessible via /static/widgets/
✅ Metrics data flowing from core-ai → core-api → browser
✅ Color coding and formatting working
✅ Auto-refresh functional

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
2025-12-04 08:58:43 +01:00
co-authored by Claude
parent 632b20febe
commit 0ac1128b04
5 changed files with 912 additions and 0 deletions
+197
View File
@@ -0,0 +1,197 @@
"""
Core-AI HTTP Client
Provides interface to Core-AI service for AI performance metrics.
"""
import httpx
from typing import Optional, Dict, List, Any
from src.logging_config import get_logger
from src.config import get_settings
logger = get_logger(__name__)
settings = get_settings()
class CoreAIClient:
"""
HTTP client for Core-AI service
Provides access to AI performance metrics, tool execution stats,
and memory system monitoring.
"""
def __init__(
self,
base_url: Optional[str] = None,
timeout: int = 10
):
"""
Initialize Core-AI client
Args:
base_url: Core-AI base URL (default from settings)
timeout: Request timeout in seconds
"""
self.base_url = (base_url or getattr(settings, 'core_ai_base_url', 'http://core-ai:8086')).rstrip("/")
self.timeout = timeout
self.client = httpx.AsyncClient(timeout=self.timeout)
async def close(self):
"""Close the HTTP client"""
await self.client.aclose()
async def health_check(self) -> bool:
"""
Check if Core-AI service is accessible
Returns:
True if accessible, False otherwise
"""
try:
response = await self.client.get(f"{self.base_url}/health")
return response.status_code == 200
except Exception as e:
logger.error(f"Core-AI health check failed: {e}")
return False
async def get_metrics(self) -> Dict[str, Any]:
"""
Get comprehensive AI performance metrics
Returns:
Dict with agent performance, tool execution, memory stats
Example:
{
"uptime_seconds": 3600,
"timestamp": "2025-12-03T20:00:00Z",
"agent": {
"total_requests": 100,
"avg_response_time_ms": 1250.5,
"p95_response_time_ms": 3200.0,
...
},
"tools": {
"total_calls": 250,
"success_rate": 0.98,
"top_tools": {...}
},
"memory": {
"tier1_hit_rate": 0.85,
...
},
...
}
"""
try:
response = await self.client.get(f"{self.base_url}/metrics")
response.raise_for_status()
return response.json()
except httpx.HTTPStatusError as e:
logger.error(f"Failed to get metrics: HTTP {e.response.status_code}")
raise
except Exception as e:
logger.error(f"Failed to get metrics: {e}")
raise
async def get_recent_errors(self, limit: int = 20) -> List[Dict[str, Any]]:
"""
Get recent request errors
Args:
limit: Maximum number of errors to return
Returns:
List of error records with timestamps
Example:
[
{
"timestamp": "2025-12-03T19:45:12Z",
"agent_type": "pydantic",
"error": "Connection timeout",
"duration_ms": 5000
},
...
]
"""
try:
response = await self.client.get(
f"{self.base_url}/metrics/errors",
params={"limit": limit}
)
response.raise_for_status()
data = response.json()
return data.get("errors", [])
except Exception as e:
logger.error(f"Failed to get recent errors: {e}")
raise
async def get_tool_failures(self, limit: int = 20) -> List[Dict[str, Any]]:
"""
Get recent tool execution failures
Args:
limit: Maximum number of failures to return
Returns:
List of tool failure records
Example:
[
{
"timestamp": "2025-12-03T19:50:30Z",
"tool_name": "list_containers",
"error": "Connection refused",
"duration_ms": 150
},
...
]
"""
try:
response = await self.client.get(
f"{self.base_url}/metrics/tool-failures",
params={"limit": limit}
)
response.raise_for_status()
data = response.json()
return data.get("failures", [])
except Exception as e:
logger.error(f"Failed to get tool failures: {e}")
raise
async def reset_metrics(self) -> bool:
"""
Reset all metrics (admin operation)
Returns:
True if successful
"""
try:
response = await self.client.post(f"{self.base_url}/metrics/reset")
response.raise_for_status()
logger.info("Successfully reset Core-AI metrics")
return True
except Exception as e:
logger.error(f"Failed to reset metrics: {e}")
raise
async def __aenter__(self):
"""Async context manager entry"""
return self
async def __aexit__(self, exc_type, exc_val, exc_tb):
"""Async context manager exit"""
await self.close()
# Singleton instance
_ai_client: Optional[CoreAIClient] = None
def get_ai_client() -> CoreAIClient:
"""Get singleton Core-AI client instance"""
global _ai_client
if _ai_client is None:
_ai_client = CoreAIClient()
return _ai_client