Update app.py

app.py

@@ -7,32 +7,20 @@ import aiohttp
 from typing import Dict, Any, List, Tuple
 from datetime import datetime
 import os
+import threading
+import concurrent.futures
 
 class MCPClient:
     """MCP Client for communicating with the MCP server"""
     
     def __init__(self, server_url: str):
         self.server_url = server_url.rstrip('/')
-        self.session = None
     
-    async def initialize_session(self):
-        """Initialize aiohttp session"""
-        if not self.session:
-            self.session = aiohttp.ClientSession()
-    
-    async def close_session(self):
-        """Close aiohttp session"""
-        if self.session:
-            await self.session.close()
-            self.session = None
-    
-    async def call_tool(self, tool_name: str, arguments: Dict[str, Any] = None) -> Dict[str, Any]:
-        """Call a tool on the MCP server"""
+    def call_tool_sync(self, tool_name: str, arguments: Dict[str, Any] = None) -> Dict[str, Any]:
+        """Synchronous tool call using requests instead of aiohttp"""
         if arguments is None:
             arguments = {}
         
-        await self.initialize_session()
-        
         mcp_request = {
             "jsonrpc": "2.0",
             "id": 1,
@@ -44,7 +32,7 @@ class MCPClient:
         }
         
         try:
-            async with self.session.post(
+            response = requests.post(
                 f"{self.server_url}/mcp",
                 json=mcp_request,
                 headers={
@@ -52,28 +40,27 @@ class MCPClient:
                     "ngrok-skip-browser-warning": "true"
                 },
                 timeout=30
-            ) as response:
-                if response.status == 200:
-                    result = await response.json()
-                    if "result" in result and "content" in result["result"]:
-                        content = result["result"]["content"][0]["text"]
-                        return json.loads(content)
-                    return result
-                else:
-                    return {
-                        "success": False,
-                        "error": f"HTTP {response.status}: {await response.text()}"
-                    }
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                if "result" in result and "content" in result["result"]:
+                    content = result["result"]["content"][0]["text"]
+                    return json.loads(content)
+                return result
+            else:
+                return {
+                    "success": False,
+                    "error": f"HTTP {response.status_code}: {response.text}"
+                }
         except Exception as e:
             return {
                 "success": False,
                 "error": f"Connection error: {str(e)}"
             }
     
-    async def list_tools(self) -> List[Dict[str, Any]]:
-        """List available tools on the MCP server"""
-        await self.initialize_session()
-        
+    def list_tools_sync(self) -> List[Dict[str, Any]]:
+        """Synchronous tool listing using requests"""
         mcp_request = {
             "jsonrpc": "2.0",
             "id": 1,
@@ -81,7 +68,7 @@ class MCPClient:
         }
         
         try:
-            async with self.session.post(
+            response = requests.post(
                 f"{self.server_url}/mcp",
                 json=mcp_request,
                 headers={
@@ -89,13 +76,14 @@ class MCPClient:
                     "ngrok-skip-browser-warning": "true"
                 },
                 timeout=30
-            ) as response:
-                if response.status == 200:
-                    result = await response.json()
-                    return result.get("result", {}).get("tools", [])
-                return []
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                return result.get("result", {}).get("tools", [])
+            return []
         except Exception as e:
-            print(f"Error listing tools: {str(e)}")  # For debugging
+            print(f"Error listing tools: {str(e)}")
             return []
 
 class AIAssistant:
@@ -114,9 +102,9 @@ class AIAssistant:
         self.mcp_client = mcp_client
         self.available_tools = []
     
-    async def initialize(self):
+    def initialize(self):
         """Initialize the assistant by fetching available tools"""
-        self.available_tools = await self.mcp_client.list_tools()
+        self.available_tools = self.mcp_client.list_tools_sync()
     
     def get_system_prompt(self) -> str:
         """Generate system prompt with available tools"""
@@ -335,7 +323,7 @@ def test_connection(mcp_url):
     except Exception as e:
         return f"❌ Connection error: {str(e)}"
 
-async def initialize_assistant(openai_key, mcp_url):
+def initialize_assistant(openai_key, mcp_url):
     """Initialize the AI assistant"""
     global assistant, mcp_client
     
@@ -348,7 +336,7 @@ async def initialize_assistant(openai_key, mcp_url):
     try:
         mcp_client = MCPClient(mcp_url)
         assistant = AIAssistant(openai_key, mcp_client)
-        await assistant.initialize()
+        assistant.initialize()
         return f"✅ AI Assistant initialized with {len(assistant.available_tools)} tools available"
     except Exception as e:
         return f"❌ Failed to initialize: {str(e)}"
@@ -358,13 +346,13 @@ def chat_interface(message, history, openai_key, mcp_url):
     global assistant
     
     if not assistant:
-        init_result = asyncio.run(initialize_assistant(openai_key, mcp_url))
+        init_result = initialize_assistant(openai_key, mcp_url)
         if "❌" in init_result:
             history.append([message, init_result])
             return history, ""
     
     try:
-        response, tool_info = asyncio.run(assistant.process_message(message))
+        response, tool_info = assistant.process_message(message)
         
         # Format response with tool info if available
         if tool_info: