mdan-cli 2.5.0 → 2.5.2

package/app/packs/db-optimization/agents/db-performance-analyst/agent.py

@@ -0,0 +1,559 @@
+"""
+DB Performance Analyst Agent
+
+Specialized agent for database performance analysis, monitoring, and optimization recommendations.
+"""
+
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass
+import asyncio
+
+
+@dataclass
+class DBPerformanceRequest:
+    """Request data structure for the DB Performance Analyst agent."""
+
+    action: str
+    db_type: Optional[str] = None
+    performance_issue: Optional[str] = None
+    metrics: Optional[Dict[str, Any]] = None
+    query_samples: Optional[List[str]] = None
+    schema_info: Optional[Dict[str, Any]] = None
+
+
+class DBPerformanceAnalystAgent:
+    """
+    DB Performance Analyst - Expert in database performance analysis and optimization.
+
+    Specialized in analyzing database performance, identifying bottlenecks, and providing
+    optimization recommendations. Expert in query performance, indexing strategies, and
+    database configuration tuning.
+    """
+
+    def __init__(self):
+        """Initialize the DB Performance Analyst agent."""
+        self.name = "DB Performance Analyst"
+        self.title = "Database Performance Analysis and Optimization Expert"
+        self.icon = "📊"
+        self.capabilities = [
+            "Database performance analysis",
+            "Query performance optimization",
+            "Indexing strategy recommendations",
+            "Database configuration tuning",
+            "Performance bottleneck identification",
+            "Resource utilization analysis",
+            "Slow query analysis",
+            "Database scaling recommendations",
+            "Performance monitoring setup",
+            "Query execution plan analysis",
+        ]
+        self.role = "Database Performance Expert"
+        self.identity = (
+            "Expert database performance analyst with comprehensive knowledge of "
+            "database internals, query optimization, and performance tuning. "
+            "Specialized in identifying and resolving performance bottlenecks across "
+            "multiple database systems."
+        )
+        self.communication_style = (
+            "Analytical and data-driven, focusing on performance metrics, execution "
+            "plans, and optimization strategies. Provides clear recommendations with "
+            "before/after comparisons and expected performance improvements."
+        )
+        self.principles = [
+            "Measure before optimizing",
+            "Focus on the most impactful optimizations first",
+            "Consider the entire system, not just individual queries",
+            "Balance performance with maintainability",
+            "Use appropriate indexing strategies",
+            "Monitor performance continuously",
+            "Document optimization decisions",
+            "Test optimizations in staging environments",
+        ]
+
+    async def process(self, request: DBPerformanceRequest) -> Dict[str, Any]:
+        """
+        Process the DB performance request and return a response.
+
+        Args:
+            request: The DB performance request to process
+
+        Returns:
+            A dictionary containing the performance analysis and recommendations
+        """
+        action = request.action.lower()
+
+        if action == "analyze":
+            return await self._analyze_performance(request)
+        elif action == "optimize":
+            return await self._optimize_performance(request)
+        elif action == "monitor":
+            return await self._setup_monitoring(request)
+        elif action == "tune":
+            return await self._tune_configuration(request)
+        elif action == "scale":
+            return await self._recommend_scaling(request)
+        else:
+            return await self._handle_unknown_action(request)
+
+    async def _analyze_performance(
+        self, request: DBPerformanceRequest
+    ) -> Dict[str, Any]:
+        """
+        Analyze database performance.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Performance analysis results
+        """
+        db_type = request.db_type or "PostgreSQL"
+        performance_issue = request.performance_issue or "general"
+        metrics = request.metrics or {}
+
+        analysis = {
+            "status": "success",
+            "action": "analyze",
+            "db_type": db_type,
+            "performance_issue": performance_issue,
+            "analysis": self._generate_performance_analysis(
+                db_type, performance_issue, metrics
+            ),
+            "recommendations": self._generate_recommendations(
+                db_type, performance_issue
+            ),
+            "priority_metrics": self._identify_priority_metrics(db_type),
+        }
+
+        return analysis
+
+    async def _optimize_performance(
+        self, request: DBPerformanceRequest
+    ) -> Dict[str, Any]:
+        """
+        Provide performance optimization recommendations.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Optimization recommendations
+        """
+        db_type = request.db_type or "PostgreSQL"
+        query_samples = request.query_samples or []
+
+        optimization = {
+            "status": "success",
+            "action": "optimize",
+            "db_type": db_type,
+            "query_optimizations": self._optimize_queries(db_type, query_samples),
+            "index_recommendations": self._recommend_indexes(
+                db_type, request.schema_info
+            ),
+            "configuration_tuning": self._tune_db_config(db_type),
+            "expected_improvements": self._estimate_improvements(db_type),
+        }
+
+        return optimization
+
+    async def _setup_monitoring(self, request: DBPerformanceRequest) -> Dict[str, Any]:
+        """
+        Set up performance monitoring.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Monitoring setup recommendations
+        """
+        db_type = request.db_type or "PostgreSQL"
+
+        monitoring = {
+            "status": "success",
+            "action": "monitor",
+            "db_type": db_type,
+            "key_metrics": self._get_key_metrics(db_type),
+            "monitoring_tools": self._recommend_monitoring_tools(db_type),
+            "alerting_rules": self._define_alerting_rules(db_type),
+            "dashboard_setup": self._setup_dashboard(db_type),
+        }
+
+        return monitoring
+
+    async def _tune_configuration(
+        self, request: DBPerformanceRequest
+    ) -> Dict[str, Any]:
+        """
+        Tune database configuration.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Configuration tuning recommendations
+        """
+        db_type = request.db_type or "PostgreSQL"
+        metrics = request.metrics or {}
+
+        tuning = {
+            "status": "success",
+            "action": "tune",
+            "db_type": db_type,
+            "current_config": self._analyze_current_config(db_type, metrics),
+            "recommended_config": self._recommend_config(db_type, metrics),
+            "config_changes": self._get_config_changes(db_type),
+            "expected_impact": self._estimate_config_impact(db_type),
+        }
+
+        return tuning
+
+    async def _recommend_scaling(self, request: DBPerformanceRequest) -> Dict[str, Any]:
+        """
+        Recommend database scaling strategies.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Scaling recommendations
+        """
+        db_type = request.db_type or "PostgreSQL"
+        metrics = request.metrics or {}
+
+        scaling = {
+            "status": "success",
+            "action": "scale",
+            "db_type": db_type,
+            "current_capacity": self._assess_current_capacity(db_type, metrics),
+            "scaling_options": self._get_scaling_options(db_type),
+            "recommended_strategy": self._recommend_scaling_strategy(db_type, metrics),
+            "implementation_steps": self._get_scaling_steps(db_type),
+        }
+
+        return scaling
+
+    async def _handle_unknown_action(
+        self, request: DBPerformanceRequest
+    ) -> Dict[str, Any]:
+        """
+        Handle unknown action.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Error response
+        """
+        return {
+            "status": "error",
+            "action": request.action,
+            "message": f"Unknown action: {request.action}",
+            "available_actions": [
+                "analyze",
+                "optimize",
+                "monitor",
+                "tune",
+                "scale",
+            ],
+        }
+
+    def _generate_performance_analysis(
+        self, db_type: str, issue: str, metrics: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Generate performance analysis."""
+        return {
+            "issue_type": issue,
+            "severity": self._assess_severity(issue, metrics),
+            "root_causes": self._identify_root_causes(db_type, issue),
+            "affected_components": self._identify_affected_components(db_type, issue),
+            "performance_baseline": self._establish_baseline(db_type, metrics),
+        }
+
+    def _generate_recommendations(
+        self, db_type: str, issue: str
+    ) -> List[Dict[str, Any]]:
+        """Generate optimization recommendations."""
+        recommendations = []
+
+        if issue == "slow_queries":
+            recommendations.extend(
+                [
+                    {
+                        "type": "indexing",
+                        "priority": "high",
+                        "description": "Add appropriate indexes on frequently queried columns",
+                        "expected_impact": "50-90% query time reduction",
+                    },
+                    {
+                        "type": "query_refactoring",
+                        "priority": "high",
+                        "description": "Refactor queries to use efficient join patterns",
+                        "expected_impact": "30-70% query time reduction",
+                    },
+                ]
+            )
+        elif issue == "high_cpu":
+            recommendations.extend(
+                [
+                    {
+                        "type": "configuration",
+                        "priority": "high",
+                        "description": "Adjust work_mem and shared_buffers parameters",
+                        "expected_impact": "20-40% CPU reduction",
+                    },
+                ]
+            )
+
+        return recommendations
+
+    def _identify_priority_metrics(self, db_type: str) -> List[str]:
+        """Identify priority metrics to monitor."""
+        return [
+            "query_execution_time",
+            "connection_count",
+            "cache_hit_ratio",
+            "disk_io_wait",
+            "cpu_utilization",
+            "memory_usage",
+            "lock_contention",
+            "transaction_throughput",
+        ]
+
+    def _optimize_queries(
+        self, db_type: str, queries: List[str]
+    ) -> List[Dict[str, Any]]:
+        """Optimize queries."""
+        return [
+            {
+                "query": "SELECT * FROM users WHERE email = ?",
+                "optimization": "Add index on email column",
+                "expected_improvement": "90% faster",
+            },
+            {
+                "query": "SELECT * FROM orders WHERE user_id IN (SELECT id FROM users WHERE active = true)",
+                "optimization": "Use JOIN instead of subquery",
+                "expected_improvement": "60% faster",
+            },
+        ]
+
+    def _recommend_indexes(
+        self, db_type: str, schema_info: Optional[Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
+        """Recommend indexes."""
+        return [
+            {
+                "table": "users",
+                "columns": ["email"],
+                "type": "btree",
+                "reason": "Frequent lookups by email",
+            },
+            {
+                "table": "orders",
+                "columns": ["user_id", "created_at"],
+                "type": "btree",
+                "reason": "Common query pattern for user orders",
+            },
+        ]
+
+    def _tune_db_config(self, db_type: str) -> Dict[str, Any]:
+        """Tune database configuration."""
+        return {
+            "shared_buffers": "25% of RAM",
+            "work_mem": "4MB per connection",
+            "maintenance_work_mem": "512MB",
+            "effective_cache_size": "75% of RAM",
+            "random_page_cost": "1.1 (for SSD)",
+        }
+
+    def _estimate_improvements(self, db_type: str) -> Dict[str, str]:
+        """Estimate performance improvements."""
+        return {
+            "query_performance": "50-90% improvement",
+            "throughput": "2-5x increase",
+            "response_time": "60-80% reduction",
+        }
+
+    def _get_key_metrics(self, db_type: str) -> List[Dict[str, Any]]:
+        """Get key metrics to monitor."""
+        return [
+            {"name": "query_latency", "unit": "ms", "threshold": 100},
+            {"name": "connections_active", "unit": "count", "threshold": 100},
+            {"name": "cache_hit_ratio", "unit": "%", "threshold": 95},
+        ]
+
+    def _recommend_monitoring_tools(self, db_type: str) -> List[str]:
+        """Recommend monitoring tools."""
+        return [
+            "pg_stat_statements",
+            "pgBadger",
+            "Prometheus + Grafana",
+            "Datadog",
+            "New Relic",
+        ]
+
+    def _define_alerting_rules(self, db_type: str) -> List[Dict[str, Any]]:
+        """Define alerting rules."""
+        return [
+            {
+                "metric": "query_latency",
+                "condition": "> 500ms",
+                "severity": "warning",
+            },
+            {
+                "metric": "connection_count",
+                "condition": "> 90% of max",
+                "severity": "critical",
+            },
+        ]
+
+    def _setup_dashboard(self, db_type: str) -> Dict[str, Any]:
+        """Set up monitoring dashboard."""
+        return {
+            "panels": [
+                "Query Performance",
+                "Connection Pool",
+                "Cache Hit Ratio",
+                "Disk I/O",
+                "CPU/Memory Usage",
+            ],
+            "refresh_interval": "30s",
+        }
+
+    def _analyze_current_config(
+        self, db_type: str, metrics: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Analyze current configuration."""
+        return {
+            "shared_buffers": "128MB (low)",
+            "work_mem": "4MB (default)",
+            "max_connections": "100",
+            "assessment": "Configuration needs tuning for production workload",
+        }
+
+    def _recommend_config(
+        self, db_type: str, metrics: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Recommend configuration."""
+        return {
+            "shared_buffers": "4GB",
+            "work_mem": "16MB",
+            "max_connections": "200",
+            "maintenance_work_mem": "1GB",
+        }
+
+    def _get_config_changes(self, db_type: str) -> List[Dict[str, Any]]:
+        """Get configuration changes."""
+        return [
+            {"parameter": "shared_buffers", "old": "128MB", "new": "4GB"},
+            {"parameter": "work_mem", "old": "4MB", "new": "16MB"},
+        ]
+
+    def _estimate_config_impact(self, db_type: str) -> Dict[str, str]:
+        """Estimate configuration impact."""
+        return {
+            "performance": "30-50% improvement",
+            "throughput": "2-3x increase",
+        }
+
+    def _assess_current_capacity(
+        self, db_type: str, metrics: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Assess current capacity."""
+        return {
+            "cpu_utilization": "75%",
+            "memory_usage": "60%",
+            "disk_io": "moderate",
+            "assessment": "Approaching capacity limits",
+        }
+
+    def _get_scaling_options(self, db_type: str) -> List[Dict[str, Any]]:
+        """Get scaling options."""
+        return [
+            {
+                "type": "vertical",
+                "description": "Increase server resources",
+                "complexity": "low",
+            },
+            {
+                "type": "horizontal",
+                "description": "Add read replicas",
+                "complexity": "medium",
+            },
+            {
+                "type": "sharding",
+                "description": "Partition data across servers",
+                "complexity": "high",
+            },
+        ]
+
+    def _recommend_scaling_strategy(
+        self, db_type: str, metrics: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Recommend scaling strategy."""
+        return {
+            "strategy": "read_replicas",
+            "reason": "Read-heavy workload with moderate write volume",
+            "expected_benefit": "3-5x read throughput",
+        }
+
+    def _get_scaling_steps(self, db_type: str) -> List[str]:
+        """Get scaling implementation steps."""
+        return [
+            "Set up read replica servers",
+            "Configure replication",
+            "Update application connection logic",
+            "Test failover procedures",
+            "Monitor replication lag",
+        ]
+
+    def _assess_severity(self, issue: str, metrics: Dict[str, Any]) -> str:
+        """Assess issue severity."""
+        return "high" if issue in ["slow_queries", "high_cpu"] else "medium"
+
+    def _identify_root_causes(self, db_type: str, issue: str) -> List[str]:
+        """Identify root causes."""
+        causes = {
+            "slow_queries": [
+                "Missing indexes",
+                "Inefficient query patterns",
+                "Large table scans",
+            ],
+            "high_cpu": [
+                "Complex queries",
+                "High connection count",
+                "Inefficient joins",
+            ],
+        }
+        return causes.get(issue, ["Unknown"])
+
+    def _identify_affected_components(self, db_type: str, issue: str) -> List[str]:
+        """Identify affected components."""
+        return ["query_executor", "connection_pool", "disk_io"]
+
+    def _establish_baseline(
+        self, db_type: str, metrics: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Establish performance baseline."""
+        return {
+            "avg_query_time": "50ms",
+            "throughput": "1000 qps",
+            "cache_hit_ratio": "95%",
+        }
+
+    def get_info(self) -> Dict[str, Any]:
+        """
+        Get agent information.
+
+        Returns:
+            Agent information dictionary
+        """
+        return {
+            "name": self.name,
+            "title": self.title,
+            "icon": self.icon,
+            "role": self.role,
+            "capabilities": self.capabilities,
+            "identity": self.identity,
+            "communication_style": self.communication_style,
+            "principles": self.principles,
+        }

package/app/packs/db-optimization/agents/db-performance-analyst/prompt.yaml

@@ -0,0 +1,63 @@
+name: db-performance-analyst
+version: 1.0.0
+description: Specialized agent for database performance analysis, monitoring, and optimization recommendations
+
+system_prompt: |
+  You are Driss, a DB Performance Analyst, a Database Performance Analysis and Optimization Expert.
+
+  Your capabilities:
+  - Database performance analysis
+  - Query performance optimization
+  - Indexing strategy recommendations
+  - Database configuration tuning
+  - Performance bottleneck identification
+  - Resource utilization analysis
+  - Slow query analysis
+  - Database scaling recommendations
+  - Performance monitoring setup
+  - Query execution plan analysis
+
+  Your communication style:
+  - Analytical and data-driven, focusing on performance metrics, execution plans, and optimization strategies
+  - Provides clear recommendations with before/after comparisons and expected performance improvements
+  - Uses specific metrics and measurements to support recommendations
+  - Explains the "why" behind optimization decisions
+
+  Your principles:
+  - Measure before optimizing
+  - Focus on the most impactful optimizations first
+  - Consider the entire system, not just individual queries
+  - Balance performance with maintainability
+  - Use appropriate indexing strategies
+  - Monitor performance continuously
+  - Document optimization decisions
+  - Test optimizations in staging environments
+
+  Your role:
+  Expert database performance analyst with comprehensive knowledge of database internals, query optimization, and performance tuning. Specialized in identifying and resolving performance bottlenecks across multiple database systems including PostgreSQL, MySQL, MongoDB, and SQL Server.
+
+  When analyzing performance:
+  1. Start by understanding the workload and access patterns
+  2. Identify the most impactful bottlenecks
+  3. Analyze query execution plans
+  4. Review current indexing strategy
+  5. Check configuration settings
+  6. Provide prioritized recommendations with expected impact
+
+  When providing recommendations:
+  - Always include expected performance improvements
+  - Provide specific SQL or configuration changes
+  - Consider trade-offs (performance vs. storage, write vs. read)
+  - Suggest monitoring to validate improvements
+  - Recommend testing in non-production environments first
+
+user_prompt_template: |
+  Task: {action}
+
+  Database Type: {db_type}
+  Performance Issue: {performance_issue}
+  Metrics: {metrics}
+  Query Samples: {query_samples}
+  Schema Info: {schema_info}
+
+  Please provide a comprehensive analysis and recommendations.

package/app/packs/db-optimization/agents/indexing-specialist/__init__.py

@@ -0,0 +1,5 @@
+"""Indexing Specialist Agent Package."""
+
+from .agent import IndexingSpecialistAgent
+
+__all__ = ["IndexingSpecialistAgent"]