Create assistant/ai_assistant.py

assistant/ai_assistant.py

@@ -0,0 +1,150 @@
+"""
+AI Assistant for Gradio MCP system.
+Handles intelligent responses for both sensitive operations and safe commands.
+"""
+
+import openai
+import json
+from typing import Dict, Any, List
+from shared.config import config
+import logging
+
+logger = logging.getLogger(__name__)
+
+class GradioAIAssistant:
+    """AI Assistant optimized for Gradio MCP integration"""
+    
+    def __init__(self):
+        self.client = openai.OpenAI(api_key=config.openai.api_key)
+    
+    def process_tool_result(self, user_message: str, tool_result: Dict[str, Any]) -> str:
+        """
+        Process tool execution result and generate intelligent response.
+        This is called by Gradio after tool execution.
+        """
+        tool_type = tool_result.get("tool_type", "unknown")
+        
+        if tool_type == "sensitive_operation":
+            return self._handle_sensitive_result(user_message, tool_result)
+        elif tool_type == "safe_command":
+            return self._handle_safe_result(user_message, tool_result)
+        else:
+            return self._handle_unknown_result(user_message, tool_result)
+    
+    def _handle_sensitive_result(self, user_message: str, result: Dict[str, Any]) -> str:
+        """Handle results from sensitive operations with educational approach"""
+        
+        prompt = f"""You are an expert Linux system administrator and teacher.
+
+A user requested: "{user_message}"
+
+This triggered a SENSITIVE system operation with the following result:
+{json.dumps(result, indent=2)}
+
+Respond with a Socratic, educational approach:
+
+If SUCCESSFUL:
+- Explain what was accomplished and why it matters
+- Discuss the security implications
+- Suggest best practices or next steps
+- Ask if they understand the implications
+
+If FAILED:
+- Help them understand why it failed
+- Guide them through what needs to be corrected
+- Ask clarifying questions to gather missing information
+- Provide learning opportunities
+
+If MISSING INFORMATION:
+- Ask specific questions to gather needed details
+- Explain why each parameter is important
+- Provide examples of good values
+- Guide them step by step
+
+Be conversational, helpful, and educational. This is a teaching moment."""
+
+        return self._call_openai(prompt)
+    
+    def _handle_safe_result(self, user_message: str, result: Dict[str, Any]) -> str:
+        """Handle results from safe operations with clear explanations"""
+        
+        prompt = f"""You are a helpful Linux system administrator.
+
+A user requested: "{user_message}"
+
+This executed a SAFE system command with the following result:
+{json.dumps(result, indent=2)}
+
+Provide a clear, informative response:
+
+If SUCCESSFUL:
+- Explain the output in an easy-to-understand way
+- Highlight important information
+- Suggest related commands that might be useful
+- Keep it concise but helpful
+
+If FAILED:
+- Explain what went wrong
+- Suggest how to fix it
+- Provide alternative approaches
+
+Format the response to be helpful and professional. Focus on making the technical information accessible."""
+
+        return self._call_openai(prompt)
+    
+    def _handle_unknown_result(self, user_message: str, result: Dict[str, Any]) -> str:
+        """Handle unknown or error results"""
+        
+        return f"""I encountered an issue processing your request: "{user_message}"
+
+Result: {json.dumps(result, indent=2)}
+
+This might be due to:
+- An unrecognized command or operation
+- A system error
+- Missing configuration
+
+Could you please rephrase your request or try a different approach? I'm here to help with Linux system administration tasks."""
+    
+    def generate_help_response(self) -> str:
+        """Generate a helpful introduction to the system"""
+        
+        prompt = """You are a Linux system administration assistant with AI capabilities.
+
+Generate a helpful introduction that explains:
+- What kinds of tasks you can help with
+- Examples of safe operations (file listing, system info, etc.)
+- Examples of sensitive operations that require careful consideration
+- How you use a Socratic approach for sensitive tasks
+- Encourage users to ask questions and learn
+
+Keep it friendly, professional, and encouraging. Make users feel confident about learning Linux administration."""
+
+        return self._call_openai(prompt)
+    
+    def _call_openai(self, prompt: str) -> str:
+        """Make OpenAI API call with error handling"""
+        try:
+            response = self.client.chat.completions.create(
+                model=config.openai.model,
+                messages=[
+                    {
+                        "role": "system", 
+                        "content": "You are an expert Linux system administrator and educator. Provide helpful, accurate, and educational responses."
+                    },
+                    {
+                        "role": "user", 
+                        "content": prompt
+                    }
+                ],
+                temperature=config.openai.temperature,
+                max_tokens=config.openai.max_tokens
+            )
+            return response.choices[0].message.content
+        
+        except Exception as e:
+            logger.error(f"OpenAI API error: {e}")
+            return f"I apologize, but I encountered an error generating a response. The operation completed with the following result: {json.dumps(result if 'result' in locals() else {}, indent=2)}"
+
+# Global assistant instance
+assistant = GradioAIAssistant()