Fixed the FastAPI issue

app.py

@@ -33,36 +33,56 @@ class MCPClient:
         self.conversation_history = []
     
     def call_mcp_server(self, server_key: str, endpoint: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        """Make a call to an MCP server"""
+        """Make a call to an MCP server (FastAPI-based)"""
         try:
             server_config = self.mcp_servers[server_key]
-            url = f"{server_config['space_url']}/{endpoint}"
             
-            response = requests.post(
-                url,
-                json=payload,
-                headers={"Content-Type": "application/json"},
-                timeout=30
-            )
+            # For FastAPI MCP servers, we need to use different endpoints
+            if endpoint == "tools/list":
+                url = f"{server_config['space_url']}/tools"
+                response = requests.get(url, timeout=30)
+            elif endpoint == "tools/call":
+                url = f"{server_config['space_url']}/tools/call"
+                response = requests.post(
+                    url,
+                    json=payload,
+                    headers={"Content-Type": "application/json"},
+                    timeout=30
+                )
+            else:
+                # Fallback to direct endpoint
+                url = f"{server_config['space_url']}/{endpoint}"
+                response = requests.post(
+                    url,
+                    json=payload,
+                    headers={"Content-Type": "application/json"},
+                    timeout=30
+                )
             
             if response.status_code == 200:
                 return {"success": True, "data": response.json()}
             else:
                 return {
                     "success": False, 
-                    "error": f"HTTP {response.status_code}: {response.text}"
+                    "error": f"HTTP {response.status_code}: {response.text}",
+                    "server": server_config['name']
                 }
                 
         except requests.exceptions.RequestException as e:
-            return {"success": False, "error": f"Request failed: {str(e)}"}
+            return {"success": False, "error": f"Request failed: {str(e)}", "server": server_config['name']}
         except Exception as e:
-            return {"success": False, "error": f"Unexpected error: {str(e)}"}
+            return {"success": False, "error": f"Unexpected error: {str(e)}", "server": server_config['name']}
     
     def get_available_tools(self, server_key: str) -> List[Dict[str, Any]]:
         """Get available tools from an MCP server"""
         result = self.call_mcp_server(server_key, "tools/list", {})
         if result["success"]:
-            return result["data"].get("tools", [])
+            data = result["data"]
+            # Handle different response formats
+            if isinstance(data, dict):
+                return data.get("tools", data.get("result", []))
+            elif isinstance(data, list):
+                return data
         return []
     
     def execute_tool(self, server_key: str, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
@@ -78,10 +98,12 @@ class MCPClient:
         system_prompt = f"""
         You are an intelligent assistant that helps users interact with MCP (Model Context Protocol) servers.
         
-        Available MCP servers:
-        1. Terraform: {self.mcp_servers['terraform']['description']}
-        2. Linux: {self.mcp_servers['linux']['description']}  
-        3. Cisco: {self.mcp_servers['cisco']['description']}
+        Available MCP servers (use these EXACT keys in your response):
+        1. terraform: {self.mcp_servers['terraform']['description']}
+        2. linux: {self.mcp_servers['linux']['description']}  
+        3. cisco: {self.mcp_servers['cisco']['description']}
+        
+        IMPORTANT: For the "recommended_server" field, you MUST use one of these exact keys: "terraform", "linux", or "cisco"
         
         Analyze the user's request and determine:
         1. Which MCP server(s) would be most appropriate
@@ -90,7 +112,7 @@ class MCPClient:
         
         Respond in JSON format with:
         {{
-            "recommended_server": "server_key",
+            "recommended_server": "terraform|linux|cisco",
             "reasoning": "explanation of why this server was chosen",
             "suggested_action": "what action to take",
             "parameters": {{"key": "value"}}
@@ -98,22 +120,45 @@ class MCPClient:
         """
         
         try:
-            response = self.openai_client.chat.completions.create(
-                model="gpt-4",
-                messages=[
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": user_input}
-                ],
-                temperature=0.3
-            )
-            
-            return json.loads(response.choices[0].message.content)
-            
-        except Exception as e:
-            return {
-                "error": f"Failed to analyze request: {str(e)}",
-                "recommended_server": None
-            }
+            try:
+                response = self.openai_client.chat.completions.create(
+                    model="gpt-4",
+                    messages=[
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": user_input}
+                    ],
+                    temperature=0.3
+                )
+                
+                content = response.choices[0].message.content.strip()
+                
+                # Try to parse JSON, handle cases where GPT returns non-JSON
+                try:
+                    return json.loads(content)
+                except json.JSONDecodeError:
+                    # If not valid JSON, extract server recommendation manually
+                    content_lower = content.lower()
+                    if "cisco" in content_lower:
+                        recommended_server = "cisco"
+                    elif "linux" in content_lower:
+                        recommended_server = "linux"
+                    elif "terraform" in content_lower:
+                        recommended_server = "terraform"
+                    else:
+                        recommended_server = "cisco"  # Default for network questions
+                    
+                    return {
+                        "recommended_server": recommended_server,
+                        "reasoning": "Based on content analysis",
+                        "suggested_action": content,
+                        "parameters": {}
+                    }
+                
+            except Exception as e:
+                return {
+                    "error": f"Failed to analyze request: {str(e)}",
+                    "recommended_server": "cisco"  # Default fallback
+                }
     
     def generate_response(self, user_input: str, mcp_results: Dict[str, Any] = None) -> str:
         """Generate a natural language response using OpenAI"""
@@ -163,7 +208,7 @@ class MCPClient:
         self.conversation_history.append({"role": "user", "content": user_input})
         
         try:
-            # Analyze request if no server specified
+            # Analyze request if no server specified or auto-detect selected
             if not selected_server or selected_server == "Auto-detect":
                 analysis = self.analyze_user_request(user_input)
                 if "error" in analysis:
@@ -175,15 +220,38 @@ class MCPClient:
                 reasoning = analysis.get("reasoning", "No reasoning provided")
                 status = f"[{timestamp}] Selected: {self.mcp_servers[selected_server]['name']} - {reasoning}"
             else:
+                # Map display names back to keys if needed
+                server_mapping = {
+                    "MCP Terraform": "terraform",
+                    "MCP Linux": "linux", 
+                    "MCP Cisco": "cisco",
+                    "Terraform": "terraform",
+                    "Linux": "linux",
+                    "Cisco": "cisco"
+                }
+                selected_server = server_mapping.get(selected_server, selected_server.lower())
+                
+                # Validate server key
+                if selected_server not in self.mcp_servers:
+                    response = f"❌ Invalid server selection: {selected_server}. Available: {', '.join(self.mcp_servers.keys())}"
+                    self.conversation_history.append({"role": "assistant", "content": response})
+                    return response, f"[{timestamp}] Invalid server"
+                
                 status = f"[{timestamp}] Using: {self.mcp_servers[selected_server]['name']}"
             
             # Get available tools for the selected server
             tools = self.get_available_tools(selected_server)
             
             if not tools:
-                response = f"⚠️ No tools available from {self.mcp_servers[selected_server]['name']} server"
+                # Try to get more info about the server
+                server_check = self.call_mcp_server(selected_server, "", {})
+                if not server_check["success"]:
+                    response = f"⚠️ Cannot connect to {self.mcp_servers[selected_server]['name']} server: {server_check.get('error', 'Unknown error')}"
+                else:
+                    response = f"⚠️ No tools available from {self.mcp_servers[selected_server]['name']} server (but server is responsive)"
+                
                 self.conversation_history.append({"role": "assistant", "content": response})
-                return response, status + " - No tools available"
+                return response, status + " - Connection/Tools issue"
             
             # For now, just show available tools and generate a helpful response
             # In a full implementation, you'd use OpenAI to select and execute appropriate tools
@@ -255,19 +323,47 @@ def create_gradio_interface():
             history.append([message, error_msg])
             return history, ""
     
-    def get_server_status():
+    def get_server_status(self):
         status_info = "## MCP Servers Status\n\n"
-        for key, config in mcp_client.mcp_servers.items() if mcp_client else []:
+        for key, config in (mcp_client.mcp_servers.items() if mcp_client else []):
             try:
-                # Simple health check
-                response = requests.get(f"{config['space_url']}/health", timeout=5)
-                status = "🟢 Online" if response.status_code == 200 else "🟡 Issues"
+                # Try multiple health check endpoints
+                health_urls = [
+                    f"{config['space_url']}/health",
+                    f"{config['space_url']}/",
+                    f"{config['space_url']}/docs"
+                ]
+                
+                status = "🔴 Offline"
+                for url in health_urls:
+                    try:
+                        response = requests.get(url, timeout=5)
+                        if response.status_code == 200:
+                            status = "🟢 Online"
+                            break
+                        elif response.status_code in [404, 422]:  # Common for FastAPI
+                            status = "🟡 Running (different endpoint structure)"
+                            break
+                    except:
+                        continue
+                        
             except:
                 status = "🔴 Offline"
             
             status_info += f"**{config['name']}**: {status}\n"
             status_info += f"- URL: {config['space_url']}\n"
-            status_info += f"- Description: {config['description']}\n\n"
+            status_info += f"- Description: {config['description']}\n"
+            
+            # Try to get tools info for additional status
+            if mcp_client:
+                try:
+                    tools = mcp_client.get_available_tools(key)
+                    tools_count = len(tools) if tools else 0
+                    status_info += f"- Available Tools: {tools_count}\n"
+                except:
+                    status_info += f"- Available Tools: Unable to fetch\n"
+            
+            status_info += "\n"
         
         return status_info